 |
 |
 |
 |
PARADIGMA
La computadora puede hacer tantos errores en un segundo
como 100 hombres trabajando un año.!!
|
Además Java permite generar programas que pueden correr bajo plataformas cruzadas, de manera que puedan ser
operadas directamente bajo entorno Windows y sin ninguna modificación también pueden correr bajo plataforma
Apple de Macintosh o bajp la mayoría de las versiones UNIX.
|
|||||
A partir de tal momento se cambia la estética y la efectividad de millones de páginas y sitios de la WEB,
cuya programación permitirá disfrutar de las innumerables ventajas los ya populares applets de Java, los cuales
han hecho que este lenguaje permita diseñar programas que funcionen en conjunto con Internet.
También Java, puede operar en otros dispositivos ajenos a las computadoras, tales como televisores, teléfonos celulares y relojes de pulso..!!!
Colega virtual, si eres amigo del lenguaje C y tienes ganas de aprender Java, posiblemente veas simplificar tu tarea, pues su sintaxis y su semántica son bastante parecidos, solo que más simple..!!, que suerte no..??!!
INICIAR Y DETENER LA APLICACION
El paquete com.ms.wfc.app incluye la clase "static" Application, que es responsable del procesamiento de ventanas de Win32, como el registro, la creación de instancias, la administración del bucle de mensajes, etc.
La ventana principal de la aplicación se crea llamando al método Application.run y pasando el objeto derivado de Form que compone el aspecto visual de la ventana.
Esta llamada se produce en el método main() de la clase de plantilla basada en Form y generada por Visual J++. Se generó el código siguiente para la aplicación MiBlocdeNotas:
public static void main(String args[])
{
Application.run(new MiBlocdeNotas());
}
De forma predeterminada, la aplicación básica creada por una plantilla de Visual J++ se cierra utilizando el botón Salir (X) de la ventana, en la esquina superior derecha de la aplicación. Sin embargo, ésta puede cerrarse mediante programación en cualquier lugar del código llamando al método Application.exit. Por ejemplo, esta aplicación se cierra al hacer clic en Salir en el menú Archivo:
private void FileMenuExit_click(Object sender, Event e)
{
// Llamar al nuevo controlador de archivo para ejecutar
// NuevoDialogo y preguntar al usuario si desea guardar los datos
this.FileMenuNew_click(sender, e);
Application.exit();
}
Una vez descrito el código al que se llama al ejecutar una aplicación, cabe mencionar la forma en que el usuario la ejecuta.
Visual J++ incluye funciones avanzadas de distribución, una de las cuales es la creación de un archivo ejecutable (.EXE) de Windows que permite a los usuarios ejecutar las aplicaciones WFC de forma similar a cualquier aplicación de Windows, dando por supuesto que las clases WFC se hallan instaladas en el equipo del usuario.
Las clases WFC se incluyen en la última versión de la Máquina virtual de Java, que puede redistribuirse.
Un formulario WFC básico es una clase pública que amplía la clase Form con un constructor predeterminado y un método initForm. Cuando se crea una instancia de la clase Form, el constructor de la clase llama al método initForm, que es donde el Diseñador de formularios coloca todo el código utilizado para inicializar el formulario y las propiedades de control.
Otro código específico de la aplicación sigue a la llamada a initForm en el constructor.
En la aplicación MiBlocdeNotas, el título de la aplicación se establece aquí (aunque también podría haberse establecido en la ventana Propiedades del formulario). El constructor de la aplicación MiBlocdeNotas es:
public MiBlocdeNotas()
{
// Requerido para ser compatible con el Diseñador de formularios
// de Visual J++
initForm();
this.setBounds(100, 100, 300, 300);
this.setText("Sin título - MiBlocdeNotas");
}
El Diseñador de formularios de Visual J++ agrega declaraciones para los controles incorporados en el cuerpo principal de la clase, justo delante del método initForm. A continuación se presentan las declaraciones de los objetos que componen el formulario MiBlocdeNotas.java:
/**
* NOTA: El Diseñador de formularios de Visual J++ requiere el
* código siguiente. Puede modificarlo en el editor de formularios.
* No lo modifique utilizando el editor de texto.
*/
Container components = new Container();
MainMenu Menu = new MainMenu();
MenuItem FileMenu = new MenuItem();
MenuItem FileMenuNew = new MenuItem();
MenuItem FileMenuOpen = new MenuItem();
MenuItem FileMenuSave = new MenuItem();
MenuItem FileMenuSaveAs = new MenuItem();
MenuItem FileMenuExit = new MenuItem();
MenuItem HelpMenu = new MenuItem();
MenuItem HelpMenuAbout = new MenuItem();
Edit editbox = new Edit();
private void initForm()
{
. . .
El Diseñador de formularios de Visual J++ crea este código de declaración, así como el código del método initForm que establece las propiedades del formulario y los controles insertados en él.
La infraestructura para el control de eventos también está fuertemente integrada con el Diseñador de formularios, que puede generar asignaciones de controladores de eventos en el método initForm.
Las dos primeras instrucciones del método initForm demuestran cómo el Diseñador de formularios establece las propiedades de un objeto (en este caso, establece la propiedad Text del elemento de menú en "&Nuevo") y utiliza el método addOnClick del objeto para establecer un controlador de evento de clic para el objeto.
private void initForm()
{
FileMenuNew.setText("&Nuevo");
FileMenuNew.addOnClick(new EventHandler(this.FileMenuNew_click));
CONTROL DE EVENTOS
La mayoría del código de la aplicación MiBlocdeNotas se genera en los métodos de controlador de eventos a los que se llama al hacer clic en los elementos de menú.
El Diseñador de formularios facilita la creación de plantillas de controladores de eventos para aquellos eventos que generan los controles del formulario.
Por ejemplo, para agregar un método de controlador para los eventos de clic de menú, sólo es necesario hacer doble clic en el elemento de menú en el formulario.
Si bien hacer clic directamente sobre un botón o un elemento de menú genera controladores de eventos de clic, es igual de fácil crear una plantilla de código de controlador para otros eventos utilizando la ficha Eventos de la ventana Propiedades.
A continuación, el Diseñador de formularios agrega un método de controlador de eventos estructural, donde puede agregarse código, a la clase del formulario, e inserta una llamada MenuItem.addOnClick para la clase MenuItem correspondiente en initForm.
Por ejemplo, al hacer clic en un elemento de menú denominado FileMenuNew, se agrega la línea siguiente a initForm y se agrega un método denominado FileMenuNew_click a la clase:
FileMenuNew.addOnClick(new EventHandler(this.FileMenuNew_click));
El método MenuItem.addOnClick toma un objeto EventHandler. El objeto EventHandler se crea con una referencia al método al que ha de llamarse al hacer clic en ese elemento de menú.
Esencialmente, el objeto MenuItem controla los clics del mouse (ratón) y llama a cada controlador de evento que incorpora, utilizando el delegado, cuando se produce el evento.
Todos los objetos del controlador de eventos son delegados; la diferencia entre ellos es el objeto de evento que pasan al controlador.
Un delegado EventHandler pasa un objeto Event, que contiene información del evento. Sin embargo, un delegado KeyEventHandler, por ejemplo, pasa un objeto KeyEvent que amplía al objeto Event para eventos keydown (tecla abajo) y keyup (tecla arriba).
(KeyEvent incluye un campo adicional que especifica el carácter UNICODE y si se combinó con las teclas CTRL, MAYÚS o ALT.)
En la mayoría de los casos, los programadores de WFC no necesitan saber demasiado sobre los delegados, ya que los paquetes WFC incluyen controladores de eventos para los eventos que controlan y, en su mayor parte, el Diseñador de formularios genera el código necesario para agregarlos.
A continuación se muestra el controlador de eventos de la aplicación MiBlocdeNotas que controla la selección de este elemento de menú concreto:
private void FileMenuNew_click(Object sender, Event e)
{
// Si el control de edición contiene texto, comprobar si debe
// guardarse
if (editbox.getText().length() != 0) {
// Abre la clase NewDialog como cuadro de diálogo modal
int result = new NewDialog().showDialog(this);
// Recupera el resultado
// Si se hace clic en el botón Sí, abrir el cuadro de
// diálogo Guardar como
if (result == DialogResult.YES)
this.FileMenuSaveAs_click(sender, e);
// Si se hace clic en el botón No, despejar el control de
// edición y establecer el título
else if (result == DialogResult.NO) {
editbox.setText("");
this.setText("Sin título - MiBlocdeNotas");
}
}
}
Indudablemente, el Diseñador de formularios crea sólo la estructura del controlador de eventos. El código que abre el cuadro de diálogo modal personalizado se agregó de forma manual.
CUADRO DE DIALOGO MODAL
En la aplicación MiBlocdeNotas, cuando un usuario hace clic en Nuevo en el menú Archivo, el código de este controlador de eventos determina si hay texto en el control de edición. Si es así, abre un cuadro de diálogo modal que muestra un mensaje donde se pregunta al usuario si desea guardar el texto.
Si el usuario hace clic en el botón Sí, se llama al método MiBlocdeNotas.FileMenuSaveAs_click, que permite al usuario elegir un archivo y guardar el texto actual.
Si el usuario hace clic en No, se despeja el control de edición y el título que aparece en el formulario principal pasa a ser "Sin título – MiBlocdeNotas".
En el método FileMenuNew_click, la llamada a este cuadro de diálogo y la recuperación del resultado del mismo se realiza en una línea, como se muestra a continuación:
int result = new NewDialog().showDialog(this);
Mientras el cuadro de diálogo modal está abierto, el valor del resultado del cuadro de diálogo puede establecerse desde el formulario correspondiente. La clase DialogResult contiene constantes de enteros utilizadas con este fin, pero puede devolverse cualquier entero.
En este caso, se utilizaron las propiedades dialogResult del botón, ya que se obtiene el mismo resultado que al establecer el valor DialogResult.
Por ejemplo, al hacer clic en el control yesButton se establece DialogResult.Yes. Después, el método showDialog devuelve este resultado en la clase propietaria al cerrar el cuadro de diálogo.
El resultado de entero que devuelve showDialog se utiliza para determinar qué acción ha de realizarse.
El formulario NuevoDialogo.java se creó como un nuevo formulario utilizando la misma plantilla Form del formulario principal de la aplicación.
Observe que el método main() no es necesario para cuadros de diálogo modales y no se ha incluido en el ejemplo (si se mantiene no se producen errores, pero no se considera una buena práctica). Asimismo, se eliminaron comentarios ajenos en la plantilla.
Uso de un cuadro de mensaje como cuadro de diálogo modal
Para casos poco complejos, también puede utilizarse un cuadro de mensaje en lugar de un cuadro de diálogo modal personalizado.
El controlador del evento clic para el elemento de menú Acerca de MiBlocdeNotas del menú Ayuda utiliza un objeto MessageBox de esta forma:
private void HelpMenuAbout_click(Object sender, Event e)
{
MessageBox.show("Versión: Visual J++ 6.0", "MiBlocdeNotas");
}
CUADRO DE DIALOGO PARA ARCHIVO
El código restante de interés en esta aplicación está relacionado con la E/S de archivos y el uso de los cuadros de diálogo Abrir archivo y Guardar archivo. Se demuestra cómo las clases WFC simplifican el trabajo de traducción, apertura, lectura y escritura de los archivos.
A continuación se ofrece un breve resumen de las clases WFC utilizadas con este fin.
En la jerarquía de las clases WFC, las clases com.ms.wfc.ui.OpenFileDialog y com.ms.wfc.ui.SaveFileDialog se derivan de com.ms.wfc.ui.FileDialog.
FileDialog se deriva de CommonDialog, que es un empaquetador de la API de cuadros de diálogo comunes de Win32. Todos los cuadros de diálogo comunes se configuran con propiedades como setTitle y setFilter, y se ejecutan llamando al método showDialog.
Estos cuadros de diálogo permiten a los usuarios elegir un nombre al abrir o guardar un archivo.
El paquete com.ms.wfc.io contiene clases de E/S basadas en secuencias (stream). La clase File, que amplía DataStream, contiene métodos para la E/S de archivos.
En el caso de la aplicación MiBlocdeNotas, todo lo necesario es abrir un archivo, leer su contenido en el control de edición (o escribir el contenido del control de edición en el archivo) y, a continuación, cerrar el archivo.
En la aplicación MiBlocdeNotas, el código de E/S y de cuadro de diálogo de archivo se encuentra en los métodos del controlador de eventos para los elementos Abrir, Guardar y Guardar como del menú Archivo.
Nos centraremos en uno de ellos, el controlador de eventos del menú Abrir, ya que abarca la funcionalidad de cuadro de diálogo común y E/S de archivos. El código de FileMenuOpen_click es:
private void FileMenuOpen_click(Object sender, Event e)
{
// Crear un cuadro de diálogo Abrir archivo
OpenFileDialog ofd = new OpenFileDialog();
// Establecer filtros y opciones
ofd.setFilter("Documentos de texto (*.txt)|*.txt|Todos los archivos (*.*)|*.*");
ofd.setDefaultExt("txt");
// Ejecutar el cuadro de diálogo Abrir archivo
int OK = ofd.showDialog();
// Comprobar el resultado del cuadro de diálogo después
// de cerrarse
if (OK == DialogResult.OK) {
// Recuperar el nombre de archivo especificado
fileName = ofd.getFileName();
// Abrir una secuencia File en ese nombre de archivo
currentDoc = File.open(fileName);
// Recuperar la longitud del archivo
int ilength = (int)currentDoc.getLength();
// Leer caracteres ANSI para modificar el búfer
editbox.setText(currentDoc.readStringCharsAnsi(ilength));
// Cerrar el control del archivo
currentDoc.close();
fileOpen=true;
// Establecer el título de la aplicación
this.setText(File.getName(fileName) + " - MiBlocdeNotas");
}
}
Cuando un usuario selecciona Abrir en el menú Archivo, se llama al método de controlador de eventos FileMenuOpen_click. Las tres primeras líneas de código de este método crean un objeto OpenFileDialog y establecen los filtros y las extensiones que utilizará el cuadro de diálogo.
Aunque estas líneas, en este caso, están codificadas manualmente, se puede obtener el mismo resultado con el Diseñador de formularios, agregando un objeto OpenFileDialog al formulario y estableciendo sus propiedades (después, el código de inicialización se coloca en el método initForm).
Por último, se llama al método OpenFileDialog.showDialog para abrir el cuadro de diálogo.
Cuando se cierra el cuadro de diálogo, este método devuelve un entero equivalente a DialogResult.OK, si el usuario hace clic en el botón Aceptar, o DialogResult.Cancel, si el usuario hace clic en el botón Cancelar.
Si hace clic en Aceptar, se recupera el nombre del archivo del objeto OpenFileDialog y se pasa el mismo al método File.open; éste a su vez devuelve una secuencia File que se abre en el archivo como acceso de lectura/escritura para el archivo.
File.open es una utilidad que realiza la misma función que crear un objeto File con el constructor siguiente:
File(fileName, File.OPEN, FileAccess.READWRITE, FileShare.NONE);
PARADIGMA HUMANO
La mejor forma de hacer buenos a los niños...
..es hacerlos felices...!!!
PAQUETES WFC
Los fundamentos de WFC son Windows y HTML dinámico. WFC está firmemente anclado en el modelo de programación de Windows Win32, y permite usar Java para escribir aplicaciones basadas en Windows que aprovechan las ventajas de controles, eventos y sistemas de servicios de Windows.
También está fuertemente relacionado con el modelo de objetos de HTML dinámico, que permite crear páginas HTML de cliente y de servidor con las funciones de HTML dinámico directamente desde Java.
En el núcleo de estas tecnologías se encuentran las bibliotecas de vínculos dinámicos (archivos DLL) que proporcionan la API principal del marco de programación WFC.
Estas bibliotecas están disponibles en el lenguaje Java gracias a dos tecnologías diferente: la herramienta JActiveX y J/Direct.
Si el archivo representa un componente COM/ActiveX, JActiveX crea clases contenedoras que asignan los objetos COM a objetos Java. Si no está basado en COM, se utiliza J/Direct para llamar directamente al archivo DLL y dirigir la conversión de tipos de datos entre Java y el lenguaje nativo de la DLL (como C o C++).
Ambas tecnologías aprovechan las funciones incorporadas y la sinergia entre el compilador JVC y la Máquina virtual de Java de Microsoft.
Es importante conocer todo ello, porque varios paquetes de WFC se componen por entero de clases contenedoras COM (generadas por JActiveX) o clases J/Direct.
Estas clases contienen métodos que se corresponden directamente con la API subyacente; no están documentadas en la Referencia de WFC porque no se suele llamar directamente a ellas.
Sin embargo, se comentan como clases de apoyo para otros paquetes.
Sin incluir los paquetes de funciones API nativas, hay siete paquetes principales en WFC:
PAQUETES WFC
- Com.ms.wfc.app
Clases base que encapsulan las operaciones de las aplicaciones de Windows.
La plantilla de componentes de formulario de Visual J++ usa los servicios de esta clase.
Además de la estructura básica de manejo de mensajes de Windows, hay compatibilidad con características como el Portapapeles, el Registro, subprocesos, identificadores (handle) de ventana, información del sistema, etc.
- Com.ms.wfc.core
Clases base del modelo de componente.
Este paquete incluye compatibilidad con contenedores, eventos, excepciones, propiedades y la infraestructura necesaria para la interacción con funciones de Visual J++, como el Diseñador de formularios.
- Com.ms.wfc.data
Las clases Java de Objetos de datos ActiveX (ADO) que permiten el acceso a datos y el enlace de datos.
Este paquete también incluyecom.ms.wfc.data.ui, que proporciona las clases base para los controles con enlace a datos de WFC.
- Com.ms.wfc.html
Las clases utilizadas para implementar HTML dinámico en Java.
Estas clases proporcionan funciones de cliente y de servidor.
- Com.ms.wfc.io
Las clases utilizadas para obtener acceso a secuencias de datos, implementando un paquete completo para la lectura y escritura de secuencias en serie, para el acceso a archivos y para la asignación entre los diversos tipos de secuencias de datos.
- Com.ms.wfc.ui
Clases principales (clases core) de los controles suministrados con WFC.
También proporcionan acceso a la API de gráficos de Windows.
- Com.ms.wfc.util
Clases de utilidades para varias formas de ordenación, implementación de tablas hash, etc.
Clases de compatibilidad con interfaces API nativas de WFC
- com.ms.wfc.ax
Proporciona clases contenedoras de Java para las interfaces ActiveX.
- com.ms.wfc.html.om
Proporciona clases contenedoras de Java para el modelo de objetos de HTML dinámico.
- com.ms.wfc.ole32
Proporciona clases contenedoras de Java para los servicios OLE.
- com.ms.wfc.win32
Proporciona clases contenedoras de Java para la API de Win32.