/*--------------------------------------------------------------------
 * FICHERO:       Pantalla.h
 * OBJETIVO:      Definir el objeto "Pantalla"
 * IDENTIFICADOR: Pan
 * AUTOR:         Pedro Reina
 * FECHA:         J.27.7.1995
 *------------------------------------------------------------------*/

/*--------------------------------------------------------------------
 * Funciones pblicas
 *
 *   Pan_Modo()               Pantalla.h
 *   Pan_Limpia()             Pantalla.h
 *   Pan_Tinta()              Pantalla.h
 *   Pan_Papel()              Pantalla.h
 *   Pan_Color()              Pantalla.h
 *   Pan_Cursor()             Pantalla.h
 *   Pan_BorraLinea()         Pantalla.h
 *   Pan_Caracter()           Pantalla.h
 *   Pan_PonCar()             Pantalla.h
 *   Pan_Texto()              Pantalla.h
 *   Pan_PonTexto()           Pantalla.h
 *   Pan_Entero()             Pantalla.h
 *   Pan_PonEntero()          Pantalla.h
 *   Pan_Real()               Pantalla.h
 *   Pan_PonReal()            Pantalla.h
 *   Pan_Borra()              Pantalla.h
 *   Pan_PonTextoControlado() Pantalla.h
 *   Pan_Resalta()            PanResal.c
 *   Pan_CursorVisible()      PanCurVi.c
 *   Pan_Define()             PanDefin.c
 *   Pan_Cierra()             PanDefin.c
 *   Pan_Mueve()              PanMueve.c
 *   Pan_TextoControlado()    PanTexCo.c
 *------------------------------------------------------------------*/

/*--------------------------------------------------------------------
 * Funciones conocidas
 *
 *   Pan_Ancho()             Pantalla.h
 *   Pan_Alto()              Pantalla.h
 *   Pan_AnchoCar()          Pantalla.h
 *   Pan_AltoCar()           Pantalla.h
 *   Pan_MargenSuperior()    Pantalla.h
 *   Pan_MargenIzquierdo()   Pantalla.h
 *
 * Funciones conocidas PC
 *
 *   Pan_MandaOrden()        Pantalla.h
 *
 * Funciones conocidas QL
 *
 *   Pan_Bloque()            PanBloq.c
 *------------------------------------------------------------------*/

/*--------------------------------------------------------------------
 * Funciones privadas
 *
 *   Pan_EntPos()            PanEnter.c
 *   Pan_EntSig()            PanEnter.c
 *
 * Funciones privadas PC
 *
 *   Pan_Margen()            Pantalla.h
 *   Pan_TexGraf()           PanTexGr.c
 *   Pan_CarGraf()           PanCarGr.c
 *   Pan_RealGraf()          PanRealG.c
 *   Pan_Bloque()            PanBloq.c
 *   Pan_BorraTex()          PanBloq.c
 *
 * Funciones privadas QL
 *
 *   Pan_Canal()             Pantalla.h
 *   Pan_Comienzo()          Pantalla.h
 *------------------------------------------------------------------*/

#ifndef _PANTALLA_
#define _PANTALLA_

/*--------------------------------------------------------------------
 * Ficheros de cabecera
 *------------------------------------------------------------------*/

#include "General.h"

#ifdef OLIMPO_PC
#include <conio.h>     /*  clrscr()  textcolor()  textbackground()
                           gotoxy()  clreol()  cputs()  cprintf()
                           putch()                                  */
#include <dos.h>       /*  outp()  */
#endif

#ifdef OLIMPO_QL
#include <qlib.h>      /*  fgetchid()  sd_clear()  sd_setin()
                           sd_setst()  sd_setpa()  sd_pos()
                           sd_clrln()                               */
  /* putch() printf()? */
#endif

/*--------------------------------------------------------------------
 * Definicin de macros constantes
 *------------------------------------------------------------------*/

/* Posibles modos de pantalla */

#define PAN_TEXTO    (octeto)0
#define PAN_GRAFICO  (octeto)1

/* Posibles movimientos */

#define PAN_ARRIBA   (octeto)0
#define PAN_ABAJO    (octeto)1

/* Definicin de colores */

#ifdef OLIMPO_PC
#define NEGRO   (octeto)0
#define ROJO    (octeto)4
#define VERDE   (octeto)2
#define BLANCO  (octeto)7
#endif

#ifdef OLIMPO_QL
#define NEGRO   (octeto)0
#define ROJO    (octeto)2
#define VERDE   (octeto)4
#define BLANCO  (octeto)7
#endif

/*--------------------------------------------------------------------
 * Definicin de tipos
 *------------------------------------------------------------------*/

   /* Ninguno */

/*--------------------------------------------------------------------
 * Variables globales
 *------------------------------------------------------------------*/

extern octeto Pan_Mod_;        /*  Modo de pantalla     */

/*--------------------------------------------------------------------
 * Variables globales (usadas en modo grfico en el PC)
 *------------------------------------------------------------------*/

#ifdef OLIMPO_PC
extern octeto Pan_Fil_;        /*  Fila del cursor      */
extern octeto Pan_Col_;        /*  Columna del cursor   */
extern octeto Pan_Tin_;        /*  Color de la tinta    */
extern octeto Pan_Pap_;        /*  Color del papel      */
extern logico Pan_Resal_;      /*  Modo resaltado       */
extern char far *Pan_TabCar_;  /*  Tabla de caracteres  */
#endif

/*--------------------------------------------------------------------
 * Declaracin de funciones
 *------------------------------------------------------------------*/

void   Pan_Resalta();
void   Pan_CursorVisible();
void   Pan_Bloque();
void   Pan_Mueve();
logico Pan_EntPos();
logico Pan_EntSig();

#ifdef OLIMPO_PC
void Pan_BorraTex();
void Pan_CarGraf();
void Pan_TexGraf();
void Pan_RealGraf();
#endif

/*--------------------------------------------------------------------
 * Definicin de macros funciones
 *------------------------------------------------------------------*/

/*--------------------------------------------------------------------
 * MACRO:    Pan_Ancho()
 * OBJETIVO: Decir la anchura de la pantalla en caracteres
 * ENTRADAS: Ninguna
 * SALIDAS:  La anchura
 * EJEMPLO:  Pan_Ancho()
 *------------------------------------------------------------------*/
#define Pan_Ancho()  (octeto)80

/*--------------------------------------------------------------------
 * MACRO:    Pan_Alto()
 * OBJETIVO: Decir la altura de la pantalla en caracteres
 * ENTRADAS: Ninguna
 * SALIDAS:  La anchura
 * EJEMPLO:  Pan_Alto()
 *------------------------------------------------------------------*/
#define Pan_Alto()  (octeto)24

/*--------------------------------------------------------------------
 * MACRO:    Pan_AnchoCar()
 * OBJETIVO: Decir la anchura de los caracteres en pixels
 * ENTRADAS: Ninguna
 * SALIDAS:  La anchura de los caracteres
 * EJEMPLO:  Pan_AnchoCar()
 *------------------------------------------------------------------*/

#ifdef OLIMPO_PC
#define Pan_AnchoCar()  (octeto)8    /* Se asume que la pantalla es VGA */
#endif

#ifdef OLIMPO_QL
#define Pan_AnchoCar()  (octeto)6
#endif

/*--------------------------------------------------------------------
 * MACRO:    Pan_AltoCar()
 * OBJETIVO: Decir la altura de los caracteres en pixels
 * ENTRADAS: Ninguna
 * SALIDAS:  La altura de los caracteres
 * EJEMPLO:  Pan_AltoCar()
 *------------------------------------------------------------------*/

#ifdef OLIMPO_PC
#define Pan_AltoCar()  (octeto)16   /* Se asume que la pantalla es VGA */
#endif

#ifdef OLIMPO_QL
#define Pan_AltoCar()  (octeto)10
#endif

#ifdef OLIMPO_PC
/*--------------------------------------------------------------------
 * MACRO:    Pan_Margen()
 * OBJETIVO: Decir el margen superior de la pantalla de Olimpo respecto
 *           al comienzo real de la pantalla cuando el PC est en modo
 *           grfico. El resultado se mide en caracteres
 * ENTRADAS: Ninguna
 * SALIDAS:  El margen superior en caracteres
 * EJEMPLO:  Pan_Margen()
 *------------------------------------------------------------------*/
#define Pan_Margen()  (octeto)3
#endif

/*--------------------------------------------------------------------
 * MACRO:    Pan_MargenSuperior()
 * OBJETIVO: Decir el margen superior de la pantalla de Olimpo respecto
 *           al comienzo real de la pantalla. El resultado se mide en pixels
 * ENTRADAS: Ninguna
 * SALIDAS:  El margen superior en pixels
 * EJEMPLO:  Pan_MargenSuperior()
 *------------------------------------------------------------------*/

#ifdef OLIMPO_PC
#define Pan_MargenSuperior()  (octeto)48  /* Se asume que la pantalla es VGA */
#endif

#ifdef OLIMPO_QL
#define Pan_MargenSuperior()  (octeto)3
#endif

/*--------------------------------------------------------------------
 * MACRO:    Pan_MargenIzquierdo()
 * OBJETIVO: Decir el margen izquierdo de la pantalla de Olimpo respecto
 *           al comienzo real de la pantalla. El resultado se mide en pixels
 * ENTRADAS: Ninguna
 * SALIDAS:  El margen izquierdo en pixels
 * EJEMPLO:  Pan_MargenIzquierdo()
 *------------------------------------------------------------------*/

#ifdef OLIMPO_PC
#define Pan_MargenIzquierdo()  (octeto)0  /* Se asume que la pantalla es VGA */
#endif

#ifdef OLIMPO_QL
#define Pan_MargenIzquierdo()  (octeto)15
#endif

#ifdef OLIMPO_PC
/*--------------------------------------------------------------------
 * MACRO:    Pan_MandaOrden()
 * OBJETIVO: Mandar a la tarjeta VGA una orden
 * ENTRADAS: El registro, el ndice y el valor
 * SALIDAS:  Ninguna
 * EJEMPLO:  Pan_MandaOrden (0x3C4,2,0x0F)
 *------------------------------------------------------------------*/
#define Pan_MandaOrden(Reg,Ind,Val)  (outp(Reg,Ind),outp(Reg+1,Val))
#endif

#ifdef OLIMPO_QL
/*--------------------------------------------------------------------
 * MACRO:    Pan_Canal()
 * OBJETIVO: Decir el canal QDOS asociado a la pantalla
 * ENTRADAS: Ninguna
 * SALIDAS:  El canal
 * EJEMPLO:  Pan_Canal()
 *------------------------------------------------------------------*/
#define Pan_Canal()  fgetchid(stdout)
#endif

#ifdef OLIMPO_QL
/*--------------------------------------------------------------------
 * MACRO:    Pan_Comienzo()
 * OBJETIVO: Decir la direccin de memoria en que comienza la pantalla
 * ENTRADAS: Ninguna
 * SALIDAS:  La direccin
 * EJEMPLO:  Pan_Comienzo()
 *------------------------------------------------------------------*/
#define Pan_Comienzo()  131072
#endif

/*--------------------------------------------------------------Olimpo
 * MACRO:    Pan_Modo()
 * OBJETIVO: Decir el modo en que est definida la pantalla
 * ENTRADAS: Ninguna
 * SALIDAS:  PAN_TEXTO o PAN_GRAFICO
 * EJEMPLO:  Pan_Modo()
 *------------------------------------------------------------------*/
#define Pan_Modo()  Pan_Mod_

/*--------------------------------------------------------------Olimpo
 * MACRO:    Pan_Limpia()
 * OBJETIVO: Borrar la pantalla completa
 * ENTRADAS: Ninguna
 * SALIDAS:  El valor lgico SI
 * EJEMPLO:  Pan_Limpia()
 * NOTA:     Se usa el color del papel en ese momento
 *------------------------------------------------------------------*/

#ifdef OLIMPO_PC
#define Pan_Limpia()  ( Pan_Mod_ ? ( Pan_Bloque(Pan_Pap_,0,0,29,79) , SI ) \
                                 : ( clrscr() , SI ) )
#endif

#ifdef OLIMPO_QL
#define Pan_Limpia()  ( sd_clear(Pan_Canal(),-1L), SI )
#endif

/*--------------------------------------------------------------Olimpo
 * MACRO:    Pan_Tinta()
 * OBJETIVO: Cambiar el color con el que se escribe en
 *           la pantalla
 * ENTRADAS: El nuevo color
 * SALIDAS:  El valor lgico SI
 * EJEMPLO:  Pan_Tinta ( ROJO )
 *------------------------------------------------------------------*/

#ifdef OLIMPO_PC
#define Pan_Tinta(c)  ( Pan_Mod_ ? ( Pan_Tin_=c , SI ) \
                                 : ( textcolor(c) , SI ) )
#endif

#ifdef OLIMPO_QL
#define Pan_Tinta(c)  ( sd_setin(Pan_Canal(),-1L,(int)c), SI )
#endif

/*--------------------------------------------------------------Olimpo
 * MACRO:    Pan_Papel()
 * OBJETIVO: Cambiar el color de la pantalla
 * ENTRADAS: El nuevo color
 * SALIDAS:  El valor lgico SI
 * EJEMPLO:  Pan_Papel ( VERDE )
 *------------------------------------------------------------------*/

#ifdef OLIMPO_PC
#define Pan_Papel(c)  ( Pan_Mod_ ? ( Pan_Pap_=c , SI ) \
                                 : ( textbackground(c) , SI ) )
#endif

#ifdef OLIMPO_QL
#define Pan_Papel(c)  ( sd_setpa(Pan_Canal(),-1L,(int)c),  \
                        sd_setst(Pan_Canal(),-1L,(int)c), SI )
#endif

/*--------------------------------------------------------------Olimpo
 * MACRO:    Pan_Color()
 * OBJETIVO: Cambiar el color del papel y la tinta
 * ENTRADAS: El color del papel y de la tinta
 * SALIDAS:  El valor lgico SI
 * EJEMPLO:  Pan_Color ( VERDE, NEGRO )
 *------------------------------------------------------------------*/
#define Pan_Color(p,t)   ( Pan_Papel(p) , Pan_Tinta(t) )

/*--------------------------------------------------------------Olimpo
 * MACRO:    Pan_Cursor()
 * OBJETIVO: Colocar el cursor en una posicin determinada
 * ENTRADAS: La fila y la columna
 * SALIDAS:  El valor lgico SI
 * EJEMPLO:  Pan_Cursor ( 0,0 )
 *------------------------------------------------------------------*/

#ifdef OLIMPO_PC
#define Pan_Cursor(f,c)  ( Pan_Mod_ ?                                \
                           (Pan_Fil_=(f)+Pan_Margen(),Pan_Col_=c,SI) \
                           : ( gotoxy((c)+1,(f)+1) , SI ) )
#endif

#ifdef OLIMPO_QL
#define Pan_Cursor(f,c)  ( sd_pos(Pan_Canal(),-1L,(int)c,(int)f) , SI )
#endif

/*--------------------------------------------------------------Olimpo
 * MACRO:    Pan_BorraLinea()
 * OBJETIVO: Limpiar una lnea determinada
 * ENTRADAS: La lnea
 * SALIDAS:  El valor lgico SI
 * EJEMPLO:  Pan_BorraLinea ( 0 )
 *------------------------------------------------------------------*/

#ifdef OLIMPO_PC
#define Pan_BorraLinea(f)  ( Pan_Mod_ ? \
           (Pan_Bloque(Pan_Pap_,(f)+Pan_Margen(),0,(f)+Pan_Margen(),79),SI) \
         : ( gotoxy(1,(f)+1) , clreol() , SI ) )
#endif

#ifdef OLIMPO_QL
#define Pan_BorraLinea(f)  ( Pan_Cursor(f,0),sd_clrln(Pan_Canal(),-1L),SI )
#endif

/*--------------------------------------------------------------Olimpo
 * MACRO:    Pan_Caracter()
 * OBJETIVO: Escribir un carcter en la pantalla
 * ENTRADAS: El carcter
 * SALIDAS:  El valor lgico SI
 * EJEMPLO:  Pan_Caracter ('A')
 *------------------------------------------------------------------*/

#ifdef OLIMPO_PC
#define Pan_Caracter(c)  ( Pan_Mod_ ? ( Pan_CarGraf(c) , SI ) \
                                    : ( putch(c) , SI ) )
#endif

#ifdef OLIMPO_QL
#define Pan_Caracter(c)  ( putch(c) , SI )
#endif

/*--------------------------------------------------------------Olimpo
 * MACRO:    Pan_PonCar()
 * OBJETIVO: Escribir un carcter en cierta posicin
 * ENTRADAS: La fila, la columna y el carcter
 * SALIDAS:  El valor lgico SI
 * EJEMPLO:  Pan_PonCar (3,5,'A')
 *------------------------------------------------------------------*/

#define Pan_PonCar(fil,col,car)  (Pan_Cursor(fil,col),Pan_Caracter(car))

/*--------------------------------------------------------------Olimpo
 * MACRO:    Pan_Texto()
 * OBJETIVO: Escribir un texto en la pantalla
 * ENTRADAS: Una cadena
 * SALIDAS:  El valor lgico SI
 * EJEMPLO:  Pan_Texto ("Hola, usuario")
 *------------------------------------------------------------------*/

#ifdef OLIMPO_PC
#define Pan_Texto(t)  ( Pan_Mod_ ? ( Pan_TexGraf(t) , SI ) \
                                 : ( cputs(t) , SI ) )
#endif

#ifdef OLIMPO_QL
#define Pan_Texto(t)  ( printf(t) , SI )
#endif

/*--------------------------------------------------------------Olimpo
 * MACRO:    Pan_PonTexto()
 * OBJETIVO: Escribir un texto en cierta posicin
 * ENTRADAS: La fila, la columna y el texto
 * SALIDAS:  El valor lgico SI
 * EJEMPLO:  Pan_PonTexto (3,5,"Hola")
 *------------------------------------------------------------------*/
#define Pan_PonTexto(fil,col,t)  (Pan_Cursor(fil,col),Pan_Texto(t))

/*--------------------------------------------------------------Olimpo
 * MACRO:    Pan_Entero()
 * OBJETIVO: Escribir un nmero entero en la pantalla en
 *           un ancho determinado
 * ENTRADAS: El nmero y el ancho
 * SALIDAS:  El valor lgico SI
 * EJEMPLO:  Pan_Entero ( 12345,6 )
 * NOTA:     El nmero se evala dos veces
 *------------------------------------------------------------------*/
#define Pan_Entero(e,a)  ( (e) > 0 ? Pan_EntPos((entpos)e,a) \
                                   : Pan_EntSig((entero)e,a) )

/*--------------------------------------------------------------Olimpo
 * MACRO:    Pan_PonEntero()
 * OBJETIVO: Escribir un nmero entero en cierta posicin
 * ENTRADAS: La fila, la columna, el entero y el 
 *           ancho disponible
 * SALIDAS:  El valor lgico SI
 * EJEMPLO:  Pan_PonEntero (3,5,12345,6)
 * NOTA:     El nmero se evala dos veces
 *------------------------------------------------------------------*/
#define Pan_PonEntero(fil,col,e,a)  (Pan_Cursor(fil,col),Pan_Entero(e,a))

/*--------------------------------------------------------------Olimpo
 * MACRO:    Pan_Real()
 * OBJETIVO: Escribir un nmero real en la pantalla
 * ENTRADAS: Un nmero real, el ancho asignado y el nmero
 *           de decimales
 * SALIDAS:  El valor lgico SI
 * EJEMPLO:  Pan_Real (1.23455, 5, 2)
 *------------------------------------------------------------------*/

#ifdef OLIMPO_PC
#define Pan_Real(r,a,d)  ( Pan_Mod_ ? ( Pan_RealGraf((real)r,a,d) , SI ) \
                                    : ( cprintf("%*.*f",a,d,(real)r) , SI ) )
#endif

#ifdef OLIMPO_QL
#define Pan_Real(r,a,d)   ( printf("%*.*f",a,d,(real)r) , SI )
#endif

/*--------------------------------------------------------------Olimpo
 * MACRO:    Pan_PonReal()
 * OBJETIVO: Escribir un nmero real en la pantalla en una
 *           posicin determinada
 * ENTRADAS: La fila, la columna, un nmero real, el ancho 
 *           asignado y el nmero de decimales
 * SALIDAS:  El valor lgico SI
 * EJEMPLO:  Pan_PonReal (0, 0, 1.23455, 5, 2)
 *------------------------------------------------------------------*/
#define Pan_PonReal(f,c,r,a,d)  ( Pan_Cursor(f,c), Pan_Real(r,a,d) )

/*--------------------------------------------------------------Olimpo
 * MACRO:    Pan_PonTextoControlado()
 * OBJETIVO: Escribir una cadena en la pantalla en una
 *           posicin determinada de modo que no exceda un 
 *           determinado nmero de caracteres
 * ENTRADAS: La fila, la columna, la cadena y el nmero 
 *           de caracteres
 * SALIDAS:  Ninguna
 * EJEMPLO:  Pan_PonTextoControlado ( 3, 6, "Hola, mundo", 4 )
 *------------------------------------------------------------------*/
#define Pan_PonTextoControlado(f,c,t,n)  (Pan_Cursor(f,c), \
                                          Pan_TextoControlado(t,n))
                                         
/*--------------------------------------------------------------Olimpo
 * FUNCION:  Pan_Borra()
 * OBJETIVO: Borrar una zona de la pantalla
 * ENTRADAS: El color y las coordenadas
 * SALIDAS:  El valor lgico SI
 * EJEMPLO:  Pan_Borra ( ROJO,3,3,15,15 )
 *------------------------------------------------------------------*/
#ifdef OLIMPO_PC
#define Pan_Borra(c,f1,c1,f2,c2)  ( Pan_Mod_ ? \
                 (Pan_Bloque(c,(f1)+Pan_Margen(),c1,(f2)+Pan_Margen(),c2),SI) \
               : (Pan_BorraTex(c,f1,c1,f2,c2),SI) )
#endif

#ifdef OLIMPO_QL
#define Pan_Borra(c,f1,c1,f2,c2) ( Pan_Bloque(c,Pan_AnchoCar()*((c2)-(c1)+1),\
                                   Pan_AltoCar()*((f2)-(f1)+1),\
                                   Pan_AnchoCar()*(c1), Pan_AltoCar()*(f1)),SI)
#endif

#endif /* _PANTALLA_ */