//
//  glFont.m
//  CGL
//
//  Created by kat on Sat Jun 15 2002.
//  Copyright (c) 2001 Katherine Tattersall. All rights reserved.
//

#import "NSGLFont.h"
#define PI		3.141592653589793238462643383280


@implementation NSGLFont

-(id) initFont: (NSString *)fontname atSize:(int)size
{
    CGContextRef cg_context;	// we do not need to keep a cg_context: only the data needs to be kept
    size_t bytesPerRow;		// at least (width * bitsPerComponent * number of components + 7)/8
    CGColorSpaceRef colorspace;	// create with CGColorSpaceCreateDevice... functions
    CGImageAlphaInfo alphaInfo;	// see CGImage for valid enum constants
    size_t bitsPerComponent;	// must be 1,2,4 or 8
    size_t num;			// number of components
    const char *c_fontname;
    int i;
    // the first character we will need to draw is a ' '. The c-string of this is a space with a null terminator
    char jstr[2] = { ' ', '\0' };
 
    max_height = 8;
    max_width  = 8;
    c_fontname = [fontname cString];
    font = [NSFont fontWithName:fontname size:size];
    if( font == nil ) return nil;
    NSLog(@"font is being initialized");
    [font retain];

    // get tthe minimum width and height for the data for the characters
    while( max_width  < [font maximumAdvancement].width )
        max_width += 8;
    while( max_height < [font defaultLineHeightForFont] )
        max_height += 8;
 
    // CGContexts in grey space are all 8 bits
    bitsPerComponent = 8;
    // Gray color space is chosen here only because it is easy to convert to a bitmap
    colorspace       = CGColorSpaceCreateDeviceGray();
    // We do not need any alpha information
    alphaInfo        = kCGImageAlphaNone;
    // we need to ensure that we have the correct number of componants in the colorspace ( exactly 1 )
    num              = CGColorSpaceGetNumberOfComponents(colorspace);
    // we now generate max_chars contiguous lists
    base = glGenLists( max_chars );
    
    // if any of the operations above have failed, we should not continue
    if( colorspace != nil)
        // to use the font, we'll need an unpack alignment of 1
        // otherwise we'll get lines or other wierd things (but not the font)
        glPixelStorei( GL_UNPACK_ALIGNMENT,   1   );

        for( i = 0; i < max_chars ; i++ ) // each character
        {
            height[i] = max_height; // we need to have a multiple of 8 in order to use my convertBitmap method
            width[i]  = max_width ; 
    
            // width* number of componants: should be 1 componant for CGColorSpaceCreateDeviceGray()
            bytesPerRow  = width[i]*num;

            // must use CALLOC <- if not, memory may not be empty, leading to strange results in the drawings
            // space must be at least (bytesPerRow * height)
            data[i] = (void *) calloc( bytesPerRow, height[i] );
            if( data[i] != nil ) // calloc was successful
            {
                // create the context
                cg_context = CGBitmapContextCreate(data[i], width[i], height[i], bitsPerComponent, 
                                                    bytesPerRow, colorspace, alphaInfo);
                if( cg_context != nil ) {
                    // x_offset is the width of the character (null terminated cString to NSString) + a bit of space
                    // I don't know what this "bit of space" is called or I might be able to get it better
                    x_offset[i] = (unsigned int)[font widthOfString: [NSString stringWithCString: jstr]] + 1;
                    // draw the current letter
                    [self drawLetter:jstr[0] context:cg_context atx:0 withFont:c_fontname atSize:size];
                    CGContextRelease(cg_context);
                }
                else NSLog(@"NSGLFont init ERROR: Didn't create CGContext[%d]",i);
            }
            // create a BITMAP (as opposed to the Apple BYTEMAP CGBitmapContextRef)
            [self convertBitmap:i];
            jstr[0]++;
            glNewList( base+i,GL_COMPILE);			// compile the following
                glBitmap(width[i],height[i],0,0,x_offset[i],0,data[i]);
            glEndList();
        }
    return self;
}


-(void) drawLetter:(char) ch context: (CGContextRef)cg_context atx:(int)xpos 
            withFont:(const char *)fontname atSize:(int)size
{
    // OpenGL will draw these upside down if we don't do this
    CGContextTranslateCTM( cg_context, 0, max_height );
    CGContextScaleCTM( cg_context, 1.0,-1.0);
    
    // set the gray fill color to 1,1 which will make the bitmap work properly
    CGContextSetGrayFillColor(cg_context, 1.0, 1.0);

    // if you're doing a glDrawPixel, then leave this on
    // using glBitmap means converting to a bit image, and antialiasing that doesn't really work
    CGContextSetShouldAntialias(cg_context, 0 ); 

    // some fonts don't work very well, like "Courier"
    // they are drawn very strangely
    CGContextSelectFont(cg_context, fontname, size, kCGEncodingMacRoman );
    CGContextSetTextDrawingMode(cg_context, kCGTextFill);

    // draw exactly one glyph into the context 
    CGContextShowTextAtPoint(cg_context, xpos, -[font descender], &ch, 1);
}

// clean up the memory
-(void) dealloc
{
    int i;
    for( i=0; i<max_chars; i++ )
        free(data[i]);
    glDeleteLists(base,max_chars);
    [font release];
    [super dealloc];
}

// this method will write an NSString to the OpenGL context
-(void) writeString: (NSString *)s
{
    const char *c_str;
    GLboolean tex2d;
    
    glGetBooleanv( GL_TEXTURE_2D, &tex2d );
    glDisable(GL_TEXTURE_2D);

    c_str = [s cString];
    glPushAttrib(GL_LIST_BIT);
    glListBase(base-' '); // 97='a'
    glCallLists( [s cStringLength], GL_UNSIGNED_BYTE, c_str);
    glPopAttrib();

    if(tex2d ) 
        glEnable(GL_TEXTURE_2D);
}

//	Apple is good, Apple is great, but it looks like Apple didn't give us any way to access pure bitmaps 
// 	(ie, maps of BITS, not BYTES )
//	Here is a function to convert my data (as written to by CGBitmapContextRef) into a real bitmap 
-(void) convertBitmap: (int) number
{
    int i;
    int new_width, new_height;
    char *newdata;
    char *olddata = data[number];

    // the new width in BYTES = old width(in bytes) / 8 (number of bits in a byte)
    new_width = width[number]/8;
    new_height = height[number];

    if( width[number]%8 ) { NSLog(@"Invalid width: w=%d", width[number]); return; }

    // you can use malloc or calloc here, because we will be writing over anything in here anyways
    newdata = malloc( new_width*new_height );

    if( newdata != nil ) // make sure the newdata was successfully allocated
    {

        //    For each NEW BYTE, I want to have
        //        1st bit from byte 1
        //        2nd bit from byte 2
        //        3rd bit from byte 3 ... etc
        for( i=0; i<new_width*new_height; i++ ) // There are new_width*h NEW BYTES in newdata, and w*h OLD BYTES in olddata
            {
                int j = i*8;
                newdata[i]=0;
                // to get an all 1's bitmap, we would use
                //   newdata[i] = 1+2+4+8+16+32+64+128;
                // we want the data from the olddata though, so...
                if( (olddata[j+7])%2   != 0) newdata[i] += 1;
                if( (olddata[j+6])%4   != 0) newdata[i] += 2;
                if( (olddata[j+5])%8   != 0) newdata[i] += 4;
                if( (olddata[j+4])%16  != 0) newdata[i] += 8;
                if( (olddata[j+3])%32  != 0) newdata[i] += 16;
                if( (olddata[j+2])%64  != 0) newdata[i] += 32;
                if( (olddata[j+1])%128 != 0) newdata[i] += 64;
                if( (olddata[j+0])%256 != 0) newdata[i] += 128;
            }
        free( olddata ); 	// we're not going to keep the old stuff if the new bitmap was created successfully
        data[number] = newdata; // we will be storing the new bitmap instead
    }
    else { NSLog(@"allocation error"); }
}


@end

// write to the screen using font f at location x,y with the specified string
void glPrint( NSGLFont *f, float x, float y, const char *fmt, ... )
{
    char	text[256];
    va_list	ap;
    NSString    *s;
    GLboolean tex2d, light;

    // I always get a SIGSEGV 11 when glRasterPos* is called with textures off and lighting on
    // so here I turn them off.
    glGetBooleanv( GL_TEXTURE_2D, &tex2d ); 	glDisable(GL_TEXTURE_2D);
    glGetBooleanv( GL_LIGHTING, &light );	glDisable(GL_LIGHTING);

    if( fmt == NULL ) return;
    // format the string into (char *) text
    va_start( ap, fmt );
        vsprintf( text, fmt, ap );
    va_end(ap);
    
    // RasterPos to the correct location
    // um, I took this out because I didn't want to modify some other code where 
    // I've already rastered and so on
//   glRasterPos2f(x, y);

    // create an NSString
    s = [NSString stringWithCString: text];

    // write the string
    [f writeString: s ];
 
    // enable as required
    if( tex2d ) glEnable(GL_TEXTURE_2D);
    if( light ) glEnable(GL_LIGHTING);

}