Subversion Repositories planix.SVN

#include <u.h>
#include <libc.h>
#include <draw.h>
#include <memdraw.h>

Memsubfont*
getmemdefont(void)
{
        char *hdr, *p;
        int n;
        Fontchar *fc;
        Memsubfont *f;
        int ld;
        Rectangle r;
        Memdata *md;
        Memimage *i;

        /*
         * make sure data is word-aligned.  this is true with Plan 9 compilers
         * but not in general.  the byte order is right because the data is
         * declared as char*, not ulong*.
         */
        p = (char*)defontdata;
        n = (uintptr)p & 3;
        if(n != 0){
                memmove(p+(4-n), p, sizeofdefont-n);
                p += 4-n;
        }
        ld = atoi(p+0*12);
        r.min.x = atoi(p+1*12);
        r.min.y = atoi(p+2*12);
        r.max.x = atoi(p+3*12);
        r.max.y = atoi(p+4*12);

        md = mallocz(sizeof(Memdata), 1);
        if(md == nil)
                return nil;
        
        p += 5*12;

        md->base = nil;         /* so freememimage doesn't free p */
        md->bdata = (uchar*)p;  /* ick */
        md->ref = 1;
        md->allocd = 1;         /* so freememimage does free md */

        i = allocmemimaged(r, drawld2chan[ld], md);
        if(i == nil){
                free(md);
                return nil;
        }

        hdr = p+Dy(r)*i->width*sizeof(ulong);
        n = atoi(hdr);
        p = hdr+3*12;
        fc = malloc(sizeof(Fontchar)*(n+1));
        if(fc == 0){
                freememimage(i);
                return 0;
        }
        _unpackinfo(fc, (uchar*)p, n);
        f = allocmemsubfont("*default*", n, atoi(hdr+12), atoi(hdr+24), fc, i);
        if(f == 0){
                freememimage(i);
                free(fc);
                return 0;
        }
        return f;
}