/*
    GeMiniTel - ‚mulateur vid‚o DRCS "temps r‚‚l" pour ATARI ST
    (c)1995 ROCHE.X.
    Librairie GMTel
    Attention! Ce source ne doit pas ˆtre utilis‚ … des fins
    commerciales
    Toute exploitation de ce source, … des fins quelconques, est
    interdite sans l'autorisation de l'auteur
/*/

/* A effectuer:

   d‚clarer les #defines n‚cessaires
   #include "GMTLIB.C"
   (aprŠs ‚ventuellement utiliser les I_xxx)

*/

#define GMT_VERSION "0.01"

/* Variables qui doivent ˆtre fix‚es AVANT le #include "gmtlib.c" : */

/* - Adresse bitmap de gmt: */
/*	#define gmt_bit_adr

/* - Adresse bitmap de comparaison (s'il y a lieu) de gmt: */
/*	#define gmt_bit_cmp

/* - Longueur d'une ligne de gmt_bit_adr et gmt_bit_cmp en octets: */
/*	#define gmt_line_len

/* - Position de d‚part gmtel xy (0..39 et 1..24)
     et dimensions de la fenˆtre: */
/*	#define gmt_startmx
	#define gmt_startmy
	#define gmt_sizemw
	#define gmt_sizemh

/* - Couleur texte et fond (0..7): */
/*	#define gmt_colt colt
/*	#define gmt_colf colf

/* - Option #1 de chargement de fonte
     0 = Fonte avant (le texte)
     1 = Fonte aprŠs
     2 = Fonte avant chaque ligne (entrelac‚)
     3 = Fonte aprŠs chaque ligne */
/*	#define gmt_opt 
*/

/* - Option #2 de placement du fond
     0 = Pas de fond
     1 = Placer un fond … chaque dessin */
/*	#define gmt_opt2
*/


/* - Mode animation:
     0 : g‚n‚rer que des images fixes, pas de gmt_bit_cmp
     1 : g‚n‚rer en tenant compte de l'image pr‚c‚dente gmt_bit_cmp
         des routines d'optimisation sont mises en oeuvre ‚galement */
/*	#define gmt_anim
*/

/* - Compactage:
     0 : pas de compactage simultan‚
     1 : compactage simultan‚
/*	#define gmt_optcom
*/

/* - Option #3 d'optimisation header DRCS
     0 = pas d'optimisation
     1 = optimisation */
/*	 #define gmt_opt3     
*/

/* - Option #4 de contr“le des caractŠres DRCS /
     0 = pas de contr“le
     1 = contr“le: si keep[x]=1 alors ne pas utiliser x
/*     	 #define gmt_opt4
*/



/* Variables qui peuvent ˆtre utiles, mais pas indispensables: (d‚ja d‚clar‚es!) */

/* # Nombre de caractŠres trait‚s:
	I_nchar

   # Status buffer DRCS plein:
     0 : pas encore plein
	I_full

   # Nombre de nouveaux caractŠres DRCS cr‚‚s:
	I_ndrcs
*/


/* 			FIN 			*/


/* --------------------------------------------------------------------- */
/* --------------------------------------------------------------------- */
/* GeMiniTEL (c)1995 R.X. 						 */

#define GOPT 0		/* optimisation semi-graphique NON INSTALLEE */
#define DEBUG 0		/* debuggage? */
#define DEBUGC 0	/* debuggage de contr“le? */
#define AFFDEB 0	/* debuggage graphique? */

#define DIV2 >>1
#define DIV4 >>2
#define DIV8 >>3
#define MUL2 <<1
#define MUL8 <<3

#define vmax_x 39
#define vmax_y 24

/* ARRAY-STR, moins tordu que les chaines en C et + maniable */
#include "arrstr.h"
#include "gu_type.h"

/* --------------------------------------------------------------------- */
/* vars globales */
ARRSTR vpage;


/* --------------------------------------------------------------------- */
/* Variables d'info et options */

int I_nchar;		/* nombre de car. trait‚s */
			/* nombre de car. DRCS cr‚‚s */

#define I_full newfull	/* 0 si buffer drcs <>plein */

#define I_ndrcs maxnew	/* nbr nouveaux car */


/* --------------------------------------------------------------------- */

/* jeu DRCS: 94*2 car de 8 bits (colonnes) *10 (lignes) */
uchar drcs[94*2][10];

/* nouveaux caractŠres: identificateur (index de drcs), flag "plein" */
int maxnew;
char newfull;
int roll;	/* rolling pointer */
uchar newdrcs[94*2];

/* caractŠre non d‚clar‚ (non ‚crit) */
boolean undrcs[94*2];

/* --------------------------------------------------------------------- */
/* Diff‚rents flags pour l'algo de codage */

/* garder caractŠre (ne pas effacer) */
char keep[94*2];

/* flag nouveau caractŠre */
boolean newload[94*2];

/*  flag 0=espace caractŠre non modifi‚ TRUE=modifi‚ */
char change[25][40];

/* treated flag 0=espace caractŠre non trait‚ TRUE=trait‚ */
char treated[25][40];

/* DRCS char = caractŠre DRCS de l'espace caractŠre */
uchar xchange[25][40];

/* optimisation state 
 0    pas d'opti - xchange[][] format DRCS: 0..93 texte 94..188 graph
 1    caractŠre texte non DRCS - xchange[][] format ASCII
 2    caractŠre graph non DRCS - xchange[][] format mosa‹que
 32   caractŠre 32 (espace) quelconque (DRCS ou TEXTE) \ xchange[][] sans
 -32  ' ' mais pour cause de manque de caractŠres DRCS
 127  caractŠre 127 (blanc) quelconque (DRCS ou TEXTE) / -signification
*/
char opti[25][40];

/* car utilis‚s (gmt_code) 
   0=non
   -1=oui
   1=oui mais JUSTE avant (donc d‚ja charg‚) 
*/
char chuse[94*2];

/* utilis‚ par gmt_code: */
boolean coded=FALSE;	/* on a cod‚ qqchose */

/* status header de chargement DRCS charg‚ ( != mode : non charg‚ ) */
#if ( gmt_opt3 == 0 )
char head_fnt=99;
#else
char head_fnt=2;
#endif

/* --------------------------------------------------------------------- */

#define CESC "\x1B"
#define CR 13
#define ESC 27
#define CLS 12
#define SPACE 32
#define BL 24
#define REP 18
#define DROITE 9
#define BAS 10
#define GAUCHE 8
#define HAUT 11
#define HOME 30
#define POS 31
#define DRCST_ON    CESC"( B"
#define DRCSG_ON    CESC") C"
#define DRCST_OFF   CESC"(@"
#define DRCSG_OFF   CESC")c"
#define GRAPH_ON    0xE
#define GRAPH_OFF   0xF
#define START_TEXT  "\x1F\x23\x20\x20\x20\x42\x49"
#define START_GRAPH "\x1F\x23\x20\x20\x20\x43\x49"
#define END_TEL     "\x1F\x5A\x5A"
#define RST_GMT     "\xE"DRCST_OFF""DRCSG_OFF""CESC"D""\x1F@AGeMiniTel v"GMT_VERSION" (c)1995 R.X. \x12""Z \xC"

#define VDT_NOIR      0
#define VDT_BLEU      1
#define VDT_ROUGE     2
#define VDT_MAGENTA   3
#define VDT_VERT      4
#define VDT_CYAN      5
#define VDT_JAUNE     6
#define VDT_BLANC     7

const char idxtext[]="@DAEBFCG";	/* col texte 0..7 */
const char idxfond[]="PTQURVSW";	/* col fond 0..7 */


void gmt_clear(void);
int gmt_cut(int xp,int yp,int wp,int hp);
int pos(ARRSTR *blk,int x,int y);
int gmt_coltext(ARRSTR *blk , char col);
int gmt_colfond(ARRSTR *blk , char col);
void addcurs( int *x , int *y );
int gmt_code(ARRSTR *blk,char flag,int x,int y,int w,int h);
void _gmtmcl( void );
int _gmt_fnt(ARRSTR *blk);
void _gmt_map(int xp,int yp,int wp,int hp);
void _gmt_mclr( void );

/* Efface toute les vars, r‚initialise les tableaux */
void gmt_clear(void) {	/* effacer tout */
  int a,b;
    
  roll=0;
  maxnew=0;
  for(a=0 ; a<94*2 ; a++) {
    for(b=0 ; b<10 ; b++) {
      drcs[a][b]=0;
    }
    keep[a]=newdrcs[a]=undrcs[a]=0;
  }
  for(a=0 ; a<25 ; a++) {
    for(b=0 ; b<40 ; b++) {
      treated[a][b]=0;
      xchange[a][b]=change[a][b]=-1;
      opti[a][b]=SPACE;	/* caractŠre espace initialis‚ */
    }
  }
}


/*
   gmt_cut
   Encodage dans xchange[][] (car DRCS) opt[][] drcs[]
   Une fois cela, les morceaux pourront ˆtre cod‚s en
   vid‚otex.
*/
int gmt_cut(int xp,int yp,int wp,int hp) {
  {
    int x,y;
    int XY;
    #if (gmt_anim)
    uchar *A;
    #endif
    uchar *B;

    /* Note: ???[y][x] est remplac‚ par *(???+XY) */

    for( y=yp ; y<yp+hp ; y++ ) {
      /* incr‚ment tableau */
      XY=y*40+xp-1;
      for( x=xp ; x<xp+wp ; x++ ) {
        XY++;	/* incr‚ment tableau +1 */

        if (ch_(change,XY)) {
          int z=0;
          {
            #if (gmt_anim)
            long plus;
            B=(uchar*) (gmt_bit_adr + (plus=y*10*gmt_line_len+x) );
            A=(uchar*) (gmt_bit_cmp)+plus;
            #else
            B=(uchar*) (gmt_bit_adr + y*10*gmt_line_len+x );
            #endif            
          }

          switch( ch_(opti,XY) ){	/* DRCS */
            case 0: {
              if ( uch_(xchange,XY) != 255)	/* d‚clar‚ */
              if (newload[ uch_(xchange,XY) ])	/* a ‚t‚ effac‚! (prio) */
                z=1;		/* reconstruire car non prio */
              break;
            }
            case -32: {	/* error, pas assez de car */
              z=1;          
              break;
            }
          }
                    
          #if gmt_anim
          if (z==0) {
            while( (z<10) AND (*(A+(z*gmt_line_len))==(*(B+(z*gmt_line_len)))) )
              z++;
          }	/* a chang‚? */
          #else
            z=0;	/* forcer reconnaissance */
          #endif
          
          /* note: il se peut que le bord n'ait pas ‚t‚ trait‚! */
          if (z!=10) {	/* a chang‚! */
            int r=0;
            /* ch_(change,XY)=-1;	 O+ pas la peine */
            #if DEBUGC
             if (ch_(change,XY) != -1)
               printf("ch_change <> TRUE ! non initialis‚ correctement??? ");
            #endif
            I_nchar++;		/* un de plus! */

            switch ( *B ) {
              case 0: {
                int RIND=0;
                if ( *(B+(RIND+=gmt_line_len)) == 0 )
                if ( *(B+(RIND+=gmt_line_len)) == 0 )
                if ( *(B+(RIND+=gmt_line_len)) == 0 )
                if ( *(B+(RIND+=gmt_line_len)) == 0 )
                if ( *(B+(RIND+=gmt_line_len)) == 0 )
                if ( *(B+(RIND+=gmt_line_len)) == 0 )
                if ( *(B+(RIND+=gmt_line_len)) == 0 )
                if ( *(B+(RIND+=gmt_line_len)) == 0 )
                if ( *(B+(RIND+=gmt_line_len)) == 0 )
                {
                  ch_(opti,XY)=SPACE;	/* caractŠre spc (DRCS ou TEXTE) */
                  /* pas de uch_(xchange,XY) */
                  ch_(xchange,XY)=-1;
                  ch_(treated,XY)=-1;	/* trait‚ */
                  /* pas de keep[r] */
 
                  r=1;	/* optimis‚! */
                }
                break;
              }

              case 255: {
                int RIND=0;
                if ( *(B+(RIND+=gmt_line_len)) == 255 )
                if ( *(B+(RIND+=gmt_line_len)) == 255 )
                if ( *(B+(RIND+=gmt_line_len)) == 255 )
                if ( *(B+(RIND+=gmt_line_len)) == 255 )
                if ( *(B+(RIND+=gmt_line_len)) == 255 )
                if ( *(B+(RIND+=gmt_line_len)) == 255 )
                if ( *(B+(RIND+=gmt_line_len)) == 255 )
                if ( *(B+(RIND+=gmt_line_len)) == 255 )
                if ( *(B+(RIND+=gmt_line_len)) == 255 )
                {
                  ch_(opti,XY)=127;	/* caractŠre VDT_BLANC (DRCS ou TEXTE) */
                  /* pas de uch_(xchange,XY) */
                  ch_(xchange,XY)=-1;
                  ch_(treated,XY)=-1;	/* trait‚ */
                  /* pas de keep[r] */
 
                  r=1;	/* optimis‚! */
                }
                break;
              }
            } /* case */

            #if (GOPT)
              int RIND=(-gmt_line_len);	/* init … -gmt_line_len */
              int a=0;
              
              for( ; a<10 ; a++ ) {
                char tempo;
                tempo = ( *(B+(RIND+=gmt_line_len)) );
                if ( ((tempo >> 4) != 0) AND ((tempo >> 4) != 0xF) )
                  break;
                if ( ((tempo & 0xF) != 0) AND ((tempo & 0xF) != 0xF) )
                  break;
              } /* next a */
            
            #endif /* opti semi-graphique */
            

            if (r==0) {		/* non optimis‚ */
              /* On cherche ce caractŠre dans le jeu */
              {
                int GRIND=0;
                for( r=0 ; r<94*2 ; r++ ) {
                  /* d‚clar‚ */
                  /* if (undrcs[r]) { */
                  {
                    int RIND=GRIND;
                    int RIND2=0;
                    GRIND+=10;	/* opti, cf XY */
                    /* caractŠre reconnu? */
                    if ( *B                    == uch_(drcs,RIND++) )
                    if ( *(B+(RIND2+=gmt_line_len)) == uch_(drcs,RIND++) )
                    if ( *(B+(RIND2+=gmt_line_len)) == uch_(drcs,RIND++) )
                    if ( *(B+(RIND2+=gmt_line_len)) == uch_(drcs,RIND++) )
                    if ( *(B+(RIND2+=gmt_line_len)) == uch_(drcs,RIND++) )
                    if ( *(B+(RIND2+=gmt_line_len)) == uch_(drcs,RIND++) )
                    if ( *(B+(RIND2+=gmt_line_len)) == uch_(drcs,RIND++) )
                    if ( *(B+(RIND2+=gmt_line_len)) == uch_(drcs,RIND++) )
                    if ( *(B+(RIND2+=gmt_line_len)) == uch_(drcs,RIND++) )
                    if ( *(B+(RIND2+=gmt_line_len)) == uch_(drcs,RIND++) )
                      break; /* sortie de boucle */
                  } /* if newdecl */
                } /* for r */
              } /* bloc */
       
              if (r>=94*2) /* NOT found */
                ch_(treated,XY)=FALSE;	/* non trait‚, faire + tard */
              else {
                ch_(opti,XY)=0;	/* caractŠre DRCS */
                if ( uch_(xchange,XY) != r )	/* index n'a pas chang‚ */
                  uch_(xchange,XY)=r;	/* index */
                else
                  ch_(change,XY)=FALSE;	/* donc n'a pas chang‚! */
                ch_(treated,XY)=-1;	/* trait‚ */
                keep[r]=-1;	/* utilis‚ */
                #if DEBUG
                  info("car trait‚ (reconnu)");
                #endif
              } /* else (if found) */

            } /* if non optimis‚ (espace, VDT_BLANC etc..) */

          } /* if changed */
          else { /* n'a pas chang‚, mais il faut garder le car! */
            ch_(change,XY)=FALSE;
            ch_(treated,XY)=-1;  /* non trait‚, n'a pas chang‚ */
            if (ch_(opti,XY)==0)  /* DRCS d‚clar‚ */
              if ( uch_(xchange,XY) != 255)	/* initialis‚? (bin oui??!) */
                keep[ uch_(xchange,XY) ] = -1;	/* encore en service!! */
          }
        } /* if changed */
      } /* for x */
    } /* for y */
        
    /* ici on a remplac‚ les caractŠres qui ont chang‚s
    et figurant dans le jeu DRCS 
    Il faut encore cr‚er les caractŠres qui restent
    Lorsqu'un caractŠre nouveau est cr‚‚, (il reste de la place)
    on le note dans l'index newdrcs (0..maxnew) au cas o— il
    pourrait reservir pour les autres carctŠres non encore
    cod‚s*/
          
    /* caractŠres n'‚tants pas pass‚s par la 1Šre boucle */
    maxnew=0;	/* caractŠres nouveaux */
    newfull=0;  /* buffer non plein */
    
    /* Note: ???[y][x] est remplac‚ par *(???+XY) */

    for( y=yp ; y<yp+hp ; y++ ) {
      XY=y*40+xp-1;
      for( x=xp ; x<xp+wp ; x++ ) {
        XY++;	/* incr‚ment tableau +1 */

        /* caractŠre point‚ dans image mono */
        B=(uchar*) (gmt_bit_adr+y*10*gmt_line_len+x);

        if ( ch_(change,XY) )		/* si a chang‚ */
        if ( ch_(treated,XY) == 0 ) {	/* et non trait‚ */
          int a,r=-1;

          /* le caractŠre ne serait pas un nouveau d‚ja d‚fini? */
          if (maxnew>0) {
            for( a=0 ; a<maxnew ; a++ ) {
              int b=0;
              int RIND=0;
              while((b<10) AND (drcs[newdrcs[a]][b]==(*(B+RIND)))) {
                b++;
                RIND+=gmt_line_len;
              }
              if (b>=10)
                break; 
            } /* for a (0..maxnew) */

            if (a<maxnew)		/* trouv‚ */
              r=newdrcs[a];
        
          } /* maxnew>0 */

          if (r==(-1)) {
            #if DEBUG
              info("car en cours de cr‚ation");
            #endif
       
            if (newfull==0) {	/* pas encore plein? */
              int r_escue;	/* r de "rechange" */
              if ( (r_escue=ch_(xchange,XY)) != -1) {	/* pr‚c car? */
                if ( keep[r_escue] == -1 )	/* pas libre */
                  r_escue=-1;
              }

              if ( r_escue == -1 ) {
                r=roll;
                do {	/* rechercher place libre!! */
                  if ( keep[r] != -1 ) {
                    if ( keep[r] == 0 ) {		/* yeah cool */
                      break;
                    }
                    else {	/* noter qd mˆme!! */
                      r_escue=r;
                    }
                  }

                  #if DEBUGC
                  if ( keep[r] == 0 )
                    printf("Ahhhhhhhgh!!!!!!!!!, q<>0 ");
                  #endif
                  
                  r++;
                  if (r>=94*2)
                    r=0;
                } while( r!=roll );

                if ( ( r == roll ) AND ( keep[r] == -1 ) ) {
                  if ( r_escue != -1 ) {	/* mais un de rechange! */
                    roll=(r=r_escue);	/* roll=r=r_escue */
                    #if DEBUG
                    printf("\x1bH -> Char %d par d‚faut",r);
                    #endif
                  }
                  else {
                    r=94*2;
                  }
                } /* if roll<>0 */
                else
                  roll=r;		/* rolling pointer */
              } /* if r_escue==0 (start) */
              else { /* le mˆme car est encore libre, on le reprend!! */
                r=r_escue;	/* on garde le mˆme char, mais qui a chang‚ de fonte */
                /* donc n'a pas chang‚ */
                ch_(change,XY)=FALSE;
              }
              
            } /* if newfull==0 */
            else
              r=94*2;	/* plein! */
            
            if ( (++roll) >= 94*2 )	/* rolling pointer */
              roll=0;

            if (r<94*2) {	/* emplacement libre */
              #if DEBUGC
              if ( keep[r] == -1 )
                printf("\nErreur interne d‚buggage: keep[r] corrupted");
              #endif
              newload[r]=TRUE; /* a recharger! */
              { /* copier caractŠre */
                #if DEBUG
                  printf("\x1bY# caractŠre copi‚: %d  ",r);
                #endif
                undrcs[r]=TRUE;
                for( a=0 ; a<10 ; a++)
                  drcs[r][a]=(*(B+gmt_line_len*a));
              } /* copie char */
              newdrcs[maxnew++]=r;	/* noter nouveau */
              #if DEBUGC
                if (maxnew>94*2)
                  printf("\x1BY\x25 Erreur, maxnew>94*2!!! ");
              #endif

            } /* si trouv‚ */
            else {	/* plus de place!! */
              r=-1;
              newfull=TRUE;	/* ne plus tester */
            }
          
          } /* if not present */

          if ( r != -1 ) {	/* on prend en compte r */
            keep[r]=-1;	/* on le garde! */
            ch_(opti,XY) = 0;	/* caractŠre DRCS */
            uch_(xchange,XY) = r;	/* noter car. */
            #if DEBUGC
              /* printf("\x1b\x26 car ‚crit: %d ",r); */
              if ((r>=94*2) OR (r<0))
                printf("\n\x1BY\x25 ***** Erreur, !!! maxnew>94*2!!! Agh!! ");              
            #endif
          } /* if r!=-1 */
          else {	/* plus de place! */
            if ( ch_(opti,XY) != -32 ) { ;	/* annuler car DRCS */
              uch_(xchange,XY)=-1;	/* annuler car DRCS */
              ch_(opti,XY) = -32;	/* espace, signe plein etc.. */
            }
            else
              uch_(change,XY)=FALSE;
          }
          
        } /* if not treated / if changed */
      } /* for x */
    } /* for y */

  } /* bloc de traitement #1 et bloc des nouveaux caractŠres */

  #if AFFDEB
  {
    int x,y,a,b;
    uchar c;

    deffillcol(0);
    boundary(0);
    color(1);
    for( y=yp ; y<yp+hp ; y++ ) {
      for( x=xp ; x<xp+wp ; x++ ) {
        char dr=0;
        if ( change[y][x] )
          dr=-1;
        else
          if ( opti[y][x]==0 )
          if (xchange[y][x]!=255)
          if (newload[xchange[y][x]])
            dr=1;

        if (dr) {
          /* change[y][x]=FALSE; */
          pbox(400+x*8,y*10+yscr,400+x*8+7,y*10+yscr+9);
          switch( opti[y][x] ) {
            case 0: {
              if (dr==1)	/* la fonte a juste chang‚e !! */
                color(3);
              for(a=0 ; a<10 ; a++) {
                c=drcs[xchange[y][x]][a];
                if (xchange[y][x]==255)
                  printf("Erreur! char DRCS -1 gagl!"); 
                for(b=0 ; b<8 ; b++ ) {
                  if (c & 128)
                    plot(400+x*8+b,y*10+a+yscr);
                  c<<=1;
                } /* for b */
              } /* for a */
              if (dr==1)
                color(1);
              break;
            } /* case */
            case 32: {
              pbox(400+x*8,y*10+yscr,400+x*8+7,y*10+yscr+9);
              break;
            }
            case 127: {
              deffillcol(2);
              pbox(400+x*8,y*10+yscr,400+x*8+7,y*10+yscr+9);
              deffillcol(0);
              break;
            }
            default: {
              deffillcol(3);
              pbox(400+x*8,y*10+yscr,400+x*8+7,y*10+yscr+9);
              deffillcol(0);
              break;
            }
          } /* switch */
        } /* if changed */
      
      } /* for x */
    } /* for y */
    
  } /* bloc draw */
  #endif

  
  #if DEBUG
  mf2.fd_addr=(void*) gmt_bit_cmp;
  mf2.fd_stand=0;
  mf2.fd_nplanes=1;
  xy[0]=xy[1]=0;
  xy[2]=(gmt_sizemw MUL8)-1;
  xy[3]=gmt_sizemh*10-1;
  xy[4]=xscr+180;
  xy[5]=yscr;
  xy[6]=xscr+(gmt_sizemw MUL8)-1+180;
  xy[7]=yscr+gmt_sizemh*10-1;
  {
    int color[2]={1,0};
    vrt_cpyfm(handle,1,xy,&mf2,(void*) &screen,color);
  }
  #endif

 return 0;
  
}

/* ‚crire position du curseur */
int pos(ARRSTR *blk,int x,int y) {
  if ( x == 0 ) {
    switch ( y ) {
      case 1: {
        if (mem_tst(*blk,1)) return 1;    
        mem_putchar(*blk,HOME);
      } /* case */
      case 2: {
        if (mem_tst(*blk,2)) return 1;    
        mem_putchar(*blk,HOME);
        mem_putchar(*blk,BAS);
      }
      default: {
        if (mem_tst(*blk,3)) return 1;
        mem_putchar(*blk,POS);
        mem_putchar(*blk,y+64);
        mem_putchar(*blk,x+65);
      }
    } /* switch */
  } /* if x */
  else {
    /* y=1 1‚re ligne mais y=0 ligne "0" (en haut) */
    /* x commence … 0 */
    if (mem_tst(*blk,3)) return 1;
    mem_putchar(*blk,POS);
    mem_putchar(*blk,y+64);
    mem_putchar(*blk,x+65);
  }
  return 0;
}

/* ‚crire couleur de texte */
int gmt_coltext(ARRSTR *blk , char col) {
  if (mem_tst(*blk,2)) return 1;
  mem_putchar(*blk,ESC);
  mem_putchar(*blk,idxtext[col]);
  return 0;
}

/* ‚crire couleur de fond */
int gmt_colfond(ARRSTR *blk , char col) {
  if (mem_tst(*blk,2)) return 1;
  mem_putchar(*blk,ESC);
  mem_putchar(*blk,idxfond[col]);
  return 0;
}

/* curseur + 1 */
void addcurs( int *x , int *y ) {
  (*x)++;
  if ( *x > vmax_x ) {
    if ( *y > 0 ) {
      *x = 0;
      (*y)++;
      if ( *y > vmax_y ) {
        *y = 1;
      }
    }
    else
      *x = vmax_x;
  } 
}

/* Encode dans ARRSTR blk la page graphique pr‚par‚e avec
   gmt_get() selon les coordonn‚es xywh - opt: gmt_opt
   retour: 0 si Ok
   Attention! Coordonn‚es absolues (ne pas d‚passer xm[] etc..)
   flag: 1=car 2=fonte 3=les deux
*/
int gmt_code(ARRSTR *blk,char flag,int x,int y,int w,int h) {
  long oldsize;	/* taille buffer */
    
  /* Note pour gmt_map:
  la carte de chargement ne sert que sur le plan interne:
  les char d‚clar‚s comme "newload" sont rep‚r‚s, mais la carte
  est effac‚e aprŠs */

  _gmt_mclr();
  
  /* interdire certains caractŠres */
  #if ( 0 )
  {
    int a;
    for(a=0 ; a<94*2 ; a++ ) {
      if ( keep[a] == 1 ) {	/* si keep=1 */
        chuse[a]=1;
      }
    }
  }
  #endif
  
  coded=FALSE;
  #if ( gmt_opt3 )
  head_fnt=2;
  #endif

  oldsize=blk->len;	/* noter! */
  
  /* fonte avant */
  if ((flag==2) OR gmt_opt==0) {
    _gmt_map(x,y,w,h);
    if (_gmt_fnt(blk))	/* error */
      return 1;
  }
  
  /* codage caractŠres */
  if (flag & 1) {
    uchar lastc=255;	/* dernier char: pour compactage */
    int countc=0;	/* nombre de caractŠres compact‚s */
    int x_curs,y_curs;
    int by;
    boolean g_gr=0;	/* mode texte */
    boolean g_dr0=0;	/* mode non DRCS texte */    
    boolean g_dr1=0;	/* mode non DRCS graph */    
    char ct,cf;		/* col texte et fond pour graphique */

    #if gmt_optcom
    /* GROSSE macro: tester et ‚ventuellement vider flag de compactage */
    #define flushc if ( countc ) { if ( countc <= 2 ) { if ( mem_tst(*blk,countc) ) return 1; while( (countc--) > 0) mem_putchar(*blk,lastc); countc=0; } else { if ( mem_tst(*blk,2) ) return 1; mem_putchar(*blk,REP); mem_putchar(*blk,countc+64); countc=0; } }     
    #else
    #define flushc 
    #endif
    /* Corps de la macro:
    if ( countc ) {      // si count d‚clar‚ //
      if ( countc <= 2 ) {  // si ne vaut pas la peine //
        if ( mem_tst(*blk,countc) )
          return 1;
        while( (countc--) > 0)
          mem_putchar(*blk,lastc);
      }
      else {  // on compacte //
        if ( mem_tst(*blk,2) )
          return 1;
        mem_putchar(*blk,REP);
        mem_putchar(*blk,countc+64);
      }
      countc=0; 
    }
    */

    /* GROSSE macro: enrgistrer caractŠre */
    #if gmt_optcom
    #define storec(C) if ( C==lastc ) { if ( countc++ >= 63 ) { flushc countc=0; } } else { flushc if (mem_tst(*blk,1)) return 1; mem_putchar(*blk,C); lastc=C; }
    #else
    #define storec(C) if mem_tst(*blk,1) return 1; mem_putchar(*blk,C);
    #endif
    /* Corps de la macro:
    if ( C==lastc ) {  // mˆme caractŠre que  pr‚c‚demment //
      if ( (++countc) >= 63 ) {  // count>63 -> vider! //
        flushc
        countc=0;
      }
    } 
    else { 
      flushc
      if (mem_tst(*blk,1)) 
        return 1; 
      mem_putchar(*blk,C);
      lastc=C; 
    }
    */
    
    /* Init */
    if ( mem_write(blk,DRCST_OFF) )
      return 1;
    if ( mem_write(blk,DRCSG_OFF) )
      return 1;

    /* +inc sur minitel! */
    /* if ( pos(blk,x+gmt_startmx,y+gmt_startmy) )
      return 1;
    x_curs=x+gmt_startmx;
    y_curs=y+gmt_startmy; */

    x_curs=32000;	/* non init */
    y_curs=32000;
    g_gr=FALSE; ct=VDT_BLANC; cf=VDT_NOIR;	/* pos & couleur fond! */
    
    for( by=y ; by < y+h ; by++ ) {
      int bx;
      
      /* fonte avant, entrelac‚e */
      if (gmt_opt==2) {
        _gmt_map(x,by,w,1);
        if (_gmt_fnt(blk))	/* error */
          return 1;
      } /* fonte avant */

/* #if ( gmt_opt2 ) /* … supprimer si gŠne! (inutile, ‚vite un WARNING) */
      if ( gmt_opt2 ) {	/* fond */

        flushc /* vider */

        if ( pos(blk,max(0,x+gmt_startmx-1),by+gmt_startmy) )
          return 1;
         if ( gmt_colfond(blk,gmt_colf) )
           return 1;
        if ( w >= 3 ) {
          if ( mem_tst(*blk,3) )
            return 1;
          storec(SPACE)
          mem_putchar(*blk,REP);
          mem_putchar(*blk,w-1+64);
        }
        else if ( w == 1 ) {
          if ( mem_tst(*blk,1) )
            return 1;
          storec(SPACE)
        }
        else if ( w == 2 ) {
          if ( mem_tst(*blk,2) )
            return 1;
          storec(SPACE)
          storec(SPACE)
        }

        flushc /* vider */
        if ( pos(blk,x+gmt_startmx,by+gmt_startmy) )
          return 1;
        x_curs=x+gmt_startmx; /* r‚gl‚ maintenant */
        y_curs=by+gmt_startmy;
        g_gr=FALSE; ct=VDT_BLANC; cf=VDT_NOIR;		/* pos & couleur fond! */
      }
/* #endif */
      
      for( bx=x ; bx < x+w ; bx++ ) {
        if (change[by][bx]) {

          coded=TRUE;	/* on a ‚crit qq chose */

          if ( (x_curs != (bx+gmt_startmx) ) OR (y_curs != (by+gmt_startmy) ) ) {

            flushc /* vider */

            if ( y_curs == by+gmt_startmy ) {	/* mˆme ligne */
              if ( bx+gmt_startmx == x_curs+1 ) {	/* droite */
                if (mem_tst(*blk,1)) return 1; /* error */
                mem_putchar(*blk,DROITE);
              }
              else if ( bx+gmt_startmx == x_curs+2 ) { /* + 2 droite */
                if (mem_tst(*blk,2)) return 1; /* error */
                mem_putchar(*blk,DROITE);
                mem_putchar(*blk,DROITE);
              }
              else if ( bx+gmt_startmx == x_curs+3 ) { /* + 3 droite */
                if (mem_tst(*blk,3)) return 1; /* error */
                mem_putchar(*blk,DROITE);
                mem_putchar(*blk,DROITE);
                mem_putchar(*blk,DROITE);
              }
              else if ( bx+startmx == 0 ) {	/* d‚but ligne (?!) */
                if (mem_tst(*blk,1)) return 1; /* error */
                mem_putchar(*blk,CR);	/* CR */
              }
              else {	/* pos normal */
                if ( pos(blk,bx+gmt_startmx,by+gmt_startmy) )	/* erreur */
                  return 1;
                g_gr=FALSE; ct=VDT_BLANC; cf=VDT_NOIR;		/* pos & couleur fond! */
              }
              
            }
            else {
              if ( pos(blk,bx+gmt_startmx,by+gmt_startmy) )	/* erreur */
                return 1;
              g_gr=FALSE; ct=VDT_BLANC; cf=VDT_NOIR;		/* pos & couleur fond! */
            }

            x_curs=bx+gmt_startmx; /* r‚gl‚ maintenant */
            y_curs=by+gmt_startmy;
          } /* positionner? */

      
          #define tstfcol if ( (gmt_colf != 0) AND (g_gr) AND (cf != gmt_colf) ) { if ( gmt_colfond(blk,gmt_colf) ) return 1; cf=gmt_colf; }
          /* on doit mettre en place un fond POUR LE MODE GRAPHIQUE */
          /* Corps de la macro:
          if ( (gmt_colf != 0) AND (g_gr) AND (cf != gmt_colf) ) {
            if ( gmt_colfond(blk,gmt_colf) )
              return 1;
            cf=gmt_colf; 
          }
          */

          /* couleur de texte a chang‚e ? */
          if ( gmt_colt != ct ) {

            flushc /* vider */

            if ( gmt_coltext(blk,gmt_colt) )
              return 1;
            ct=gmt_colt;
          }
        
          /* quel type de caractŠre? */
          switch( opti[by][bx] ) {
            case 0: {	/* non opti */

              if ( (xchange[by][bx] / 94) == 0 ) {	/* texte */
                if ( g_dr0 == 0 ) {
                  flushc /* vider */
                  g_dr0 = TRUE;
                  if ( mem_write(blk,DRCST_ON) )	/* error */
                    return 1;
                }
                
                if ( g_gr )  {
                  flushc /* vider */
                  g_gr=FALSE; ct=VDT_BLANC; cf=VDT_NOIR;		/* pos & couleur fond! */
                  if (mem_tst(*blk,1)) return 1; /* error */
                  mem_putchar(*blk,GRAPH_OFF);
                }

              } /* if graph */
              else {	/* graph */

                if ( g_dr1 == 0 ) {
                  flushc /* vider */
                  g_dr1=TRUE;
                  if ( mem_write(blk,DRCSG_ON) )	/* error */
                    return 1;
                }
                
                if ( g_gr == 0 ) {
                  flushc /* vider */
                  g_gr=TRUE;
                  if (mem_tst(*blk,1)) return 1; /* error */
                  mem_putchar(*blk,GRAPH_ON);
                }

                tstfcol /* tester si fond graphique == VDT_NOIR */

              } /* else */
              
              /* if (mem_tst(*blk,1)) return 1; */
              /* mem_putchar(*blk,(xchange[by][bx]%94)+33); */
              
              {
                int tempoc;
                if ( (tempoc=xchange[by][bx]) >= 94 )
                  tempoc-=94;
                tempoc+=33;
                storec(tempoc)
              }
              addcurs(&x_curs,&y_curs);

              break;
            }
            case 1: {	/* txt non DRCS */
              if (g_dr0) {
                flushc /* vider */
                g_dr0=FALSE;
                if ( mem_write(blk,DRCST_OFF) )	/* error */
                  return 1;
              }
              if (g_gr) {
                flushc /* vider */
                g_gr=FALSE; ct=VDT_BLANC; cf=VDT_NOIR;		/* pos & couleur fond! */
                if (mem_tst(*blk,1)) return 1; /* error */
                mem_putchar(*blk,GRAPH_OFF);
              }

              /* if (mem_tst(*blk,1)) return 1; */
              /* mem_putchar(*blk,xchange[by][bx]); */

              {
                int tempoc=xchange[by][bx];
                storec(tempoc)
              }
              addcurs(&x_curs,&y_curs);

              break;
            }
            case 2: {	/* grf non DRCS */
              if (g_dr1) {
                flushc /* vider */
                g_dr1=FALSE;
                if ( mem_write(blk,DRCSG_OFF) )	/* error */
                  return 1;
              }  
              if (g_gr==FALSE) {
                flushc /* vider */
                g_gr=TRUE;
                if (mem_tst(*blk,1)) return 1; /* error */
                mem_putchar(*blk,GRAPH_ON);
              }

              tstfcol /* tester si fond graphique == VDT_NOIR */

              /* if (mem_tst(*blk,1)) return 1; */
              /* mem_putchar(*blk,xchange[by][bx]); */
              
              {
                int tempoc=xchange[by][bx];
                storec(tempoc)
              }
              addcurs(&x_curs,&y_curs);

              break;
            }
            case SPACE: {	/* espace */
              /* if (mem_tst(*blk,1)) return 1; */
              /* mem_putchar(*blk,SPACE); */

              tstfcol /* tester si fond graphique == VDT_NOIR (si graphique) */
              storec(SPACE)
              addcurs(&x_curs,&y_curs);

              break;
            }
            case 127: {	/* VDT_BLANC */
              /* if (mem_tst(*blk,1)) return 1; */
              /* mem_putchar(*blk,127); */

              tstfcol /* tester (si graphique) si fond graphique == VDT_NOIR */
              storec(127)
              addcurs(&x_curs,&y_curs);

              break;
            }
            case -32: {		/* remplacer */
              if (g_dr0) {
                flushc /* vider */
                g_dr0=FALSE;
                if ( mem_write(blk,DRCST_OFF) )	/* error */
                  return 1;
              }
              if (g_gr) {
                flushc /* vider */
                g_gr=FALSE; ct=VDT_BLANC; cf=VDT_NOIR;		/* pos & couleur fond! */
                if (mem_tst(*blk,1)) return 1; /* error */
                mem_putchar(*blk,GRAPH_OFF);
              }

              storec('?')
              addcurs(&x_curs,&y_curs);

              break;
            }
            #if DEBUGC
            default:
              printf("\x1bY\26 ERREUR!!! gmt_code *case* ");
            #endif
          } /* case */
        } /* if change */
        
      } /* for bx */

      flushc /* vider */
      
      /* fonte aprŠs, entrelac‚e */
      if (gmt_opt==3) {
        _gmt_map(x,by,w,1);
        if (_gmt_fnt(blk))	/* error */
          return 1;
      } /* fonte aprŠs */
      
    } /* for by */

  } /* code char */

  /* fonte aprŠs */
  if (gmt_opt==1) {
    _gmt_map(x,y,w,h);
    if (_gmt_fnt(blk))	/* error */
      return 1;
  }

  if (coded==0) {	/* rien de neuf */
    blk->len=oldsize;
  }
  
  return 0;
}

/* effacer "plan" de chargement */ 
void _gmt_mclr( void ) {
  int x;
  
  for( x=0 ; x<94*2 ; chuse[x++]=0 );
}

/* calculer "plan" de chargement */
void _gmt_map(int xp,int yp,int wp,int hp) {
  int x,y;

  /* attention! change=0 ne veut pas dire n'a pas chang‚, veut dire
     que le num‚ro de caractŠre n'a pas chang‚, mais la fonte 
     a bien pu ˆtre chang‚e.. dans ce cas newload est d‚j… fix‚ */
      
  /* chuse: 0 non utilis‚ TRUE … utiliser 1 utilis‚ (charg‚) */
  for( y=yp ; y<yp+hp ; y++ ) {
    for( x=xp ; x<xp+wp ; x++ ) {
      if (opti[y][x]==0) { /* DRCS loading */
        if (chuse[xchange[y][x]]!=1) {	/* non d‚ja charg‚? */
          if (newload[xchange[y][x]]) { /* nouveau car? */
            chuse[xchange[y][x]]=-1;
          } /* if newload */
        } /* if chuse!=-1 */
      } /* opti=0 */
    } /* next x */
  } /* next y*/
} /* return */

/* ‚xecuter "plan" de chargement */
int _gmt_fnt(ARRSTR *blk) {
  int f;
  int lastc=-2;	/* dernier caractŠre charg‚ */
  char init=0;	/* init state */
  
  for( f=0 ; f<94*2 ; f++ ) {

    if (f == 94) {	/* nouveau type (texte/graph) */
      if (init) {	/* initialis‚ donc fermer TEXTE */
        if ( mem_write(blk,END_TEL) )	/* error */
          return 1;
        init=0;  
        lastc=-2;
      }
    }

    if (chuse[f]==-1) {	/* charger!! */
      
      if (init==0) {	/* non initialis‚! */
        /* charger header de chargement + 1er caractŠre */

        init=TRUE;
        lastc=-2;

        if ( (f/94) == 0 ) {	/* TEXTE */
          /* **LOAD-TEXTE** */         
          if ( head_fnt != 0 ) { 	/* header non charg‚ pr‚c‚demment */
            if ( mem_write(blk,START_TEXT) )	/* error */
              return 1;
            if ( head_fnt != 99 )	/* 99=toujours */
              head_fnt=0;
          }
          /* on ne fait rien, d‚ja d‚clar‚ */
        }
        else {
          /* **LOAD-GRAPH** */         
          if ( head_fnt != 1) { 	/* header non charg‚ pr‚c‚demment */
            if ( mem_write(blk,START_GRAPH) )	/* error */
              return 1;
            if ( head_fnt != 99 )	/* 99=toujours */
              head_fnt=1;
          }
          /* on ne fait rien, d‚ja d‚clar‚ */
        }

        /* **LOAD-CHAR** f */
        if (mem_tst(*blk,4)) return 1; /* error */
        mem_putchar(*blk,0x1F);
        mem_putchar(*blk,0x23);
        mem_putchar(*blk,(f%94)+33);
        mem_putchar(*blk,0x30);
          
      } /* initialis‚? */
      else {	/* next char! */
        /* **NEXT-CHAR** */
        if ( f == lastc+1 ) {	/* next */
          if (mem_tst(*blk,1)) return 1; /* error */
          mem_putchar(*blk,0x30);
        }
        else {
          /* **LOAD-CHAR** f */
          if (mem_tst(*blk,4)) return 1; /* error */
          mem_putchar(*blk,0x1F);
          mem_putchar(*blk,0x23);
          mem_putchar(*blk,(f%94)+33);
          mem_putchar(*blk,0x30);
        }
        
      } /* next char (non init) **/

      /* le charger! */

      {
        uchar oct[12];
        uchar sext[16];
        int i;
        
        coded=TRUE;	/* on a ‚crit qq chose */

        /* copier dans oct */
        for(i=0 ; i<10 ; (oct[i] = drcs[f][i++]) );
        oct[10]=oct[11]=0;	/* effacer */

        /* 3 octets -> 4 sextets */
        /* 01234567|01234567|01234567 -> 012345|670123|456701|234567 */
        for( i=0 ; i<4 ; i++ ) {
          long tri;
          
          /* triplet (24 bits) */
          tri = (long) ( ( ((long) oct[i*3]) <<16) | ( ((long) oct[i*3+1]) <<8) | ( ( long) oct[i*3+2]) );
          
          /* convertir en sextets */
          sext[i*4 + 3] = ( tri & 63 );
          sext[i*4 + 2] = ( (tri >>= 6) & 63 );
          sext[i*4 + 1] = ( (tri >>= 6) & 63 );
          sext[i*4    ] = ( (tri >>= 6) );

        } /* next i */

        /* optimiser: supprimer sextets nuls (le 1er sextet!=0) */
        
        for( i= 15 ; (sext[i]==0) AND (i>0) ; i-- );
        
        #if DEBUGC
         if (i<0 OR i>13)
           printf("Transmission error: >14 chars!!");
        #endif
      
        /* charger de 0 … i */  
        {
          int j;
          for( j=0 ; j<=i ; j++ ) {

            if (mem_tst(*blk,1)) return 1; /* error */
            mem_putchar(*blk,(sext[j]+64));

          } /* next j*/

        } /* bloc charger chars */
      
      } /* charger caractŠre */
      
      lastc=f;
      chuse[f]=1;
      
    } /* if chuse==-1 */
  
  } /* for f */
  
  /* fin tlc */
  if (init) {
    if ( mem_write(blk,END_TEL) )	/* error */
      return 1;
  }
  
  return 0;
}

#if defined(gmt_sizemw)
/* Efface ‚cran & initialise */
int gmt_cls(ARRSTR *blk) {
  int i;
  
  /* if ( mem_write( blk , RST_GMT ) )
    return 1; */

  for(i=0 ; i<gmt_sizemh ; i++ ) {

    if ( (gmt_colf) && (gmt_startmx>0) ) {
      if ( pos(blk,gmt_startmx-1,gmt_startmy+i) )
        return 1;
      if ( gmt_colfond(blk,gmt_colf) )
        return 1;
      if ( mem_tst(*blk,1) )
        return 1;
      mem_putchar(*blk,SPACE);
    }
    else {
      if ( pos(blk,gmt_startmx,gmt_startmy+i) )
        return 1;
    }

    if ( mem_tst(*blk,3) )
      return 1;
    mem_putchar(*blk,SPACE);
    mem_putchar(*blk,REP);
    mem_putchar(*blk,min(gmt_sizemw,vmax_x-gmt_startmx)+64);
               
  } /* for i */

  return 0;
}
#endif

/* Optimisation du bloc vid‚otext NON ACHEVE CAR NON NECESSAIRE (compactage temps reel dans algo) */
int gmt_optim(ARRSTR *blk) {
  int i,j;
  uchar lastc=255;
  int countc=0;
  uchar c;

  for(i=j=0 ; i < blk->len ; i++ ) {
  
    /* caractŠre en traitement */
    c=blk->str[i];
    
    if ( c==lastc ) {
      if ( countc++ >= 63 ) {
        blk->str[j++]=REP;	/* REP */        
        blk->str[j++]=countc+64;
        countc=0;
      }
    } /* if c==lastc */
    else {	/* caractŠre diff‚rent */
      if (countc) {	/* caractŠres! */
        if ( countc<=2 ) {	/* pas la peine! */
          while( countc-- > 0 )
            blk->str[j++]=lastc;
          blk->str[j++]=c;
        }
        else {	/* on compacte ok */
          blk->str[j++]=REP;	/* REP */        
          blk->str[j++]=countc+64;
        } /* if countc>2 */

        countc=0;
      } /* if countc */

      if ( (lastc=c) < 32 ) {
        lastc=255;	/* non valide! */
        if (c==27) {	/* agh */
        
        
        
        }
        
      }

      /* ‚crire */
      blk->str[j++]=c;
    } /* c!=lastc */
  } /* next i */
 
  return 0; 
}