if ((region->extents.x1 != region->extents.x2) &&
	    (region->extents.y1 != region->extents.y2)) {
	    region->numRects = 1;
	    *(region->rects) = region->extents;
	}
	return(region);
    }

    if (Count < 2) return region;

    if (! (pETEs = (EdgeTableEntry *)
	   Xmalloc((unsigned) (sizeof(EdgeTableEntry) * Count)))) {
	XDestroyRegion(region);
	return (Region) NULL;
    }

    public:
        typedef PixFmt   pixfmt_type;
        typedef typename pixfmt_type::color_type color_type;
        typedef typename pixfmt_type::order_type order_type;
        typedef typename pixfmt_type::value_type value_type;

        image_accessor_wrap_gray8() {}
        explicit image_accessor_wrap_gray8(const pixfmt_type& pixf) :
            m_pixf(&pixf),
            m_wrap_x(pixf.width()),
            m_wrap_y(pixf.height())
        {}

        void attach(const pixfmt_type& pixf)
        {
            m_pixf = &pixf;
        }

	    m_src(&src),
            m_offset_x(offset_x),
            m_offset_y(offset_y)
    {}

    //--------------------------------------------------------------------
    void generate(color_type* span, int x, int y, unsigned len)
    {
	x += m_offset_x;
	y += m_offset_y;
	const Uint8* p = (const Uint8*)m_src->span(x, y, 1);
	do {
	    if (p[0]) {
		*span = m_color;
	    } else {

	Uint8* p = (Uint8*)m_rbuf->row_ptr(y) + x;
	p[0] ^= 0xFF;
	p[1] ^= 0xFF;
	p[2] ^= 0xFF;
    }

    //--------------------------------------------------------------------
    void copy_hline(int x, int y,
			    unsigned len,
			    const color_type& c)
    {
	Uint8* p = (Uint8*)m_rbuf->row_ptr(y) + x + x + x;
	do {
	    p[0] ^= 0xFF;
	    p[1] ^= 0xFF;
	    p[2] ^= 0xFF;
	    p += 3;
	} while(--len);
    }

    //--------------------------------------------------------------------
    void blend_hline(int x, int y,
		    unsigned len,
		    const color_type& c,
		    agg::int8u cover)
    {
	Uint8* p = (Uint8*)m_rbuf->row_ptr(y) + x + x + x;
	do {
	    p[0] ^= 0xFF;
	    p[1] ^= 0xFF;
	    p[2] ^= 0xFF;
	    p += 3;
	} while(--len);
    }

    //--------------------------------------------------------------------
    void blend_vline(int x, int y,
		    unsigned len,
		    const color_type& c,
		    agg::int8u cover)
    {
	Uint8* p = (Uint8*)m_rbuf->row_ptr(y) + x + x + x;
	do {
	    p[0] ^= 0xFF;
	    p[1] ^= 0xFF;
	    p[2] ^= 0xFF;
	    p += m_rbuf->stride();
	} while(--len);
    }

    //--------------------------------------------------------------------
    void blend_color_hspan(int x, int y,
			   unsigned len,
			   const color_type* colors,
			   const agg::int8u* covers,
			   agg::int8u cover)
    {
    }

private:

    void copy_pixel(int x, int y, const color_type& c)
    {
	Type* p = (Type*)m_rbuf->row_ptr(y) + x;
	*p ^= 0xFFFFFFFF;
    }

    //--------------------------------------------------------------------
    void copy_hline(int x, int y,
		    unsigned len,
		    const color_type& c)
    {
	Type* p = (Type*)m_rbuf->row_ptr(y) + x;
	do {
	    *p ^= 0xFFFFFFFF;
	    p += 1;
	} while(--len);
    }

    //--------------------------------------------------------------------
    void blend_hline(int x, int y,
		    unsigned len,
		    const color_type& c,
		    agg::int8u cover)
    {
	Type* p = (Type*)m_rbuf->row_ptr(y) + x;
	do {
	    *p ^= 0xFFFFFFFF;
	    p += 1;
	} while(--len);
    }

    //--------------------------------------------------------------------
    void blend_vline(int x, int y,
		    unsigned len,
		    const color_type& c,
		    agg::int8u cover)
    {
	Type* p = (Type*)m_rbuf->row_ptr(y) + x;
	do {
	    *p ^= 0xFFFFFFFF;
	    y++;
	    p = (Type*)m_rbuf->row_ptr(y) + x;
	} while(--len);
    }

    //--------------------------------------------------------------------
    void blend_color_hspan(int x, int y,
			   unsigned len,
			   const color_type* colors,
			   const agg::int8u* covers,
			   agg::int8u cover)
    {
    }

private:

    if ((parent->child == _w) && (_w->next == NULL)) {
	return;
    }

    for (child = parent->child; child != _w; child = child->next) {
	oldPos++;
    }

    if (sibling == NULL && stack_mode == Above && !_w->topmost) {
	/* Special handling for non-topmost windows. */
	int lastPos[2] = { -1, -1};

	for (child = parent->child; child != NULL; child = child->next) {
	     lastPos[0]++;
	     if (child->topmost) {
		lastPos[1] = lastPos[0];
	     }
	}
	if (lastPos[1] >= 0) {
	    stack_mode = Below;
	    lastPos[0] = 0;
	    for (sibling = parent->child; sibling != NULL;
		    sibling = sibling->next) {
		if (lastPos[0] >= lastPos[1]) {
		    break;
		}
		lastPos[0]++;
	    }
	}
    }

    SdlTkRemoveFromParent(_w);

    if (sibling == NULL) {
	switch (stack_mode) {
	case Above:
	    sibling = parent->child;

    _w = SdlTkToplevelForWindow(_w, NULL, NULL);
    if (_w == NULL) {
	return;
    }

    sibling = _w->parent->child;
    while ((sibling != _w) &&
	(SdlTkIsTransientOf(sibling, _w) ||
	 (!_w->topmost &&
	  (sibling->topmost || (sibling->child && sibling->child->topmost)
	 )))) {
	sibling = sibling->next;
    }

    if (sibling != _w) {
	SdlTkRestackWindow(_w, sibling, Above);
	SdlTkRestackTransients(_w);
    }

    master = SdlTkWrapperForWindow(_w);

    _Window *master; /* Master if this is a transient */
    Display *display;
    XWindowAttributes atts, atts_saved;
    int back_pixel_set;
    unsigned long back_pixel;
    struct _Pixmap *back_pixmap;
    int fullscreen;
    int topmost;
    int clazz;
    XSizeHints size;
    int parentWidth, parentHeight; /* our width/height + 2*atts.border_width */
    TkWindow *tkwin; /* NULL for decorative frame */
    DecFrame dec; /* only for decorative frame */
#ifdef ANDROID
    int gl_flags;

    int arg_nosysfonts;
    int arg_swcursor;

    /* Various atoms */
    Atom mwm_atom;
    Atom nwmn_atom;
    Atom nwms_atom;
    Atom nwmsa_atom;
    Atom nwmsf_atom;
    Atom clipboard_atom;
    Atom comm_atom;
    Atom interp_atom;
    Atom tkapp_atom;
    Atom wm_prot_atom;
    Atom wm_dele_atom;

		SdlTkChangeWindowAttributes(display, w,
					    CWOverrideRedirect, &atts);
	    }
	}
	goto done;
    }
    if (property == SdlTkX.nwms_atom) {
	int i, fullscreen = 0, topmost = 0;
	Atom *props = (Atom *) data;
	XPropertyEvent xproperty;
	_Window *_ww = _w;

	for (i = 0; i < nelements; i++) {
	    if (props[i] == SdlTkX.nwmsa_atom) {
		topmost = 1;
	    }
	    if (props[i] == SdlTkX.nwmsf_atom) {
		fullscreen = 1;
	    }
	}
	if (topmost && !_w->topmost) {
	    _w->topmost = 1;
	    if (_w->parent != NULL && _w->parent->dec != NULL) {
		_w->parent->topmost = 1;
		SdlTkRestackWindow(_w->parent, NULL, Above);
	    } else {
		SdlTkRestackWindow(_w, NULL, Above);
	    }
	    SdlTkRestackTransients(_w);
	} else if (!topmost && _w->topmost) {
	    _w->topmost = 0;
	    if (_w->parent != NULL && _w->parent->dec != NULL) {
		_w->parent->topmost = 0;
		SdlTkRestackWindow(_w->parent, NULL, Above);
	    } else {
	    	SdlTkRestackWindow(_w, NULL, Above);
	    }
	}
	if (fullscreen && !_w->fullscreen) {
	    int xx, yy, ww, hh;

	    _w->atts_saved = _w->atts;
	    xx = yy = 0;

    _w->visRgn = SdlTkRgnPoolGet();
    _w->visRgnInParent = SdlTkRgnPoolGet();
    _w->dirtyRgn = SdlTkRgnPoolGet();

    _w->clazz = (clazz == InputOnly) ? InputOnly : InputOutput;

    /* Make first child of parent except for topmost children. */
    if (IS_ROOT(_parent)) {
	_Window *prev = NULL, *next = _parent->child;

	while (next != NULL) {
	    if (!next->topmost) {
		break;
	    }
	    prev = next;
	    next = next->next;
	}
	if (prev != NULL) {
	    _w->next = prev->next;
	    prev->next = _w;
	} else {
	    _w->next = _parent->child;
	    _parent->child = _w;
	}
    } else {
	_w->next = _parent->child;
	_parent->child = _w;
    }

    if (_parent->atts.your_event_mask & SubstructureNotifyMask) {
	/* Make CreateNotify event. */
	XEvent event;

	memset(&event, 0, sizeof (event));
	event.type = CreateNotify;

    *actual_type_return = None;
    *actual_format_return = 0;
    *nitems_return = 0;
    *bytes_after_return = 0;
    *prop_return = NULL;
    if (property == SdlTkX.nwms_atom) {
	_Window *_w = (_Window *) w;
	int n = 0;

	SdlTkLock(display);
	display->request++;
	if (_w->fullscreen || _w->topmost) {
	    *prop_return = (unsigned char *) ckalloc(sizeof (Atom) * 2);
	}
	if (_w->fullscreen) {
	    ((Atom *) *prop_return)[n++] = SdlTkX.nwmsf_atom;
	    *nitems_return = n;
	}
	if (_w->topmost) {
	    ((Atom *) *prop_return)[n++] = SdlTkX.nwmsa_atom;
	    *nitems_return = n;
	}
	SdlTkUnlock(display);
	return Success;
    }
    if (req_type != XA_STRING) {
	return BadValue;
    }

    SDL_EnableScreenSaver();

    /* Some well known atoms. */
    SdlTkX.mwm_atom = XInternAtom(NULL, "_MOTIF_WM_HINTS", False);
    SdlTkX.nwmn_atom = XInternAtom(NULL, "_NET_WM_NAME", False);
    SdlTkX.nwms_atom = XInternAtom(NULL, "_NET_WM_STATE", False);
    SdlTkX.nwmsa_atom = XInternAtom(NULL, "_NET_WM_STATE_ABOVE", False);
    SdlTkX.nwmsf_atom = XInternAtom(NULL, "_NET_WM_STATE_FULLSCREEN", False);
    SdlTkX.clipboard_atom = XInternAtom(NULL, "CLIPBOARD", False);
    SdlTkX.comm_atom = XInternAtom(NULL, "Comm", False);
    SdlTkX.interp_atom = XInternAtom(NULL, "InterpRegistry", False);
    SdlTkX.tkapp_atom = XInternAtom(NULL, "TK_APPLICATION", False);
    SdlTkX.wm_prot_atom = XInternAtom(NULL, "WM_PROTOCOLS", False);
    SdlTkX.wm_dele_atom = XInternAtom(NULL, "WM_DELETE_WINDOW", False);

}

int
XSendEvent(Display *display, Window w, Bool propagate, long event_mask,
	   XEvent *event_send)
{
    XEvent event;
    int ret = 0, send_nwms = 0;
    _Window *_w = NULL;

    SdlTkLock(display);
    display->request++;
    event = *event_send;
    if ((event.xany.type == ClientMessage) && (w != None) &&
	(w != PointerRoot) && (w != InputFocus) &&
	(event.xclient.message_type == SdlTkX.nwms_atom) &&
	(event.xclient.data.a[1] == SdlTkX.nwmsa_atom)) {
	int topmost = event.xclient.data.l[0];

	_w = (_Window *) event.xany.window;
	if ((_w == NULL) || (_w->display == NULL)) {
	    goto done;
	}
	if (topmost && !_w->topmost) {
	    _w->topmost = 1;
	    if (_w->parent != NULL && _w->parent->dec != NULL) {
		_w->parent->topmost = 1;
	    	SdlTkRestackWindow(_w->parent, NULL, Above);
	    } else {
	    	SdlTkRestackWindow(_w, NULL, Above);
	    }
	    SdlTkRestackTransients(_w);
	    send_nwms = 1;
	} else if (!topmost && _w->topmost) {
	    _w->topmost = 0;
	    if (_w->parent != NULL && _w->parent->dec != NULL) {
		_w->parent->topmost = 0;
		SdlTkRestackWindow(_w->parent, NULL, Above);
	    } else {
	    	SdlTkRestackWindow(_w, NULL, Above);
	    }
	    send_nwms = 1;
	}
	goto send_nwms;
    } else if ((event.xany.type == ClientMessage) && (w != None) &&
	(w != PointerRoot) && (w != InputFocus) &&
	(event.xclient.message_type == SdlTkX.nwms_atom) &&
	(event.xclient.data.a[1] == SdlTkX.nwmsf_atom)) {
	int fullscreen = event.xclient.data.l[0];

	_Window *_ww;

	_w = (_Window *) event.xany.window;
	if ((_w == NULL) || (_w->display == NULL)) {
	    goto done;
	}
       	_ww = _w;
	if (fullscreen && !_w->fullscreen) {
	    int xx, yy, ww, hh;

	    _w->atts_saved = _w->atts;
	    xx = yy = 0;
	    ww = SdlTkX.screen->width;
	    hh = SdlTkX.screen->height;
	    if ((_w->parent != NULL) && (_w->parent->dec != NULL)) {
		xx -= SdlTkX.dec_frame_width;
		yy -= SdlTkX.dec_title_height;
	    }
	    SdlTkMoveResizeWindow(display, (Window) _w, xx, yy, ww, hh);
	    while (!IS_ROOT((Window) _ww)) {
		_ww->fullscreen = 1;
		_ww = _ww->parent;
	    }
	    send_nwms = 1;
	} else if (!fullscreen && _w->fullscreen) {
	    while (!IS_ROOT((Window) _ww)) {
		_ww->fullscreen = 0;
		_ww = _ww->parent;
	    }
	    SdlTkMoveResizeWindow(display, (Window) _w,
				  _w->atts_saved.x, _w->atts_saved.y,
				  _w->atts_saved.width, _w->atts_saved.height);
	    send_nwms = 1;
	}
send_nwms:
	if (send_nwms) {
	    XPropertyEvent xproperty;

	    memset(&xproperty, 0, sizeof (xproperty));
	    xproperty.type = PropertyNotify;
	    xproperty.serial = _w->display->request;
	    xproperty.send_event = False;

    display->request++;
    SdlTkUnlock(display);
}

int
XSetTransientForHint(Display *display, Window w, Window prop_window)
{
    _Window *_w, *_p, *_parent, *oldMaster;
    int ret = 1;

    SdlTkLock(display);
    display->request++;

    _w = (_Window *) w;
    _p = (_Window *) prop_window;
    if (_w->display == NULL) {
	ret = 0;
	goto done;
    }
    oldMaster = _w->master;
    if (_p != NULL) {
	_parent = _p->parent;
	while ((_parent != NULL) && !IS_ROOT(_parent)) {
	    _p = _parent;
	    _parent = _p->parent;
	}
	if ((_p != NULL) && (_p->dec != NULL)) {

	if (SdlTkX.keyboard_window == NULL) {
	    SdlTkSetInputFocus(SdlTkX.display,
			       (Window) SdlTkWrapperForWindow(_w),
			       RevertToParent, CurrentTime);
	    /* Frames need redrawing if the focus changed. */
	    SdlTkScreenChanged();
	}
    }
    if ((_w->master != NULL) && (_w->master != oldMaster)) {
	SdlTkRestackTransients(_w->master);
    }

    SdlTkUnlock(display);
done:
    return ret;
}

#if defined(ANDROID) && defined(PLATFORM_SDL)
    const char *path, *temp;
#endif
#ifdef __APPLE__
    Tcl_ThreadId thrId;
    struct ThreadStartup startup;
    extern void SdlTkEventThread(void);
#endif

#ifdef TK_LOCAL_MAIN_HOOK
    TK_LOCAL_MAIN_HOOK(&argc, &argv);
#endif
#ifdef ANDROID
    Tcl_InitSubsystems(AndroidPanic);