/* Copyright 1997 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, and/or sell copies of the Software, and to permit persons
 * to whom the Software is furnished to do so, provided that the above
 * copyright notice(s) and this permission notice appear in all copies of
 * the Software and that both the above copyright notice(s) and this
 * permission notice appear in supporting documentation.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
 * OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
 * HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL
 * INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING
 * FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
 * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 * Except as contained in this notice, the name of a copyright holder
 * shall not be used in advertising or otherwise to promote the sale, use
 * or other dealings in this Software without prior written authorization
 * of the copyright holder.
 */


/* 
** draw_inquiry.c - state inquiry routines for drawable veneer.
*/

#ifdef SERVER_DGA
#include <X11/Xlib.h>
#endif /* SERVER_DGA */
#include "dga_incls.h"

extern int dgai_mbsmemb_devinfochg (_Dga_window dgawin);
extern int dgai_pix_devinfochg(_Dga_pixmap dgapix);

Display *
dga_draw_display (Dga_drawable dgadraw)
{
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	return (dgai_mbsmemb_display((_Dga_window)dgadraw));
    case DGA_DRAW_PIXMAP:
	return (dgai_pix_display((_Dga_pixmap)dgadraw));
    }
}

Drawable
dga_draw_id (Dga_drawable dgadraw)
{
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	return ((Drawable)((_Dga_window)dgadraw)->w_id);
    case DGA_DRAW_PIXMAP:
	return ((Drawable)((_Dga_pixmap)dgadraw)->p_id);
    }
}

int
dga_draw_type (Dga_drawable dgadraw)
{
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	return ((((_Dga_window)dgadraw)->isOverlay)
		? (DGA_DRAW_OVERLAY)
		: (DGA_DRAW_WINDOW));
    case DGA_DRAW_PIXMAP:
	return (DGA_DRAW_PIXMAP);
    }
}

char *
dga_draw_devname (Dga_drawable dgadraw)
{
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	return (dgai_mbsmemb_devname((_Dga_window)dgadraw));
    case DGA_DRAW_PIXMAP:
	return (dgai_pix_devname((_Dga_pixmap)dgadraw));
    }
}

int
dga_draw_devfd (Dga_drawable dgadraw)
{
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	return (dgai_mbsmemb_devfd((_Dga_window)dgadraw));
    case DGA_DRAW_PIXMAP:
	return (dgai_pix_devfd((_Dga_pixmap)dgadraw));
    }
}

int
dga_draw_depth (Dga_drawable dgadraw)
{
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	return (dgai_mbsmemb_depth((_Dga_window)dgadraw));
    case DGA_DRAW_PIXMAP:
	return (dgai_pix_depth((_Dga_pixmap)dgadraw));
    }
}

void
dga_draw_set_client_infop (Dga_drawable dgadraw, void *client_info_ptr)
{
#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	dgai_mbsmemb_set_client_infop((_Dga_window)dgadraw, client_info_ptr);
	break;
    case DGA_DRAW_PIXMAP:
	dgai_pix_set_client_infop((_Dga_pixmap)dgadraw, client_info_ptr);
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
}

void *
dga_draw_get_client_infop (Dga_drawable dgadraw)
{
    void *rval;
#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	rval = dgai_mbsmemb_get_client_infop((_Dga_window)dgadraw);
	break;
    case DGA_DRAW_PIXMAP:
	rval = dgai_pix_get_client_infop((_Dga_pixmap)dgadraw);
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
    return (rval);
}

int
dga_draw_devinfochg (Dga_drawable dgadraw)
{
    int rval;

#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	rval = dgai_mbsmemb_devinfochg((_Dga_window)dgadraw);
	break;
    case DGA_DRAW_PIXMAP:
	rval = dgai_pix_devinfochg((_Dga_pixmap)dgadraw);
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
    return (rval);
}

void *
dga_draw_devinfo (Dga_drawable dgadraw)
{
    void *rval;

#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	rval = dgai_mbsmemb_devinfo((_Dga_window)dgadraw);
	break;
    case DGA_DRAW_PIXMAP:
	rval = dgai_pix_devinfo((_Dga_pixmap)dgadraw);
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
    return (rval);
}

int
dga_draw_sitechg (Dga_drawable dgadraw, int *reason)
{
    int rval;

#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	rval = dgai_mbsmemb_sitechg((_Dga_window)dgadraw, reason);
	break;
    case DGA_DRAW_PIXMAP:
	rval = dgai_pix_sitechg((_Dga_pixmap)dgadraw, reason);
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
    return (rval);
}

void
dga_draw_sitesetnotify (Dga_drawable dgadraw, DgaSiteNotifyFunc site_notify_func,
			   void *client_data)
{
#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	dgai_mbsmemb_sitesetnotify((_Dga_window)dgadraw, site_notify_func, client_data);
	break;
    case DGA_DRAW_PIXMAP:
	dgai_pix_sitesetnotify((_Dga_pixmap)dgadraw, site_notify_func, client_data);
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
}

void
dga_draw_sitegetnotify (Dga_drawable dgadraw, DgaSiteNotifyFunc *site_notify_func,
			   void **client_data)
{
#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	dgai_mbsmemb_sitegetnotify((_Dga_window)dgadraw, site_notify_func, client_data);
	break;
    case DGA_DRAW_PIXMAP:
	dgai_pix_sitegetnotify((_Dga_pixmap)dgadraw, site_notify_func, client_data);
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
}

int
dga_draw_site (Dga_drawable dgadraw)
{
    int rval;

#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	rval = dgai_mbsmemb_site((_Dga_window)dgadraw);
	break;
    case DGA_DRAW_PIXMAP:
	rval = dgai_pix_site((_Dga_pixmap)dgadraw);
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
    return (rval);
}

void *
dga_draw_address (Dga_drawable dgadraw)
{
    void *rval;

#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	rval = dgai_mbsmemb_address((_Dga_window)dgadraw);
	break;
    case DGA_DRAW_PIXMAP:
	rval = dgai_pix_address((_Dga_pixmap)dgadraw);
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
    return (rval);
}

int
dga_draw_linebytes (Dga_drawable dgadraw)
{
    int rval;

#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	rval = dgai_mbsmemb_linebytes((_Dga_window)dgadraw);
	break;
    case DGA_DRAW_PIXMAP:
	rval = dgai_pix_linebytes((_Dga_pixmap)dgadraw);
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
    return (rval);
}

int
dga_draw_bitsperpixel (Dga_drawable dgadraw)
{
    int rval;

#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	rval = dgai_mbsmemb_bitsperpixel((_Dga_window)dgadraw);
	break;
    case DGA_DRAW_PIXMAP:
	rval = dgai_pix_bitsperpixel((_Dga_pixmap)dgadraw);
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
    return (rval);
}

int
dga_draw_clipchg (Dga_drawable dgadraw)
{
    int rval;

#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	rval = dgai_mbsmemb_clipchg((_Dga_window)dgadraw);
	break;
    case DGA_DRAW_PIXMAP:
	rval = dgai_pix_clipchg((_Dga_pixmap)dgadraw);
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
    return (rval);
}

void
dga_draw_bbox(Dga_drawable dgadraw, int *xp, int *yp, int *widthp, int *heightp)
{
#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	dgai_mbsmemb_bbox((_Dga_window)dgadraw, xp, yp, widthp, heightp);
	break;
    case DGA_DRAW_PIXMAP:
	dgai_pix_bbox((_Dga_pixmap)dgadraw, xp, yp, widthp, heightp);
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
}

int
dga_draw_visibility (Dga_drawable dgadraw)
{ 
    int rval;

#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	rval = dgai_mbsmemb_visibility((_Dga_window)dgadraw);
	break;
    case DGA_DRAW_PIXMAP:
	/* always unobscured */
	rval = DGA_VIS_UNOBSCURED;
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
    return (rval);
}

int
dga_draw_empty (Dga_drawable dgadraw)
{ 
    int rval;

#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	rval = dgai_mbsmemb_empty((_Dga_window)dgadraw);
	break;
    case DGA_DRAW_PIXMAP:
	rval = dgai_pix_empty((_Dga_pixmap)dgadraw);
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
    return (rval);
}

short *
dga_draw_clipinfo (Dga_drawable dgadraw)
{
    short *rval;

#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	rval = dgai_mbsmemb_clipinfo((_Dga_window)dgadraw);
	break;
    case DGA_DRAW_PIXMAP:
	rval = dgai_pix_clipinfo((_Dga_pixmap)dgadraw);
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
    return (rval);
}


int
dga_draw_singlerect (Dga_drawable dgadraw)
{
    int rval;

#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	rval = dgai_mbsmemb_singlerect((_Dga_window)dgadraw);
	break;
    case DGA_DRAW_PIXMAP:
	/* always a single rect */
	rval = 1;
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
    return (rval);
}

int
dga_draw_obscured (Dga_drawable dgadraw)
{
    int rval;

#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	rval = dgai_mbsmemb_obscured((_Dga_window)dgadraw);
	break;
    case DGA_DRAW_PIXMAP:
	/* never obscured */
	rval = 0;
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
    return (rval);
}


/* CONSOLIDATION PRIVATE */
u_short
dga_draw_borderwidth (Dga_drawable dgadraw) 
{ 
    u_short rval;

#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	rval = dgai_mbsmemb_borderwidth((_Dga_window)dgadraw);
	break;
    case DGA_DRAW_PIXMAP:
	/* always 0 */
	rval = 0;
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
    return (rval);
} 


void
dga_draw_curshandle (Dga_drawable dgadraw, DgaCursTakeDownFunc take_down_func,
		        void *client_data)
{
#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	dgai_mbsmemb_curshandle((_Dga_window)dgadraw, take_down_func, client_data);
	break;
    case DGA_DRAW_PIXMAP:
	/* pixmaps never have cursors */
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
}


int		
dga_draw_rtngrab (Dga_drawable dgadraw)
{
    int rval;

#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	rval = dgai_mbsmemb_rtngrab((_Dga_window)dgadraw);
	break;
    case DGA_DRAW_PIXMAP:
	/* not applicable to pixmaps */
	rval = 0;
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
    return (rval);
}

int		
dga_draw_rtnungrab (Dga_drawable dgadraw)
{
    int rval;

#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	rval = dgai_mbsmemb_rtnungrab((_Dga_window)dgadraw);
	break;
    case DGA_DRAW_PIXMAP:
	/* not applicable to pixmaps */
	rval = 0;
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
    return (rval);
}

int		
dga_draw_rtnchg (Dga_drawable dgadraw)
{
    int rval;

#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	rval = dgai_mbsmemb_rtnchg((_Dga_window)dgadraw);
	break;
    case DGA_DRAW_PIXMAP:
	/* not applicable to pixmaps -- force a query for active */
	rval = 1;
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
    return (rval);
}

int		
dga_draw_rtnactive (Dga_drawable dgadraw)
{
    int rval;

#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	rval = dgai_mbsmemb_rtnactive((_Dga_window)dgadraw);
	break;
    case DGA_DRAW_PIXMAP:
	/* not applicable to pixmaps -- never active */
	rval = 0;
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
    return (rval);
}

int		
dga_draw_rtncached (Dga_drawable dgadraw)
{
    int rval;

#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	rval = dgai_mbsmemb_rtncached((_Dga_window)dgadraw);
	break;
    case DGA_DRAW_PIXMAP:
	/* not applicable to pixmaps -- consider never cached */
	rval = 0;
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
    return (rval);
}

void *		
dga_draw_rtndevinfop (Dga_drawable dgadraw)
{
    void *rval;

#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	rval = dgai_mbsmemb_rtndevinfop((_Dga_window)dgadraw);
	break;
    case DGA_DRAW_PIXMAP:
	/* not applicable to pixmaps -- doesn't have devinfo */
	rval = NULL;
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
    return (rval);
}

/* This routine is for compatibility only. In the old interface both
 * the "p" and the "non-p" version were in but the "p" version was the
 * one that was documented. */
void *		
dga_draw_rtndevinfo (Dga_drawable dgadraw)
{
    return(dga_draw_rtndevinfop (dgadraw));
}

void
dga_draw_rtndevtype (Dga_drawable dgadraw, u_char *type, 
		     char **name)
{
#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	dgai_mbsmemb_rtndevtype((_Dga_window)dgadraw, type, name);
	break;
    case DGA_DRAW_PIXMAP:
	/* not applicable to pixmaps -- no dev type and name */
	*type = (u_char) 0;
	*name = NULL;
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
}

void
dga_draw_rtndimensions (Dga_drawable dgadraw, short *width, 
			short *height, u_int *linebytes)
{
#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	dgai_mbsmemb_rtndimensions((_Dga_window)dgadraw, width, height, linebytes);
	break;
    case DGA_DRAW_PIXMAP:
	/* not applicable to pixmaps -- no dimensions */
	*width = 0;
	*height = 0;
	*linebytes = 0;
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
}

int
dga_draw_rtnbitsperpixel (Dga_drawable dgadraw)
{
    int rval;

#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	rval = dgai_mbsmemb_rtnbitsperpixel((_Dga_window)dgadraw);
	break;
    case DGA_DRAW_PIXMAP:
	/* not applicable to pixmaps */
	rval = 0;
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
    return (rval);
}

void *
dga_draw_rtnpixels (Dga_drawable dgadraw)
{
    void *rval;

#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	rval = dgai_mbsmemb_rtnpixels((_Dga_window)dgadraw);
	break;
    case DGA_DRAW_PIXMAP:
	/* not applicable to pixmaps -- doesn't have retained pixels */
	rval = NULL;
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
    return (rval);
}

Dga_widinfo *
dga_draw_widinfop (Dga_drawable dgadraw)
{
    Dga_widinfo *rval;

#ifdef MT
    mutex_lock(&dgaGlobalMutex);
#endif
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	rval = dga_win_widinfop((Dga_window)dgadraw);
	break;
    case DGA_DRAW_PIXMAP:
	/* not applicable to pixmaps -- doesn't have retained pixels */
	rval = NULL;
	break;
    }
#ifdef MT
    mutex_unlock(&dgaGlobalMutex);
#endif
    return (rval);
}


/* Note: the following routines are consolidation private.  They are not
   a part of the public interface. */

int
dga_draw_mbchg (Dga_drawable dgadraw, int *reason)
{
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	return (dgai_mbsmemb_mbchg((_Dga_window)dgadraw, reason));
    case DGA_DRAW_PIXMAP:
	/* pixmaps never are multibuffered */
	return (0);
    }
}
 
void
dga_draw_mbsetnotify (Dga_drawable dgadraw, DgaMbNotifyFunc mb_notify_func,
			   void *client_data)
{
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	dgai_mbsmemb_mbsetnotify((_Dga_window)dgadraw, mb_notify_func, client_data);
	break;
    case DGA_DRAW_PIXMAP:
	/* pixmaps never are multibuffered */
	break;
    }
}

void
dga_draw_mbgetnotify (Dga_drawable dgadraw, DgaMbNotifyFunc *mb_notify_func,
			   void **client_data)
{
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	dgai_mbsmemb_mbgetnotify((_Dga_window)dgadraw, mb_notify_func, client_data);
	break;
    case DGA_DRAW_PIXMAP:
	/* pixmaps never are multibuffered */
	break;
    }
}


int
dga_draw_mbaccessmode (Dga_drawable dgadraw)
{
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	return (dgai_mbsmemb_mbaccessmode((_Dga_window)dgadraw));
    case DGA_DRAW_PIXMAP:
	return (DGA_MBACCESS_NONE);
    }
}

int
dga_draw_mbsitetypeconst (Dga_drawable dgadraw)
{
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	return (dgai_mbsmemb_mbsitetypeconst((_Dga_window)dgadraw));
    case DGA_DRAW_PIXMAP:
	/* can't tell for pixmaps - be conservative */
	return (0);
    }
}

void
dga_draw_mbsetrendbufnotify (Dga_drawable dgadraw, DgaRendBufNotifyFunc rb_notify_func,
				void *client_data)
{
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	dgai_mbsmemb_mbsetrendbufnotify((_Dga_window)dgadraw, rb_notify_func, client_data);
	break;
    case DGA_DRAW_PIXMAP:
	/* pixmaps never are multibuffered */
	break;
    }
}

void
dga_draw_mbgetrendbufnotify (Dga_drawable dgadraw, DgaRendBufNotifyFunc *rb_notify_func,
				void **client_data)
{
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	dgai_mbsmemb_mbgetrendbufnotify((_Dga_window)dgadraw, rb_notify_func, client_data);
	break;
    case DGA_DRAW_PIXMAP:
	/* pixmaps never are multibuffered */
	break;
    }
}


int
dga_draw_ovlstatechg (Dga_drawable dgadraw)
{
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	return (dgai_mbsmemb_ovlstatechg((_Dga_window)dgadraw));
    case DGA_DRAW_PIXMAP:
	/* Pixmaps never have an ovlstate */
	return (0);
    }
}

int
dga_draw_ovlstate (Dga_drawable dgadraw)
{
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	return (dgai_mbsmemb_ovlstate((_Dga_window)dgadraw));
    case DGA_DRAW_PIXMAP:
	/* Pixmaps never have an ovlstate */
	return (DGA_OVLSTATE_CONFLICT);
    }
}

void
dga_draw_ovlstatesetnotify (Dga_drawable dgadraw, 
			    DgaOvlStateNotifyFunc ovlstate_notify_func,
			    void *client_data)
{
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	dgai_mbsmemb_setovlstatenotify((_Dga_window)dgadraw,
				       ovlstate_notify_func,
				       client_data);
    case DGA_DRAW_PIXMAP:
	/* Pixmaps never have an ovlstate */
	break;
    }
}

void
dga_draw_ovlstategetnotify (Dga_drawable dgadraw, 
			    DgaOvlStateNotifyFunc *ovlstate_notify_func,
			    void **client_data)
{
    switch ( ((_Dga_drawable)dgadraw)->drawable_type) {
    case DGA_DRAW_WINDOW:
	dgai_mbsmemb_getovlstatenotify((_Dga_window)dgadraw,
				       ovlstate_notify_func,
				       client_data);
    case DGA_DRAW_PIXMAP:
	/* Pixmaps never have an ovlstate */
	break;
    }
}