--- np2/x11/gtk/Attic/gtk_drawmng.c	2004/02/06 16:51:22	1.3
+++ np2/x11/gtk/Attic/gtk_drawmng.c	2005/03/12 12:36:40	1.8
@@ -1,3 +1,5 @@
+/*	$Id: gtk_drawmng.c,v 1.8 2005/03/12 12:36:40 monaka Exp $	*/
+
 /*
  * Copyright (c) 2003 NONAKA Kimihiro
  * All rights reserved.
@@ -10,8 +12,6 @@
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote products
- *    derived from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
@@ -37,94 +37,113 @@
 #include "gtk/gtk_drawmng.h"
 
 
-GTKDRAWMNG_HDL
-gtkdrawmng_create(GtkWidget *parent_window, int width, int height)
+DRAWMNG_HDL
+drawmng_create(void *parent, int width, int height)
 {
 	GTKDRAWMNG_HDL hdl = NULL;
+	GtkWidget *parent_window;
 	GdkVisual *visual;
-	int bitcolor;
+	pixmap_format_t fmt;
 	int bytes_per_pixel;
+	int padding;
 
-	if (parent_window == NULL)
+	if (parent == NULL)
 		return NULL;
+	parent_window = GTK_WIDGET(parent);
+	gtk_widget_realize(parent_window);
 
 	hdl = (GTKDRAWMNG_HDL)_MALLOC(sizeof(_GTKDRAWMNG_HDL), "drawmng hdl");
 	if (hdl == NULL)
 		return NULL;
 	memset(hdl, 0, sizeof(_GTKDRAWMNG_HDL));
 
-	hdl->width = width;
-	hdl->height = height;
+	hdl->d.width = width;
+	hdl->d.height = height;
+	hdl->d.drawing = FALSE;
 
 	hdl->drawarea = gtk_drawing_area_new();
 	gtk_drawing_area_size(GTK_DRAWING_AREA(hdl->drawarea), width, height);
 
 	visual = gtk_widget_get_visual(hdl->drawarea);
-	bitcolor = gtkdrawmng_getbpp(hdl->drawarea, parent_window);
-	if (bitcolor == 0)
+	if (!gtkdrawmng_getformat(hdl->drawarea, parent_window, &fmt))
 		goto destroy;
-	bytes_per_pixel = bitcolor / 8;
 
-	if (bitcolor == 16) {
-		drawmng_make16mask(&hdl->pal16mask, visual->blue_mask,
+	switch (fmt.bits_per_pixel) {
+#if defined(SUPPORT_32BPP)
+	case 32:
+		break;
+#endif
+#if defined(SUPPORT_24BPP)
+	case 24:
+		break;
+#endif
+#if defined(SUPPORT_16BPP)
+	case 16:
+	case 15:
+		drawmng_make16mask(&hdl->d.pal16mask, visual->blue_mask,
 		    visual->red_mask, visual->green_mask);
+		break;
+#endif
+#if defined(SUPPORT_8BPP)
+	case 8:
+		break;
+#endif
+
+	default:
+		goto destroy;
 	}
+	bytes_per_pixel = fmt.bits_per_pixel / 8;
 
-	hdl->dest.x = hdl->dest.x = 0;
-	hdl->src.left = hdl->src.top = 0;
-	hdl->src.right = width;
-	hdl->src.bottom = height;
-	hdl->lpitch = hdl->src.right * bytes_per_pixel;
-	if (hdl->lpitch % 4) {
-		hdl->src.right += (hdl->lpitch % 4) / bytes_per_pixel;
-		hdl->lpitch = hdl->src.right * bytes_per_pixel;
+	hdl->d.dest.x = hdl->d.dest.x = 0;
+	hdl->d.src.left = hdl->d.src.top = 0;
+	hdl->d.src.right = width;
+	hdl->d.src.bottom = height;
+	hdl->d.lpitch = hdl->d.src.right * bytes_per_pixel;
+	padding = hdl->d.lpitch % (fmt.scanline_pad / 8);
+	if (padding > 0) {
+		hdl->d.src.right += padding / bytes_per_pixel;
+		hdl->d.lpitch = hdl->d.src.right * bytes_per_pixel;
 	}
 
 	/* image */
 	hdl->surface = gdk_image_new(GDK_IMAGE_FASTEST, visual,
-	    hdl->src.right, hdl->src.bottom);
+	    hdl->d.src.right, hdl->d.src.bottom);
 	if (hdl->surface == NULL)
 		goto destroy;
 
-	hdl->vram.width = hdl->src.right;
-	hdl->vram.height = hdl->src.bottom;
-	hdl->vram.xalign = bytes_per_pixel;
-	hdl->vram.yalign = hdl->lpitch;
-	hdl->vram.bpp = bitcolor;
+	hdl->d.vram.width = hdl->d.src.right;
+	hdl->d.vram.height = hdl->d.src.bottom;
+	hdl->d.vram.xalign = bytes_per_pixel;
+	hdl->d.vram.yalign = hdl->d.lpitch;
+	hdl->d.vram.bpp = fmt.bits_per_pixel;
 
 	/* pixmap */
-	hdl->shared_pixmap = use_shared_pixmap;
-	hdl->backsurf = NULL;
-	if (use_shared_pixmap) {
-		hdl->backsurf = gdk_pixmap_shpix_new(parent_window->window,
-		    hdl->surface, hdl->vram.width, hdl->vram.height,
-		    visual->depth);
-	}
-	if (hdl->backsurf == NULL) {
-		hdl->shared_pixmap = FALSE;
-		hdl->backsurf = gdk_pixmap_new(parent_window->window,
-		    hdl->vram.width, hdl->vram.height, visual->depth);
-	}
+	hdl->backsurf = gdk_pixmap_new(parent_window->window,
+	    hdl->d.vram.width, hdl->d.vram.height, visual->depth);
 	if (hdl->backsurf == NULL)
 		goto destroy;
 
-	return hdl;
+	return (DRAWMNG_HDL)hdl;
 
 destroy:
 	if (hdl) {
-		gtkdrawmng_release(hdl);
-		if (hdl->drawarea) {
-			gtk_widget_unref(hdl->drawarea);
+		GtkWidget *da = hdl->drawarea;
+		drawmng_release((DRAWMNG_HDL)hdl);
+		if (da) {
+			gtk_widget_unref(da);
 		}
 	}
 	return NULL;
 }
 
 void
-gtkdrawmng_release(GTKDRAWMNG_HDL hdl)
+drawmng_release(DRAWMNG_HDL dhdl)
 {
+	GTKDRAWMNG_HDL hdl = (GTKDRAWMNG_HDL)dhdl;
 
 	if (hdl) {
+		while (hdl->d.drawing)
+			usleep(1);
 		if (hdl->backsurf) {
 			gdk_pixmap_unref(hdl->backsurf);
 		}
@@ -136,107 +155,147 @@ gtkdrawmng_release(GTKDRAWMNG_HDL hdl)
 }
 
 CMNVRAM *
-gtkdrawmng_surflock(GTKDRAWMNG_HDL hdl)
+drawmng_surflock(DRAWMNG_HDL dhdl)
 {
+	GTKDRAWMNG_HDL hdl = (GTKDRAWMNG_HDL)dhdl;
 
-	hdl->vram.ptr = (BYTE *)hdl->surface->mem;
-
-	return &hdl->vram;
+	if (hdl) {
+		hdl->d.vram.ptr = (BYTE *)hdl->surface->mem;
+		if (hdl->d.vram.ptr) {
+			hdl->d.drawing = TRUE;
+			return &hdl->d.vram;
+		}
+	}
+	return NULL;
 }
 
 void
-gtkdrawmng_surfunlock(GTKDRAWMNG_HDL hdl)
+drawmng_surfunlock(DRAWMNG_HDL dhdl)
 {
-	GdkGC *gc =hdl->drawarea->style->fg_gc[GTK_WIDGET_STATE(hdl->drawarea)];
+	GTKDRAWMNG_HDL hdl = (GTKDRAWMNG_HDL)dhdl;
+	GdkGC *gc;
 
-	if (!hdl->shared_pixmap) {
+	if (hdl) {
+		gc = hdl->drawarea->style->fg_gc[GTK_WIDGET_STATE(hdl->drawarea)];
 		gdk_draw_image(hdl->backsurf, gc, hdl->surface,
-		    0, 0, 0, 0, hdl->width, hdl->height);
+		    0, 0, 0, 0, hdl->d.width, hdl->d.height);
+		hdl->d.drawing = FALSE;
 	}
 }
 
 void
-gtkdrawmng_blt(GTKDRAWMNG_HDL hdl, RECT_T *sr, POINT_T *dp)
+drawmng_blt(DRAWMNG_HDL dhdl, RECT_T *sr, POINT_T *dp)
 {
-	GdkGC *gc =hdl->drawarea->style->fg_gc[GTK_WIDGET_STATE(hdl->drawarea)];
+	GTKDRAWMNG_HDL hdl = (GTKDRAWMNG_HDL)dhdl;
+	RECT_T r;
+	POINT_T p;
+	GdkGC *gc;
+	int width, height;
 
-	if (sr || dp) {
-		POINT_T p;
-		RECT_T r;
-		int width, height;
-
-		if (sr) {
-			r = *sr;
-		} else {
-			r.left = r.top = 0;
-			r.right = hdl->width;
-			r.bottom = hdl->height;
-		}
-		if (dp) {
-			p = *dp;
+	if (hdl) {
+		gc = hdl->drawarea->style->fg_gc[GTK_WIDGET_STATE(hdl->drawarea)];
+		if (sr || dp) {
+			if (sr) {
+				r = *sr;
+			} else {
+				r.left = r.top = 0;
+				r.right = hdl->d.width;
+				r.bottom = hdl->d.height;
+			}
+			if (dp) {
+				p = *dp;
+			} else {
+				p.x = p.y = 0;
+			}
+			width = r.right - p.x;
+			height = r.bottom - p.y;
+
+			gdk_draw_pixmap(hdl->drawarea->window, gc,
+			    hdl->backsurf,
+			    r.left, r.top, p.x, p.y, width, height);
 		} else {
-			p.x = p.y = 0;
+			gdk_draw_pixmap(hdl->drawarea->window, gc,
+			    hdl->backsurf,
+			    0, 0, 0, 0, hdl->d.width, hdl->d.height);
 		}
-		width = r.right - p.x;
-		height = r.bottom - p.y;
+	}
+}
 
-		gdk_draw_pixmap(hdl->drawarea->window, gc, hdl->backsurf,
-		    r.left, r.top, p.x, p.y, width, height);
+void
+drawmng_set_size(DRAWMNG_HDL dhdl, int width, int height)
+{
+	GTKDRAWMNG_HDL hdl = (GTKDRAWMNG_HDL)dhdl;
+
+	hdl->d.width = width;
+	hdl->d.height = height;
+	gtk_widget_set_usize(hdl->drawarea, width, height);
+}
+
+void
+drawmng_invalidate(DRAWMNG_HDL dhdl, RECT_T *r)
+{
+	GTKDRAWMNG_HDL hdl = (GTKDRAWMNG_HDL)dhdl;
+	gint x, y, w, h;
+
+	if (r == NULL) {
+		gtk_widget_queue_draw(hdl->drawarea);
 	} else {
-		gdk_draw_pixmap(hdl->drawarea->window, gc, hdl->backsurf,
-		    0, 0, 0, 0, hdl->width, hdl->height);
+		x = r->left;
+		y = r->top;
+		w = r->right - r->left;
+		h = r->bottom - r->top;
+		gtk_widget_queue_draw_area(hdl->drawarea, x, y, w, h);
 	}
 }
 
-int
-gtkdrawmng_getbpp(GtkWidget *w, GtkWidget *parent_window)
+void *
+drawmng_get_widget_handle(DRAWMNG_HDL dhdl)
+{
+	GTKDRAWMNG_HDL hdl = (GTKDRAWMNG_HDL)dhdl;
+
+	return hdl->drawarea;
+}
+
+BOOL
+gtkdrawmng_getformat(GtkWidget *w, GtkWidget *pw, pixmap_format_t *fmtp)
 {
 	GdkVisual *visual;
-	int bitcolor;
 
 	visual = gtk_widget_get_visual(w);
 	switch (visual->type) {
 	case GDK_VISUAL_TRUE_COLOR:
 	case GDK_VISUAL_PSEUDO_COLOR:
 	case GDK_VISUAL_DIRECT_COLOR:
-		if (visual->depth >= 8) {
-			break;
-		}
-		/* FALLTHROUGH */
+		break;
+
 	default:
 		fprintf(stderr, "No support visual class.\n");
-		return 0;
+		return FALSE;
 	}
 
-	if (visual->depth == 32) {
-		bitcolor = 32;
-	} else if (visual->depth == 24) {
-		if (is_32bpp(parent_window->window)) {
-			bitcolor = 32;
-		} else {
-			bitcolor = 24;
+	switch (visual->depth) {
+#if defined(SUPPORT_32BPP)
+	case 32:
+#endif
+#if defined(SUPPORT_24BPP)
+	case 24:
+#endif
+#if defined(SUPPORT_16BPP)
+	case 16:
+	case 15:
+#endif
+#if defined(SUPPORT_8BPP)
+	case 8:
+#endif
+		break;
+
+	default:
+		if (visual->depth < 8) {
+			fprintf(stderr, "Too few allocable color.\n");
 		}
-	} else if (visual->depth == 15 || visual->depth == 16) {
-		bitcolor = 16;
-	} else if (visual->depth == 8) {
-		bitcolor = 8;
-	} else if (visual->depth < 8) {
-		fprintf(stderr, "Too few allocable color.\n");
-		return 0;
-	} else {
 		fprintf(stderr, "No support depth.\n");
-		return 0;
+		return FALSE;
 	}
 
-	return bitcolor;
-}
-
-
-void
-gtkdrawmng_set_size(GTKDRAWMNG_HDL hdl, int width, int height)
-{
-
-	hdl->width = width;
-	hdl->height = height;
-	gtk_widget_set_usize(hdl->drawarea, width, height);
+	return gdk_window_get_pixmap_format(pw->window, visual, fmtp);
 }