#include <cpu_prog_model.h>
#include <stdio.h>
#include <video_atribut.h>

#define FALSE 0
#define TRUE  1

char  * dub_screen [2] = {0,0};   /* screen 1/2 */
void  * malloc();

double_screen( address)
unsigned short int address;
{
   /**/
}



#if hubba

extern char MEMORY[];

extern int gr,
           full_screen,
           old_address,
           old_radflg;

int  byte,
     address,
     radflg;


video_out(address,radflg)
int address,
    radflg;
{
  int has_send = 0,
      old_x,
      old_y,
      old_byte;
  old_x = (old_address - (0x0400+0x80*(old_radflg-1)))%40;
  old_y = (((old_address - (0x0400+0x80*(old_radflg-1)))/40)*8)+(old_radflg-1);
  old_byte = MEMORY [old_address];


  {
    int x,
        y,
        byte;
    x = (address - (0x0400+0x80*(radflg-1)))%40;
    y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
    byte = MEMORY [address];

    if ((y == old_y) && (x == old_x+1))
    {
      charprn(old_byte);
      charprn(byte);
      has_send = 1;
    }

    if ((y == old_y) && (x == old_x-1))
    {
      printf("\210");
      charprn(byte);
      has_send = 1;
    }

    if ((y == old_y+1) && (x == old_x))
    {
      printf("\233D");
      charprn(byte);
      has_send = 1;
    }

    if ((y == old_y-1) && (x == old_x))
    {
      printf("\233M");
      charprn(byte);
      has_send = 1;
    }

    if (!has_send)
    {
      printf("\233[%d;%df",y+1,x+1);
      charprn(byte);
    }
  }

  printf("\210");
  old_address = address;
  old_radflg = radflg;
}

graphprn(byte)
int  byte;
{
  if (!byte)
    printf(" ");
  else
  {
    if ((byte & 0xf0) == 0)
      printf("\233(2\233)2p\233(B\233)B");
    if ((byte & 0x0f) == 0)
      printf("\233(2\233)2r\233(B\233)B");
    if ( ((byte & 0x0f) != 0) && ((byte & 0xf0) !=0) )
      printf("=");
  }
}

graph_out(address,radflg)
int address,
    radflg;
{
  int has_send = 0,
      old_x,
      old_y,
      old_byte;
  old_x = (old_address - (0x0400+0x80*(old_radflg-1)))%40;
  old_y = (((old_address - (0x0400+0x80*(old_radflg-1)))/40)*8)+(old_radflg-1);
  old_byte = MEMORY [old_address];

  {
    int x,
        y,
        byte;
    x = (address - (0x0400+0x80*(radflg-1)))%40;
    y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
    byte = MEMORY [address];

    if ((y == old_y) && (x == old_x+1))
    {
      graphprn(old_byte);
      graphprn(byte);
      has_send = 1;
    }

    if ((y == old_y) && (x == old_x-1))
    {
      printf("\210");
      graphprn(byte);
      has_send = 1;
    }

    if (!has_send)
    {
      printf("\233[%d;%df",y+1,x+1);
      graphprn(byte);
    }
  }

  printf("\210");
  old_address = address;
  old_radflg = radflg;
}

refresh_screen()
{
  int address;
  printf("\233[2J\233[f");
  for (address = 0x400;address < 0x428;address++)
  {
    int y;
    y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
    if (!gr | (y > 19))
      charprn( MEMORY [address] );
    else
      graphprn ( MEMORY [address] );
  }
  printf("\n");

  for (address = 0x480;address < 0x4a8;address++)
  {
    int y;
    y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
    if (!gr | (y > 19))
      charprn( MEMORY [address] );
    else
      graphprn ( MEMORY [address] );
  }
  printf("\n");

  for (address = 0x500;address < 0x528;address++)
  {
    int y;
    y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
    if (!gr | (y > 19))
      charprn( MEMORY [address] );
    else
      graphprn ( MEMORY [address] );
  }
  printf("\n");

  for (address = 0x580;address < 0x5a8;address++)
  {
    int y;
    y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
    if (!gr | (y > 19))
      charprn( MEMORY [address] );
    else
      graphprn ( MEMORY [address] );
  }
  printf("\n");

  for (address = 0x600;address < 0x628;address++)
  {
    int y;
    y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
    if (!gr | (y > 19))
      charprn( MEMORY [address] );
    else
      graphprn ( MEMORY [address] );
  }
  printf("\n");

  for (address = 0x680;address < 0x6a8;address++)
  {
    int y;
    y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
    if (!gr | (y > 19))
      charprn( MEMORY [address] );
    else
      graphprn ( MEMORY [address] );
  }
  printf("\n");

  for (address = 0x700;address < 0x728;address++)
  {
    int y;
    y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
    if (!gr | (y > 19))
      charprn( MEMORY [address] );
    else
      graphprn ( MEMORY [address] );
  }
  printf("\n");

  for (address = 0x780;address < 0x7a8;address++)
  {
    int y;
    y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
    if (!gr | (y > 19))
      charprn( MEMORY [address] );
    else
      graphprn ( MEMORY [address] );
  }
  printf("\n");

  for (address = 0x428;address < 0x450;address++)
  {
    int y;
    y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
    if (!gr | (y > 19))
      charprn( MEMORY [address] );
    else
      graphprn ( MEMORY [address] );
  }
  printf("\n");

  for (address = 0x4a8;address < 0x4d0;address++)
  {
    int y;
    y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
    if (!gr | (y > 19))
      charprn( MEMORY [address] );
    else
      graphprn ( MEMORY [address] );
  }
  printf("\n");

  for (address = 0x528;address < 0x550;address++)
  {
    int y;
    y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
    if (!gr | (y > 19))
      charprn( MEMORY [address] );
    else
      graphprn ( MEMORY [address] );
  }
  printf("\n");

  for (address = 0x5a8;address < 0x5d0;address++)
  {
    int y;
    y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
    if (!gr | (y > 19))
      charprn( MEMORY [address] );
    else
      graphprn ( MEMORY [address] );
  }
  printf("\n");

  for (address = 0x628;address < 0x650;address++)
  {
    int y;
    y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
    if (!gr | (y > 19))
      charprn( MEMORY [address] );
    else
      graphprn ( MEMORY [address] );
  }
  printf("\n");

  for (address = 0x6a8;address < 0x6d0;address++)
  {
    int y;
    y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
    if (!gr | (y > 19))
      charprn( MEMORY [address] );
    else
      graphprn ( MEMORY [address] );
  }
  printf("\n");

  for (address = 0x728;address < 0x750;address++)
  {
    int y;
    y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
    if (!gr | (y > 19))
      charprn( MEMORY [address] );
    else
      graphprn ( MEMORY [address] );
  }
  printf("\n");

  for (address = 0x7a8;address < 0x7d0;address++)
  {
    int y;
    y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
    if (!gr | (y > 19))
      charprn( MEMORY [address] );
    else
      graphprn ( MEMORY [address] );
  }
  printf("\n");

  for (address = 0x450;address < 0x478;address++)
  {
    int y;
    y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
    if (!gr | (y > 19))
      charprn( MEMORY [address] );
    else
      graphprn ( MEMORY [address] );
  }
  printf("\n");

  for (address = 0x4d0;address < 0x4f8;address++)
  {
    int y;
    y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
    if (!gr | (y > 19))
      charprn( MEMORY [address] );
    else
      graphprn ( MEMORY [address] );
  }
  printf("\n");

  for (address = 0x550;address < 0x578;address++)
  {
    int y;
    y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
    if (!gr | (y > 19))
      charprn( MEMORY [address] );
    else
      graphprn ( MEMORY [address] );
  }
  printf("\n");

  for (address = 0x5d0;address < 0x5f8;address++)
  {
    int y;
    y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
    if (!gr | (y > 19))
      charprn( MEMORY [address] );
    else
      graphprn ( MEMORY [address] );
  }
  printf("\n");

  for (address = 0x650;address < 0x678;address++)
  {
    int y;
    y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
    if (!gr | (y > 19))
      charprn( MEMORY [address] );
    else
      graphprn ( MEMORY [address] );
  }
  printf("\n");

  for (address = 0x6d0;address < 0x6f8;address++)
  {
    int y;
    y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
    if (!gr | (y > 19))
      charprn( MEMORY [address] );
    else
      graphprn ( MEMORY [address] );
  }
  printf("\n");

  for (address = 0x750;address < 0x778;address++)
  {
    int y;
    y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
    if (!gr | (y > 19))
      charprn( MEMORY [address] );
    else
      graphprn ( MEMORY [address] );
  }
  printf("\n");

  for (address = 0x7d0;address < 0x7f8;address++)
  {
    int y;
    y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
    if (!gr | (y > 19))
      charprn( MEMORY [address] );
    else
      graphprn ( MEMORY [address] );
  }
  full_screen = 0;
}









  int radflg;
  if (radflg = video_check(address) )
  {
    if (!r_w && !full_screen)
    {
      int y;
      y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
      if (!gr | (y > 19))
        video_out(address,radflg);
      else
        graph_out(address,radflg);
    }
  }
  else
  {
    /* slotdefine i/o */
  }
}

#endif



short display_page( address)   /* Return the number of area. 0 if no scrre */
unsigned short int address;
{
  short  area;

  area = 0;
  area += ((address >= 0x0400) && (address <= 0x0477)) * 1;
  area += ((address >= 0x0480) && (address <= 0x04F7)) * 2;
  area += ((address >= 0x0500) && (address <= 0x0577)) * 3;
  area += ((address >= 0x0580) && (address <= 0x05F7)) * 4;
  area += ((address >= 0x0600) && (address <= 0x0677)) * 5;
  area += ((address >= 0x0680) && (address <= 0x06F7)) * 6;
  area += ((address >= 0x0700) && (address <= 0x0777)) * 7;
  area += ((address >= 0x0780) && (address <= 0x07F7)) * 8;

  return area;
}

print_char( tecken)
char tecken;
{
   switch (tecken >> 6)
   {
      case 0:    /* Invers */
         printf("\233[7m");

         if ((tecken & 0x20) == 0)
            tecken = (tecken & 0x3F) + 0x40;
         else
            tecken = (tecken & 0x3F);

         printf("%c",tecken | 0x80);
         printf("\233[m");
         break;

      case 1:    /* Flash */
         printf("\233[5m");
         if ((tecken & 0x20) == 0)
            tecken = (tecken & 0x3F) + 0x40;
         else
            tecken = (tecken & 0x3F);

         if (tecken == 0x20)
            printf("\233(2\233)2a\233(B\233)B");
         else
            printf("%c",tecken | 0x80);

         printf("\233[m");
         break;

      case 2:   case 3:   /* Control / Normal */
         if (tecken < 0xA0)
         {
            /* ctrl */
            printf(".");
         }

         else
         {
            /* norm */
            printf("%c",tecken | 0x80);
         }
         break;
   }  /* End of switch (tecken >> 6) */

}

clear_screen()
{
   short x_led,
         y_led;

   cls();

   for (y_led = 1;y_led < 25;y_led ++)
   {
      for (x_led = 1;x_led <= 40;x_led ++)
      {
         dub_screen [0][x_led + y_led * 40] = 0xA0;
         dub_screen [1][x_led + y_led * 40] = 0xA0;
      }
   }
}

init_screen()
{

   dub_screen [0] = (char *) malloc( sizeof( short) * 1000);
   dub_screen [1] = (char *) malloc( sizeof( short) * 1000);

   clear_screen();
}

move_print( x_led, y_led, charackter)
short x_led,
      y_led;
char  charackter;
{
   short         action;
   static short  old_x = 1,
                 old_y = 1;

   action = FALSE;
   if ( (x_led == old_x) && (y_led == old_y) )
      action = TRUE;

   if ( (x_led == old_x - 1) && (y_led == old_y) )
   {
      printf("\b");
      action = TRUE;
   }

   if ( (x_led == old_x - 2) && (y_led == old_y) )
   {
      printf("\b\b");
      action = TRUE;
   }

   if (!action)
      printf("\233[%d;%df", y_led + 1, x_led + 1);

   print_char( charackter);
   x_led ++;

   old_x = x_led;
   old_y = y_led;
}

to_video( address, area, value)
unsigned short int  address;
short               area,
                    value;
{
   short x_led,
         y_led;

   short temp_value;

   if (!dub_screen [0] || !dub_screen [1])
      init_screen();

   x_led = (address - (0x0400+0x80*(area-1)))%40;
   y_led = (((address - (0x0400+0x80*(area-1)))/40)*8)+(area-1);
   dub_screen [0][x_led + y_led * 40] = value;

   if (dub_screen [0][x_led + y_led * 40] !=
       dub_screen [1][x_led + y_led * 40]    )
   {
      if (value)
         move_print( x_led, y_led, value);

      dub_screen [1][x_led + y_led * 40] = dub_screen [0][x_led + y_led * 40];
   }

   /* If value == 0xFF Then this is a RAM test secvens */
}

refresh( code)
PM *code;
{
   short address,
         area,
         x_led,
         y_led;

   if (!dub_screen [0] || !dub_screen [1])
      init_screen();
   else
      clear_screen();

   for (address = 0x400;address < 0x0800;address ++)
   {
      if (area = display_page( address) )
      {
         x_led = (address - (0x0400+0x80*(area-1)))%40;
         y_led = (((address - (0x0400+0x80*(area-1)))/40)*8)+(area-1);

         to_video( address, area, code->Me [address]);
      }
   }
}