|
|
|
|
|
| Description |
| Este módulo importa todas las funciones y tipos necesarios para el correcto
funcionamiento de la libreria y exporta sólo aquellas necesarias para el usuario. Por tanto
sólo es necesario incluir este módulo para poder utilizar todas las funciones definidas de la biblioteca.
El módulo principal en el que se apoya es CgiBase.
|
|
|
| Módulos auxiliares
|
|
| Módulo cgiBase
|
|
| Funciones básicas para el CGI.
|
|
| runCgi
|
|
| runCgi |
| :: Cgi () | Representa el cómputo (la página) que queremos mostrar.
| | -> IO () | | | Esta función toma como argumento un Cgi y muestra la página asociada.
Para ello se apoya en la función startCgi implementada más abajo.
(En la documentación presentamos la definición de startCgi que es más completa que ésta)
|
|
|
Ejemplo:
main :: IO ()
main = runCgi programa
where
programa :: Cgi ()
programa = ...
|
|
| runCgiExt
|
|
| runCgiExt |
| :: Maybe String | Nos permite especificar un nombre de archivo si queremos guardar el resultado.
| | -> Bool | Indica si queremos leer de entrada estándar o queryString
| | -> StateType | Este argumento indica la forma de guardar el estado de la mónada (InClient ó InServer).
| | -> Cgi () | Representa el cómputo (la página) que queremos mostrar.
| | -> IO () | | | runCgiExt es una versión extendida de la función runCgi. Nos permite especificar un nombre de archivo en el caso de
que queramos guardar el resultado (la página generada) en el servidor.
También podemos especificar en el segundo argumento booleano si queremos que lea de entrada estándar o queryString si
es True, o no leer, si es False.
|
|
|
| Funciones especiales para formularios
|
|
| ask |
| :: Html a | Página a mostrar
| | -> Cgi a | Valor devuelto
| Esta función permite mostrar al cliente un formulario (cuando utilizamos ask, se supone que estamos esperando
alguna información del cliente). Para los casos en los que no queramos obtener valores de formulario (sólo queramos mostrar
una página normal) utilizaremos tell.
Ejemplo:
main :: IO ()
main = runCgi principal
where
principal :: Cgi ()
principal = ask primeraPágina
primeraPágina :: Html a
primeraPágina = hHtml $ do { hHead(...)
; hBody(...)
}
En los programas que codifiquemos, cada ask representa una interacción con el cliente, por lo que algo como esto:
do { ask pagina1
; ask pagina2
; ask pagina3
}
No mostrará las 3 páginas al ejecutarse, sino que automáticamente determinará cuáles de ellas han sido
ejecutadas ya.
En la primera ejecución, sólo se mostrará pagina1. En la segunda, no se mostrará pagina1 y se mostrará
pagina2. En la tercera ejecución, no se mostrará ni pagina1 ni pagina2, y se mostrará pagina3.
Hay un método alternativo para secuenciar varios formularios y permitir la presentación de diferentes páginas
dependiendo del botón pulsado en un formulario (podemos incluir más de uno en cada formulario). Esto está explicado
en detalle en la definición de la función hButtonInput.
|
|
|
| askExt |
| :: Attr | Atributos para la etiqueta <DOCTYPE>
| | -> Html a | Página a mostrar
| | -> Cgi a | Valor devuelto
| | Esta función tiene exactamente el mismo objetivo que ask, presentar al cliente un formulario.
Pero esta versión extendida nos permite determinar el atributo del elemento <DOCTYPE>.
(En la función ask se utiliza por defecto el atributo transDocAttribute).
|
|
|
| Presentación de páginas normales
|
|
| tell |
| :: Html a | Página a mostrar
| | -> Cgi a | Valor devuelto
| Esta función muestra una página al cliente en la que no tenemos posibilidad de recoger información de ningún tipo.
Ejemplo:
main :: IO ()
main = runCgi páginaSinForm
where
páginaSinForm :: Cgi ()
páginaSinForm = tell $ do { hHtml (...) }
Con tell no tenemos posibilidad de presentar las páginas progresivamente (sería un error secuenciar
varias acciones tell, ya que sólo se mostraría una de ellas, la primera).
|
|
|
| tellExt |
| :: Attr | Atributos para la etiqueta <DOCTYPE>
| | -> Html a | Página a mostrar
| | -> Cgi a | Valor devuelto
| | Esta función tiene el mismo objetivo que tell, presentar al cliente una página sin formularios.
Al igual que askExt, es una versión extendida de su predecesora. Permite determinar el atributo para
la etiqueta <DOCTYPE> en la página generada, siendo utilizado por defecto el atributo transDocAttribute
en tell.
|
|
|
| Variables de entorno disponibles.
|
|
En el módulo CgiBase también están disponibles diferentes funciones definidas en el módulo Var.
Estas funciones están relacionadas con los nombres de las variables de entorno que define Xitami al solicitar cualquier
página web o archivo del servidor.
En el caso de utilizar otro servidor sólo hay que cambiar el valor de la variable asociada por el nuevo nombre
creado por el servidor.
Ejemplo de utilización:
do { valor <- unsafeIO $ getEnv serverName
; ...
}
getEnv es una función predefinida en el módulo System de la biblioteca de Haskell. Su definición es la
siguiente:
getEnv :: String -> IO String
La función unsafeIO pertenece a la clase IOAction, y permite realizar acciones de entrada/salida
mientras se crea la página.
|
|
| serverSoftware :: String |
| Nombre del servidor.
|
|
| serverVersion :: String |
| Versión del servidor web.
|
|
| serverName :: String |
| Nombre de servidor actual (host).
|
|
| serverUrl :: String |
| El Url completo para el servidor.
|
|
| serverPort :: String |
| Puerto donde se está ejecutando el servidor.
|
|
| serverProtocol :: String |
| Versión HTTP (ej. "HTTP/1.0").
|
|
| gatewayInterface :: String |
| Versión Cgi (ej. "Cgi/1.1").
|
|
| requestMethod :: String |
| Método HTTP usado, Get o Post.
|
|
| queryMethod :: String |
| Igual que requestMethod, método HTTP usado, Get o Post.
|
|
| contentType :: String |
| Tipo de contenido.
|
|
| contentLength :: String |
| Longitud (número de caracteres) recibidos.
|
|
| remoteUser :: String |
| Usuario autorizado, si lo hay, en otro caso "-"; solo se utilizará al entrar en URL's protegidos.
|
|
| remoteHost :: String |
| Igual que remoteAddr, dirección del host remoto, "x.x.x.x".
|
|
| remoteAddr :: String |
| Dirección del host remoto, "x.x.x.x".
|
|
| scriptPath :: String |
| Path del script que se está ejecutando.
|
|
| scriptName :: String |
| URI del script que se está ejecutando.
|
|
| queryString :: String |
| Es la cadena que sigue al URL (los parámetros recibidos del formulario).
|
|
| pathInfo :: String |
| Es cualquier información de path siguiendo al URL de cgi.
|
|
| pathTranslated :: String |
| Path completo traducido con argumentos URL.
|
|
| cgiRoot :: String |
| Directorio binario de cgi.
|
|
| cgiStdIn :: String |
| Fichero de entrada estándar Cgi.
|
|
| cgiStdOut :: String |
| Fichero de salida estándar Cgi.
|
|
| cgiStdErr :: String |
| Fichero de error estándar Cgi, si lo hubiera.
|
|
| documentRoot :: String |
| Directorio raiz de las páginas de inicio.
|
|
| Creación de etiquetas HTML.
|
|
| Tipos básicos
|
|
| data Cgi a |
| Un valor de tipo Cgi a representa un cómputo realizado en un programa Cgi que devuelve un valor de tipo a.
(Cualquier página se forma con las funciones ask ó tell que devuelven tipo Cgi a).
| | Instances | |
|
|
| data Html a |
| Un valor de tipo Html a representa un cómputo que crea una etiqueta de una página Html y devuelve un
dato de tipo a.
| | Instances | |
|
|
| data StateType |
| Forma de guardar el estado (parámetro de la función runCgiExt).
| | Constructors | | InClient | Guarda el estado en un campo oculto del formulario.
| | InServer | Crea un fichero temporal en el servidor, junto con un password aleatorio para controlar el acceso
de los usuarios a dichos archivos (el nombre del archivo se incluye en un campo oculto del formulario,
pero el estado se almacena en el servidor).
|
| | Instances | |
|
|
| data MethodType |
| Este tipo nos permite determinar el método que vamos a utilizar en los formularios (parámetro de la función hFormExt).
| | Constructors | | Get | Método Get (la información es recibida a través de la variable de entorno queryString).
| | Post | Método Post (la información es recibida a través de la entrada estándar).
|
|
|
|
| Clases definidas
|
|
| class (Show a, Read a) => CgiInput a where |
| Esta clase permite mostrar mensajes de error cuando no sea posible una lectura correcta de la cadena de caracteres
para su conversión a un tipo instanciado de la clase. Así mismo, define las funciones de análisis y visualización de un valor para
un tipo específico (el tipo instanciado).
Si queremos mostrar de una forma específica un dato de dicho tipo, o cambiar la forma en la que se lee, para realizar
la conversión de tipos, sólo debemos definir las funciones pertenecientes a la clase.
Todas las funciones, excepto msg, tienen algún método por defecto definido (que coincide con las funciones predefinidas
de Haskell para lectura y visualización).
| | | Methods | | toString :: a -> String | | Visualización de un valor.
| | | listToString :: [a] -> String | | Visualización de una lista de valores.
| | | parse :: ReadS a | | Lectura de un valor (a partir de una cadena de caracteres).
| | | parseList :: ReadS [a] | | Lectura de una lista de valores.
| | | msg :: a -> String | Mensaje de error que se mostrará en los casos en los que haya problemas de lectura (si la conversión de tipos no se
realiza con éxito).
Esta es la única función que no tiene métodos por defecto definidos. Por lo tanto, cualquier instancia de un tipo
debe proporcionar, al menos, la definición de esta función.
Ejemplo:
instance CgiInput Int where
msg _ = "Int expected from data input."
|
| | | Instances | |
|
|
| class (Monad m) => IOAction m where |
| Los tipos pertenecientes a esta clase son cómputos que pueden realizar operaciones de entrada/salida. Los tipos
Html y Cgi son instancias de esta clase.
| | | Methods | | unsafeIO :: IO a -> m a | Esta función permite ejecutar un cómputo de entrada/salida en la mónada m.
Ejemplo:
do { valor <- unsafeIO $ getClockTime
; ... (utilizamos valor)...
}
Este trozo de código realizará la acción de entrada/salida cada vez que se ejecute.
| | | safeIO :: (Show a, Read a) => IO a -> m a | Esta función, al igual que unsafeIO, permite ejecutar un cómputo de entrada/salida en la mónada m,
pero tiene en cuenta los valores devueltos por la acción para ejecuciones futuras, es decir, garantiza que el valor
devuelto siempre es el mismo (el primero que obtuvimos).
Ejemplo:
do { valor <- safeIO $ randomRIO (minV,maxV)
; ... (utilizamos valor)...
}
Este trozo de código sólo realizará la acción de entrada/salida la primera vez que se ejecute (las demás veces
recogerá el valor almacenado de la primera ejecución).
|
| | | Instances | |
|
|
| Funciones para añadir atributos a una etiqueta
|
|
| withAttr |
| :: (IsAttr attr) | | | => attr | Atributos HTML
| | -> Html a | Etiqueta donde se incluirán los atributos.
| | -> Html a | Etiqueta con atributos añadidos.
| withAttr toma un parámetro que puede ser traducido en atributos HTML y los
añade a la etiqueta Html que toma como segundo argumento.
Ejemplo:
withAttr atributos $ hHtml (...)
where
atributos :: Attr
atributos = ...
Para profundizar sobre la forma de crear atributos ver Attr.
|
|
|
| withCss |
| :: (IsAttr attr) | | | => attr | Atributos CSS
| | -> Html a | Etiqueta donde se incluirán los atributos.
| | -> Html a | Etiqueta con atributos añadidos.
| | withCss toma un parámetro que puede ser traducido en atributos de estilo (CSS) y los añade a etiqueta
Html que toma como segundo argumento. El ejemplo presentado para withAttr también es válido aquí, pues
los atributos de estilo son también de tipo Attr.
|
|
|
| Funciones para crear las etiquetas
|
|
Cada una de las siguientes funciones crean una etiqueta de apertura y de cierre (cuando sea necesario)
de los elementos Html a los que hacen referencia. Es decir, una función como hBody crea la etiqueta
<BODY> en el documento final. Los casos excepcionales serán comentados en su definición.
Todas aquellas etiquetas simples (aquellas que no tienen cierre, sólo apertura) tendrán tipo Html (),
puesto que no reciben ningún argumento. Las demás etiquetas tienen tipo
Html a -> Html a, donde el primer argumento representa el contenido de dicha etiqueta
(lo que se incluirá entre la apertura y el cierre de la misma).
Por lo tanto, todas aquellas funciones que no tengan una explicación detallada corresponden con la creación de
las etiquetas HTML 4.0 cuyos nombres coinciden con el de la función definida (las demás tendrán un funcionamiento
especial).
La sintaxis utilizada es la siguiente:
- Anteponer el carácter 'h' a todas las funciones (para no crear confusión con otras funciones
predeterminadas del Prelude).
- Utilizar la primera letra de cada palabra en mayúsculas, así como la de las palabras compuestas.
- Los nombres compuestos se definen concatenando las palabras que intervienen en su definición (no hay
ningún carácter de separación especial como pudiera ser '_').
Ejemplos de funciones definidas:
Etiqueta <BODY> => Función hBody
Etiqueta <NOFRAME> => Función hNoFrame
Etiqueta <BASEFONT> => Función hBaseFont
Etiqueta <A> => Función hA
Ejemplo de utilización:
programa :: Html ()
programa = do {funcionEtiquetaNormal funcionEtiquetaSimple
;funcionEtiquetaNormal2 (do {hText "Hola"
;...
}
)
}
where
funcionEtiquetaNormal :: Html a -> Html a
...
funcionEtiquetaNormal2 :: Html a -> Html a
...
funcionEtiquetaSimple :: Html ()
...
Ejemplo práctico:
main :: IO ()
main = runCgi holaMundo
where
holaMundo :: Cgi ()
holaMundo = tell $ hHtml $
do { hHead $ hTitle $ hText "Hola"
; hBody $ hText "Hola Mundo"
}
|
|
| Texto y valores mostrables
|
|
| hText :: String -> Html () |
| Función que muestra en la página, la cadena de caracteres que se le proporcione como argumento.
|
|
| hEmpty :: Html () |
| Esta función es útil cuando no queremos mostrar ningún elemento, pero necesitamos una función de tipo Html a.
(Esta función no incluye ninguna información en la página resultante).
|
|
| hShow :: (Show a) => a -> Html () |
| Mostramos la representación en cadenas de caracteres, del argumento recibido (se hace un show del valor).
|
|
| Elementos más externos
|
|
| hHtml :: Html a -> Html a |
|
| hHead :: Html a -> Html a |
|
| hBody :: Html a -> Html a |
|
| hFrameSet :: Html a -> Html a |
|
| Elementos Head
|
|
| hBase :: Html () |
|
| hIsIndex :: Html () |
|
| hLink :: Html () |
|
| hMeta :: Html () |
|
| hScript :: Html a -> Html a |
|
| hStyle :: Html a -> Html a |
|
| hTitle :: Html a -> Html a |
|
| Elementos de bloque genéricos
|
|
| hAddress :: Html a -> Html a |
|
| hBlockQuote :: Html a -> Html a |
|
| hCenter :: Html a -> Html a |
|
| hDiv :: Html a -> Html a |
|
| hH1 :: Html a -> Html a |
|
| hH2 :: Html a -> Html a |
|
| hH3 :: Html a -> Html a |
|
| hH4 :: Html a -> Html a |
|
| hH5 :: Html a -> Html a |
|
| hH6 :: Html a -> Html a |
|
| hHr :: Html () |
|
| hNoScript :: Html a -> Html a |
|
| hP :: Html a -> Html a |
|
| hPre :: Html a -> Html a |
|
| Elementos de Listas
|
|
| hDir :: Html a -> Html a |
|
| hDl :: Html a -> Html a |
|
| hDt :: Html a -> Html a |
|
| hDd :: Html a -> Html a |
|
| hLi :: Html a -> Html a |
|
| hMenu :: Html a -> Html a |
|
| hOl :: Html a -> Html a |
|
| hUl :: Html a -> Html a |
|
| Elementos de tablas
|
|
| hTable :: Html a -> Html a |
|
| hCaption :: Html a -> Html a |
|
| hColGroup :: Html a -> Html a |
|
| hColGroupS :: Html () |
|
| hCol :: Html () |
|
| hTHead :: Html a -> Html a |
|
| hTFoot :: Html a -> Html a |
|
| hTBody :: Html a -> Html a |
|
| hTr :: Html a -> Html a |
|
| hTd :: Html a -> Html a |
|
| hTh :: Html a -> Html a |
|
| Formularios
|
|
| Tipos y funciones especiales
|
|
| getFieldName :: Html String |
| Esta función nos permite obtener el nombre que se asignará al siguiente campo de formulario.
|
|
| getSubmitName :: Html String |
| Esta función nos permite obtener el nombre que se asignará al siguiente campo submit de un formulario.
|
|
| data SelectOption a |
| Con este tipo nos cercioramos de que los parámetros utilizados con la función hSelectInputExt
son etiquetas <Option> o bien, etiquetas <Optgroup> (o una combinación de ellas lógicamente).
|
|
|
| tempFilePath :: String |
| Path del directorio temporal donde se guardarán los archivos que guardan el estado (en caso de que StateType
sea InServer). Cuando se utiliza este método, automáticamente se comprueba si este directorio existe o no.
De no existir, se crean automáticamente tanto el directorio como el archivo que guarda el contador cgiCont.
Si el directorio existe, entonces sólo se comprueba la existencia de dicho archivo.
|
|
| cgiCont :: String |
| Nombre del archivo que contiene la cuenta para generar los diferentes nombres de los archivos temporales.
|
|
| Campos y etiquetas de formularios
|
|
| hForm |
| :: Html () | Página a mostrar
| | -> Html () | | | hForm crea las etiquetas necesarias para incluir un formulario en la página. Automáticamente añade los valores
para la acción (atributo pAction), que será el mismo archivo que se está ejecutando actualmente, y
el método (Post). Recibe como argumento el contenido que se mostrará en el formulario.
|
|
|
| hFormExt |
| :: MethodType | Método a utilizar en el envío de datos al servidor.
| | -> Html () | Página a mostrar
| | -> Html () | | | Esta función funciona exactamente igual que hForm, pero permite especificar el método a utilizar en su
primer argumento
|
|
|
| hTextInput |
| :: (CgiInput a) | | | => Html a | Devuelve el valor introducido en el formulario
| Función utilizada para incluir un campo de entrada de texto. Sin embargo, el dato recogido es automáticamente
comprobado y convertido al tipo adecuado para su utilización. Por lo tanto, es obligatorio que el tipo al que debe
convertirse el valor recogido sea instancia de la clase CgiInput (para asegurarnos de que disponemos de las funciones
adecuadas de conversión y visualización de dicho tipo).
Ejemplo:
do {...
;edad <- hTextInput
;guardaEdad edad
}
where
guardaEdad :: Int -> Html a
En este ejemplo, la variable edad debe ser de tipo Int obligatoriamente, ya que la definición de guardaEdad
así lo define. En caso de que el dato recogido no pueda ser convertido al tipo esperado,
obtendremos una página de error (para más información ver CgiInput).
|
|
|
| hPasswordInput |
| :: Html String | Cadena de caracteres introducida en el formulario
| Creación de campo de passwords (no se visualizan los caracteres al introducirlos).
Ejemplo:
do {nombre <- hTextInput
;pass <- hPasswordInput
;registra nombre pass
...
}
where
registra :: String -> String -> Html a
registra n p = ...
|
|
|
| hCheckBoxInput |
| :: Html Bool | Devuelve True si fue pulsada. False en otro caso.
| Creación de una caja de selección.
Ejemplo:
do{...
;pulsado <- hCheckBoxInput
;procesaPulsado pulsado
}
where
procesaPulsado :: Bool -> Html a
procesaPulsado p = ...
|
|
|
| hRadioGroupInput |
| :: (CgiInput a) | | | => [(Html (), a)] | Una lista de "definiciones" y el valor asociado al botón.
| | -> Html a | Devolvemos el valor asociado al botón pulsado (valor proporcionado en
el parámetro anterior).
| Esta función crea un conjunto de botones radiales relacionados (sólo uno de ellos puede
estar marcado en un momento dado). Para cada uno de ellos se puede dar una definición o crear una etiqueta especial
(notar que el parámetro es de tipo Html () por lo que podríamos incluir una imagen, por ejemplo, como descripción
del botón radial). Si sólo queremos dar una definición escrita, nos basta con utilizar hText.
Ejemplo:
do {...
;hText "Elige una opción"
;valor <- hRadioGroupInput [(hText "Opción 1",1),(hText "Opción 2",2),(hText "Opción 3",3)]
;guardaValor valor
...
}
where
guardaValor :: Int -> ...
En este ejemplo, podemos observar que el valor devuelto por la función hRadioGroupInput no es una cadena de
caracteres sino un entero, ya que se hace la conversión de tipos de forma automática.
|
|
|
| hFileInput :: Html String |
| Esta función crea una etiqueta que nos permite el envío de archivos al servidor. Para ello es necesario que el método
utilizado para enviar el formulario sea Post y el atributo pEncType sea "multipart/form-data". Actualmente,
sin embargo, no es posible utilizar este método de envío, puesto que no está implementado en la biblioteca la
decodificación de este formato en la recepción de los datos.
(si utilizamos el modo "multipart/form-data" obtendremos un error en la ejecución de la función runCgi).
No obstante, si no especificamos el valor de pEncType tal y como hemos citado antes,
podremos obtener una cadena de caracteres que corresponde con el archivo que el cliente quería enviar al servidor. Esto
es útil si pretendemos asociar algún programa que se encargue del envío del fichero a partir del nombre
del mismo (podemos incluir en el lado del cliente un gestor de envio de ficheros en javascript por ejemplo).
|
|
| hHiddenInput |
| :: Html String | Valor del campo oculto
| Creación de un campo oculto en el formulario. El valor devuelto es el valor proporcionado en su creación (por medio
del atributo pValue).
Ejemplo:
do {valor <- withAttr (pValue =: v) $ hHiddenInput
;...
}
where
v :: Value
v = ...
|
|
|
| hPrimButtonInput :: Html () |
| Esta función permite añadir botones normales que no devuelven ningún resultado. (Son útiles si se combinan
con otros elementos, como por ejemplo javascript).
|
|
| hSubmitInput :: Html () |
| Incluye un botón de aceptación del formulario. Al pulsarse, los datos serán enviados al servidor.
|
|
| hResetInput :: Html () |
| Botón de Reset. Inicializa los campos, borrando el contenido que hubiéramos escrito en ellos.
|
|
| hButtonInput |
| :: String | Mensaje que aparecerá en el botón.
| | -> Cgi () | Acción a ejecutar si se pulsa el botón.
| | -> Html () | | Esta función permite especificar una acción asociada al botón que vamos a crear.
De esta forma, si el botón se pulsa, se llevará acabo la acción especificada. Si disponemos
varios botones en un mismo formulario, damos la oportunidad de presentar al cliente diferentes resultados. Esta acción
normalmente estará relacionada con los datos recogidos en el formulario actual (en el que se incluye el botón).
Ejemplo:
do {nombre <- hTextInput
;pass <- hPasswordInput
;hButtonInput "Entrar servidor 1" (comprueba1 nombre pass)
;hButtonInput "Entrar servidor 2" (comprueba2 nombre pass)
...
}
where
comprueba1 :: String -> String -> Cgi ()
comprueba1 n p = if (correcto1 n p) then
tell paginaCorrectaServidor1
else
ask formularioEntradaOtraVez
comprueba2 :: String -> String -> Cgi ()
comprueba2 n p = if (correcto2 n p) then
tell paginaCorrectaServidor2
else
ask formularioEntradaOtraVez
No debemos utilizar los valores recogidos en el mismo formulario en el que se presentan las etiquetas,
sino en el siguiente, tal y como se muestra en el ejemplo, ya que en la primera ejecución, sólo se crearán las
etiquetas (necesitamos ejecutarlo al menos una vez más para poder recoger los valores introducidos por el cliente).
La segunda vez que se ejecute el programa, se recogerán todos los valores y se mostrará la página generada por
la función que hemos proporcionado a hButtonInput sólo si ese botón ha sido pulsado.
|
|
|
| hImageInput |
| :: String | Path de la imagen que queremos mostrar.
| | -> ((Int, Int) -> Cgi ()) | Función que toma una tupla de dos enteros (las coordenadas) y devuelve una acción Cgi () (otra página).
| | -> Html () | | Tiene el mismo objetivo que hButtonInput, funciona como si fuera un botón submit, pero en vez de presentarlo,
presenta una imagen en la que podemos "pinchar" con el ratón.
Dependiendo de la zona donde pinchemos (coordenadas x e y de la imagen) se llevará a cabo una acción u otra
(depende de la función que especifiquemos).
Ejemplo:
do {...
;hImageInput "imagen.jpg" compruebaCoordenadas
}
where
compruebaCoordenadas :: (Int,Int) -> Cgi ()
compruebaCoordenadas (x,y) =
if (x > unValorX) then
if (y > unValorY) then
tell pagina1
else
tell pagina2
else
if (y > otroValorY) then
tell pagina3
else
tell pagina4
pagina1 :: Html ()
pagina2 :: Html ()
...
|
|
|
| hSelectInput |
| :: (CgiInput a) | | | => [a] | Lista de valores (serán visualizados a partir de la implementación de toString (clase CgiInput).
| | -> Html a | Devuelve el valor seleccionado con el tipo apropiado.
| Esta función crea una lista de selección no múltiple (sólo devuelve un dato) y sin opciones agrupadas. Es un poco
menos potente que la función hSelectInputExt (la versión extendida) pero más fácil de utilizar. Sólo es apropiada
cuando queremos crear una lista de selección con opciones simples. Al igual que hRadioGroupInput, realiza conversión
de tipos de forma automática (el valor devuelto no tiene por qué ser una cadena de caracteres).
Ejemplo:
data Día = Lunes | Martes | Miercoles | Jueves | Viernes | Sábado | Domingo
deriving (Show,Read,Enum)
instance CgiInput Día
\
do { hText "Select con opciones simples"
; valor <- hSelectInput [Lunes..Viernes]
; hButtonInput "Ver valor" (verValor valor)
...
}
where
verValor :: Día -> Cgi ()
verValor d = ...
|
|
|
| hSelectInputExt |
| :: (CgiInput a) | | | => [SelectOption a] | Lista de opciones creadas con una combinación de hOption y hOptGroup
| | -> Html [a] | Lista de valores seleccionados.
| hSelectInputExt recibe una lista de opciones select (que representan a las posibles elecciones) y devuelve una lista de valores,
que son los valores seleccionados (puede ser un select multiple añadiendo el atributo aMultiple).
Al igual que hSelectInput, realiza la conversión de tipos de forma automática para devolver un dato del mismo tipo.
El único requisito es que todas las opciones se construyan con el mismo tipo instanciado, es decir, si queremos
añadir valores enteros, todas las opciones deben ser construidos a partir de valores enteros (no podemos añadir
una opción de tipo entero y otra de tipo Char por ejemplo).
Ejemplo:
do { hText "Select con opciones múltiples"
; lista <- withAttr aMultiple $ hSelectInputExt opciones
; hButtonInput "Ver valores" (verValores lista)
...
}
where
opciones = [hOption Lunes,
hOption Martes,
hOptGroup "Fin de Semana" [Viernes,Sábado,Domingo],
hOption Jueves]
\
verValores :: [Día] -> Cgi ()
verValores lista = ...
Podemos observar que verValores recibe una lista de Día, que es el tipo de los valores que habíamos utilizado
para crear la lista de selección (con hSelectInputExt). Para ver la definición del tipo Día, acudir a la definición
de la función hSelectInput.
|
|
|
| hTextAreaInput |
| :: Value | Número de filas.
| | -> Value | Número de columnas.
| | -> Html String | Devuelve el texto escrito por el usuario.
| Creación de un área de texto en la que podemos escribir párrafos de larga longitud. Las dimensiones son
a filas por b columnas, donde a y b son, respectivamente, el primer y segundo argumento que recibe.
Ejemplo:
do {hText "Introduce un texto"
;texto <- hTextArea 5 30
;hButtonInput "Mándalo!!!" (leerTexto texto)
}
where
leerTexto :: String -> Cgi ()
leerTexto s = ...
|
|
|
| hTextAreaInputExt |
| :: Value | Número de filas.
| | -> Value | Número de columnas.
| | -> String | Contenido inicial
| | -> Html String | Devuelve el texto escrito por el usuario.
|
|
|
| Otros elementos de formularios
|
|
| hButton :: Html a -> Html a |
|
| hFieldSet :: Html a -> Html a |
|
| hLegend :: Html a -> Html a |
|
| hLabel :: Html a -> Html a |
|
| hOptGroup |
| :: (CgiInput a) | | | => String | Nombre para el grupo (será la cabecera).
| | -> [a] | Lista de elementos para crear las opciones de dicho grupo.
| | -> SelectOption a | | | Creación de un grupo de opciones relacionadas bajo un nombre de grupo (el navegador las presenta de forma diferente
al resto). La forma de hacerlo depende del navegador, pero usualmente el nombre de grupo viene representado en negrita y
cursiva, y las opciones dentro del grupo un poco desplazadas a la derecha con respecto a las demás opciones no agrupadas.
|
|
|
| hOption |
|
|
| Elementos especiales "en linea"
|
|
| hA :: Html a -> Html a |
|
| hApplet :: Html a -> Html a |
|
| hBaseFont :: Html () |
|
| hBdo :: Html a -> Html a |
|
| hBr :: Html () |
|
| hFont :: Html a -> Html a |
|
| hIFrame :: Html a -> Html a |
|
| hImg :: Html () |
|
| hMap :: Html a -> Html a |
|
| hArea :: Html () |
|
| hObject :: Html a -> Html a |
|
| hParam :: Html () |
|
| hQ :: Html a -> Html a |
|
| hSpan :: Html a -> Html a |
|
| hSub :: Html a -> Html a |
|
| hSup :: Html a -> Html a |
|
| Elementos de frase
|
|
| hAbbr :: Html a -> Html a |
|
| hAcronym :: Html a -> Html a |
|
| hCite :: Html a -> Html a |
|
| hCode :: Html a -> Html a |
|
| hDel :: Html a -> Html a |
|
| hDfn :: Html a -> Html a |
|
| hEm :: Html a -> Html a |
|
| hIns :: Html a -> Html a |
|
| hKbd :: Html a -> Html a |
|
| hSamp :: Html a -> Html a |
|
| hStrong :: Html a -> Html a |
|
| hVar :: Html a -> Html a |
|
| Elementos de estilo de fuente
|
|
| hB :: Html a -> Html a |
|
| hBig :: Html a -> Html a |
|
| hI :: Html a -> Html a |
|
| hS :: Html a -> Html a |
|
| hSmall :: Html a -> Html a |
|
| hStrike :: Html a -> Html a |
|
| hTt :: Html a -> Html a |
|
| hU :: Html a -> Html a |
|
| Frames
|
|
| hFrame :: Html () |
|
| hNoFrames :: Html a -> Html a |
|
| Creación de atributos HTML 4.0 y CSS2.
|
|
| Este módulo define la totalidad de los atributos, propiedades y valores de HTML 4.0 y CSS2.
Para más información visitar http://www.htmlhelp.com
y
http://www.w3.org/TR/REC-CSS2/cover.html.
Si alguno de los enlaces no funcionara, entonces buscar la información a partir de http://www.w3.org
|
|
Los atributos, propiedades y valores han sido definidos conforme a las siguientes reglas:
- Todos los atributos simples comienzan por 'a' (por ejemplo, aMultiple).
- Todas las propiedades empiezan por 'p' (por ejemplo, pWidth).
- Todos los valores definidos para las propiedades empiezan por 'v' (por ejemplo, vButton).
- Los nombres compuestos conservan la primera letra de cada palabra en mayúsculas (por ejemplo, pBorderRight).
|
|
| Tipos básicos
|
|
| data Attr |
Este tipo representa a un atributo HTML 4.0 o un atributo de estilo (CSS 2). La única diferencia entre ambos
es la forma de visualizarlos. Hay varios tipos de atributos y disponemos de funciones específicas para crear
cada uno de ellos.
- Atributos simples
- Atributos compuestos (de la forma "Propiedad = Valor")
- Secuencia de atributos
| | Instances | |
|
|
| data Property |
| Este tipo permite representar una propiedad para un atributo de una etiqueta (tanto propiedades HTML 4.0 como CSS2).
Para crear propiedades podemos utilizar la función property.
| | Instances | |
|
|
| property :: String -> Property |
Esta función permite crear un dato de tipo Property a partir de una cadena de caracteres.
Ejemplo:
pBackground :: Property
pBackground = property "background"
|
|
| data Value |
| Este tipo nos permite representar los valores que se asignarán a las propiedades. Para ello, podemos utilizar la
función value para crear un valor a partir de una cadena de caracteres, o utilizar numeros gracias a las instancias
definidas.
Algunos propiedades CSS2 pueden tener valores múltiples, por lo que disponemos de un operador especial que se encarga
de esta tarea |+|.
| | Instances | |
|
|
| value :: String -> Value |
Esta funcion permite crear valores para una propiedad.
Ejemplo:
vBorder :: Value
vBorder = value "border"
|
|
| Clases y funciones relacionadas
|
|
| class IsAttr a where |
| Esta clase define varias funciones para obtener un dato de tipo Attr a partir de otro instanciado. De esta forma,
los tipos instanciados en esta clase pueden ser utilizados en las funciones de adición de atributos
(withAttr, withCss).
| | | Methods | | toAttr :: a -> Attr | | Obtiene un dato de tipo Attr a partir del tipo instanciado.
| | | listToAttr :: [a] -> Attr | | Obtiene un dato de tipo Attr a partir de una lista de valores del tipo instanciado.
| | | (<+>) :: a -> a -> a | Este operador permite secuenciar varios atributos, a partir del tipo instanciado.
Ejemplo:
atributos :: Attr
atributos = pColor =: vBlue <+> pSize =: px 10
|
| | | Instances | |
|
|
| class Plus a where |
Esta clase nos permite secuenciar datos del mismo tipo, a partir del operador |+|.
El tipo Value pertenece a esta clase.
Ejemplo:
atributo Attr
atributo = pBorder =: px 5 |+| vSolid |+| vYellow
| | | Methods | | | | Instances | |
|
|
| Algunas funciones útiles
|
|
| none :: Attr |
| Esta función se puede utilizar cuando no queremos añadir ningún atributo y necesitamos algún argumento de tipo Attr.
|
|
| simpleAttr :: String -> Attr |
Esta función crea un atributo simple. Son aquellos atributos que se representan sólo con una palabra clave.
Ejemplo:
aMultiple :: Attr
aMultiple = simpleAttr "MULTIPLE"
|
|
| complexAttr :: Property -> Value -> Attr |
Esta función crea un atributo compuesto, que son los más usuales. Sigue una sintaxis de "Propiedad = Valor", por lo
que necesitamos proporcionarle un argumento de tipo Property y un argumento de tipo Value.
Ejemplo:
atributo :: Attr
atributo = complexAttr pBgColor vBlue
Alternativamente podemos utilizar el siguiente operador para crear atributos a partir de una propiedad y un valor.
|
|
| (=:) :: Property -> Value -> Attr |
Este operador se comporta igual que la función complexAttr. Construye un atributo a partir de una propiedad
y un valor (pero su uso es más cómodo e intuitivo, puesto que se trata de un operador infijo).
Ejemplo:
atributo :: Attr
atributo = pBgColor =: vBlue
|
|
| attrToDoc :: Attr -> Doc |
|
| cssToDoc :: Attr -> Doc |
|
| Algunos atributos útiles para <DOCTYPE>
|
|
| strictDocAttribute :: Attr |
| Este atributo es específico para páginas HTML "strict".
|
|
| transDocAttribute :: Attr |
| Este atributo es específico para páginas HTML "transitional".
|
|
| frameSetDocAttribute :: Attr |
| Este atributo es específico para páginas HTML con marcos ("frames").
|
|
| Atributos simples
|
|
| aChecked :: Attr |
|
| aCompact :: Attr |
|
| aDeclare :: Attr |
|
| aDefer :: Attr |
|
| aDisabled :: Attr |
|
| aIsMap :: Attr |
|
| aMultiple :: Attr |
|
| aNoHRef :: Attr |
|
| aNoResize :: Attr |
|
| aNoShade :: Attr |
|
| aNoWrap :: Attr |
|
| aReadOnly :: Attr |
|
| aSelected :: Attr |
|
| Propiedades
|
|
| Core Attributes
|
|
| pClass :: Property |
|
| pId :: Property |
|
| pStyle :: Property |
|
| pTitle :: Property |
|
| Internationalization Attributes
|
|
| pDir :: Property |
|
| pLang :: Property |
|
| Common Scripting Events
|
|
| pOnClick :: Property |
|
| pOnDblClick :: Property |
|
| pOnKeyDown :: Property |
|
| pOnKeyPress :: Property |
|
| pOnKeyUp :: Property |
|
| pOnMouseDown :: Property |
|
| pOnMouseMove :: Property |
|
| pOnMouseOut :: Property |
|
| pOnMouseOver :: Property |
|
| pOnMouseUp :: Property |
|
| Propiedades normales (No son propiedades tan comunes como las anteriores, dependen de las etiquetas)
|
|
| pAbbr :: Property |
|
| pAccesKey :: Property |
|
| pAccept :: Property |
|
| pAcceptCharset :: Property |
|
| pAction :: Property |
|
| pAlign :: Property |
|
| pALink :: Property |
|
| pAlt :: Property |
|
| pArchive :: Property |
|
| pAxis :: Property |
|
| pBackground :: Property |
|
| pBgColor :: Property |
|
| pBorder :: Property |
|
| pCellSpacing :: Property |
|
| pCellPadding :: Property |
|
| pChar :: Property |
|
| pCharoff :: Property |
|
| pCharset :: Property |
|
| pCite :: Property |
|
| pClassId :: Property |
|
| pClear :: Property |
|
| pCode :: Property |
|
| pCodeBase :: Property |
|
| pCodeType :: Property |
|
| pColor :: Property |
|
| pCols :: Property |
|
| pColSpan :: Property |
|
| pContent :: Property |
|
| pCoords :: Property |
|
| pData :: Property |
|
| pDateTime :: Property |
|
| pEncType :: Property |
|
| pFace :: Property |
|
| pFor :: Property |
|
| pFrame :: Property |
|
| pFrameBorder :: Property |
|
| pHeaders :: Property |
|
| pHeight :: Property |
|
| pHRef :: Property |
|
| pHRefLang :: Property |
|
| pHSpace :: Property |
|
| pHttpEquiv :: Property |
|
| pLabel :: Property |
|
| pLanguage :: Property |
|
| pLink :: Property |
|
| pLongDesc :: Property |
|
| pMarginHeight :: Property |
|
| pMarginWidth :: Property |
|
| pMaxLength :: Property |
|
| pMedia :: Property |
|
| pMethod :: Property |
|
| pName :: Property |
|
| pObject :: Property |
|
| pOnBlur :: Property |
|
| pOnChange :: Property |
|
| pOnFocus :: Property |
|
| pOnLoad :: Property |
|
| pOnReset :: Property |
|
| pOnSelect :: Property |
|
| pOnSubmit :: Property |
|
| pOnUnLoad :: Property |
|
| pProfile :: Property |
|
| pPrompt :: Property |
|
| pRel :: Property |
|
| pRev :: Property |
|
| pRows :: Property |
|
| pRowSpan :: Property |
|
| pRules :: Property |
|
| pScheme :: Property |
|
| pScope :: Property |
|
| pScrolling :: Property |
|
| pShape :: Property |
|
| pSize :: Property |
|
| pSpan :: Property |
|
| pSrc :: Property |
|
| pStandBy :: Property |
|
| pStart :: Property |
|
| pSummary :: Property |
|
| pTabIndex :: Property |
|
| pTarget :: Property |
|
| pText :: Property |
|
| pType :: Property |
|
| pUseMap :: Property |
|
| pVAlign :: Property |
|
| pValue :: Property |
|
| pValueType :: Property |
|
| pVersion :: Property |
|
| pVLink :: Property |
|
| pVSpace :: Property |
|
| pWidth :: Property |
|
| Valores para algunas de las propiedades listadas anteriormente
|
|
| vAbove :: Value |
|
| vAll :: Value |
|
| vAuto :: Value |
|
| vBaseline :: Value |
|
| vBelow :: Value |
|
| vBorder :: Value |
|
| vBottom :: Value |
|
| vBox :: Value |
|
| vButton :: Value |
|
| vCenter :: Value |
|
| vChar :: Value |
|
| vCheckBox :: Value |
|
| vCircle :: Value |
|
| vCol :: Value |
|
| vColGroup :: Value |
|
| vCols :: Value |
|
| vData :: Value |
|
| vDefault :: Value |
|
| vDisc :: Value |
|
| vFile :: Value |
|
| vGet :: Value |
|
| vGroups :: Value |
|
| vHidden :: Value |
|
| vHSides :: Value |
|
| vImage :: Value |
|
| vJustify :: Value |
|
| vLeft :: Value |
|
| vLhs :: Value |
|
| vLtr :: Value |
|
| vMiddle :: Value |
|
| vNo :: Value |
|
| vNone :: Value |
|
| vObject :: Value |
|
| vPassword :: Value |
|
| vPoly :: Value |
|
| vPost :: Value |
|
| vRadio :: Value |
|
| vRect :: Value |
|
| vRef :: Value |
|
| vReset :: Value |
|
| vRhs :: Value |
|
| vRight :: Value |
|
| vRow :: Value |
|
| vRowGroup :: Value |
|
| vRows :: Value |
|
| vRtl :: Value |
|
| vSquare :: Value |
|
| vSubmit :: Value |
|
| vText :: Value |
|
| vTop :: Value |
|
| vVoid :: Value |
|
| vVSides :: Value |
|
| vYes :: Value |
|
| Propiedades CSS2
|
|
| Box model
|
|
| pMarginTop :: Property |
|
| pMarginRight :: Property |
|
| pMarginBottom :: Property |
|
| pMarginLeft :: Property |
|
| pMargin :: Property |
|
| pPaddingTop :: Property |
|
| pPaddingRight :: Property |
|
| pPaddingBottom :: Property |
|
| pPaddingLeft :: Property |
|
| pPadding :: Property |
|
| pBorderTopWidth :: Property |
|
| pBorderRightWidth :: Property |
|
| pBorderBottomWidth :: Property |
|
| pBorderLeftWidth :: Property |
|
| pBorderWidth :: Property |
|
| pBorderTopColor :: Property |
|
| pBorderRightColor :: Property |
|
| pBorderBottomColor :: Property |
|
| pBorderLeftColor :: Property |
|
| pBorderColor :: Property |
|
| pBorderTopStyle :: Property |
|
| pBorderRightStyle :: Property |
|
| pBorderBottomStyle :: Property |
|
| pBorderLeftStyle :: Property |
|
| pBorderStyle :: Property |
|
| pBorderTop :: Property |
|
| pBorderRight :: Property |
|
| pBorderBottom :: Property |
|
| pBorderLeft :: Property |
|
| Visual formatting model
|
|
| pDisplay :: Property |
|
| pPosition :: Property |
|
| pTop :: Property |
|
| pRight :: Property |
|
| pBottom :: Property |
|
| pLeft :: Property |
|
| pFloat :: Property |
|
| pZIndex :: Property |
|
| pDirection :: Property |
|
| pUnicodeBidi :: Property |
|
| Visual formatting model details
|
|
| pMinWidth :: Property |
|
| pMaxWidth :: Property |
|
| pMinHeight :: Property |
|
| pMaxHeight :: Property |
|
| pLineHeight :: Property |
|
| pVerticalAlign :: Property |
|
| Visual effects
|
|
| pOverflow :: Property |
|
| pClip :: Property |
|
| pVisibility :: Property |
|
| Generated content, automatic numbering and lists
|
|
| pQuotes :: Property |
|
| pCounterReset :: Property |
|
| pCounterIncrement :: Property |
|
| pMarkerOffset :: Property |
|
| pListStyleType :: Property |
|
| pListStyleImage :: Property |
|
| pListStylePosition :: Property |
|
| pListStyle :: Property |
|
| Paged media
|
|
| pMarks :: Property |
|
| pPageBreakBefore :: Property |
|
| pPageBreakAfter :: Property |
|
| pPageBreakInside :: Property |
|
| pPage :: Property |
|
| pOrphans :: Property |
|
| pWidows :: Property |
|
| Colors and backgrounds
|
|
| pBackgroundColor :: Property |
|
| pBackgroundImage :: Property |
|
| pBackgroundRepeat :: Property |
|
| pBackgroundAttachment :: Property |
|
| pBackgroundPosition :: Property |
|
| Fonts
|
|
| pFontFamily :: Property |
|
| pFontStyle :: Property |
|
| pFontVariant :: Property |
|
| pFontWeight :: Property |
|
| pFontStretch :: Property |
|
| pFontSize :: Property |
|
| pFontSizeAdjust :: Property |
|
| pFont :: Property |
|
| Text
|
|
| pTextIndent :: Property |
|
| pTextAlign :: Property |
|
| pTextDecoration :: Property |
|
| pTextShadow :: Property |
|
| pLetterSpacing :: Property |
|
| pWordSpacing :: Property |
|
| pTextTransform :: Property |
|
| pWhiteSpace :: Property |
|
| Tables
|
|
| pCaptionSide :: Property |
|
| pTableLayout :: Property |
|
| pBorderCollapse :: Property |
|
| pBorderSpacing :: Property |
|
| pEmptyCells :: Property |
|
| pSpeakHeader :: Property |
|
| User interface
|
|
| pCursor :: Property |
|
| pOutline :: Property |
|
| pOutlineWidth :: Property |
|
| pOutlineStyle :: Property |
|
| pOutlineColor :: Property |
|
| Aural style sheets
|
|
| pVolume :: Property |
|
| pSpeak :: Property |
|
| pPauseBefore :: Property |
|
| pPauseAfter :: Property |
|
| pPause :: Property |
|
| pCueBefore :: Property |
|
| pCueAfter :: Property |
|
| pCue :: Property |
|
| pPlayDuring :: Property |
|
| pAzimuth :: Property |
|
| pElevation :: Property |
|
| pSpeechRate :: Property |
|
| pVoiceFamily :: Property |
|
| pPitch :: Property |
|
| pPithRange :: Property |
|
| pStress :: Property |
|
| pRichness :: Property |
|
| pSpeakPunctuation :: Property |
|
| pSpeakNumeral :: Property |
|
| Valores predeterminados para algunas de las propiedades anteriores (CSS2)
|
|
| vAbsolute :: Value |
|
| vActiveBorder :: Value |
|
| vActiveCaption :: Value |
|
| vAlways :: Value |
|
| vAppWorkspace :: Value |
|
| vArmenian :: Value |
|
| vAvoid :: Value |
|
| vBackground :: Value |
|
| vBehind :: Value |
|
| vBidiOverride :: Value |
|
| vBlink :: Value |
|
| vBlock :: Value |
|
| vBold :: Value |
|
| vBolder :: Value |
|
| vBoth :: Value |
|
| vButtonFace :: Value |
|
| vButtonHighlight :: Value |
|
| vButtonShadow :: Value |
|
| vButtonText :: Value |
|
| vCapitalize :: Value |
|
| vCaption :: Value |
|
| vCaptionText :: Value |
|
| vCenterLeft :: Value |
|
| vCenterRight :: Value |
|
| vCjkIdeoGraphic :: Value |
|
| vCloseQuote :: Value |
|
| vCode :: Value |
|
| vCollapse :: Value |
|
| vCompact :: Value |
|
| vCondensed :: Value |
|
| vContinuous :: Value |
|
| vCrop :: Value |
|
| vCross :: Value |
|
| vCrosshair :: Value |
|
| vDashed :: Value |
|
| vDecimal :: Value |
|
| vDecimalLeadingZero :: Value |
|
| vDigits :: Value |
|
| vDotted :: Value |
|
| vDouble :: Value |
|
| vEmbed :: Value |
|
| vEResize :: Value |
|
| vExpanded :: Value |
|
| vExtraCondensed :: Value |
|
| vFarLeft :: Value |
|
| vFarRight :: Value |
|
| vFast :: Value |
|
| vFaster :: Value |
|
| vFixed :: Value |
|
| vGeorgian :: Value |
|
| vGreyText :: Value |
|
| vGroove :: Value |
|
| vHebrew :: Value |
|
| vHelp :: Value |
|
| vHide :: Value |
|
| vHigh :: Value |
|
| vHigher :: Value |
|
| vHighlight :: Value |
|
| vHighlightText :: Value |
|
| vHiragana :: Value |
|
| vHiraganaIroha :: Value |
|
| vIcon :: Value |
|
| vInactiveBorder :: Value |
|
| vInactiveCaption :: Value |
|
| vInactiveCaptionText :: Value |
|
| vInfoBackground :: Value |
|
| vInfoText :: Value |
|
| vInherit :: Value |
|
| vInLine :: Value |
|
| vInLineTable :: Value |
|
| vInset :: Value |
|
| vInSide :: Value |
|
| vItalic :: Value |
|
| vKatakana :: Value |
|
| vKatakanaIroha :: Value |
|
| vLandscape :: Value |
|
| vLarge :: Value |
|
| vLarger :: Value |
|
| vLeftSide :: Value |
|
| vLeftwards :: Value |
|
| vLevel :: Value |
|
| vLight :: Value |
|
| vLighter :: Value |
|
| vLineTrough :: Value |
|
| vListItem :: Value |
|
| vLoud :: Value |
|
| vLow :: Value |
|
| vLower :: Value |
|
| vLowerAlpha :: Value |
|
| vLowerFase :: Value |
|
| vLowerGreek :: Value |
|
| vLowerLatin :: Value |
|
| vLowerRoman :: Value |
|
| vMarker :: Value |
|
| vMedium :: Value |
|
| vMessageBox :: Value |
|
| vMenu :: Value |
|
| vMenuText :: Value |
|
| vMix :: Value |
|
| vMove :: Value |
|
| vNarrower :: Value |
|
| vNResize :: Value |
|
| vNeResize :: Value |
|
| vNwResize :: Value |
|
| vNoCloseQuote :: Value |
|
| vNoOpenQuote :: Value |
|
| vNoRepeat :: Value |
|
| vNormal :: Value |
|
| vNoWrap :: Value |
|
| vOblique :: Value |
|
| vOnce :: Value |
|
| vOpenQuote :: Value |
|
| vOverLine :: Value |
|
| vOutset :: Value |
|
| vOutside :: Value |
|
| vPointer :: Value |
|
| vPortrait :: Value |
|
| vPre :: Value |
|
| vRelative :: Value |
|
| vRepeat :: Value |
|
| vRepeatx :: Value |
|
| vRepeaty :: Value |
|
| vRidge :: Value |
|
| vRightSide :: Value |
|
| vRightwards :: Value |
|
| vRunIn :: Value |
|
| vScroll :: Value |
|
| vScrollBar :: Value |
|
| vSemiCondensed :: Value |
|
| vSemiExpanded :: Value |
|
| vSeparate :: Value |
|
| vShow :: Value |
|
| vSilent :: Value |
|
| vSlow :: Value |
|
| vSlower :: Value |
|
| vSmall :: Value |
|
| vSmaller :: Value |
|
| vSmallCaps :: Value |
|
| vSamllCaption :: Value |
|
| vSoft :: Value |
|
| vSolid :: Value |
|
| vSpellOut :: Value |
|
| vSResize :: Value |
|
| vSeResize :: Value |
|
| vSwResize :: Value |
|
| vStatic :: Value |
|
| vStatusBar :: Value |
|
| vSub :: Value |
|
| vSuper :: Value |
|
| vTable :: Value |
|
| vTableCaption :: Value |
|
| vTableCell :: Value |
|
| vTableColumn :: Value |
|
| vTableColumnGroup :: Value |
|
| vTableFooterGroup :: Value |
|
| vTableHeaderGroup :: Value |
|
| vTableRow :: Value |
|
| vTableRowGroup :: Value |
|
| vTextBottom :: Value |
|
| vTextTop :: Value |
|
| vThick :: Value |
|
| vThin :: Value |
|
| vThreeDDarkShadow :: Value |
|
| vThreeDFace :: Value |
|
| vThreeDHighlight :: Value |
|
| vThreeDLightShadow :: Value |
|
| vThreeDShadow :: Value |
|
| vTransparent :: Value |
|
| vUltraCondensed :: Value |
|
| vUltraExpanded :: Value |
|
| vUnderLine :: Value |
|
| vUpperAlpha :: Value |
|
| vUpperCase :: Value |
|
| vUpperLatin :: Value |
|
| vUpperRoman :: Value |
|
| vVisible :: Value |
|
| vWait :: Value |
|
| vWider :: Value |
|
| vWindow :: Value |
|
| vWindowFrame :: Value |
|
| vWindowText :: Value |
|
| vWResize :: Value |
|
| vXFast :: Value |
|
| vXHigh :: Value |
|
| vXLarge :: Value |
|
| vXLoud :: Value |
|
| vXLow :: Value |
|
| vXSoft :: Value |
|
| vXSlow :: Value |
|
| vXXLarge :: Value |
|
| vXSmall :: Value |
|
| vXXSmall :: Value |
|
| VARIOS
|
|
| Unidades de longitud
|
|
| Relativos
|
|
| em :: (Num a) => a -> Value |
| Especifica el tamaño de forma relativa a la propiedad pFontSize (el tamaño final se obtiene multiplicando
ambos valores).
|
|
| ex :: (Num a) => a -> Value |
| Tamaño relativo a la altura de la letra 'x'.
|
|
| px :: (Num a) => a -> Value |
| Tamaño en pixels, dependiente del dispositivo de visualización.
|
|
| Absolutos
|
|
| inch :: (Num a) => a -> Value |
| Tamaño en pulgadas. (1 pulgada = 2.54 centímetros).
|
|
| cm :: (Num a) => a -> Value |
| Tamaño en centímetros.
|
|
| mm :: (Num a) => a -> Value |
| Tamaño en milímetros.
|
|
| pt :: (Num a) => a -> Value |
| Tamaño en puntos. Los puntos utilizados en CSS2 equivalen a la 72-ava parte de una pulgada.
|
|
| pc :: (Num a) => a -> Value |
| Tamaño en picas. Una pica es igual a 12 puntos.
|
|
| Porcentajes
|
|
| percent :: (Num a) => a -> Value |
| Tamaño en porcentaje.
|
|
| Construcción de colores
|
|
| rgb :: Int -> Int -> Int -> Value |
| Esta función nos permite especificar un color (Red,Green,Blue).
Rango: 0 - 255 (Incluidos).
|
|
| rgbP :: Float -> Float -> Float -> Value |
| rgbP tiene el mismo objetivo que rgb, pero nos permite determinar el color con porcentajes en vez de números
enteros. Rango: 0.0 - 100.0 (Incluidos).
|
|
| Construcción de URI's
|
|
| url :: String -> Value |
| Para añadir una dirección (URI's).
|
|
| Grados
|
|
| deg :: (Num a) => a -> Value |
| Especificación de un ángulo mediante grados centígrados.
|
|
| grad :: (Num a) => a -> Value |
| Especificación de un ángulo mediante gradianes.
|
|
| rad :: (Num a) => a -> Value |
| Especificación de un ángulo mediante radianes.
|
|
| Tiempos
|
|
| ms :: (Num a) => a -> Value |
| Medida del tiempo en milisegundos.
|
|
| s :: (Num a) => a -> Value |
| Medida del tiempo en segundos.
|
|
| Frecuencias
|
|
| hz :: (Num a) => a -> Value |
| Medida de frecuencia en hertzios.
|
|
| kHz :: (Num a) => a -> Value |
| Medida de frecuencia en kilohertzios.
|
|
| Valores para algunos colores (nombres pertenecientes a la paleta VGA de Windows)
|
|
| vAqua :: Value |
|
| vBlack :: Value |
|
| vBlue :: Value |
|
| vFuchsia :: Value |
|
| vGray :: Value |
|
| vGreen :: Value |
|
| vLime :: Value |
|
| vMaroon :: Value |
|
| vNavy :: Value |
|
| vOlive :: Value |
|
| vPurple :: Value |
|
| vRed :: Value |
|
| vSilver :: Value |
|
| vTeal :: Value |
|
| vWhite :: Value |
|
| vYellow :: Value |
|
| Primitivas de bloqueo de ficheros.
|
|
(c) Pepe Gallardo (pepeg@lcc.uma.es), 2003
Primitivas en C.
|
|
| type HANDLE = Ptr () |
| Es como un manejador de ficheros.
|
|
| lockFile :: FilePath -> IO HANDLE |
| Recibe el nombre del archivo (con su path) y lo bloquea, devolviendo el manejador de archivo correspondiente.
|
|
| unlockFile :: HANDLE -> IO () |
| Recibe el manejador del archivo y lo libera.
|
|
Ejemplo:
main = do { h <- lockFile "file1"
; ...
; operaciones sobre "file1"
; ...
; unlockFile h
}
|
|
| Operaciones bajo exclusión mutua
|
|
| Las siguientes funciones utilizan automáticamente las primitivas lockFile y unlockFile para
realizar las operaraciones sobre el fichero.
|
|
| Lectura de un fichero
|
|
| exclusiveReadFile |
| :: FilePath | Nombre del fichero (path incluido)
| | -> IO String | Devuelve el contenido completo
| | Lectura del contenido de un fichero
|
|
|
| Escritura en un fichero (si no existe, se crea automáticamente)
|
|
| exclusiveWriteFile |
| :: FilePath | Nombre del fichero (path incluido)
| | -> String | Datos a escribir en el fichero
| | -> IO () | No devuelve nada
| | Escritura en un fichero
|
|
|
| Añadir contenido al final de un fichero
|
|
| exclusiveAppendFile |
| :: FilePath | Nombre del fichero.
| | -> String | Datos a añadir en el fichero.
| | -> IO () | No devuelve nada
| | Concatenación (se añade al final del fichero)
|
|
|
Ejemplo: Lectura, escritura o adición bajo exclusión mutua.
main = do { cont <- exclusiveReadFile "file1"
; exclusiveWriteFile "file2" cont
; exclusiveAppendFile "file3" cont
}
|
|
| Produced by Haddock version 0.6 |