home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1997 March / VPR9703A.ISO / VPR_DATA / DOGA / SOURCES / POLYEDIT.LZH / MODEL / GRAPHX.C < prev    next >
C/C++ Source or Header  |  1996-03-27  |  7KB  |  431 lines
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4. #include <doslib.h>
  5. #include <iocslib.h>
  6. #include "graph.h"
  7.  
  8. int        Cols, Lines ;
  9. int        FontH = 8, FontV = 16 ;
  10. extern    void    TextLine( int, int, int, int, int );
  11. extern    void    TextFill( int, int, int, int, int );
  12.  
  13. void    graph_init()
  14. {
  15.     int        i ;
  16.  
  17.     CRTMOD( 16 );
  18.     B_CLR_AL();
  19.     C_WIDTH( 0 );
  20.     C_FNKMOD( 0 );
  21.     LEDMOD( 4, 1 );
  22.     G_CLR_ON();
  23.  
  24.     Lines = 32 ;
  25.     Cols = 96 ;
  26.  
  27.     for (i = 0; i < 8; ++i) {
  28.         graph_palet(i, (i&4) ? 255 : 0, (i&2) ? 255 : 0, (i&1) ? 255 : 0);
  29.     }
  30. }
  31.  
  32. void    graph_exit()
  33. {
  34. }
  35.  
  36. void    graph_line( x1, y1, x2, y2, color )
  37. int     x1 ;
  38. int     y1 ;
  39. int        x2 ;
  40. int        y2 ;
  41. int        color ;
  42. {
  43.     struct    LINEPTR    lbuf ;
  44.  
  45.     if ( color < 16 )
  46.     {
  47.         lbuf.x1 = x1 ;
  48.         lbuf.x2 = x2 ;
  49.         lbuf.y1 = y1 ;
  50.         lbuf.y2 = y2 ;
  51.         lbuf.color = color ;
  52.         lbuf.linestyle = 0xffff ;
  53.         LINE( &lbuf );
  54.     }
  55.     else
  56.     {
  57.         TextLine( x1, y1, x2, y2, color-16 );
  58.     }
  59. }
  60.  
  61. void    graph_dashline( x1, y1, x2, y2, color )
  62. int     x1 ;
  63. int     y1 ;
  64. int        x2 ;
  65. int        y2 ;
  66. int        color ;
  67. {
  68.     struct    LINEPTR    lbuf ;
  69.  
  70.     if ( color < 16 )
  71.     {
  72.         lbuf.x1 = x1 ;
  73.         lbuf.x2 = x2 ;
  74.         lbuf.y1 = y1 ;
  75.         lbuf.y2 = y2 ;
  76.         lbuf.color = color ;
  77.         lbuf.linestyle = 0xcccc ;
  78.         LINE( &lbuf );
  79.     }
  80.     else
  81.     {
  82.         TextLine( x1, y1, x2, y2, color-16 );
  83.     }
  84. }
  85.  
  86. void    graph_cls( color )
  87. int        color ;
  88. {
  89.     graph_fill( 0, 0, 768, 512, color );
  90. }
  91.  
  92. void    graph_fill( x1, y1, x2, y2, color )
  93. int        x1 ;
  94. int        y1 ;
  95. int        x2 ;
  96. int        y2 ;
  97. int        color ;
  98. {
  99.     struct    FILLPTR    fbuf ;
  100.  
  101.     if ( color < 16 )
  102.     {
  103.         fbuf.x1 = x1 ;
  104.         fbuf.x2 = x2 ;
  105.         fbuf.y1 = y1 ;
  106.         fbuf.y2 = y2 ;
  107.         fbuf.color = color ;
  108.         FILL( &fbuf );
  109.     }
  110.     else
  111.     {
  112.         TextFill( x1, y1, x2, y2, color-16 );
  113.     }
  114. }
  115.  
  116. void    graph_palet( paletmode, g, r, b )
  117. int        paletmode ;
  118. int        g, r, b ;
  119. {
  120.     int    color ;
  121.  
  122.     color = ( ( g >> 3 ) << 11 ) | ( ( r >> 3 ) << 6 ) | ( ( b >> 3 ) << 1 );
  123.     GPALET( paletmode, color );
  124. }
  125.  
  126. void    graph_puts( str, x, y, atr )
  127. char    *str ;
  128. int        x, y ;
  129. int        atr ;
  130. {
  131.     int        len ;
  132.     int        i, j, k ;
  133.     char    *src ;
  134.     short    *dst ;
  135.     int        fg, bg, pat ;
  136.     int        sp ;
  137.  
  138.     len = strlen( str );
  139.     if ( len <= 0 )
  140.         return ;
  141.  
  142.     B_PUTMES( 3, 0, 63, len-1, (UBYTE*)str );
  143.  
  144.     if ( len <= 0 )
  145.         return ;
  146.  
  147.     fg = atr & 0xf ;
  148.     bg = ( atr >> 4 ) & 0x0f;
  149.  
  150.     dummy_label1:
  151.     sp = SUPER( 0 );
  152.     dummy_label2:
  153.  
  154.     for( i = 0 ; i < 16 ; i++ )
  155.     {
  156.         src = (char*)0xE00000 + ( 63 * 16 + i ) * ( 1024 / 8 ) ;
  157.         dst = (short*)0xC00000 + ( y + i ) * 1024 + x ;
  158.         for( j = 0 ; j < len ; j++ )
  159.         {
  160.             pat = *src++ ;
  161.             for( k = 0 ; k < 8 ; k++ )
  162.             {
  163.                 if ( pat & 0x80 )
  164.                     *dst++ = fg ;
  165.                 else if ((atr & 0x100) == 0)
  166.                     *dst++ = bg ;
  167.                 else
  168.                     dst++;
  169.                 pat <<= 1 ;
  170.             }
  171.         }
  172.     }
  173.  
  174.     dummy_label3:
  175.     SUPER( sp );
  176. }
  177.  
  178. void    graph_pattern( x, y, color, pat, h, v )
  179. int        x, y ;
  180. int        color ;
  181. short    *pat ;
  182. int        h, v ;
  183. {
  184.     int        i, j, k ;
  185.     int        a, hh, hword ;
  186.     int        fg, bg ;
  187.     short    *gram ;
  188.     int        sp ;
  189.  
  190.     fg = color & 0xf ;
  191.     bg = ( color >> 4 );
  192.  
  193.     hword = ( h + 15 ) / 16 ;
  194.  
  195.     dummy_label1:
  196.     sp = SUPER( 0 );
  197.     dummy_label2:
  198.     for( i = 0 ; i < v ; i++ )
  199.     {
  200.         gram = (short*)0xC00000 + ( y + i ) * 1024 + x ;
  201.         hh = h ;
  202.         for( j = 0 ; j < hword ; j++ )
  203.         {
  204.             a = *pat++ ;
  205.             for( k = 0 ; k < 16 && k < hh ; k++ )
  206.             {
  207.                 if ( a & 0x8000 )
  208.                     *gram++ = fg ;
  209.                 else
  210.                     *gram++ = bg ;
  211.                 a <<= 1 ;
  212.             }
  213.             hh -= 16 ;
  214.         }
  215.     }
  216.     dummy_label3:
  217.     SUPER( sp );
  218. }
  219.  
  220. /*    ボタン表示    */
  221. void    graph_box( x1, y1, x2, y2, sw )
  222. int        x1, y1, x2, y2 ;
  223. int        sw ;
  224. {
  225.     if ( sw )
  226.     {
  227.         graph_line( x1, y1, x2, y1, 7 );
  228.         graph_fill( x1, y1, x1+1, y2, 7 );
  229.         graph_line( x1, y2, x2, y2, 0 );
  230.         graph_line( x2, y1, x2, y2, 0 );
  231.     }
  232.     else
  233.     {
  234.         graph_line( x1, y1, x2, y1, 0 );
  235.         graph_line( x1, y1, x1, y2, 0 );
  236.         graph_line( x1, y2, x2, y2, 7 );
  237.         graph_fill( x2, y1, x2+1, y2, 7 );
  238.     }
  239. }
  240.  
  241. #if 0
  242. static unsigned char *ap;
  243. static int    xpos, ypos, xlen, ylen ;
  244.  
  245. int graph_push(int xp, int yp, int xl, int yl)
  246. {
  247.     int    sz, sp, x, y, n=0 ;
  248.     unsigned short *gram = ((unsigned short *)(0xc00000)) + yp * 1024 + xp;
  249.     unsigned char *buf;
  250.     xpos = xp;
  251.     ypos = yp;
  252.     xlen = xl;
  253.     ylen = yl;
  254.  
  255.     sz = xlen * ylen;
  256.     if (ap != NULL) {
  257.         free(ap);
  258.     }
  259.     ap = malloc(sz) ;
  260.     if (ap != NULL) {
  261.         buf = ap;
  262.         dummy_label_1:
  263.         sp = SUPER(0) ;
  264.         dummy_label_2:
  265.         for (y = ylen ; y > 0 ; --y) {
  266.             for(x = xlen ; x > 0; --x) {
  267.                 *buf++ = *gram++;
  268.             }
  269.             gram += 1024 - xlen;
  270.         }
  271.         dummy_label_3:
  272.         SUPER(sp) ;
  273.         dummy_label_4:
  274.         return TRUE;
  275.     }
  276.     return FALSE;
  277. }
  278.  
  279. int graph_pop(void)
  280. {
  281.     int    sz, sp, x, y, n=0 ;
  282.     unsigned short *gram = ((unsigned short *)(0xc00000)) + ypos * 1024 + xpos;
  283.     unsigned char *buf;
  284.  
  285.     if (ap != NULL) {
  286.         buf = ap;
  287.         dummy_label_1:
  288.         sp = SUPER(0) ;
  289.         dummy_label_2:
  290.         for (y = ylen ; y > 0 ; --y) {
  291.             for(x = xlen ; x > 0; --x) {
  292.                 *gram++ = (unsigned short)*buf++;
  293.             }
  294.             gram += 1024 - xlen;
  295.         }
  296.         dummy_label_3:
  297.         SUPER(sp) ;
  298.         dummy_label_4:
  299.         free(ap);
  300.         ap = NULL;
  301.         return TRUE;
  302.     }
  303.     return FALSE;
  304. }
  305.  
  306. #endif
  307. static unsigned char *gp;
  308. static int    xpos, ypos, xlen, ylen ;
  309.  
  310. static unsigned long *tp;
  311. static int txpos, txlen;
  312.  
  313. int graph_push(int xp, int yp, int xl, int yl)
  314. {
  315.     int    sz, sp, x, y, n=0, i ;
  316.     unsigned short *gram = ((unsigned short *)(0xc00000)) + yp * 1024 + xp;
  317.     unsigned char *buf;
  318.     unsigned long *tram, *tbuf;
  319.  
  320.     txpos = xp / 32;
  321.     txlen = ((xp+xl) / 32) - txpos + 1;
  322.  
  323.     xpos = xp;
  324.     ypos = yp;
  325.     xlen = xl;
  326.     ylen = yl;
  327.  
  328.     sz = xlen * ylen;
  329.     if (gp != NULL) {
  330.         free(gp);
  331.     }
  332.     if (tp != NULL) {
  333.         free(tp);
  334.     }
  335.     gp = malloc(sz) ;
  336.     tp = malloc(4 * txlen * ylen * sizeof(long));
  337.     if (gp != NULL && tp != NULL) {
  338.         dummy_label_1:
  339.         sp = SUPER(0) ;
  340.         dummy_label_2:
  341.  
  342.         buf = gp;
  343.         for (y = ylen ; y > 0 ; --y) {
  344.             for(x = xlen ; x > 0; --x) {
  345.                 *buf++ = *gram++;
  346.             }
  347.             gram += 1024 - xlen;
  348.         }
  349.         MS_CUROF();
  350.         tbuf = tp;
  351.  
  352.         for (i = 0; i < 4; ++i) {
  353.             tram = ((unsigned long*)(0xe00000)) + i * 32 * 1024 + ypos * 32 + txpos;
  354.             for (y = ylen; y > 0; --y) {
  355.                 for (x = txlen; x > 0; --x) {
  356.                     *tbuf++ = *tram++;
  357.                 }
  358.                 tram += 32 - txlen;
  359.             }
  360.         }
  361.         MS_CURON();
  362.  
  363.         dummy_label_3:
  364.         SUPER(sp) ;
  365.         dummy_label_4:
  366.         return TRUE;
  367.     }
  368.     return FALSE;
  369. }
  370.  
  371. int graph_pop(void)
  372. {
  373.     int    sz, sp, x, y, n=0, i ;
  374.     unsigned short *gram = ((unsigned short *)(0xc00000)) + ypos * 1024 + xpos;
  375.     unsigned long *tram = ((unsigned long*)(0xe00000)) + ypos * 32 + txpos;
  376.     unsigned char *buf;
  377.     unsigned long *tbuf;
  378.  
  379.     if (gp != NULL && tp != NULL) {
  380.  
  381.         dummy_label_1:
  382.         sp = SUPER(0) ;
  383.         dummy_label_2:
  384.  
  385.         buf = gp;
  386.         for (y = ylen ; y > 0 ; --y) {
  387.             for(x = xlen ; x > 0; --x) {
  388.                 *gram++ = (unsigned short)*buf++;
  389.             }
  390.             gram += 1024 - xlen;
  391.         }
  392.  
  393.         MS_CUROF();
  394.         tbuf = tp;
  395. /*printf("begin tp = %08x\n", tp);*/
  396.         for (i = 0; i < 4; ++i) {
  397.             tram = ((unsigned long*)(0xe00000)) + i * 32 * 1024 + ypos * 32 + txpos;
  398. /*printf("(%d,%d):(%d,%d)-> %d:%d : %08x\n", xpos, ypos, xlen, ylen, txpos, txlen, tram);*/
  399.             for (y = ylen; y > 0; --y) {
  400.                 for (x = txlen; x > 0; --x) {
  401.                     *tram++ = *tbuf++;
  402.                 }
  403.                 tram += 32 - txlen;
  404.             }
  405.         }
  406.         MS_CURON();
  407.  
  408.         dummy_label_3:
  409.         SUPER(sp) ;
  410.         dummy_label_4:
  411.  
  412.         free(gp);
  413.         gp = NULL;
  414.  
  415.         free(tp);
  416.         tp = NULL;
  417.  
  418.         return TRUE;
  419.     }
  420.     return FALSE;
  421. }
  422.  
  423. int graph_buffer_start(void)
  424. {
  425.     return FALSE;
  426. }
  427.  
  428. void graph_buffer_end(void)
  429. {
  430. }
  431.