cenidet · basadas en un framework para la representaci~n de informaci~n’~~ tesi s maestro en ciencias de la computaci~n que como requisito para obtener el grado de: p r e s e n

- - ’- - ----- ,----

SElT DGlT SEP / /

CENTRO NACIONAL DE INVESTIGACIÓN Y DESARROLLO TECNOLÓGICO

cenidet “CONSTRUCCIÓN DE INTERFACES GRÁFICAS

BASADAS EN UN FRAMEWORK PARA LA REPRESENTACI~N DE INFORMACI~N’~~

T E S I S

MAESTRO EN CIENCIAS DE LA COMPUTACI~N

Q U E COMO R E Q U I S I T O PARA OBTENER EL GRADO DE:

P R E S E N TA: LORENZO ZAMBRANO CALGADO

DIRECTOR(S) DE TESIS RENE SANTAOLAYA SALGADO FRANCISCO V.VIDAL LORANDI VkTOR M V.VIDAL LORANDI

CUERNAVACA MOR. MAYO~DE 1998

SISTEMA NACIONAL DE INSTITUTOS TECNOL~GICOS

U D SQP- Centro Nacional de Investigación y Desarrollo Tecnológico

FORMA A3 REVISION DE TESIS

REV. 04/98

Cuernavaca, Morelos a 30 de abril de 1998

Dr. Javier Ortiz Hernández Presidente de la Academia de Ciencias Computacionales Presente

Nos es grato comunicarie, que conforme a los lineamientos para la obtención del grado de Maestro en Ciencias de la Computación de este Centro, y después de haber sometido a revisión académica la tesis denominada: "Construcción de Interfaces Gráficas Basadas en un Framework para la Representación de Información", y habiendo cum"plido con todas las correcciones que le fueron indicadas, acordamos no tener objeción para que se le conceda la autorización de impresión de la tesis.

Sin otro particular, quedamos de usted.

f----\., Atentamente

M. a

M.C. René Cantaolaya Calgado

a

ccp Dr. Javier Ortiz HernándezlJefe del Departamento de Ciencias Computacionales

o. O. I . T. . ,

+--o%-- & 4 w w - ..:

Institutos Tecnológicos

Wcnsstb 50 años de educación superior tecnológica en México ..

APARTADO POSTAL 5.164, CP 62051. CUERNAVACA. MOR. MCXICO. TELS. (75112 2314.12 7613, FA% (73) 12 2434. EMAIL: Cenidell@inlorei n e m x

SISTEMA NACiONAL DE INSTITUTOS TECNOLÓGICOS

Centro Nacional de Investigación y Desarrollo Tecnológico

FORMA A4 AUTORIZACIÓN DE IMPRESIÓN DE TESIS

REV 05/98

Cuernavaca, Morelos a 12 de mayo de 1998

C. Lorenzo Zambrano Salgado Candidato al grado de Maestro en Ciencias En Ciencias de la Computación Presente

Después de haber atendido las indicacior sua idas Dor la Comisión Revisora I la Academia de Ciencias Cornputacionales en relación a su trabajo de tesis: "Construcción de Interfaces Gráficas Basadas en un Framework para la Representación de Información", me es grato comunicarle, que conforme a los lineamientos establecidos para la obtención del grado de Maestro en Ciencias en este Centro, se le concede la autorización paraique proceda con la impresión de su tesis.

Atentam 1 te

Ortiz Hernández de Ciencias Cornputacionaies

.,%

Institutos Tecnológicos 50 años de educación superior tecnológica en México -

U

APARTADO POSTAL 5-IM. CP 62051, CUERNAVACA, MOR. M ~ I C O - T E L C . (73112 2314.12 7613, FAXn3) 12 2434. EMAIL. &ideii@infosel n e m x

A mi muñeca y amada esposa Silvia: Por sus reconfortantes palabras' de aliento y su cariño, en los momentos en que la voluntad declina.

,I

A mis hoos Josafat y David: Con todo mi amor quiero compartir con ustedes, la gran satisfacción de haber culminado mi tesis.

A mis hermanos (Celso, Leobigílda, J.Concepción y Filiberto): Con quienes quiero compartir este logro tan importante en mi vida.

A mis Padres (Raque1 y Victoríno ) $3 Quienes viven dentro de mi.

AGRADECIMIENTOS

AI Dr. Francisco V.vidal L. y al Dr. Victor V.vidal L. Por su amistad ilimitada, su asesoría y apoyo para la realización de esta tesis. Quiero compartir con ellos este gran logro.

AI M.C. René Santaolaya S. Quien me a brindado su amistad y tuvo la paciencia de supervisar y dirigir esta tesis.

A mis Compañeros y Amigos. A quienes les debo muchas enseñanzas tanto de la vida como de la profesión, me han apoyado en los momentos difíciles y han sabido darme consejos cuando lo he necesitado. A ellos muchas, gracias por su sincera amistad.

AI instituto de Investigaciones Eléctricas (IIE) Por su apoyo económico y por el uso de sus instalaciones, durante el desarrollo de este trabajo, especialmente al Grupo1 de Estudios Oceanográf ¡cos (G EO).

AI Centro Nacional de Investigación y Desarrollo ,! Tecnológico (C E N I DET) Por su apoyo económico brindado durante la realización de esta tesis y por mi formación académica.

Ai Instituto Politécnico Nacional (IPN) Por darme la oportunidad de continuar formándome en el ambiente docente y de investigación, especialmente a la Dirección de Estudios de Posgrado e Investigación.

............ .- .

íNDlCE

Capítulo 1 INTRODUCCI~N

I 1.1 Antecedentes ...................................................................................... 1 1.2 Proposicion del Problema ................................................................... 3

1.3 Estructura de la Tesis ......................................................................... 4

. . .

Capítulo 2 PLANTEAMIENTO Y ANÁLISIS DEL PROBLEMA

2.1. Antecedentes .................................................................................... 2.2. Planteamiento del Problema ............................................................. 2.3. Planteamiento de Objetivos .............................................................. 2.4. Definición de Requerimientos ................ ........................................ 2.5. Principios de Diseio de Interfaces Gráficas ......................................

2.5.1. Factores que Influyen en el Diseño de Diálogos ............... 2.5.2. Especificación de Color ...................................... ...............

2.5.3. Multiples Ventanas .............................................................. 2.5.4. La Importancia de los Iconos .............................................

................... 2.5.5. Manipulación Dinámica .......................... 2.6. Filosofía de la Programación Orientada a Objetos 2.7. Definición de Herramientas de Programación ......

2.7.1 . Requerimientos de Software .............................................. 2.7.2. Requerimientso de Hardware ............................. : ...............

6

6

9

10

10 12

13 13

14

15

15 17

18 18

I 8 ...... _.__ - - .................. ~- . . .

Capítulo 3

DISENO DEL SISTEMA

3.1. Objetivo del Sistema ....................................................................... 20 3.2. Modelo Conceptual ......................................................................... 20 3.3. Descripción y Diseño Conceptual del Sistema ................................. 22 3.4. Diseño Funcional o Semántico .............................................. ; ......... 25

il

Capítulo 4

IMPLEMENTACIÓN DEL SISTEMA

4.1. Introducción ..................................................................................... 4.2. Programación Orientada a Objetos .................................................. 4.3. Ventajas de Windows sobre DOS .................................................. 4.4. Obtención de Mensajes ................................................................... 4.5. Componentes de una Aplicación Windows ...................................... 4.6. Módulos de Archivos Utilizados en la Programación Windows ........

4.6.1. Archivo de Definición del Módulo (.DEF) ........................... 4.6.2. Archivo de Cabecera (#include) ................................. '! ...... 4.6.3. Archivo de Especificación de Recursos (.RC) ...................

4.8. Convenciones para Dibujar ............................................................... 4.9. Herramientas de Trazo ...................................................................... 4.10. Descripción del Programa Principal de Dibujo ................................ 4.1 1 . Uso de Objetos Gráficos ................................................................. 4.12. Manejo de Objetos Gráficos ............................................................ 4.1 3 . Dibujo de Objetos ............ : ........................................................ :

4.7. Creación de Herramientas Interactivas de Dibujo .............................

I

I ......

33 33 34 35 36 37 37 37 38 40 42 43 45

46 48 50

4.14. Selección de un Objeto __ .____ . ... . .... ... . ....__.. ._...__. .__. . .... , ,.._.. . . ___ 1/ ._.... .. 4.1 5. Borrado de Objetos ........................ ........ ........ ..... .......__. ._... ....,.. , .___ .

4.16. Uso de Mensajes Definidos por el Usuario ...................................... 4.1 7. Rotación de Objetos .__.......... .... ............ . ..................... . __ 4.1 8. Cambios de Orden del Dibujo .......... ............. ........ ..... .... 4.19. Movimiento de Objetos .................................................................. 4.20. Cambio de Tamaño de un Objeto .................................................. 4.21. Cambio de Forma de Objetos ........................................................ 4.22. Copiar y Pegar Objetos .................................................................. 4.23. Formación del Ambiente Gráfico del SlCOlG .......................... ;

4.24. Ambiente de un Menú .......................................................................

I,

1,

!)

' I

4.25. Guardar Archivos Objetos ................................................... .... 4.26. Caja de Diálogo para Abrir Archivos ...................................... .<: .___ .

4.27. Barridos y Enfocamientos (Zoom and Scrolling) ___.._,,... 4.28. Creación de una Paleta de Colores ................................................. 4.29. Desplegando la Paleta de Colores .......................................... I ....., 4.30. Impresión de Gráficas y Figuras ....................................................

52 53 55

56

57 58 59 60 61 63 66 66 69 70 71 73 74

Capítulo 5

PRUEBAS Y RESULTADOS

5.1. Introducción ..................................................................................... 76 5.2. Plan de Pruebas ............................................................................... 76 5.3. Procedimiento de Pruebas ................................................................. 77

Caso Numero 1 :I 77 Despliegue del menú de la interfaz del SICOIG ...................... .... Caso número 2 79

Diseño gráfico por medio de herramientas base __...._...__...._,... ;,

... Ill

~ ~ - - - - ...... ..

Caso número 3 80

Despliegue y diseño de una grdfica ........................................... Caso número 4 82

Despliegue y diseño de un histograma ....................................... Caso número 5 83

Incrustación de diferentes tipos de gráficas ....................... !'......

Capítulo 6

CONCLUSIONES

6.1. Antecedentes ......................................................................... \ ......... 85

6.2. Beneficios ........................................................................................ 86

6.3. Alcances Logrados ........................................................................... 86 6.4. Mejoras y Ampliaciones a este Trabajo ............................................ 88

. . ,!

i,

Apéndice A Caracterización de la Información Utilizada Perfiles de Playeros ....................................................................... 89

Orientada a Objetos ........................................................................ 92 Apéndice 6 Glosario de Términos Usados en la Programación

Apéndice C Técnica de Modelado de Objetos (OMT) ........................................ Apéndice D Diagramas de Jerarquía y Herencia de las Clases OWL ................. Apéndice E Programa de Cabecera DRA WTOOL. H ...........................................

96 1 o1

I 16

1

I

Abreviaturas ........................................................................................... ;... ........ 122 Bibliografía ......................................................................................................... 123

!'

iV

Introducción

Capítulo 1

1.1 Antecedentes !I

Todos 10s días de nuestra vida y desde el momento en que abrimos 10s ojos al despertar, experimentamos un proceso realmente sorprendente: vemos e identificamos mediante imágenes los objetos del mundo que nos rodea a través de la óptica de nuestros ojos y así en todos los aspectos de la vida cotidiana, el ser humano siempre está en continua percepción visual con imágenes "de objetos para interpretar y explicar el sentido de lo que observa logrando con esto proporcionarse mejores condiciones ambientales de vida"]. En el trabajo y en la, industria, para aumentar el rendimiento de los trabajadores, se busca la manera de proporcionar las mejores condiciones ambientales tales como ventilación, iluminación, posición de operación, las relaciones interpersonales, etc., y así podríamos mencionar muchos otros aspectos en donde intervienen de manera preponderante la calidad de trabajo y de vida de las personas. De tal suerte que no cabe la menor duda de que cada día que pasa se le da más valor a los factores humanos. El desarrollo ';ie las ciencias computacionales no escapa a estas importantes consideraciones, porj!ejemplo en los hogares y/o trabajos en donde se utilizan computadoras con sistemas computacionales para procesar y analizar información, las personas p'asan cada vez mayor parte de su tiempo frente a las pantallas de sus computadoras por lo que actualmente se hacen grandes esfuerzos por investigadores del área,'en desarrollar sistemas de interacción cada vez más amigables y dinámicos, para que el ser humano pueda desarrollar mejor las tareas de trabajo asignadas e interactuar con las computadoras en una forma más óptima (ver figura 1 . I ) .

Figura 1.1 La importancia de la percepción visual en nuestra vida cotidiana así como sus aplicaciones en sistemas computacionales modernos.

1

introducción

las ciencias aplicadas y específicamente en el procesamiento de una de las aplicaciones complejas que se presentan son' las formas de presentaciones gráficas de grandes volúmenes de informaCiÓn para SU interpretación y análisis, Como es de suponerse 10s usuarios que procesan esta información no necesariamente son expertos en computación, por tal motivo, es importante que estos usuarios utilicen interfaces gráficas computacionales "con herramientas adecuadas para el desarrollo de sus tareas de trabajo asignadas. En la actualidad los sistemas computacionales responden únicamente a lo que en el diseiio de interfaces de denomina "manipulación directaJfz1. Es decir nada sucede mientras no haya una persona que dé ordenes desde un teclado, un ratón o'iuna pantalla táctil. Por lo que en los sistemas computacionales futuros a desarrollarse se pretende que estos puedan ser utilizados eficazmente por usuarios inexperto: de tal manera de que la manipulación directa pueda ceder el paso a ciertas fo'rmas de actuación delegadas por el usuario de una forma simple.

It

!*

En los sistemas de computación modernos se ha estimado que la interfaz hombre-máquina es un medio de comunicación muy importante, puesto que representa la cara que el sistema da al usuario, y de aquí la aceptación o rechazo en su conjunto por los usuarios potenciales. Dada su importancia, el desarrollo de interfaces hombre-máquina en dichos sistemas muchas veces resultan más costosos que el mismo sistema de aplicación, por esta razón el trabajo 'de investigadores y desarrolladores en esta línea se orientan hacia la construcción de sistemas interactivos dinámicos hombre-máquina que tiene como objeto reducir los tiempos de desarrollo y por consiguiente los costos de éstos.

Dentro de las ciencias de la computación, y específicamente en el ambiente de ComPutaCiÓn gráfica existen áreas en las que se requiere!& la aplicación de lenguajes de ProWmaCiÓn orientados a objetos así corno .de la investigación ComPutacional para el desarrollo de sistemas, herramientas y &todos de software que Sean más eficientes'31, con el objeto de que los usuarios ,de computadoras a través de las interfaces hombre-máquina tengan más versati&d en aplicaciones ingenieriles, administrativas y científicas que ellos realicen.

Este trabajo de tesis se orientó hacia la aportación de unirsistema constructor de interfaces gráficas basadas en un framework para la, representación de información aplicable en ambiente Windows mediante una interfaz gráfica de usuario que permita representar diferentes tipos de gráficas, a través de la implementación de una metodología de graficado, utilizando los paradigmas de programación orientado a objetos, de tal manera de que el usuario pueda haier sus adaptaciones de tipos de gráficas de una forma simple, apegándose a ;,dicha metodología. Específicamente esta metodología se aplicará al análisis de presentaciones gráficas de Bases de Datos Topográficos de Perfiles Playeros, ver apéndice A.

2 i!

-

Introducción

1.2 Proposición del Problema.

La idea original del desarrollo de esta tesis surge a partiri!de que la Comisión Federal de Electricidad (CFE) y el Grupo de Estudios Oceanográficos (GEO) del Instituto de Investigaciones Eléctricas (IIE) realizan estudios oceanográficos y de Ingeniería costera en diferentes sitios del territorio nacional[41 con el propósito de caracterizar y definir la variabilidad de los fenómenos hidrodinamicos costeros que pueden afectar el buen funcionamiento y la seguridad de las centrales costeras generadoras de energía eléctrica, tales como nucleares ~ y termoeléctricas. Específicamente se ha determinado la necesidad de realizar, entre otros, estudios de transporte de sedimentos y evolución de playas.

'I

11

':

Los estudios oceanográficos que se realizan para definir la evolución de playas producen una gran cantidad de datos de perfiles playeros que requieren ser almacenados y ordenados para su posterior análisis'51. El probkma que constituye el manejo de esta gran cantidad de información podría evitarse mediante el desarrollo de un sistema computacional gráfico capaz de desplegar conjuntos de datos con valor agregado de acuerdo a los procedimientos dinámicos y !#a los requerimientos especificados por el usuario. Una forma de resolver esto es conformando bases de datos ordenadamente para que facilite manejar de manera rápida . y eficaz la información, automatizando el procesamiento de graficación utilizando un Sistema Computacional Gráfico. )1

Este sistema será de gran utilidad, principalmente ,'en los estudios de prospección ambiental que se realizan en el litoral mexicano con el objeto de identificar sitios geográficos cuyas características sean'' idóneas para el emplazamiento de centrales de potencia costeras así como el desarrollo de centros turísticos, desarrollo de puertos, etc.

I

; I

La utilización de este sistema gráfico facilitará en gran medida conocer la caracterización de construchones de obras ingenieriles costeras y portuarias y ayudara a realizar los estudios de prospección ambiental de u i a manera expedita y económica.

También, se podrá utilizar los recursos de este sistema para el estudio de sedimentación (acumulación de sedimentos y arenas) de las obras de toma y descarga de agua de enfriamiento de centrales de potencia,,^ el equilibrio de las playas cercanas a éstas, que en mayor o menor grado, pueden ser afectadas por la

li operación de las centrales. ,'

3

Introducción

El presente trabajo pretende que la información oceanográfica requerida para el análisis de evolución de playas, sea consultada y analizada a través del sistema constructor de interfaces gráficas y que facilite conocer el comportamiento asociados a la evolución de playas, mediante el procesamiento de representación gráfica, para caracterizar los fenómenos oceanográficos costeros asociados a la evolución de las playas de nuestros litorales.

1.3 Estructura de la Tesis.

Esta tesis está dividida en seis capítulos, los cinco primeros explican el desarrollo del sistema constructor gráfico y el último reseña una síntesis de conclusiones sobre la aplicación y utilidad del sistema así como los desarrollos futuros que se recomienda se realicen, y finalmente se cuenta con cinco apéndices, los cuales se explican brevemente a continuación.

,I

Capitulo 2. Planteamiento y análisis del problema, se describe el planteamiento acerca del origen de este trabajo y el proceso actual de los problemas que se quieren resolver con el desarrollo del ambiente de Interfaces Gráficas de Usuario; se da un resumen de los resultados del análisis que contempla: factores humanos, equipo y las herramientas de Software disponibles 'para el desarrollo de este trabajo; se da un resumen del estudio de los principios más importantes de diseño recomendables en el desarrollo de interfaces gráficas de usuario de los términos utilizados para el desarrollo de este trabajo; y por último se mencionan y describen los requerimientos seleccionados para la aplicación y desarrollo de la interfaz gráfica así como los conceptos elementales de programación orientada a objetos en ambiente Windows

Capitulo 3. Diseño del Sistema, en este capítulo se presenta el diseño preliminar del sistema de construcción de interfaces gráficas y las diferentes entidades que lo conforman como lo es la base de datos que utiliza de entrada y salida, las estructuras que utiliza, las clases de objetos que lo integran, además del diseño detallado de los módulos de clases de objetos.

Capitulo 4 lmplemenfación del Sistema, en este i capítulo se explica detalladamente la filosofía de la programación WINDOWS utilizada para el desarrollo de la interfaz gráfica de usuario así como la funcionalidad de.ilas clases de objetos que manejan las librerías OWL (Object Windows Library) del lenguaje de programación del Borland C++, sus estructuras de ligue din,ámico en las que se basa. Y se explica la metodología que se utilizó para la implementación del sistema.

A

Introducción

Capitulo 5. Pruebas y Resultados, por medio de pantallas se muestran los resultados obtenidos de las diferentes pruebas, realizadas al sistema constructor de interfaces gráficas, explicando el proceso de cada tipo de !I gráfica y los requerimientos cubiertos por cada gráfica.

Capitulo 6. Conclusiones, se explican los resultados obtenidos en el desarrollo de este trabajo de tesis, y los desarrollos futuros que se contemplan para el mejoramiento del Sistema Computacional Gráfico.

Apéndice A. Caracterización de la Información Utilizada en Perfiles Playeros, explicación de la terminología utilizada para describir un perfil de playa y los datos necesarios para recabar esta información.

Apéndice B. Glosario de términos de la Programacion Orientada a Objetos Describe la definición de términos utilizados para el análisis y diseño de la programación orientada a objetos y el paradigma de programación.

Apéndice C. Técnica de Modelado de Objetos (OMT), Anexo Aonde se explica la notación OMT utilizada en el diseño de patrones para desarroll& diagramas de clases de objetos, sus estructuras y la relación entre las clases, !I

Apéndice D. Diagramas de Jerarquía y Herencia de las Clases OWL, Anexo donde se muestra la jerarquía de clases de las librerías OWL del Borland C++, y se explica las clases principales de TWindow, F rame Window y TPrintoh

Apéndice E. Programa de Cabecera DRA WTOOL.H, Programa cabecera donde se define la clase de control de diálogo y del manejo de la ventana de dibujo.

Abreviaturas, Anexo donde se explica las abreviaciones uhizadas en la escritura de texto de este trabajo de tesis.

Bibliografía. Se enumeran los libros y artículos consultados que sirven de apoyo y referencia para la realización de este sistema computacional.

5

Planteamiento y Análisis

Capítulo 2

PLANTEAMIENTO Y ANÁLISIS DEL PROBLEMA

2.1 Antecedentes

La capacidad de almacenar y procesar información de mil maneras ha sido esencial para el progreso de la humanidad. El almacenamiento de la información ha constituido el catalizador de sistemas legales, políticos y sociales de complejidad creciente. También la ciencia moderna está estrechamente vinculada al procesamiento de la información en donde los avances científicos han permitido almacenar, extraer y procesar cada vez más información, produciendo más conocimiento y nuevos progresos. Abriéndose así una nueva era en los últimos decenios debido al surgimiento de la electrónica de semiconductores, principalmente los circuitos integrados, que dieron origen a los microprocesadores y sistemas de control para el mejor funcionamiento de maquinaria y sistemasIG1. Estas y otras muchas ventajas derivan, en buena parte, la capacidad de integrar cada vez mas transistores en una pastilla llamada ”chip” logrando con esto crear un ambiente electrónico complejo pero a la vez ingenioso el cual se ha denominado como HARDWARE, y con este se inicia el desarrollo de computadoras inteligentes que han transformado el mundo empresarial. AI nacer este nuevo ambiente electrónico llamado hardware, también nacen paralelamente los lenguajes formales de programación denominados SOFTWARE y es este, el que se utiliza para programar los “chips”, de las computadoras, cuyo propósito es desarrollar aGbientes y sistemas de programación más eficientes y dinámicos, facilitando un mejor uso de las computadoras por los usuarios.

I/

’/

2.2 Planteamiento del Problema

Actualmente gran parte de la comunidad oceanográfica mexicana no cuenta con la infraestructura computacional necesaria para realizar el procesamiento y el análisis expedito de datos oceanográficos, dentro de los cuales1 se encuentran los datos de perfiles playeros. La disponibilidad de los modelos y algoritmos matemáticos requeridos para este proceso analítico ocurre de una manera disgregada. Generalmente la infraestructura computacional disponible está formada por conjuntos de programas desintegrados que corresponden a cada uno de los

I‘

6 I I

I 1 Planfeamiento y Análisis I

algoritmos matemáticos y que algunos se utilizan para realizar la validación y calidad de los datos[51, otros realizan cálculos matemáticos y estadísticos para obtener parámetros de uso especial, y otlos realizan las representaciones gráficas, en diferentes fases del procesamiento de los datos (figura 2.1). Esta forma de procesar la información depende mucho de la experiencia de los usuarios "y programadores, por lo que en la fase de representación gráfica se han detectado las necesidades siguientes: contar con una interfaz gráfica dinámica para la presentación gráfica de información, eliminar la necesidad de un experto que realice ':el procesamiento gráfico, eliminar la duplicidad de esfuerzos en la programación de códigos de graficado, facilitar el mantenimiento de programas a través de ut! módulo ejecutivo que permita realizar el procesamiento gráfico de los datos en forma integral.

Sistema

Figura 2.1. Fases de un Sistema para el Procesamiento de Datos

El sistema propuesto, llamado Construcción de Interfaces Gráficas Basadas en un Framework para la Representación de Información se deriva esencialmente de otro sistema, como se muestra en la figura 2.1, el cual lo conforman tres módulos básicos esenciales por los cuales deben procesar los datos oceanográficos para su análisis cualesquiera, como por ejemplo, datos hidrográficos, datos de oleaje, corrientes marinas, vientos, topográficos, etc. Para concluir el análisis de cada uno de los datos mencionados anteriormente es necesario contar,,con un módulo de representación gráfica para cada caso, de aquí la importancia que tiene el sistema propuesto en este trabajo de tesis cuyo propósito es acoplarlo a otros sistemas que requieran realizar representaciones gráficas.

La aplicación de los ambientes computacionales gráficos para el desarrollo de interfaces de usuario, simplifican aspectos de programación como la edición de ventanas, menús y objetos gráficos, ya que éstos son especificados gráficamente en lugar de tener que escribir código textual en algún lenguaje de programación. Por esta razón la manipulación gráfica es un medio por el cual el usuario puede especificar el componente que desea editar. Existen herramientas comerciales para el desarrollo de sistemas de graficado, pero en algunos casos su utilidad disminuye notablemente cuando se requieren incorporar a otros sistemas para el procesamiento y representación gráfica de información.

I.

I


Las áreas de la computación que constantemente requieren de investigación, 4

y desarrollo de software en ambientes de programación gráfica y dinámica

La Programación Visual. La Computación Gráfica. El Procesamiento de Imágenes. Diseño Asistido Por Computadoras. Desarrollo de Interfaces Gráficas de Usuario

Las herramientas de programación visual y la computación gráfica es una nueva tendencia que surgió a principios de los ~ O ' S ~ ~ ] , apoyándose en la programación orientada a objetos pero aunque existen ambientes de desarrollo orientado a objetos, estos son propietarios y están hechos en algunos casos a la medida de una aplicación en particular18] y en ocasiones limitados a algunos ambientes de programación gráfica visual disponibles. Por esta razón en algunos casos ninguna de estas herramientas satisface los requerimientos de aplicación que puedan adaptarse de manera fácil a otras aplicaciones con diferentes Bases de Datos y a la medida de sus análisis respectivos por los usuarios.

USUARIO

SICOIG SOLUCI~N DE GRAFICADO

Figura. 2.2. Arquitectura del sistema constructor de interfaces gráficas para la representación de información.

8


Dado lo anterior, en esta tesis se desarrolló un sistema de construcción de interfaces gráficas de usuario bajo la plataforma Windows (figura 2.2), que permite las representaciones gráficas de grandes volúmenes de información basado en técnicas de programación gráfica y utilizando el paradigma ' de programación orientada a objetos mediante una metodología de graficado, cuya aplicación pueda hacerse o adaptarse fácilmente a varias aplicaciones ingenieriles, Científicas, Sociales y Administrativas.

2.3 planteamiento de Objetivos

El objetivo general de esta tesis es el desarrollo de "un sistema de construcción de interfaces gráficas que permita representar diferentes estilos de gráficas para la interpretación de información basadas en un marco de trabajo (Framework) utilizando librerías de clases OWL. Que además este sistema pueda ser incorporado sin problemas a otros sistemas de cómputo que requieran de una intetfaz de graficado de tal manera que se puedan construir ',otros tipos de presentaciones gráficas de manera consistente o que de soporte a 'la construcción de interfaces gráficas de usuario para varias aplicaciones y que opere en computadoras personales bajo el ambiente de programación Windows 3.1 o Windows 95.

Como objetivos específicos, este trabajo de tesis debe cumplir con:

La lnterfaz gráfica utilizará como datos de entrada una Base de Datos topográficos de perfiles playeros que son datos de distancias y elevaciones (alturas) y que debe tener las siguientes características: íntegra, válida y ordenada. Pero también se pueden tener datos de series de tiempo cualesquiera que cumplan con el sistema coordenado X,Y.

El despliegue de Gráficas es en dos dimensiones e iconificación de los estilos de gráficas en una paleta de herramientas gráfica, colocación de texto y la deformación de gráfica por cada gráfica diseñada.

Que la interfaz Gráfica sea desarrollada para ejecutarse e n una PC 486 o Pentiurn 100% compatible con IBM, bajo el ambiente Windows con 16 o 32 bits con sistema operativo DOS y utilizando los paradigmas de Programación Orientada a Objetos (POO) mediante las librerías de clases de objetos OWL (Object Windows Library) del lenguaje programación Borland C++.

9

Planieamienio y Análisis

AI término de esta tesis, se contará con una herramienta de software integrada en clases de objetos gráficos llamada estructura de trabajo permitiendo la implementación interfaces gráficas de usuario y la programación de tipos de gráficas, que puedan ser acopladas a otros sistemas gráficos.

2.4 Definición de Requerimientos

De manera general, el sistema deberá contener las siguientqs características:

Calidad aceptable. Documentación completa Flexible y amigable La implementación de las herramientas de dibujo en clases de objetos deben aprovechar al máximo las posibilidades que ofrecen los modelos de programación de “Abstracción de datos” y ‘Frogramación orientada a objetos”,“ Dadas las características de diseño el sistema estará abierto a otras aplicaciones.

El sistema deberá soportar como producto de salida las siguientes hv5ones:

Herramientas básicas de dibujo como, línea, cuadros, círculos, poligonos, colores, selección de objetos, borrado de objetos, rotación de objetos, etc. Escritura de texto en cualquier posición de la gráfica. Lectura de archivos Gráficos y de datos. Representaciones de gráficas en dos dimensiones. Representaciones de gráficas de histogramas. Representaciones de gráficas de rosas de viento. Iconificación de los tipos de gráficas. Reducción y amplificación de los gráficos (Zoom). Deformación en lo vertical y horizontal de la imagen gráfica. Movimiento total de la posición de la gráfica. Diálogo a través del teclado y del Mouse.

2.5 Principios de Diseño de Interfaces Gráficas

Considerando la tecnología actual para el desarrollo de interfaces gráficas de usuario, que es el tema principal de este trabajo, en la literatura actual de algunas referencias bibliográficas[81 se menciona que para los desarrollos de interfaces se pretende que éstas sean consistentes, fáciles de usar y fáciles de aprender. Entre


otros aspectos importantes están el reuso del software y la adaptación de éstos desarrollos a otras aplicaciones distintas para las que originalmente fueron creados. Sin embargo no existe alguna guía o método que garantice que el software desarrollado cubra completamente estas características que además son exigidas por los usuarios.

'1

El propósito principal para el diseño de interfaces gráficas de usuario es: Incrementar la rapidez, facilidad de aprendizaje y uso, reducir la razón de errores, propiciar el recuerdo de como usar una interfaz y hacerla atractiva para ganar su preferencia.

El éxito para seleccionar y elaborar las representaciones gráficas en pantalla depende de aproximarse lo más posible a las imágenes gráficas operativas que los usuarios quieran representar acerca de los procesos y procedimientos gráficos que deban realizar.

El diseñador de una interfaz de usuario debe seleccionar e incluir las técnicas interactivas y los dispositivos físicos que mejor se ajusten tanto a las características del usuario como a los requerimientos específicos de la tarea a realizar y que minimicen el trabajo requerido por tres tipos de procesos humanos básicos: la percepción visual, la cognición, y la actividad rnotoralQ1.

8 \

La relación entre una tarea a realizar y la técnica aplicada que proporcione mayor ventaja a un usuario es influenciada por la experiencia y el conocimiento mismo del usuario. Un usuario que conoce la aplicación requiere un rango más amplio de facilidades y herramientas más finas y precisas que los usuarios que conocen menos la aplicación y no les interesa obtener un sistema eficaz y preciso. El usuario experimentado tolera mayor sobrecarga mental. También la relación de la tarea a realizar y su más apropiada técnica de interacción se ve influenciada por el dispositivo físico en el que se implementa la tarea. Por lo q%e éste deberá ser seleccionado adecuadamente antes de aplicar la técnica o método de interacción.

No es sencillo que una interfaz sea a la vez fácil de usar ,y fácil de aprender: una forma simple para combinar estos dos aspectos es proporcionando una librería de comandos básicos destinada a usuarios novatos y que todos los comandos o irstrucciones tanto básicos como avanzados se utilicen a través del ratón o del teclado.

En la actualidad las empresas que se dedican al desarrollo de software de sistemas de graficado, constantemente están construyendo herramientas integradas que faciliten los despliegues gráficos para llegar a tener el software apropiado a cada aplicación y las funciones que van a realizar en algún sistema así como los tipos de

.k

1 1


datos que serán usados. Pero sobre estas herramientas integradas de configuración de despliegues, hay mucho que hacer para lograr obtener unas herramientas integradas de uso general o específico.

il

2.5.1 Factores que Influyen en el Diseño de Diálogos:

El diseño correcto de la distribución ubicación y tamaño de los componentes y elementos de las imágenes proyectadas en la pantalla, evita la sobrecarga mental, aumenta la precisión y la velocidad de respuesta del usuario y sobre todo disminuye la frecuencia de errores. /I

No emplear los mismos principios de diseño para imágenes gráficas en las que el usuario dispone de mucho tiempo para observarlas, que para aquellas en las que se propicie tensión nerviosa o que existan presiones . de tiempo. Una recomendación es que no se sobrecarguen las imágenes para que éstas sean simples, precisas y fáciles de interpretar con el objeto de evitar errores.

I

il La forma de presentar información en pantalla debe ser atendiendo las características de la memoria de acceso rápido del usuario, p8r lo tanto la forma de codificación debe ayudarlo a comprender mejor su significado utilizando para tal efecto formas geometricas, alfanumericas, colores iluminación, parpadeo, etc.; sin embargo el abuso de varias formas de codificación disminuye el rendimiento del usuario porque se le obliga a memorizarlos todos.

La tarea del diseñador es conservar las reglas de la interíaz de usuario y el vocabulario tan simple como sea posible, así como usar conceptos del dominio del usuario o que los pueda aprender fácilmente.

11

El lenguaje del diálogo debe ser eficiente y completo, y debe tener reglas de secuencia natural.

Las reglas de secuencia, definen el orden de la sintaxis del lenguaje. Debe tener un número mínimo de casos simples y fáciles de aprender la! simplicidad de las reglas de secuencia, ayudan a minimizar el entrenamiento y le permiten al usuario concentrarse en la aplicación. Las reglas de secuencias complejas introducen distracciones y discontinuidades en los procesos del pensamiento del usuario.

12


O Un lenguaje debe ser extensible. Esta cualidad adicional se le puede hacer al lenguaje del diálogo mediante la definición de nuevbs términos como combinaciones de los ya existentes.

O Una interfaz gráfica debe tener las instrucciones de Deshacer (UNDO) y Retroalimentar (FEEDBACK) ya que estas son dos componentes clave en los diálogos de las interfaces de usuario hombre-máquina.

2.5.2 Especificación de Color:

Es una propiedad que forma parte del graficado, y es la habilidad de especificar el color al ambiente gráfico de una imagen que se despliegue en pantalla. Se recomienda más oportuno dar un conjunto pequeño de colores cuidadosamente seleccionados basados en principios ergonómicos, que proporcionar un conjunto grande y aparentemente más flexible que no esté soportado en tales principios.

2.5.3 Múltiples Ventanas:

La técnica gráfica de definición de ventanas sobre una pantalla, permite al usuario observar múltiples conjuntos de información al, mismo tiempo. Típicamente las ventanas pueden ser manipuladas libremente sobre la pantalla mediante un dispositivo llamado ratón (Mouse). De igual manera pueden ser amplificadas o reducidas (zoom) a un tamaño adecuado y arrastradas alrededor de la pantalla y traslapadas unas sobre otras. Las ventanas son particularmente apropiadas en ambientes computacionales “multitareas””O1, en donde los resultados producidos por varias tareas pueden desplegarse en ventanas separadas simultáneamente. LOS

sistemas de múltiple ventaneo pueden ser aprovechados en:

La descomposición de grandes cantidades de información sobreila pantalla con el uso de traslapes o compresión de ventanas.

Accesar a múltiples fuentes de información. Con una ventana para cada fuente

O Tener control independiente de múltiples programas

Que la información que se vaya a usar en un futuro o en un momento cualquiera, se encuentra contenida y comprimida en un ICONO.

13


Que se puedan hacer múltiples representaciones de la misma tarea. Por ejemplo para diferentes vistas de un mismo objeto.

El tamaño de las ventanas es una restricción del uso de múltiple ventaneo. Si un usuario requiere de un número de ventanas durante cierto tiempo con el fin de ejecutar su tarea eficientemente; y su conjunto de ventanas de trabajo no pueden ser acomodadas en pantalla, entonces el usuario perderá mucho tiempo en buscar las ventanas escondidas por el traslape o en borrar algunas de ellas con el objeto de hacer espacio para colocar las nuevas.

.

2.5.4 La importancia de los Iconos:

En los sistemas computacionales modernos unos símbolos gráficos llamados iconos están teniendo un crecimiento y uso en aplicaciones de interfaces. Estos iconos representan objetos que familiarizan a cosas como: archiveros de oficina, carpetas de cartón, cesto de basura, calculadoras, etc.; que se representan simbólicamente y que tienen por significado alguna acción a ejecutarse y pueden ser seleccionados apuntándolos con algún dispositivo de interacción para tal efecto.

Entre las razones del uso de iconos en interfaces gráficas de usuarios se encuentran:

Los iconos son visualmente más distintivos que un conjunto de palabras que describan al mismo objeto.

Pueden representar mucha información en un espacio reducido.

subjetivamente son más deseables a utilizar por un usuario que el uso del texto.

Un conjunto de ¡conos activos, informan al usuario el estado actual en que encuentra un tipo de gráfica representada en la pantalla,de igual manera señalan los componentes y atributos gráficos que la conforman.

Se ha encontrado que la funcionalidad eficiente de una interfaz basada en menús e ¡conos contra un medio alfanumérico es preferida por la mayoría de los usuarios, porque cuando los iconos son diseñados apropiadamente, parecen más naturales, más fáciles de usar, y aprender, requieren de poca memorización y se reducen los errores. La desventaja principal del uso de ¡conos es qhe requieren que el usuario aprenda y memorice su significado.

14


2.5.5 Manipulación Dinámica:

Es la habilidad para manipular o editar partes o componentes de un dibujo representado en la pantalla de una computadora de un sistema gráfico. El usuario que utilice dicho sistema, es adiestrado para manipular los componentes gráficos como el trasladar, escalar, rotar, enfocar (zoom), duplicar, borrar, etc. La aplicación del concepto de banda elástica también es importante al permitir que el componente gráfico siendo manipulado sea “redibujado” continuamente con cada operación que se realice sobre la gráfica, p’or ejemplo durante una operación de traslación, el componente puede ser arrastrado a través de la pantalla, mientras que para una operación de escalamiento el movimiento de un localizador a lo largo de un mundo escalado producirá cambios continuos en el tamano del objeto sobre el que se opera.

Un aspecto clave de manipulación gráfica es el medio por el cual el usuario puede especificar el componente que desea editar. Una de estas formas se conoce como “segmentación”, en donde el usuario define a los componentes como segmentos, y cada uno de los cuales puede ser manipulado independientemente. Una segunda alternativa se basa en la técnica de “ventaneo’:’ en donde el usuario especifica las esquinas de cualquier rectángulo en la pantalla llamados asideros , y esta área de la superficie de la pantalla pasa a ser el elemento gráfico que se va a manipular, con la técnica de banda elástica la ventana puede ser ampliada o reducida antes de seleccionar el componente gráfico que se desea editar.

I1

2.6 Filosofía de la Programación Orientada a Objetos

La Programación Orientada a Objetos (POO) es una técnica, método, tipo, forma o herramienta de hacer programación de software que ‘hace posible escribir programas compactos y faciles de aplicar basándose en el concepto de objetos, denominándose a esta técnica como paradigma de programación y desde que se empezó a desarrollar esta forma de programar, cada nuevo paradigma para la construcción de software (programación estructurada, CASE, POO) ha sido etiquetada como la solución a la crisis del software. Sin embargo no se ha logrado hacer mella sustancial en esta cola de espera. Es cierto que el servicio que obtenemos del software comercial es mucho mejor que en el pasado, pero sigue siendo exageradamente costoso construir software a la medida de las necesidades de un usuario en particular, ya sea para automatizar proceso; únicos para alguna industria o compañía o para desarrollar sistemas computacionales que permitan realizar procesamiento y análisis de datos cualesquiera, principalmente en el ambiente de presentaciones gráficas.

15


La Programación Orientada a Objetos se basa en el concepto de Objetos O

Clases, la Clase es un nÜevo tipo de dato definido por el usuario que ofrece las ventajas de una estructura especial que permite el acceso a datos específicos y a funciones que también sean miembros de la clase, donde un Objeto o Clase es un módulo especial de programación que contiene datos y procedimientos o funciones. De igual manera la PO0 soporta tipos de Datos Abstractos, Encapsulamiento, Herencia y Polimorfismo[”l (ver apéndice 6)

El objeto clase constituye la base para la PO0 en los lenguajes de programación que lo soporten, por ejemplo una clase en el lenguaje de programación C++ esta compuesta por partes públicas, privadas y protegidas. Este concepto permite a determinadas partes, generalmente a las vaKiables de la clase, a estar ocultas en todas las funciones excepto aquellas que son miembros de la clase.

Las ventajas de usar PO0 desde el punto de vista del concepto de calidad del software se debe considerar que un software hecho con !PO0 sea confiable, reutilizable, y que garantice un mantenimiento eficaz. Cuando se libera un módulo de software se le considera totalmente probado y por lo tanto confiable, su comportamiento está íntegramente descrito en su aplicación, permitiendo la reutilización para hacer desarrollos confiables usando herenkia de jerarquía de clases en su comportamiento. El desarrollo se hace modularmente haciendo uso de las propiedades de encapsulamiento lo que permite hacer “fácilmente cambios funcionales a un módulo programado de software sin que esto repercuta en la totalidad del sistema facilitando su mantenimiento.

Otra ventaja de la PO0 es que desde el punto de vista de facilidades, los lenguajes de PO0 permiten controlar y explorar con’facilidad nuevas tecnologías en lo referente a las interfaces gráficas de usuario, en donde utilizando métodos de software se pueden manipular mejor las aplicaciones mediante imágenes gráficas como lo son los símbolos llamados ¡conos representados en las pantallas. Así como las paletas de herramientas que pueden contener información significativa o compleja para el usuario a través del ambiente de ventanas.

16

Planteamiento y Análisls

2.7 Definición de Herramientas de Programación.

Tomando 'en cuenta las consideraciones para realizar sistemas computacionales con Interfaces Gráficas de Usuario (GUI) que se apoyen en la Programación Orientada a Objetos, al seleccionar el lenguaje de programación para el desarrollo e implementación del sistema de construcción de interfaces gráficas, se determinó usar el lenguaje de programación del Borland C++ debido a que es un lenguaje que contiene Librerías de Objetos para ambientes Windows llamadas OWL (Object Windows Library) las cuales contienen clases de objetos que permiten obtener calidad de software, así como también es posible que se aprovechen las facilidades que ofrece un lenguaje que soporte los paradigmas de programación orientados a objetos en aplicaciones gráficas como se muestra en la figura 2.3.

............ . . . . . . . . . .

. . . . . . . . . . . . . . . . . : . . . . . . . . . . . . . . . . . .

Figura 2.3 Requerimientos de Software para el desarrollo de una lnterfaz Gráfica de Usuario (GUI)

17


2.7.1 Requerimientos de Software

Para el desarrollo del sistema constructor de interfaces graficas se necesitan mínimo las siguientes características de software.

Sistema Operativo 6.2 o superior.

Lenguaje de programación Borland C++ para programar con clases de objetos

Herramienta de Librería de Objetos para Windows OWL (ObjectWihdows Library).

Librerías de Ligue Dinámico (DLL) para el enlace entre la programación de objetos en C++ y la programación Windows.

Ambiente de programación Windows 3.1 o Windows 95.

2.7.2 Requerimientos de Hardware

Se requiere de una computadora personal 486 o Pentium IBM compatible 100% con las siguientes características principales:

AI menos 51 2 Kb de memona convencional. Mínimo requiere de 16 MB de memoria RAM. Disco Duro de 1 GB ( El sistema requiere de al menos 40 MB) Monitor de alta resolución (0.28) Super VGA. Tarjeta aceleradora de video. Coprocesador Matemático. Ratón (Mouse) compatible con Windows.

18

Diseño

Capítulo 3

DISEÑO DEL SISTEMA

3.1 Objetivo del Sistema

El objetivo principal de este proyecto de tesis fue el desarrollar un Sistema para la Construcción de Interfaces Gráficas Basadas en un Framework para la Representación de Información, denominado SlCOlG que permita ai'usuario graficar datos del tipo series de tiempo cualesquiera, y obtener gráficas en dos dimensiones de una forma rápida y sencilla.

3.2 Modelo Conceptual

El modelo conceptual propuesto, está basado en el método de programación orientado a objetos bajo el ambiente de programación WINDOWS. Este arquetipo consta de varias capas programadas modularmente y su representación se muestra en la figura 3.1.

Explicando la figura 3.1 de abajo hacia arriba se muestra que la capa más baja consiste en el hardware que son 10.s componentes electrónicos de los que está compuesta una computadora, éstos son la memoria RAM, la memoria secundaria, el procesador, la tarjeta gráfica, los dispositivos de despliegue y los dispositivos físicos que se asocian a las técnicas de interacción de una computadora. Las capas superiores son de nivel de programación de una computadora que van desde algoritmos de bajo nivel que son los que inciden de manera directa en los componentes electrónicos de la computadora hasta los algoritmos de"más alto nivel que se separan de la arquitectura de una computadora por el software, pero que a la vez se apoyan en la programación de las capas inferiores (hardware).

19

I Diserio I I

v - PROGRAMACIÓN ESTRUCTURADA Y

ALGORITMOS DE BASE

SISTEMA OPERATIVO

HARDWARE

11

Aplicación al

,Usuario

Figura 3.1. Modelo Conceptual del Sistema de Construcción de Interfaces Gráficas para la Representación de información.

La segunda capa consta de los servicios ofrecidos por el sistema operativo y que son utilizados mediante interrupciones a BIOS y a DOS.

La capa de Algoritmos de Base lo conforma un paquete de programas de bajo nivel que permiten el uso de los dispositivos físicos de una computadora, tales como la programación de puertos, memoria de video así como de:futuros y múltiples medios. De igual manera sobre los algoritmos base se apoyan los lenguajes de programación que dieron origen a la metqdología de programacion estructurada y que constituye un nivel y forma de programación ordenada, permitiendo con este

Diseño

desarrollo construir fácilmente algoritmos estructurados más eficientes para las aplicaciones específicas del usuario.

Las capas de Primitivas Gráficas, Configuración de Pantallas y las Técnicas de Interacción son estructuras de trabajo que están embebidas clases de objeto en las librerías de clases de las OWL del Borland C++['*] y son transparentes para el usuario, simplemente el usuario se somete aprender a usar las clases de objetos que realizan las operaciones pertinentes para cada 'aplicación y su estructura. A manera.de información se describe la funcionalidad que tiene cada una de estas capas:

1. La capa de Primitivas Gráficas consta de los algoritmos básicos que ofrecen soporte para representar en pantalla objetos gráficos tales como líneas, polilíneas, polígonos textos; atributos de primitivas tales como anchura de líneas, color, relleno de polígonos, tamaño de letra en tejdo, algoritmos de segmentación gráfica, algoritmos de recorte, algoritmos de manipulación de bloques de bits; algoritmos de banda elástica; algoritmos de animación dinámica.

2. La capa Configuración de Pantailas permite al usuario obseivar múltiples conjuntos de información sobre una pantalla por medio de la manipulación de ventanas. La función de esta capa es la de administrar los espacios de la pantalla para lograr una visibilidad confortable de trabaj6 para el usuario. Como por ejemplo es muy cómodo y fácil para un usuario manipular con el ratón libremente las ventanas sobre la pantalla de s; monitor logrando aumentarlas o disminuirlas a un tamaño adecuado, moviéndolas alrededor de la pantalla y encimadas unas sobre otras.

3. Las Técnicas de Interacción es uno de los elementos mas importantes en el diseño de interfaces interactivas de usuario, dado que estas técnicas son las que se encargan de seleccionar adecuadamente a los dispositivos físicos, por medio de los cuales el usuario realiza sus tareas elementales como por ejemplo programar el ratón y el teclado alfanumérico como dispositivos físicos para interactuar con la aplicación del usuario.

El mecanismo de Control de Diálogo da soporte al diseñador para la construcción de la interfaz gráfica de usuario que incluye la configuración de la estructura de datos de entrada en la pantalla, la asociación de una o más variables de los menús de selección y de los diálogos definidos con la aplicación. Como resultado de la configuración de la interfaz gráfica se tendrá la estructura de datos de las imágenes mostradas en la pantalla ligadas a los menús o iconos de selección, el enlace del

,

21

http://manera.de

Diseño

código del diálogo que opera sobre esta estructura de datos, y en algunos casos en particular se puede generar código textual en algún lenguaje de programación.

La capa del Ambiente de Programación Windows está respaldada por casi todas las capas mencionadas anteriormente'y es quizá la más impohante a la fecha dado que es una herramienta de programación que inició a principios de los años 80's aportando un ambiente de apoyo a los diseñadores de interfaces gráficas de usuario para PC's u otros sistemas. Este ambiente se fundamenta en el éxito del entorno operativo basado en gráficos que son los iconos y proporciona la elección directa de procesos a través de la pantalla, menús desplegables yiJa posibilidad de ejecutar programas específicos para ambiente Windows de PC's de una manera más eficiente. Es este ambiente el que se aplicó para la realización'-de este proyecto de tesis y se explicará con mayor detalle en el capítulo 4.

La capa de Algoritmos de Base y la capa de Primitivas Gráficas, quedan fuera del alcance de este proyecto por lo tanto su detalle funcional no es tratado en el desarrollo de esta tesis porque esto queda implícito al usar:las funciones de programación Windows y las Librerías de ObjectWindow's (OWL) que proporciona el lenguaje de programación Borland C++'l2] y se prestará mayor atención y detalle a la capa del ambiente de programación'Windowc respaldada por los módulos de configuración de pantallas, las técnicas de interacción y el controlador de diálogos mismos que a su vez también están implícitos dentro de'las OWL del C++,

junto con SU habilidad, sólo se sujeta al uso de estas funiiones que están programadas en clases de objetos dentro de las OWL como ;e muestra en los diagramas del apéndice D (ver la figura 3.2).

y al diseñador de interfaces le facilitan el I no programarlas, por lo que el diseñador

La capa de Aplicación al Usuario se refiere a la programación especifica de un sistema a realizar y que dependiendo del nivel de programación que se utilice se puede tener mayor o menor grado de complejidad para realizar un sistema o una aplicación específica así como la eficacia del mismo, esto depende mucho de la magnitud y complejidad del problema a resolver y de la experiencia de los programadores.

3.3 Descripción y Diseño Conceptual del Sistema

La figura 3.2 muestra la intetfaz gráfica de usuario para la representación de información, en ella se definen los conceptos de aplicación a los que debe sujetarse el usuario, es decir se definen los objetos, sus propiedades, las relaciones y operaciones sobre ellos. En los cuales se incluye los siguientes componentes:

\

I

22

Diseño

Paleta de Colores. Consiste de una barra de botones de colores para seleccionar uno o varios de ellos. Esta paleta es utilizada en la edición de atributos de los objetos gráficos desplegados en el área de aplicación del usuario y consta de 16 colores.

Juego de Herramientas. Es una paleta formada de ¡conos de selección para asociar texto y objetos gráficos a las gráficas que se van a diseñar y en el área de aplicación donde se representarán una o más gráficas en particular, estas agrupaciones o asociaciones tienen como objetivo diseñar la gráfica que se quiera formar. La selección de estas herramientas de iconos, entre otras, pueden ser: Trazo de líneas, cuadro o rectángulo vacío, cuadro o rectángulo relleno, circulo vacío, circulo relleno, polígono cerrado, polígono abierto, texto, rotación de objetos, deformación de objetos, borrado de objetos, movimiento atrás o adelante de un objeto, gráficas en dos dimensiones, histogramas, rosas de viento, etc. Con cualquiera de estas herramientas se abrirá un cuadro de diálogo para poder manipular el o los objetos gráficos.

de Interfaces Gráficas

23

Diseno

Area de Aplicación. Es una parte de la pantalla que está destinada para representar y diseñar una gráfica mediante las respuestas de salida de una aplicación. Cada vez que se seleccione del juego de herramientas de dibujo, de la paleta de colores o del menú principal una herramienta o icono de aplicación mediante el ratón y que ésta se arrastre ubicándola en el área de aplicación, se hará la creación de un objeto de clase gráfico. Por lo que esta parte de la pantalla llamada área de aplicación o área

de dibujo está bajo el control del administrador de la pantalla.

Barra de Visualización Gráfica. Es la barra principal de la interfaz gráfica (SICOIG) y está compuesta de cuatro menús, ver figura 3.3, a traves de los cuales el usuario tiene acceso a los archivos de la base de datos gráficos, eligiendo y asociando estos datos al tipo de gráfica que se quiera representar y que además permite realizar las funciones que se describen a continuación:

I Barra de Visualización Gráfica I

Reducir-Vnt Paleta henmts

Borrar todo 100 70

Figura 3.3. Diagrama esquemático de la estructura del SICOIG.

- Archivo. Define y administra el almacenamiento secundario a disco duro, la estructura de directorios donde se organizan los datos y los archivos gráficos ya editados así como imprimir el archivo gráfico.

- Edición. Permite realizar operaciones como copiar, pegar y borrar un objeto gráfico en el área de aplicación.

- Ver. Permite reducir o ampliar la parte de la ventana del área de aplicación para poder visualizar mejor el diseño de una gráfica en particular.

24

Disetio

Merramiéntac. Define los recursos gráficos como la paleta de colores, el juego de herramientas de iconos y la cuadricula de malla. para que aparezcan dentro del área de aplicación o fuera de la ventana como se muestra en la figura 3.3.

3.4 Diseño Funcional o Semantico

En la figura 3.4 se muestra la vista lógica de las clases base que conforman el diseño funcional del SICOIG, se especifica a nivel detalle la funcionalidad de cada estructura de clases de la interfaz, tomando como referencia la terminología usada para especificar diagramas de clases de objetos utilizando el diseño de patrones y su notación formal OMT (Object, Modeling ver el Apéndice C.

. . .. . - - . .

Figura 3.4. Estructuras de clases base que conforman al SlCOlG y la relación que existe entre ellas.

25

Diseño

La notación OMT indica las relaciones e interacciones entre clases Y objetos de tal manera que normalmente se usan tres diferentes notaciones de diagramas que son:

1. Un diagrama de clases que representa clases, su estructura, y las relaciones

2. Un diagrama de objetos que representa una estructura pariicuiar,de objeto al

3. Un diagrama de interacción que muestra el flujo de solicitudes entre objetos.

estáticas entre ellas.

momento de ejecución.

En la figura 3.5, se muestra la clase TPaintContext, que es una clase contenedora a la cual se agregan las clases TDrawingTool que es'la clase base que define los formatos de las herramientas de dibujo y la clase TWindow (OWL) es una clase predefinida en las librerías de OWL de C++ en la cual se m'uestra la jerarquía de esta y sus clases heredadas de la misma.

TDrawln Tool L==I

I

I L L Figura 3.5. Jerarquía de la clase contenedora TPaintContext y las clases

contenidas o agregadas TWindow(0WL) y TDrawingTool.

26

Diseño

TWindowView TMDIClienl

Figura 3.6. Diagrama de clases principales Twindow, TFrameWindow y TPrinout de las librerías OWL del C++ que se ligan con las clases base

que conforman el SICOIG.

La figura 3.6 muestra las clases principales TWindow, TFrameWindow y TPrintout de las OWL del C++ que se utilizan como enlace principal de las clases que conforman al SlCOlG como se vio en la figura 3.4. La clase TWindow es una clase ventana genérica que se utiliza para el diseño de interfaces gráficas y es necesario construirla. Esto se logra creando una instancia de la clase TWindow que normalmente se usa como una clase base para la configuración de pantallas ya que suministra varios comportamientos específicos de ventaneo permitiendo redimensionar y mover dichas ventanas, debido a que contiene el encapsulamiento de varias funciones que controlan el comportamiento de dicho ventaneo, ver apéndice D y figura D.1. La clase TWindow de OWL, es la clase base para todas las clases de ventanas incluyendo a Tírame Window, TControl, TDialog y TMDIChild. La clase Window se encuentra definida en el archivo cabecera WiND0W.H de las librerías de OWL.

21

Diseño

La clase TFrameWindow es una clase derivada de la Clase TWindow Y controla el comportamiento específico de una ventana como un procesamiento de navegación y comandos de teclado para las ventanas del Usuario. Por ejemplo cuando se reactiva una ventana, TFrameWindow es responsable de restablecer un punto central de entrada de la ventana y añade el apoyo al icono seleccionado de la barra de herramientas de dibujo o del menú. TFrameWindow es una clase eslabón concatenable como extensión se muestra en la figura 3.6, y se definida en el archivo de cabecera FRAMEW1N.H de las librerias OWL, ver apéndice D y figura D.1.

La clase TPrintout es una clase derivada de la clase base fStrearnableBase, ver figura 3.6, y representa el documento físico desplegable en la pantalla que se enviará a una impresora, ver apéndice D y figura D.3. Debido a que este tipo de objeto es abstracto no puede ser usado para imprimir nada por si ,mismo, para cada tipo .de documento debe crearse una clase derivada de TPrintout y su función Printpage debe ser incluida. Como ejemplo de este concepto a continuación se muestra como se crea la clase TWindowprintout derivada de fprintout fwestra en la figura 3.7 y se muestra el código de implementaciófi de esta clase,

se

Figura 3.7. Clase TWindowPrintout derivada de la clase TPrintout(0WL).

//Clase WindowPrintout derivada de la clase TPrintout de los objetos OWL 's. class WindowPrintout : public TPrintout ( public:

TDra wing Window * Window; BOOL Scale; TWindowPrintout(const char" title, TDra wing Window* window); void GetDialoglnfo(int& minPage, int& maxPage,

int& selFromPage, int& selToPage) ( minPage = maxPage = selFromPage = selToPage = O;

I void PrintPage(int page, TRect& rect, unsigned flags); void SetBanding(BO0L banding) ( Banding = banding; } BOOL HasPage(int pageNum) (return pageNum == 1; }

I;

28

Diseño

// Función vjflual para ser reconocida por la clase TDrawing Window, ~ jndOwpr jn tout : : JWindowPrintout(C0nst char* title,

TDra wingwindow" window): TPrintoutítitle)

VJNldow = window; Scale = TRUE;

I

I

/ /Se crea la función PrintPage para imprimir la pagina de dibujo void TWindowPrintout::PrintPage(int Ppagina */, TRect& rect, unsigned /'bandera*/)

SIZE oldVExt, oldWExt; int prevMode = ::SetMapMode(*DC, MM-ISOTROPIC); ::SetViewportExtEx(*C, PageSize. cx, PageSize. cy,' &oldVExt); / /La dimesion del dibujo usado en la ventana tiene que ser del tamafio //actual del papel ::SetWindowExtExl*DC, PAPERWD*50+ 1, PAPERHT50t. 1, &oldWExt); ::lntersectClipRect(*DC, O, O, PA PER WD*50+ 1, PAPERHT50+ I); ::DPtoLP(*DC, (POINT *)(&rect), 2); // Temporalmente se tiene que cerrar el cuadro y seleccionar cualquier // Objeto cuando el dibujo se este imprimiendo BOOL oldGridOn = Window->SetGridOn(FALSE); int saveSelectedObj = Windo w->Figures->SetSelectedObj(- 1); Window->Paint(*DC, FALSE, rect); //Imprimir el dibujo //Restituir el objeto seleccionado y colocar el cuadro Window->SetGridOn(oldGridOn); W¡ndow->Figures->SetSelectedObj(sa veSelectedObj); ::Set WindowExtExpC, oldWExt.cx, old WExt.cy, o); ::SetViewportExtEx(*C, oldVExt.cx, oldVExt. cy, o); ::SetMapMode(*DC, prevMode);

I

1

La clase TPrintout se encuentra definida en el archivo de cabecera PR1NTER.H de las librerías de OWL.

Para entender mejor el comportamiento y uso de las clases TWindow, TFrameWindow y TPrintout así como de otras clases mas, ver.el apéndice D donde se muestra la jerarquía de cada una de estas clases así como~las funciones que las integran en sus partes públicas, privadas y protegidas.

29

Diseño

En la figura 3.8 se muestra la clase base TDrawingTool Y la'lerarquía de las clases de objetos gráficos que se derivan de esta clase, por medio de herencia Y polimorfismo. La clase TDrawingTool se considera una clase madre Porque es en esta clase donde se definen las herramientas básicas interactivas de dibujo en clases de objetos como lo son: TTextTool que es la clase única para escribir texto, la clase TiineTool es la que se utiliza para trazar líneas, la clase TRectangleTool que es la que se utiliza para el trazo de cuadros, nótese que esta clase se forma de la clase TLineTool , la clase TPolylineTool que es la que se utiliza para trazar polígonos abiertos, la clase TPoligonTool se utiliza para trazar polígonos cerrados, la clase TEllipseTool se utiliza para trazar círculos y/o elipses rellenos, la clase T€mptyRectang/eTooí se utiliza para trazar rectángulos reiienos, la clase T€mpty€//ipseTool se utiliza para dibujar círculos y/o elipses vacíos, esta clase se forma por herencia de todos los atributos públicos que formeniparte de la clase TDrawingTool, TiineTool, TRectangíeTool y TEllipseTool como "se muestra en la figura 3.8.

La clase TDrawingTool es de vital importancia, pues es en esta clase donde se tendrían que añadir mas herramientas de dibujo como lo veremos en el capítulo 4 que es donde se muestra la implementación de estas y otras herramientas de diseño gráfico.

\

i----i TEmptyEliipseTool

I ---_-.A Figura 3.8. Diagrama de clases que se derivan de la clase base TDrawingTool

30

Diseño

La figura 3.9 muestra otra clase importante llamada TGObject, también es clase madre ya que de esta se derivan las clases objeto de "cada clase de herramienta de dibujo declaradas y formas en la clase TDrawingTool. La clase TDrawingTool y la clase TGObject están íntimamente relacionadas o asociadas por medio del apuntador 'Obj como se muestra en la figura 3.4. Es:decir los objetos de la clase TDrawingTool proporcionan la forma de cómo dibujar ,interactivamente cada objeto en la ventana o área de aplicación así como el lugar para almacenar sus coordenadas, sin embargo es necesario guardar los segmentos de dibujo como lo es la línea, el cuadro, el círculo, el texto y la combinación de cada uno de estos u otras herramientas de dibujo como objetos wáficos de tal manera que el,:usuario al dibujar una figura la pueda seleccionar, mover, redimensionar, cambiar de forma, rotarla, etc.; y esto sólo se logra asociando la clase TGObject con la clase TDrawingTool, de aquí que para cada segmento de dibujo construido en la clase TDrawingTool como por ejemplo TLineTool habrá un TLineObj declarado en la clase base TGObject, y así sucesivamente para cada objeto de dibujo, ver la asociación de objetos de las figuras 3.8 y 3.9, en la figura 3.4.

rJ TGobject h t 4 '

v

i

- Figura 3.9. Diagrama de clases que se derivan de la clase base TGObject.

La clase TObjectList es la clase que se usa para guardar las figuras o gráficas diseiiadas en la pantalla cuando se dibujan en el área de aplicación o ventana de dibujo. Esta clase se enlaza o se agrega a las clases TGObject, TDrawingWinúow , TPaintContext y TOODrawWindow como se muestra en la figura 3.10. La clase TGObjectList es básica para guardar, almacenar e imprimir las figuras, es decir es una lista de clase nodo, donde el nodo incluye todos los atributos y segmentos gráficos heredados de las clases TGObject, TDrawingWindow,

31

Diseño

TPajntContext y TOODrawWindow. Estas clases se explicarán más detalladamente en el capítulo 4

La clase TDrawingWindow es una clase heredada de la clase TWindow y podemos decir que esta clase es la más importante de todas, ya que es la que controla y maneja todas las funciones como son: Las de control de diálogo, las de contexto, las herramientas de dibujo, la paleta de colores, las de con:trol de ventaneo y las funciones de impresión, ver detalladamente la figura 3.4. Por ,ejemplo la clase TDrawingWindow controla el movimiento del ratón, el teclado, las deformaciones de una ventana, la iconificación de la ventana, los barridos horizontales y verticales de la ventana y el enfocamiento (zooms) de una figura, etc., para mayor entendimiento de esta clase ver el apéndice E, donde se muestra la declaración 'de esta clase en código de programación C++.

De igual manera la paleta de colores que es la clase TColorPallete y la paleta de herramientas de dibujo que es la clase TToolsPalette son clases derivadas de la clase TFrarneWindow de las OWL. Estas clases se explican y se describen detalladamente en la implementación del código programadas en el capítulo 4 correspondiente a estas clases.

TPainlConlexf

4'OWLWindow

*'Toolpaletie 4'ColorPaiette +'DrawingWindow

*'Tool *'Figures

Figura 3.10. Diagrama de clases que se agrupan de la clase TGObjectList

32

Implementación

Capítulo 4

IMPLEMENTACIÓN DEL SISTEMA

4.1. Introducción

La Programación Windows es un ambiente Operativo que funciona con DOS. Es un entorno de Ventanas y multitarea basado en gráficos. Todos los programas escritos específicamente para Windows poseen una apariencia :,consistente y una estructura de Órdenes que posibilita el dominio más fácil de las nuevas aplicaciones de window^"^].

La implementación de la interfaz del SlCOlG se 'elaboró utilizando Programación Windows en la plataforma del ambiente operativo de Windows 3.1 y Windows 95, por ser una herramienta de programación "que cumple con características que son necesarias para el buen funcionamiento $e la interfaz, como el ambiente de menús, ventanas, iconos, cajas de diálogo y muchas otras características de uso amigable que facilitan el manejo y aprendizaje de la interfaz.

4.2. Programación Orientada a Objetos

La programación Windows se basa en una metodología de programación Orientada a Objetos. En la programación orientada a objetos, un objeto es un tipo de dato abstracto que consta de una estructura de datos y de varias funciones que actúan sobre dicha estructura de datos. Los objetos reciben mensajes que pueden hacer que estos modifiquen su estado.

Por ejemplo: un objeto gráfico es una colección de datos que se puede manipular como una entidad única y que se presenta al usuario como parte de la interfaz visual. En particular, un objeto gráfico representa tanto"a los datos como a la representación de los mismos. Algunos ejemplos de objetos g&ficos pueden ser los menúc, las barras de título, los cuadros de control y las barras de desplazamiento.

33

Implerneniación

'4.3. Ventajas de Windows sobre DOS.

Windows tiene muchas aplicaciones que el ambiente DOS no tiene, por esta razón las aplicaciones Windows pueden verse inicialmente más complejas que las aplicaciones standard de DOS. Por estas razones Windows ofrece algunas mejoras adicionales tales como:

El tener una interfaz gráfica de usuario mejorada que incluye, ventanas, menús, cajas de diálogo y controles de aplicación para facilitar su uso. El tener una cola de entrada. El tener independencia de dispositivos gráficos. El tener la capacidad de realizar multitareas. El facilitar el Intercambio de datos entre aplicaciones.

Las aplicaciones Windows interactuan directamente con ,el usuario en un ambiente gráfico basado en la pantalla, el teclado y el Ratón (Mouse).

"Una ventana es un rectángulo que provee una combinación de dispositivos visuales útiles , tales como menús, controles y barras de scroll, en el cual'el usuario controla una aplicación".

Una de las diferencias entre las aplicaciones Windows y las aplicaciones del lenguaje de programación C++ o cualquier otro lenguaje con DOS, es el camino por el cual ellos reciben la entrada del usuario.

'

En una aplicación Windows todas las entradas del teclado, Mouse y timer son interceptados por Windows, quien sitúa la entrada en la cola de mensajes de la aplicación apropiada. Cuando la aplicación está lista para recibir la entrada, ésta simplemente lee la próxima entrada desde la cola de mensajes.

Tales mensajes especifican acciones como el tiempo del sistema, la posición del Mouse, el estado del teclado, la señal de examinación de la tecla (si una tecla fue presionada), el botón del Mouse presionado. Cuando se toma una acción de éstas y entonces el dispositivo genera un mensaje.

Una caja de diálogo es una ventana temporal desplegada por la aplicación, en la que el usuario puede suministrar más información para un comando. Una caja de diálogo contiene uno o más controles.

Un control es una pequeña ventana que tiene una función de entrada y salida muy simple. Por ejemplo, un control de edición es una simple ventana en la cual el

34

Implementación

usuario suministra nombres de archivos, escoge opciones y en algunos casos la acción directa del comando.

4.4. Obtención de Mensajes

El propósito de un mensaje es notificar a un programa que se ha producido un suceso de interés para la aplicación, para una ventana específica dentro de dicha aplicación. Por tanto, todos los mensajes están destinados a una ventana.

Los cuatro parámetros siguientes están asociados a todos los mensajes, independientemente de su tipo.

Un manipulador de ventana (palabra de 16 bits) Un tipo de mensaje (palabra de 16 bits) Un parámetro WORD (palabra de 16 bits) Un parámetro LONG (palabra de 32 bits)

El primer parámetro especificado en un mensaje de ventana es el manipulador de la ventana a la que está dirigida el mensaje. En un entorno de programación orientada a objetos, un manipulador es justamente el identificador de un objeto, que, para la sintaxis actual, es el identificador de una ventana en particular a la que está dirigido el mensaje.

El segundo parámetro de un mensaje es el tipo de mensaje. Este es uno de los identificadores especificados en el archivo de cabecera WIND0WS.H. Con Windows, cada tipo de mensaje se representa mediante un mnemónico de dos caracteres, seguido de un carácter de subrayado y, por Último, un descriptor para completar el mensaje,

El propósito de los dos últimos parámetros, WORD y LONG, es ofrecer información adicional necesaria para interpretar el mensaje. Por tanto el contenido de estos dos Últimos parámetros, variará en función del tipo de mensaje,

Una aplicación puede recibir mensajes del usuario, del mismo Windows , del propio programa de aplicación o de otra aplicación. Dependien'do del estado actual de una aplicación, los mensajes originados por Windows pueden ser atendidos o bien ignorados.

35

Implementución

4.5. Componentes de una Aplicación Windows

o todas las etapas siguientes'"]:

1. Crear WinMain y las funciones de ventana asociadas en C o C++,. 2. Crear las descripcjones de menús y cuadros de diálogo y de otros recursos

3. (Opcional) Usar las herramientas de Windows para crear cursores, matrices de

4. (Opcional) Usar el editor de diálogos que se suministra en las herramientas de

5. Crear todas las definiciones de los módulos y situarlas en el archivo de definición

6. Compilar y enlazar todo el código fuente en lenguaje C/C++ o en VBasic. 7. Compilar el archivo guión de recursos y añadirlo al archivo ejecutable.

La construcción de una aplicación Windows puede suponer pasar por alguno

adicionales, situarlas en un archivo de guión de recursos.

punto e iconos propios.

Windows, para crear cuadros de dialogo.

de módulos.

de Cabecera

c o c++ MACM

de Diaiogos

(Opcional)

BMP DLG

Bibliotecas de tiempo de Ejecución de Cy Windows

l I r

Enlazador T Archivo de

DeIinici6"

de M6duIoS

DEF

ARCHIVO .EXE SW WINDOWS i

Cornpilador

4-l Archivo. .RES

Figura 4.1. Elementos de un programa en Windows

36

Implemeniación

4.6. Módulos de Archivos Utilizados en la Programación Windows.

La programación de aplicaciones Windows está basada en un enfoque multimodular. Se compilan y enlazan una serie de archivos fuente para generar un programa completo denominado ejecutable Windows. Los archivos, necesarios para una aplicación Windows (ver figura. 4.1), son los siguientes:

4.6.1. Archivo de Definición del Módulo (.DEF)

El archivo de definición del módulo DEF, contiene información técnica acerca de la estructura del archivo ejecutable completo. Esta información es utilizada fundamentalmente por el enlazador. Este archivo, describe las características tales como el tamaño de la pila local, el nombre de la función gestora de'rnensajes, etc.

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . / Filename: OWL. DEF

NAME OWL DESCRIPTION 'SICOIG generated by Lorenzo Zambrano S. EXETYPE WIND0 WS CODE PRELOAD MOVEABLE DISCARDABLE DATA PRELOAD MOVEABLE MULTIPLE HEAPSIZE 4096 STACKSIZE 8192 ...........................................................................

/

4.6.2. Archivos Cabecera (.H)

Son archivos de cabecera típicos en los que se incluyen los prototipos de las funciones, con la declaración de la lista de parámetros y valores a devolver por las funciones que constituyen el núcleo de la aplicación. Define también las variables en concordancia, que incluyen las denominadas constantes identificadoras de un menú y que permiten asociar las funciones con elementos específicos del menú. El archivo cabecera lleva la extensión .H. y se incorpora con la instrucción #include.en un programa fuente o cabecera.

37

, Implementación

t, /

/*Nombre del archivo: OODRA W. H /* OODRA W. H da el acceso a los manejadores en todos los módulos de código */ */ /* manejados por el programa principal OODRA W.CPP

#define CM-PRINT 105 #define CM-SELECT 110 #define CM-LINE 113 #define CM-TEXT 114 #define CM-RECT 115 #define CM-EMPTYRECT 116 #define CM-ELLIPSE 11 7 #define CM-EMPTYELLIPSE 118 #define CM-POLYLINE 119 #define CM-POLYGON 120 #define CM-COPY 200 #define CM-PASTE 201 #define CM-DELETE 202 #define CM-DELETEALL 203 #define CM-TOOLPAL 121 #define CM-COLORPAL 122 #define CM-TOBACK 123 #define CM-TOFRONT 124 #define CM-ROTATE 125 #define CM-DUPLICA TE 126 #define CM-GRID 127 #define CM-SNAPTOGRID 128 #define CM-VIEW25 130 #define CM-VIEW50 131 #define CM- VIEW 1 O0 132 #define CM-VIEW200 133 #define CM-VIEWFITINWINDOW 134

4.6.3. Archivo de Especificación de Recursos (.RC)

Utiliza combinaciones de teclado especiales para describir los recursos que la aplicación necesita, como el menú del sistema y sus rnnemónicos del teclado.

.............................................................................

/ */

/* por el programa principal OODRA W.CPP */ #include "windows. h" #include <owl\docvie w. rc> #include cowllprinter.rh>

P OODRA W. RC: Programa de Recursos para ser utilizado

38

Implemeniución

#include <owliprinter. re> #include <owl\except.rcr #include <owl\inputdia.rcz /* Requerido por el objeto TlnputDialog */ #include "oodraw. h"

/*Menus del Programa */ MENU-1 MENU PRELOAD MOVEABLE DISCARDABLE

POPUP "&Archivo"

MENUITEM "&Nuevo': CM-FILENEW MENUITEM "&Abrir ... ", CM-FILEOPEN MENUITEM "&Salvar", CM-FILESAVE MENUITEM "Salvar &como ... It, CM-FILESAVEAS MENUITEM SEPA RATOR MENUITEM "&Imprimir", CM-PRINT MENUITEM SEPARATOR MENUlTEM "S&alir", CM-EXIT

1 POPUP "&Edicion" I MENUITEM "&Copiar", CM-COPY MENUITEM "&Pegar", CM-PASTE MENUITEM SEPARA TOR MENUITEM "&Borrar': CM-DEL ETE MENUITEM "Borrar &Todo", CM-DELETEALL

I POPUP "&Ver" { MENUITEM "&Reducir ventana ", CM- VIEWFITINWINDOW MENUITEM "&25%", CM-VIEW25 MENUITEM "&50%", CM- VIEW50 MENUITEM "&loo%': CM-VIEW100 MENUITEM "&200%': CM-VIEW200

I POPUP "&Herramientas" I MENUITEM "&Paleta Herramientas': CM-TOOLPAL MENUITEM "&Palefa Colores", CM-COLORPAL MENUITEM "&Malla ", CM- GRID MENUITEM "&Snap to grid", CM-SNAPTOGRID

I I

{

I

39

Impkmentación

p lconos usados en /a paleta de herramientas del Programa Pri'Jc;pal: 0ODRAW.CPP */ linetool /CON "line. ic0" emptyrectangle tool /CON recfko rectangletool /CON fillrect. ~ C O emptyellipsetool /CON ellipse. ico ellipsefool /CON fille/li.ico

I polylinetool /CON polyline.ico polygontool /CON polygon.ico pointertool /CON pointer. ico deletetool /CON cut.ico fliptofronttool /CON flipfrnt. ico fliptobacktool /CON flipback. ico savetool ICON cavetoolko readtool ICON readko texttool ¡CON text. ico rota teccwtool IC0 N rotcc w. ico rotatecwtool /CON rotcw.ico beziertool /CON bezier.ico ejestool /CON ejes.ico ~ * ~ ~ . * + t * * t t t * * * t * * * ~ * " * ~ ~ ~ ~ ~ " * ~ ~ ~ ~ ~ ~ ~ " ~ ~ " ~ " ~ " " ~ ~ ~ ~ , ~ ~ " ~ ~ ~ ~ ~ * ~ ~ ~ , ~ ~ ~ ~ * ~ , , ~ ~ ~ ~ ~ * " " ~ ~ " * ~ * * ~ ~ ~ * * /

4.7. Creación de Herramientas Interactivac de Dibujo

Generar y usar herramientas de dibujo interactivas es uno de los elementos de dibujo más importantes que han tenido éxito en el ambiente Windows, principalmente en aplicaciones gráficas de sistemas o programa en particular. Aunque. Windows provee muchos elementos de interfaces de usuario y funciones gráficas el usuario puede tener o estar en su propio ambiente de interacción al dibujar figuras en su monitor con el ratón.

El paquete de herramientas interactivas de dibujo incluye iconos de dibujo, cada icono es implementado como una clase separada como se muestra en la tabla 4.1 y cada una de estas es sucesora común de la clase base TDrawingTool, la jerarquía de cada una de estas clases de objetos se muestra en la figura 4.2. La clase TDrawingTool es la clase madre que controla el flujÓ de información de interacción con el usuario y provee una interface de programación común para realizar otras rutinas o funciones. Todas las herramientas sonsconstruidas desde la clase madre TDrawigTool teniendo todas las ventajas completas de las partes del código programable a traves del Polimosfismo (que es la habilidad de llamar a una función simple y puede tener un comportamiento diferente en otra clase), El código fuente programado para las clases de dibujo están incluidos' en el archivo fuente llamado 0ODRAW.CPP y en el archivo de cabecera DRAW.H como se listan en el apéndice E.

40

Figura 4.2 Jerarquía de la clase madre TDrawingTool y las clases de herramientas interactivas declaradas en el programa DRAW.H

CLASES DESCRIPCION TDrawingTool TLineTool Trazo de líneas. TRectangleTool Trazo de rectángulos relleno. TEmptyRectangleTool Trazo de rectángulos vacíos. TPolilyneTool Trazo de polígonos abiertos. TPoligonTool TEllipseTool Trazo de elipses rellenas. TEmptyEllipseTool Trazo de elipses vacías. TTextTool

Clase Madre para todas las clases de dibujo interactivas.

Trazo de polígono cerrado y relleno.

Permite la captura de texto. Tabla 4.1. Clases de objetos de dibujo dinámico incluidos en el Programa

DRAW:CPP

41

Implementcición

4.8. Convenciones para Dibujar

Todas las clases de dibujo interactivas como herramientas de dibujo se adhieren a varias convenciones. La primera de ellas es que sólo soportan interacción con el ratón, la segunda es que las herramientas siempre son llamadas por ¡conos en el área de aplicación, La tercera es que el marco de dibujo queilas herramientas pueden usar al trazar una figura se especifica en una clase base llamada TPaintContext. (como se mostró en la figura 3.4 del capítulo 3) La clase TPaintContext esta definida al principio del archivo cabecera DRAW.H como:

//Mantiene /os parametros de/ presente dibujo y el Color especifico 'de 10s //Objetos, rellenar e l color, y COnthUar class TPaintContext { public:

Türa wingToo/* Tool; int Pen Wd; COLORREF PenColor; COLORREF BrushColor; HWNü DrawingWnd; TWindow' OWLWindow; double Zoom; int Offsx, Offsy; int SnapWd, SnapHf; BOOL SnapOn; TPaintContext(); void SetSnapToGrid(int snap Wd, int snapHt); POINT SnapToGrid(POINT& pt); BOOL SetSnapToGridOn(BO0L snapon);

//Apuntador a la herramienta acfua1,seieccionada //Ancho de la pluma // Color de la pluma //Color de la brocha // Ventana para dibujar en / /El objeto de la ventana de dibujo OWL / /El factor de enfocamiento //Compensar las coordenadas del dibujo en ventana //Ancho y Alto "del remarco cuadro de la malla" // Etiqueta del recuadro del marco de la malla

I ;

La clase TPaintContext coloca en un paquete, todos los ajustes comunes de dibujo requeridos para desplegar una figura. En muchos aspectos TPaintContext actúa parecido al contexto de los dispositivos de Windows. Por ejemplo TPaintContext contiene un manejador de estilo de pluma y color de brocha para usarse en el trazo de una figura. En el contexto de pintar también se tiene un factor de enfocamiento (zoom), los cambios de desplazamiento horizontal y vertical y las dimensiones de malla. Además, TPaintContext mantiene Ün apuntador a la herramienta seleccionada actualmente, así como un manejador'y un apuntador para la ventana misma de dibujo. El constructor TPaintContext fija estas variables a varios ambientes por omisión. Los restantes tres miembros controlan los ajustes de la malla.

La clase TPaintContext es usada ampliamente por las herramientas de dibujo y es un elemento necesario de cualquier programa que utiliza estas herramientas.

42

Implemeníación

Una aplicación es responsable de la asignación y el manejo de un.objeto global de TPaintContext, es este objeto el que mantiene los ajustes actuaIes,.de dibujo que se usan para un dibujo nuevo. Sin embargo, cada herramienta posee SU propia copia de un objeto de TPintContext, la cual especifica el color del objeto, el estilo de la brocha y así sucesivamente. Inicialmente, estos parámetros internos de dibujo se asignan a los valores en el objeto global de TPaintContext

4.9. Herramientas de Trazo

~1 programa DRAW.CPP contiene la jerarquía de las clases dinámicas de dibujo en las cuales se encuentra programada la clase madre TDrawingTool en código de programación C++, donde se define el esqueleto básico de las herramientas de dibujo que a continuación se muestra.

//Clase madre o base que define el esqueleto básico de las herramientas de dibujo. class TDrawingTool í public:

POINT Pt 1, Pt2; TPaintContext* PC; HDC hDC; HPEN hfen; HBRUSH hBrush; HCURSOR hCursor; virtual void Selecf(TPaintContext pc); virtual void Deselect() I} // Inicia los procesos interactivos del dibujo virtual BOOL LButtonDown(POINT& pt); // Trazos interactivos de dibujo. virtual void MouseMove(POINT& pt); virtual BOOL LButtonUp(POINT& pt); virtual BOOL RButtonDown(POINT& pt) { return LButtonUp(pt); } virtual void Start() { Show(hDC, PC->Zoom, PC->Offsx, PC-POffsy); ) virtual void Finish(); virtual void Show(HDC, double zoom, int offsx=O, int offsy=o) í}4 virtual HICON Getlcon() return 0; } virtual Void UPdateCursor(POINT& pt) { } virtual void SortPoints(); virtual void SelectCursor(int id);

//Posición actual y última del ratón // Parámetros de dibujo //Despliega dispositivos de contexto / /El estilo de la pluma de dibujo / /El estilo de la brocha / /La herramienta 'del cursor / /La herramienta seleccionada //La herramienta no seleccionada

//Finalización del dibujo

//Despliega los parámetros del marco

// Toma un icono de la herramienta //Coloca el cursor del ratón

I ; La Clase TDrawingTool comienza con las dos variables de instancia Ptl y

Pt2, las cuales conservan la trayectoria de las ubicaciones originales y actuales del ratón. Estas coordenadas especifican donde se desplegará una figura conforme se esté dibujando interactivamente.

43

http://actuaIes,.de

L Implementación

Los componentes hPen y hBrush son los estilos de la pluma y la brocha que se usan mientras se dibuja una figura. (No confundir con los ajustes de la pluma y la brocha definidos en la clase TPaintContext, los cuales se usan para dibujar la figura final). La clase TDrawingTool también contiene un manejador del ,tipo hDC para el contexto de dispositivo de la ventana de dibujo. Finalmente el manejador del cursor que se usa mientras se dibuja la figura es almacenado en el componente de datos hCursor.

FUNCIONES DESCRIPCI~N Deselect Deselecciona una herramienta que ya no es está en uso. Finish Getlcon LButtonDown

LButtonUp

MouseMove

RbuttonDown

Select

Selectcursor

Show Start 3ortPoint

~~

18 Finaliza el trazo de figuras. Regresa el manejador de las herramientas de iconos. Llamado en cuanto el botón izquierdo del ratón es presionado mientras está en la ventana de dibujo. Llamado en cuanto en la ventana de dibujo se recibe un mensaje WM-LBUTTONUP, esta función generalmente finaliza el dibujo interactivamente y ,traza la figura permanentemente en la ventana. Se usa cuando en la ventana de dibujo se recibe un mensaje WM-MOUSEMOVE; actualizando la figura existente trazada. Llamado en cuanto en la ventana de di6ujo se recibe un mensaje WM-RBUTTONDOWN, usada pol las herramientas de polígonos al terminar el proceso de dibujo. Llamado en cuanto inicialmente una" herramienta es seleccionada. Coloca el componente del hCursor en el cursor de ratón para usarse mientras se dibuja. Despliega o muestra la figura en su localización y tamaño. Inicia el dibujo de la figura, Ordena los puntos Pt l y pt2 de tal manera que Pt l este a la izquierda y arriba de Pt2.

JpdateCursor Se usa poi algunas herramientas que cambian el cursor. Tabla 4.2. Funciones y componentes de la clase madre TDrawingTool

incluidos en el programa DRAW:H.

La tabla 4.2. Describe brevemente cada una de las funciones de los componentes de la clase TDrawingTool, estas funciones caen en dos categorias: una es que soportan funciones y la otra es que soportan rutinas actúales de dibujo. Las funciones como el Select, Deselect, Setcursor y Getlcon garantizan que la aplicación use las herramientas propias de icono y cursor. Las funciones restantes son las que en realidad hacen o forman parte de diseño del dibujo donde cada herramienta de dibujo es asignada y manejada por la aplicación principal. A continuación se explican las funciones de código que se implementa en cada una de las herramientas de dibujo de la clase madre TDrawingTool. ,

44

Implementación

4.10. Descripción del Programa Principal de Dibujo

El ambiente de dibujo del programa principal, OODRAW.CPP, se muestra en la figura 4.3, y a continuación se, describen las principales características que lo componen:

Cada figura se salva como un objeto en una lista de objetos.

. Los objetos pueden seleccionarse, moverse, cambiar de tamaño, reordenarse y cambiar su forma.

Se incluye una paleta de colores, la cual se puede utilizar para seleccionar los colores de la pluma y de la brocha.

Los dibujos pueden leerse y escribirse en archivos.

El ambiente proporciona una función para imprimir,

Se dibuja en una superficie “de papel” que puede desplazarse y escalarse.

El ambiente muestra una malla opcional para alineación o como guía de dibujo.

El funcionamiento y desarrollo del CICOIG se maneja mediante cuatro archivos primarios que son:

1. G0BJECT:CPP Proporciona una serie de objetos que se usan para representar

2. GOBJLIST.CPP mantiene una lista de los objetos gráficos.

3. GOBJTOOL.CPP proporciona las herramientas derivadak del DRAW.CPP (listadas en el capítulo 13) que agrega figuras dibujadas a la lista de objetos,

4. 0ODRAW.CPP Proporciona el código para los cuatro elementos principales del ambiente: La paleta de Herramientas, la paleta de colores, la ventana de dibujado y la ventana principal del programa.

cada figura dibujada.

45

: [mplemeniación

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ......................... 16; .... . . . , . . . , , . . . . . , . . . . . . . . . . ....c..- i . . ' 1;

4.1 1. Uso de Objetos Gráficos.

Nuestro programa de dibujado usará objetos para representar cada figura. Específicamente, cada figura de gráficos es almacenada como un objeto derivado de la clase TGOBJECT. El código para TGOBJECT está incluido en G0BJECT.H y GOBJECT.CPP. La tabla 4.3 lista cada una de las funciones en la clase

FUNCIONES DESCRIPCI~N TGObject -TGObjectl UpDateüounds Getüoundsl Display Despliega los objetos. Rotate Rota los objetos. Translate Traslada los objetos. Savel

Uno de dos constructores de la clase TGObject. Destructor de una clase TGObject. Recalcula repetitivamente los límites de los objetos. Regresa los limites de un objeto.

Guarda o salva los objetos.

46

Implemeniación

iasSize

Scale 3ffset DrawHandles DrawResizingObject Resize

ResizeFrame

DUP PtOnResizeHandle

PtOnReshapeHandle

PtOnFrame

PtlnObject

ScaleToRect

Reuresa un valor verdadero si el objeto es' mayor que un 'I

- tamaño mínimo. Escala un objeto. Ajusta la posición de un objeto. Dibuja los asideros alrededor del objeto. Dibuja el objeto conforme se está redimensionando. Redimensiona un objeto para ajustarlo dentro de una región con ciertos límites. Redimensiona un marco de unión de acuerdo al movimiento del asidero. Retorna una copia de un objeto. Regresa un valor verdadero si un punto especificado está sobre un asidero que redimensiona. Regresa un valor VERDADERO si un punto especificado está sobre un asidero que cambia la forma. Regresa un valor VERDADERO si un punto especificado está sobre un marco de unión de un objeto. Regresa un valor VERDADERO si un pUnto especificado está dentro de las uniones de un objeto. Redimensiona el objeto para ajustarlo dentro de una región rectangular.

Reshape Cambia la forma del objeto o mueve uno de sus puntos. Tabla 4.3. Funciones que integran la clase TGObject.

La clase objeto TGObject forma la base para una jerarquía de clases similar a la jerarquía que se usó en las herramientas de dibujado. Por ejemplo el programa GOBJECT.CPP incluye la clase TLineObj, la cual se derival'de TGObject, para representar la información acerca de un segmento de línea. Un ,Objeto específico de TGObject se crea para cada objeto que se dibuja. La información acerca del objeto se copia de la herramienta interactiva que lo dibuja. La jerarquía de clase completa se presenta en la figura 4.4.

41

implementación

Figura 4.4 Jerarquía de clases de Objetos derivadas de la clase base TGObject y declaradas en el programa DRAW.CPP

El propósito de la clase base TGObject es dar a cada clase suficiente información y flexibilidad de manera que se pueda dibujar una figura permitiendo que se seleccione, se mueva, se redimensione y se cambie de forma. Un objeto TGObject no almacena las coordenadas actuales de un objeto si no mas bien contiene un apuntador a la clase TDrawingTool que realiza, estas tareas. Esto quiere decir que se puede colapsar la clase TGObject en la Clase TDrawingTool como se mostró en la figura 3.4 del capitulo 3. La forma adecuada en la que se deben manejar los conceptos de dibujo de estas dos clases es en partes. Los objetos de TDrawingTool proporcionan una forma para dibujar interactivamente cada objeto y un lugar para almacenar sus coordenadas mientras que las clases TGObject extienden estas herramientas para que el usuario pueda mover, redimensionar, y cambiar la forma de los objetos dibujados,

4.12. Manejo de Objetos Gráficos

La clase TGObjList, codificada y se localizada ,en los programas, G0BJLIST.H y GOBJLIST.CPP, contiene la lista de figuras que se diseñan en la ventana de dibujo así como una colección de funciones que manipula esta lista, esta clase se muestra a continuación:

/ GOBJLIST. H: Define una clase que contiene una lista de figuras // #ifndef GOBJLISTH

todas las gráficas de objetos que estén recién dibujadas.

#define GOBJLISTH #include <stdio.h> #include '9object. h ''

48

Implementación

#include "draw. h"

// €1 máximo número de figuras que puedan estar en Un lugar de la escena const int NUMGOBJECTS = 100; //Esta clase es usada para mantener la lista de figuras que //estén actualmente desplegadas en la ventana de dibujo class TGObjList { public:

TGObject' GObjects[NUMGOBJECTS]; //Lista de las gráficas de !as figuras TGObject* CopyBuffer; // Corta y pega un objetos del buffer int NextObj; //Números de gráficas de objetos int SelectedObj; //Seleccionar el presente objeto int PrevSelectedObj; //Seleccionar previamente el objeto TfaintContext* PC; BYTE Dirty; / /Si el dibujo tiene un cambio es verdadero TGObjList(TPaintContext * pc) {

NextObj = O; / /La lista de objetos está vacía SelectedObj = PrevSelectedObj = -1; //Aún No hay un objeto seleccionado.

CopyBuffer = O; Ditty = FALSE;

I - TGObjList(); void DisplayAII(HDC hDC); void Add(TG0bject' Obj); void Delete(); void DeleteAll(); void FlipToBack(); void FlipToFront(); void Rotate(doub1e angle); int Read(FILE* fp); void Save(FILE* fp); void Copy(); BOOL Empty() {return (NextObj == O) ? TRUE : FALSE; } BOOL ObjectSelected() {return (SelectedObj == -1) ? FALSE': TRUE; ] int SetSelectedObj(int selectedObj); void Repaint(int obj, RECT* bounds);

PC = pc; / /La operación pegar,está vacía / /El dibujo de la ventana no ha cambiado

I ; #endif

La tabla 4.4 proporciona una breve explicación de cada función miembro que conforma a la clase TGObjList. El arreglo Gobjects[] en la c'lase, es un arreglo de apuntadores para la clase TGObject la cual mantiene la lista de los objetos gráficos. El tamaño del arreglo se declara lo suficientemente grande para mantener 10s objetos NUMGOBJECT, los cuales se definieron como 100 en G0BJLIS.H. La lista de objetos se declara en la ventana principal del programa; sin embargo, un

49

Implementuclón

apuntador de la lista se comparte con el objeto de la ventana de dibujado. Como se verá más adelante, la función Paint de la ventana de dibujo utiliza la lista de figuras para mostrar lo que está en el dibujo actual.

FUNCIONES DESCRIPCION TGObjList Constructor de la clase TGObjList. -TGObjList Destructor de la clase TGObjList. Add Adiciona o agrega un objeto a la lista. Delete Borra los objetos seleccionados desde la lista.

DisplayAll Despliega todos los objetos que contiene la lista. FlipToBack Mueve el objeto seleccionado debajo de los objetos de la lista. FlipToFront Mueve el objeto seleccionado arriba de los objetos de la lista. Rotate Rota los objetos. Read Lee un archivo desde la lista de objetos. Save Salva o guarda en un archivo la lista de objetos. COPY Copia el objeto seleccionado en un Buffer de Objetos. Empty Regresa un valor VERDADERO si la lista de objetos está vacía. Objectselected Regresa un valor VERDADERO si se selecciona un objeto. SetSelectedObj Obtiene el objeto seleccionado y regresa el objeto previc

selecionado. Repaint Repinta el dibujo que está dentro de una región rectangular.

DeletaAll Borra todos los Objetos de la lista. il

Tabla 4.4. Funciones que integran la clase TGObject

Un objeto gráfico se agrega al arreglo Gobjecfs[] llamando a la función miembro Add. Add simplemente adiciona un objeto TG0bject"pasado dentro de la función al arreglo Gobjecfsl] si es que existe espacio. También Add incrementa la variable NextObj que especifica la siguiente ubicación libre en"el arreglo Gobjecfs[]. Inicialmente, NextObj empieza en cero.

Las restantes funciones miembro en TGObjList También se usan para manipular las figuras gráficas en el arreglo Gobjecfs[]. Estas funciones determinan cuáles objetos se despliegan y en que orden, por ejemplo, hay funciones para borrar, copiar y mover objetos gráficos en la pantalla. Sólo un objeto puede manipularse a la vez. Específicamente, la variable índice SelectedObj en TGObjList apunta al objeto que puede manipularse. Estos componentes se tratarán conforme se discutan los diversos aspectos del programa principal OODRAW .CPP

4.13. Dibujo de Objetos

La ventana de dibujo está definida en la clase TDrawingWindow, que se deriva de la clase madre TWindow de las OWL como se mostró en la figura 3.4 del capítulo 3 y se encuentra programada en el archivo DRAWTOOL.H, a continuación se muestra el código de la clase:

so

Implemeninción

// DRA WTOOL.H: Define una ventana de dibujo para OODRA w. cpp class TDrawingWindow : public TWindow public:

jnt GrjdWd, GridHt; BOOL GridOn; BOOL Dra wingMode; TPaintContext* PC; TGObjList* Figures; int ZoomMode; TGObject' CurrObjTool; / /La presente herramienta de dibujo fue usada char Filename[l28]; TDra wing Window(TWindow* parent, const char* title,

void DrawGrid(HDC hDC); char* GetFilenameo { return Filename; } void SetFilename(char' name) { strcpy(Filename, name); } int SaveDra wing(char* filename); void Paint(TDC& dc, BOOL, TRect&); void EvL Button Do wn (UIPJT, TPoint&); void EvLButtonUp(UINT, TPoint&); void EvMouseMove(UINT, TPoint&); void EvRBuffonDown(UINT, TPoint&); BOOL EvSetCursor(HWND h WndCursor, UlNT hitTest, UlNTmouseMsg); int SetZoom(int zoomMode, double userScale=O); BOOL SetGridOn(BO0L gridon); //Las siguientes funciones contestan los mensajes para el usuario: LRESULT EvUDeleteObject(WPARAM, LPARAM); LRESULT EvUDeleteAll(WPARAM, LPA RAM); L RE SUL T EvUFlipToBack( WPA RAM, LPA RA M); LRESULT EvUFlipToFront(WPARAM, LPARAM); L RESUL T EvURotateCCW(WPA RAM, LPA RA M); LRESULT EvURotateCW(WPARAM, LPARAM); LRESULT EvUReadObjList(WPARAM, LPARAM); LRESULT EvUSaveObjList(WPA RA M, L PA RAM); void EvHScroll(U1NT code, UlNT ps, HWND wnd); void EvVScroll(U1NT code, UINTps, HWND wnd);

DECLARE- RESPONSE- TABL E(TDra wing Windo w); 1; #endif

//Ancho y alto del cuadro //Exhibir un cuadro en la ventana

/ /E l modo de acercamiento

/ /E l archivo esta editado

TPaintContext* pc, TGObjList" figures);

La función TDrawingWindow pinta la ventana de dibujo y une los eventos del ratón de la ventana de dibujo con la lista de objetos. La ventana de dibujo, soporta una variedad de características que incluyen una superficie de ,,papel para realizar el dibujo gráfico, una ventana desplazable, capacidad para agrandar y reducir un dibujo (enfocamiento), una malla que silve de guía para realizar el dib,ujo y una opción para activar o desactivar la malla.

51

Implemcntcición

La ventana de dibujo es también el lugar donde los objetos dibujados son adicionados a la lista de objetos. Cuando el usuario termina de dibujar un objeto, tal como cuando se libera el botón derecho del ratón, la información en el objeto TDrawingTool de la herramienta se duplica y se copia a un TGObject. Entonces este objeto se adiciona a la lista de objetos:

//Función del polígono usada para terminar un dibujo void TDrawingWindow::EvRButtonDown(UlNK TPoint& pt) I pt = PC->SnapToGrid(pt); POINT scaledPt; ScalePt(scaledPt, pt, l/PC->Zoom); if (Dra wingMode) { / /E l botón derecho de ratón es usado

TGObject* gObj = CurrObjTool; //para terminar la función del polígono Ora wingMode = gObj->Obi->RButtonDown(scaledPt); if (!DrawingMode) {

/ /Si el dibujo está hecho entonces se agrega a la lista if (gObj->Hassize()) { / /Si el objeto tiene su tamaño adecuado, / /se agrega una copia a la lista de objetos o de figuras TGObject *nuObj = gObj->Dup(); nuObj->Of fset(TPoint((Scro1ler->XPos *Stroller-rXUnit)/PC->Zoom,

nuObj->UpdateBounds(); //Actualiza los limites üel objeto Figures->Add(nuObj);

(Scroller-> YPos *Stroller-> YUnit)/PC-doom));

I I

I I

Este código proporciona una breve descripción de cómo los objetos gráficos son adicionados a la lista de figuras. Posteriormente, se discutirán los mecanismos de la función Dup y los otros componentes.de este código.

4.14. Selección de un Objeto

Para manipular un objeto, primero debe seleccionarse, Para seleccionar un objeto, se apunta con el ratón el icono de flecha de la caja de herramientas. Después presione el botón izquierdo del ratón mientras el ratón está sobre el objeto deseado y aparecerá un marco indicando que el objeto está seleccionado como se muestra en la figura 4.5. Si varios objetos están apiiados, uno en la pardsuperior de otro, haga clic nuevamente en el botón izquierdo del ratón para seleccionar el siguiente objeto de la lista. Para deseleccionar el objeto, haga clic en el ratón dentro de la ventana de dibujado pero fuera de todos los objetos.

52

http://componentes.de

Implementación

La clase TSelectObjTool, proporciona el código para seleccionar un objeto. Su código es un poco complicado debido a que la herramienta de selección también mantiene en código de interacción con el usuario para mover, ilredimensionar, y cambiar la forma de objetos. Más adelante se tratarán estas acciones. Por ahora sólo es importante que el índice de los objetos seleccionados es asignado a la variable SelectedObj en el objeto TGObjList. Si no se selecciona ningún objeto, SelectedObj se fija en - 1 . El código fuente para TSelectObjTool se localiza en el archivo GOBJTOOL.CPP.

Figura 4.5. El objeto seleccionado normalmente es encerrado dentro de los limites de un marco y sus asideros.

4.15. Borrado de Objetos 1

Para borrar un objeto, implica dos pasos: Primero se debe seleccionar el objeto utilizando la herramienta de selección (flecha); después, se debe seleccionar la herramienta de tijeras para borrar el objeto. It

53

Implementación

El código para borrar un objeto está contenido en la~función Delete de TGObjLict. La rutina empieza cerciorándose de que la lista de figuras no esté vacía (debe de existir algo para borrar). Existe un pequeño truco que se podría esperar. El problema es que un objeto seleccionado en realidad no está seleccionado siempre que se selecciona una nueva herramienta; esto es exactamente igual a lo que suceda cuando se escoge la herramienta tijera. Para resolver este problema, el código salva el objeto previamente seleccionado en la variable PrevSelectedObj. Si PrevSelectedObj no es -1 y SelectedObj es -1, entonces mantiene un objeto válido que se considera seleccionado. A continuación se muestra el código de la función Delete que realiza esta verificación:

//Borra el objeto seleccionado desde la lista de objetos. //Actualiza la pantalla después de borrar un objeto de la lista / /A l borrarlo de la ventana de dibujo y rehacer todos los objetos faltantes. void iGObjiist::De/ete() i if (SelecfedObj == - 1 && PrevSelectedObj == - 1) return; //Restablece e l objeto seleccionado, cuando se obtiene un reset después de //Presionar la herramienta de rotación. if (SelectedObj == - 1) SelectedObj = PrevSelectedObj;

Enseguida se salvan las uniones del objeto seleccionado actualmente:

RECT bounds; //Salva los límites de objeto que va a ser borrado CopyRect(&bounds, GObjects[SelectedObj]->GetBounds(FALSE));

Posteriormente en este capítulo se discutirá el código que obliga a Windows a repintar esta área después de que el objeto es eliminado de la lista de figuras. Después, el objeto se borra quitándolo del arreglo GObject y cambiando todos los objetos que siguen hacia debajo de una ubicación índice:

delete(GObjects[SelectedObj]); for (int i=SelectedObj; i<NexfObj- 1; i t+ )

GObjects[i] = GObjects[i+ 11;

La variable NextObj, la cual apunta a la siguiente ubicación del objeto en GObject, se decrementa en 1, Además SelectedObj se fija en -1 indicando que no está seleccionado ningún objeto:

NextObj--; SelectedObj = - 1; //No hay ningún objeto seleccionado

El area donde el objeto estaba localizado, salvada anteriormente en las uniones se inválida de manera que la ventana de dibujado repintará el área:

Didy = TRUE;

54

implementación

Repainf(-l, &bounds); // Remarca Iá ventana donde estuvo el objeto 1

El área que se vuelve a pintar se ajusta a la caja de unión del objeto. Este uso de una caja de unión proporciona una forma eficiente para reducir la cantidad del repintado requerido en la ventana. La función Repaint está incluida en TGObjlist y encapsula el código requerido para escalar apropiadamente y compensan las uniones del objeto cuando el usuario ha deformado el dibujo. La herramienta para borrar es una herramienta de dibujo derivada de la clase TGObject. Sin embargo, su interacción se logra realmente en su objeto anidado de TDrawingTool. Además, la herramienta para borrar toma acciones cuando se llama a la función Select, recordando que Select se invoca tan pronto como se escoge el icono de la herramienta, Por lo tanto, cuando se selecciona el icono de borrar de la paleta de herramientas, en ese momento la función Select, es llamada y la herramienta borra inmediatamente el objeto seleccionado. De igual manera trabajan varias de las otras nuevas herramientas de dibujo.

Otro nuevo aspecto de la herramienta para borrar se muestra en la función Select:

void Select(TPaintContext* pc) { TDra wingTool::Select(pc); //Envía a la ventana de dibujo un mensaje para borrar //los objetos actualmente seleccionados SendMessage(PC->DrawingWnd, WM-UDELETE, O, O);

‘Qué es lo que sucede aquí?. Anteriormente se dijo que las herramientas de dibujo no se enteran para nada a cerca de la lista de objetos. En la herramienta línea, se usó una función del apuntador de la ventana de dibujo para tener acceso a la lista de objetos. Aquí se muestra otro planteamiento. En esta función, se envía a la ventana de dibujo un mensaje definido por el usuario (descrito en la siguiente sección) para borrar el objeto asimismo.

4.16. Uso de Mensajes Definidos por el Usuario

Los mensajes definidos por el usuario proporcionan una forma muy poderosa y flexible para la comunicación entre objetos en una aplicación grande. Para crear un mensaje definido por el usuario se debe definir su propia constante, empezando con WM-USER. Por ejemplo el mensaje de borrar definido por el usuario se especifica en GOBJTO0L.H como:

#define WM-UDELETE (WM-UsER i 7) //Borra un objeto

55

Implementación

La ventana receptora es responsable de atender al mensaje. Por ejemplo; la clase de la ventana de dibujo, TDrawingWindow, Tiene una función de respuestas de mensajes que verifica los mensajes de WM-UNDELETE:

EV- MESSA GE( WM- USER+ 1, EvUDeleteObject),

EL EvUDeleteObject Procesa el mensaje llamando a la función Delete de TGObjList's:

//Borra el objeto actual en la lista de figuras. // Repinta la ventana donde el objeto fue localizado. LRESULT TDrawingWindow::EvUDeleteObject(WPARAM, LPARAM) I

I

Figures->Delete(); return O;

4.1 7. Rotación de Objetos

Existen dos funciones adicionales provistas en el programa OODRAW que permiten girar un objeto alrededor de su centro. Una función gira las líneas y los polígonos 45 grados a la derecha y la otra función gira a la izquierda en incrementos de 45 grados. La rotación de objetos comienza con la función miembro Rotate definida en la clase TGObjLict. Esta función, a su vez llama a la función Rotate del objeto para girarlo asimismo. Para girar la figura, se comienza calculando el centro del objeto:

//Gira un polígono por el valor de un "ángulo" void TPolylineObj::Rotate(double angle) I int num Pts = (( TPolyline Tool *) Obj)-> Num Pts; double 'wfoints = new double[numPts*2]; if (!wPoints) {

MessageBox(GetActive Window(), "Out of Memory", GetApplicationObject()->GetName(), MB-OK I MB-ICONEXCLA MA TION); return;

I UpdateBounds(); double cx = (DevBounds.leít + DevBounds.right) /2.0; double cy = (DevBounds.top + DevBounds.bottom) /2.0;

//Obtener los límites actuales del objeto

La estructura DevBoundc RECT contiene las coordenadas de la caja de unión del objeto. El código llama primero a la función UpdateBoundc del objeto para calcular las uniones de pixeles actuales del objeto y colocarlos dentro de DevBoundc. Posteriormente, el objeto se traslada al origen, se rota y después se

56

Implementación

traslada de regreso. Por ejemplo, la función Rotate de TPolylineObj's realiza estas translaciones usando las siguientes declaraciones:

CopyTo WPoly(((TPolylineToo1 *)Obj)->Poly, numPts, wpoints); WTranslatePoly(wPoints, numPts, -cx, -cy); WRotatePoly(wPoints, numPts, angle); WTranslatePoly(wPoints, numPts, cx, cy); CopyFrom WPoly(wPoints, numPts, ((TPolyline Tool *)Obi)->Poly);

1

La función Rotate declarada en la clase TGObjLict obliga a la ventana de dibujo a repintarse asimisma de manera de que la figura rotada vuelve aparecer. Esto se logra obligando a la ventana de dibujo a repintarse asimisma donde el objeto estaba inicialmente colocado y donde ahora existe. Rotate salva los límites de la figura antes de que se gire.

CopyRect(&beforeBounds, GObjects[SelectedObj]->GetBounds(TRUE));

Después se gira el objeto y se recupera la nueva caja de unión del objeto girado:

GObjects[SelectedObj]-> Rota te(-angle); //Obtiene los limites de la figura reciente que fue rotada CopyRect(&afferBounds, GObjects[SelectedObj]->GetBounds(TRUE)),

Finalmente se pintan las dos cajas de unión, llamando a la función Repaint en TGObjLict.

UnionRect(&clipRect, &beforeBounds, &afterBounds); Repaint(- 1, &clipRect);

4.18. Cambios de Orden del Dibujo.

Cada vez que se llama a DisplayAli se dibuja cada objeto en el arreglo GObjects, empezando desde el índice cero y moviéndose hacia la Última ubicación en el arreglo (la cual es justo antes del índice NexObj). Debido a que siempre se sigue este orden para dibujar, los objetos que se encuentran al comienzo de la lista siempre se dibujan primero. Consecuentemente si se traslapan dos objetos, el objeto más cercano al comienzo del arreglo GObject se dibuja debajo del otro.

El programa OODRAW permite modificar el orden en el cual los objetos se despliegan intercambiando las posiciones de los objetos en el arreglo GObject. Por ejemplo mover un objeto detrás de todos los demás es simplemente una manera de mover el objeto al comienzo de la lista. Esto es lo que hace FlipToBack de la función miembro TGObjLict. Similarmente, la función miembro FiipToFront mueve

57

implementación

un objeto de su ubicación actual a la cola de la lista, de manera que se desplegara al final, y por lo tanto, en la parte superior de todos los otros objetos. Debido a que ambas funciones son similares, sólo nos enfocaremos en la función FlipToFront.

La función comienza determinando si un objeto está seleccionado, si no lo está, la función regresa sin tomar ninguna acción. Posteriormente un apuntador temporal temp, se usa para salvar el objeto indexado por SelectedObj. Este es el objeto que será movido al final del arreglo GObjects. Después, cada objeto arriba de SelectedObj se cambia una posición hacia abajo en el arreglo por el ciclo:

TGObject" temp = GObjects[SelectedObj]; for (int i=SelectedObj; i<NextObj- 1; i++)

GObjects[iJ = GObjects[i+ 11;

Finalmente el objeto, que se salvó en temp, se copia al final de la lista de objetos y el índice SetectedObj se actualiza, de manera que sigue apuntando al mismo objeto, aún y cuando no este al final de la lista.

GObjects[iJ = temp; SelectedObj = i; Dkty = TRUE;

Después de que la lista de objetos ha sido modificada, la ventana de dibujo se actualiza limpiando la pantalla y desplegando todos los objetos en el arreglo que están dentro de la caja de unión del objeto actual:

Repainf(SelectedObj, O);

La Parte restante de la ventana no tiene que ser actualizada

//Remarcar el area donde se encuentra el objeto

4.1 9. Movimiento de Objetos

Un objeto seleccionado se puede mover usando la herramienta de selección, (flecha) la cual está localizada en la esquina superior izquierda de la paleta de herramientas. Para mover una figura seleccionada, presione y mantenga presionado el botón izquierdo del ratón mientras el cursor del ratón está sobre el rectángulo punteado de unión. Después arrastre el objeto a la ubicación deseada y liberar el botón izquierdo del ratón.

El código para seleccionar y mover objetos se localiza en la clase nueva TSelectObj. Este objeto incluye la TSelectObjTool que se deriva de la clase TDrawingTool. Debido a que la interacción del usuario es muy diferente de las otras herramientas de dibujado, varias de sus funciones miembros cancelan las funciones inherentes. TSelectObjTool también incluye una nueva función, PtOnRect, que prueba si el ratón está localizado en la caja de unión de la figura. Cabe también

58

implementución

mencionar que el código toma especial cuidado para manejar las coordenadas actuales del ratón y la coordenada absoluta del objeto en el papel. Esto es particularmente importante cuando se manipulan interactivamente los objetos de Tgobject, debido a que las coordenadas del ratón están siempre especificadas en términos de pixeles y los datos del objeto se almacenan en coordenadas del mundo (absolutas).

4.20. Cambio de Tamaño de un Objeto

i

La clase TSelectObj también incluye un código para redimensionar interactivamente un objeto seleccionado. Para redimensionar un objeto, primero se hace clic en un objeto, usando la herramienta de selección. Aparece un marco con una serie de rectángulos negros pequeños llamados asideros en los que se puede hacer clic y arrastrar con el ratón. Cuando el ratón está sobre un asidero válido, cambiará a un cursor para redimensionar. Esta acción se lleva a cabo en la función UpDateCursor en la selección del código de la herramienta.

Cuando se libera el cursor, la función Finish en TSelectObjTool es llamada para fijar el tamaño del objeto al nuevo marco. No todos los objetos se redimensionan de la misma manera. Por ejemplo, el usuario redimensiona el marco de unión de polígonos y rectángulos. Por otro lado, las líneas no tienen un marco de unión y los asideros de las líneas se mueven directamente. Para proveer esta flexibilidad los objetos proporcionan tres funciones que se usan para redimensionar: Resize, RecizeFrame y DrawResizingObject. Un objeto puede usar una o todas estas funciones para redimensionarse asimismo. Generalmente DrawResizingObject es la rutina principal que se usa para dibujar el objeto conforme se está redimensionando. Por ejemplo, la mayoría de los objetos dibujan un marco que sirve de guía para que se redimensione. La función Resize es usada por los objetos de tipo línea para restar uno de los puntos terminales de la línea. Y finalmente, la función ResizeFrame es usada por algunos objetos para escalar el objeto al tamaño final del marco cuando se libera el ratón.

Cada objeto también es responsable de arrastrar sus propios asideros mediante la función DrawHandles. Por ejemplo, los objetos tipo línea sólo arrastran dos asideros; uno en cada punto terminal de la línea, como se muestra e n la figura 4.6 por el contrario, los objetos elípticos tienen cuatro asideros, uno en cada esquina del rectángulo de unión, (ver la figura 4.5). Una serie de constantes definida en programa GO6JECT.H se usan para mantener la trayectoria del asidero que se selecciona y se mueve. Sin embargo corresponde a cada objeto interpretar que significa el identificador de asidero. La función PtOnResizeHandle se usa para determinar cuando el ratón esta posicionado sobre uno de los asideros de un objeto. Si el ratón está sobre un asidero, se regresa el identificador del asidero.

59

i

. . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . .

; .! . . . . .. ,

. . .:. .

?

I . .

. . . . . ._ I '

" . : : , j ~ .- I : l ' l : :

. . . . . . . . . . . . . . . .

"'-- 6 4

Figura 4.6. AI seleccionar el objeto tipo linea aparecen dos asideros negros, como rectángulos pequeños.

4.21. Cambio de Forma de Objetos Algunos objetos, tales como los polígonos, permiten al usuario modificar las

ubicaciones de los puntos existentes. Para cambiar la forma de la figura, primero Seleccione el objeto. Como se mencionó anteriormente, un marco aparecerá alrededor del objeto, y una serie de rectángulos se dibujaran alrededor de cada una de las coordenadas del objeto, como se muestra en la figura 4.7 Estos son los puntos (asideros) que se pueden mover. Para relocalizar un punto, se debe presionar y sostener presionado la tecla Crl, y hacer clic, y arrastre el punto deseado. Cuando se libera el ratón, el objeto se dibujará en su nueva forma. La mayoría del código programado para cambiar la forma de un objeto se localiza en el archivo fuente GOBJECTCPP y para la selección de la herramienta se localiza en GOBJTOOL.CPP.

Aunque podría parecer un poco extraño, la edición de texto se apoya mediante las funciones para cambiar formas. Para cambiar la línea en un objeto tipo texto se selecciona el objeto, se presiona la tecla Crl, y después se hace clic con el ratón sobre el texto, la caja de diálogo aparece permitiendo introducir una nueva

1 línea de texto. I 1 El código para cambiar la forma de objetos está incluido en la herramienta de

mayoría de los objetos no proporcionan ningún código para las rutinas que cambian la forma, debido a que para ellas la acción es equivalente al cambio de tamaño.

i I 1 selección y refleja muchas de las rutinas para redimensionar. Sin embargo, la

60

Irnplementación

. . . . . . . , . . . . . . . . . . . . . . . . . . . . . . . m:- . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . ._* . . . . . . . . . . . . . . . . . . . . .

. , , . . , . .

Figura 4.7. AI seleccionar objetos elípticos aparecen 4 asideros negros, como rectángulos pequeños.

4.22. Copiar y Pegar Objetos

EL programa OODRAW permite copiar el objeto actual al buffer y lo pega donde se desee. Ambas operaciones son accesibles mediante el menú de persiana de Edit. Para copiar el objeto actual seleccione la opción del copy de menú. Después pegue el objeto en la pantalla, seleccione la opción pegar y haga clic en el botón izquierdo del ratón en la ventana de dibujado. El objeto se pegará en el centro de la ventana de dibujado. Se pueden pegar copias adicionales del mismo objeto haciendo clic nuevamente en el botón izquierdo del ratón.

La operación Copy se proporciona por la clase GObjList y los objetos mismos. La clase GObjList proporciona un buffer, GObjBuffer, para mantener la copia del objeto. Este buffer está declarado como un apuntador de TGObject, por Io tanto puede apuntar a cualquiera de las clases de figuras de gráficas derivadas; tal como TLineObj, TEllipseObj, y así sucesivamente.

A continuación se muestra la función Copy en TGObjList:

//Copia el objeto seleccionado dentro del objeto buffer, CopyBuffer. //si está realmente un objeto dentro del Copy Buffer, borra el primero void TGObjList::Copy() I if (SelectedObj == - 1) return; if (!CopyBuffer) delete CopyBuffer; //Copia el objeto actual seleccionado al objeto buffer

// No hay objeto seleccionado // Libera Cualquier objeto existente

61

Implementución

CopyBuffer = GObjects[SelectedObj]->Dup(); I

Solo se llama a la función cuando se selecciona la opción Copy. Si el buffer del objeto ya contiene algo, entonces el objeto previamente guardado en el buffer se borra y ObjBuffer se fija en un punto para copiar el objeto actual.

Cada TGObject tiene su propia rutina Dup en el archivo GOBJECTCPP para duplicarse asimismo, Por ejemplo, la función Dup de la clase TLineObj es:

TGObject* Dup() { TGObject* gObj = new TLineObjrthis); gObj->Obj = new TLineTool(*(TLineTooI*)Obj); gObj->Obj->PC = new TPaintContextr(((TLLineTool*)Obj)->PC)); return gObj;

I El llamado a los constructores TLineObj, TLineTool y TPaintContext crea los

objetos anidados que representan la figura. Estos constructores llamados constructores de copias, duplican la información que reciben relacionada con el objeto actual.

La operación de Pegado se maneja por un objeto TPasteObj. Cuando se selecciona esta herramienta, pega en la pantalla lo que este en el ObjBuffer. Dentro de TPasteObj se encuentra la herramienta TPasteObjTool que maneja la interacción del usuario con herramienta, Esta herramienta interna se deriva de TDraawingTooi y cancela la función miembro LButtonUp. Aquí es donde se lleva acabo la operación de pegado y el objeto en ObjBuffer primero se duplica.

I 1

// TGObject * ob] = Figures-> CopyBuffer-> Dup();

Hace una copia del objeto a pegar.

Entonces se traslada, de manera que su centro queda en la ubicación del I ratón:

// Translada la figura la nueva posición que se elige con el ratón RECT bounds; CopyRect(&bounds, obj->GetBounds(FALSE)); obj-> Translate(pt.x-(bounds.left +bounds. right)&

pt. y-(bounds. top+bounds. bottom)/2); Figures->Add(obj); //Adiciona un objeto a la lista de figuras de objetos

Finalmente el objeto se añade a la lista de objetos y se despliega:

//Se llama a /a función display() para desplegar las funciones. //Esto se hace aquí porque e l objeto a pegar siempre se traza en la I

1

62

.. ---

Implementación

//Parte superior de todo los otros objetos. HDC hDC = GetDC(PC->DrawingWnd); obi-> Displa y(h DC, PC->Zoom); ReleaseDC(PC->DrawingWnd, hDC);

Nos podemos preguntar por que se están desplegando directamente los Y

objetos, usando la función Display. ¿que no deberíamos llamar a InvalidateRect para colocar correctamente la figura en la pantalla con relación a las otras figuras?. Esto no es necesario; un objeto pegado siempre se coloca en la parte superior de todos los otros objetos.

4.23. Formación del Ambiente Gráfico del SlCOlG

El SlCOlG se maneja mediante un programa principal llamado 0ODRAW.CPP y usan varios programas por separado donde se definen las herramientas y rutinas que se desarrollaron para el funcionamiento del SICOIG, como se muestra en la tabla 4.5. El acceso a estos códigos fuentes está en el anexo de programas que se entrega como parte del cumplimiento justificable del desarrollo de este proyecto de tesis,

CLASES DESCRlPClON 0RAW.H Programa encabezador del programa DRAW.CPP. DRAW .CPP Programa donde se definen las herramientas interactivas

de dibujo. DRAWTOOL.CPP Contiene las funciones de la ventana de dibujo.. DRAWTO0L.H Programa encabezador del programa DRAWTOOL.CPP. G0BJECT.H Programa encabezador del programa GOBJECT.CPP. GOBJECT.CPP Realiza la representación de cada figura como objeto. G0BJLIST.H Programa encabezador del programa GOBJLISTCPP. GOBJLIST.CPP Almacena una serie de objetos gráficos. GOBJTO0L.H Programa encabezador del programa GOBJTOOL.CPP. GOBJTOOL.CPP Realiza las asociaciones de las herramientas de dibujo

con la lista de objetos. MATR1X.H Programa encabezador del programa MATRIX.CPP. MATRIX.CPP Provee operaciones de transformación de coordenadas. OODRAW .H Programa encabezador del programa 0ODRAW.CPP. OODRAW .CPP Programa principal y de control del SICOIG. OODRAW .RC Archivo de recursos para el SICOIG. Tabla 4.5. Archivos usados en el programa principal 0ODRAW:CPP del SICOIG.

Los cuales se incluyen en un archivo proyecto (PROJECT)

I

63

I Figura 4.8. Relación que existe entre los programas que conforman el SICOIG.

i

64

. _ _ _ . . - . . --

f

Implementación 1

El SICOIG está formado por cinco objetos clave que se muestran en la figura 4.9 y que se listan a continuación:

O La ventana principal La ventana de dibujo Una paleta de colores Una paleta de herramientas Una lista de objetos

... ,;, ...: . . . . . . . . . . . . . . . . . ,... ................ ~ . i ..... <.. ......... ,. .

....... .... ...................... ............. ...... ..... .................. j . . . !. ! ~: !...

......................... ............ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . _ r ~ , . . .,

. . . . . . . . . . . . . . , . . . . . . . . . . . . . . . . . . . . ., . . . . . . . , . . . . . . .

. . . . . . , . . . . I . . . . . . . . . . . . . . , . . . . . . ' . . . . . . . . . . .....

,...... ~ . . ~

.....,.....,..............I > . . . . . . . .

Figura 4.9. Relación de los componentes que con'

La clase TOODrawWindow, definida en OODRAW.CPP, engloba estos objetos clave bajo un techo. También proporcionan acceso a la ventana principal de la aplicación, la cual contiene la ventana de dibujo. La paleta de herramientas y colores se despliegan por omisión; sin embargo, se pueden abrir y cerrar según las utilice el usuario. Además, la ventana de dibujo despliega opcionalmente una malla de alineación que sirve de guía para el diseño gráfico. El espaciamiento de la malla es por definición de 50 unidades. El tamaño de la malla se fija en el constructor de la clase TDrawingWindow, la cual se localiza en el archivo cabecera DRAWTO0L.H.

La función DrawGrid en DRAWTOOL.CPP pinta la "hoja de papel" y la malla de dibujado. La hoja de papel se dibuja del tamaño de una hoja de papel de 85x1 1 pulgadas de color gris claro y una malla punteada. El resto de la ventana también se

65

.. . -

Implementación

pinta al mismo tiempo. Pintar manualmente el fondo de la ventana ayuda a ahorrar tiempo de pintado y reduce la titilación de la pantalla.

4.24 Ambiente de un Menú

El programa OODRAW CPP contiene un menú principal de donde se derivan cuatro sub-menús que son: Archivo, Edición, &y Herramientas como se muestra en la figura 4.9. Las declaraciones para definir el menú se listan en el archivo de recursos 0ODRAW.RC y las constantes del código de recursos se localizan en OODRAW.H, las opciones del menú normalmente se manejan mediante las OWL, y el código tiene especial atención en las opciones del menú que no están en color gris donde no hay dibujos disponibles. Además, deben verificarse algunas de las opciones del menú cuando se seleccionan. Por ejemplo, el siguiente código maneja la contraseña de reducción del cincuenta por ciento (50%) de la opción VER del menú:

i

// Verifica la visión 50% alternativa del menú si este es seleccionado void TOODrawWindow::CeCheckView5O(TCommandEnabler& ce) I

ce. SetCheck((Dra wing Window->ZoomMode == VIEW50) ? TCommandEnab1er::Checked : TCommandEnab1er::Unchecked);

Si se está familiarizado con la programación en Windows este código fija el estado de la contraseña de la opción del menú dependiendo de si la modalidad de deformación de la ventana de dibujado es VIEWSO. OWL llama a esta constante para asegurarse de que la contraseña se este mostrando correctamente y la clase TCommanEnabler es definida por OWL.

4.25. Guardar Archivos Objetos

Una capacidad importante de un programa de dibujo es la facultad para salvar o guardar figuras en disco. Por lo tanto, las clases de tipo TGObjList y TGObject contienen funciones que soportan la lectura y escritura de archivos.

La información se salva como un archivo de texto tipo ASCII de manera que es fácil trabajar con ellos. También se puede usar un editor de tipo texto para modificar cualquier valor. Los archivos comienzan con un encabezado de dos líneas. La primera línea contiene la cadena "OODRAW2. La segunda línea específica el número de objetos del archivo. Por ejemplo, si hay 6 objetos gráficos en un archivo, el encabezado sería:

I i / I

I I

66

._ -- -

Implementución

OODRA W2 6 1 1 O 240 95 335 95 810230115295165 2 1 O 16777215355 145415 170 3 1 O 16777215320 180375225 4 107140220155185165165195200200205215180215 180 5 1 O 167772157 185255185255205220295235280275350285350280

La tarea de salvar la lista de objetos se maneja con la función miembro Save de TGObjList. En realidad todas estas funciones llaman a cada objeto en el arreglo GobjectL] para salvarse asimismos:

//Guarda cada objeto en la lista de objetos a un archivo void TGObjList::Save(FIi E* fp)

fprintf(fp, "OODRA W2ln%d\n", NextObj); //Escribir un encabezado for (int i=O; ícNextObj; i+ 6 )

Difty = FALSE;

í //Guardar cada información del objeto

/ /El dibujo fue guardado; reactiva la bandera usada GObjects[¡)>Save(fp);

1

Cada clase derivada de TGObject cancela a la función Save con la finalidad de salvar sus datos de objetos en un archivo. Por ejemplo, TLineObj utiliza las siguientes rutinas para salvar el ancho de la pluma, el color de la pluma y los puntos terminales de la línea:

//Guardar la informacion de las lineas. void TLineObj::Save(FILE *(o)

fprintf(fp, "%d %d %Id %d %d %d %din': LINEOBJ, Obj-zPC-zPenWd, Obj-zPC->PenColor, Obj->Ptl.x, Obj->Ptl .y, Obj->PtZ.x, Obj->Pt2.y);

1

El valor LINEOBJ es un valor entero único que se usa cuando la información del objeto se lee del archivo e indica el tipo de objeto en el archivo. La constante para cada tipo de objeto está definida en el programa cabecera G0BJECT.H.

Para leer la información del objeto de un archivo es un poco diferente. La función miembro Read en TGObjList inicia el proceso leyendo el encabezado del objeto para garantizar que el archivo es del tipo correcto:

I

I

61

Impiementución

/ /E / letrero t'OODRAW2" debe de aparecer en /a parte Superior del archivo fscanf(fp, "%8s': buffer); if (/strcrnp(buffer, "OODRAW2") != O) return -7;

si esta prueba tiene éxito, se lee el número de objetos en el archivo Y después un ciclo For lee el archivo con una linea a la vez. Posteriormente se lee el código completo que inicia con la declaración de objeto y después utiliza la declaración switch para ampliar a la declaración correcta y leer el resto de los datos de objetos:

//Adiciona e l objeto apropiado a la lista figuras. Notifica que e l //Constructor usado sea diferente a aquellos usados en otra parte. switch(0bjType) {

case LINEOBJ: fscanf(fp, "%d %Id %d %d %d %d", &tl, &pc, &t2, &t3, &t4, &t5); obj=new TLineObj(PC-zDrawingWnd, f2, t3, t4, t5, t l , pc, PC, TRUE); Add(obj); break;

El llamado a la función Add de TGObjList añade el objeto a la lista de objetos. Se leen los datos de los objetos tales como líneas y elipses etc., esto es sencillo, sólo se necesita la declaración fscanf, como la que se mostró anteriormenteSin embargo los poligonos y las cadenas de texto requieren de un proceso adicional debido a que estas figuras pueden ser de diferentes longitudes. Cada una contiene una longitud que se usa para leer adecuadamente los datos. A continuación se presentan las declaraciones para leer un polígono:

case POL YGONOBJ: fscanf(fp, "%d %Id %Id %d", &t7, &pc, &bc, &t2); for (j=O; jd2; j++)

fscanf(fp, "%d %d': &po].x, &pi$y); obj = new TPolygonObj(PC-AIrawingWnd, p, t2, t l , pc, bc, PC, TRUE); Addlobj); break;

Después de haber leido todos los objetos se repinta toda la ventana de dibujo

InvalidateRect(PC->Drawing Wnd, O, objectsExist);

llamando a IvalidateRect: I '

I I El parámetro objectsExit es una bandera booleana que se fija en

VERDADERO si había figuras en la pantalla antes de leer la lista de objetos. Este parámetro controla si el programa borra la ventana de dibujo antes de repintarse asimisma. Si no hay objetos en la lista de objetos, no hay ninguna razón para primero borrar la ventana.

I

, I !

i 68

. - -

Implementución

Un detalle importante que se debe considerar es que el constructor llama a los objetos de TGObject. Note que estos llamados tienen uno o más parámetros usados anteriormente para crear los objetos. Esto obliga al código a usar la versión del constructor TGObject que supone que las coordenadas de entrada ya están en coordenadas del mundo.

4.26, Caja de Diálogo para Abrir Archivos

Los archivos de objetos se abren en respuesta a una de las tres opciones del menú Archivo que se capturan por TOODrawWindow. Sin embargo, estas funciones de respuesta no realizan ninguna operación de archivo en sí mismas. En su lugar, envían mensajes a la ventana de dibujo para leer un archivo o para guardar la lista de objetos actual en un archivo. Por ejemplo, la función crnFileOpen, a la cual se llama cuando se escoge la opción Abrir del menú, envía el mensaje del usuario WM-UREADOBJLIST a la ventana de dibujo:

// Envia un mensaje a la ventana de dibujo y lee un objeto del archivo void TOODrawWindow::CrnFileOpen() I

if (Canclose() && / /Se llama c CanClose para guardar el dibujo actual ::SendMessage(DrawingWindow->HWindow, WM-UREADOBJLIST, o, o) == 1) { Set Title To(Dra wing Window->GetFilename());

I

La función EvReadObjList que responde a este mensaje en TDrawingWindow revela como se introduce el nombre del archivo y donde se abre el archivo. Primero, EvReadObjList saca una caja de diálogo abierta de archivo proporcionada por OWL y Windows. Esta maneja todos los detalles para recuperar un nombre de archivo del usuario.

La caja de diálogo se despliega con las siguientes dos declaraciones:

TFileOpenDialog *fiIeDlg = new TFileOpenDialog(this, FilenameData); if (fileDlg->Execute(J == IDOK) (

Si el usuario selecciona el botón OK en la caja de diálogo, el archivo se abre para lectura. El nombre del archivo dado por el usuario aparece en el campo FileName de la variable FileNarneData:

I

I

/ /Se abre el archivo if ((fp = fopen(FilenameData.FileName, Yl)) == NULL) (

i i

strcpy(buffer, "Could not open file: 'y; ' ,

1 ::MessageBox(HWlndow, strcat(buffer, FilenameData. FileName), I GetApp/icationObject()->GetNarne(), Mü- OK I MB- ICONEXCLA MA TION);

I

69

[mplementación

Si el archivo se abre sin ningún problema, se llama a la lista de objetos para leer el archivo:

swifch (readStatus=Figures->Read{fp~) {

La declaración Switch se usa para procesar cualquier código de error. Después de que se ha concluido esta operación, el archivo se cierra y la función termina.

Finalmente, en la función CmFileOpen se adiciona el nombre del archivo abierto a la barra de titulos usando:

void TOODrawWindow::SetTifleTo(const char *str)

wsprinff(TitjeBarSfr, "SICVIG %s", sir); ::SefW/ndowTexi(HWindow, TitleBarStr);

//Añade las hileras //Despliega el nuevo titulo

I

1

4.27. Barridos y Enfocamientos (Zoom and Scrolling)

La ventana de dibujo permite escalar o desplazar el dibujo. El código para estas funciones se localiza en dos lugares. Se puede encontrar en código de bajo nivel en la clase TDrawingWindow programado en el archivo fuente DRAWTOOL.CPP. El código que integra la ventana de dibujo con la aplicación, así como con su menú, se localiza en el programa 0ODRAW.CPP.

Afortunadamente, OWL considera muchos de los detalles de desplazamiento. Sin embargo se tiene que compensar el desplazamiento vigente de la ventana al determinar la ubicación actual del ratón. Por ejemplo si se desplaza la ventana horizontalmente 50 unidades, se debe añadir 50 a la ubicación X del ratón. Se descubrirh numerosos lugares en el código que realiza este tipo de operación. Usualmente el desplazamiento actual de la ventana está disponible en los campos Offsx y Offy de la estructura global de PC TpaintContext.

El soportar las características del enfocamiento para agrandar o reducir complica aún mas el problema para determinar dónde está realmente el ratón y cómo se deben dibujar las figuras. El archivo fuente 0ODRAW.CPP dispone al usuario para que pueda cambiar el ajuste de agrandar o reducir a uno de los diversos valores. El código no tiene una ubicación sencilla que ajuste la escala del dibujo, sin embargo el ajuste actual de agrandar o disminuir es accesible a la variable zoom en la estructura global PC. El código escala manualmente los dibujos con base en su valor. Por ejemplo, si zoom es igual a 0.5, el dibujo se escala al 50% de su valor real.

I

70

.~ - - - ---

Implernen tución

4.28. Creación de una Paleta de Co~oreS

EI programa OODRAW incluye una paleta de colores que permite se~eccionar interactivamente 10s colores de la pluma y de la brocha que se usan en las herramientas de dibujo. La paleta de coiores es similar a la paleta de herramientas Y la principal diferencia de la paleta de COlOreS Consiste en que tiene bloques de colores y no iconos, como se muestra en la figura 4.9.

~1 color superior izquierdo de la paleta despliega el Color actual de la Pluma Y el de la celda inferior izquierda muestra el color de la brocha. Para cambiar el color actual de la pluma apuntar con el cursor el color deseado y hacer clic con el botón izquierdo del ratón. AI hacer clic en el botón derecho del ratón se actualiza el Color de la brocha. Si se hace clic en la paleta de colores cuando esta seleccionado un objeto, sólo se cambia el color del objeto seleccionado.

El código de la paleta de colores está contenido en el archivo 0ODRAW.CP y se encuentra localizado en la clase TColorPalette. Nos enfocaremos en sus diferencias con respecto 2 la paleta de herramientas más adelante.

Los colores se despliegan en la lista de la constante DefColors, la cual está definida como un arreglo de valores COLORREF:

//Se definen los Colores en la Paleta de colores const COLORREF DefColors[l8 /*NUMCOLORSHIGH*NUMCOLORS WIDE*/] = { //Nota: La Posición del primer color mantiene el presente color seleccionado. // El color de abajo muestra e l actual dibujo coloreado. // El color de abajo es el índice para la localización del 1. RG B(0, O, O), RG B(255,255,255), //dibujar el color y rellenarlo RGB(255,255,255), RGB(O,O, O), //Blanco y Negro RGB(128,128,128), RGB(64,64,64), //Gris y Gris oscuro RGB(Z55,0, O), RGB( 128,0, O), //Rojos RGB(0,255,0), RGB(O,128,0), /Í Verdes RGB(0,0,255), RGB(0, O, 128), //Azules RGB(255,255,0), RGB(128,128,0), /Í Amarillos RGB(0,255,255), RGB(O,l28,128), //Cyans i RGB(255,0255), RGB(128,0,128)}, // Magentas

1 1

1

En el constructor TColorPalette, estos colores se copian a los colores del arreglo de manera que puedan modificarse. Los colores se despliegan de la parte superior a la inferior y de izquierda a derecha de la paleta. Ya que el color superior izquierdo en la paleta muestra el color actual de la pluma y la celda inferior izquierda el color de la brocha, las primeras dos ubicaciones en el arreglo Colors, se resewan para 10s colores de la pluma y de la brocha. El programa copia Colors[O] al campo PenCoior de TPaintContext y Colors[l] a BruchColor. Esto se debe a que las

i I

I I

71

... .~ . - -

implernentución

1

herramientas para dibujar usan de la clase TPaintContext atributos Para debminar cual color se usará para dibujar las figuras.

L~ función EvLButtonDown de mensajes-respuestas detecta si se está presionado el botón izquierdo, indicando que el USUariO está seleccionando un nuevo color de pluma. Primero, EvLButtonDown calcula el índice de la celda de Color We corresponde con la posición del ratón. La ubicación del ratón se pasa a la función en el parámetro pt.

//determina e l color que usuario a seleccionado en la celda int ix = pt.x / ColorWd; int iy = pt.y / ColorHt; int i = ix * NUMCOLORSHIGH + iy;

Después se actualiza el color correspondiente de la pluma en el arreglo Colors y en la estructura de TPaintContext:

Colors[O] = GetNearestColor(hDC, Colors[i]J; PC->Pencolor = Colors[Oj;

Los colores de la pluma nunca se rellenan. Por lo tanto, se llama a la función GetNearestColor para desplegar la correspondencia más cercana para el color seleccionado. Esto muestra al usuario exactamente que color aparecerá.

Sin embargo, si está seleccionado un objeto se cambia el color del objeto:

((TDra wing Tool *)ob)> Obi) -> PC-> Pen Color = Colors[O];

En ambos casos la función llama a InvalidateRect para actualizar la región apropiada de la pantalla por ejemplo si no está seleccionado un objeto, la región donde está desplegado el color de la pluma se invalida, de manera que la paleta de colores mostrará el nuevo color:

//Influencia de la paleta para demostrar el nuevo color en el dibujo rect.left = O; rect.right = ColorWd; rect.boffom = ColorHt; ::lnvalidateRect(H Windo w, & rect, FALSE);

La función EvRButtonDown es similar a EvLButtonDown excepto que EvRButtonDbwn cambia el color de la brocha cuando el usuario presiona el botón derecho del ratón mientras el apuntador está sobre la paleta de colores.

rect.top = O;

i

12

i

Implementación

4.29. Desplegando la Paleta de Colores

Por definición, la paleta de colores se despliega en la esquina inferior izquierda de la ventana de dibujado. La paleta se puede mover libremente alrededor de la pantalla o cerrarla si se desea. Para apagar la pantalla de la paleta de Colores, use la opción paleta de colores que se encuentra en el menú de herramientas la función de mensaje y respuesta CmColorPal responde a esta entrada del menú. Note que cuando comienza el programa aparece una contraseña en la opción paleta de colores. Esto le índica al usuario que está seleccionada la paleta de colores. Un vistazo a CmColorPal mostrará que se introdujeron nuevas funciones de Windows. A continuación se muestra la rutina completa CmColorPal:

/ /El cierre de las expresiones de la paleta de color esta demostrado void TOODra w Windo w::CmColorPal()

if (::Is WindowVisible(ColorPa1ette-> H Windo w))

else { //Demostrar el color de la paleta, pero no hacer la activacion

c ::ShowWindow(ColorPalette->H Window, SW-HIDE);

::Show Windo w(ColorPa1ette-zH Windo w, S W- S HO WNOA C TI VA TE); ::lnvalidateRect(ColorPalette->HWindow, O, TRUE);

I I

Esta función es llamada cuando el usuario desea desplegar o apagar la paleta de colores. Por lo tanto, la primera rutina determina si está visible la paleta de colores. Para este propósito, Windows provee la función IsWindowVisible, la cual está definida como:

. . .

En este caso, la función IsWindowsVisible pasa el código ai campo HWindow del objeto ColorPalette. Si la paleta de colores ya está visible, entonces IsWindowsVisible regresa un valor diferente de cero.

La siguiente declaración llama a la función ShowWindow de Windows, la cual se usa para controlar si las ventanas se produjeron y aparecieron. A continuación se muestra como está definida ShowWindow:

73

I

I I

Implemeniación

Para quitar la ventana de la paleta de colores se utiliza

Show Windo w(ColorPa1eíte-> Hwindo w, S W- HIDE);

La opción SW-SHOWNOACTIVATE se usa si la paleta de colores se tiene que volver a desplegar. Esta opción despliega la ventana que . aparece repentinamente en su más reciente ubicación y tamaño. La ventana activa actual permanece activa.

la siguiente instrucción:

4.30. Impresión de Gráficas y Figuras

Mostrar las gráficas en la pantalla de una computadora es muy agradable, pero es tan importante, como el poder imprimir una copia de sus actividades. AI igual que las operaciones en pantalla, la impresión de un objeto gráfico puede ser un esfuerzo involucrado en Windows. En el lado positivo Windows maneja todos los detalles de comunicación de bajo nivel con amplio conocimiento y rango de impresoras, además, Windows hace todo esto y aún todavía proporciona una consistencia absoluta, y una interface de programación independiente del dispositivo. De hecho, la impresora es tratada como otros dispositivos, tales como los contextos de dispositivos de pantalla y memoria. Es decir, se manipula a la impresora usando un manejador para un contexto de dispositivo, se pueden usar las mismas funciones de GDI (Graphic Driver Interface) que se han estado usando con la pantalla; sin embargo, más que usar un manejador para un contexto de dispositivo para la pantalla, se usa uno para la impresora.

Desafortunadamente, las impresoras varían ampliamente y hay mucho que Windows puede hacer para obtener una rápida impresión. Se debe asegurar que la impresora sea capaz de imprimir lo que está recibiendo. Además, los errores de la impresora son muy comunes. Un buen programa monitorea estos errores.

Finalmente, imprimir gráficas requiere de mucha memoria. Se puede necesitar optimizar el código para trabajar con algunas impresoras que no puedan manejar rápidamente la carga de la impresión de gráficas.

74

. .

I.

Zmpiementación

Afortunadamente, OWL proporciona la clase TPrintout que tiene muchas de las características necesarias para imprimir. El programa principal OODRAW .CPP contiene la declaración de la clase TWindowPrintout desde TPrintout con la finalidad de proporcionar una función personalizada de PrintPage que es la que imprime el dibujo. Sólo se explicará un poco la función Printpage. La variable Printer en la clase TOODrawWindow apunta a un objeto de TWindowPrintout, como se vio en el diagrama de clases de la figura 3.4 del capítulo 3, el cual es creado en el constructor TOODrawWindow:

Printer = new TPrinfer;

La rutina CmPrint inicia la acción de impresión y es invocada en respuesta a la opción del menú Imprimir. CmPrint está localizado en la clase TDrawWindow en OODRAW .CPP y está definida como:

//imprime el dibujo actual de la ventana void TOODra w Windo w::CmPrint()

//asigna la impresión de un objeto

í if (Printer) { /I Si el existe el objeto a imprimir

TWindowPrintout printout(Dra wing Windo w->Getfilename(), Drawing Window); printout. SetBanding(TRU€); Printer-zPrint(0ra wing Windo w, printout, TRUE);

I I

Este código indirectamente llama a PrintPage de TWindowPrintout que es la que en realidad imprime el dibujo. Esta función está involucrada, debido a que se debe escalar el dibujo al tamaño del papel. Para mantener las cosas sencillas, el código fija el tamaño de la impresión de manera que lo ajusta dentro de la página, independientemente de su orientación. Además, el Código apaga la rejilla y elimina temporalmente el marco de selección de cualquier objeto seleccionado.

I

75

, _ _ _ ~-

Pruebas

Capítulo 5

PRUEBAS Y RESULTADOS

5.1. Introducción

“Un plan de pruebas prescribe varias clases de actividades que se realizarán para demostrar que el producto de programación cumple con sus requisitos”.

Después del diseño detallado e implementación, se realiza una revisión critica cuyo propósito es verificar la consistencia integridad y funcionalidad del sistema y el cumplimiento de los objetivos y requerimientos planteados al inicio del proyecto.

Para la Evaluación del SlCOlG se diseñó un plan de pruebas, que verifique la funcionalidad del sistema. Dicho plan incluye los casos de pruebas reales, resultados esperados y capacidades que demostrará cada caso.

5.2. Plan de Pruebas

Es importante verificar y evaluar la funcionalidad del SICOIG, para lograrlo se realizó un plan de pruebas que consiste de las siguientes secciones:

a) Nombre Especifica el nombre de la prueba

b) Objetivo Señalar el propósito de la prueba ,

c) Descripción de la prueba Especifica la configuración del sistema, las suposiciones concernientes

al estado del sistema para el caso de prueba, los requisitos que se están probando y las entradas de prueba.

I !

I d) Criterios de aceptación Determinar los resultados esperados, bajo las condiciones y entradas

especificadas en la descripción de la prueba.

i I

76

Pruebus

e) Procedimiento de la prueba Precisar las pasos a realizar, las suposiciones referentes al estado del

sistema, y entradas de la prueba, para obtener los resultados esperados.

f) Resultados de la prueba Anotar los resultados obtenidos en el desarrollo de la prueba.

g) Desempeño de la prueba Demostrar que la prueba ha cumplido con requerimientos establecidos.

5.3. Procedimiento de Pruebas

Caso Numero 1:

Nombre: Despliegue del menú principal de la interfaz del SICOIG.

Objetivo: Verificar que las opciones del menú reflejen de una manera clara las funciones principales de la interfaz, y verificar que el menú de la interfaz habilite sólo las opciones que se pueden realizar en un momento determinado.

Descripción de la prueba: Activar desde el sistema Windows, el SICOIG, las opciones principales del menú corresponden a las funciones principales que el SlCOlG realiza, cuando se está en un punto inicial, verificar que en el menú de la interfaz, únicamente estén activas las opciones de Archivo [figura 5. I ] ,

Criterios de Aceptación: Esta prueba deberá de mostrar por medio del menú las principales funciones que tiene el SlCOlG , además de habilitar sólo las opciones correctas en un determinado momento.

Procedimiento de la Prueba: El procedimiento de la prueba consiste en activar el SICOIG desde el sistema Windows, una vez que se activa Windows , aparecen una serie de grupos , entre los que se encuentran la paleta de colores, la paleta de herramientas y el área de aplicación de diseño gráfico, dentro de este grupo se encuentra un ícono que activa el cursor de elección (flecha), una vez que estamos dentro del SICOIG, se verifican que las opciones del menú principal cumplen con las funciones principales del SICOIG, y también se prueba que no todas las opciones están activadas al inicio de una sesión con el sistema. Sólo están activas todas las sub-opciones de Archivo, como lo son: Nuevo, Abrir, Salvar, Salvar Como, lmprimir y Salir.

71

I

Pruebas

Resultados de la prueba: Los resultados obtenidos durante esta prueba fueron satisfactorios , se cumple con las principales funciones que debe tener el sistema: a) Entrada de datos y archivos, b) Acciones de Edición, c) Acciones de Acercamiento d) Acciones de herramientas , las cuales están reflejadas en el menú principal. Además se observó que sólo están habilitadas las opciones que un usuario puede realizar de acuerdo a los datos que ha proporcionado en esta sesión con el SICOIG. Por ejemplo en la figura 5.1 se nota que las acciones de la opción Edición están deshabilitadas porque todavía no existe ninguna figura en la ventana de dibujo.

Desempeño de la prueba: Esta prueba cumple con los objetivos particulares del sistema, los cuales se ven reflejados en las opciones del menú principal, la validación de las opciones del menú y la interfaz en su ambiente amigable y fácil de utilizar, como lo es el ambiente Windows, en la que ésta interfaz fue desarrollada.

:

, . . . .. . , . . ,, . .. . . , . . , .. . . l.._ I ..... ~ I~ ~ . . . .

, 78

." . ~. . .. .. - - Pruebas

Caso número 2:

Nombre: Diseño gráfico por medio de herramientas base.

Objetivo: El sistema deberá permitir diseñar gráficos por medio de las herramientas base como lo son: La línea, el círculo, el rectángulo, polilineas y texto.

Descripción de la prueba: La prueba consiste en elegir de la paleta de herramientas y colores los elementos de dibujo para realizar uno de ellos y de igual manera elegir en la sub-opción de Abrir el nombre de un archivo nuevo, con extensión .OOD, en el cual serán grabados los objetos gráficos diseñados en la ventana de dibujo; Una vez elegido, el nombre del archivo es creado por el sistema y se habilita la sub-opción de Salvar Corno del menú ARCHIVOS, el usuario introduce el nombre del archivo y la ruta de directorio donde desee grabar el archivo.

Criterios de aceptación: La prueba deberá aceptar los iconos de diseño gráfico y &os deberán ser introducidos tantas veces sean utilizados. La información capturada deberá ser valida , dependiendo del tipo de icono utilidad, en caso de introducir información incorrecta el sistema deberá indicarlo con un mensaje al usuario, y el dato incorrecto será rechazado hasta que sea correcto. AI terminar de introducir esta información el sistema deberá formar un archivo de datos que contenga ésta información.

Procedimiento de la prueba: Para realizar esta prueba el usuario activa la opción ARCHIVOS del menú principal elige la sub-opción Abrir , elige la ruta y nombre del archivo nuevo de datos, ver figura. 5 2, (el nombre del archivo gráfico deberá tener extensión .OOD, a continuación se elige la sub-opción de Salvar Como del menú ARCHIVOS, aparece una pantalla solicitando el nombre del archivo de acuerdo al formato de archivos, se oprime el botón [ACEPTAR] y automáticamente el sistema guarda o llama el archivo. Toda la información proporcionada es validada,

Resultado de la prueba: La prueba obtuvo resultados satisfactorios, la información introducida fue validada correctamente , la captura de la información coincide con los datos especificados, y el almacenamiento se realizó correctamente.

Desempeño de la prueba: La prueba cubrió los requerimientos referentes a validación de la información, la captura de la información coincidió con la requerida, y se cumplió satisfactoriamente en lo referente al diseño gráfico.

79

I

Pruebas

Figura 5.2. Opción para diseñar dibujos utilizando ¡conos de dibujo escribir texto y salvar o abrir un archivo.

Caso número 3:

Nombre : Despliegue y diseño de una gráfica.

Objetivo: Mostrar en pantalla como se realiza una gráfica utilizando datos seriales campo, de una manera clara, ordenada y sencilla para el usuario.

Descripción de la prueba: La prueba consiste en elegir un archivo de datos que fue grabado anteriormente y asignarlos al sistema coordenado que es un icono que forma parte de la paleta de herramientas y posteriormente obtener la gráfica mostrándose en la pantalla.

Criterios de aceptación: La interfaz debe contar con una opción de consulta de la información de los archivos de datos de campo, esta información debe estar ordenada facilitando al usuario la comprensión y claridad de la misma.

80

- . ~ . . ~ - - _- --

Pruebas

procedimiento de la prueba: Se eligió un el icon0 de ejes Y se arrastró a la ventana de dibujo ubicando el cursor del ratón en alguna posición dentro de la ventana de dibujo y abriendo un marco donde se pintan los ejes coordenados y posteriormente se seleccionó el icono de datos eligiendo el archivo de datos y arrtistrando este archivo dentro del marco de ejes coordenados y al soltar el cursor se empieza a dibujar la gráfica, para dar una mejor claridad en la información al usuario Ver figura 5.3.

Resultados de la prueba: Los resultados cumplieron con los criterios de aceptación, de los diferentes archivos elegidos , se visualizó cada uno de ellos y se encontró que los datos son correctos cumpliendo con cierto formato para el usuario.

Desempeño de la prueba: La prueba fue satisfactoria, cumpliendo con el requerimiento referente a la consulta de información y almacenamiento de la información,

..................

....... I ...............

...................

...... -, ............

...................

! , .

1

..... ' ...

81

_ _ ~ - - - - -

Pruebas

f

Caso número 4:

Nombre : Despliegue y diseño de un histograma.

Objetivo: Mostrar en pantalla cómo se realiza un histograma utilizando datos seriales campo de la gráfica anterior.

Descripción de la prueba: La prueba consiste en elegir un archivo de datos como el de la gráfica anterior y asignarlos al sistema coordenado que es un icono que forma parte de la paleta de herramientas y posteriormente obtener el histograma mostrándose en la pantalla.

........ ....................

. . , . . . . .& ...............

Serie I f . Pimdveie d B I991 O m w l . OYWSl

..... 1 . ...... , . . . . . ',SO

IR,

11.1

<1>1

............. .

............ . __. ........................ . . . . . . . . _ - ~

i" 2501

g 1 0 1

e Ioi E

o ...................................................... .... ,.. .......... ~ ..

,>I.

8%

d I I

. . . . . . . . . . . . . . .~

............. ....,... . ......., ..................

n , 6 1 2 a1 .U6 6568 u 1B12 111 11/.1s 111.11 1 6 U . . , . . . . . . . .

8 2 1 2.6, 4 , lili I d eo34 ,067, 121 , 3 0 5 7 156

*,,or8 (Crn) .. .........

I I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

Figura.5.4. Muestra gráfica de un histograma.

Criterios de aceptación: La interfaz debe contar con una opción de consulta de la información de los archivos de datos, esta información debe estar ordenada facilitando al usuario la comprensión y claridad de la misma.

Procedimiento de la prueba: Se eligió el icono de histograma y se arrastra a la ventana de dibujo ubicando el cursor del ratón en alguna posición dentro de la ventana de dibujo y abriendo un marco donde se pintan los ejes coordenados y

82

. . . . . - -

Pruebas

posteriormente se seleccionó el icono de datos eligiendo el archivo de datos y arrastrando este archivo dentro del marco de ejes coordenados y al soltar el cursor se empieza a dibujar el histograma la, para dar una mejor .claridad en la información al usuario, Ver figura 5.4.

Resultados de la prueba: Los resultados cumplieron con los criterios de aceptación, de los diferentes archivos elegidos , se visualizó cada uno de ellos y se encontró que los datos son correctos cumpliendo con cierto formato para el usuario.

Desempeño de la prueba: La prueba fue satisfactoria, cumpliendo con el requerimiento referente a la consulta de información y almacenamiento de la información.

Caso número 5:

Nombre: Incrustación de diferentes tipos de gráficas.

Objetivo: Presentar en la pantalla una serie de gráficas que se pueden representar en la misma ventana de dibujo.

Descripción de la prueba: Para realizar esta prueba se debe asignar un o varios archivos de datos al sistema coordenado de cada ventana o puerto de visión que se forme arrastrando el icono correspondiente a cada tipo de gráfica, este icono se elige y forma parte de la paleta de herramientas y posteriormente se obtienen los tipos de gráficas asignados.

Criterios de aceptación: La interfaz debe contar con una opción de consulta de la información de los archivos de datos asignados a cada gráfica, esta información debe estar ordenada facilitando al usuario la comprensión y claridad de la misma.

Procedimiento de la prueba: Se eligió un el icono para cada tipo de gráfica a diseñar y se arrastra a la ventana de dibujo ubicando el cursor del ratón en alguna posición dentro de la ventana de dibujo y abriendo un marco donde se pintan los ejes coordenados y posteriormente se seleccionó el icono de datos eligiendo el archivo de datos y arrastrando este archivo dentro del marco de ejes coordenados y al soltar el cursor se empieza a dibujar la gráfica correspondiente a cada tipo de icono gráfico, para dar una mejor claridad en la información al usuario, Ver figura 5.5.

83

Y

Resultados de la prueba: Los resultados de esta prueba fueron satisfactorios, ya que se verificó que dependiendo del archivo de datos asignado a cada puerto de visión y signándole el icono correspondiente a cada tipo de gráfica se nota que no se interfiere para nada una de otra.

Desempeño de la prueba: La prueba cumplió con los requerimientos establecidos para cada archivos de datos asignado.

84

Conclusiones

Capítulo 6

CONCLUSIONES

6.1. Antecedentes

De Conformidad y de acuerdo a los problemas expuestos en el capítulo 1 Y 2, se puede concluir que la aplicación de conceptos modernos como son los constructores interactivos mediante el uso de herramientas de programación dinámica proporciona un medio muy poderoso para la construcción de interfaces gráficas de usuario en forma interactiva y dinámica, y podemos decir que se tiene la ventaja de que el tiempo de desarrollo de una tarea a realizar por un usuario se reduce al mínimo, debido a que el diseño del sistema de construcción de interfaces gráficas se hace por medio de una metodología y ambiente de estructuras de trabajo que se implementa de una manera rápida, con posibilidades de incorporar cambios descubiertos a través de un ciclo reiterativo de diseño, en su implementación y evaluación, liberando al usuario de la tarea de construir programas específicos para representar los diferentes tipos y estilos de gráficas en pantalla. Por otro lado el empleo de lenguajes de programación que soporten el estilo de programación orientado a objetos hace posible alcanzar calidad en términos de confiabilidad y mantenibilidad en los desarrollos de software implementados con esta tecnología, puesto que proporciona el medio para hacer programación incremental, utilizando el mecanismo de herencia lo cual significa que es posible agregar nuevos módulos de programación al sistema heredando el comportamiento de clases una vez comprobada su confiabilidad. También es posible reducir los costos de mantenimiento de este software, puesto que la edición y la compilación puede hacerse por módulos, confinando las fallas del sistema a los módulos que hayan sido actualizados. Esto es de vital importancia mencionarlo dadas las condiciones particulares de las aplicaciones, porque dada una cierta aplicación se puede dar el caso en el que el sistema no proporcione la gráfica requerida, y en tal caso es posible que Únicamente se programe el módulo que proporcione lo deseado y este puede ser incorporado al sistema sin dificultad alguna.

85

. -

I

Conclusiones

6.2. Beneficios

. Tomando en consideración que los sistemas o interfaces interactivas Y dinámicas normalmente son de mucha utilidad para usuarios que requieren procesar iiiformación en particular y cuya labor más importante no es precisamente la programación de estas herramientas, se puede mencionar que una de las principales aportaciones de este trabajo es el de proporcionar un marco de trabajo interactivo con técnicas, procedimientos y estrategias, para la configuración de interfaces gráficas de usuario y sus representaciones gráficas en pantalla, que proporcionan un mecanismo de programación interactiva y dinámica, con lo que se libera en lo posible al usuario del proceso de la tarea de programar y del aprendizaje de la sintaxis de algún lenguaje de programación en particular. En otras palabras, se incrementa la habilidad de los "no programadores" a construir sus aplicaciones de manera consistente.

La asimilación y uso de la tecnología para el desarrollo de interfaces gráficas (GUI), as¡ como del paradigma de programación orientado a objetos (POO) para la producción de software creciente y de calidad, que promueve el rehuso de módulos de código ya existentes, incrementando la productividad normal de los programadores para sus aplicaciones.

La generación de una librería de clases básica que servirá como plataforma de desarrollo para trabajos futuros en el área.

La experiencia obtenida al utilizar librerías comerciales de software que contienen clases de objetos y que permiten realizar programación en Windows como es el caso del uso de las librerías OWL del Borlan C++. Y cuyo beneficio se vera alcanzado con la difusión de los conocimientos del software desarrollado y de la generación de nuevos proyectos de investigación en un ambiente académico.

La disponibilidad de esta herramienta como apoyo didáctico para la ensefianza en áreas tales como: diseño Y desarrollo de interfaces gráficas de usuario Y técnicas de programación orientadas a objetos.

6.3. Alcances Logrados

En forma general, el objetivo global fue cumplido: El desarrollo de un sistema de construcción de interfaces gráficas Basadas en un Framework para la Representación de información.

Los resultados específicos alcanzados, fuel-on el desarrollo de los siguientes módulos:

! 86

I

Conclusiones

1, Realizar el desarrollo de un Sistema de ConStrUCCiÓn de Interfaces Gráficas Basadas en un Marco de Trabajo para la representación de Información con un mínimo de esfuerzo de programación, como es la Construcción de Programas usando herramientas gráficas y componentes de Software reutilizable (programación gráfica), para lo cuál los desarrollos actuales se están concentrando en la implementación de herramientas dinámicas para realizar varios aspectos del ciclo de vida de desarrollo de software de una forma automática y más fácil, tal es el caso del desarrollo de herramientas OWL (Object Windows Library).

2. Enriquecer Librerías de herramientas de desarrollo tales como DLL (Dynamic Link Libraries); Ambientes de desarrollo de interfaces de usuario como GUl's (Graphical User Interfaces), WIMP (Windows Icons, Menus and Pointers), UlMS (User Interfaces Management Systems) y UlDS (User Interfaces Development Systems).

Desarrollos de software en lenguajes formales de programación que proporcionen cada vez mayores facilidades a los programadores permitiendo construir software de mayor calidad en términos de legibilidad, confiabilidad, mantenibilidad,

Crear un marco o estructura de trabajo en programación Windows orientado a objetos permitiendo formar librerías de clase genéricas para reutilizar código.

Una metodología de Creación-Edición de interfaces de usuario para la presentación gráfica de información, que proporciona una librería de clases genéricas de software encapsuladas; una herramienta interactiva de desarrollo para la creación visual de ventanas, representaciones gráfica y los mecanismos de control de diálogos.

El Desarrollo de los algoritmos de administración de pantallas. En esta parte del sistema, se detecta el tipo de tarjeta gráfica utilizada y se fijan la cantidad de pixeles de resolución vertical y horizontal de la pantalla para que esta sea distribuida entre el número de ventanas que se vayan creando, que por definición estos objetos se organizan en forma de mosaico.

Desarrollo de algoritmos de Creación-Edición de ventanas. Aquí el sistema ProPorciona facilidades para que interactivarnente con el teclado se haga la creación de instancias de clase ventana, con valores de definición y que a la vez será acomodada en una porción de pantalla asignado por el administrador de pantalla Así mismo de pueden editar los valores de definición asignados en la creación de la misma y se dan los medios para manipular directamente a una ventana, dando facilidades para mover y redimensionar (agrandar o acortar) una ventana.

. .

#

87

Conclusiones

6.4. Mejoras y Ampliaciones a este Trabajo

Durante el desarrollo e implementación de este sistema fueron surgiendo cada vez nuevos enfoques extensivos y mejoras al mismo. Como proyecto.de tesis tiene sus limitaciones y alcances, y para mejorarlo se proponen como trabajos futuros los siguientes:

Se necesita incorporar un algoritmo o metodología que permita construir de manera visual e interactivamente objetos de mayor complejidad a partir de objetos primitivos simples, por ejemplo si quisiera construir una gráfica iogarítmica se tendría que añadir dentro del objetos ejes una subclase de ejes espaciales logaritmicos de tal manera de que dinámicamente de armara este tipo de ejes simple y sencillamente con el objeto tipo línea. Este rubro actualmente ya se esta contemplando en una tesis de maestría que tiene por objeto integrar dos o más clases de objetos en uno solo de mayor complejidad utilizando mecanismos de relación tales como herencia para hacer extensiones, agregaciones (fuerte y débil) y asociaciones, etc.;

El sistema debe de aceptar a nuevos objetos e incorporarlos visualmente e interactivamente en la paleta de iconos o de herramientas.

Incorporar otros objetos Útiles para el uso específico del análisis de perfiles playeros tales como rosas de viento, etc.

Sería conveniente también incorporar gráficas en tres dimensiones.

88

http://proyecto.de

Apéndice A

Apéndice A Caracterización de la Información utilizada en

Perfiles Playeros

Las playas varían de un lugar a otro, pero se puede decir que todas tienen en común la existencia de un perfil, el cual puede presentar diferentes características, según sean los procesos terrestres, acuosos y atmosféricos que la afecten.

A continuación se describe brevemente, la terminología utilizada en el presente trabajo de los rasgos principales del perfil de playa [8 ] .

CARACTERkTlCAS PRINCIPALES DEL PERFIL DE PLAYA.

Distancia O

L Lirnüe hacia el

I

Fig. A-1 Elementos básicos del perfil de playa.

Perfil.-

Línea d e perfil.-

La curva definida en la intersección del sedimento de la superficie por un plano vertical insertado perpendicularmente en éste.

La línea definida por dos puntos fijos Ó por un punto fijo y un ángulo conocido, a lo largo del cual las distancias medidas de los levantamientos y las elevaciones son definidas en el perfil de playa.

89

Apéndice A

Levantamiento.-

Distancia.-

Elevación.-

Punto de referencia.-

Nivel de referencia.-

6erma.-

Localización.-

Código de localización.

Número de línea de perfil.-

Contorno.-

Intersección de contorno.-

Posición del contorno.-

Punto de referencia de entrada.-

Punto de referencia de salida.-

Es un evento durante el cual una o todas las líneas de perfil de una localización son medidas.

Es la coordenada horizontal medida, desde un punto de referencia de la playa hacia el límite del mar, en un punto fijo del perfil de la linea.

Es la coordenada vertical de un punto horizontal de referencia hacia arriba y abajo del perfil de la playa,

Es el punto de referencia fijo localizado en la playa, con distancia y elevación conocida.

Es el nivel de referencia que se toma para realizar la medición de la elevación.

Es una parte casi horizontal, de la playa formada por material depositado por la acción de las olas. Algunas playas no tienen bermas otras tienen una o mas.

Un lugar único donde los datos del levantamiento son localizados. Por ejemplo (Cazones, Veracruz).

Es la abreviación que representa el nombre del lugar o sitio, por ejemplo (CZ).

El número Único que se asigna a cada línea de perfil para su identificación.

Una línea de elevación constante a lo largo de la superficie de la playa.

El punto definido por la intersección de un contorno con un perfil de la playa. En algunos perfiles, podrían tener más de una intersección de un contorno dado.

La intersección de un plano horizontal y la superficie de la playa.

Punto de referencia de entrada al cual los levantamientos son referenciados.

Punto de referencia al cual los datos del perfil son representados en las gráficas de salida.

90

Apéndice A

Nivel de referencia de entrada.-

Nivel de referencia de salida.-

Dato extrapolado.-

Unidades de medición.-

Límite hacia el mar.-

Límite hacia tierra.-

Levantamiento de referencia.-

Linea de costa.-

Media espacial.-

Unidad de Volumen.-

Cambio en la unidad de volumen..

Nivel de referencia al cual los levantamientos de entrada son referenciados. Usualmente es el nivel medio del mar.

I

Nivel de referencia del mar al cual los datos son representados en las gráficas y tablas de salida. (Por ejemplo: posición de la línea de la costa, levantamiento de referencia, posición de la cresta de la berma). ,i

Desde la posición de la línea de la costa cuando se quiere extrapolar se usan los dos Últimos puntos coordenados levantados del perfil y 'se pueden conocer al menos dos datos posteriores.

iI Unidad de medida en la cual los levantamientos de entrada son registrados.

U Distancia identificada como más hacia tierra del i

I final de una línea de perfil.

Distancia identificada como más hacia tierra del i inicio de una línea de un perfil. I

~

El levantamiento de una línea de perfil el cual define un valor estándar para el cual los valores subsecuentes son referenciados. (posición de la linea corta o unidad de volumen).

Es la intersección del límite hacia tierra (playa) con el límite del mar en el plano vertical con el'mar.

El promedio aritmético de una serie de variables recolectadas durante un número de levantamientos' en una simple línea de perfil.

El producto de un cruce seccional de un área y una unidad de longitud perpendicular al área. Dado como unidad de volumen por longitud de la línea corta.

La diferencia entre unidades de volumen medidas durante dos levantamientos.

i

I I

91

__ _ _ . .. . Apéndice 5

Apéndice B Glosario de Términos Usados en la Programación Orientada a Objetos

Clase Abstracta. Es una clase cuyo objetivo principal es definir una interface. Una clase abstracta otorga sus implementaciones a una subclase. Una clase abstracta no puede ser instanciada.

Acoplamiento Abstracto. Dada una Clase A que mantiene una referencia a una clase abstracta B, la clase A se dice que está acoplada abstractamente a B. Y se llama acoplamiento abstracto porque A se refiere a un tipo de objeto y no a un objeto concreto.

Operación Abstracta. Es una operación que declara funciones pero que no se implementan. En C++, una operación de este tipo corresponde a una funcion miembro puramente virtual (pure virtual member function).

Relación de Conocimiento. Es una clase que se refiere a otra clase y que tiene una relación con esa clase.

Objeto Agregado. Es un objeto que está compuesto de subobjetos. El subobjeto es llamado agregador de partes, y el agregado es responsable de ellos.

Relación de Agregación. La relación de un objeto agregado es en partes. Una clase define esta relación por instancias (es decir objetos agregados).

Reuso de Cajas Negras. Es un estilo de reuso basado en composición de objetos. Los objetos compuestos no revelan detalles internos uno a otro y estos son análogos a “cajas negras”.

Clase. Una clase define la interface e implementación de un objeto. Especifica la representación interna del objeto y define las operaciones que el objeto puede ejecutar.

Diagrama de Clases. Es un diagrama que representa clases, sus estructuras internas y operaciones y la relacion estática entre ellas.

I I

Operación de Clases. Es una operación que se fija a una clase y no a un objeto individual. En C++ estas operaciones de clase son llamadas funciones miembro estáticas (static member functions).

1

I I 92

Apéndice B

Clase Concreta. Es una clase que no tiene operaciones abstractas. Esta puede ser instanciada.

Constructor. En C++ es una.operación que es automáticamente invocada para inicializar una nueva instancia.

Acoplamiento. Es el grado con el cual los componentes de software dependen unos de otros.

Delegación. Es un mecanismo de implementación en el cual un objeto delega una petición a otro objeto. El delegante solicita el mensaje afuera en nombre del objeto setvidor

Diseño de Patrones. Es una disposición de clases de objetos que colaboran para resolver un problema que se presenta recurrentemente bajo un sistema de fuerzas o contexto.

Destructor. En C++, es una operación que es automáticamente invocada para liberar el espacio de memoria ocupado por un objeto.

Ligado Dinámico. Es una petición (en tiempo de ejecución) de un objeto en una de sus operaciones. En C++ solo las funciones' virtuales son dinámicamente ligadas.

Encapsulamiento. Es el resultado de una representación e implementación oculta de un objeto. La reprentación no es visible y no puede ser asociada directamente desde la parte externa del objeto. Las operaciones sólo son el camino de acceso y modifican o cambian el estado de los objetos.

Estructura de Trabajo (Framework). Es colocar o armar una colaboración de clases que integren un diseño reusable para una clase especifica de software. Una estructura o marco de trabajo provee una guía arquitectónica por bloques de diseño dentro de una clase abstracta y estos definen responsabilidades y colaboraciones. Es un revelador que construye el marco de trabajo a una aplicación en particular por subclases y compone instancias de clases de estructuras de trabajo.

Clase amiga. En C++ es una clase que tiene el mismo e idéntico acceso a las operaciones y a los datos de una clase como aquella clase que se llama asimisma.

Inherencia. Es un vínculo que define una entidad en términos de otra. Una clase Inherente define una nueva clase en términos de una o más clases madre. L.a nueva clase hereda la interface y las implementaciones desde las clases madres. Esta nueva clase es llamada subclase, en C++ se le llama clase derivada. Una clase inherente mezcla o combina la interface inherente y las

93

Apéndice B

implementaciones inherentes. La interface inherente define una nueva interface en términos de una o más interfaces existentes. Las implementaciones inherentes definen una nueva implementación en términos de una o más implementaciones existentes.

Variable de Instancia. Es un fragmento de dato que define parte de la representacion de objetos. En C++ se usa el término dato miembro.

Diagrama de Interacción. E s un diagrama que muestra el flujo de petición o de instancias que hay entre objetos.

i

Interface. Arma y coloca todas las formas asignaturas definidas por las operaciones de objetos. La interface coloca y describe las peticiones a quien un objeto puede responder.

Metaclase. Son clases de objetos usadas en Smalltalk. Una metaclase es una clase derivada de una clase de objetos.

Clase Combinada. Es una clase diseñada para ser combinada con otras clases a través de herencia. Las clases combinadas son usualmente abstractas.

Objeto. Es una entidad que en su tiempo de ejecución empaqueta a datos y procedimientos y que operan en esos mismos datos.

e Objetos Compuesto. Es un ensamble o composición de objetos que adquiere una mayor complejidad funcional.

Diagrama Objeto E s un diagrama que describe una estructura de un objeto en particular en su tiempo de ejecución.

Objeto Referencia. Es un valor que identifica a otro objeto.

e Operación. Es una entidad autorizada para la manipulación interna de los datos de un objeto. Un objeto realiza una operación cuando recibe un petición. En C++ estas operaciones son llamadas funciones miembro (member function). Smalltalk usa el término método (method).

e Dominador. Es una redefinición de una operación en una subclase (la operación es heredada desde una clase madre).

específico. Los tipos no especificados son proveidos como parámetros en el lugar

(templates). i

!

e Tipo Paramétrizado. Es un tipo que autoriza algún tipo de componente no

donde se usa. En C++ los tipos parametrizados son llamados patrones o plantillas !

!

94

Apétzdice B

Clase Madre. Es una clase principal desde la cual se hereda a otras clases. Sus sinónimos son las superclases, (Smalltalk), clase base (C++) y clase predecesor.

Polimorfismo. Es una habilidad para sustituir objetos en apareamiento de interfaces de una a otra en su tiempo de ejecucuón.

Herencia Privada. En C++ es una clase que se hereda exclusivamente a una ejecución.

Protocolo. Extiende el concepto de una interface que incluye las secuencias permisibles o tolerables a la petición.

Receptor. Es el objetivo del objeto de una petición o instancia.

Petición. Es cuando un objeto servidor realiza una operación cuando recibe la petición correspondiente desde otro objeto cliente. Un sinonirno común para una petición es un mensaje.

Signatura o Firma. Define el nombre, tipo y número de parametros, así como el tipo del valor de retorno de una operación.

Subclase. Es una clase que se hereda de otra clase. En C++ una subclase es llamada clase derivada (derived class).

Subsistema. Es un grupo independiente de clases que colabora a satisfacer una aplicación de responsabilidad.

Subtipo. Un subtipo es un tipo de otro, si esta interface contiene la interface del otro tipo.

Superiipo. Es el tipo padre desde el cual se hereda a un tipo

Juego de Herramientas (Toolkit). Es una colección de clases que proveen una funcionalidad Útil, pero que no definen el diseño de una aplicación.

Tipo. Es es nombre que se da a una interface en particular.

Reuso de Cajas Blancas. Es un estilo de reuso basado en herencia de clases. Una subclase reusa la interface y se ejecuta de la clase madre, pero puede tener acceso de otra forma a aspectos privados de la clase madre.

95

Apéndice C

Apéndice Técnica

c de Modelado de Objetos (OMT)

Se usaron diagramas en el desarrollo de este trabajo de tesis. Algunos diagramas son informales, como un marco de pantalla de una caja de diálogo o un esquema mostrando un árbol de objetos. Pero los patrones de diseño en particular usan notaciones más formales para indicar relaciones e interacciones entre clases y objetos. Este apéndice describe en detalle estas notaciones.

Se usaron tres diferentes notaciones de diagramas:

1. Un diagrama de clases que representa clases, su estructura, y las relaciones estáticas entre ellas.

2. Un diagrama de objetas que representa una estructura particular de objeto al

3. Un diagrama de interacción que muestra el flujo de solicitudes entre objetos

Cada patrón de diseno incluye por lo menos un diagrama de clase. Las otras notaciones se usan como se necesiten para complementar la discusión Los diagramas de clase y objetos están basados en la notación o terminología OMT (Object,Modeling Thecnique). Los diagramas de interacción se toman del Objetory y del método Booch.

momento de ejecución.

DIAGRAMA DE CLASES

La figura B.l (a) muestra la notación OMT para clases abstractas y concretas. Una clase está denotada por una caja con el nombre de la clase en negrillas en la parte superior de la caja. Las llaves de operaciones de la clase aparecen abajo del nombre de la clase. Cualquier variable de instancia aparece debajo de las operaciones. El tipo de información es opcional; se usa la convención de C++, la cual pone el tipo de nombre antes del nombre de la operación (para expresar el tipo de regreso) a la variable de instancia o el parámetro actual. El tipo itálica (Slanted) indica que la clase o la operación es abstracta.

96

.... -- ..

Apéndice C

r Clase concreta Clase Abstracta

Operación10 OIxracionrs absrraciasl0 Tipo de operaci6n20

Variable de instancia1 Typo de variable de instancia2

(a) diferencia entre clase abstracta y clase concreta

-__ ............

cliente

(b) clase cliente participante (izquierda) y clase cliente irnplicita (derecha)

Drawing Shape I

4 I

.................................. Color

(b) relación entre clases

E] ..........................................................

Shape->draw()

(d) notación de pseudo código.

Figura B.l: Notación de diagramas de clases

97

Apéndice C

algunos patrones de diseño es de utilidad ver donde la5 clases del cliente hacen referencia a las clases participantes. Cuando Un patrón incluye una Cliente como uno de sus participantes (indicando que el cliente tiene una responsabilidad en ei patrón), el Cliente aparece como una clase ordinaria. Por ejemplo cuando un patrón no incluye un cliente participante (por ejemplo, 10s Clientes no tienen responsabilidades en el patrón), pero lo incluye no obstante que aclara cuales patrones participantes interactuan con los clientes, entonces la clase cliente se muestra en gris, como se muestra en la figura B.l b. Un ejemplo es Proxy (207). Un cliente gris también aclara que no se ha omitido accidentalmente la discusión del cliente de los participantes.

La figura B. lc muestra varias relaciones entre clases. La notación OMT para la herencia de la clase es un triángulo conectando una subclase (Lineshape) en la figura con su clase madre (Shape). Una referencia de objeto representando una relación, es una agregación y se indica con una flecha con punta de diamante en la base. La flecha apunta hacia la clase que es agregada (Shape). Una Flecha sin el diamante denota conocimiento por ejemplo un LineShape mantiene una referencia con un objeto (Color), cuyas otras formas se pueden compartir). El nombre para la referencia puede aparecer cerca de la base, para distinguirlo de otras referencias.

Otra utilidad que se muestra es cuales clases son instancias de otras. Se usa una flecha punteada para indicar esto, debido a que OMT no lo soporta. A esto se le llama la relación “creates”. La flecha apunta a la clase que está instanciada. En la figura Bclc CreationTool crea a los objetos LineShape.

La OMT también define un círculo lleno para indicar “más de uno”. Cuando el círculo aparece en la parte superior de la referencia significa objetos múltiples que están siendo referenciados o agregados. La figura B.lc muestra que Drawing agrega objetos múltiples del tipo Shape,

Finalmente la notación OMT contiene anotaciones de seudocódigo para permitirnos esbozar las implementaciones de las operaciones. La figura 5.1 d muestra la anotación de seudocódigo para la operación de (Draw) en la clase (Drawing).

DIAGRAMA DE OBJETOS

Un diagrama de objetos muestra exclusivamente instancias. Proporciona una instancia de objetos en un patrón de diseño. Los objetos son nombrados “aSomething” donde Something es la clase del objeto. Nuestro símbolo para un objeto modificado ligeramente (del OMT estándar) es un cuadro redondeado con una linea separando el nombre del objeto de cualquier referencia de objeto. Las flechas indican al objeto referenciado. L2 figura 8.2 muestra un ejemplo.

. -

Apéndice c

aCircleqha a1,ineShaoe

Figura 6.2: Notación de Diagrama de Objetos

aCreationToo1 aDrawing aLineShape

New Li i icShap

Add(LinrShape)

1 I

9 ...............................................................

Figura 6.2: Notación de Diagrama de Interacción

DIAGRAMA DE INTERACCIÓN

Un diagrama de interacción muestra el orden en el cual se ejecutaron las solicitudes entre objetos. La figura 6.3 es un diagrama de interacción que muestra cuando una figura se añade a un dibujo.

El tiempo fluye de arriba hacia abajo en un diagrama de interacción. Una línea sólida vertical indica el tiempo de vida de un objeto en particular. La convención de nombres para los objetos es la misma que para los diagramas de objetos; El nombre de la clase tiene el prefijo de la letra “a” (por ejemplo ashape). Si el objeto no es

99

..

Apéndice C

instanciado después del inicio del tiempo como se registró en el diagrama, entonces, su línea vertical aparece punteada hasta el punto de creación.

Un rectángulo vertical muestra que un objeto está activo; esto es que se esta manejando una solicitud. La operación puede enviar solicitudes a los objetos; estas son indicadas con una flecha horizontal apuntando al objeto receptor. El nombre de la solicitud se muestra arriba de la flecha. Una solicitud para crear un objeto se muestra con una flecha punteada. Una solicitud para el objeto que se envía, apunta por sí misma de regreso al remitente.

La figura B.3 muestra que la primera solicitud es de aCreationTool para crear aLineShape. Posteriormente aLineShape se añade a aDrawing, el cual incita a aDrawing para que envíe una solicitud de Refresh asimisma. Note que aDrawing envía una solicitud Draw a aLineShape como parte de la operación Refresh,

I O0

Apéndice D

Apéndice D Diagramas de Jerarquía y Herencia

de las Clases OWL

Clase TWindow Jerarquía de la clase TWindow y su herencia, ver figura D.1.

Archivo Cabecera Utiliza el archivo cabecera wind0w.h de las OWL

Descripción La clase TWindow se deriva de las clases TeventHandler y TstreamableBase,

proporciona el comportamiento de ventana específica y encapsula muchas funciones que controlan el comportamiento de la ventana y la creación de la ventana especifica y los atributos de registro.

Twindow es una ventana genérica que se puede redimencionar y mover. Se puede construir una instancia de Twindow aunque normalmente se utiliza Twindow como una base para sus clases de ventanas especializadas. En general, para asociar y desasociar un objeto Twindow con un elemento de ventana es necesario seguir los siguientes pasos:

1.

2.

. o

3.

o

o

Construir una instancia de la clase TWindow.

Llamar a Crear o ejecutar, lo cual crea el elemento de interface (HWND) y después llama a Setupwindow, la cual llama a la Setupwindow base para el procesamiento normal, lo cual a su vez comprende: Crear la HWindow y cualquier child HWindows. Llamar a TransferData para restablecer la trasferencia de datos entre las ventanas madre e hija.

Para destruir el elemento de interface, se escoge una de las siguientes acciones, dependiendo de la aplicación: Llamar a Destroy para destruir el elemento de interface incondicionalmente. Llamar a CloseWindow, la cual llama a CanClose para probar si está de acuerdo en destruir el elemento de interface.

Apéndice D

4. Existen dos formas para destruir el objeto de interface: Si el objeto ha sido reconstruido, use eliminar. Si el objeto no ha sido reconstruido, el compilador automáticamente destruye el objeto.

El proceso de destrucción de la ObjectWindows costa de dos partes: (1) llama a Destroy para destruir el elemento de interface y (2) después elimina el objeto C++. Sin embargo, es perfectamente válido llamar a destroy en el elemento de interface sin eliminar el objeto C++ y después llamar a crear posteriormente para volver a crear la ventana. Debido a que es también válido construir un objeto de ventana C++ en la pila (stack) o como un miembro agregado, la función Destroy no puede asumir que se debe eliminar el Objeto C++.

El manejador de eventos WM-CLOSE generado por el usuario EvClose también provoca que se elimine un objeto C++ pasando este apuntador a la aplicación el objeto C++ se elimina automáticamente debido a que el evento EvClose ocurre frecuentemente en respuesta a una acción del usuario y este es el lugar más conveniente donde se IleJa acabo la eliminación. Posteriormente, cuando es seguro hacerlo, la aplicación entonces elimina el apuntador de la ventana. Debido a que la pila con frecuencia contiene selectores que se refieren a las direcciones de los objetos que pueden volverse inválidos durante el proceso de eliminación, no es seguro eliminar este apuntador mientras todavía se están procesando los eventos. Sí la dirección se vuelve inválida, podría causar problemas cuando se vuelvan a cargar de la pila.

TWindow es la clase base para todas las clases de ventanas, incluyendo TFrameWindow, TControl, TDialog, and TMDIChild. El diagrama de jerarquía de ObjectWindows muestra muchas clases que se derivan de TWindow.

Public (Datos Miembro) TWindowAttr Attr; WNDPROC DefaultProc; HWND HWindow; TWindow* Parent; TScroller" Scroller; TStatus Status; char far' Title:

Public (Constructores y Destructores) Window(HWND hWnd, TModule' module = O); TWindow(TWindow* parent, const char far* title = O, TModule* module = o); virtual -TWindow();

I02

-

Apéiidicr D

- public (Funciones Miembro)

exstyle); void BringWindowToTop(); virtual boo1 Canclose(); void CheckDlgBution(int buttonld, uint check); void CheckRadioButton(int firstButtonld, int IastButionld, ¡nt checkButtonld); void ChildBroadcastMessage(uint rnsg, WPARAM wPararn, LPARAM IPararn); HWND ChildWindowFrornPoint(const TPoint&) const; TWindow' ChildWithld(int id) const;

void CIientToScreen(TPoint& point) const; virtual void CloseWindow(int retval = O); void CrnExit(); virtual boo1 Create(); void CreateCaret(HB1TMAP hBitrnap); void CreateCaret(boo1 isGray, int width, int height); boo1 Createchildreno; LRESULT DefaultProcessing(); virtual LRESULT DefWindowProc(uint rnsg, WPARAM wPararn, LPARAM IPararn); virtual void Destroy(int retVal = O); static void Destroycareto; void DisableAutoCreate(); void DisableTransfer(); virtual LRESULT Dispatch(TEventlnfo& info, WPARAM wp, LPARAM Ip = O); void DragAcceptFiles(boo1 accept); void DrawMenuEarO; void EnableAutoCreateO; void EnableScrollBar(uint sbFlags = SB-BOTH, uint arrowFlags = ESE-ENABLE-BOTH); void EnableTransferO; virtual boo1 EnableWindow(boo1 enable); int EnurnProps(PROPENUMPR0C proc); void EvChildlnvalid(HWND hWnd); virtual LRESULT EvCornmand(uint id, HWND hWndCtl, uint notifycode); void EvCornmandEnable(TCornmandEnabler& ce); void EvSysCornrnand (uint crndType. TPoint& point); TWindow* FirstThat(TCondFunc test, void" paramList = o); TWindow* FirstThat(TC0ndMernFunc test, void* paramList = o); boo1 FlashWindow(boo1 invert); void ForEach(TActionFunc action, void* pararnList = O); void ForEach(TActionMernFunc action, void" paramlist = o); LRESULT FonvardMessage(boo1 send = true) LRESULT ForwardMessage(HWND hWnd, boo1 send = true); static HWND GetActiveWindow(); TApplication* GetApplication()const;

void AdjustWindowRect(TReCt& reCt, Uint32 Style, boo1 static void AdjustWindowRectEx(TReCt&, reCt, Uint32 style, boo1

, void ClearFlag(TWindowF1ag mask);

103

Apéndice D

static HWND GetCaptureO; static uint GetCaretBlinkTimd); static void GetCaretPos(TPoint& Point); long GetClassLong(int index) const; uintl6 GetClassWord(int index) const; TRect GetClientRect() const; void GetClientRect(TRect& rect) const; static void GetCursorPos(TPoint& pos); static HWND GetDesktopWindow; int GetDlgCtrllD() const; HWND GetDlgltem(int childld) Const; uint GetDlgltemlnt(int childld, boo1 "translated = 0,bool issigned = true) const; uint GetDlgltemText(int childld, char far* text, int max) const; TWindow" GetFirstChild() static HWND GetFocus() void GetHWndStateO; int Getld(); TModule* GetModule() const; HWND GetLastActivePopup() const; TWindow* GetLastChildO; HMENU GetMenu() const; HWND GetNextDlgGroupltem(HWND hWndCtrl, boo1 previous = false) const; HWND GetNextDlgTabltem(HWND HWndCtrl, boo1 previous = false) const: HWND GetNextWindow(uint dirflag) const; TWindow* GetWindowPtr(HWND hWnd); HWND Getparent() const; HANDLE GetProp(uintl6 atom) const; HANDLE GetProp(const char far* string) const; int GetScrollPos(int bar) const; void GetScrollRange(int bar, int& minPos, int& maxPos) const; static HWND GetSysModaiWindow(); HMENU GetSystemMenu(boo1 revert = false) const; WNDPROC GetThunkOconst; HWND GetTopWindow()const; boo1 GetUpdateRect(TRect& rect, boo1 erase = true) const; boo1 GetUpdateRgn(TRegion& rgn, boo1 erase = true) const; HWND GetWindow(uint cmd) const; HFONT GetWindowFont(); long GetWindowLong(int index) const; boo1 GetWindowPiacement(WlNDOWPLACEMENT* place) const; void GetWindowRect(TRect& rect) const; TRect GetWindowRect() const; HTASK GetWindowTask() const; int GetWindowText(char far* string, int maxcount) const; int GetWindowTextLength() const; void GetWindowTextTitle(); uintl6 GetWindowWord(int index) const;

104

Apéndice D

LRESULT HandleMessage(uint msg, WPARAM wParam = O, LPARAM IParam = O); void Hidecareto; boo1 HiliteMenultem(HMENU hMenu, uint idltem, uint hilite); virtual boo1 HoldFocusHWnd(HWND hWndLose, HWND hWndGain); operator HWND()const; virtual boo1 IdleAction(1ong idlecount); void Invalidate(boo1 erase = true); void InvalidateRect(c0nst TRect&, boo1 erase = true); void InvalidateRgn(HRGN hRgn, boo1 erase = true); boo1 IsChild(HWND) Const; uint IsDlgButtonChecked(int buttonld) const; boo1 IsFlagSet(TWindowF1ag mask); boo1 isiconic() const; boo1 IsWindow() const; boo1 IsWindowEnabled() const; boo1 IsWindowVisible() const; boo1 IsZoorned() const; boo1 KillTimer(uint timerld); boo1 LockWindowUpdate(!; void MapWindowPoints(HWND hWndTo, TPoint* points, int count) const; int MessageBox(const char far' text,const char far" caption = O, uint type = MB-OK); void MoveWindow(int x, int y, int w, int h, boo1 repaint = false); void MoveWindow(const TRect& rect, boo1 repaint = false); Window' Next(); unsigned NumChildren(); TClipboard& Openclipboard(); virtual void Paint(TDC& dc, bool,erase, TRect& rect); boo1 PostMessage(uint msg, WPARAM wParam = O, LPARAM IParam=O) const; virtual void PerformCreate(int menuOrld); virtual boo1 PreProcessMsg(MSG& msg); TWindow* Previous(); LRESULT ReceiveMessage(uint msg, WPARAM wParam = O, LPARAM IParam = O); boo1 RedrawWindow(TRect* update, HRGN hUpdateRgn, uint redrawFlags = RDW-INVALIDATE I RDW-UPDATENOW I RDW-ERASE); virtual boo1 Register(); boo1 RegisterHotKey(int idHotKey, uint modifiers, uint virtKey); static void Releasecapture(); HANDLE RernoveProp(uintl6 atom) const; HANDLE RernoveProp(const char far* str) const; void RouteCommandEnable(HWND hlnitCmdTarget, TCommandEnabler& ce); void ScreenToClient(TPoint& point) const; void CcrollWindow(int dx, ¡ni dy, const TRect* scroll = O, const TRect far* clip = O); void ScrollWindowEx(int dx, int dy, const TRect far* scroll = O, const TRect far* clip = O, HRGN hUpdateRgn = O, TRect far* update = O, uint flags = O); LRESULT SendDlgltemMessage(int childld, uint msg, WPARAM wParam = O, LPARAM IParam = O); LRESULT SendMessage(uint msg, WPARAM wParam = O, LPARAM IParam = o);

I05

Apéndice D

void SendNotification(¡nt id, int notifycode, HWND hCtl, uint msg = WM-COMMAND); HWND SetActiveWindow(); void SetBkgndColor(uint32 color); void SetCaption(const char far* title); HWND SetCaptureO; static void SetCaretBlinkTime(uintl6 milliSeCS); static void SetCaretPos(int x, int y); static void SetCaretPos(const TPoint& pos); long SetClassLong(int index) const; uintl6 SetClassWord(int index, uintl6 newword); boo1 SetCursor(TModule* module, TResld resld); void SetDlglternlnt(int childld, uint value, boo1 issigned = true) const; void SetDlgltemText(int childld, const char far* text) const; virtual boo1 SetDocTitle(const char far* docname, int index); void SetFlag(TWindowF1ag mask); HWND SetFocus(); boo1 SetMenu(HMENU hMenu); void SetModule(TModule* module); void SetNext(TWindow* next); virtual void SetParent(TWindow* newparent); boo1 SetProp(uintl6 atom, HANDLE data) const; boo1 SetProp(const char far* str, HANDLE data) const; void SetRedraw(boo1 redraw); int SetScrollPos(int bar, int pos, boo1 redraw =true); void SetScrollRange(int bar, int rninPos, int maxPos, boo1 redraw = true); HWND SetSysModalWindow(); uint SetTirner(uint timerld, uint timeout, TIMERPROC proc = O); void SetTransferBuffer(void* transferBuffer); void SetWindowFont(HF0NT font, boo1 redraw); long SetWindowLong(int index, long newlong); boo1 SetWindowPlacernent(const WINDOWPLACEMENT place); void SetWindowPos(HWND hWndlnsertAfter, const TRect& rect, uint flags); void SetWindowPos(HWND hWndlnsertAfter, int x, int y, int w, int h, uint flags); void SetWindowText(const char far* str); uintl6 SetWindowWord(int index, uintl6 newword); void Show(int cmdShow); void Showcareto; void ShowOwnedPopups(boo1 show); void ShowScrollBar(int bar, boo1 show = true); virtual boo1 ShowWindow(int cmdShow); void ShutDownWindow(int retVal = O); static void ShutDownWindow(TWindow* win, int retVal = O); void SubclassWindowFunction(); virtual uint Transfer(vÓid* buffer, TTransferDirection direction): virtual void TransferData(TTransferDirection direction); boo1 UnregisterHotKey(int idHotKey);

I06

Apéndice D

void UpdateWindowO; void Validateo; void ValidateRect(const TRect& rect); void ValidateRgn(HRGN hRgn); static HWND WindowFromPoint(c0nst TPoint& point) const; virtual LRESULT WindowProc(uint msg, WPARAM wParam, LPARAM IParam); boo1 WinHelp(const char far* helpfile, uint command, uint32 data);

Protected (Datos Miembro) uint32 BkgndColor; TModule* CursorModule; TResld CursorResld; HACCEL hAccel; HCURSOR HCursor; void* TransferBuffer;

Protected (Constructor) TW indow();

Protected (Funciones Miembro) virtual void CleanupWindow(); void DispatchScroll(uint scrollCode, uint thumbPos, HWND hWndCtrl); virtual char far* GetClassName(); virtual void GetWindowClass(WNDCLASS& wndclass); void Init(TWindow* parent, const char far* title, TModule" module); void LoadAcceleratorTable(); void RemoveChild(TWindow* child); virtual void Setupwindow();

Respuesta a la tabla de Entrada EV- macros y funciones miembros de la clase TWindow.

Estas son dos tablas. La primera muestra la las respuestas estándar de entradas La segunda muestra la respuesta de entradas de Win32.

107

Apéndice D

Respuesta de Entradas Estándar

Respuesta de entradas EVWMCREATE EV-WM-CLOSE E V W M-DESTROY EV-WM-SIZE EVWM-MOVE E V W M-NCDESTROY EVWM-QUERYENDSESSION EVWMCOMPAREITEM EV-WM-DELETEITEM EV-WM-DRAWITEM EVWM-MEASUREITEM EV-W M-CH I LDI NVALl D EVWM-VSCROLL EV-WM-HSCROLL E V W M-PA1 NT EV-WM-SETCURSOR EVWM-LBUTTONDOWN EV-COMMAND(CM-EXIT, CmExit) EV-WM-SYSCOLORCHANGE EVWM-KILLFOCUS EVWM-ERASEBKGND

Funciones Miembro EvCreate EvClose EvDestroy EvSize EvMove EvNcDeslroy EvQuety Endsession EvCompareltem EvDeleteltem EvDrawltem EvMeasureltem EvChildlnvalid EvVScroll EvHScroll EvPaint EvSetCursor EvLButtonDown CmExit EvSysColorChange EvKillFocus EvEraseBkgnd

Respuesta de Entradas Win32

Respuestas de entrada Entradas EV-MESSAGE(WM-CTLCOLORMSGBOX, EvWin32CtlColor) EvWin32CtlColor EV-MESSAGE(WM-CTLCOLOREDIT, EvWin32CtlColori EvWin32CtlColor

Funciones Miembro

~

' EV-MESSAGE(WM-CTLCOLORLISTBOX, EvWin32CtlColor) EvWin32CtlColor EV-MESSAGE(WM-CTLCOLORBTN, EvWin32CtlColor) EvWin32CtlColor EV-MESSAGE(WM-CTLCOLORDLG, EvWin32CtlColor) EvWin32CtlColor EV-MESSAGE(WM-CTLCOLORSCROLLBAR, EvWin32CtlColor) EvWin32CtlColor EV-MESSAGE(WM-CTLCOLORSTATIC, EvWin32CtlColor) EvWin32CtlColor

1 O8

Apéndice D

Clase TFrameWindow

Archivo Cabecera Utiliza el archivo frarnewinh de las OWL.

Descripción TFrameWindow es una clase derivada de la clase Twindow y controla el comportamiento de cada ventana específica por medio de la navegación del teclado y de los comandos de procesamiento para cada ventana de usuario. Por ejemplo cuando se reactiva una ventana, TFrameWindow es responsable para restablecer el foco de entrada de una ventana y de añadir el soporte para la barra e iconos del menú, TFrameWindow es una clase titular muy importante

En términos de áreas de ventaneo, el área del marco consiste del borde, los menús del sistema, las barras de herramientas y las barras de estado mientras que el área del usuario excluye esas áreas. Aunque las ventanas del marco pueden soportar una ventana de usuario, la ventana del marco permanece separada de la ventana del usuario de manera que puede cambiar la ventana del usuario sin afectar la ventana del marco.

OWL usa ésta estructura de marco y usuario para las clases TFrameWlndow y TMDIChild. Ambas clases pueden mantener una clase del usuario. Cuando se tiene una clase separada del area del cliente de la ventana añade mayor flexibilidad a su programa. Por ejemplo esta área de cliente separada, la cual podría ser una caja de diálogo se puede mover dentro de otra ventana del marco, ya sea a una ventana principal o una ventana MDI child,

Consulte TFloatingFrame para obtener una descripción de un marco flotante

Jerarquía de la clase TFrameWindow y SU herencia, ver figura D.'.

con la misma funcionalidad por omisión que una ventana de marco.

Public (Datos Miembro) boo1 KeyboardHandling;

Public (Constructores y Destructores) TFrameWindow(TWindow* Parent, const char far* title = O, TWindow* clientWnd = O, boo1 ShrinkToClient =false, TModule* module = O); TFrameWindow(HWND hWnd, TModule* module = O); -TFrameWindow();

Public (Funciones Miembro) virtual boo1 AssignMenu(TRes1d menuResld); void EnableKBHandlerO; virtual TWindow* GetClientWindow(); virtual HWND GetCommandTarget(); const TMenuDescr' GetMenuDescrO; boo1 HoldFocusHWnd(HWND hWndLose, HWND hWndGain); void IdleAction(1ong idlecount);

109

- -

Apéndice D

boo1 MergeMenu(const TMenuDescr& childMenuDescr); boo1 PreProcessMsg(MSG& msg); boo1 RestoreMenuO; virtual TWindow* SetClientWindow(TWindow* clientwnd); boo\ SetDocTitle(const char far* docname, int index); bool Setlcon(TModule* iconModule, TResld iconResW virtual boo1 SetMenu(HMENU newMenu); void SetMenuDescr(const TMenuDescr& menuDescr);

Protected (Datos Miembro) Window* ClientWnd; int DocTitlelndex; HWND HWndRestoreFocus; TModule* MergeModule;

Protected (Constructor) TFrameWindow();

Protected (Funciones Mirmbro) LRESULT EvCommand(uint id, HWND hWndCtl, uint notifycode); void EvCommandEnable(TCommandEnabler& ce); boo1 EvEraseBkgnd(HDC); HANDLE EvlnitMenuPopup(HMENU hPopupMenu, uint index, boo1 sysMenu); void EvPaintO; void EvParentNotify(uint event, uint childHandleOrX, uint childlDOrY); HANDLE EvQueryDraglcon();

void EvSize(uint sizeType, TSize& size); void Init(TWindow* clientWnd, boo1 shrinkToClient); void Setupwindow();

Respuesta a la tabla de Entradas Eventos (EV) de macros y funciones miembro de la clase TFrameWindow

Respuesta, tabla de Entrada EV-WM-ERASEBKGND EvEraseBkgnd EV-WM-INITMENUPOPUP EvlnitMenuPopup EVWM-PAINT EvPaint EV-WM-PARENTNOTIFY EvParentNotify EV-WM-QUERYDRAGICON, EvQueryDraglcon (Windows only) E V W M-SETFOCUS EvSetFocus EV-WM-SIZE EvSize

, void EvSetFocus(HWND hWndLostFocus);

Funciones Miembro

110

..

Apéndice D

Clase TPrintout Jerarquía de la clase Tfrintouf y su herencia, ver figura D.3.

Archivo Cabecera Utiliza el archivo cabecera printerh de /as OWL

Descripción La clase TPrintout es una clase derivada 0 formada de la cla e base

TStreamableBase, y su función es imprimir todo el documento físico que se representa en la pantalla y que se enviará a una impresora. Debido a que este tipo de objeto es abstracto no se puede usar para imprimir nada por si mismo, para cada tipo de documento debe crearse una clase derivada de TPrintout por lo que la función fr intfage debe ser incluida.

Public Constructor and Destructor TPrintout(const char far* title); virtual -TPrintout();

Public Funciones Miembro virtual void BeginDocument(int startpage, int endpage, unsigned flags); virtual void Beginprinting(); virtual void EndDocumentO; virtual void Endprintingo; virtual void GetDialoglnfo(int& minPage, int& maxPage, int& selFromPage, int& selToPage); const char far’ GetTitle() const; virtual boo1 HasPage(int pageNumber); virtual void PrintPage(int page, TRect& rect, unsigned flags); virtual void SetPrintParams(TPrintDC* dc, TSize pagesize); boo1 WantBanding()const; boo1 WantForceAIIBands()const;

Definición de tipos TPrintoutFlags enum

Protected Datos Miembro boo1 Banding; TPrintDC* DC; boo1 ForceAIIBands; TSize Pagesize; char far* Title:

,

111

1

I

Figura 0.1. Diagrama jerárquico de las clases de OWL donde se muestra la clase principal TWindow que gobierna casi todas las Clases de OWL

y las Clases de Control de Ventanas (FrameWindows)

Apéndice D

c o

Figura D.2. Diagrama jerárquico de las clases de OWL donde se muestran las clases que gobiernan las Clases de Control (Control Classes)

y las Clases de Dialogo Común (Common Dialog Clases)

I

113

Apéndice D

Continuación de las OWL, 3 de 4. ~

Figura D.3. Diagrama jerárquico de las clases de OWL donde se muestran las clases que gobiernan las Clases de Impresión (Printer Classes)

y las Clases de Barrido Horizontal y Vertical (Scroller Clases)

I14

Apéndice D

Cnntiniiacirín de las OWL. 4 de 4.

ObjectWindows Hierarchy (Diagram 4 of 4)

Figura D.4. Diagrama jerárquico de las clases de OWL donde se muestran las clases que gobiernan las GDI de las Interfaces de Objetos

y los Dispositivos de Contexto.

115

Apéndice E

Apéndice E Programa de Cabecera DRAWTO0L.H

// DRAWTO0L.H: Define las funciones de control de diálogo y del manejo /I de la ventana de dibujo usados en el programa principal I/ 0ODRAW.CPP

#ifndef DRAWTOOLH #define DRAWTOOLH

#include <owl\applicat.h> #include <owl\framewin.h> #include <owl\dc.h> #include <owl\scroller.h> #include "draw.h" #include "gobj1ist.h"

#define FITINWINDOW O #define VIEW25 1 #define VIEW50 2 #define VIEW100 3 #define VIEW200 4 #define PAPERWD 17 #define PAPERHT 22 #define GRlDlNCWD 10 #define GRlDlNCHT 10

/I librerías OWL

// Proporción de grados /I Proporción de grado 25% // Proporción de grado 50% // Proporción de grado 100% I/ Proporción de grado 200% //Ancho del papel (en número de cuadros de la celda) // Ancho del papel (en número de cuadros de la celda) // El barrido de la ventana horizontalmente y I/ Verticalmente en 1 O puntos de distancia

class TDrawingWindow : public TWindow { public: int GridWd, GridHt; BOOL GridOn; BOOL DrawingMode; TPaintContext* PC; TGObjLW Figures; int ZoomMode; TGObject* CurrObjTool; char Filename[l28]; TDrawingWindow(TWindow' parent, const char* title,

void DrawGrid(HDC hDC); char* GetFilenameO { return Filename; } void SetFilename(char* name) { strcpy(Filename, name); }

// Ancho y alto del cuadro // Exhibir un cuadro en la ventana

// El modo de acercamiento // La presente herramienta de dibujo fue usada /I El archivo esta editado

TPaintContext* pc, TGObjList" figures);

i

I I6

Apéndice E

int SaveDrawing(char* filename); void Paint(TDC& dc, BOOL, TRect&); void EvLButtonDown(UINT, TPoint&); void EvLButtonUp(UINT, TPoint&); void EvMouseMove(UINT, TPoint&); void EvRButtonDown(UINT, TPoint&); BOOL EvSetCursor(HWND hWndCursor, UlNT hitTest, UlNT rnouseMsg); int SetZoorn(int zoornMode, double userScale=O); BOOL SetGridOn(BO0L gridon); // Las siguientes funciones contestan los rnensages para el usuario: LRESULT EvUDeleteObject(WPARAM, LPARAM); LRESULT EvUDeleteAII(WPARAM, LPARAM); LRESULT EvUFlipToBack(WPARAM, LPARAM); LRESULT EvUFlipToFront(WPARAM, LPARAM); LRESULT EvURotateCCW(WPARAM, LPARAM); LRESULT EvURotateCW(WPARAM, LPARAM); LRESULT EvUReadObjList(WPARAM, LPARAM); LRESULT EvUSaveObjList(WPARAM, LPARAM); void EvHScroll(U1NT code, UlNT ps, HWND wnd); void EvVScroll(U1NT code, UlNT ps, HWND wnd);

DECLARE-RESPONSE-TABLE(TDrawingW indow); 1; #endif

Programa de Cabecera DRAW.H

DRAW,+ Archivo Manelador de herramientas de trazo interactivas //

#ifndef DRAWH #define DRAWH #include <owl\applicat. h> #include <owl\framewin.h> #include <owl\dc.h> #include <stdio.h> #include <math.h> #define NOHANDLE -1 #define NWHANDLE O #define NHANDLE 1 #define NEHANDLE 2 #define EHANDLE 3 #define SEHANDLE 4 #define SHANDLE 5 #define SWHANDLE 6 #define WHANDLE 7 #define SIZEFRAME 8 #define LASTHANDLE 8

class TDrawingTool; // Clase principal

// Mantiene el dibujo actual y los parametros del Objeto específico //como el color, relleno de color, y demas. class TPaintContext { public: TDrawingTool* Tool; int PenWd; COLORREF Pencolor; COLORREF Brushcolor; HWND DrawingWnd; TWindow* OWLWindow; double Zoom; int Offsx, Offsy; int SnapWd, SnapHt; BOOL SnapOn; TPaintContext(); void SetSnapToGrid(int snapWd, int snapHt); POINT SnapToGrid(POINT& pt); BOOL SetSnapToGridOn(BO0L snapon);

de dibujo utilizadas en el programa principal de dibujo.

// ldentificadores para cada uno de los tamanos de // manejadores de redimensión del marco de objetos // Estas son usados para especificar //cual cursor del ratón se usa actualmente // con el objeto.

// Usar el siguiente manejador disponible

// Apuntador seleccionado de la herramienta actual / /El Ancho de la pluma // El color de la pluma // El Color de la brocha // La ventana para trazos de dibujo // Clase derivada de los Objetos OWL // Factor de acercamiento // Offset de dibujo en coordenadas de la ventana // Ancho y alto " del Snap to Grid" //Autorización para representar el grid

1;

I18

- Apéndice E

// Clase base que define el formato básico de la herramienta de dibujo class TDrawingTool { public:

POINT Pt l , Pt2; TPaintContext' PC; HDC hDC; HPEN hPen; HBRUSH hBrush; HCURSOR hcursor; virtual void Select(TPaintContext* pc); virtual void Deselect() ( ) // Comienza el process0 interactivo del dibujo virtual BOOL LButtonDown(POINT& pt); // Dibujo de figuras lnteractivamente virtual void MouseMove(POINT& pt); virtual BOOL LButtonUp(POINT& pt); // Finalización del dibujo virtual BOOL RButtonDown(POINT& pt) { return LButtonUp(pt); ) virtual void Start() ( Show(hDC, PC->Zoom, PC->Offsx, PC->Offsy); } virtual void Finish(); virtual void Show(HDC, double zoom, int offsx=O, int offsyd) ( } virtual HICON Getlcon() { return O; ) virtual void UpdateCursor(POINT& pt) ( ) virtual void SortPoints(); virtual void SelectCursor(int id);

// posisión actual y ultima del raton // Parámetros de dibujo // Despliega dispositivos de contexto // El estilo de la pluma de dibujo // El estilo de la brocha // La herramienta del cursor // La herramienta seleccionada // La herramienta no seleccionada

// Desplega los parámetros del marco

//toma un icono de la herramienta //Coloca el cursor del raton

1; class TLineTool : public TDrawingTool { // Dibujar líneas individuales public: void Start(); void SelectCursor(int id); void Show(HDC hDC, double zoom, int offsx=O, int offsy=O); HICON Getlcono;

1;

class TRectangleTool : public TLineTool ( / / Dibujar un rectángulo completo public: void Startli: >, . void Show(HDC hDC, double zoom, int offsx=O, int offsy=o); HICON Getlcon();

1. 11

class TEjesTool : public TLineTool ( public:

// Dibuja ejes coordenados

void Start(); void Show(HDC hDC, double zoom, int offsx=O, int offsy=O);

// void EscalaX(HDC hDC, double zoom, int offsx=O, int offsy=O,

I19

Apéndice E

/I int ndisx,int vix, int ndelx, int ndx,int X I ,int y l ) ;

int ndisx,int vix, int ndelx, int ndx,int x l ,int yl); void EscalaX(HDC hDC, double zoom,

HICON Getlcono; 1; // Dibuja un rectángulo VaCiO class TEmptyRectangleTool : public TRectangleTool ( public: void Show(HDC hDC, double zoom, int offsx=O, int offsy=O); HICON Getlcon();

1; const int MAXPOLYSIZE = 40; class TPolylineTool : public TLineTool ( protected:

public:

// Puede tener muchos límites /I Trazo de líneas conectadas

// Si es verdadero, un polígono sera dibujado BOOL Drawing;

POINT Poly[MAXPOLYSIZE]; int NumPts; TPolylineTool() ( Drawing = FALSE; ) BOOL LButtonDown(POINT& pt); BOOL LButtonUp(POINT& pt); BOOL RButtonDown(POINT& pt); void Start(); void Show(HDC hDC, double zoom, int offsx=O, int offsy=O); HICON Getlcon();

// La lista de puntos en la figura I/ Número de coordenadas de un polígono

1;

/I Dibuja un polígono completo se liga con TPolylineTool class TPolygonTool : public TPolylineTool ( public: void Show(HDC hDC, double zoom, int offsx=O, int offsy=O); HICON Getlcon();

1; class TEllipseTool : public TRectangleTool ( public:

// Dibujar una elipse

void Show(HDC hDC, double zoom, int offsx=O, int offsy=O); HICON Getlcon();

1;

I/ Dibujar una elipse vacia class TEmptyEllipseTool : public TEllipseTool (

I20

Apéndice E

public: void Show(HDC hDC, double zoom, int offsx=O, int offsy=O); HICON Getlcono;

1 1; const int DEFAULTWD = 20; const int DEFAULTHT = 20; const int MAXSTRING = 80; class TTextTool : public TDrawingTool { public:

I/ Ancho y alto de el texto

// Largo que puede ser la cadena /I Clase registro de texto

/I Ancho y alto del texto /I Cadena de entrada

I/ cadena de default /I Dimensiones del texto

int Wd, Ht; char Str[MAXSTRING]; TTextTool() {

&[O] = '\O; Wd = DEFAULTWD; Ht = DEFAULTHT;

1 BOOL LButtonDown(POINT& pt) { return TRUE: ) BOOL RButtonDown(POINT&) ( return FALSE; ) void MouceMove(POINT& pt) { ) void Start() ( ] BOOL LButtonUp(POINT&); void Show(HDC hDC, double zoom, int offsx=O, int offsy=O); HICON Getlcon(); void GetTextSize(SIZE& size); void SelectCursor(int id);

/I Los objetos del texto I/ no soportan estas I/ Cuatro funciones

);

#if defined(WIN32-)

11 Sporta una curva Bezier en la herramienta si compila es para Win32 class TBezierTool : public TPolylineTool { public: POINT BezierPts[MAXPOLYSIZE"4]; void Show(HDC hDC, double zoom, int offsx=O, int offsy=O); HICON Getlcono; void Start(); BOOL LButtonUp(POINT& pt);

11 Incluye el control de puntos

1; #endif #endif

i

i

!

! ! ,

I

i

~

i

!

i

~

~

!

!

i

i

121

Abreviuturus

ABREVIATURAS

CENIDET CEntro Nacional de Investigación y DEsarrollo Tecnólogico.

CFE Comisión Federal de Electricidad

IIE Instituto de Investigaciones Eléctricas.

GEO Grupo de Estudios Oceanográficos.

2-D O 2D Dos Dimensiones.

DLL Librerías de Enlace Dinámico.

GUI lnterfaz Gráfica de Usuario.

SlCOlG Sistema de Construcción de Interfaces Gráficas.

OWL Librería de Objetos de Windows.

OOD Dispositivo Orientado a Objetos. (Orient Object Device)

PO0 Programación Orientado a Objetos

122

Referencias Bibliográficas

BlBLlOGRAFíA

1. “Ciencia y Sociedad. Sección: Neurología; Primeros Pasos en la detección de Formas, Javier Cudeiro, Investigación y Ciencia, agosto de 1996.

2. ‘‘programas Inteligentes”. Sección: Técnicas de Información, Pattie Meas, Investigación y Ciencia, noviembre de 1995.

3. Visualization in Scientific Computing, Special Report: A Synopsis, IEEE july 1987.

4. “ATLAS OCEANOGRAFICO DEL GOLFO DE MEXICO, Volumen 3”. Serie Atlas Oceanográfico del Golfo de México. V.M. V.vidal, F. V.vidal, A.F. Hernández, E. Meza y L. Zambrano. Instituto de Investigaciones Eléctricas, Cuernavaca, Mor., México, noviembre de 1994,ISBN 968-6357-03-3. 586 páginas.

5. “Desarrollo de una lnterfase para el Análisis de Bases de Datos Topográficos de Evolución de Playas”. Dulce Ma. Heredia Guzman, Instituto Tecnológico de Zacatepec, Tesis de Licenciatura en Informática, abril de 1995. Zacatepec Mor.

6. “Futuro de la Industria de los Semiconductores”. Sección: Técnicas de Información, G. Dan Hutcheson y Jerry D. Hutcheson, Investigación y Ciencia, marzo de 1996.

7. COMPUTER innovative Technology for Computer Professionals. (revista especial de Programacón Visual), IEEE COMPUTER SOCIETY, marzo de 1995.

8. COMPUTER innovative Technology for Computer Professionals. (revista “Ambiente para el Desarrollo de Programación Visual de Interfaces de Usuario para Monitoreo de Procesos en Línea”. René Santaolaya Salgado, CENIDET, Tesis de Maestría en Ciencias de la Computación, mayo de 1994. Cuernavaca Mor.

9. Segregation of Form, Color, Movement, and Depth: Anatomy, Physiology and Perception. Margaret Livingstone and David Hubel, Deparment Of Neurobiology, Harvard Madical School, Boston MA021 15, pp. 177-186.

10.Programming Windows 3.7. Charles Petzold. Microsoft Corporation, One Microsoit Way, Redmond, Washington 98052-6399.

123

Referencias Bibliográjkas

11.Manual de Borland C++. Chris H. Pappas, William H. Murray, I l l , McGRAW- HILUINTERAMERICANA DE ESPAÑA, S.A. Madrid 1993.

12. Borland ObjectWondows for C+i, Reference Guide, Class Reference Event- Handling functions. Borland international Inc. Version 2.0 1993.

13. Desing Patterns, Elements of Reusable Object-Oriented Software. Erich Gamma, Richard Helem, Ralph Johnson and John Vlissides Robert. Addison- Wesley Publishing Company, 1995.

14. Windows Graphics Programming With Borland C++. Loren Heiny, editor John Wiley & Sons, Inc, Second Edition, 1994.

15.Algorithms. Robert Sedgewick , Brown University. Addison-Wesley Publishing Company, August 1984.

16.Computer Aided Geometric Desing. Robert E. Barnhill, Richard F. Riesenfeld Academic Press New York San Francisco London 1974.

17. Numerical Computing and Mathematical Analysis. Stephen M. Pizer. Department of Computer Science. University of North Carolina, Chapel Hill, N.C. 1985.

18. Visiometric, Juxtaposition and Modeling. Norman J. Zabusky, Deborah Silver, Richard Pelz and Vizgroup 93.Physics Today. march 1993. Volumen 46, No. 3.

19. Computer Grafhics and Aplications. IEEE.

20. Distribución Espacial Costera de los Radionúclidos Contenidos en la Descarga del Agua de Enfriamiento de la Central Laguna Verde. V.M.V. Vidal, F.V. Vidal, J.M. Pérez Molero, R. Anaya.lnstituto de Investigaciones Eléctricas. Informe Final No. 16994IE,febrero 1985.

21 Statistical and Dynamical Prediction of Changes in Natural Sand Beaches. David G. Aubrey, 1978. UNIVERSITY OF CALIFORNIA, San Diego.

22.Report on Data from the Nearshore Sediment Trnsport Study Experimental at Leadbatter Beach, SANTA BARBARA, CALIFORNIA, 1980. Edited by C.G. Gable, February, 1981. UNIVERSITY OF CALIFORNIA, Institute of Marine Resources, Mail Code-A022, Scripps Institution of Oceanography, La Jolla, California 920093.

I24

Referencias Bibliogrúficus

23.COMPUTER innovative Technology for Computer Professionals. (revista especial de Programacón Visual), IEEE COMPUTER SOCIETY, marzo de 1995.

24."Desarrollo de un Sistema de Modelación Costera: Modelos Numéricos, Sistemas Computacionales, Modelos Físicos y Estudios de Verificación. Parte Ill: Sistema Computacional para el Procesamiento y Análisis de Perfiles Playeros". L. Zambrano, F. V.vidal, V.M. V.vidal, E.Meza, y J.M. Pérez. Informe IIE/UREN/13/10044/103/P-l. Cuernavaca, Morelos, México, septiembre de 1995. 81 páginas.

.. ...

\:.-----.---

125

9 8 - 1 0 4 3

Documents

cenidet · basadas en un framework para la representaci~n de informaci~n’~~ tesi s maestro en ciencias de la computaci~n que como requisito para obtener el grado de: p r e s e n