Return to rotate.c CVS log

Up to [Research Unix] / researchv10no / cmd / dimpress

Annotation of researchv10no/cmd/dimpress/rotate.c, revision 1.1

1.1     ! root        1: 
        !             2: /*
        !             3:  *
        !             4:  * Things needed to rotate glyphs. Includes setting new reference point,
        !             5:  * bitmap dimensions, and filling in the new bitmap.
        !             6:  *
        !             7:  */
        !             8: 
        !             9: 
        !            10: #include <stdio.h>
        !            11: 
        !            12: #include "gen.h"                       /* a few general definitions */
        !            13: #include "rast.h"                      /* for definition of Glyph */
        !            14: #include "rotate.h"                    /* rotation macros */
        !            15: 
        !            16: 
        !            17: /*
        !            18:  *
        !            19:  * These guys are used in the translation and rotation macros defined
        !            20:  * in rotate.h.
        !            21:  *
        !            22:  */
        !            23: 
        !            24: 
        !            25: int    cosine[ROT_COUNT] = {1, 0, -1, 0};
        !            26: int    sine[ROT_COUNT] = {0, 1, 0, -1};
        !            27: int    delta[ROT_COUNT] = {1, 0, 0, 0};
        !            28: 
        !            29: 
        !            30: char   *bptr = NULL;                   /* last rotated bitmap */
        !            31: 
        !            32: 
        !            33: /*****************************************************************************/
        !            34: 
        !            35: 
        !            36: rotate(glyph, angle)
        !            37: 
        !            38: 
        !            39:     Glyph      *glyph;                 /* rotate this glyph */
        !            40:     int                angle;                  /* to this orientation */
        !            41: 
        !            42: 
        !            43: {
        !            44: 
        !            45: 
        !            46:     Glyph      oglyph;                 /* old glyph data */
        !            47:     int                orwid;                  /* rows in the old bitmap */
        !            48:     int                nrwid;                  /* same but for the new bitmap */
        !            49:     int                mapsize;                /* byte size of the new map */
        !            50:     int                i, j;                   /* coordinates in the old bitmap */
        !            51:     int                x, y;                   /* same but in the new bitmap */
        !            52: 
        !            53: 
        !            54: /*
        !            55:  *
        !            56:  * Called when we want to rotate glyph to an orientation of angle, where
        !            57:  * angle should be 0, 1, 2, or 3. I decided against using a complete set
        !            58:  * of raster files that had already been rotated in favor of doing the work
        !            59:  * at run time. Really don't expect this stuff to be used that much and
        !            60:  * we've already got too many raster files around.
        !            61:  *
        !            62:  */
        !            63: 
        !            64: 
        !            65:     if ( angle == 0 ) return;          /* everything's already done */
        !            66: 
        !            67:     oglyph = *glyph;                   /* we'll need most of the old values */
        !            68: 
        !            69:     glyph->xref = NEWX(oglyph.xref, oglyph.yref, oglyph.height, oglyph.width, angle);
        !            70:     glyph->yref = NEWY(oglyph.xref, oglyph.yref, oglyph.height, oglyph.width, angle);
        !            71:     glyph->width = (angle % 2) ? oglyph.height : oglyph.width;
        !            72:     glyph->height = (angle % 2) ? oglyph.width : oglyph.height;
        !            73: 
        !            74:     if ( bptr != NULL )
        !            75:        free(bptr);
        !            76: 
        !            77:     mapsize = ((glyph->width + BYTE - 1) / BYTE) * glyph->height;
        !            78:     if ( (bptr = (char *) calloc(mapsize, sizeof(char))) == NULL )
        !            79:        error(FATAL, "can't get memory for bitmap");
        !            80: 
        !            81:     orwid = (oglyph.width + BYTE - 1) / BYTE;
        !            82:     nrwid = (glyph->width + BYTE - 1) / BYTE;
        !            83: 
        !            84:     for ( j = 0; j < oglyph.height; j++ )
        !            85:        for ( i = 0; i < oglyph.width; i++ )
        !            86:            if ( checkbit(oglyph.bptr, orwid * j * BYTE + i) )  {
        !            87:                x = NEWX(i, j, oglyph.height, oglyph.width, angle);
        !            88:                y = NEWY(i, j, oglyph.height, oglyph.width, angle);
        !            89:                setbit(bptr, nrwid * y * BYTE + x);
        !            90:            }   /* End if */
        !            91: 
        !            92:     glyph->bptr = bptr;
        !            93: 
        !            94: }   /* End of rotate */
        !            95: 
        !            96: 
        !            97: /*****************************************************************************/
        !            98: 
        !            99: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.