diff options
Diffstat (limited to 'generic')
| -rw-r--r-- | generic/Image.c | 1562 |
1 files changed, 1023 insertions, 539 deletions
diff --git a/generic/Image.c b/generic/Image.c index 52ba2eb..3ef66b4 100644 --- a/generic/Image.c +++ b/generic/Image.c @@ -45,240 +45,642 @@ static const char rcsid[] = "$Id$"; static const char compile_id[] = "$Compile: " __FILE__ " " __DATE__ " " __TIME__ " $"; -/* - * Key used to index the bitmap_masks hash table. - */ -typedef struct { - Display *dpy; - Pixmap bitmap; -} BitmapKey; - -typedef struct _ImagePixmap { - Display *dpy; - Pixmap pixmap; - Pixmap mask_pmap; - struct _ImagePixmap *next; -} ImagePixmap; - -static int image_bits_inited = 0; -static Tcl_HashTable image_bits; -static Tcl_HashTable bitmap_masks; +static int images_inited = 0; +static Tcl_HashTable images; #ifdef GLX static Tcl_HashTable font_textures; #endif +typedef struct _ImageStruct { + union { + struct { + Pixmap pixmap; + Pixmap mask_pmap; + Display *dpy; + } x; + struct { + GLuint texobj; + struct _WidgetInfo *wi; + } gl; + } i; + struct _ImageBits *bits; + + /* Bookkeeping */ + + ZnBool for_gl; + int refcount; + struct _ImageStruct *next; +} ImageStruct, *Image; + + +typedef struct _ImageBits { + int width; + int height; + unsigned char *bpixels; /* Needed at least to know the bounds (Pick), or if + * the image is a bitmap. Can be NULL if no mask is + * defined for the image (i.e the image is + * rectangular) and the image is not a bitmap. */ + int rowstride; +#ifdef GLX + ZnReal t; /* Texture parameters for the image. */ + ZnReal s; +#endif + + /* Bookeeping */ + + Tcl_HashEntry *hash; /* From this it is easy to get the image/bitmap + * name. */ + XImage *ipixels; /* Keep this to create textures and pixmaps as + * needed. NULL if the image is a bitmap. This + * can be tested to tell if this is an image or + * a bitmap. */ + XImage *mask; /* Keep this to build special clip mask in X (Icon). + * Can be NULL if no mask is defined for the image + * (i.e the image is rectangular) or if the image + * is a bitmap. */ +#ifdef GLX + int t_width; /* Texture size used for this image. */ + int t_height; + unsigned char *t_bits; /* Can be NULL if texture is not used (no GL + * rendering active on this image). */ +#endif + Image images; /* Linked list of widget/display dependant + * specializations of this image. If NULL, the + * image has no specialization and can be freed. */ +} ImageBits; + + +/* + * Working only for 16 bits displays with 5r6g5b mask, + * and 24/32 bits displays. Byte ordering ok on Intel + * plateform only. + */ +static void +From5r6g5b(unsigned char *data, + int width, + int height, + int bytes_per_line, + int t_width, + int t_height, + unsigned char *bpixels, + int bstride, + unsigned char *t_bits) +{ + int x, y; + int rowstride = t_width * 4; + unsigned char *obptr; + unsigned char *bptr, *bp2; + unsigned char alpha; + unsigned short temp; + + bptr = t_bits; + + for (y = 0; y < height; y++) { + bp2 = bptr; + obptr = data; + for (x = 0; x < width; x++) { + /* + * Configure the alpha value. + */ + alpha = ZnGetBitmapPixel(bpixels, bstride, x, y) ? 255 : 0; + + /* + * Dispatch the 3 color components. + */ + temp = ((unsigned short *)obptr)[0]; + *bp2 = (temp >> 8) & 0xf8; /* r */ + bp2++; + *bp2 = (temp >> 3) & 0xfc; /* v */ + bp2++; + *bp2 = (temp << 3); /* b */ + bp2++; + *bp2 = alpha; + bp2++; + obptr += 2; + } + for (x = width; x < t_width; x++) { + *bp2 = 0; + bp2++; + *bp2 = 0; + bp2++; + *bp2 = 0; + bp2++; + *bp2 = 0; + bp2++; + } + bptr += rowstride; + data += bytes_per_line; + } + for (y = height; y < t_height; y++) { + memset(bptr, 0, rowstride); + bptr += rowstride; + } +} + +static void +From8r8g8b(unsigned char *data, + int width, + int height, + int bytes_per_line, + int t_width, + int t_height, + unsigned char *bpixels, + int bstride, + unsigned char *t_bits) +{ + int x, y; + int rowstride = t_width * 4; + unsigned char *obptr; + unsigned char *bptr, *bp2; + unsigned char alpha; + + bptr = t_bits; + + for (y = 0; y < height; y++) { + bp2 = bptr; + obptr = data; + for (x = 0; x < width; x++) { + /* + * Configure the alpha value. + */ + if (bpixels) { + alpha = ZnGetBitmapPixel(bpixels, bstride, x, y) ? 255 : 0; + } + else { + alpha = 255; + } + + /* + * Dispatch the 3 color components. + * Be careful the Red and Blue are swapped it works on an Intel + * plateform but may need some more tests to be fully generic. + */ + *bp2++ = obptr[2]; /* r */ + *bp2++ = obptr[1]; /* v */ + *bp2++ = obptr[0]; /* b */ + obptr += 4; + *bp2++ = alpha; + } + for (x = width; x < t_width; x++) { + *bp2 = 0; + bp2++; + *bp2 = 0; + bp2++; + *bp2 = 0; + bp2++; + *bp2 = 0; + bp2++; + } + bptr += rowstride; + data += bytes_per_line; + } + for (y = height; y < t_height; y++) { + memset(bptr, 0, rowstride); + bptr += rowstride; + } +} + +static int +To2Power(int a) +{ + int result = 1; + + while (result < a) { + result *= 2; + } + return result; +} + + /* ********************************************************************************** * - * ValidateImage -- - * Make sure an image is ok for use in an attribute - * and do any needed housekeeping. + * ZnGetImage -- * ********************************************************************************** */ -int -ValidateImage(WidgetInfo *wi, - void *item_or_field, - char *image_name, - Tk_ImageChangedProc *image_proc, - Tk_Image *image_ref, - char *msg) +static void +InvalidateImage(ClientData client_data, + int x, + int y, + int width, + int height, + int image_width, + int image_height) { - Tk_Image image; - int w, h, status = ZN_OK; + /* + * Void stub that keeps the Tk image mecanism happy. Zinc does + * _not_ implement image update. + */ +} + +static void +GatherImageBits(WidgetInfo *wi, + Tk_Image tkimage, + ImageBits *bits) +{ + Pixmap pmap; + int depth = DefaultDepthOfScreen(wi->screen); + int x, y; + unsigned char *line; + GC gc; + XImage *im1, *im2; + ZnBool full_mask=True; + + /* + * Nothing known about this image, collect the image bits. + */ + pmap = XCreatePixmap(wi->dpy, RootWindowOfScreen(wi->screen), + bits->width, bits->height, depth); + gc = XCreateGC(wi->dpy, pmap, 0, NULL); + XSetForeground(wi->dpy, gc, 0); + XFillRectangle(wi->dpy, pmap, gc, 0, 0, bits->width, bits->height); + Tk_RedrawImage(tkimage, 0, 0, bits->width, bits->height, pmap, 0, 0); + im1 = bits->ipixels = XGetImage(wi->dpy, pmap, 0, 0, + bits->width, bits->height, ~0L, ZPixmap); - if (strcmp(image_name, "") != 0) { - image = Tk_GetImage(wi->interp, wi->win, image_name, - image_proc, (ClientData) item_or_field); - /* - * The name will not be in sync with the image in - * these cases. - */ - if (image == NULL) { + XSetForeground(wi->dpy, gc, 1); + XFillRectangle(wi->dpy, pmap, gc, 0, 0, bits->width, bits->height); + Tk_RedrawImage(tkimage, 0, 0, bits->width, bits->height, pmap, 0, 0); + im2 = XGetImage(wi->dpy, pmap, 0, 0, bits->width, bits->height, ~0L, ZPixmap); + XFreePixmap(wi->dpy, pmap); + + /* + * The image structure can be setup locally (TODO). + */ + XFreeGC(wi->dpy, gc); + pmap = XCreatePixmap(wi->dpy, RootWindowOfScreen(wi->screen), + bits->width, bits->height, 1); + gc = XCreateGC(wi->dpy, pmap, 0, NULL); + XSetForeground(wi->dpy, gc, 0); + XFillRectangle(wi->dpy, pmap, gc, 0, 0, bits->width, bits->height); + XFreeGC(wi->dpy, gc); + bits->mask = XGetImage(wi->dpy, pmap, 0, 0, bits->width, bits->height, 1, XYPixmap); + XFreePixmap(wi->dpy, pmap); + + bits->rowstride = bits->mask->bytes_per_line; + bits->bpixels = ZnMalloc(bits->height * bits->rowstride); + memset(bits->bpixels, 0, bits->height * bits->rowstride); + line = bits->bpixels; + for (y = 0; y < bits->height; y++) { + for (x = 0; x < bits->width; x++) { + if (XGetPixel(im1, x, y) == XGetPixel(im2, x, y)) { + XPutPixel(bits->mask, x, y, 1L); + line[x >> 3] |= 0x80 >> (x & 7); + } + else { + full_mask = False; + } + } + line += bits->rowstride; + } + + XDestroyImage(im2); + if (full_mask) { + XDestroyImage(bits->mask); + bits->mask = NULL; + ZnFree(bits->bpixels); + bits->bpixels = NULL; + } +} + +static Image +GetImageInstance(WidgetInfo *wi, + ImageBits *bits) +{ + int depth = DefaultDepthOfScreen(wi->screen); + ZnBool for_gl = wi->render>0; + XGCValues values; + GC gc; + Image image; + + /* + * Try to find an image instance that fits this widget/display. + */ + for (image = bits->images; image != NULL; image = image->next) { + if (image->for_gl == for_gl) { + if (for_gl && (image->i.gl.wi == wi)) { + image->refcount++; + return image; + } + else if (!for_gl && (image->i.x.dpy == wi->dpy)) { + image->refcount++; + return image; + } + } + } + /* + * Create a new instance for this case. + */ + image = ZnMalloc(sizeof(ImageStruct)); + image->bits = bits; + image->refcount = 1; + image->for_gl = for_gl; + if (image->for_gl) { +#ifdef GLX + image->i.gl.wi = wi; + image->i.gl.texobj = 0; + } +#endif + else { + image->i.x.dpy = wi->dpy; + image->i.x.pixmap = XCreatePixmap(wi->dpy, RootWindowOfScreen(wi->screen), + bits->width, bits->height, depth); + gc = XCreateGC(wi->dpy, image->i.x.pixmap, 0, NULL); + XPutImage(wi->dpy, image->i.x.pixmap, gc, bits->ipixels, 0, 0, 0, 0, + bits->width, bits->height); + XFreeGC(wi->dpy, gc); + if (bits->mask) { + image->i.x.mask_pmap = XCreatePixmap(wi->dpy, RootWindowOfScreen(wi->screen), + bits->width, bits->height, 1); + values.foreground = 1; + values.background = 0; + gc = XCreateGC(wi->dpy, image->i.x.mask_pmap, + GCForeground|GCBackground, &values); + XPutImage(wi->dpy, image->i.x.mask_pmap, gc, bits->mask, 0, 0, 0, 0, + bits->width, bits->height); + XFreeGC(wi->dpy, gc); + } + else { + image->i.x.mask_pmap = None; + } + } + image->next = bits->images; + bits->images = image; + + return image; +} + +ZnImage +ZnGetImage(WidgetInfo *wi, + char *image_name) +{ + Tcl_HashEntry *entry; + int new; + ImageBits *bits; + Tk_Image tkimage; + + /*printf("ZnGetImage: %s\n", image_name);*/ + if (!images_inited) { + Tcl_InitHashTable(&images, TCL_STRING_KEYS); + images_inited = 1; + } + entry = Tcl_FindHashEntry(&images, image_name); + if (entry != NULL) { + /*printf("Image %s déjà connue\n", image_name);*/ + bits = (ImageBits *) Tcl_GetHashValue(entry); + } + else { + /*printf("Nouvelle Image %s\n", image_name);*/ + if (strcmp(image_name, "") == 0) { + return ZnUnspecifiedImage; + } + bits = ZnMalloc(sizeof(ImageBits)); + tkimage = Tk_GetImage(wi->interp, wi->win, image_name, + InvalidateImage, (ClientData) bits); + if (tkimage == NULL) { im_val_err: - image = ZnUnspecifiedImage; - /*Tcl_AppendResult(wi->interp, "unknown or bogus image \"", - image_name, "\" in ", msg, NULL); - status = ZN_ERROR; */ + ZnFree(bits); ZnWarning("unknown or bogus image \""); ZnWarning(image_name); - ZnWarning("\" in "); - ZnWarning(msg); - ZnWarning("\n"); - status = ZN_OK; + ZnWarning("\"\n"); + return ZnUnspecifiedImage; } else { - Tk_SizeOfImage(image, &w, &h); - if ((w == 0) || (h == 0)) { + Tk_SizeOfImage(tkimage, &bits->width, &bits->height); + if ((bits->width == 0) || (bits->height == 0)) { + Tk_FreeImage(tkimage); goto im_val_err; } } +#ifdef GLX + bits->t_bits = NULL; +#endif + bits->images = NULL; + bits->mask = NULL; + bits->bpixels = NULL; + entry = Tcl_CreateHashEntry(&images, image_name, &new); + bits->hash = entry; + Tcl_SetHashValue(entry, (ClientData) bits); } - else { - image = ZnUnspecifiedImage; - } - if (*image_ref != ZnUnspecifiedImage) { - Tk_FreeImage(*image_ref); + + if (!bits->ipixels) { + GatherImageBits(wi, tkimage, bits); + Tk_FreeImage(tkimage); } - *image_ref = image; - - return status; + return GetImageInstance(wi, bits); } - /* ********************************************************************************** * - * GetImageBits -- + * ZnGetBitmap -- * ********************************************************************************** */ -ImageBits * -GetImageBits(ZnWindow win, - char *image_name, - ZnImage image) +ZnImage +ZnGetBitmap(WidgetInfo *wi, + char *bitmap_name) { Tcl_HashEntry *entry; - XImage *im1, *im2, *mask; + ImageBits *bits; Pixmap pmap; - Display *dpy = Tk_Display(win); - int depth = Tk_Depth(win); + XImage *mask; + Image image; + ZnBool for_gl = wi->render>0; int x, y, new, width, height; unsigned char *line; - XGCValues values; - GC gc; - ImageBits *im_bits; - ZnBool full_mask=True; - /* printf("GetImageBits: %s\n", image_name);*/ - if (!image_bits_inited) { - Tcl_InitHashTable(&image_bits, TCL_STRING_KEYS); - image_bits_inited = 1; + /*printf("ZnGetBitmap: %s\n", bitmap_name);*/ + if (!images_inited) { + Tcl_InitHashTable(&images, TCL_STRING_KEYS); + images_inited = 1; } - entry = Tcl_FindHashEntry(&image_bits, image_name); + entry = Tcl_FindHashEntry(&images, bitmap_name); if (entry != NULL) { - im_bits = (ImageBits *) Tcl_GetHashValue(entry); + bits = (ImageBits *) Tcl_GetHashValue(entry); } else { - Tk_SizeOfImage(image, &width, &height); - im_bits = (ImageBits *) ZnMalloc(sizeof(ImageBits)); + pmap = Tk_GetBitmap(wi->interp, wi->win, Tk_GetUid(bitmap_name)); + if (pmap == ZnUnspecifiedImage) { + return ZnUnspecifiedImage; + } + Tk_SizeOfBitmap(wi->dpy, pmap, &width, &height); + bits = ZnMalloc(sizeof(ImageBits)); + bits->width = width; + bits->height = height; #ifdef GLX - im_bits->texture = 0; - im_bits->t_bits = NULL; + bits->t_bits = NULL; #endif - im_bits->pixmaps = NULL; - im_bits->b_bits = NULL; - pmap = XCreatePixmap(dpy, ZnWindowId(win), width, height, depth); - - values.foreground = 0; - gc = XCreateGC(dpy, pmap, GCForeground, &values); - XFillRectangle(dpy, pmap, gc, 0, 0, width, height); - Tk_RedrawImage(image, 0, 0, width, height, pmap, 0, 0); - im_bits->pixels = im1 = XGetImage(dpy, pmap, 0, 0, width, height, ~0L, ZPixmap); - im_bits->width = width; - im_bits->height = height; - - values.foreground = 1; - XChangeGC(dpy, gc, GCForeground, &values); - XFillRectangle(dpy, pmap, gc, 0, 0, width, height); - XFreeGC(dpy, gc); - Tk_RedrawImage(image, 0, 0, width, height, pmap, 0, 0); - im2 = XGetImage(dpy, pmap, 0, 0, width, height, ~0L, ZPixmap); - XFreePixmap(dpy, pmap); - - /* - * The image structure can be setup locally (TODO). - */ - pmap = XCreatePixmap(dpy, ZnWindowId(win), width, height, 1); - values.foreground = 0; - gc = XCreateGC(dpy, pmap, GCForeground, &values); - XFillRectangle(dpy, pmap, gc, 0, 0, width, height); - XFreeGC(dpy, gc); - mask = XGetImage(dpy, pmap, 0, 0, width, height, 1, XYPixmap); - XFreePixmap(dpy, pmap); - - im_bits->b_bits = (BitmapBits *) ZnMalloc(sizeof(BitmapBits)); - im_bits->b_bits->pixels = ZnMalloc(height * mask->bytes_per_line); - memset(im_bits->b_bits->pixels, 0, height * mask->bytes_per_line); - im_bits->b_bits->rowstride = mask->bytes_per_line; - im_bits->b_bits->width = width; - im_bits->b_bits->height = height; - line = im_bits->b_bits->pixels; + bits->images = NULL; + bits->mask = NULL; + bits->bpixels = NULL; + bits->ipixels = NULL; + mask = XGetImage(wi->dpy, pmap, 0, 0, width, height, 1L, XYPixmap); + bits->rowstride = mask->bytes_per_line; + bits->bpixels = ZnMalloc(height * bits->rowstride); + memset(bits->bpixels, 0, height * bits->rowstride); + line = bits->bpixels; for (y = 0; y < height; y++) { for (x = 0; x < width; x++) { - if (XGetPixel(im1, x, y) == XGetPixel(im2, x, y)) { - XPutPixel(mask, x, y, 1L); + if (XGetPixel(mask, x, y)) { line[x >> 3] |= 0x80 >> (x & 7); } - else { - full_mask = False; - } } - line += im_bits->b_bits->rowstride; + line += bits->rowstride; } + XDestroyImage(mask); + entry = Tcl_CreateHashEntry(&images, bitmap_name, &new); + Tcl_SetHashValue(entry, (ClientData) bits); + bits->hash = entry; + } - XDestroyImage(im2); - if (full_mask) { - XDestroyImage(mask); - im_bits->mask = ZnUnspecifiedPattern; + /* + * Try to find an image instance that fits this widget/display. + */ + for (image = bits->images; image != NULL; image = image->next) { + if (image->for_gl == for_gl) { + if (for_gl && (image->i.gl.wi == wi)) { + image->refcount++; + return image; + } + else if (!for_gl && (image->i.x.dpy == wi->dpy)) { + image->refcount++; + return image; + } + } + } + + /* + * Create a new instance for this widget/display conf. + */ + image = ZnMalloc(sizeof(ImageStruct)); + image->bits = bits; + image->refcount = 1; + image->for_gl = for_gl; + if (image->for_gl) { +#ifdef GLX + image->i.gl.wi = wi; + image->i.gl.texobj = 0; + } +#endif + else { + image->i.x.dpy = wi->dpy; + image->i.x.mask_pmap = None; + if (bits->images == NULL) { + /* + * For the first one, the Tk_GetBitmap call has already been done. + */ + image->i.x.pixmap = pmap; } else { - im_bits->mask = mask; + /* + * Need to get a pixmap that match this dpy. + */ + image->i.x.pixmap = Tk_GetBitmap(wi->interp, wi->win, bitmap_name); } - - entry = Tcl_CreateHashEntry(&image_bits, image_name, &new); - Tcl_SetHashValue(entry, (ClientData) im_bits); } + image->next = bits->images; + bits->images = image; + + return image; +} + - return im_bits; +/* + ********************************************************************************** + * + * ZnGetImageByValue -- + * + ********************************************************************************** + */ +ZnImage +ZnGetImageByValue(ZnImage image) +{ + ((Image) image)->refcount++; + return image; } +/* + ********************************************************************************** + * + * ZnFreeImage -- + * + ********************************************************************************** + */ void -InvalidateImage(char *image_name) +ZnFreeImage(ZnImage image) { - Tcl_HashEntry *entry; - ImageBits *im_bits; - ImagePixmap *im_pmap, *next_im_pmap; - - if (!image_bits_inited) { + Image prev, scan, this = ((Image) image); + ImageBits *bits = this->bits; + + /* + * Search the instance in the list. + */ + for (prev=NULL, scan=bits->images; (scan!=NULL)&&(scan!=this); + prev=scan, scan=scan->next); + if (scan != this) { + return; /* Not found ? */ + } + + this->refcount--; + if (this->refcount != 0) { return; } + /* - * Destroy the image entry and wait the cache fault to - * reload the new one. + * Unlink the deleted image instance. */ - /*printf("InvalidateImage %s\n", image_name);*/ - entry = Tcl_FindHashEntry(&image_bits, image_name); - if (entry != NULL) { - /*printf("deallocating bits for image %s\n", image_name);*/ - im_bits = (ImageBits *) Tcl_GetHashValue(entry); - XDestroyImage(im_bits->pixels); - if (im_bits->mask) { - XDestroyImage(im_bits->mask); + if (prev == NULL) { + bits->images = this->next; + } + else { + prev->next = this->next; + } + if (this->for_gl) { + if (this->i.gl.texobj) { + glDeleteTextures(1, &this->i.gl.texobj); } - im_pmap = im_bits->pixmaps; - while (im_pmap) { - next_im_pmap = im_pmap->next; - XFreePixmap(im_pmap->dpy, im_pmap->pixmap); - if (im_bits->mask) { - XFreePixmap(im_pmap->dpy, im_pmap->mask_pmap); - } - ZnFree(im_pmap); - im_pmap = next_im_pmap; + } + else if (bits->ipixels) { + /* + * This is an image, we need to free the pixmaps. + */ + if (this->i.x.pixmap != None) { + XFreePixmap(this->i.x.dpy, this->i.x.pixmap); } - if (im_bits->b_bits) { - ZnFree(im_bits->b_bits->pixels); - ZnFree(im_bits->b_bits); + if (this->i.x.mask_pmap != None) { + XFreePixmap(this->i.x.dpy, this->i.x.mask_pmap); } -#ifdef GLX - if (im_bits->texture) { - ZnFree(im_bits->t_bits); - glDeleteTextures(1, &im_bits->texture); + } + else { + /* + * This is a bitmap ask Tk to free the resource. + */ + Tk_FreeBitmap(this->i.x.dpy, this->i.x.pixmap); + } + ZnFree(this); + + /* + * No clients for this image, it can be freed. + */ + if (bits->images == NULL) { + /*printf("destruction complète de l'image %s\n", ZnNameOfImage(this));*/ + if (bits->t_bits) { + ZnFree(bits->t_bits); } -#endif - ZnFree(im_bits); - Tcl_DeleteHashEntry(entry); + if (bits->mask) { + XDestroyImage(bits->mask); + } + if (bits->ipixels) { + XDestroyImage(bits->ipixels); + } + if (bits->bpixels) { + ZnFree(bits->bpixels); + } + Tcl_DeleteHashEntry(bits->hash); + ZnFree(bits); } } @@ -286,141 +688,242 @@ InvalidateImage(char *image_name) /* ********************************************************************************** * - * GetImagePixmap -- + * ZnNameOfImage -- * ********************************************************************************** */ -Pixmap -GetImagePixmap(ZnWindow win, - char *image_name, - ZnImage image, - Pixmap *mask_pmap) +char * +ZnNameOfImage(ZnImage image) { - ImageBits *im_bits; - Display *dpy = Tk_Display(win); - int depth = Tk_Depth(win); - ImagePixmap *im_pmap, *next_im_pmap; - Pixmap pixmap; - GC gc; - XGCValues values; - - im_bits = GetImageBits(win, image_name, image); - im_pmap = next_im_pmap = im_bits->pixmaps; - while (next_im_pmap && (im_pmap->dpy != dpy)) { - im_pmap = next_im_pmap; - next_im_pmap = next_im_pmap->next; - } - if (!im_pmap || (im_pmap->dpy != dpy)) { - /* printf("New pixmap\n");*/ - next_im_pmap = (ImagePixmap *) ZnMalloc(sizeof(ImagePixmap)); - next_im_pmap->next = NULL; - next_im_pmap->dpy = dpy; - pixmap = XCreatePixmap(dpy, ZnWindowId(win), - im_bits->width, im_bits->height, depth); - gc = XCreateGC(dpy, pixmap, 0, NULL); - XPutImage(dpy, pixmap, gc, im_bits->pixels, 0, 0, 0, 0, - im_bits->width, im_bits->height); - XFreeGC(dpy, gc); - next_im_pmap->pixmap = pixmap; - if (im_bits->mask) { - next_im_pmap->mask_pmap = XCreatePixmap(dpy, ZnWindowId(win), - im_bits->width, im_bits->height, 1); - values.foreground = 1; - values.background = 0; - gc = XCreateGC(dpy, next_im_pmap->mask_pmap, - GCForeground|GCBackground, &values); - XPutImage(dpy, next_im_pmap->mask_pmap, gc, im_bits->mask, 0, 0, 0, 0, - im_bits->width, im_bits->height); - XFreeGC(dpy, gc); - if (mask_pmap) { - *mask_pmap = next_im_pmap->mask_pmap; - } - } - else { - next_im_pmap->mask_pmap = None; - } - if (im_pmap) { - im_pmap->next = next_im_pmap; - } - else { - im_bits->pixmaps = next_im_pmap; - } - } - else { - /*printf("Reusing pixmap\n");*/ - pixmap = im_pmap->pixmap; - if (mask_pmap) { - *mask_pmap = im_pmap->mask_pmap; - } + return Tcl_GetHashKey(&images, ((Image) image)->bits->hash); +} + + +/* + ********************************************************************************** + * + * ZnSizeOfImage -- + * + ********************************************************************************** + */ +void +ZnSizeOfImage(ZnImage image, + int *width, + int *height) +{ + Image im = (Image) image; + *width = im->bits->width; + *height = im->bits->height; +} + + +/* + ********************************************************************************** + * + * ZnImagePattern -- + * + ********************************************************************************** + */ +char * +ZnImagePattern(ZnImage image, + int *stride) +{ + if (stride) { + *stride = ((Image) image)->bits->rowstride; } + return ((Image) image)->bits->bpixels; +} - return pixmap; +/* + ********************************************************************************** + * + * ZnImageIsBitmap -- + * + ********************************************************************************** + */ +ZnBool +ZnImageIsBitmap(ZnImage image) +{ + return (((Image) image)->bits->ipixels == NULL); } +/* + ********************************************************************************** + * + * ZnImageMask -- + * + ********************************************************************************** + */ +XImage * +ZnImageMask(ZnImage image) +{ + return ((Image) image)->bits->mask; +} /* ********************************************************************************** * - * GetBitmapMask -- + * ZnImagePixmap -- * ********************************************************************************** */ -BitmapBits * -GetBitmapMask(Display *dpy, - Pixmap bitmap) +Pixmap +ZnImagePixmap(ZnImage image, + Pixmap *mask_pmap) { - static int inited = 0; - BitmapKey key; - Tcl_HashEntry *entry; - XImage *mask; - BitmapBits *b_bits; - unsigned char *line; - int x, y, w, h, new; - - if (!inited) { - Tcl_InitHashTable(&bitmap_masks, (sizeof(BitmapKey)) / sizeof(int)); - inited = 1; + if (((Image) image)->for_gl) { + return None; } - key.dpy = dpy; - key.bitmap = bitmap; - entry = Tcl_FindHashEntry(&bitmap_masks, (char *) &key); - if (entry != NULL) { - b_bits = (BitmapBits *) Tcl_GetHashValue(entry); + if (mask_pmap) { + *mask_pmap = ((Image) image)->i.x.mask_pmap; } - else { - Tk_SizeOfBitmap(dpy, bitmap, &w, &h); - mask = XGetImage(dpy, bitmap, 0, 0, w, h, 1L, XYPixmap); - b_bits = (BitmapBits *) ZnMalloc(sizeof(BitmapBits)); - b_bits->pixels = ZnMalloc(h * mask->bytes_per_line); - memset(b_bits->pixels, 0, h * mask->bytes_per_line); - b_bits->rowstride = mask->bytes_per_line; - b_bits->width = w; - b_bits->height = h; - line = b_bits->pixels; - for (y = 0; y < h; y++) { - for (x = 0; x < w; x++) { - if (XGetPixel(mask, x, y)) { - line[x >> 3] |= 0x80 >> (x & 7); + return ((Image) image)->i.x.pixmap; +} + +/* + ********************************************************************************** + * + * ZnImageTex -- + * + ********************************************************************************** + */ +#ifdef GLX +GLuint +ZnImageTex(ZnImage image, + ZnReal *t, + ZnReal *s) +{ + Image this = (Image) image; + ImageBits *bits = this->bits; + ZnBool is_bmap = ZnImageIsBitmap(image); + int depth, t_size; + + if (!this->for_gl) { + return 0; + } + if (!bits->t_bits) { + /*printf("chargement texture pour image %s\n", ZnNameOfImage(this));*/ + bits->t_width = To2Power(bits->width); + bits->t_height = To2Power(bits->height); + bits->s = bits->width / (ZnReal) bits->t_width; + bits->t = bits->height / (ZnReal) bits->t_height; + if (is_bmap) { + int i, j; + unsigned char *ostart, *dstart, *d, *o; + + t_size = bits->t_width * bits->t_height; + bits->t_bits = ZnMalloc(t_size); + memset(bits->t_bits, 0, t_size); + ostart = bits->bpixels; + dstart = bits->t_bits; + for (i = 0; i < bits->height; i++) { + d = dstart; + o = ostart; + for (j = 0; j < bits->width; j++) { + *d++ = ZnGetBitmapPixel(bits->bpixels, bits->rowstride, j, i) ? 255 : 0; } + ostart += bits->rowstride; + dstart += bits->t_width; + } + } + else { + t_size = bits->t_width * 4 * bits->t_height; + bits->t_bits = ZnMalloc(t_size); + if (this->for_gl) { + depth = DefaultDepthOfScreen(this->i.gl.wi->screen); + } + else { + depth = DefaultDepthOfScreen(DefaultScreenOfDisplay(this->i.x.dpy)); + } + if (depth == 16) { + From5r6g5b(bits->ipixels->data, bits->width, bits->height, + bits->ipixels->bytes_per_line, bits->t_width, bits->t_height, + bits->bpixels, bits->rowstride, bits->t_bits); + } + else if ((depth == 24) || (depth == 32)) { + From8r8g8b(bits->ipixels->data, bits->width, bits->height, + bits->ipixels->bytes_per_line, bits->t_width, bits->t_height, + bits->bpixels, bits->rowstride, bits->t_bits); } - line += b_bits->rowstride; } - XDestroyImage(mask); - key.dpy = dpy; - key.bitmap = bitmap; - entry = Tcl_CreateHashEntry(&bitmap_masks, (char *) &key, &new); - Tcl_SetHashValue(entry, (ClientData) b_bits); } - - return b_bits; + if (!this->i.gl.texobj) { + glGenTextures(1, &this->i.gl.texobj); + /*printf("creation texture %d pour image %s\n", + this->i.gl.texobj, ZnNameOfImage(this));*/ + glBindTexture(GL_TEXTURE_2D, this->i.gl.texobj); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + if (ZnImageIsBitmap(image)) { + glTexImage2D(GL_TEXTURE_2D, 0, GL_INTENSITY4, + this->bits->t_width, this->bits->t_height, + 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, this->bits->t_bits); + } + else { + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, + this->bits->t_width, this->bits->t_height, + 0, GL_RGBA, GL_UNSIGNED_BYTE, this->bits->t_bits); + } + glBindTexture(GL_TEXTURE_2D, 0); + } + *t = this->bits->t; + *s = this->bits->s; + return this->i.gl.texobj; } +#endif + #ifdef GLX +/* Copyright (c) Mark J. Kilgard, 1997. */ + +/* This program is freely distributable without licensing fees and is + provided without guarantee or warrantee expressed or implied. This + program is -not- in the public domain. */ + #define MAX_GLYPHS_PER_GRAB 512 /* this is big enough for 2^9 glyph * character sets */ typedef struct { + unsigned short c; /* Potentially support 16-bit glyphs. */ + unsigned char width; + unsigned char height; + char xoffset; + char yoffset; + char advance; + char dummy; /* Space holder for alignment reasons. */ + short x; + short y; +} TexGlyphInfo; + +typedef struct _TexFontInfo { + GLuint texobj; + struct _TexFont *txf; + WidgetInfo *wi; + int refcount; + struct _TexFontInfo *next; +} TexFontInfo; + +typedef struct _TexFont { + TexFontInfo *tfi; + ZnFont tkfont; + int tex_width; + int tex_height; + int max_ascent; + int max_descent; + int num_glyphs; + int min_glyph; + int range; + unsigned char *teximage; + TexGlyphInfo *tgi; + ZnTexGVI *tgvi; + ZnTexGVI **lut; + Tcl_HashEntry *hash; +} TexFont; + +typedef struct { short width; short height; short xoffset; @@ -504,7 +1007,8 @@ placeGlyph(FontInfoPtr font, int width, height, spanLength; int i, j; - /*printf("x: %d, y: %d, c: %d, texarea: 0x%X\n", x, y, c, texarea);*/ + /*printf("x: %d, y: %d, c: %d, texarea: 0x%X, stride: %d\n", + x, y, c, texarea, stride);*/ if ((c < font->min_char) || (c > font->max_char)) { return; } @@ -514,10 +1018,9 @@ placeGlyph(FontInfoPtr font, width = glyph->width; spanLength = (width + 7) / 8; height = glyph->height; - for (i = 0; i < height; i++) { for (j = 0; j < width; j++) { - texarea[stride * (y+i) + x + j] = (bitmapData[i*spanLength + j/8] & (1<<(j&7))) ? 255 : 0; + texarea[stride * (y+i) + x + j] = (bitmapData[i*spanLength + j/8] & (1<<(j&7))) ? 255 : 0; } } } @@ -637,10 +1140,10 @@ SuckGlyphsFromServer(ZnWindow win, spanLength = (charWidth + 7) / 8; } bitmapData = ZnMalloc(height * spanLength * sizeof(char)); - memset(bitmapData, 0, height * spanLength * sizeof(char)); if (bitmapData == NULL) { goto FreeFontAndReturn; } + memset(bitmapData, 0, height * spanLength * sizeof(char)); for (y = 0; y < charHeight; y++) { for (x = 0; x < charWidth; x++) { /* XXX The algorithm used to suck across the font ensures that @@ -694,52 +1197,137 @@ SuckGlyphsFromServer(ZnWindow win, /* ********************************************************************************** * - * GetTexFont -- + * ZnGetTexFont -- * ********************************************************************************** */ -TexFont * -GetTexFont(ZnWindow win, - ZnFont font) +ZnTexFontInfo +ZnGetTexFont(WidgetInfo *wi, + ZnFont font) { - unsigned char *glisto = " ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890abcdefghijmklmnopqrstuvwxyz?.;,!*:\"'èéêëïîôâàçûùü/+@#$%^&~{[|`]}()=\\-_<>\t\024\025\026\027"; - unsigned char *glist=NULL, *glist2=NULL; TexFont *txf; - TexGlyphInfo *tgi; - int i, j; - int min_glyph, max_glyph; - int gap = 1; /* gap between glyphs */ - int px, py, maxheight; - int new, width, height; - GLfloat xstep, ystep, texw, texh; + TexFontInfo *tfi; static int inited = 0; Tcl_HashEntry *entry; - int max_tex_size[1]; - + char *fontname = Tk_NameOfFont(font); + int new; + if (!inited) { - Tcl_InitHashTable(&font_textures, sizeof(ZnFont)/sizeof(int)); + Tcl_InitHashTable(&font_textures, TCL_STRING_KEYS); inited = 1; } - entry = Tcl_FindHashEntry(&font_textures, (char *) font); + entry = Tcl_FindHashEntry(&font_textures, fontname); if (entry != NULL) { - return (TexFont *) Tcl_GetHashValue(entry); + /*printf("found font: %s\n", fontname);*/ + txf = (TexFont *) Tcl_GetHashValue(entry); } else { - txf = (TexFont *) ZnMalloc(sizeof(TexFont)); + /*printf("new font: |%s|\n", fontname);*/ + txf = ZnMalloc(sizeof(TexFont)); if (txf == NULL) { - goto error; + return NULL; } - glGetIntegerv(GL_MAX_TEXTURE_SIZE, max_tex_size); + txf->tfi = NULL; txf->tgi = NULL; txf->tgvi = NULL; txf->lut = NULL; txf->teximage = NULL; + txf->tkfont = font; + + entry = Tcl_CreateHashEntry(&font_textures, fontname, &new); + Tcl_SetHashValue(entry, (ClientData) txf); + txf->hash = entry; + } + + /* + * Now locate the texture obj in the texture list for this widget. + */ + tfi = txf->tfi; + while (tfi != NULL) { + if (tfi->wi == wi) { + tfi->refcount++; + return tfi; + } + } + /* + * Not found allocate a new texture object. + */ + tfi = ZnMalloc(sizeof(TexFontInfo)); + if (tfi == NULL) { + ZnFree(txf); + return NULL; + } + tfi->refcount = 1; + tfi->texobj = 0; + tfi->wi = wi; + tfi->txf = txf; + tfi->next = txf->tfi; + txf->tfi = tfi; + + return tfi; +} + + +/* + ********************************************************************************** + * + * ZnNameOfTexFont -- + * + ********************************************************************************** + */ +char * +ZnNameOfTexFont(ZnTexFontInfo tfi) +{ + return Tcl_GetHashKey(&font_textures, ((TexFontInfo *) tfi)->txf->hash); +} + +/* + ********************************************************************************** + * + * ZnTexFontTex -- + * + ********************************************************************************** + */ +GLuint +ZnTexFontTex(ZnTexFontInfo tfi) +{ + TexFontInfo *this = (TexFontInfo *) tfi; + TexFont *txf = this->txf; + unsigned char *glisto = " ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890abcdefghijmklmnopqrstuvwxyz?.;,!*:\"'èéêëïîôâàçûùü/+@#$%^&~{[|`]}()=\\-_<>\t\024\025\026\027"; + unsigned char *glist=NULL, *glist2=NULL; + TexGlyphInfo *tgi; + int i, j; + int min_glyph, max_glyph; + int gap = 1; /* gap between glyphs */ + int px, py, maxheight; + int width, height; + GLfloat xstep, ystep, texw, texh; + GLuint max_tex_size[1]; + + if (!txf->teximage) { + /*printf("Chargement de la texture pour la fonte %s\n", + ZnNameOfTexFont(tfi));*/ + glGetIntegerv(GL_MAX_TEXTURE_SIZE, max_tex_size); + fontinfo = SuckGlyphsFromServer(this->wi->win, txf->tkfont); + if (fontinfo == NULL) { + goto error; + } + txf->max_ascent = fontinfo->max_ascent; + txf->max_descent = fontinfo->max_descent; + txf->num_glyphs = strlen(glisto); + /* * Initial size of texture. - * Assume that max_tex_size is at least 256 texels. + * Assume that max_tex_size is at least 128 texels. */ texw = 128; texh = 64; + while (texh < txf->max_ascent+txf->max_descent) { + texh *= 2; + } + if (texh > max_tex_size[0]) { + goto error; + } xstep = 0/*0.5 / texw*/; ystep = 0/*0.5 / texh*/; @@ -749,20 +1337,11 @@ GetTexFont(ZnWindow win, } /*memset(txf->teximage, 0x55, texw * texh * sizeof(unsigned char));*/ - fontinfo = SuckGlyphsFromServer(win, font); - if (fontinfo == NULL) { - goto error; - } - - txf->max_ascent = fontinfo->max_ascent; - txf->max_descent = fontinfo->max_descent; - txf->num_glyphs = strlen(glisto); - - txf->tgi = (TexGlyphInfo *) ZnMalloc(txf->num_glyphs * sizeof(TexGlyphInfo)); + txf->tgi = ZnMalloc(txf->num_glyphs * sizeof(TexGlyphInfo)); if (txf->tgi == NULL) { goto error; } - txf->tgvi = (TexGlyphVertexInfo *) ZnMalloc(txf->num_glyphs * sizeof(TexGlyphVertexInfo)); + txf->tgvi = ZnMalloc(txf->num_glyphs * sizeof(ZnTexGVI)); if (txf->tgvi == NULL) { goto error; } @@ -776,7 +1355,7 @@ GetTexFont(ZnWindow win, */ glist2 = ZnMalloc((txf->num_glyphs+1) * sizeof(unsigned char)); strcpy(glist2, glist); - + restart: px = gap; py = gap; @@ -910,24 +1489,15 @@ GetTexFont(ZnWindow win, txf->min_glyph = min_glyph; txf->range = max_glyph - min_glyph + 1; - txf->lut = (TexGlyphVertexInfo **) ZnMalloc(txf->range * sizeof(TexGlyphVertexInfo *)); - memset(txf->lut, 0, txf->range * sizeof(TexGlyphVertexInfo *)); + txf->lut = ZnMalloc(txf->range * sizeof(ZnTexGVI *)); if (txf->lut == NULL) { goto error; } + memset(txf->lut, 0, txf->range * sizeof(ZnTexGVI *)); for (i = 0; i < txf->num_glyphs; i++) { txf->lut[txf->tgi[i].c - txf->min_glyph] = &txf->tgvi[i]; } - glGenTextures(1, &txf->texobj); - glBindTexture(GL_TEXTURE_2D, txf->texobj); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); - glTexImage2D(GL_TEXTURE_2D, 0, GL_INTENSITY4, txf->tex_width, txf->tex_height, 0, - GL_LUMINANCE, GL_UNSIGNED_BYTE, txf->teximage); - for (i = 0; i < fontinfo->num_glyphs; i++) { if (fontinfo->glyph[i].bitmap) ZnFree(fontinfo->glyph[i].bitmap); @@ -935,11 +1505,23 @@ GetTexFont(ZnWindow win, ZnFree(fontinfo); ZnFree(glist); ZnFree(glist2); + } - entry = Tcl_CreateHashEntry(&font_textures, (char *) font, &new); - Tcl_SetHashValue(entry, (ClientData) txf); - return txf; + if (!this->texobj) { + glGenTextures(1, &this->texobj); + /*printf("creation texture %d pour la fonte %s\n", + this->texobj, ZnNameOfTexFont(tfi));*/ + glBindTexture(GL_TEXTURE_2D, this->texobj); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + glTexImage2D(GL_TEXTURE_2D, 0, GL_INTENSITY4, txf->tex_width, txf->tex_height, + 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, txf->teximage); + glBindTexture(GL_TEXTURE_2D, 0); } + + return this->texobj; error: if (glist) { @@ -955,247 +1537,149 @@ GetTexFont(ZnWindow win, } ZnFree(fontinfo); } - if (txf) { - if (txf->tgi) { - ZnFree(txf->tgi); - } - if (txf->tgvi) { - ZnFree(txf->tgvi); - } - if (txf->lut) { - ZnFree(txf->lut); - } - if (txf->teximage) { - ZnFree(txf->teximage); - } - ZnFree(txf); + + if (txf->tgi) { + ZnFree(txf->tgi); + txf->tgi = NULL; } - return NULL; + if (txf->tgvi) { + ZnFree(txf->tgvi); + txf->tgvi = NULL; + } + if (txf->lut) { + ZnFree(txf->lut); + txf->lut = NULL; + } + if (txf->teximage) { + ZnFree(txf->teximage); + txf->teximage = NULL; + } + + return 0; } + /* - * Working only for 16 bits displays with 5r6g5b mask, - * and 24/32 bits displays. Byte ordering ok on Intel - * plateform only. + ********************************************************************************** + * + * ZnFreeTexFont -- + * + ********************************************************************************** */ void -From5r6g5b(unsigned char *data, - int width, - int height, - int bytes_per_line, - int t_width, - int t_height, - BitmapBits *b_bits, - unsigned char *t_bits) +ZnFreeTexFont(ZnTexFontInfo tfi) { - int x, y; - int rowstride = t_width * 4; - unsigned char *obptr; - unsigned char *bptr, *bp2; - unsigned char alpha; - unsigned short temp; - - bptr = t_bits; - - for (y = 0; y < height; y++) { - bp2 = bptr; - obptr = data; - for (x = 0; x < width; x++) { - /* - * Configure the alpha value. - */ - alpha = GetBitmapPixel(b_bits, x, y) ? 255 : 0; + TexFontInfo *this = ((TexFontInfo *) tfi); + TexFont *txf = this->txf; + TexFontInfo *prev, *scan; - /* - * Dispatch the 3 color components. - */ - temp = ((unsigned short *)obptr)[0]; - *bp2 = (temp >> 8) & 0xf8; /* r */ - bp2++; - *bp2 = (temp >> 3) & 0xfc; /* v */ - bp2++; - *bp2 = (temp << 3); /* b */ - bp2++; - *bp2 = alpha; - bp2++; - obptr += 2; - } - for (x = width; x < t_width; x++) { - *bp2 = 0; - bp2++; - *bp2 = 0; - bp2++; - *bp2 = 0; - bp2++; - *bp2 = 0; - bp2++; - } - bptr += rowstride; - data += bytes_per_line; - } - for (y = height; y < t_height; y++) { - memset(bptr, 0, rowstride); - bptr += rowstride; + for (prev=NULL, scan=this->txf->tfi; (scan!=NULL)&&(scan != this); + prev=scan, scan=this->next); + if (scan != this) { + return; } -} -void -From8r8g8b(unsigned char *data, - int width, - int height, - int bytes_per_line, - int t_width, - int t_height, - BitmapBits *b_bits, - unsigned char *t_bits) -{ - int x, y; - int rowstride = t_width * 4; - unsigned char *obptr; - unsigned char *bptr, *bp2; - unsigned char alpha; - - bptr = t_bits; - - for (y = 0; y < height; y++) { - bp2 = bptr; - obptr = data; - for (x = 0; x < width; x++) { - /* - * Configure the alpha value. - */ - alpha = GetBitmapPixel(b_bits, x, y) ? 255 : 0; + /* + * Decrement tex font object refcount. + */ + this->refcount--; + if (this->refcount != 0) { + return; + } - /* - * Dispatch the 3 color components. - * Be careful the Red and Blue are swapped it works on an Intel - * plateform but may need some more tests to be fully generic. - */ - *bp2++ = obptr[2]; /* r */ - *bp2++ = obptr[1]; /* v */ - *bp2++ = obptr[0]; /* b */ - obptr += 4; - *bp2++ = alpha; - } - for (x = width; x < t_width; x++) { - *bp2 = 0; - bp2++; - *bp2 = 0; - bp2++; - *bp2 = 0; - bp2++; - *bp2 = 0; - bp2++; - } - bptr += rowstride; - data += bytes_per_line; + /* + * Unlink the deleted tex font info. + */ + if (prev == NULL) { + txf->tfi = this->next; } - for (y = height; y < t_height; y++) { - memset(bptr, 0, rowstride); - bptr += rowstride; + else { + prev->next = this->next; + } + if (this->texobj) { + /*printf("Libération de la texture %d pour la fonte %s\n", + this->texobj, ZnNameOfTexFont(tfi));*/ + glDeleteTextures(1, &this->texobj); } -} - -static int -To2Power(int a) -{ - int result = 1; - while (result < a) { - result *= 2; + /* + * There is no more client for this font + * deallocate the structures. + */ + if (txf->tfi == NULL) { + /*printf("destruction complète du txf pour %s\n", + ZnNameOfTexFont(tfi));*/ + ZnFree(txf->tgi); + ZnFree(txf->tgvi); + ZnFree(txf->lut); + ZnFree(txf->teximage); + ZnFree(txf); + Tcl_DeleteHashEntry(txf->hash); } - return result; + + ZnFree(this); } - -ImageBits * -GetImageTexture(ZnWindow win, - char *image_name, - ZnImage image) + +/* + ********************************************************************************** + * + * ZnCharInTexFont -- + * + ********************************************************************************** + */ +ZnBool +ZnCharInTexFont(ZnTexFontInfo tfi, + int c) { - ImageBits *im_bits; - int t_width, t_height; - int depth = Tk_Depth(win); - /* int error;*/ - - im_bits = GetImageBits(win, image_name, image); - if (!im_bits->t_bits) { - t_width = To2Power(im_bits->width); - t_height = To2Power(im_bits->height); - im_bits->s = im_bits->width / (ZnReal) t_width; - im_bits->t = im_bits->height / (ZnReal) t_height; - im_bits->t_bits = ZnMalloc(t_width * 4 * t_height); - if (depth == 16) { - From5r6g5b(im_bits->pixels->data, im_bits->width, im_bits->height, - im_bits->pixels->bytes_per_line, t_width, t_height, - im_bits->b_bits, im_bits->t_bits); - } - else if (depth == 24) { - From8r8g8b(im_bits->pixels->data, im_bits->width, im_bits->height, - im_bits->pixels->bytes_per_line, t_width, t_height, - im_bits->b_bits, im_bits->t_bits); - } + TexFont *txf = ((TexFontInfo *) tfi)->txf; - glGenTextures(1, &im_bits->texture); - /*printf("creation texture %d pour image %s\n", im_bits->texture, image_name);*/ - glBindTexture(GL_TEXTURE_2D, im_bits->texture); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); - glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, t_width, t_height, 0, - GL_RGBA, GL_UNSIGNED_BYTE, im_bits->t_bits); - /* - error = glGetError(); - if (error != GL_NO_ERROR) { - printf("GetImageTexture: %s\n", gluErrorString(error)); + if ((c >= txf->min_glyph) && (c < txf->min_glyph + txf->range)) { + if (txf->lut[c - txf->min_glyph]) { + return True; } - */ } - - return im_bits; + return False; } -BitmapBits * -GetBitmapTexture(Display *dpy, - Pixmap bitmap) +/* + ********************************************************************************** + * + * ZnTexFontGVI -- + * + ********************************************************************************** + */ +ZnTexGVI * +ZnTexFontGVI(ZnTexFontInfo tfi, + int c) { - BitmapBits *b_bits; - int t_width, t_height; - int i, j; - unsigned char *o, *ostart, *d, *dstart; - - b_bits = GetBitmapMask(dpy, bitmap); - if (!b_bits->texture) { - t_width = To2Power(b_bits->width); - t_height = To2Power(b_bits->height); - b_bits->s = b_bits->width / (ZnReal) t_width; - b_bits->t = b_bits->height / (ZnReal) t_height; - b_bits->t_bits = ZnMalloc(t_width * t_height); - memset(b_bits->t_bits, 0, t_width * t_height); - - ostart = b_bits->pixels; - dstart = b_bits->t_bits; - for (i = 0; i < b_bits->height; i++) { - d = dstart; - o = ostart; - for (j = 0; j < b_bits->width; j++) { - *d++ = GetBitmapPixel(b_bits, j, i) ? 255 : 0; + TexFont *txf = ((TexFontInfo *) tfi)->txf; + ZnTexGVI *tgvi; + + /* Automatically substitute uppercase letters with lowercase if not + uppercase available (and vice versa). */ + if ((c >= txf->min_glyph) && (c < txf->min_glyph + txf->range)) { + tgvi = txf->lut[c - txf->min_glyph]; + if (tgvi) { + return tgvi; + } + if (islower(c)) { + c = toupper(c); + if ((c >= txf->min_glyph) && (c < txf->min_glyph + txf->range)) { + return txf->lut[c - txf->min_glyph]; + } + } + if (isupper(c)) { + c = tolower(c); + if ((c >= txf->min_glyph) && (c < txf->min_glyph + txf->range)) { + return txf->lut[c - txf->min_glyph]; } - ostart += b_bits->rowstride; - dstart += t_width; } - - glGenTextures(1, &b_bits->texture); - glBindTexture(GL_TEXTURE_2D, b_bits->texture); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); - glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); - glTexImage2D(GL_TEXTURE_2D, 0, GL_INTENSITY4, t_width, t_height, 0, - GL_LUMINANCE, GL_UNSIGNED_BYTE, b_bits->t_bits); } - - return b_bits; + fprintf(stderr, + "Tried to access unavailable texture font character '%c'(\\0%o)\n", + c, c); + return txf->lut[(int)'!' - txf->min_glyph]; } + #endif |