home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 405.lha / AppleII_Emulators_src / src-2 / ap_video.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-06-28  |  12.9 KB  |  638 lines
  1. #include <cpu_prog_model.h>
  2. #include <stdio.h>
  3. #include <video_atribut.h>
  4.  
  5. #define FALSE 0
  6. #define TRUE  1
  7.  
  8. char  * dub_screen [2] = {0,0};   /* screen 1/2 */
  9. void  * malloc();
  10.  
  11. double_screen( address)
  12. unsigned short int address;
  13. {
  14.    /**/
  15. }
  16.  
  17.  
  18.  
  19. #if hubba
  20.  
  21. extern char MEMORY[];
  22.  
  23. extern int gr,
  24.            full_screen,
  25.            old_address,
  26.            old_radflg;
  27.  
  28. int  byte,
  29.      address,
  30.      radflg;
  31.  
  32.  
  33. video_out(address,radflg)
  34. int address,
  35.     radflg;
  36. {
  37.   int has_send = 0,
  38.       old_x,
  39.       old_y,
  40.       old_byte;
  41.   old_x = (old_address - (0x0400+0x80*(old_radflg-1)))%40;
  42.   old_y = (((old_address - (0x0400+0x80*(old_radflg-1)))/40)*8)+(old_radflg-1);
  43.   old_byte = MEMORY [old_address];
  44.  
  45.  
  46.   {
  47.     int x,
  48.         y,
  49.         byte;
  50.     x = (address - (0x0400+0x80*(radflg-1)))%40;
  51.     y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
  52.     byte = MEMORY [address];
  53.  
  54.     if ((y == old_y) && (x == old_x+1))
  55.     {
  56.       charprn(old_byte);
  57.       charprn(byte);
  58.       has_send = 1;
  59.     }
  60.  
  61.     if ((y == old_y) && (x == old_x-1))
  62.     {
  63.       printf("\210");
  64.       charprn(byte);
  65.       has_send = 1;
  66.     }
  67.  
  68.     if ((y == old_y+1) && (x == old_x))
  69.     {
  70.       printf("\233D");
  71.       charprn(byte);
  72.       has_send = 1;
  73.     }
  74.  
  75.     if ((y == old_y-1) && (x == old_x))
  76.     {
  77.       printf("\233M");
  78.       charprn(byte);
  79.       has_send = 1;
  80.     }
  81.  
  82.     if (!has_send)
  83.     {
  84.       printf("\233[%d;%df",y+1,x+1);
  85.       charprn(byte);
  86.     }
  87.   }
  88.  
  89.   printf("\210");
  90.   old_address = address;
  91.   old_radflg = radflg;
  92. }
  93.  
  94. graphprn(byte)
  95. int  byte;
  96. {
  97.   if (!byte)
  98.     printf(" ");
  99.   else
  100.   {
  101.     if ((byte & 0xf0) == 0)
  102.       printf("\233(2\233)2p\233(B\233)B");
  103.     if ((byte & 0x0f) == 0)
  104.       printf("\233(2\233)2r\233(B\233)B");
  105.     if ( ((byte & 0x0f) != 0) && ((byte & 0xf0) !=0) )
  106.       printf("=");
  107.   }
  108. }
  109.  
  110. graph_out(address,radflg)
  111. int address,
  112.     radflg;
  113. {
  114.   int has_send = 0,
  115.       old_x,
  116.       old_y,
  117.       old_byte;
  118.   old_x = (old_address - (0x0400+0x80*(old_radflg-1)))%40;
  119.   old_y = (((old_address - (0x0400+0x80*(old_radflg-1)))/40)*8)+(old_radflg-1);
  120.   old_byte = MEMORY [old_address];
  121.  
  122.   {
  123.     int x,
  124.         y,
  125.         byte;
  126.     x = (address - (0x0400+0x80*(radflg-1)))%40;
  127.     y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
  128.     byte = MEMORY [address];
  129.  
  130.     if ((y == old_y) && (x == old_x+1))
  131.     {
  132.       graphprn(old_byte);
  133.       graphprn(byte);
  134.       has_send = 1;
  135.     }
  136.  
  137.     if ((y == old_y) && (x == old_x-1))
  138.     {
  139.       printf("\210");
  140.       graphprn(byte);
  141.       has_send = 1;
  142.     }
  143.  
  144.     if (!has_send)
  145.     {
  146.       printf("\233[%d;%df",y+1,x+1);
  147.       graphprn(byte);
  148.     }
  149.   }
  150.  
  151.   printf("\210");
  152.   old_address = address;
  153.   old_radflg = radflg;
  154. }
  155.  
  156. refresh_screen()
  157. {
  158.   int address;
  159.   printf("\233[2J\233[f");
  160.   for (address = 0x400;address < 0x428;address++)
  161.   {
  162.     int y;
  163.     y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
  164.     if (!gr | (y > 19))
  165.       charprn( MEMORY [address] );
  166.     else
  167.       graphprn ( MEMORY [address] );
  168.   }
  169.   printf("\n");
  170.  
  171.   for (address = 0x480;address < 0x4a8;address++)
  172.   {
  173.     int y;
  174.     y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
  175.     if (!gr | (y > 19))
  176.       charprn( MEMORY [address] );
  177.     else
  178.       graphprn ( MEMORY [address] );
  179.   }
  180.   printf("\n");
  181.  
  182.   for (address = 0x500;address < 0x528;address++)
  183.   {
  184.     int y;
  185.     y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
  186.     if (!gr | (y > 19))
  187.       charprn( MEMORY [address] );
  188.     else
  189.       graphprn ( MEMORY [address] );
  190.   }
  191.   printf("\n");
  192.  
  193.   for (address = 0x580;address < 0x5a8;address++)
  194.   {
  195.     int y;
  196.     y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
  197.     if (!gr | (y > 19))
  198.       charprn( MEMORY [address] );
  199.     else
  200.       graphprn ( MEMORY [address] );
  201.   }
  202.   printf("\n");
  203.  
  204.   for (address = 0x600;address < 0x628;address++)
  205.   {
  206.     int y;
  207.     y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
  208.     if (!gr | (y > 19))
  209.       charprn( MEMORY [address] );
  210.     else
  211.       graphprn ( MEMORY [address] );
  212.   }
  213.   printf("\n");
  214.  
  215.   for (address = 0x680;address < 0x6a8;address++)
  216.   {
  217.     int y;
  218.     y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
  219.     if (!gr | (y > 19))
  220.       charprn( MEMORY [address] );
  221.     else
  222.       graphprn ( MEMORY [address] );
  223.   }
  224.   printf("\n");
  225.  
  226.   for (address = 0x700;address < 0x728;address++)
  227.   {
  228.     int y;
  229.     y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
  230.     if (!gr | (y > 19))
  231.       charprn( MEMORY [address] );
  232.     else
  233.       graphprn ( MEMORY [address] );
  234.   }
  235.   printf("\n");
  236.  
  237.   for (address = 0x780;address < 0x7a8;address++)
  238.   {
  239.     int y;
  240.     y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
  241.     if (!gr | (y > 19))
  242.       charprn( MEMORY [address] );
  243.     else
  244.       graphprn ( MEMORY [address] );
  245.   }
  246.   printf("\n");
  247.  
  248.   for (address = 0x428;address < 0x450;address++)
  249.   {
  250.     int y;
  251.     y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
  252.     if (!gr | (y > 19))
  253.       charprn( MEMORY [address] );
  254.     else
  255.       graphprn ( MEMORY [address] );
  256.   }
  257.   printf("\n");
  258.  
  259.   for (address = 0x4a8;address < 0x4d0;address++)
  260.   {
  261.     int y;
  262.     y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
  263.     if (!gr | (y > 19))
  264.       charprn( MEMORY [address] );
  265.     else
  266.       graphprn ( MEMORY [address] );
  267.   }
  268.   printf("\n");
  269.  
  270.   for (address = 0x528;address < 0x550;address++)
  271.   {
  272.     int y;
  273.     y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
  274.     if (!gr | (y > 19))
  275.       charprn( MEMORY [address] );
  276.     else
  277.       graphprn ( MEMORY [address] );
  278.   }
  279.   printf("\n");
  280.  
  281.   for (address = 0x5a8;address < 0x5d0;address++)
  282.   {
  283.     int y;
  284.     y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
  285.     if (!gr | (y > 19))
  286.       charprn( MEMORY [address] );
  287.     else
  288.       graphprn ( MEMORY [address] );
  289.   }
  290.   printf("\n");
  291.  
  292.   for (address = 0x628;address < 0x650;address++)
  293.   {
  294.     int y;
  295.     y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
  296.     if (!gr | (y > 19))
  297.       charprn( MEMORY [address] );
  298.     else
  299.       graphprn ( MEMORY [address] );
  300.   }
  301.   printf("\n");
  302.  
  303.   for (address = 0x6a8;address < 0x6d0;address++)
  304.   {
  305.     int y;
  306.     y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
  307.     if (!gr | (y > 19))
  308.       charprn( MEMORY [address] );
  309.     else
  310.       graphprn ( MEMORY [address] );
  311.   }
  312.   printf("\n");
  313.  
  314.   for (address = 0x728;address < 0x750;address++)
  315.   {
  316.     int y;
  317.     y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
  318.     if (!gr | (y > 19))
  319.       charprn( MEMORY [address] );
  320.     else
  321.       graphprn ( MEMORY [address] );
  322.   }
  323.   printf("\n");
  324.  
  325.   for (address = 0x7a8;address < 0x7d0;address++)
  326.   {
  327.     int y;
  328.     y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
  329.     if (!gr | (y > 19))
  330.       charprn( MEMORY [address] );
  331.     else
  332.       graphprn ( MEMORY [address] );
  333.   }
  334.   printf("\n");
  335.  
  336.   for (address = 0x450;address < 0x478;address++)
  337.   {
  338.     int y;
  339.     y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
  340.     if (!gr | (y > 19))
  341.       charprn( MEMORY [address] );
  342.     else
  343.       graphprn ( MEMORY [address] );
  344.   }
  345.   printf("\n");
  346.  
  347.   for (address = 0x4d0;address < 0x4f8;address++)
  348.   {
  349.     int y;
  350.     y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
  351.     if (!gr | (y > 19))
  352.       charprn( MEMORY [address] );
  353.     else
  354.       graphprn ( MEMORY [address] );
  355.   }
  356.   printf("\n");
  357.  
  358.   for (address = 0x550;address < 0x578;address++)
  359.   {
  360.     int y;
  361.     y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
  362.     if (!gr | (y > 19))
  363.       charprn( MEMORY [address] );
  364.     else
  365.       graphprn ( MEMORY [address] );
  366.   }
  367.   printf("\n");
  368.  
  369.   for (address = 0x5d0;address < 0x5f8;address++)
  370.   {
  371.     int y;
  372.     y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
  373.     if (!gr | (y > 19))
  374.       charprn( MEMORY [address] );
  375.     else
  376.       graphprn ( MEMORY [address] );
  377.   }
  378.   printf("\n");
  379.  
  380.   for (address = 0x650;address < 0x678;address++)
  381.   {
  382.     int y;
  383.     y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
  384.     if (!gr | (y > 19))
  385.       charprn( MEMORY [address] );
  386.     else
  387.       graphprn ( MEMORY [address] );
  388.   }
  389.   printf("\n");
  390.  
  391.   for (address = 0x6d0;address < 0x6f8;address++)
  392.   {
  393.     int y;
  394.     y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
  395.     if (!gr | (y > 19))
  396.       charprn( MEMORY [address] );
  397.     else
  398.       graphprn ( MEMORY [address] );
  399.   }
  400.   printf("\n");
  401.  
  402.   for (address = 0x750;address < 0x778;address++)
  403.   {
  404.     int y;
  405.     y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
  406.     if (!gr | (y > 19))
  407.       charprn( MEMORY [address] );
  408.     else
  409.       graphprn ( MEMORY [address] );
  410.   }
  411.   printf("\n");
  412.  
  413.   for (address = 0x7d0;address < 0x7f8;address++)
  414.   {
  415.     int y;
  416.     y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
  417.     if (!gr | (y > 19))
  418.       charprn( MEMORY [address] );
  419.     else
  420.       graphprn ( MEMORY [address] );
  421.   }
  422.   full_screen = 0;
  423. }
  424.  
  425.  
  426.  
  427.  
  428.  
  429.  
  430.  
  431.  
  432.  
  433.   int radflg;
  434.   if (radflg = video_check(address) )
  435.   {
  436.     if (!r_w && !full_screen)
  437.     {
  438.       int y;
  439.       y = (((address - (0x0400+0x80*(radflg-1)))/40)*8)+(radflg-1);
  440.       if (!gr | (y > 19))
  441.         video_out(address,radflg);
  442.       else
  443.         graph_out(address,radflg);
  444.     }
  445.   }
  446.   else
  447.   {
  448.     /* slotdefine i/o */
  449.   }
  450. }
  451.  
  452. #endif
  453.  
  454.  
  455.  
  456. short display_page( address)   /* Return the number of area. 0 if no scrre */
  457. unsigned short int address;
  458. {
  459.   short  area;
  460.  
  461.   area = 0;
  462.   area += ((address >= 0x0400) && (address <= 0x0477)) * 1;
  463.   area += ((address >= 0x0480) && (address <= 0x04F7)) * 2;
  464.   area += ((address >= 0x0500) && (address <= 0x0577)) * 3;
  465.   area += ((address >= 0x0580) && (address <= 0x05F7)) * 4;
  466.   area += ((address >= 0x0600) && (address <= 0x0677)) * 5;
  467.   area += ((address >= 0x0680) && (address <= 0x06F7)) * 6;
  468.   area += ((address >= 0x0700) && (address <= 0x0777)) * 7;
  469.   area += ((address >= 0x0780) && (address <= 0x07F7)) * 8;
  470.  
  471.   return area;
  472. }
  473.  
  474. print_char( tecken)
  475. char tecken;
  476. {
  477.    switch (tecken >> 6)
  478.    {
  479.       case 0:    /* Invers */
  480.          printf("\233[7m");
  481.  
  482.          if ((tecken & 0x20) == 0)
  483.             tecken = (tecken & 0x3F) + 0x40;
  484.          else
  485.             tecken = (tecken & 0x3F);
  486.  
  487.          printf("%c",tecken | 0x80);
  488.          printf("\233[m");
  489.          break;
  490.  
  491.       case 1:    /* Flash */
  492.          printf("\233[5m");
  493.          if ((tecken & 0x20) == 0)
  494.             tecken = (tecken & 0x3F) + 0x40;
  495.          else
  496.             tecken = (tecken & 0x3F);
  497.  
  498.          if (tecken == 0x20)
  499.             printf("\233(2\233)2a\233(B\233)B");
  500.          else
  501.             printf("%c",tecken | 0x80);
  502.  
  503.          printf("\233[m");
  504.          break;
  505.  
  506.       case 2:   case 3:   /* Control / Normal */
  507.          if (tecken < 0xA0)
  508.          {
  509.             /* ctrl */
  510.             printf(".");
  511.          }
  512.  
  513.          else
  514.          {
  515.             /* norm */
  516.             printf("%c",tecken | 0x80);
  517.          }
  518.          break;
  519.    }  /* End of switch (tecken >> 6) */
  520.  
  521. }
  522.  
  523. clear_screen()
  524. {
  525.    short x_led,
  526.          y_led;
  527.  
  528.    cls();
  529.  
  530.    for (y_led = 1;y_led < 25;y_led ++)
  531.    {
  532.       for (x_led = 1;x_led <= 40;x_led ++)
  533.       {
  534.          dub_screen [0][x_led + y_led * 40] = 0xA0;
  535.          dub_screen [1][x_led + y_led * 40] = 0xA0;
  536.       }
  537.    }
  538. }
  539.  
  540. init_screen()
  541. {
  542.  
  543.    dub_screen [0] = (char *) malloc( sizeof( short) * 1000);
  544.    dub_screen [1] = (char *) malloc( sizeof( short) * 1000);
  545.  
  546.    clear_screen();
  547. }
  548.  
  549. move_print( x_led, y_led, charackter)
  550. short x_led,
  551.       y_led;
  552. char  charackter;
  553. {
  554.    short         action;
  555.    static short  old_x = 1,
  556.                  old_y = 1;
  557.  
  558.    action = FALSE;
  559.    if ( (x_led == old_x) && (y_led == old_y) )
  560.       action = TRUE;
  561.  
  562.    if ( (x_led == old_x - 1) && (y_led == old_y) )
  563.    {
  564.       printf("\b");
  565.       action = TRUE;
  566.    }
  567.  
  568.    if ( (x_led == old_x - 2) && (y_led == old_y) )
  569.    {
  570.       printf("\b\b");
  571.       action = TRUE;
  572.    }
  573.  
  574.    if (!action)
  575.       printf("\233[%d;%df", y_led + 1, x_led + 1);
  576.  
  577.    print_char( charackter);
  578.    x_led ++;
  579.  
  580.    old_x = x_led;
  581.    old_y = y_led;
  582. }
  583.  
  584. to_video( address, area, value)
  585. unsigned short int  address;
  586. short               area,
  587.                     value;
  588. {
  589.    short x_led,
  590.          y_led;
  591.  
  592.    short temp_value;
  593.  
  594.    if (!dub_screen [0] || !dub_screen [1])
  595.       init_screen();
  596.  
  597.    x_led = (address - (0x0400+0x80*(area-1)))%40;
  598.    y_led = (((address - (0x0400+0x80*(area-1)))/40)*8)+(area-1);
  599.    dub_screen [0][x_led + y_led * 40] = value;
  600.  
  601.    if (dub_screen [0][x_led + y_led * 40] !=
  602.        dub_screen [1][x_led + y_led * 40]    )
  603.    {
  604.       if (value)
  605.          move_print( x_led, y_led, value);
  606.  
  607.       dub_screen [1][x_led + y_led * 40] = dub_screen [0][x_led + y_led * 40];
  608.    }
  609.  
  610.    /* If value == 0xFF Then this is a RAM test secvens */
  611. }
  612.  
  613. refresh( code)
  614. PM *code;
  615. {
  616.    short address,
  617.          area,
  618.          x_led,
  619.          y_led;
  620.  
  621.    if (!dub_screen [0] || !dub_screen [1])
  622.       init_screen();
  623.    else
  624.       clear_screen();
  625.  
  626.    for (address = 0x400;address < 0x0800;address ++)
  627.    {
  628.       if (area = display_page( address) )
  629.       {
  630.          x_led = (address - (0x0400+0x80*(area-1)))%40;
  631.          y_led = (((address - (0x0400+0x80*(area-1)))/40)*8)+(area-1);
  632.  
  633.          to_video( address, area, code->Me [address]);
  634.       }
  635.    }
  636. }
  637.  
  638.