Proyecto Atlas Quemaduras - Universidad de...

UNIVERSIDAD DE SEVILLA

ESCUELA SUPERIOR DE INGENIEROS

INGENIERÍA DE TELECOMUNICACIÓN

PROYECTO FIN DE CARRERA

Atlas Multimedia de Quemaduras Departamento de Teoría de la Señal y Comunicaciones

Autor: Sergio Pérez Gala

Tutora: Begoña Acha Piñero

Junio 2006

Atlas de Quemaduras

I. Objetivos del Proyecto ............................................. I-3

II. Programación en el Entorno Director .................... II-5

II.1 Introducción a Director 8.......................................................II-5

II.2 La metáfora de Director 8 para llamar a sus elementos .......II-7

II.3 Introducción al lenguaje Lingo ............................................II-15

III. Rutinas y su Particularización en el Proyecto.... III-27

IV. Resultados: Estructura del Atlas........................ IV-72

IV.1 Introducción al Atlas: Punto de Vista Médico .................. IV-72

IV.2 Estructura del Atlas ......................................................... IV-81

V. Conclusiones y Líneas Futuras ......................... V-109

VI. Bibliografía.......................................................... VI-111

Atlas de Quemaduras I. Objetivos del Proyecto

I-3

I. Objetivos del Proyecto

El objetivo del proyecto es la realización de un atlas de

quemaduras interactivo que sirva como herramienta didáctica y

orientativa a todo tipo de personal médico, mejorando el

conocimiento sobre las quemaduras, su etiología, profundidad y

extensión. Está formado por numerosas imágenes reales tomadas

en la Unidad de Grandes Quemados del H.H.U.U. Virgen del Rocío

de Sevilla y facilitadas por la médico en la especialidad de Cirugía

Plástica Araceli Lagares Borrego.

El atlas presenta diversas ventajas respecto a un libro sobre

esta materia:

� El hecho de ser interactivo y muy visual facilita el acceso a los

diferentes apartados de manera intuitiva, fácil y rápida.

� El formato digital (CD) en el que se presenta permite tener

una gran base de datos e información, en la que hay más de

500 fotografías, lo que supondría un gran coste en el

desarrollo de un libro.

� La facilidad de actualización y de aumento del contenido del

atlas es sencilla y mucho menos costosa. En tal caso se

podría recurrir a un DVD incrementando las prestaciones y

posibilidades del mismo.

Al estar encaminado tanto a estudiantes de medicina,

residentes de cirugía plástica, enfermeros y médicos generalistas,

Atlas de Quemaduras I. Objetivos del Proyecto

I-4

las imágenes que se muestran pueden ser desagradables a la vista

de cualquier persona.

Este proyecto es una ampliación y mejora del realizado por

Iván María González Guzmán [1].

Atlas de Quemaduras II. Programación en el Entorno Director

II-5

II. Programación en el Entorno Director

II.1 Introducción a Director 8

El programa Director 8 de Macromedia es la herramienta

software más usada en todo el mundo para la creación y desarrollo

de cualquier producto multimedia. Es una herramienta de las

llamadas “visuales”, lo cual nos permite hacer gran parte del trabajo

sin recurrir a un lenguaje de programación propio llamado Lingo que

permite controlar y asignar a nuestra aplicación una serie de

recursos y propiedades muy útiles.

Director permite crear aplicaciones de autor llamadas

películas, donde la interactividad y la animación son sus principales

baluartes. Obtenemos así productos de gran valor visual, y

programas independientes que funcionan en cualquier ordenador

sin necesidad de tener instalado el programa en él, con lo cual

obtenemos una mayor flexibilidad al poder estar destinado a

cualquier usuario.

Conviene decir también que con este capítulo no se pretende

realizar un manual para usuario de Director 8, pues para ello ya

existe una amplia bibliografía a la que se puede consultar si se está

interesado en el uso de este programa. Sólo se hace una

introducción en la que se indica las posibilidades que posee y

herramientas que utiliza, de manera que el lector se pueda hacer

una idea de funcionalidad y posibilidad del mismo.


II-6

A continuación vamos a ver distintos aspectos relacionados

con el programa, los cuales vamos a dividir en dos partes:

� La metáfora de Director 8 para llamar a sus elementos:

Director emplea una metáfora para nombrar cada una de sus

partes. Veremos cada uno de estos nombres y su

funcionalidad dentro del programa.

� Introducción al lenguaje Lingo: es el lenguaje usado por

Director. Es la herramienta más potente a la hora de realizar

los proyectos multimedia, ya que se pueden programar

acciones que en el entorno gráfico de Director no son

posibles. Aunque en un principio era un lenguaje muy simple

orientado a controlar animaciones, actualmente está orientado

a objetos, pudiéndose comparar con C y Pascal, así como con

lenguajes orientados a internet como Java.


II-7

II.2 La metáfora de Director 8 para llamar a sus

elementos

Dentro de esta metáfora, el propio programa tiene una

denominación acorde a la situación. Se trata de un “director de cine”

(director) que elabora unos archivos que son las “películas”

(movies) generadas en un “escenario” (stage) con unos “actores”

(sprites) que forman parte de un “reparto” (cast) y siguen un “guión”

(score, scripts). Dicha películas pueden ser visualizadas de forma

independiente utilizando unos archivos ejecutables llamados

“proyectores” (projector). Esta metáfora facilita la compresión, y

sobre todo, hace mucho más intuitivo el proceso de creación de un

producto multimedia.

A continuación vamos a explicar cada uno de estos elementos

por separado:

� Stage (Fig. II.1): Es el escenario donde se sitúan nuestros

actores. La ventana de stage actúa como previsualizador de la

película que estamos creando, pero también sirve como

herramienta de edición porque dentro de ella se pueden ir

modificando los elementos que intervienen en la película.


II-8

Fig. II.1: Stage del apartado Introducción

� Cast (Fig. II.2): Reparto, no es más que el espacio físico

donde se guardan y organizan los elementos que intervienen

en la película y que serán llamados a escena conforme a unos

parámetros que intervienen en la película y que podemos

definir a voluntad. Existen dos tipos de cast: el interno, el cual

forma parte de la película y se incluye dentro de la misma, y el

externo que no forma parte del archivo de la película, pero

cuyos miembros están vinculados a la misma y se utilizan en

su reproducción. Normalmente el cast interno se usa para

almacenar aquellos actores que permanecen invariables a lo

largo de toda la película como la imagen de fondo, texto, etc.

El cast externo se usará, por lo general, para guardar los

miembros del reparto que tienen una aparición puntual o bien

un tamaño de archivo considerable.


II-9

Fig. II.2: Internal cast del apartado Cuidados Iniciales

� Score (Fig. II.3): No es más que el guión o partitura de

nuestra película. El aspecto de su ventana recuerda mucho a

las líneas de tiempo de los editores de vídeo. El score está

dividido horizontalmente en fotogramas (“frames”, que son las

unidades mínimas en que se divide nuestro eje temporal de

reproducción) y verticalmente en canales agrupados en dos

partes: una superior formada por el canal dedicado a las

transiciones, los dos canales de sonido, otro dedicado a la

paleta de colores usada en la película, otro dedicado al control

temporal de la misma y por último otro destinado a los scripts

o guiones Lingo. La parte inferior está formada por los canales

de sprite que no son otra cosa que los personajes del cast que

han saltado a escena. El score nos sirve de referencia

temporal. En la parte superior podemos ver los “markers”,


II-10

necesarios para saltar de un lado a otro de la película, así

como la barra de herramientas del sprite seleccionado.

Fig. II.3: Score del apartado Infecciones en el Paciente

� Scripts: Son porciones de código escritos en Lingo que

permiten controlar todo lo que ocurre en nuestra película y

dotarle de interactividad. Hay varios lugares donde podemos

poner nuestros scripts, afectando eso al ámbito de acción que

tendrá el mismo: por ejemplo si colocamos el script en el canal

del score dedicado a ese fin, la acción afectará a todos los

fotogramas que estén bajo él y a todos los actores que estén

en escena en esos fotogramas. También podemos tener

scripts de película (afectan a toda la película y se sitúa en el

cast), de sprite (afectan a un actor puesto en escena o sobre

el cast y controlan sobre todo las acciones relacionadas con el

ratón) y de miembro del reparto (son diferentes a los de sprite,

ya que los de sprite afectan al actor en esa puesta en escena


II-11

en particular, mientras que los de miembro de reparto afectan

al actor en cada puesta en escenas que hagamos de él).

� La estrategia: Es quizás un elemento más conceptual que

otra cosa, pero es uno de los elementos más importantes a la

hora de trabajar con Director. Hay que tener claro qué es lo

que pretendemos hacer desde un principio: tener bien claro

los objetivos de nuestra aplicación, a quién va dirigida, hasta

dónde queremos llegar.

� Behavior (comportamiento) (Fig. II.4): No es más que una

nueva forma de añadir interactividad a nuestra película. Un

behavior no es más que un script con nuevas propiedades y

características tales como: la posibilidad de que varios sprites

o fotogramas compartan un behavior (reutilización del código

ya escrito), podemos asociar más de un behavior a un sprite

(no así a un fotograma), podemos modificar o añadir

parámetros a un behavior con la ventana del Inspector

Behavior (Fig. II.5), etc. Esta ventana es una herramienta muy

útil para la creación o modificación de nuestros behaviors. En

el proceso de creación hemos de tener claro lo que es un

evento, algo que ocurre en el desarrollo de nuestra película y

que usaremos como disparo para realizar una determinada

acción. Es así como podemos dotar de interactividad a

nuestra película (por ejemplo, un evento podría ser el pulsar el

botón izquierdo del ratón mientras se está ejecutando la

película).


II-12

Fig. II.4: Behavior Script (Al pulsar con el ratón sobre el sprite salta a la

película Introducción)

Fig. II.5: Behavior Inspector del sprite Introducción

Para facilitarnos enormemente las cosas, Director 8 dispone

de una amplia biblioteca de comportamientos (library palette

Fig. II.6) que nos permite realizar la mayoría de acciones que

imaginemos. No obstante, en ocasiones será necesario

modificar los comportamientos existentes o crear alguno

nuevo usando la ventana del behavior inspector.


II-13

Fig. II.6: Library Palette (Comportamientos de la sección Animación

Interactiva)

� Xtras: Son aportaciones desarrolladas por terceras empresas

(ajenas a Macromedia) que pretenden cubrir ciertas

deficiencias, tratar problemas específicos y ayudarnos en

nuestro trabajo diario con Director. Para usar un xtra es

necesario instalarlo previamente (aunque la mayoría de ellos

se instala por defecto al instalar el programa Director). Una

vez realizada la instalación, bastará con seleccionarlo en el

menú del mismo nombre que está presente en la barra de

herramientas. Algunos de los xtras incluidos en Director son:

librería de botones, librería de paletas, PrintOMatic (útil para

enviar información desde la película a una impresora),…

� Shockwave: De igual forma que es necesario crear el

projector para que nuestra película pueda ser visionada en un

ordenador que no tenga instalado Director, la herramienta

Shockwave debe ser instalada en el navegador de internet

para que nuestra película pueda ser visionada en la red. Es

decir, Shockwave es la herramienta que nos permite lanzar


II-14

nuestra película a la red. Pero para ello es necesario realizar

una serie de pasos previos, sobre todo en lo que se refiere a

la compactación de la película, ya que la velocidad a la que

viaja la información en Internet es bastante más reducida que

a la que trabaja un PC medianamente potente. En este

sentido Lingo puede ayudarnos, ya que dispone de una serie

de comandos que permiten adaptar nuestra película a este

nuevo medio.


II-15

II.3 Introducción al lenguaje Lingo

Lingo y guiones

Lingo es el lenguaje de programación que usa Director. Este

lenguaje constituye la herramienta más potente a la hora de realizar

los proyectos multimedia, ya que se pueden programar acciones

que en el entorno gráfico de Director no son posibles. Aunque en

sus principios era un lenguaje muy simple orientado casi

exclusivamente a controlar animaciones, actualmente es un

lenguaje completamente orientado a objetos, pudiendo llegar a

compararse en potencia de programación tanto a C y Pascal como,

sobre todo, a los lenguajes orientados a Internet como Java.

Lingo se concibió en las primeras versiones de Director como

una forma de controlar su entorno, es decir, la partitura (Score), el

reparto (Cast) y el escenario (Stage). Al escribir cualquier código en

Lingo estamos creando un guión, y cada uno de estos guiones

constituye un miembro de reparto, como también lo son las

imágenes o vídeos. Concretamente, un guión es un miembro del

reparto que contiene una pieza de texto que es válida en código

Lingo.

Una vez escrito, un guión se puede asociar a cualquier otro

miembro de reparto, como por ejemplo imágenes o sonidos, aunque

también se puede situar en la Partitura, asociado a un fotograma

(Frame) determinado.


II-16

Este lenguaje tiene la particularidad de que casi se puede leer

como si fuera el idioma inglés, lo que le hace más sencillo tanto de

comprender como de aprender, ya que hoy en día el inglés no

debería ser un obstáculo al nivel que nos movemos. Esta relativa

facilidad de aprendizaje se debe a que todos los comandos,

funciones y otras palabras claves en Director son palabras, grupos

de palabras o abreviaciones en inglés.

Para crear guiones se puede partir de varios puntos: partir de

cero mediante la ventana de guiones (Script Window Fig. II.4), usar

el inspector de comportamientos (Behavior Inspector Fig. II.5) para

seleccionar un evento y una acción, o podemos usar un

comportamiento ya elaborado desde la paleta de la biblioteca

(Library Palette Fig. II.6), bien en su forma original o bien

modificándolo.

Tipos de guiones

Respecto a los tipos de guiones de Lingo existen

discrepancias entre distintos autores. Existe un grupo de éstos que

consideran que las diferencias entre un guión y un comportamiento

(behavior) son meramente históricas, y que a partir de la versión 8

de Director dichas diferencias han desaparecido. Podría

considerarse esto como cierto, ya que tanto guiones como

comportamientos son instrucciones escritas en Lingo.

Sin embargo, los autores más detallistas consideran que sí

hay diferencias, y exponen que todos los comportamientos son

guiones, pero no todos los guiones son comportamientos. La


II-17

principal diferencia es que los comportamientos deben escribirse

según las reglas de la programación orientada a objetos y tratarse

como un objeto que se puede utilizar y personalizar de nuevo,

dotado de parámetros que puedan ser configurados de forma

independiente para cada instancia del mismo.

Esta segunda distinción parece más acertada para niveles

avanzados de programación, que serán en los que nos movamos.

Además, como se muestra en la Fig. II.7, Director diferencia

claramente a la hora de elegir el tipo de guión entre los tres que

describiremos, entre los que se encuentra el behavior. Así, los

guiones pueden ser de tres tipos: de película, de comportamiento o

padre.

Fig. II.7: Property Inspector

Otros miembros de reparto, como las imágenes de mapa de

bits, o cualquier otro tipo de miembros, pueden tener guiones dentro

de sí mismos. Éstos son llamados normalmente guiones de reparto.

La diferencia entre todos estos tipos de guión no está en qué

aspecto tienen o cómo se comportan, sino en cuándo actúan.


II-18

Un guión de película es una presencia global en una película.

Un guión de comportamiento es similar en concepto a los

comportamientos. No hace nada hasta que se sitúa en un sprite o

en un canal de guión de fotograma. Si se sitúa sobre un sprite, los

comandos Lingo dentro del guión están activos sólo en lo que al

sprite se refiere. Los guiones de comportamiento son a veces

llamados guiones de sprite o partitura por esta razón.

Los guiones de comportamiento pueden ser asignados

también al canal del guión de fotograma de la partitura. Cuando se

hace esto, actúan como guiones de película, pero sólo para el

fotograma o fotogramas a los que son asignados. Los

comportamientos usados de esta manera son llamados a veces

guiones de partitura.

Guiones padre son un tipo de guión mucho más avanzado. No

están asociadas a ningún otro elemento, y funcionan como

instancias de objetos independientes. Realmente no hacen nada

hasta que usa algunos comandos Lingo de programación orientada

a los objetos para decirles cómo y cuando deben utilizarse.

Los guiones de reparto, por otra parte, son fáciles de usar.

Puede crearse uno seleccionando un actor, como por ejemplo una

imagen de mapa de bits, y haciendo clic sobre el botón de guión en

la parte superior de la ventana de reparto (Cast window). Esto abre

la Script Window y le permite añadir un guión a ese miembro del

reparto en particular.


II-19

Los guiones de reparto actúan solamente en ese miembro del

reparto. Si se usa a ese miembro del reparto más de una vez en la

partitura, el guión con él está activo en todos esos lugares. Sin

embargo, no debe confundirse un guión de miembro de reparto con

un comportamiento: un miembro de reparto puede aparecer muchas

veces en la película, e incluso puede haber varias instancias de ese

miembro al mismo tiempo en el escenario (cada una de estas

estancias será un “sprite”). El guión de miembro de reparto se aplica

siempre a ese miembro, mientras que el comportamiento se aplica

solo a un aparición de éste (es decir, a un sprite).

Para crear o modificar guiones se usa la Script Window. La

importancia de esta ventana a la hora de programar en Lingo

merece que expliquemos un poco sus partes (Fig. II.8):

Fig. II.8 Behavior Script de la rutina Rollover Cursor Change


II-20

La parte superior tiene los típicos botones de miembro del

reparto de Director que nos llevan hacia atrás y adelante en el

reparto, nos permiten añadir un nuevo miembro del reparto y nos

permitan cambiar bibliotecas de reparto. El resto de botones tratan

como funciones más avanzadas de Lingo tales como correctores,

inserción de breakpoints (puntos donde se parará la ejecución del

guión, para facilitar su depuración), recompilación del guión,…

Los dos botones llamados “Alfabetical Lingo” y “Categorized

Lingo” nos permiten buscar e insertar automáticamente en un guión

cualquier palabra clave de Lingo. Son muy útiles cuando no

podemos recordar el nombre de un comando, o cuando no

recordamos la sintaxis apropiada para usar comandos Lingo.

Por último, hay que decir que mediante “Property Inspector”

podemos cambiar el tipo de guión (Fig. II.7).

Contadores y eventos

Lingo está diseñado para responder a eventos en el entorno

de Director. Prácticamente todas las acciones que tienen lugar en

una película son eventos y mientras se reproduce una película de

Director, éste emite notificaciones internas llamadas mensajes,

indicando los eventos que han tenido lugar. Esto da lugar a que

prácticamente podamos intervenir en cualquier momento de la

película en función del tipo de evento que se produzca.


II-21

Los eventos pueden ser de varios tipos, como por ejemplo de

reproducción (startMovie, enterFrame,…), de respuesta del usuario

(keyDown, mouseDown,…), de tiempo (idle, timeOut) o de ventana

(acivateWindow, openWindow,…).

Los controladores de eventos o handlers (los llamaremos a

partir de ahora sólo controladores) se pueden considerar como

hojas de instrucciones dirigidas a realizar varias tareas. Los

controladores están asociados a los eventos, es decir, cuando se

produce un evento, actuará el controlador asociado a dicho evento.

La estructura del controlador es la siguiente:

� Comienzan con la palabra on seguida por un evento.

� Incluyen una serie de acciones que han de producirse cuando

el evento tiene lugar.

� Terminan con la palabra end.

Si un guión incluye varias instrucciones, se van ejecutando

progresivamente una después de otra hasta llegar al final del

controlador.

Ejemplo:

on mouseUp me go to movie "Introduccion" end

Este controlador indica que cuando se pulsa el botón

izquierdo del ratón sobre el elemento al que está asociado y se

suelta, vaya a la película “Introducción”. Como puede apreciarse,

puede leerse fácilmente el significado, pues Lingo intenta

asemejarse al idioma inglés (excepto por la palabra “me”, que es un


II-22

parámetro de la función indicando que el objeto sobre el que se

aplica la función es el mismo guión al que pertenece).

El programador puede fabricar sus propios controladores, que

no respondan a ningún evento. En ese caso, al controlador también

se le puede llamar función. Los controladores es ese caso pueden ir

acompañados por argumentos, también conocidos como

parámetros, los cuales representan valores suplementarios que se

transmiten al controlador cuando se le invoca y que suministran la

información adicional que necesita la función para completar la

tarea para la que se ha programado. Estos parámetros se sitúan

detrás del nombre de la función. Este método de crear

controladores propios con parámetros tiene innumerables

aplicaciones.

Ahora bien, a una función sólo se le puede llamar desde el

ámbito desde el cual esa función es visible: desde la misma

instancia del mismo objeto al que pertenece (bien sea un guión de

comportamiento, o bien sea un guión padre). La única forma de

tener una función a la que se puede llamar desde cualquier tipo de

objeto es colocarla en un guión de película. Pero si queremos

comunicarnos con una función que está en un objeto determinado y

que no es visible, aún nos queda otra posibilidad: podemos mandar

un mensaje hacia ese objeto.

Para terminar de hablar de los controladores y eventos, sólo

hay que decir que a la hora de ejecutarse, los guiones siguen una

jerarquía definida. Es decir, al producirse un evento determinado, es


II-23

importante conocer a qué controlador va asociado, y si tiene que

ejecutar algún conjunto de instrucciones.

Supongamos que se produce un evento mouseDown (es

decir, si se pulsa el botón izquierdo del ratón). El primer lugar en el

que este evento se tendría en cuenta es en el sprite sobre el que se

ha pulsado el ratón. Si dicho sprite tiene asociado un controlador

con el evento en cuestión, lo recibe y realiza la acción

correspondiente que le indique el controlador. Si por el contrario no

tiene ningún comportamiento con un controlador asociado al evento

mouseDown, continuará buscando un controlador repetitivo.

El siguiente sitio donde mira es en los miembros del reparto,

es decir, chequea el reparto para ver si algún controlador lleva

asociado el evento mouseDown, y en tal caso lo ejecuta. Si

tampoco lo encuentra aquí, busca en los guiones de fotogramas y

finalmente, si esto también falla, se va a los guiones de película. Si

sigue sin encontrarlo, desecha el evento y sigue con la

reproducción de la película.

Elementos de Lingo

Las instrucciones incluidas en un controlador de Lingo están

formadas por una combinación de elementos, de forma idéntica a

las palabras de una frase en una lengua. Se pueden clasificar

según su función y las reglas determinan cómo se pueden

combinar.


II-24

Los elementos de Lingo se agrupan en las siguientes

categorías:

� Comandos: Indican, en una película, una acción. Por

ejemplo, go to ordena al cabezal de reproducción que se

desvíe hacia un fotograma concreto.

� Funciones: Devuelven un valor. Por ejemplo, date devuelve

la fecha establecida en el ordenador. Existen muchas

funciones Lingo, además de las que pueda escribir el

programador.

� Términos claves: Son palabras reservadas que tienen un

significado especial en Lingo. Por ejemplo, todas las

propiedades de Lingo y muchas propiedades y funciones de

los sprites deben ir precedidas por el término clave the. Este

término clave distingue el nombre de la propiedad de una

variable o del nombre de un objeto.

� Propiedades: Son atributos de un objeto. Por ejemplo,

thecolorDepth es una propiedad del monitor del ordenador

referente a la definición del color. Las propiedades también

pueden venir expresadas con sintaxis de punto, como por

ejemplo lista.count (número de elementos de una lista). En

este caso, lista es un objeto, y count, una propiedad suya.

� Operadores: Son términos que modifican o cambian uno o

varios valores. Por ejemplo, los operadores + ó <.


II-25

� Constantes: Son elementos que no cambian. Por ejemplo,

TRUE siempre tiene el mismo significado, el valor 1.

� Variables: Son fragmentos que se reservan en la memoria

para guardar ciertos valores. Las dos cualidades más

importantes de las variables son su tipo (entero, punto

flotante, carácter, cadena de caracteres, lista,…), y su ámbito.

En cuanto al ámbito, las variables pueden ser locales (sólo

accesibles en la función en que fueron declaradas), globales

(accesibles en toda la película) y propiedades (accesibles por

todas las funciones en una instancia de un objeto, bien sea

comportamiento, bien guión padre).

Primeros pasos: la ventana Message

Director envía mensajes cada vez que tiene lugar un evento

en la película (por ejemplo, pulsar el botón del ratón). A partir de los

eventos, Director desencadena una serie de acciones que

previamente se le han asignado mediante un controlador.

Estos mensajes son recogidos por Director en la ventana

Message, que no es más que un intérprete de Lingo, es decir, toma

comandos de Lingo y los evalúa de la misma forma que los guiones.

Por tanto, haciendo uso de esta ventana podemos visualizar la

forma de trabajar de Director. Esto supone una forma sencilla de

comenzar a aprender el funcionamiento de Lingo y Director.


II-26

Tenemos dos posibilidades a la hora de trabajar con la

ventana Message (Fig. II.9). Si el botón Trace está pulsado y

comenzamos a reproducir nuestra película, comenzarán a

aparecernos los distintos mensajes que envía Director, así como las

líneas de guión que ejecuta. Ésta es una forma de visualizar lo que

ocurre durante el transcurso de la película, ayudando notablemente

en la realización de proyectos tanto a nivel de principiante como a

nivel más avanzado. Por el contrario, si el botón Trace no está

pulsado, podremos practicar tal como escribiríamos los guiones en

Lingo, para ver los errores que cometemos y poder subsanarlos.

Ésta es una forma sencilla de probar y mejorar guiones.

Fig. II.9: Ventana Message

Atlas de Quemaduras III. Rutinas y su Particularización

III-27

III. Rutinas y su Particularización en el Proyecto

En el apartado anterior se mostró una introducción al

programa Director con sus distintos elementos, destacando el

lenguaje de programación Lingo.

En este punto veremos las distintas rutinas utilizadas en la

realización del atlas, tanto las de creación propia como las de la

biblioteca (“Library Palette”), particularizándolas en el proyecto y

asociándolas con imágenes del mismo para facilitar su

comprensión.

Rutinas

� Ir a un determinado marker:

Al pulsar sobre el sprite salta al marker indicado.

on mouseUp me go to "ClasificacionGrados" end

En la Fig. III.1 podemos observar que estamos situados en el

apartado “Fisiopatología” y una vez pulsado el sprite de

“Clasificación por Grados” salta hacia él (Fig. III.2). Por último la

Fig. III.3 indica el marker en el score.


III-28

Fig. III.1: Rutina “Ir a un marker”

Fig. III. 2: Rutina “Ir a un marker”


III-29

Fig. III. 3: Rutina “Ir a un marker”

� Ir a otra película:

Al pulsar sobre el sprite salta hacia otra película (“movie”).

on mouseUp me go to movie "Cuidados Iniciales" end

Estamos en la película “Rehabilitación y Prevención de las

Deformidades” (Fig. III.4) y al pulsar sobre el punto “Cuidados

Iniciales” nos situamos en dicho apartado (Fig. III.5).

Fig. III.4: Rutina “Ir a otra movie”


III-30

Fig. III.5: Rutina “Ir a otra movie”

� Ir a un marker de otra película:

Esta rutina es una unión de las dos anteriores y al pinchar

sobre el sprite salta a un marker de otra película.

on mouseUp me go to "Tratamiento del Paciente Quemado" of movie "Manejo del Paciente Quemado" end

� Ir al siguiente marker:

Se desplaza al marker siguiente.

on mouseUp me go to next end

� Ir al anterior marker:

Se desplaza al marker anterior.

on mouseUp me go to previous end


III-31

� Esperar:

La película se detiene hasta que el usuario interacciona con

ella.

on exitFrame me go to the frame end

La Fig. III.6 muestra el score donde la película se ha detenido.

Fig. III.6: Rutina “Esperar”

� Rollover Cursor Change:

Pertenece a la biblioteca (“library palette”) dentro del apartado

animación interactiva. Cambia el cursor del ratón (desde una mano,

dedo, reloj,…) cuando pasa por encima del sprite determinado.


III-32

-- DESCRIPTION -- on getBehaviorDescription me return \ "ROLLOVER CURSOR CHANGE" & RETURN & RETURN & \ "Changes the cursor when the mouse rolls over the current sprite. " & \ "Choose one of the pointers included with Director, or specify two 1-bit 16x16 pixel bitmap members: one to act as the pointer image, the other to define the transparent/opaque areas of the cursor." & RETURN & RETURN & \ "TIPS:" & RETURN & \ "Place a single pixel at the topRight and bottomLeft of the image itself to create what is in fact a 17x17 pixel bitmap. " & \ "These extra pixels will not appear in the cursor (they will be clipped) but the mask will align with them. " & \ "This ensures that the opaque area surrounds the cursor image correctly." & RETURN & RETURN & \ "Set the regPoint of the image to define the cursor's hotspot." & RETURN & RETURN & \ "PARAMETERS:" & RETURN & \ "* EITHER - Use one of Director's built-in cursors." & RETURN & RETURN & \ "* OR - Use your own bitmap images." & RETURN & \ "* Custom Image " & RETURN & \ "* Custom Mask" & RETURN & RETURN & \ "To use custom images, ensure that " & QUOTE & "1 bit bitmap" & QUOTE & " is selected as the type of cursor." end getBehaviorDescription on getBehaviorTooltip me return \ "Use with graphic members." & RETURN & RETURN & \ "Modifies the cursor when the mouse rolls over a sprite." & RETURN & RETURN & \ "You can use built-in or custom images for the cursor." end getBehaviorTooltip -- PROPERTIES -- property spriteNum -- author-defined parameters property myCursorType property myBuiltInCursor property myCursorMember property myCustomCursor


III-33

property myCustomMask -- internal properties property mySprite property mySavedCursor -- EVENT HANDLERS -- on beginSprite me SetSpriteCursor me end beginSprite on endSprite me mySprite.cursor = mySavedCursor end endSprite -- CUSTOM HANDLER -- on SetSpriteCursor me mySprite = sprite (me.spriteNum) -- Save cursor to revert to mySavedCursor = mySprite.cursor -- Set the cursor of the sprite if voidP (myCursorType) then mySprite.cursor = myBuiltInCursor exit end if case myCursorType of "Built-in cursor": mySprite.cursor = myBuiltInCursor "Cursor Member": myCursorMember = value (myCursorMember) cursorList = [myCursorMember.number] mySprite.cursor = cursorList "1 bit bitmap": myCustomCursor = value (myCustomCursor) cursorList = [myCustomCursor.number] if myCustomMask <> "no mask" then myCustomMask = value (myCustomMask) cursorList.append(myCustomMask.number) end if mySprite.cursor = cursorList end case end SetSpriteCursor


III-34

-- AUTHOR-DEFINED PARAMETERS -- on isOKToAttach (me, aSpriteType, aSpriteNum) case aSpriteType of #graphic: return TRUE #script: return FALSE end case end isOKToAttach on getPropertyDescriptionList me if not the currentSpriteNum then exit propertyDescriptionList = [:] cursorTypes = [] cursorMembersList = GetCursorMembers (me) cursorBitmapsList = GetCursorBitmaps (me) cursorMasksList = duplicate (cursorBitmapsList) cursorMasksList.addAt (1, "no mask") cursorMembers = cursorMembersList.count() bitmapCursors = cursorBitmapsList.count() if cursorMembers then cursorTypes.append ("Cursor Member") end if if bitmapCursors then cursorTypes.append ("1 bit bitmap") end if if cursorTypes.count() then cursorTypes.addAt (1, "Built-in cursor") propertyDescriptionList.addProp \ ( \ #myCursorType, \ [\ #comment: "CHOICE OF TYPE - Use which type of cursor?", \ #format: #string, \ #range: cursorTypes, \ #default: cursorTypes[1]\ ] \ ) propertyDescriptionList.addProp \ ( \ #myBuiltInCursor, \ [\ #comment: "CHOICE OF CURSOR - Built-in cursor:", \


III-35

#format: #cursor, \ #default: 280\ ] \ ) else return \ [ \ #myBuiltInCursor: \ [\ #comment: "Use which cursor?", \ #format: #cursor, \ #default: 280\ ] \ ] end if if cursorMembers then propertyDescriptionList.addProp \ ( \ #myCursorMember, \ [\ #comment: "- Cursor member:", \ #format: #member, \ #range: cursorMembersList, \ #default: cursorMembersList[1] \ ] \ ) end if if bitmapCursors then propertyDescriptionList.addProp \ ( \ #myCustomCursor, \ [ \ #comment: "- 1 bit bitmap (image)", \ #format: #bitmap, \ #range: cursorBitmapsList, \ #default: cursorBitmapsList[1]\ ] \ ) propertyDescriptionList.addProp \ ( \ #myCustomMask, \ [ \ #comment: "1 bit bitmap (mask)", \ #format: #bitmap, \ #range: cursorMasksList, \ #default: cursorMasksList[1]\ ] \ )


III-36

end if return propertyDescriptionList end on GetCursorMembers me cursorMembersList = [] maxCastLib = the number of castLibs repeat with theCastLib = 1 to maxCastLib maxMember = the number of members of castLib theCastLib repeat with memberNumber = 1 to maxMember theMember = member(memberNumber, theCastLib) if theMember.type = #cursor then if theMember.name = EMPTY then cursorMembersList.append(theMember) else cursorMembersList.append(theMember.name) end if end if end repeat end repeat return cursorMembersList end GetCursorMembers on GetCursorBitmaps me cursorBitmapsList = [] maxCastLib = the number of castLibs repeat with theCastLib = 1 to maxCastLib maxMember = the number of members of castLib theCastLib repeat with memberNumber = 1 to maxMember theMember = member(memberNumber, theCastLib) if theMember.type = #bitmap then if theMember.depth > 1 then next repeat if theMember.width > 20 then next repeat if theMember.height > 20 then next repeat if theMember.name = EMPTY then cursorBitmapsList.append(theMember) else cursorBitmapsList.append(theMember.name) end if end if end repeat end repeat return cursorBitmapsList end GetCursorMembers


III-37

� Rollover Member Change:

Esta rutina pertenece al apartado animación interactiva de la

biblioteca, como en el caso anterior. Sustituye un sprite del score

por otro del cast al pasar por encima el ratón.

-- DESCRIPTION -- on getBehaviorDescription me return \ "ROLLOVER MEMBER CHANGE" & RETURN & RETURN & \ "Change the sprite's cast member when the mouse rolls over the sprite." & RETURN & RETURN & \ "PARAMETERS:" & RETURN & \ "* Rollover cast member" end getBehaviorDescription on getBehaviorTooltip me return \ "Use with graphic members." & RETURN & RETURN & \ "Swaps a sprite's cast member on rollover." end getBehaviorTooltip -- HISTORY -- -- 22 October 1998, written for the D7 Behaviors Palette by James Newton -- -- Modified 7 January, 2000 by T. Higgins to include the isOKToAttach -- event handler along with removing some redundant error checking. property spriteNum property mySprite property myStandardMember property myRollovermember on beginSprite me mySprite = sprite (me.spriteNum) myStandardMember = mySprite.member end


III-38

on mouseEnter me mySprite.member = myRolloverMember end mouseEnter on mouseLeave me mySprite.member = myStandardMember end mouseLeave on isOKToAttach (me, aSpriteType, aSpriteNum) case aSpriteType of #graphic: return TRUE #script: return FALSE end case end isOKToAttach on getPropertyDescriptionList if the currentSpriteNum = 0 then exit theMember = sprite(the currentSpriteNum).member theMemberNumber = theMember.number return \ [ \ #myRolloverMember: \ [ \ #comment: "Display which member on rollover?", \ #format: #graphic, \ #default: member (theMemberNumber + 1) \ ] \ ] end getPropertyDescriptionList

La Fig. III.7 muestra el stage sin ninguno de los sprites

activos. A continuación vemos como el sprite “Sinusitis” ha

cambiado por otro del cast al estar el ratón encima (Fig. III.8).


III-39

Fig. III.7: Rutina “Rollover Member Change”

Fig. III.8: Rutina “Rollover Member Change”


III-40

� Pixelate:

Rutina perteneciente al apartado animación y transición de

sprites de la biblioteca. Crea una transición al principio o final del

sprite “pixelizando” la imagen. Posee varios parámetros entre ellos

la menor resolución tanto vertical como horizontal, la duración en

frames y la dimensión mínima del píxel (Fig. III.9).

-- OPENING COMMENTS -- Pixelate Transition -- Use this behavior on a sprite to have it resolve from or -- dissolve into a tile grid -- v1 20 December 1999 by Darrel Plant -- based on prototype by Mike Edmunds -- v2 22 December 1999 DP (QA Kraig Mentor) stringtable -- v3 27 December 1999 DP changes to timing -- v4 04 January 2000 DP bugfix -- v5 09 January 2000 DP bugfix 54413 -- v6 20 January 2000 bugfixes 54928 & 54597 KM (incorporated by DP) -- v7 30 January 2000 bugfixes -- fixed registration point problem -- fixed type background color problem -- added vector shapes and flash types -- changed from linear to geometric prograssion -- v8 04 February 2000 bugs 55811, 55855, 55702, 55703 -- v9 09 February 2000 type sprite size fix, pixelate routine optimization -- copyright 1999-2000, Macromedia, Inc. -- PROPERTY DECLARATIONS property appearWhen -- moves sprite on or off the stage property pixelateDuration -- number of frames for transition property horizontalPixels -- minimum number of pixels across property verticalPixels -- minimum number of pixels up and down property minimumDim -- minimum dimension for pixels grid


III-41

property spriteNum property mySprite property myStartFrame -- first frame of the transition property myEndFrame -- last frame of the transition property myOriginalMember -- original cast member for sprite property myOriginalImage -- original cast member image property myTransitionMember -- cast member used for transition property myAlphaMask -- image for manipulating current image mask property myPixelatedImage -- working image for pixelating image property myMultipliers -- values used to generate tile sizes --SPRITE HANDLERS on beginSprite (me) -- change string values for appearWhen and direction -- properties into symbol values me.convertAppearance () mySprite = sprite (spriteNum) myOriginalMember = mySprite.member case myOriginalMember.type of #bitmap: myOriginalImage = image (myOriginalMember.width, \ myOriginalMember.height, myOriginalMember.depth) myOriginalImage = myOriginalMember.image case myOriginalMember.depth of 32: if myOriginalMember.useAlpha then -- only use alpha if original member does myOriginalAlpha = myOriginalMember.image.extractAlpha() end if end case #text, #vectorshape, #flash: -- account for a problem when replacing text sprites with bitmaps if myOriginalMember.type = #text then mySprite.rect = mySprite.rect end if myOriginalImage = image (myOriginalMember.width, myOriginalMember.height, 32) if mySprite.ink = 0 then


III-42

-- if the text sprite is using copy ink, composite the masked image -- with the background color case myOriginalMember.type of #text, #flash: myOriginalImage.fill (myOriginalImage.rect, myOriginalMember.bgcolor) #vectorshape: myOriginalImage.fill (myOriginalImage.rect, myOriginalMember.backgroundcolor) end case myOriginalImage.copypixels (myOriginalMember.image, \ myOriginalMember.rect, myOriginalImage.rect, \ [#maskImage: myOriginalMember.image.extractAlpha()]) else myOriginalImage = myOriginalMember.image end if end case -- determine start and end frames of the transition case appearWhen of #start: -- move sprite onto the stage at the beginning of its span myStartFrame = mySprite.startFrame myEndFrame = myStartFrame + pixelateDuration - 1 #end: -- move sprite off the stage at the end of its span myEndFrame = mySprite.endFrame myStartFrame = myEndFrame - pixelateDuration + 1 end case -- create a new cast member to use for the transition myTransitionMember = new (#bitmap, castLib mySprite.castLibNum) -- create an image the same size as the original cast member myTransitionMember.image = image (myOriginalMember.width, \ myOriginalMember.height, 32, 8) -- set registration point to match original myTransitionMember.regpoint = myOriginalMember.regpoint -- copy the original member image to the transition cast member myTransitionMember.image.copyPixels(myOriginalImage, \ myOriginalMember.rect, myOriginalMember.rect) -- make sure the alpha channel is on for 32-bit if myOriginalImage.depth = 32 then myTransitionMember.useAlpha = TRUE end if -- create pixelated image and mask by downsampling both


III-43

myPixelatedImage = image (myOriginalMember.width, \ myOriginalMember.height, myOriginalImage.depth, 0) myMultipliers = me.generatePixelMults () end beginSprite on endSprite (me) mySprite.member = myOriginalMember -- after the sprite ends, get rid of the transition cast member -- this may not always work during authoring erase myTransitionMember end endSprite -- EVENT HANDLERS on prepareFrame (me) -- determine whether the transition is active if (the frame >= myStartFrame) and (the frame <= myEndFrame) then --find the number of frames since when the transition started elapsedFrames = the frame - myStartFrame + 1 -- invert the elapsed frames for end transitions if appearWhen = #end then elapsedFrames = pixelateDuration - elapsedFrames end if -- find the current pixelization factors currentHorzPixels = integer (minimumDim * power (myMultipliers.horz, elapsedFrames)) currentVertPixels = integer (minimumDim * power (myMultipliers.vert, elapsedFrames)) -- get the cast member rect memberRect = myTransitionMember.rect -- clear pixelated image myPixelatedImage.fill (myPixelatedImage.rect, 0) -- create pixelated image and mask by downsampling both pixelatedRect = rect (0, 0, currentHorzPixels, currentVertPixels) myPixelatedImage.copyPixels (myOriginalImage, \ pixelatedRect, memberRect) -- copy the pixelated image to the transition cast member myTransitionMember.image.copyPixels (myPixelatedImage, \ memberRect, pixelatedRect) -- set the member of the sprite to the transition sprite


III-44

mySprite.member = myTransitionMember else -- if the current frame is before or after the transition effect, -- then reset the cast member to the original cast member mySprite.member = myOriginalMember end if end prepareFrame -- CUSTOM HANDLERS on convertAppearance (me) -- changes property controlling when transition -- happens from a string to a symbol case appearWhen of "beginning of sprite": appearWhen = #start "end of sprite": appearWhen = #end end case end convertAppearance on generatePixelMults (me) multipliers = [:] horzFactor = (myOriginalMember.width / minimumDim) / horizontalPixels vertFactor = (myOriginalMember.height / minimumDim) / verticalPixels multipliers[#horz] = power (horzFactor, 1.0 / (pixelateDuration - 1)) multipliers[#vert] = power (vertFactor, 1.0 / (pixelateDuration - 1)) return multipliers end generatePixelMults -- BEHAVIOR DESCRIPTION BLOCK on isOKToAttach (me, aSpriteType, aSpriteNum) -- can be attached to either bitmaps or text isOK = FALSE case aSpriteType of #graphic: case sprite(aSpriteNum).member.type of #bitmap, #text, #flash, #vectorshape: isOK = TRUE end case end case return isOK


III-45

end isOKToAttach on getPropertyDescriptionList (me) props = [:] props[#appearWhen] = [ \ #comment: "When transition appears:", \ #format: #string, \ #default: "beginning of sprite", \ #range: ["beginning of sprite", \ "end of sprite"]] firstFrame = sprite (the currentSpriteNum).startFrame endFrame = sprite (the currentSpriteNum).endFrame maxLength = endFrame - firstFrame + 1 maxWidth = sprite (the currentSpriteNum).member.width maxHeight = sprite (the currentSpriteNum).member.height maxDim = max (2, min (maxWidth, maxHeight) / 2) props[#pixelateDuration] = [ \ #comment: "Duration:", \ #format: #integer, \ #default: 10, \ #range: [#min: 1, #max: maxLength]] props[#horizontalPixels] = [ \ #comment: "Lowest Resolution (horizontal):", \ #format: #integer, \ #default: 3, \ #range: [#min: 2, #max: maxWidth]] props[#verticalPixels] = [ \ #comment: "Lowest Resolution (vertical):", \ #format: #integer, \ #default: 3, \ #range: [#min: 2, #max: maxHeight]] props[#minimumDim] = [ \ #comment: "Minimum pixel dimension:", \ #format: #integer, \ #default: 4, \ #range: [#min: 2, #max: maxDim]] return props end getPropertyDescriptionList on getBehaviorTooltip return \ "Creates a transition where the sprite resolves from or into a grid of low-resolution pixels." end getBehaviorTooltip on getBehaviorDescription return \ "PIXELATE TRANSITION" & RETURN & RETURN & \ "Drop this behavior onto a sprite to create an animation where the sprite transforms from a low-resolution to high-resolution image." & RETURN & RETURN & \


III-46

"Select when the transition will take effect. " & \ "The duration controls the number of frames over which the transition occurs. " & \ "The minimum number of pixels in both directions can also be controlled." & RETURN & RETURN & \ "When this transition is used during authoring, and the movie is stopped the cast member it uses for the transition effect may not be erased." & RETURN & RETURN & \ "PERMITTED MEMBER TYPES:" & RETURN & \ "bitmaps and text" & RETURN & RETURN & \ "PARAMETERS:" & RETURN & \ "* When transition appears - controls whether sprite moves on or off the stage" & RETURN & \ "* Duration - number of frames for the transition to take place" & RETURN & \ "* Horizontal Pixels - number of pixels at lowest resolution" & RETURN & \ "* Vertical Pixels - number of pixels at lowest resolution" & RETURN & \ "* Minimum Pixel Dimension - smallest edge length for a pixel during transition" end getBehaviorDescription

Fig. III.9: Parámetros de la rutina “Pixelate”

Podemos observar la transición en las siguientes capturas

donde la Fig. III.10 muestra el inicio del sprite y la Fig. III.11 el final.


III-47

Fig. III.10: Rutina “Pixelate” Fig. III.11: Rutina “Pixelate”

� Tooltip:

Rutina del apartado controles de la biblioteca. Cuando el ratón

está un cierto tiempo sobre un sprite, aparece un mensaje, en una

sola línea, mostrando información del punto. Este behavior necesita

de la rutina “Display Text” aplicada a un sprite de texto para su uso.

Entre los parámetros (Fig. III.12) es posible elegir la posición, el

tiempo que transcurre antes de revelar el tooltip, si se mantiene o

no una vez pulsado el sprite o el texto del score en el que se ha

empleado el “Display Text”. Sólo se precisa de un sprite de texto

para todos los tooltips, si bien éste ha de conservarse durante toda

la película.

-- DESCRIPTION -- on getBehaviorDescription me return \ "TOOLTIP" & RETURN & RETURN & \ "Generates a tool tip when the user rolls over the sprite." & RETURN & RETURN & \ "NOTE: This behavior calls the 'Display Text' behavior to actually show the message. " & \ "The 'Display Text' behavior must be attached to a different sprite which contains either a Field or a Text member." & RETURN & RETURN & \


III-48

"If such a sprite exists, it will automatically be selected in the Behavior Parameters dialog." & RETURN & RETURN & \ "If you wish the Tooltip to appear in a given position relative to the current sprite, choose the appropriate position in the Behavior Parameters dialog, and ensure that the associated 'Display Text' behavior is set to act as a Tooltip. " & \ "(If the 'Display Text' behavior is set to act as a Status Bar, then it will ignore any position data and appear in a fixed position)." & RETURN & RETURN & \ "You can choose to have the tooltip appear immediately on rollover, or to appear only if the mouse remains over the sprite for a given period. " & \ "You can also choose to have the tooltip disappear if the user clicks on the sprite." & RETURN & RETURN & \ "The Behavior Parameters dialog has limited space for entering a tool tip message. " & \ "In particular, it will not accept a string which contains the RETURN character. " & \ "If you need to display a long Tooltip which consists of several lines of text, and which must appear at the position of this sprite, then you must use send a message to this behavior containing the requiresd string. " & \ "For example:" & RETURN & RETURN & \ " SendSprite (1, #Tooltip_SetMessage, " & QUOTE & "This message consists" & QUOTE & "&RETURN&" & QUOTE & "of two lines of text" & QUOTE & ")" & RETURN & RETURN & \ "This would produce the following message when the mouse rolls over sprite 1:" & RETURN & RETURN & \ " This message consists" & RETURN & \ " of two lines of text" & RETURN & RETURN & \ "If the tooltip generated by this behavior is to be diplayed in a Status bar then this step may be needed. " & \ " The 'Display Text' behavior will ensure that a long line of text is wrapped in the Status bar, and that scroll bars appear if necessary." & RETURN & RETURN & \ "PERMITTED MEMBER TYPES:" & RETURN & \ "All" & RETURN & RETURN & \ "PARAMETERS:" & RETURN & \ "* Tool tip to display (single-line string)" & RETURN & \ "* Delay before displaying tool tip (0 - 2 seconds)" & RETURN & \ "* Hide tool tip if sprite is clicked? (TRUE | FALSE)" & RETURN & \ "* Position of tool tip relative to the sprite" & RETURN & \ " (This will be ignored if the 'Display Text' behavior is set to act as a status bar)." & RETURN & \


III-49

"* Number of the sprite where tool tip is to be displayed." & RETURN & \ " (This sprite should have the 'Display Text' behavior attached to it. " & \ " If the given sprite is moved an authortime alert will invite you to update the Behavior Parameters)." & RETURN & RETURN & \ "PUBLIC METHODS:" & RETURN & \ "=> Set the tooltip message (allows the RETURN character)" & RETURN & \ "=> Obtain behavior reference" & RETURN & RETURN & \ "ASSOCIATED BEHAVIORS:" & RETURN & \ "+ Display Text - ESSENTIAL - must be attached to a Field or Text sprite which covers the same span of frames." & RETURN & RETURN & \ "You can find the 'Display Text' behavior in the Library Palette, under Controls > Display Text." end getBehaviorDescription on getBehaviorTooltip me return \ "Use with any type of member." & RETURN & RETURN & \ "Generates a tool tip message when the mouse is over the sprite." & RETURN & RETURN & \ "This behavior requires that the 'Display Text' behavior be available on a Field or Text sprite to display the messages that it generates. " & \ "If no such sprite is available an alert will appear (authortime only)." & RETURN & RETURN & \ "The parameter set for the associated 'Display Text' behavior determines whether the tool tip message appears in a Status Bar or as a temporary Tooltip display over or near this sprite." end getBehaviorTooltip -- NOTES FOR DEVELOPERS -- -- The tool tip member appears in a separate sprite: myDisplaySprite. This -- behavior merely tells the 'Display Text' behavior on myDisplaySprite what -- text to display. Before it can do this, it must first discover the memory -- address where the 'Display Text' behavior is stored. It does this through -- the EnrollDisplaySprite handler. This is not called on beginSprite


III-50

-- since, logically, myDisplaySprite will be in a higher channel. If both -- sprites begin in the same frame, myDisplaySprite may not have been -- initialised yet. -- You may have more than one sprite with the 'Display Text' behavior. It may -- therefore be important to ensure that the Tooltip is sent to the right -- sprite. However, while authoring, sprites tend to get moved around. The -- EnrollDisplaySprite does its best to find a new instance of the -- 'Display Text' behavior, but it warns the author that a conflict may be -- occurring. -- -- DECIDING WHEN TO DISPLAY THE TOOL TIP -- The tooltip should only appear when the mouse is over the current sprite. -- You may want the it only to be visible when the mouse is up. The -- CheckStatus handler, called on each prepareFrame analyses the position and -- state of the mouse, and either calls ShowTip, HideTip, or leaves things as -- they are. -- -- HideTip doesn't in fact hide anything. It merely displays an empty string. -- If the 'Display Text' behavior is set to act as a Tooltip, it will move its -- sprite off-stage. If it is set to act as a Status Bar, it will simply empty. -- -- Since many behaviors may be sending messages to myDisplaySprite, I make sure -- that these messages don't conflict. To do this, I use a boolean property: -- myDisplayFlag. This toggles between TRUE and FALSE. While it is TRUE, no -- further ShowTip messages are generated. It is set to FALSE when the tool -- tip is hidden: HideTip is thus also only called once. -- -- I could have chosen to use mouseEnter and mouseLeave to show and hide the -- tip. This technique would make the tool tip appear immediately. I chose to


III-51

-- allow up to 2 seconds delay (120 ticks) before showing the tip. Instead of -- using mouseEnter to trigger the ShowTip call directly, I use it to -- calculate the value of the ticks when the call should be make. I store the -- result in a property: myStartTicks. By setting myStartTicks to -- the maxInteger on mouseLeave, I can be sure that ShowTip will not be -- triggered. -- -- POSITION OF TOOL TIP -- ShowTip calculates where the tool tip should (ideally) be shown. The -- 'Display Text' behavior on myDisplaySprite may overrule this for one of two -- reasons: -- * You have set the 'Display Text' behavior to act as a Status bar -- * The ideal position of the tool tip would place it (partially) off-stage. -- -- See the 'Notes for Developers' in the 'Display Text' behavior for more -- details. -- HISTORY -- -- 1 October 1998: Written for the D7 Behaviors Palette by James Newton -- 29 October 1998: Descriptions improved, myPosition property extended. -- 7 January 2000: Added isOKToAttach and substituteStrings event handlers. -- Removed redundant error checking. - Karl Miller -- PROPERTIES -- property mySprite -- error checking property getPDLError -- author-defined parameters property myString property myDelay property myPosition property myDisplaySprite


III-52

property myHideFlag -- internal properties property myDisplayList property myStartTicks property myDisplayFlag -- EVENT HANDLERS -- on beginSprite me Initialize me end beginSprite on prepareFrame me CheckStatus me end prepareFrame on mouseEnter me myStartTicks = the ticks + myDelay end mouseEnter on mouseLeave me myStartTicks = the maxinteger end mouseLeave -- CUSTOM HANDLERS -- on Initialize me -- sent by beginSprite mySprite = sprite(me.spriteNum) myMember = mySprite.member myDisplayList = [] myStartTicks = the maxinteger end Initialize on CheckStatus me if myStartTicks < the ticks then if myHideFlag then if the mouseDown then if myDisplayFlag then HideTip me end if exit end if end if


III-53

if myDisplayFlag then exit ShowTip me else if myDisplayFlag then HideTip me end if end CheckStatus on ShowTip me -- sent by prepareFrame myDisplayFlag = TRUE case myPosition of "centered above": theAlignment = #bottomCenter displayLoc = point ((mySprite.left + mySprite.right) / 2, mySprite.top) "centered below": displayLoc = point ((mySprite.left + mySprite.right) / 2, mySprite.bottom) theAlignment = #topCenter "at topLeft": displayLoc = point (mySprite.left, mySprite.top) theAlignment = #topLeft "at topRight": displayLoc = point (mySprite.right, mySprite.top) theAlignment = #topRight "centered": centerH = (mySprite.left + mySprite.right) / 2 centerV = (mySprite.top + mySprite.bottom) / 2 displayLoc = point (centerH, centerV) theAlignment = #center "at bottomLeft": displayLoc = point (mySprite.left, mySprite.bottom) theAlignment = #bottomLeft "at bottomRight": displayLoc = point (mySprite.right, mySprite.bottom) theAlignment = #bottomRight "at regPoint": displayLoc = mySprite.loc theAlignment = #center "under the mouse": displayLoc = the mouseLoc theAlignment = #center end case if not myDisplayList.count() then EnrollDisplaySprite me end if call #DisplayText_SetText, myDisplayList, myString, displayLoc, theAlignment end ShowTip


III-54

on HideTip me -- sent by prepareFrame myDisplayFlag = FALSE if not myDisplayList.count() then EnrollDisplaySprite me end if call #DisplayText_SetText, myDisplayList, EMPTY end HideTip on EnrollDisplaySprite me -- Enroll the 'Display Text' behavior sendSprite (myDisplaySprite, #DisplayText_Enroll, myDisplayList) if not myDisplayList.count() then -- Try to find a sprite with the 'Display Text' behavior anyway sendAllSprites (#DisplayText_Enroll, myDisplayList) if not myDisplayList.count() then ErrorAlert (me, #noValidSprites, myDisplaySprite) else -- Notify author of change ErrorAlert (me, #invalidSpriteNumber, myDisplaySprite) end if end if end EnrollDisplaySprite on GetDisplaySprite me -- Checks the scriptList of each sprite in this frame for 'Display Text' displayScriptMember = the number of member ("Display Text") if displayScriptMember > 0 then displayScriptMember = member (displayScriptMember) repeat with theSprite = 1 to the lastChannel theScripts = sprite (theSprite).scriptList scriptCount = theScripts.count() repeat while scriptCount if theScripts[scriptCount][1] = displayScriptMember then return theSprite end if scriptCount = scriptCount - 1 end repeat end repeat end if return the currentSpriteNum + 1 end GetDisplaySprite


III-55

-- PUBLIC METHODS (responses to #sendSprite, #sendAllSprites, #call) -- on Tooltip_SetMessage me, theString -- Allows you to set a more complex message that can be done through the -- Behavior Parameters Dialog, or to change it at runtime -- Error check case ilk (theString) of #string: -- nothing otherwise return #invalidTypeError end case -- End of error check myString = theString end Tooltip_SetMessage on Tooltip_GetReference me -- Returns a reference to the behavior for Lingo calls return me end Tooltip_GetReference -- ERROR CHECKING -- on ErrorAlert me, theError, data -- sent by Initialize -- Determine the behavior's name behaviorName = string (me) delete word 1 of behaviorName delete the last word of behaviorName delete the last word of behaviorName -- Convert #data to useful value case data.ilk of #void: data = "<void>" #symbol: data = "#"&data end case case theError of #invalidSpriteNumber: if the runMode = "Author" then message = substituteStrings(me, \ "Sprite ^3 did not respond to a #DisplayText call. " & \ " Another sprite will be used. " & \


III-56

" Please open the Behavior Parameters dialog to choose the correct sprite for displaying the Tooltip message.", \ ["^0": the frame, "^1": me.spriteNum, "^2": behaviorName, "^3": data]) end if #noValidSprites: if the runMode = "Author" then message = substituteStrings(me, \ "BEHAVIOR ERROR: Frame ^0, Sprite ^1 " & RETURN & \ "Behavior ^2" & RETURN & RETURN & \ "No sprites responded to a #DisplayText call." & RETURN & RETURN & \ "Please ensure that the '^3' behavior is attached to a Field or Text Sprite in the same frames as Sprite ^1.", \ ["^0": the frame, "^1": me.spriteNum, "^2": behaviorName, "^3": "Display Text"]) end if end case end ErrorAlert on substituteStrings(me, parentString, childStringList) -------------- -- -- * Modifies parentString so that the strings which appear as -- properties in childStringList are replaced by the values -- associated with those properties. -- -- <childStringList> has the format ["^1": "replacement string"] -------------------------------------------------------------------- i = childStringList.count() repeat while i tempString = "" dummyString = childStringList.getPropAt(i) replacement = childStringList[i] lengthAdjust = dummyString.char.count - 1 repeat while TRUE position = offset(dummyString, parentString) if not position then parentString = tempString&parentString exit repeat else if position <> 1 then tempString = tempString&parentString.char[1..position - 1]


III-57

end if tempString = tempString&replacement delete parentString.char[1..position + lengthAdjust] end if end repeat i = i - 1 end repeat return parentString end substituteStrings -- AUTHOR-DEFINED PARAMETERS -- on isOKToAttach (me, aSpriteType) return aSpriteType = #graphic end isOKToAttach on getPropertyDescriptionList me -- try to find a sprite which has the 'Display Text' behavior attached displaySprite = GetDisplaySprite (me) return \ [ \ #myString: \ [ \ #comment: "Text of tool tip", \ #format: #string, \ #default: "Insert your single-line tool tip here" \ ], \ #myDelay: \ [ \ #comment: "Pause before showing tool tip (ticks)", \ #format: #integer, \ #range: [#min: 0, #max: 120], \ #default: 30 \ ], \ #myHideFlag: \ [ \ #comment: "Hide tool tip if user clicks on sprite?", \ #format: #boolean, \ #default: TRUE \ ], \ #myPosition: \ [ \ #comment: "Tool tip position relative to sprite (see notes)", \ #format: #string, \ #range: \


III-58

[ \ "centered above", \ "at topLeft", \ "at topRight", \ "centered", \ "at bottomLeft", \ "at bottomRight", \ "centered below", \ "at regPoint", \ "under the mouse" \ ], \ #default: "centered" \ ], \ #myDisplaySprite: \ [ \ #comment: "Use which sprite to display tooltip?", \ #format: #integer, \ #range: [#min: 1, #max: the lastChannel], \ #default: displaySprite \ ] \ ] end getPropertyDescriptionList

Fig. III.12: Parámetros de la rutina “Tooltip”

� Display Text:

Correspondiente al apartado de controles de la biblioteca. Se

utiliza sobre un sprite de texto para poder aplicar los tooltips.

-- DESCRIPTION -- on getBehaviorDescription me return \ "DISPLAY TEXT" & RETURN & RETURN & \ "This behavior allows you to display a given string in a field or text member. " & \


III-59

"Use it with the Tooltip and Hypertext - Display Status behaviors which need a field or text member in which to display their information. " & \ "Or create your own custom Lingo to display runtime information, such as the position of the mouse." & RETURN & RETURN & \ "This behavior waits for Lingo commands to tell it what to do. " & \ "It is not active by itself." & RETURN & RETURN & \ "You can choose between two display types: tooltip and status bar." & RETURN & RETURN & \ "The TOOLTIP type of display will make the field or text member resize itself to fit the text, and disappear when it is empty. " & \ "You can set the tooltip type display to appear at any position on the stage, such as under the cursor. " & \ "If no position is sent to the sprite, it will appear at the top left corner of the Stage. " & \ "See the Tooltip behavior for more details." & RETURN & RETURN & \ "If you wish to display several lines of text, you must use RETURN characters to define the line breaks. " & \ "An empty tooltip sprite will move off-stage to hide. " & \ "It is recommended that you place it off-stage before it is used, in case it causes a brief flash on the screen." & RETURN & RETURN & \ "The STATUS BAR type of display will appear on Stage at all times. " & \ "It will not resize or change position. " & \ "Any positional information sent to this sprite will be ignored if it is set to act as a status bar. " & \ "If the text is too long to appear in the member of the current sprite, a scrollbar will appear. " & \ "You do not need to divide the text with RETURN characters. " & \ "If you think that a scrollbar may be necessary, make sure that the field or text member is sufficiently tall for the scroll arrows to operate correctly." & RETURN & RETURN & \ "Set the font size and other characteristics of the field or text member to customize the appearance of the message." & RETURN & RETURN & \ "Be sure to give the field or text member a name. " & \ "It may be emptied by this behavior. " & \ "Director automatically erases nameless empty members." & RETURN & RETURN & \ "PERMITTED MEMBER TYPES:" & RETURN & \ "field and text" & RETURN & RETURN & \ "PARAMETERS:" & RETURN & \ "* Display type:" & RETURN & \


III-60

" - Tooltip (appears near the cursor on rollover)" & RETURN & \ " - Status bar (appears in a fixed position at all times)" & RETURN & RETURN & \ "PUBLIC METHODS:" & RETURN & \ "* Set the text to display (and the position of the sprite)" & RETURN & RETURN & \ "ASSOCIATED BEHAVIORS:" & RETURN & \ "* Tooltip" & RETURN & \ "* Source Status" & RETURN & \ "* Hypertext - Display Status" end getBehaviorDescription on getBehaviorTooltip me return \ "Use with field or text members." & RETURN & RETURN & \ "Waits for a message from another behavior or custom handler to display a character string. " & \ "This behavior is intended to be used with the Tooltip and Hypertext - Display Status behaviors to create a status bar or a tooltip under the cursor." end getBehaviorTooltip -- NOTES FOR DEVELOPERS -- -- COMMUNICATING WITH THE SPRITE -- To set the text of the current sprite's member, use a line similar to one of -- the following: -- -- sendAllSprites (#DisplayText_SetText, theStringToDisplay) -- -- sendSprite (<spriteNumber>, #DisplayText_SetText, theStringToDisplay) -- -- call (#DisplayText_SetText, displayBehavior, theStringToDisplay) -- -- It is fastest to call the behavior directly. Use code similar to the -- following lines in any script that needs to communicate with this behavior -- often: -- -- property displayBehavior -- -- ...


III-61

-- displayBehavior = [] -- sendAllSprites (#DisplayText_Enroll, displayBehavior) -- ... -- -- If your _Enroll call fails for some reason, displayBehavior will be an -- empty list. Calling an empty list will not produce an error (calling an -- invalid behavior reference will). It would, however, be wise to provide -- yourself with an authortime alert so that you can correct such a problem -- if necessary: -- -- if displayBehavior.count() = 0 then -- if the runMode = "Author" then -- alert "No 'Display Text' behavior found in frame "the frame -- end if -- end if -- -- Writing this sort of "defensive" code should ensure that any bugs that make -- it through to the finished product are relatively harmless. -- ADJUSTING THE WIDTH OF THE SPRITE -- The BestRect function is called if you choose the Tooltip display type. It -- modifies the width of the sprite to suit the longest line/paragraph of text \ -- (field lines and text paragraphs are delimited by the RETURN character). -- -- This function uses the charPosToLoc() function to determine the length of -- each line. CharPosToLoc returns the position of the bottom left corner of -- the tested character: if the character tested is the final RETURN of a line, -- then the value returned is equiavalent to the bottom right of the last -- visible character in the line. -- -- I initially set the width of the member to an extravagantly large value, to -- ensure that no line-wrapping should occur.


III-62

-- HISTORY -- -- 1 october 1998: Written for the D7 Behaviors Palette by James Newton -- 28 October 1998: Descriptions improved. getPDL simplified, GetTopLeft() added -- 7 January 2000: Added isOKToAttach and substituteStrings event handlers -- and removed redundant error checking code - Karl Miller -- PROPERTIES -- property spriteNum -- error checking property getPDLError -- author-defined parameters property myDisplayType -- internal properties property mySprite property myMember property myWidthAdjust property myHeightAdjust property myOffStageLoc -- EVENT HANDLERS -- on beginSprite me myDisplayType = resolve(myDisplayType) Initialize me end beginSprite on endSprite me mySprite.visible = TRUE end endSprite -- CUSTOM HANDLERS -- on resolve(prop) case prop of myDisplayType: choicesList = ["status bar (fixed size and position)", \ "tooltip (dynamic size and position)"]


III-63

lookup = [#statusBar, #tooltip] end case return lookup[findPos(choicesList, prop)] end resolve on Initialize me -- sent by beginSprite mySprite = sprite(me.spriteNum) myMember = mySprite.member if myMember.type = #field then myWidthAdjust = (myMember.margin + myMember.border) * 2 myHeightAdjust = myMember.margin + myMember.border * 2 -- no gremlins here:) else myWidthAdjust = 0 myHeightAdjust = 0 end if myMember.text = EMPTY if myDisplayType = #tooltip then myMember.boxType = #fixed myOffStageLoc = point (999, 999) mySprite.loc = myOffStageLoc end if end Initialize on BestRect me, theString -- sent by DisplayText_SetText -- Sets the rect of myMember to fit snugly round theString it displays myMember.rect = rect (0, 0, 8000, 0) myMember.text = theString -- Needed to update myMember.rect bestRect = myMember.rect theLine = the number of lines of theString theWidth = 0 checkedChars = 0 -- Determine the length of the longest line repeat while theLine endOfLine = offset (RETURN, theString) if not endOfLIne then -- Only one line remaining endOfLine = (the number of chars of theString) + 1 myMember.text = myMember.text & RETURN end if checkedChars = checkedChars + endOfLine endPoint = charPosToLoc (myMember, checkedChars) lineWidth = endPoint[1] if lineWidth > theWidth then


III-64

theWidth = lineWidth end if delete char 1 to endOfLine of theString theLine = theLine - 1 end repeat -- Determine the height of the text lastChar = myMember.char.count lastCharLoc = charPosToLoc (myMember, lastChar) theHeight = lastCharLoc[2] -- bestRect[3] = theWidth + 1 bestRect[4] = theHeight + 1 return bestRect end BestRect on GetTopLeft me, theLoc, theAlignment, memberRect case theAlignment of #bottomCenter: return theLoc - [memberRect.width / 2, memberRect.height] #bottomRight: return theLoc - [memberRect.width, memberRect.height] #bottomLeft: return theLoc - [0, memberRect.height] #center: return theLoc - [memberRect.width / 2, memberRect.height / 2] #topCenter: return theLoc - [memberRect.width / 2, 0] #topRight: return theLoc - [memberRect.width, 0] otherwise -- treat as #topLeft return theLoc end case end GetTopLeft -- INTER-SPRITE COMMUNICATION (response to #sendSprite, #sendAllSprites) -- on DisplayText_Enroll me, enrollList -- sent by objects which need to call this specific behavior if ilk (enrollList) <> #list then return me if not enrollList.count() then enrollList.append(me) else -- the calling behavior has already found a candidate end if return enrollList end DisplayText_Enroll


III-65

on DisplayText_SetText me, theString, theLoc, theAlignment -- called by other objects -- Sets the text of myMember to theString and shows mySprite -- as near to theLoc as possible (if myDisplayType is #tooltip) -- -- theAlignment can take any of the following values: -- #bottomCenter|#bottomRight|#bottomLeft|#center|#topCenter|#topRight|#topLeft -- This determines which point of the current sprite is to appear at theLoc -- Error check if not stringP (theString) then ErrorAlert (me, #invalidString, theString) theString = string (theString) else case ilk (theLoc) of #void, #point: -- nothing otherwise ErrorAlert (me, #invalidPoint, theLoc) theLoc = point (0, 0) end case end if -- End of error check if theString = EMPTY and myDisplayType = #tooltip then mySprite.loc = myOffStageLoc else myMember.text = theString if myDisplayType = #tooltip then memberRect = BestRect (me, theString) myMember.rect = memberRect else memberRect = myMember.rect end if memberRect = memberRect + [0, 0, myWidthAdjust, myHeightAdjust] if myDisplayType = #tooltip then if ilk (theLoc) <> #point then theLoc = point (0, 0) end if theLoc = GetTopLeft (me, theLoc, theAlignment, memberRect) -- Ensure sprite is fully visible on stage stageWidth = (the activeWindow).rect.right - (the activeWindow).rect.left


III-66

stageHeight= (the activeWindow).rect.bottom - (the activeWindow).rect.top maxH = stageWidth - memberRect.width maxV = stageHeight - memberRect.height theLoc[1] = max (0, min (theLoc[1], maxH)) theLoc[2] = max (0, min (theLoc[2], maxV)) theLoc = theLoc + myMember.regPoint mySprite.loc = theLoc else lastChar = theString.char.count textHeight = charPosToLoc (myMember, lastChar)[2] if textHeight > mySprite.height then myMember.boxType = #scroll else myMember.boxType = #fixed end if end if end if end DisplayText_SetText on DisplayText_GetReference me return me end DisplayText_GetReference -- ERROR CHECKING -- on ErrorAlert me, theError, data -- Determine the behavior's name behaviorName = string (me) delete word 1 of behaviorName delete the last word of behaviorName delete the last word of behaviorName case theError of #invalidString: if the runMode = "Author" then message = substituteStrings(me, \ "BEHAVIOR ERROR: Frame ^0, Sprite ^1" & RETURN & \ "Behavior ^2" & RETURN & RETURN & \ "The DisplayText_SetText handler could not treat the following as a string:" & RETURN & RETURN & \ "^3", \ ["^0": the frame, "^1": me.spriteNum, "^2": behaviorName, "^3": data]) alert message end if #invalidPoint:


III-67

if the runMode = "Author" then message = substituteStrings(me, \ "BEHAVIOR ERROR: Frame ^0, Sprite ^1" & RETURN & \ "Behavior ^2" & RETURN & RETURN & \ "The DisplayText_SetText handler could not treat the following as a point:" & RETURN & RETURN & \ "^3", \ ["^0": the frame, "^1": me.spriteNum, "^2": behaviorName, "^3": data]) end if end case end ErrorAlert on substituteStrings(me, parentString, childStringList) -------------- -- -- * Modifies parentString so that the strings which appear as -- properties in childStringList are replaced by the values -- associated with those properties. -- -- <childStringList> has the format ["^1": "replacement string"] -------------------------------------------------------------------- i = childStringList.count() repeat while i tempString = "" dummyString = childStringList.getPropAt(i) replacement = childStringList[i] lengthAdjust = dummyString.char.count - 1 repeat while TRUE position = offset(dummyString, parentString) if not position then parentString = tempString&parentString exit repeat else if position <> 1 then tempString = tempString&parentString.char[1..position - 1] end if tempString = tempString&replacement delete parentString.char[1..position + lengthAdjust] end if end repeat i = i - 1


III-68

end repeat return parentString end substituteStrings -- AUTHOR-DEFINED PARAMETERS -- on isOKToAttach (me, aSpriteType, aSpriteNum) case aSpriteType of #graphic: return getPos([#field, #text], sprite(aSpriteNum).member.type) <> 0 #script: return FALSE end case end isOKToAttach on getPropertyDescriptionList me if not the currentSpriteNum then exit return \ [ \ #myDisplayType: \ [ \ #comment: "Display Text sprite behaves as a", \ #format: #string, \ #default: "status bar (fixed size and position)", \ #range: ["status bar (fixed size and position)", \ "tooltip (dynamic size and position)"] \ ] \ ] end getPropertyDescriptionList

En la Fig. III.13 se puede observar el canal 70 del score donde

se ha aplicado la rutina “Display Text” sobre un sprite de texto para

aplicar los tooltips. Este sprite está presente en toda la película. La

Fig. III.14 muestra la línea del tooltip en el stage.


III-69

Fig. III.13: Rutina “Display Text”

Fig. III.14: Rutina “Tooltip”

� Cuadro de Información:

Rutina similar al tooltip pero mostrando un cuadro de texto (o

de cualquier tipo) creado previamente. No necesita de otro behavior

como el caso anterior.


III-70

on beginsprite me sprite(81).visible=0 -- Canal del score donde se ha colocado el sprite end on mouseenter me startTimer end on mouseWithin me if the timer >= 60 then sprite(81).loc=point ((sprite(me.spriteNum).left + sprite(me.spriteNum).right) / 2 + 50, sprite(me.spriteNum).bottom + 38) sprite(81).visible=1 -- Colocamos el tooltip, según el tamaño del cuadro, justo debajo del sprite end if end on mouseDown me sprite(81).visible=0 startTimer end on mouseleave me sprite(81).visible=0 end

En la Fig. III.15 se observa la aparición del cuadro de

información tras dejar el ratón sobre el sprite.

Fig. III.15: Rutina “Cuadro de Información”


III-71

� Cambio de resolución:

Cambia la resolución de la pantalla al inicio de la película y la

devuelve a su valor original una vez finalizada la aplicación. Es

necesaria la instalación de un xtra para su funcionamiento (en este

caso gratuito).

on startMovie global oldRes set oldRes = changeRes([1024,768]) end on stopMovie global oldRes changeRes(oldRes) end

� Salir:

Sale de la aplicación.

on mouseUp me halt end

Por último, destacamos que un sprite puede tener varios

behaviors (comportamientos) a la vez.

Atlas de Quemaduras IV. Resultados: Estructura del Atlas

IV-72

IV. Resultados: Estructura del Atlas

IV.1 Introducción al Atlas: Punto de Vista Médico

Las quemaduras son lesiones a las que cualquier personal

sanitario, desde el estudiante de medicina o enfermería hasta el

médico especialista, va a enfrentarse con relativa frecuencia a lo

largo de su vida profesional. Pueden ser de diferente etiología y

severidad. Pueden afectar a cualquier grupo etario, especialmente a

ancianos y a niños. Comportan un pronóstico variable dependiendo

de la edad del paciente, extensión y profundidad de las lesiones y

patología asociada. Su diagnóstico y tratamiento es amplio y a

veces se hace difícil debido a que las quemaduras son lesiones

dinámicas que evolucionan a medida que pasa el tiempo.

Este atlas está constituido por imágenes tomadas en la

Unidad de Grandes Quemados de los H.H.U.U. Virgen del Rocío de

Sevilla que muestran los diferentes tipos de lesiones térmicas, sus

peculiaridades y manejo. Desde lo más básico como es la pequeña

quemadura superficial que sólo necesitará tratamiento ambulatorio,

hasta lo más complejo como es el paciente gran quemado que

precisará ingreso en una unidad especializada con múltiples

cirugías tanto en la fase aguda como en la fase de las secuelas.

Todo ello a través de más de 500 imágenes agrupadas en

siete apartados interrelacionados y mostrados por orden

cronológico comenzando por la valoración de la lesión, su


IV-73

diagnóstico etiológico y de la profundidad; los cuidados iniciales y el

manejo terapéutico; las infecciones y las posibles complicaciones

del paciente quemado y, finalmente, la rehabilitación y prevención

de las secuelas, así como sus posibilidades reconstructivas.

El atlas no pretende aportar nuevos y profundos

conocimientos teóricos sobre la fisiopatología del paciente quemado

pues para ello están los libros y tratados sobre quemaduras. Su

utilidad se encuentra en lo práctico y gráfico de las imágenes.

Objetivos del atlas

� Mejorar el conocimiento sobre las quemaduras, su etiología,

profundidad y extensión.

� Mostrar el manejo terapéutico del paciente quemado: curas

locales, cirugías y control de la infección.

� Conocer las principales complicaciones del paciente

quemado, sus secuelas y la forma de prevenirlas.

� Servir de herramienta didáctica práctica tanto para estudiantes

de medicina, residentes de cirugía plástica, enfermeros y,

sobre todo, médicos generalistas que serán los encargados

de recibir y atender inicialmente al paciente quemado y decidir

sobre su tratamiento inmediato.

� En un futuro, cuando perfeccionemos el programa, incluir

pautas para el cálculo de la resucitación en base a la SCQ

(Superficie Corporal Quemada), criterios de

inclusión/exclusión del paciente en Unidad de Grandes

Quemados, sistema para añadir imágenes personales al

archivo y agregar una parte práctica a modo de test que


IV-74

permitirá al usuario desarrollar sus habilidades clínicas

diagnósticas.

Los datos que se aportan a continuación se pueden consultar

en la bibliografía.

1. Epidemiología e incidencia.

La quemadura extensa es una de las mayores agresiones a la

que puede enfrentarse el ser humano.

A falta de datos exactos sobre la incidencia real de las

quemaduras manejamos datos de EE.UU.: más de un millón de

personas sufren cada año quemaduras, de ellas entre 60.000-

80.000 requieren ingreso hospitalario. También se estima que

alrededor de 5.500 personas mueren por quemaduras en dicho

país.

En España también se desconoce la incidencia exacta de las

quemaduras. No obstante, debemos considerarlo como un

accidente frecuente. En países de nuestro entorno, se estima que

por cada 100.000 habitantes alrededor de 300 personas sufren

cada año quemaduras que requieren asistencia médica, lo cual

supone aproximadamente que 120.000 españoles y 1.000.000 de

europeos recibieron asistencia médica anual a causa de una

quemadura.

Según estudios recientes realizados por H.H.U.U. Virgen del

Rocío de Sevilla el número de ingresos anual por quemaduras es


IV-75

de 250 pacientes. El número anual de urgencias atendidas es de

1.500. Con lo cual el número de ingresos por quemaduras es del

15-20% de los pacientes atendidos, siendo el resto pacientes

manejados en régimen ambulatorio.

2. Etiología de las quemaduras

La etiología de las quemaduras puede ser muy diversa, el

elemento común a todas ellas es que el agente etiológico produce

una diferencia térmica en la piel. En nuestro medio la quemadura

por escaldadura y por llama son las más frecuentes. Otras causas

de quemaduras son: quemadura por sólido caliente, quemadura

eléctrica, quemadura química, quemadura por frío y quemadura por

radiaciones ionizantes.

Las quemaduras pueden afectar a pacientes de cualquier

edad, no obstante el mayor riesgo de sufrir una quemadura

corresponde a niños por debajo de los diez años. Esta tendencia,

en los últimos años, viene siendo modificada al aumentar la

incidencia de quemaduras en pacientes ancianos, sobre todo por

encima de setenta años, lo cual podría justificarse en parte al

envejecimiento que sufre la población. Por sexos la distribución es

de 2/1 de hombres con respecto a las mujeres.

3. Extensión y profundidad de las quemaduras

El porcentaje de la SCQ no es únicamente un dato que se

relaciona con el pronóstico del paciente quemado, sino que

constituye el dato más importante para la resucitación mediante


IV-76

fluidos durante la fase aguda. Es por ello que resulta de vital

importancia su cálculo exacto. Existen varias reglas que nos

permiten este cálculo. La regla de Wallace de los nueve es la más

utilizada, consiste en atribuir a cada parte del cuerpo un porcentaje

múltiplo de nueve. Esta regla se considera poco fiable para los

niños debido a la importancia de la superficie corporal de la cabeza

que puede ser de hasta un 18% en niños menores de dos años. En

las quemaduras poco extensas la regla del 1% o de la palma de la

mano es otro de los métodos utilizados, que se basa en suponer

que la palma de la mano abierta del paciente constituye un 1% de

su superficie corporal.

Otro factor muy importante de cara al pronóstico y manejo del

paciente quemado, es el conocimiento de la profundidad de las

lesiones. Podemos diferenciar tres grados de quemaduras, cada

una de ellas con ciertas peculiaridades que facilitan su diagnóstico.

GRADO PRIMERO SEGUNDO

SUPERFICIAL SEGUNDO PROFUNDO

TERCERO

LESIÓN HISTOLÓGICA

Capas superficiales de epidermis

Hasta estrato granuloso de epidermis

Destruye estrato germinativo de epidermis y membrana basal

Destrucción de epidermis y dermis

CLÍNICA

Eritema, dolor

Flictena , dolor, color rojo intenso

Con o sin flictena, hipoestesia, color rojo pálido

Escara blanca o carbonizada, anestesia

EVOLUCIÓN Cura en menos de una semana

Cura en 7-15 días

Cura en 3-4 semanas

No cura. Necesita cirugía


IV-77

Está descrito un cuarto grado de quemadura que es aquél en

el que además del espesor total de la piel se afectan estructuras

profundas como pueden ser los músculos, los huesos, tendones u

órganos internos.

4. Pronóstico del paciente quemado

Son muchos los factores que influyen en el pronóstico del

paciente quemado. La extensión y profundidad de las quemaduras,

junto con la edad del paciente, la etiología y lesiones asociadas

constituyen los principales elementos que determinan la gravedad

del paciente con quemaduras. En la siguiente relación se presentan

los criterios de gravedad del paciente quemado según la American

Burn Association:

� Quemaduras de 2º y 3º grado > 10 % de la SCQ en pacientes

<10 años ó >50 años.

� Quemaduras de 2º y 3º grado >20% de la SCQ de cualquier

edad.

� Quemaduras profundas localizadas en cara, manos, pies,

genitales periné o articulaciones.

� Quemaduras de 3º grado >5 % de la SCQ en cualquier edad.

� Asociación de síndrome de inhalación.

� Quemaduras eléctricas.

� Quemaduras químicas graves.

� Quemaduras en pacientes con antecedentes personales

médicos: Diabetes mellitus, hipertensión arterial, cáncer...

� Quemaduras en pacientes politraumatizados.


IV-78

� Quemaduras que requieren de soporte social, psicológico o

rehabilitador.

Por lo tanto, la distinción correcta de la profundidad y

extensión de la quemadura se considera de gran importancia a la

hora de clasificar al paciente en tres grandes grupos que

necesitaran una serie de cuidados particulares:

A .Quemadura mayor o paciente gran quemado.

El paciente requiere ingreso en Unidad de Grandes

Quemados.

� >25% SCQ de segundo grado en adulto.

� >20% SCQ de segundo grado en niño.

� >10% SCQ de tercer grado en adulto o niño.

� Toda quemadura que incluya ojos, orejas, cara, genitales,

manos o pies.

� Trastornos por inhalación.

� Quemaduras eléctricas.

� Lesiones por quemaduras complicadas que incluyan

traumatismos craneales u otros traumas mayores.

� Pacientes de riesgo por condiciones médicas previas como

ACV, EPOC, cáncer, diabetes, desórdenes psiquiátricos, etc.

B. Quemadura intermedia

El paciente requiere ingreso en planta de cirugía plástica.


IV-79

� 15%-25% SCQ de segundo grado en adulto.

� 10%-20% SCQ de segundo grado en niño.

� 2%-10% SCQ de tercer grado en niño o adulto que no incluya

ojos, orejas, cara o genitales.

C. Quemadura menor.

El paciente requiere cuidados ambulatorios.

� 15% SCQ o menos de primer o segundo grado en el adulto.

� 10% SCQ o menos de primer o segundo grado en el niño.

� 2% SCQ o menos de tercer grado en niño o adulto que no

incluya ojos, orejas, cara o genitales.

5. Tratamiento del paciente quemado

El tratamiento del paciente quemado es multidisciplinar. Debe

de diferenciarse una fase aguda de resucitación mediante

fluidoterapia intravenosa, mantenimiento de las constantes vitales y

valoración de la necesidad de escarotomía de urgencia ante una

quemadura profunda y en circular que produzca un síndrome

compartimental. Ésta debe ir seguida de una fase subaguda,

pasadas las primeras 48-72 horas postrauma, cuyo objetivo debe

ser el cierre completo de las heridas mediante curas locales

periódicas de las áreas quemadas con agentes antimicrobianos

tópico, que permitan un control eficaz del riesgo de infección, y

mediante el desbridamiento quirúrgico precoz de las quemaduras

profundas, con objeto de eliminar a todos los tejidos necróticos que


IV-80

mantienen la reacción inflamatoria e hipercatabólica que concurren

en el paciente quemado y mejorar el pronóstico funcional al

disminuir el tiempo de cicatrización.

La cobertura básica de la quemadura profunda es el

autoinjerto de piel parcial tomada de una zona sana del propio

paciente. En los últimos años se han desarrollado nuevas técnicas

para el caso de pacientes quemados graves cuya área cutánea no

es suficiente para el reemplazo cutáneo con autoinjertos. Éstas son

fundamentalmente los homoinjertos criopreservados de piel de

cadáver donante, las dermis artificiales y los cultivos celulares en el

laboratorio de la piel del propio paciente.

También muy importante durante la fase aguda y subaguda

del paciente es el empleo de una nutrición intensiva y adaptada a

sus necesidades; el control de la infección; la prevención y

tratamiento de las complicaciones que puedan aparecer y el inicio

de una rehabilitación tan pronto como la permita el estado del

paciente para disminuir la gravedad de las secuelas.

Ya en la fase crónica, nos debemos preocupar de tratar todas

las deformidades, estéticas o funcionales, que vayan apareciendo

aplicando tantas técnicas reconstructivas que tengamos a nuestro

alcance con objeto de mejorar la calidad de vida de este paciente.


IV-81

IV.2 Estructura del Atlas

El atlas se divide en siete capítulos principales:

� Introducción.

� Cuidados iniciales y resucitación del paciente quemado.

� Manejo del paciente quemado.

� Infección en el paciente quemado.

� Complicaciones en el paciente quemado.

� Rehabilitación y prevención de las deformidades.

� Secuelas y reconstrucción del paciente quemado.

Estos siete puntos siempre estarán accesibles durante el

desarrollo del atlas, adquiriendo así una mayor interactividad. A su

vez, cada capítulo tendrá distintas secciones con sus

correspondientes contenidos, quedando “iluminados” el apartado y

subapartados visitados. De esta forma, conoceremos en todo

momento nuestra situación dentro del atlas.

A continuación se mostrará, de forma detallada, cada sección

y su contenido:


IV-82

Capítulo 1: Introducción

Está dividido en cinco apartados:

� Piel Normal.

� Clasificación por Grados.

� Etiología.

� Fisiopatología.

� Quemaduras Especiales.

En la Fig. IV.1 podemos observar la distribución del capítulo,

donde queda “iluminado” el botón de “Introducción” y aparecen los

distintos subapartados citados.

Fig. IV.1: Capítulo “Introducción”


IV-83

El apartado “Piel Normal” (Fig. IV.2) contiene los puntos

“Fisiología” e “Histología” de la piel. Este punto expone las distintas

características de la piel sana, sus funciones y sus capas.

Fig. IV.2: “Piel Normal”

El apartado “Clasificación por Grados” (Fig. IV.3) se divide en

los diferentes tipos de quemaduras, desde el grado más superficial

y leve (primer grado) hasta el más grave y profundo (cuarto grado).

Esta sección contiene gran cantidad de imágenes que, como a lo

largo de todo el atlas, pueden ser ampliadas para su mejor

visionado (Fig. IV.4).


IV-84

Fig. IV.3: “Clasificación por Grados”

Fig. IV.4: Ampliación de quemadura de primer grado


IV-85

El apartado “Etiología” (Fig. IV.5) especifica los distintos

agentes con los que se producen las lesiones por quemaduras:

escaldadura, llama, sólido caliente, eléctrica, química y frío o

congelación. Nos encontraremos con fotografías divididas según el

grado.

Fig. IV.5: “Etiología”

El apartado “Fisiopatología” (Fig. IV.6) presenta, en sus

distintos apartados, las alteraciones producidas por las

quemaduras.


IV-86

Fig. IV.6: “Fisiopatología”

El último apartado “Quemaduras Especiales” (Fig. IV.7)

muestra la repercusión en la cara, manos, pies y genitales. Zonas

especiales debido a su carácter estético y/o funcional.

Además de estos puntos, conforme se avanza en los distintos

subapartados del atlas, aparecerán nuevos apartados relacionados

con los mismos y pertenecientes a otros capítulos. Esta información

surgirá en forma de “tooltip” tras dejar el ratón unos segundos sobre

el botón (Fig. IV.8).


IV-87

Fig. IV.7: “Quemaduras Especiales”

Fig. IV.8: “Tooltip” Manejo del Paciente Quemado → Criterios de Ingreso


IV-88

Capítulo 2: Cuidados Iniciales y Resucitación del Paciente

Está constituido por los puntos siguientes (Fig. IV.9):

� Tratamiento Prehospitalario.

� Recepción Hospitalaria.

Fig. IV.9: “Cuidados Iniciales y Resucitación del Paciente Quemado”

El punto “Tratamiento Prehospitalario” (Fig. IV.10) nos indica

los distintos pasos a realizar al recoger a un paciente quemado

antes de su llegada al hospital, desde la retirada del trauma térmico,

evaluación primaria, evaluación secundaria (Fig. IV.11), hasta el

transporte.


IV-89

Fig. IV.10: “Tratamiento Prehospitalario”

Fig. IV.11: “Evaluación Secundaria”


IV-90

El punto “Recepción Hospitalaria” (Fig. IV.12) nos muestra

cómo actuar al recibir a un paciente quemado. Nos encontremos

con siete apartados: asegurar vía aérea, ventilación y circulación;

obtener acceso venoso; valoración de la extensión y profundidad de

las quemaduras; diagnóstico del síndrome compartimental;

resucitación del paciente quemado; monitorización del paciente

quemado; y otras medidas.

Fig. IV.12: “Recepción Hospitalaria”


IV-91

Capítulo 3: Manejo del Paciente Quemado

Se divide en tres apartados (Fig. IV.13):

� Áreas de Hospitalización: Criterios de Ingreso.

� Tratamiento del Paciente Quemado.

� Soporte Nutricional del Paciente Quemado.

Fig. IV.13: “Manejo del Paciente Quemado”

El apartado “Áreas de Hospitalización: Criterios de Ingreso”

(Fig. IV.14) expone las distintas unidades hospitalarias donde se

tratan las quemaduras según la gravedad de las mismas: unidad de

grandes quemados, unidad de cuidados intermedios, tratamiento

ambulatorio y unidad de cuidados intensivos.


IV-92

Fig. IV.14: “Áreas de Hospitalización: Criterios de Ingreso”

El apartado “Tratamiento del Paciente Quemado” (Fig. IV.15)

es el más extenso y contiene dos de los puntos más importantes del

atlas:

� Curas del Paciente Quemado.

� Cirugía del Paciente Quemado.

El punto “Curas del Paciente Quemado” (Fig. IV.16) está

formado por siete subapartados donde se explica cómo se manejan

los distintos tipos de quemaduras, su limpieza, los materiales a

utilizar o las diferentes opciones a la hora de curar (Fig. IV.17).


IV-93

Fig. IV. 15: “Tratamiento del Paciente Quemado”

Fig. IV.16: “Curas del Paciente Quemado”


IV-94

Fig. IV.17: “Tipos de Curas”

El punto “Cirugía del Paciente Quemado” (Fig. IV.18) muestra

cómo ha de intervenirse la quemadura, desde la escarectomía (Fig.

IV.19), hasta la cobertura de las quemaduras (Fig. IV.20) una vez

eliminada la escara, o el uso de colgajos tisulares (Fig. IV.21) si no

es posible la aplicación de ningún sustitutivo cutáneo.


IV-95

Fig. IV.18: “Cirugía del Paciente Quemado”

Fig. IV.19: “Escarectomía”


IV-96

Fig. IV.20: “Cobertura de las Quemaduras”

Fig. IV.21: “Colgajos para el Tratamiento de las Quemaduras”


IV-97

En el último apartado del capítulo “Soporte Nutricional del

Paciente Quemado” (Fig. IV.22) podemos ver las necesidades

calóricas del paciente que ha sufrido alteraciones nutricionales

debido al trauma térmico.

Fig. IV.22: “Soporte Nutricional del Paciente Quemado”


IV-98

Capítulo 4: Infecciones en el Paciente Quemado

En este capítulo nos encontramos con los siguientes puntos

(Fig. IV.23):

� Infección Local o de la Quemadura.

� Otras Infecciones.

� Prevención y Seguimiento de la Infección.

Fig. IV.23: “Infecciones en el Paciente Quemado”

El punto “Infección Local o de la Quemadura” (Fig. IV.24)

presenta la complicación más frecuente que sufre un paciente

quemado, los signos clínicos de la infección, las consecuencias, las

fases, el diagnóstico y los gérmenes más frecuentes.


IV-99

Fig. IV.24: “Infección Local o de la Quemadura”

En “Otras Infecciones” (Fig. IV.25) podemos ver las dolencias

en otros órganos distintos a la piel, debido al estado de

inmunosupresión.

Por último, en “Prevención y Seguimiento de la Infección” (Fig.

IV.26) se comentan los distintos protocolos para la vigilancia

bacteriológica.


IV-100

Fig. IV.25: “Otras Infecciones”

Fig. IV.26: “Prevención y Seguimiento de la Infección”


IV-101

Capítulo 5: Complicaciones en el Paciente Quemado

Se divide en dos apartados (Fig. IV.27):

� Complicaciones Locales.

� Complicaciones Generales.

Fig. IV.27: “Complicaciones en el Paciente Quemado”

En “Complicaciones Locales” (Fig. IV.28) se estudian las

heridas abiertas, injertos y zonas donantes; las secuelas del

síndrome compartimental; las úlceras por decúbito; hueso ectópico;

y las úlceras de Marjolin. Estas complicaciones aparecen debido al

retraso en el cierre de las heridas.


IV-102

Fig. IV.28: “Complicaciones Locales”

Finalmente, en “Complicaciones Generales” (Fig. IV.29)

aparecen las distintas complicaciones que pueden presentarse en

cualquier paciente hospitalizado en estado grave.


IV-103

Fig. IV.29: “Complicaciones Generales”


IV-104

Capítulo 6: Rehabilitación y Prevención de las Deformidades

En este capítulo nos encontramos con dos puntos (Fig. IV.30):

� Rehabilitación Precoz.

� Presoterapia.

Fig. IV.30: “Rehabilitación y Prevención de las Deformidades”

El primer apartado “Rehabilitación Precoz” (Fig. IV.31)

muestra los objetivos de esta fase: correcta colocación del paciente,

movilizaciones precoces, fisioterapia respiratoria y prevención de

las úlceras por presión. Por ello, el médico debe realizar una

evaluación lo más precoz posible tras el trauma.

En “Presoterapia” (Fig. IV.32) se controla el estado de

cicatrización de las quemaduras.


IV-105

Fig. IV.31: “Rehabilitación Precoz”

Fig. IV.32: “Presoterapia”


IV-106

Capítulo 7: Secuelas y Reconstrucción del Paciente Quemado

Es el último de los capítulos y se divide en (Fig. IV. 33):

� Principios Generales de la Reconstrucción.

� Clasificación y Tipo de Secuelas

Fig. IV.33: “Secuelas y Reconstrucción del Paciente Quemado”

En “Principios Generales de la Reconstrucción” (Fig. IV.34) se

exponen los distintos pasos para la reconstrucción del paciente

quemado desde su ingreso en el hospital.

Por último, en el punto “Clasificación y Tipo de Secuelas” (Fig.

IV.35) se enumeran las distintas zonas corporales afectadas por las

quemaduras.


IV-107

Fig. IV.34: “Principios Generales de la Reconstrucción”

Fig. IV.35: “Clasificación y Tipo de Secuelas”


IV-108

Para profundizar en cada uno de los capítulos citados, se

puede consultar el CD que contiene la aplicación del atlas.

Atlas de Quemaduras V. Conclusiones y Líneas Futuras

V-109

V. Conclusiones y Líneas Futuras

Para finalizar la memoria del proyecto comentaremos la

utilidad del mismo, así como futuras ampliaciones y mejoras en el

desarrollo del atlas.

Este atlas contiene una gran cantidad de imágenes e

información, que junto con su estructura intuitiva, lo hacen

incomparable respecto a los libros de texto que buscan ilustrar el

diagnóstico y tratamiento de las quemaduras.

El formato en el que se presenta (CD) es mucho más versátil

y económico a la hora de ampliar, actualizar o cambiar su

contenido, y el espacio que ocupa es mínimo. Además, el tener

acceso a un PC no debe suponer un gran problema hoy en día.

A la hora de ampliar el atlas existen numerosas posibilidades

que pueden hacer de él una herramienta aún más útil:

� La actualización de la información e imágenes o la realización

de nuevas versiones, así como el uso de un DVD, permiten

que no quede obsoleto.

� Director permitiría la elaboración de un test interactivo, donde

el lector pueda evaluar sus conocimientos adquiridos tras el

estudio del atlas.

Atlas de Quemaduras V. Conclusiones y Líneas Futuras

V-110

� Una de las ampliaciones más importantes es la introducción

de otros programas. De esta manera, al añadir el Quicktime

se incluirían vídeos sobre procedimientos; con el Matlab se

podría hacer una estimación de la profundidad de la

quemadura de forma automática a partir de las imágenes

digitales; y con otras herramientas inteligentes la posibilidad

de realizar el cálculo de la superficie corporal quemada o

distintas simulaciones.

� Establecidas las bases, podrían elaborarse otros atlas sobre

temas pocos conocidos como la Microcirugía Reconstructiva.

Para finalizar, destacar que con la posible publicación del

atlas espero que se convierta en una herramienta útil tanto para

médicos, enfermeros, como estudiantes de medicina, y dar así a

conocer en mayor medida un tema poco desarrollado.

Quisiera expresar un agradecimiento especial a Araceli

Lagares Borrego, médico encargada del desarrollo teórico y de la

obtención de las imágenes, cuyo trabajo ha permitido la elaboración

del atlas y su futura publicación; a Carmen Serrano Gotarredona del

Departamento de Teoría de la Señal y Comunicaciones y a la tutora

del proyecto Begoña Acha Piñero.

Atlas de Quemaduras VI. Bibliografía

VI-111

VI. Bibliografía

Desde el punto de vista médico:

Memoria

1. Domínguez Roldán J.M., Gómez T., Martín Bermúdez R.

Principios de urgencias, emergencias y cuidados críticos

Capítulo 9.8 El paciente quemado grave. Uninet Web:

www.uninet.edu/tratado/c0908i.html

2. Arturson G. (1992) Analysis of sense disasters

Chapter 4: Marsellis M., Gunns, Eds. The management of

Mars Burn Casualties and Fire Disasters:

Proceeding of the first international Conference on Burns and

five disasters. Dordrecht/ Boston/ London: Klumer Academic

Publishers: 24-33

3. Rose J. and Herndon D. Advances in the treatment of burn

patients. Burns 1997; 23, supp.1 : s19-s26

4. Fernández- Morales E., Gálvez- Alcaraz L., Fernandez-

Crehmet- Nanajas J., Gómez-García E. y Salinas Martínez J.

Epidemialogy of burns in Málaga, Spain. Burns 1997; 23; 323-

332


VI-112

5. Bull J. and Squire J. A study of mortality in a burns unit. Ann.

Surg. 1949; 130:160. Bull J. P and Fisher A. J A study of burns

at the Massachusetts General Hospital, 1939-1954. Ann Surg.

1954; 145:210

6. Prnitt B.A and Mason A. Epidemiological Demographic and out

come characteristics of Burns injury, in Total Burn Core,

D. Herndon Ed. Saunders C. (1996), London, p.13

7. Tobiason J., Hiebert J., Edlich R. A practical burn Severity

index. J. Burn 1982; 3:229-235.B

8. Gómez-Cia T., Ortega-Martínez J.I., Mallén J.M., Márquez T.,

Posejo J.M., Santos J., Plasencia C., Julio-Agosto-Septiembre

1998. Escisión precoz de la herida por quemaduras. Su

influencia en la estancia hospitalaria y en los cultivos de la

herida. Cirugía plástica Ibero-latinoamericana. Vol. 24- Núm.

3, Págs. 297-306

Atlas

1. Barret J.P., Rendón D.N. Colour atlas of Burn Care. Ed. W.B

Saunders 2001

2. Llorente. Cuidados intensivos del paciente quemado.

Springer- Verlag Ibérica


VI-113

Internet

Manual de la Sociedad Española de Cirugía Plástica,

Reparadora y Estética.

Web: http://www.secpre.org/documentos%20manual.html

Uso del Director 8:

1. Director 8 Workshop. Gerd Gillmaier and Joachim Gola.

Marcombo Boixareu Editores

2. Herramientas de Autor Multimedia: Creación y Diseño con

Director 8 y ToolBook II. Manuel-Alonso Castro Gil, Antonio

Colmenar Santos, Pablo Losada de Dios, Juan Peire Arroba.

RA-MA Editorial. 2001

Páginas de internet consultadas para el uso del Director 8:

http://www.todoexpertos.com/categorias/tecnologia_e_internet/de

sarrollo_de_sitios_web/macromedia_director/

Referencias

[1] Iván María González Guzmán. “Desarrollo de un atlas de

quemaduras mediante la implementación de una herramienta

multimedia”. Proyecto Fin de Carrera. Ingeniería de

Telecomunicación. Escuela Superior de Ingenieros.

Universidad de Sevilla. Junio 2004.

Proyecto Atlas Quemaduras - Universidad de...

Documents

Transcript of Proyecto Atlas Quemaduras - Universidad de...