diff --git a/.checkstyle b/.checkstyle
new file mode 100644
index 0000000000000000000000000000000000000000..5783bc0d77a132dce01d27916abf9a192dd4ee08
--- /dev/null
+++ b/.checkstyle
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<fileset-config file-format-version="1.2.0" simple-config="true" sync-formatter="false">
+ <fileset name="all" enabled="true" check-config-name="Google Checks" local="false">
+ <file-match-pattern match-pattern="." include-pattern="true"/>
+ </fileset>
+</fileset-config>
diff --git a/.classpath b/.classpath
new file mode 100644
index 0000000000000000000000000000000000000000..51a8bbad89682d379e0aadb7bd54d22de601a62f
--- /dev/null
+++ b/.classpath
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+ <classpathentry kind="src" path="src"/>
+ <classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/.project b/.project
new file mode 100644
index 0000000000000000000000000000000000000000..f55b3830f59e7de959f4fe57002e63909155383c
--- /dev/null
+++ b/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>swingDemo</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ </natures>
+</projectDescription>
diff --git a/.settings/org.eclipse.jdt.core.prefs b/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000000000000000000000000000000000000..3a21537071bf4118b9e1ee864cb4bc258aa48211
--- /dev/null
+++ b/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,11 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/bin/excepciones/UsuarioNoExisteException.class b/bin/excepciones/UsuarioNoExisteException.class
new file mode 100644
index 0000000000000000000000000000000000000000..b21d317568f7adf393fdb93e0bf3de19f6d1f7e2
Binary files /dev/null and b/bin/excepciones/UsuarioNoExisteException.class differ
diff --git a/bin/excepciones/UsuarioRepetidoException.class b/bin/excepciones/UsuarioRepetidoException.class
new file mode 100644
index 0000000000000000000000000000000000000000..09e8ff121cf8c1867af82e29cdd9689f2766b109
Binary files /dev/null and b/bin/excepciones/UsuarioRepetidoException.class differ
diff --git a/bin/logica/ControladorUsuario.class b/bin/logica/ControladorUsuario.class
new file mode 100644
index 0000000000000000000000000000000000000000..9d931845fe46779b820c3fc4f5b6fe3cb37843f2
Binary files /dev/null and b/bin/logica/ControladorUsuario.class differ
diff --git a/bin/logica/DataUsuario.class b/bin/logica/DataUsuario.class
new file mode 100644
index 0000000000000000000000000000000000000000..1edee88d04843638a66c4f4c1158453fcdd70fd6
Binary files /dev/null and b/bin/logica/DataUsuario.class differ
diff --git a/bin/logica/Fabrica.class b/bin/logica/Fabrica.class
new file mode 100644
index 0000000000000000000000000000000000000000..f03ef7c2660ad481b52af7a1353b5bc9da44fa10
Binary files /dev/null and b/bin/logica/Fabrica.class differ
diff --git a/bin/logica/IControladorUsuario.class b/bin/logica/IControladorUsuario.class
new file mode 100644
index 0000000000000000000000000000000000000000..94beba85207a459a09d9ca7376ed209fe992a705
Binary files /dev/null and b/bin/logica/IControladorUsuario.class differ
diff --git a/bin/logica/ManejadorUsuario.class b/bin/logica/ManejadorUsuario.class
new file mode 100644
index 0000000000000000000000000000000000000000..8b04b215f1604fdb03fcb253d3f726041db99aad
Binary files /dev/null and b/bin/logica/ManejadorUsuario.class differ
diff --git a/bin/logica/Usuario.class b/bin/logica/Usuario.class
new file mode 100644
index 0000000000000000000000000000000000000000..e7dfde5820d507fdb11dc58b40f65bed84358462
Binary files /dev/null and b/bin/logica/Usuario.class differ
diff --git a/bin/presentacion/ConsultarUsuario$1.class b/bin/presentacion/ConsultarUsuario$1.class
new file mode 100644
index 0000000000000000000000000000000000000000..a8bf4c65affe58021b24949afc0893178fdd1509
Binary files /dev/null and b/bin/presentacion/ConsultarUsuario$1.class differ
diff --git a/bin/presentacion/ConsultarUsuario$2.class b/bin/presentacion/ConsultarUsuario$2.class
new file mode 100644
index 0000000000000000000000000000000000000000..11ba1413a56c58f8a735c0cfda33398c048d5e01
Binary files /dev/null and b/bin/presentacion/ConsultarUsuario$2.class differ
diff --git a/bin/presentacion/ConsultarUsuario.class b/bin/presentacion/ConsultarUsuario.class
new file mode 100644
index 0000000000000000000000000000000000000000..0dcd6b8d04c9f30c4384a23815468d002a832cef
Binary files /dev/null and b/bin/presentacion/ConsultarUsuario.class differ
diff --git a/bin/presentacion/CrearUsuario$1.class b/bin/presentacion/CrearUsuario$1.class
new file mode 100644
index 0000000000000000000000000000000000000000..15d031c3bf34e1d7e9d3336fa672cfd5f4e92881
Binary files /dev/null and b/bin/presentacion/CrearUsuario$1.class differ
diff --git a/bin/presentacion/CrearUsuario$2.class b/bin/presentacion/CrearUsuario$2.class
new file mode 100644
index 0000000000000000000000000000000000000000..931245bffcb7eb94804fe84f880e1e157e51b32c
Binary files /dev/null and b/bin/presentacion/CrearUsuario$2.class differ
diff --git a/bin/presentacion/CrearUsuario.class b/bin/presentacion/CrearUsuario.class
new file mode 100644
index 0000000000000000000000000000000000000000..9c3f527dcf813ebbc99e707c74aa7d9caff31ce3
Binary files /dev/null and b/bin/presentacion/CrearUsuario.class differ
diff --git a/bin/presentacion/ListaUsuarios$1.class b/bin/presentacion/ListaUsuarios$1.class
new file mode 100644
index 0000000000000000000000000000000000000000..15292aecc6b54a6016a2ce6e90a25a45d9de91df
Binary files /dev/null and b/bin/presentacion/ListaUsuarios$1.class differ
diff --git a/bin/presentacion/ListaUsuarios.class b/bin/presentacion/ListaUsuarios.class
new file mode 100644
index 0000000000000000000000000000000000000000..a3e10ea38806cccd708171621adcfb2d1a0caa50
Binary files /dev/null and b/bin/presentacion/ListaUsuarios.class differ
diff --git a/bin/presentacion/Principal$1.class b/bin/presentacion/Principal$1.class
new file mode 100644
index 0000000000000000000000000000000000000000..edd5656548b2b44e6d9455c31bbcc48e386ce665
Binary files /dev/null and b/bin/presentacion/Principal$1.class differ
diff --git a/bin/presentacion/Principal$2.class b/bin/presentacion/Principal$2.class
new file mode 100644
index 0000000000000000000000000000000000000000..bdf396d5e05f2d3e0c285d181b78b3a03c6d8abb
Binary files /dev/null and b/bin/presentacion/Principal$2.class differ
diff --git a/bin/presentacion/Principal$3.class b/bin/presentacion/Principal$3.class
new file mode 100644
index 0000000000000000000000000000000000000000..80299e95a153815e6bd6338517503d5f5d752624
Binary files /dev/null and b/bin/presentacion/Principal$3.class differ
diff --git a/bin/presentacion/Principal$4.class b/bin/presentacion/Principal$4.class
new file mode 100644
index 0000000000000000000000000000000000000000..7935acec4f9db52486f8d058e6a086d4c1b7126c
Binary files /dev/null and b/bin/presentacion/Principal$4.class differ
diff --git a/bin/presentacion/Principal$5.class b/bin/presentacion/Principal$5.class
new file mode 100644
index 0000000000000000000000000000000000000000..5685dd74bb68433099dba78d0cace2ef60cf0d10
Binary files /dev/null and b/bin/presentacion/Principal$5.class differ
diff --git a/bin/presentacion/Principal.class b/bin/presentacion/Principal.class
new file mode 100644
index 0000000000000000000000000000000000000000..f6bdbd855c43b181848381294b28b31179e21e5e
Binary files /dev/null and b/bin/presentacion/Principal.class differ
diff --git a/src/excepciones/UsuarioNoExisteException.java b/src/excepciones/UsuarioNoExisteException.java
new file mode 100644
index 0000000000000000000000000000000000000000..f972d3e0a61e60a97c26dce98c473fe7ab8b221f
--- /dev/null
+++ b/src/excepciones/UsuarioNoExisteException.java
@@ -0,0 +1,15 @@
+package excepciones;
+
+/**
+ * Excepción utilizada para indicar la inexistencia de un usuario en el sistema.
+ *
+ * @author TProg2017
+ *
+ */
+@SuppressWarnings("serial")
+public class UsuarioNoExisteException extends Exception {
+
+ public UsuarioNoExisteException(String string) {
+ super(string);
+ }
+}
diff --git a/src/excepciones/UsuarioRepetidoException.java b/src/excepciones/UsuarioRepetidoException.java
new file mode 100644
index 0000000000000000000000000000000000000000..5eee866a0aef565aaeb6bbbb717beb60b888ec46
--- /dev/null
+++ b/src/excepciones/UsuarioRepetidoException.java
@@ -0,0 +1,16 @@
+package excepciones;
+
+/**
+ * Excepción utilizada para indicar la existencia de un usuario repetido en el sistema.
+ *
+ * @author TProg2017
+ *
+ */
+@SuppressWarnings("serial")
+public class UsuarioRepetidoException extends Exception {
+
+ public UsuarioRepetidoException(String string) {
+ super(string);
+ }
+
+}
diff --git a/src/logica/ControladorUsuario.java b/src/logica/ControladorUsuario.java
new file mode 100644
index 0000000000000000000000000000000000000000..0e9b280ff17e053cd1d5b0dcd21519c3300746c5
--- /dev/null
+++ b/src/logica/ControladorUsuario.java
@@ -0,0 +1,56 @@
+package logica;
+
+import excepciones.UsuarioNoExisteException;
+import excepciones.UsuarioRepetidoException;
+
+/**
+ * Controlador de usuarios.
+ * @author TProg2017
+ *
+ */
+public class ControladorUsuario implements IControladorUsuario {
+
+ public ControladorUsuario() {
+ }
+
+ public void registrarUsuario(String n, String ap, String ci) throws UsuarioRepetidoException {
+ ManejadorUsuario mu = ManejadorUsuario.getinstance();
+ Usuario u = mu.obtenerUsuario(ci);
+ if (u != null)
+ throw new UsuarioRepetidoException("El usuario " + ci + " ya esta registrado");
+
+ u = new Usuario(n, ap, ci);
+ mu.addUsuario(u);
+ }
+
+ public DataUsuario verInfoUsuario(String ci) throws UsuarioNoExisteException {
+ ManejadorUsuario mu = ManejadorUsuario.getinstance();
+ Usuario u = mu.obtenerUsuario(ci);
+ if (u != null)
+ return new DataUsuario(u.getNombre(), u.getApellido(), u.getCedulaIdentidad());
+ else
+ throw new UsuarioNoExisteException("El usuario " + ci + " no existe");
+
+ }
+
+ public DataUsuario[] getUsuarios() throws UsuarioNoExisteException {
+ ManejadorUsuario mu = ManejadorUsuario.getinstance();
+ Usuario[] usrs = mu.getUsuarios();
+
+ if (usrs != null) {
+ DataUsuario[] du = new DataUsuario[usrs.length];
+ Usuario usuario;
+
+ // Para separar lógica de presentación, no se deben devolver los Usuario,
+ // sino los DataUsuario
+ for (int i = 0; i < usrs.length; i++) {
+ usuario = usrs[i];
+ du[i] = new DataUsuario(usuario.getNombre(), usuario.getApellido(), usuario.getCedulaIdentidad());
+ }
+
+ return du;
+ } else
+ throw new UsuarioNoExisteException("No existen usuarios registrados");
+
+ }
+}
diff --git a/src/logica/DataUsuario.java b/src/logica/DataUsuario.java
new file mode 100644
index 0000000000000000000000000000000000000000..00c17a4972434397c1280f63440b0bfbe65b0d5a
--- /dev/null
+++ b/src/logica/DataUsuario.java
@@ -0,0 +1,57 @@
+package logica;
+
+/**
+ * Datatype para transportar la información de un usuario entre capa lógica y de presentación.
+ * En Java los datatypes se definen con setters y getters, y se denominan JavaBean.
+ * @author TProg2017
+ *
+ */
+public class DataUsuario {
+
+ private String nombre;
+ private String apellido;
+ private String cedulaIdentidad;
+
+ public DataUsuario() {
+ this.setNombre(new String());
+ this.setApellido(new String());
+ this.setCedulaIdentidad(new String());
+ }
+
+ public DataUsuario(String nombre, String apellido, String cedulaIdentidad) {
+ this.setNombre(nombre);
+ this.setApellido(apellido);
+ this.setCedulaIdentidad(cedulaIdentidad);
+ }
+
+ public String getNombre() {
+ return nombre;
+ }
+
+ public String getApellido() {
+ return apellido;
+ }
+
+ public String getCedulaIdentidad() {
+ return cedulaIdentidad;
+ }
+
+ /* Sirve para mostrar textualmente la información del usuario, por ejemplo en un ComboBox
+ */
+ public String toString() {
+ return getCedulaIdentidad() + " (" + getNombre() + " " + getApellido() + ")";
+ }
+
+ private void setNombre(String nombre) {
+ this.nombre = nombre;
+ }
+
+ private void setApellido(String apellido) {
+ this.apellido = apellido;
+ }
+
+ private void setCedulaIdentidad(String cedulaIdentidad) {
+ this.cedulaIdentidad = cedulaIdentidad;
+ }
+
+}
diff --git a/src/logica/Fabrica.java b/src/logica/Fabrica.java
new file mode 100644
index 0000000000000000000000000000000000000000..f2bd57da2e6990e8f3b9e0066bf2ad00dbc1efbc
--- /dev/null
+++ b/src/logica/Fabrica.java
@@ -0,0 +1,27 @@
+package logica;
+
+/**
+ * Fábrica para la construcción de un controlador de usuarios (uno distinto para cada invocación).
+ * Se implementa en base al patrón Singleton.
+ * @author TProg2017
+ *
+ */
+public class Fabrica {
+
+ private static Fabrica instancia;
+
+ private Fabrica() {
+ };
+
+ public static Fabrica getInstance() {
+ if (instancia == null) {
+ instancia = new Fabrica();
+ }
+ return instancia;
+ }
+
+ public IControladorUsuario getIControladorUsuario() {
+ return new ControladorUsuario();
+ }
+
+}
diff --git a/src/logica/IControladorUsuario.java b/src/logica/IControladorUsuario.java
new file mode 100644
index 0000000000000000000000000000000000000000..c75000beb9a5505d2c377f2f561caad2325d33a2
--- /dev/null
+++ b/src/logica/IControladorUsuario.java
@@ -0,0 +1,35 @@
+package logica;
+
+import excepciones.UsuarioNoExisteException;
+import excepciones.UsuarioRepetidoException;
+
+/**
+ * @author TProg2017
+ *
+ */
+public interface IControladorUsuario {
+
+ /**
+ * Registra al usuario en el sistema.
+ * @param n Nombre del usuario.
+ * @param ap Apellido del usuario.
+ * @param ci Cédula del usuario.
+ * @throws UsuarioRepetidoException Si la cédula del usuario se encuentra registrada en el sistema.
+ */
+ public abstract void registrarUsuario(String n, String ap, String ci) throws UsuarioRepetidoException;
+
+ /**
+ * Retorna la información de un usuario con la cédula indicada.
+ * @param ci Cédula del usuario.
+ * @return Información del usuario.
+ * @throws UsuarioNoExisteException Si la cédula del usuario no está registrada en el sistema.
+ */
+ public abstract DataUsuario verInfoUsuario(String ci) throws UsuarioNoExisteException;
+
+ /**
+ * Retorna la información de todos los usuarios registrados en el sistema.
+ * @return Información de los usuarios del sistema.
+ * @throws UsuarioNoExisteException Si no existen usuarios registrados en el sistema.
+ */
+ public abstract DataUsuario[] getUsuarios() throws UsuarioNoExisteException;
+}
diff --git a/src/logica/ManejadorUsuario.java b/src/logica/ManejadorUsuario.java
new file mode 100644
index 0000000000000000000000000000000000000000..59906d3825ce413f6c4010c212e9f11cba13fc99
--- /dev/null
+++ b/src/logica/ManejadorUsuario.java
@@ -0,0 +1,52 @@
+package logica;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Clase que conserva la colección global de los usuarios del sistema.
+ * Los usuarios se identifican por su cédula de identidad.
+ * Se implementa en base al patrón Singleton.
+ * @author TProg2017
+ *
+ */
+public class ManejadorUsuario {
+ private Map<String, Usuario> usuariosCI;
+ private static ManejadorUsuario instancia = null;
+
+ private ManejadorUsuario() {
+ usuariosCI = new HashMap<String, Usuario>();
+ }
+
+ public static ManejadorUsuario getinstance() {
+ if (instancia == null)
+ instancia = new ManejadorUsuario();
+ return instancia;
+ }
+
+ public void addUsuario(Usuario usu) {
+ String ci = usu.getCedulaIdentidad();
+ usuariosCI.put(ci, usu);
+ }
+
+ public Usuario obtenerUsuario(String ci) {
+ return ((Usuario) usuariosCI.get(ci));
+ }
+
+ public Usuario[] getUsuarios() {
+ if (usuariosCI.isEmpty())
+ return null;
+ else {
+ Collection<Usuario> usrs = usuariosCI.values();
+ Object[] o = usrs.toArray();
+ Usuario[] usuarios = new Usuario[o.length];
+ for (int i = 0; i < o.length; i++) {
+ usuarios[i] = (Usuario) o[i];
+ }
+
+ return usuarios;
+ }
+ }
+
+}
diff --git a/src/logica/Usuario.java b/src/logica/Usuario.java
new file mode 100644
index 0000000000000000000000000000000000000000..5a08ffc3aa6fdce4bef8c59aa31e878c10bd49b6
--- /dev/null
+++ b/src/logica/Usuario.java
@@ -0,0 +1,44 @@
+package logica;
+
+/**
+ * Representa a un usuario en el sistema con nombre, apellido y cédula de identidad.
+ * @author TProg2017
+ *
+ */
+public class Usuario {
+
+ private String nombre;
+ private String apellido;
+ private String cedulaIdentidad;
+
+ public Usuario(String n, String ap, String ci) {
+ this.nombre = n;
+ this.apellido = ap;
+ this.cedulaIdentidad = ci;
+ }
+
+ public String getNombre() {
+ return nombre;
+ }
+
+ public String getApellido() {
+ return apellido;
+ }
+
+ public String getCedulaIdentidad() {
+ return cedulaIdentidad;
+ }
+
+ public void setNombre(String n) {
+ nombre = n;
+ }
+
+ public void setApellido(String ap) {
+ apellido = ap;
+ }
+
+ public void setCedulaIdentidad(String ci) {
+ cedulaIdentidad = ci;
+ }
+
+}
diff --git a/src/presentacion/ConsultarUsuario.java b/src/presentacion/ConsultarUsuario.java
new file mode 100644
index 0000000000000000000000000000000000000000..6b3c75f11d2fad3009b98f760075364a5f55ed5b
--- /dev/null
+++ b/src/presentacion/ConsultarUsuario.java
@@ -0,0 +1,158 @@
+package presentacion;
+
+import javax.swing.JInternalFrame;
+
+import excepciones.UsuarioNoExisteException;
+import logica.DataUsuario;
+import logica.IControladorUsuario;
+
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JTextField;
+import javax.swing.JButton;
+import java.awt.event.ActionListener;
+import java.awt.event.ActionEvent;
+
+/**
+ * JInternalFrame que permite consultar la información de un usuario del sistema.
+ * @author TProg2017
+ *
+ */
+@SuppressWarnings("serial")
+public class ConsultarUsuario extends JInternalFrame {
+
+ // Controlador de usuarios que se utilizará para las acciones del JFrame
+ private IControladorUsuario controlUsr;
+
+ // Los componentes gráficos se agregan como atributos de la clase
+ // para facilitar su acceso desde diferentes métodos de la misma.
+ private JTextField textFieldCI;
+ private JTextField textFieldNombre;
+ private JTextField textFieldApellido;
+ private JLabel lblIngresoCI;
+ private JButton btnBuscar;
+ private JLabel lblNombre;
+ private JLabel lblApellido;
+ private JButton btnCerrar;
+ private JLabel lblInfoUsuario;
+
+ /**
+ * Create the frame.
+ */
+ public ConsultarUsuario(IControladorUsuario icu) {
+ // Se inicializa con el controlador de usuarios
+ controlUsr = icu;
+
+ // Propiedades del JInternalFrame como dimensión, posición dentro del frame, etc.
+ setResizable(true);
+ setIconifiable(true);
+ setMaximizable(true);
+ setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
+ setClosable(true);
+ setTitle("Consultar un Usuario");
+ setBounds(30, 30, 400, 280);
+
+ // En este caso usaremos el Absolute Layout y deberemos indicar
+ // la posición absoluta de todos los componentes
+ getContentPane().setLayout(null);
+
+ // Una etiqueta (JLabel) indicando que en el siguiente campo debe ingresarse
+ // la cédula del usuario.
+ lblIngresoCI = new JLabel("Ingrese CI:");
+ lblIngresoCI.setBounds(10, 24, 170, 14);
+ getContentPane().add(lblIngresoCI);
+
+ // Una campo de texto (JTextField) para ingresar la cédula de un usuario.
+ textFieldCI = new JTextField();
+ textFieldCI.setBounds(104, 17, 140, 30);
+ getContentPane().add(textFieldCI);
+
+ // Un botón (JButton) con un evento asociado que permite buscar un usuario.
+ // Dado que el código de registro tiene cierta complejidad, conviene delegarlo
+ // a otro método en lugar de incluirlo directamente de el método actionPerformed
+ btnBuscar = new JButton("Buscar");
+ btnBuscar.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent e) {
+ cmdBuscarUsuarioActionPerformed(e);
+ }
+ });
+ btnBuscar.setBounds(256, 16, 95, 30);
+ getContentPane().add(btnBuscar);
+
+ // Una etiqueta (JLabel) indicando que a continuación se verá la
+ // información del usuarios buscado.
+ lblInfoUsuario = new JLabel("Información de Usuario");
+ lblInfoUsuario.setBounds(104, 70, 180, 14);
+ getContentPane().add(lblInfoUsuario);
+
+ // Una etiqueta (JLabel) indicando que en el siguiente campo se verá
+ // el nombre del usuario encontrado.
+ lblNombre = new JLabel("Nombre:");
+ lblNombre.setBounds(10, 114, 65, 14);
+ getContentPane().add(lblNombre);
+
+ // Una campo de texto (JTextField) para mostrar el nombre del usuario.
+ // El campo se hace no editable para impedir que se modifique.
+ textFieldNombre = new JTextField();
+ textFieldNombre.setEditable(false);
+ textFieldNombre.setBounds(80, 107, 271, 30);
+ getContentPane().add(textFieldNombre);
+
+ // Una etiqueta (JLabel) indicando que en el siguiente campo se verá
+ // el apellido del usuario encontrado.
+ lblApellido = new JLabel("Apellido");
+ lblApellido.setBounds(10, 156, 65, 14);
+ getContentPane().add(lblApellido);
+
+ // Una campo de texto (JTextField) para mostrar el apellido del usuario.
+ // El campo se hace no editable para impedir que se modifique.
+ textFieldApellido = new JTextField();
+ textFieldApellido.setEditable(false);
+ textFieldApellido.setBounds(80, 149, 271, 30);
+ getContentPane().add(textFieldApellido);
+
+ // Un botón (JButton) con un evento asociado que permite cerrar el formulario (solo ocultarlo).
+ // Dado que antes de cerrar se limpia el formulario, se invoca un método reutilizable para ello.
+ btnCerrar = new JButton("Cerrar");
+ btnCerrar.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent e) {
+ limpiarFormulario();
+ setVisible(false);
+ }
+ });
+ btnCerrar.setBounds(262, 191, 89, 23);
+ getContentPane().add(btnCerrar);
+ }
+
+ // Este método es invocado al querer buscar un usuario, funcionalidad
+ // provista por la operación del sistem verInfoUsuario().
+ // En caso de que haya un error de búsqueda se despliega
+ // un mensaje utilizando un panel de mensaje (JOptionPane).
+ // No es necesario verificar que el campo con la cédula sea un número ya
+ // que internamente el sistema almacena la cédula como un string.
+ protected void cmdBuscarUsuarioActionPerformed(ActionEvent e) {
+ DataUsuario du;
+ try {
+ du = controlUsr.verInfoUsuario(textFieldCI.getText());
+ textFieldNombre.setText(du.getNombre());
+ textFieldApellido.setText(du.getApellido());
+ } catch (UsuarioNoExisteException e1) {
+ // Si el usuario no existe, se muestra mensaje de error y se limpia el
+ // formulario.
+ JOptionPane.showMessageDialog(this, e1.getMessage(), "Buscar Usuario", JOptionPane.ERROR_MESSAGE);
+ limpiarFormulario();
+ }
+
+ }
+
+ // Permite borrar el contenido de un formulario antes de cerrarlo.
+ // Recordar que las ventanas no se destruyen, sino que simplemente
+ // se ocultan, por lo que conviene borrar la información para que
+ // no aparezca al mostrarlas nuevamente.
+ private void limpiarFormulario() {
+ textFieldNombre.setText("");
+ textFieldApellido.setText("");
+ textFieldCI.setText("");
+ }
+}
diff --git a/src/presentacion/CrearUsuario.java b/src/presentacion/CrearUsuario.java
new file mode 100644
index 0000000000000000000000000000000000000000..096ccf311a02fd079891d0a3fcbe24818c06bc60
--- /dev/null
+++ b/src/presentacion/CrearUsuario.java
@@ -0,0 +1,247 @@
+package presentacion;
+
+import javax.swing.JInternalFrame;
+
+import excepciones.UsuarioRepetidoException;
+import logica.IControladorUsuario;
+
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.SwingConstants;
+import javax.swing.JTextField;
+import javax.swing.JButton;
+import java.awt.GridBagLayout;
+import java.awt.GridBagConstraints;
+import java.awt.Insets;
+import javax.swing.JFrame;
+import java.awt.event.ActionListener;
+import java.awt.event.ActionEvent;
+
+/**
+ * JInternalFrame que permite registrar un nuevo usuario al sistema.
+ *
+ * @author TProg2017
+ *
+ */
+@SuppressWarnings("serial")
+public class CrearUsuario extends JInternalFrame {
+
+ // Controlador de usuarios que se utilizará para las acciones del JFrame
+ private IControladorUsuario controlUsr;
+
+ // Los componentes gráficos se agregan como atributos de la clase
+ // para facilitar su acceso desde diferentes métodos de la misma.
+ private JTextField textFieldNombre;
+ private JTextField textFieldApellido;
+ private JTextField textFieldCI;
+ private JLabel lblIngreseNombre;
+ private JLabel lblIngreseApellido;
+ private JLabel lblIngreseCi;
+ private JButton btnAceptar;
+ private JButton btnCancelar;
+
+ /**
+ * Create the frame.
+ */
+ public CrearUsuario(IControladorUsuario icu) {
+ // Se inicializa con el controlador de usuarios
+ controlUsr = icu;
+
+ // Propiedades del JInternalFrame como dimensión, posición dentro del frame,
+ // etc.
+ setResizable(true);
+ setIconifiable(true);
+ setMaximizable(true);
+ setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
+ setClosable(true);
+ setTitle("Registrar un Usuario");
+ setBounds(10, 40, 360, 150);
+
+ // En este caso utilizaremos el GridBagLayout que permite armar una grilla
+ // en donde las filas y columnas no son uniformes.
+ // Conviene trabajar este componente desde la vista de diseño gráfico y sólo
+ // manipular los valores para ajustar alguna cosa.
+ GridBagLayout gridBagLayout = new GridBagLayout();
+ gridBagLayout.columnWidths = new int[] { 100, 120, 120, 0 };
+ gridBagLayout.rowHeights = new int[] { 30, 30, 30, 0, 0 };
+ gridBagLayout.columnWeights = new double[] { 0.0, 0.0, 0.0, Double.MIN_VALUE };
+ gridBagLayout.rowWeights = new double[] { 0.0, 0.0, 0.0, 0.0, Double.MIN_VALUE };
+ getContentPane().setLayout(gridBagLayout);
+
+ // Una etiqueta (JLabel) indicandp que en el siguiente campo debe ingresarse
+ // el nombre del usuario. El texto está alineado horizontalmente a la derecha para
+ // que quede casi pegado al campo de texto.
+ lblIngreseNombre = new JLabel("Nombre:");
+ lblIngreseNombre.setHorizontalAlignment(SwingConstants.RIGHT);
+ GridBagConstraints gbc_lblIngreseNombre = new GridBagConstraints();
+ gbc_lblIngreseNombre.fill = GridBagConstraints.BOTH;
+ gbc_lblIngreseNombre.insets = new Insets(0, 0, 5, 5);
+ gbc_lblIngreseNombre.gridx = 0;
+ gbc_lblIngreseNombre.gridy = 0;
+ getContentPane().add(lblIngreseNombre, gbc_lblIngreseNombre);
+
+ // Una campo de texto (JTextField) para ingresar el nombre del usuario.
+ // Por defecto es posible ingresar cualquier string.
+ textFieldNombre = new JTextField();
+ GridBagConstraints gbc_textFieldNombre = new GridBagConstraints();
+ gbc_textFieldNombre.gridwidth = 2;
+ gbc_textFieldNombre.fill = GridBagConstraints.BOTH;
+ gbc_textFieldNombre.insets = new Insets(0, 0, 5, 0);
+ gbc_textFieldNombre.gridx = 1;
+ gbc_textFieldNombre.gridy = 0;
+ getContentPane().add(textFieldNombre, gbc_textFieldNombre);
+ textFieldNombre.setColumns(10);
+
+ // Una etiqueta (JLabel) indicandp que en el siguiente campo debe ingresarse
+ // el apellido del usuario. El texto está alineado horizontalmente a la derecha para
+ // que quede casi pegado al campo de texto.
+ lblIngreseApellido = new JLabel("Apellido:");
+ lblIngreseApellido.setHorizontalAlignment(SwingConstants.RIGHT);
+ GridBagConstraints gbc_lblIngreseApellido = new GridBagConstraints();
+ gbc_lblIngreseApellido.fill = GridBagConstraints.BOTH;
+ gbc_lblIngreseApellido.insets = new Insets(0, 0, 5, 5);
+ gbc_lblIngreseApellido.gridx = 0;
+ gbc_lblIngreseApellido.gridy = 1;
+ getContentPane().add(lblIngreseApellido, gbc_lblIngreseApellido);
+
+ // Una campo de texto (JTextField) para ingresar el apellido del usuario.
+ // Por defecto es posible ingresar cualquier string.
+ textFieldApellido = new JTextField();
+ GridBagConstraints gbc_textFieldApellido = new GridBagConstraints();
+ gbc_textFieldApellido.gridwidth = 2;
+ gbc_textFieldApellido.fill = GridBagConstraints.BOTH;
+ gbc_textFieldApellido.insets = new Insets(0, 0, 5, 0);
+ gbc_textFieldApellido.gridx = 1;
+ gbc_textFieldApellido.gridy = 1;
+ getContentPane().add(textFieldApellido, gbc_textFieldApellido);
+ textFieldApellido.setColumns(10);
+
+ // Una etiqueta (JLabel) indicando que en el siguiente campo debe ingresarse
+ // la cédula del usuario. El texto está alineado horizontalmente a la derecha para
+ // que quede casi pegado al campo de texto.
+ lblIngreseCi = new JLabel("C.I.:");
+ lblIngreseCi.setHorizontalAlignment(SwingConstants.RIGHT);
+ GridBagConstraints gbc_lblIngreseCi = new GridBagConstraints();
+ gbc_lblIngreseCi.fill = GridBagConstraints.BOTH;
+ gbc_lblIngreseCi.insets = new Insets(0, 0, 5, 5);
+ gbc_lblIngreseCi.gridx = 0;
+ gbc_lblIngreseCi.gridy = 2;
+ getContentPane().add(lblIngreseCi, gbc_lblIngreseCi);
+
+ // Una campo de texto (JTextField) para ingresar la cédula del usuario.
+ // Por defecto es posible ingresar cualquier string.
+ // Al campo se le incluye un Tooltip que, al pasar el mouse por encima, despliega un mensaje.
+ textFieldCI = new JTextField();
+ textFieldCI.setToolTipText("Ingrese un número sin puntos ni guiones");
+ textFieldCI.setColumns(10);
+ GridBagConstraints gbc_textFieldCI = new GridBagConstraints();
+ gbc_textFieldCI.gridwidth = 2;
+ gbc_textFieldCI.fill = GridBagConstraints.BOTH;
+ gbc_textFieldCI.insets = new Insets(0, 0, 5, 0);
+ gbc_textFieldCI.gridx = 1;
+ gbc_textFieldCI.gridy = 2;
+ getContentPane().add(textFieldCI, gbc_textFieldCI);
+
+ // Un botón (JButton) con un evento asociado que permite registrar el usuario.
+ // Dado que el código de registro tiene cierta complejidad, conviene delegarlo
+ // a otro método en lugar de incluirlo directamente de el método actionPerformed
+ btnAceptar = new JButton("Aceptar");
+ btnAceptar.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent arg0) {
+ cmdRegistroUsuarioActionPerformed(arg0);
+ }
+ });
+
+ GridBagConstraints gbc_btnAceptar = new GridBagConstraints();
+ gbc_btnAceptar.fill = GridBagConstraints.BOTH;
+ gbc_btnAceptar.insets = new Insets(0, 0, 0, 5);
+ gbc_btnAceptar.gridx = 1;
+ gbc_btnAceptar.gridy = 3;
+ getContentPane().add(btnAceptar, gbc_btnAceptar);
+
+ // Un botón (JButton) con un evento asociado que permite cerrar el formulario (solo ocultarlo).
+ // Dado que antes de cerrar se limpia el formulario, se invoca un método reutilizable para ello.
+ btnCancelar = new JButton("Cancelar");
+ btnCancelar.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent e) {
+ limpiarFormulario();
+ setVisible(false);
+ }
+ });
+ GridBagConstraints gbc_btnCancelar = new GridBagConstraints();
+ gbc_btnCancelar.fill = GridBagConstraints.BOTH;
+ gbc_btnCancelar.gridx = 2;
+ gbc_btnCancelar.gridy = 3;
+ getContentPane().add(btnCancelar, gbc_btnCancelar);
+ }
+
+ // Este método es invocado al querer registrar un usuario, funcionalidad
+ // provista por la operación del sistem registrarUsuario().
+ // Previamente se hace una verificación de los campos, particularmente que no sean vacÃos
+ // y que la cédula sea un número.
+ // Tanto en caso de que haya un error (de verificación o de registro) o no, se despliega
+ // un mensaje utilizando un panel de mensaje (JOptionPane).
+ protected void cmdRegistroUsuarioActionPerformed(ActionEvent arg0) {
+ // TODO Auto-generated method stub
+
+ // Obtengo datos de los controles Swing
+ String nombreU = this.textFieldNombre.getText();
+ String apellidoU = this.textFieldApellido.getText();
+ String ciU = this.textFieldCI.getText();
+
+ if (checkFormulario()) {
+ try {
+ controlUsr.registrarUsuario(nombreU, apellidoU, ciU);
+
+ // Muestro éxito de la operación
+ JOptionPane.showMessageDialog(this, "El Usuario se ha creado con éxito", "Registrar Usuario",
+ JOptionPane.INFORMATION_MESSAGE);
+
+ } catch (UsuarioRepetidoException e) {
+ // Muestro error de registro
+ JOptionPane.showMessageDialog(this, e.getMessage(), "Registrar Usuario", JOptionPane.ERROR_MESSAGE);
+ }
+
+ // Limpio el internal frame antes de cerrar la ventana
+ limpiarFormulario();
+ setVisible(false);
+ }
+ }
+
+ // Permite validar la información introducida en los campos e indicar
+ // a través de un mensaje de error (JOptionPane) cuando algo sucede.
+ // Este tipo de chequeos se puede realizar de otras formas y con otras librerÃas de Java,
+ // por ejemplo impidiendo que se escriban caracteres no numéricos al momento de escribir en
+ // en el campo de la cédula, o mostrando un mensaje de error apenas el foco pasa a otro campo.
+ private boolean checkFormulario() {
+ String nombreU = this.textFieldNombre.getText();
+ String apellidoU = this.textFieldApellido.getText();
+ String ciU = this.textFieldCI.getText();
+
+ if (nombreU.isEmpty() || apellidoU.isEmpty() || ciU.isEmpty()) {
+ JOptionPane.showMessageDialog(this, "No puede haber campos vacÃos", "Registrar Usuario",
+ JOptionPane.ERROR_MESSAGE);
+ return false;
+ }
+
+ try {
+ Integer.parseInt(ciU);
+ } catch (NumberFormatException e) {
+ JOptionPane.showMessageDialog(this, "La CI debe ser un numero", "Registrar Usuario",
+ JOptionPane.ERROR_MESSAGE);
+ return false;
+ }
+
+ return true;
+ }
+
+ // Permite borrar el contenido de un formulario antes de cerrarlo.
+ // Recordar que las ventanas no se destruyen, sino que simplemente
+ // se ocultan, por lo que conviene borrar la información para que
+ // no aparezca al mostrarlas nuevamente.
+ private void limpiarFormulario() {
+ textFieldNombre.setText("");
+ textFieldApellido.setText("");
+ textFieldCI.setText("");
+ }
+}
diff --git a/src/presentacion/ListaUsuarios.java b/src/presentacion/ListaUsuarios.java
new file mode 100644
index 0000000000000000000000000000000000000000..dd0f4540da84d45768e8ae7fa75ac23ba6aa5184
--- /dev/null
+++ b/src/presentacion/ListaUsuarios.java
@@ -0,0 +1,94 @@
+package presentacion;
+
+import javax.swing.JFrame;
+import javax.swing.JInternalFrame;
+
+import excepciones.UsuarioNoExisteException;
+import logica.DataUsuario;
+import logica.IControladorUsuario;
+
+import java.awt.BorderLayout;
+import javax.swing.JLabel;
+import javax.swing.SwingConstants;
+import javax.swing.DefaultComboBoxModel;
+import javax.swing.JButton;
+import java.awt.event.ActionListener;
+import java.awt.event.ActionEvent;
+import javax.swing.JComboBox;
+
+/**
+ * JInternalFrame que permite listar todos los usuarios del sistema.
+ * @author TProg2017
+ *
+ */
+@SuppressWarnings("serial")
+public class ListaUsuarios extends JInternalFrame {
+
+ // Controlador de usuarios que se utilizará para las acciones del JFrame
+ private IControladorUsuario controlUsr;
+
+ // Los componentes gráficos se agregan como atributos de la clase
+ // para facilitar su acceso desde diferentes métodos de la misma.
+ private JComboBox<DataUsuario> comboBoxUsuarios;
+ private JLabel lblUsuarios;
+ private JButton btnCerrar;
+
+ /**
+ * Create the frame.
+ */
+ public ListaUsuarios(IControladorUsuario icu) {
+ // Se inicializa con el controlador de usuarios
+ controlUsr = icu;
+
+ // Propiedades del JInternalFrame como dimensión, posición dentro del frame, etc.
+ setResizable(true);
+ setIconifiable(true);
+ setMaximizable(true);
+ setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
+ setClosable(true);
+ setTitle("Consultar un Usuario");
+ setBounds(30, 30, 300, 100);
+
+ // En este caso se utiliza un BorderLayout en donde los componentes se ubican según una orientación.
+ getContentPane().setLayout(new BorderLayout(0, 0));
+
+ // Una etiqueta (JLabel) muestra el tÃtulo de la lista que vendrá después.
+ // Se ubica al norte del layout y el texto se centra horizontalmente.
+ lblUsuarios = new JLabel("Usuarios Registrados");
+ lblUsuarios.setHorizontalAlignment(SwingConstants.CENTER);
+ getContentPane().add(lblUsuarios, BorderLayout.NORTH);
+
+ // Un combo (JComboBox) muestra la lista de usuarios registrados en el sistema.
+ // Es posible utilizar otros componentes gráficos, esta es sólo una opción.
+ // Se ubica al centro del layout.
+ comboBoxUsuarios = new JComboBox<DataUsuario>();
+ getContentPane().add(comboBoxUsuarios, BorderLayout.CENTER);
+
+ // Un botón (JButton) con un evento asociado que permite limpiar la lista
+ // de usuarios y cerrar la ventana (sólo la oculta).
+ // Se ubica al sur del layout.
+ btnCerrar = new JButton("Cerrar");
+ btnCerrar.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent e) {
+ comboBoxUsuarios.removeAllItems();
+ setVisible(false);
+ }
+ });
+ getContentPane().add(btnCerrar, BorderLayout.SOUTH);
+ }
+
+ // Método que permite cargar un nuevo modelo para el combo con la información
+ // actualizada de usuarios, provista por la operación del sistema getUsuarios().
+ // Se invoca el método antes de hacer visible el JInternalFrame
+ public void cargarUsuarios() {
+ DefaultComboBoxModel<DataUsuario> model;
+ try {
+ model = new DefaultComboBoxModel<DataUsuario>(controlUsr.getUsuarios());
+ comboBoxUsuarios.setModel(model);
+ } catch (UsuarioNoExisteException e) {
+ // No se imprime mensaje de error sino que simplemente no se muestra ningún elemento
+ }
+
+ }
+
+}
diff --git a/src/presentacion/Principal.java b/src/presentacion/Principal.java
new file mode 100644
index 0000000000000000000000000000000000000000..c5289ea72d756624e892bd4b8688aa1b44ebd8e9
--- /dev/null
+++ b/src/presentacion/Principal.java
@@ -0,0 +1,135 @@
+package presentacion;
+
+import java.awt.EventQueue;
+
+import javax.swing.JFrame;
+import javax.swing.JMenuBar;
+import javax.swing.JMenuItem;
+
+import logica.Fabrica;
+import logica.IControladorUsuario;
+
+import javax.swing.JMenu;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+/**
+ * Clase principal (Frame) con el método Main.
+ * @author TProg2017
+ *
+ */
+public class Principal {
+
+ private JFrame frmGestionDeUsuarios;
+ private IControladorUsuario ICU;
+ private CrearUsuario creUsrInternalFrame;
+ private ConsultarUsuario conUsrInternalFrame;
+ private ListaUsuarios lisUsrInternalFrame;
+
+ /**
+ * Launch the application.
+ */
+ public static void main(String[] args) {
+ EventQueue.invokeLater(new Runnable() {
+ public void run() {
+ try {
+ Principal window = new Principal();
+ window.frmGestionDeUsuarios.setVisible(true);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ });
+ }
+
+ /**
+ * Create the application.
+ */
+ public Principal() {
+ initialize();
+
+ // Inicialización
+ Fabrica fabrica = Fabrica.getInstance();
+ ICU = fabrica.getIControladorUsuario();
+
+ // Se crean los tres InternalFrame y se incluyen al Frame principal ocultos.
+ // De esta forma, no es necesario crear y destruir objetos lo que enlentece la ejecución.
+ // Cada InternalFrame usa un layout diferente, simplemente para mostrar distintas opciones.
+ creUsrInternalFrame = new CrearUsuario(ICU);
+ creUsrInternalFrame.setVisible(false);
+
+ conUsrInternalFrame = new ConsultarUsuario(ICU);
+ conUsrInternalFrame.setVisible(false);
+
+ lisUsrInternalFrame = new ListaUsuarios(ICU);
+ lisUsrInternalFrame.setVisible(false);
+ frmGestionDeUsuarios.getContentPane().setLayout(null);
+
+ frmGestionDeUsuarios.getContentPane().add(conUsrInternalFrame);
+ frmGestionDeUsuarios.getContentPane().add(creUsrInternalFrame);
+ frmGestionDeUsuarios.getContentPane().add(lisUsrInternalFrame);
+ }
+
+ /**
+ * Initialize the contents of the frame.
+ */
+ private void initialize() {
+
+ // Se crea el Frame con las dimensiones indicadas.
+ frmGestionDeUsuarios = new JFrame();
+ frmGestionDeUsuarios.setTitle("Gestion de Usuarios 1.0");
+ frmGestionDeUsuarios.setBounds(100, 100, 450, 400);
+ frmGestionDeUsuarios.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+
+ // Se crea una barra de menú (JMenuBar) con dos menú (JMenu) desplegables.
+ // Cada menú contiene diferentes opciones (JMenuItem), los cuales tienen un
+ // evento asociado que permite realizar una acción una vez se seleccionan.
+ JMenuBar menuBar = new JMenuBar();
+ frmGestionDeUsuarios.setJMenuBar(menuBar);
+
+ JMenu menuSistema = new JMenu("Sistema");
+ menuBar.add(menuSistema);
+
+ JMenuItem menuSalir = new JMenuItem("Salir");
+ menuSalir.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent arg0) {
+ // Salgo de la aplicación
+ frmGestionDeUsuarios.setVisible(false);
+ frmGestionDeUsuarios.dispose();
+ }
+ });
+ menuSistema.add(menuSalir);
+
+ JMenu menuUsuarios = new JMenu("Usuarios");
+ menuBar.add(menuUsuarios);
+
+ JMenuItem menuItemRegistrar = new JMenuItem("Registrar Usuario");
+ menuItemRegistrar.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent e) {
+ // Muestro el InternalFrame para registrar un usuario
+ creUsrInternalFrame.setVisible(true);
+ }
+ });
+ menuUsuarios.add(menuItemRegistrar);
+
+ JMenuItem menuItemVerInfo = new JMenuItem("Ver Información");
+ menuItemVerInfo.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent e) {
+ // Muestro el InternalFrame para ver información de un usuario
+ conUsrInternalFrame.setVisible(true);
+ }
+ });
+ menuUsuarios.add(menuItemVerInfo);
+
+ JMenuItem mntmListaUsuarios = new JMenuItem("ListarUsuarios");
+ mntmListaUsuarios.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent e) {
+ // Muestro el InternalFrame para ver la lista de todos los usuarios,
+ // cargando previamente la lista
+ lisUsrInternalFrame.cargarUsuarios();
+ lisUsrInternalFrame.setVisible(true);
+ }
+ });
+ menuUsuarios.add(mntmListaUsuarios);
+ }
+}