winamp/Src/tataki/region/win/win32_region.cpp

#if defined _WIN64 || defined _WIN32
#include <tataki/api__tataki.h>
#include "region.h"
#include <api/imgldr/api_imgldr.h>
#include <tataki/region/api_region.h>
#include <tataki/canvas/ifc_canvas.h>
#include <api/wnd/basewnd.h>


#define GETOSHANDLE(x) (const_cast<api_region *>(x)->getOSHandle())

#define CBCLASS RegionI
START_DISPATCH;
CB(REGION_GETOSHANDLE, getOSHandle);
CB(REGION_CLONE, clone);
VCB(REGION_DISPOSECLONE, disposeClone);
CB(REGION_PTINREGION, ptInRegion);
VCB(REGION_OFFSET, offset);
VCB(REGION_GETBOX, getBox);
VCB(REGION_SUBTRACTRGN, subtractRegion);
VCB(REGION_SUBTRACTRECT, subtractRect);
VCB(REGION_ADDRECT, addRect);
VCB(REGION_ADD, addRegion);
VCB(REGION_AND, andRegion);
VCB(REGION_SETRECT, setRect);
VCB(REGION_EMPTY, empty);
CB(REGION_ISEMPTY, isEmpty);
CB(REGION_EQUALS, equals);
CB(REGION_ENCLOSED, enclosed);
CB(REGION_INTERSECTRECT, intersectRect);
CB(REGION_DOESINTERSECTRGN, doesIntersectRgn);
CB(REGION_INTERSECTRGN, intersectRgn);
CB(REGION_ISRECT, isRect);
VCB(REGION_SCALE, scale);
VCB(REGION_DEBUG, debug);
CB(REGION_MAKEWNDREGION, makeWindowRegion);
CB(REGION_GETNUMRECTS, getNumRects);
CB(REGION_ENUMRECT, enumRect);
END_DISPATCH;
#undef CBCLASS

#define CHECK_REGION \
	if (hrgn == NULL) hrgn = CreateRectRgn(0,0,0,0);

RegionI::RegionI()
{
	hrgn = CreateRectRgn(0, 0, 0, 0);
	init();
}

RegionI::RegionI(const RECT *r)
{
	hrgn = 0;
	init();
	optrect = *r;
	optimized = 1;
	//hrgn = CreateRectRgn(r->left,r->top,r->right,r->bottom);
	//if (!hrgn) hrgn = CreateRectRgn(0,0,0,0);
	//init();
	//optimize();
}

RegionI::RegionI(int l, int t, int r, int b)
{
	hrgn = 0;
	init();
	optrect.left = l;
	optrect.top = t;
	optrect.right = r;
	optrect.bottom = b;
	optimized = 1;

	//hrgn = CreateRectRgn(l,t,r,b);
	//if (!hrgn) hrgn = CreateRectRgn(0,0,0,0);
	//init();
	//optimize();
}

RegionI::RegionI(OSREGIONHANDLE r)
{
	OSREGIONHANDLE R = CreateRectRgn(0, 0, 0, 0);
	CombineRgn(R, r, r, RGN_COPY);
	hrgn = R;
	init();
	optimize();
}

RegionI::RegionI(const RegionI *copy)
{
	init();
	if (copy->optimized)
	{
		optrect = copy->optrect;
		optimized = copy->optimized;
		hrgn = 0;
	}
	else
	{
		hrgn = CreateRectRgn(0, 0, 0, 0);
		CombineRgn(hrgn, copy->hrgn, copy->hrgn, RGN_COPY);
	}
}

RegionI::RegionI(Canvas *c, RECT *defbounds)
{
	hrgn = CreateRectRgn(0, 0, 0, 0);
	if (!GetClipRgn(c->getHDC(), hrgn))
	{
		if (defbounds != NULL)
		{
			SetRectRgn(hrgn, defbounds->left, defbounds->top, defbounds->right, defbounds->bottom);
			optrect=*defbounds;
			optimized=1;
		}
	}
	init();
	optimize();
}

RegionI::~RegionI()
{
	delete lastdebug;
	if (srv != NULL) srv->delRef(this);
	ASSERT(clonecount == 0);
	if (srv == NULL && hrgn != NULL) DeleteObject(hrgn);
}

void RegionI::init()
{
	srv = NULL;
	clonecount = 0;
	lastdebug = NULL;
	optimized = 0;
}

api_region *RegionI::clone()
{
	api_region *newregion = new RegionI(this);
	clonecount++;
	return newregion;
}

void RegionI::disposeClone(api_region *r)
{
	RegionI *ri = static_cast<RegionI *>(r);
	delete ri; // todo: validate pointer before deleting
	clonecount--;
}

// returns a handle that SetWindowRgn understands (non portable). We should NOT delete this handle, windows will delete
// it by itself upon setting a new region of destroying the window
OSREGIONHANDLE RegionI::makeWindowRegion()
{
	deoptimize();
	OSREGIONHANDLE R = CreateRectRgn(0, 0, 0, 0);
	CombineRgn(R, hrgn, hrgn, RGN_COPY);
	optimize();
	return R;
}

RegionI::RegionI(SkinBitmap *bitmap, RECT *r, int xoffset, int yoffset, bool inverted, int dothreshold, char threshold, int thinverse, int minalpha)
{
	init();
	const wchar_t *id = bitmap->getBitmapName();

	if (xoffset == 0 && yoffset == 0 && r == NULL && !inverted && !dothreshold && minalpha == 1 && id != NULL && *id != 0)
	{
		srv = WASABI_API_IMGLDR->imgldr_requestSkinRegion(id);
		if (srv != NULL)
		{
			srv->addRef(this);
			hrgn = srv->getRegion()->getOSHandle();
		}
	}

	if (srv == NULL)
	{
		if (r)
			hrgn = alphaToRegionRect(bitmap, xoffset, yoffset, TRUE, r->left, r->top, r->right - r->left, r->bottom - r->top, inverted, dothreshold, threshold, thinverse, minalpha);
		else
			hrgn = alphaToRegionRect(bitmap, xoffset, yoffset, FALSE, 0, 0, 0, 0, inverted, dothreshold, threshold, thinverse, minalpha);

		if (id != NULL && *id != 0)
		{
			if (xoffset == 0 && yoffset == 0 && r == NULL && !inverted && !dothreshold && minalpha == 1)
			{
				WASABI_API_IMGLDR->imgldr_cacheSkinRegion(id, this);
				srv = WASABI_API_IMGLDR->imgldr_requestSkinRegion(id);
				if (srv != NULL)
				{
					srv->addRef(this);
					DeleteObject(hrgn);
					hrgn = srv->getRegion()->getOSHandle();
				}
			}
		}
	}
	optimize();

}

OSREGIONHANDLE RegionI::alphaToRegionRect(SkinBitmap *bitmap, int xoffset, int yoffset, bool portion, int _x, int _y, int _w, int _h, bool inverted, int dothreshold, unsigned char threshold, int thinverse, int minalpha)
{
	return alphaToRegionRect(bitmap->getBits(), bitmap->getX(), bitmap->getY(), bitmap->getWidth(), bitmap->getHeight(), bitmap->getFullWidth(), bitmap->getFullHeight(), xoffset, yoffset, portion, _x, _y, _w, _h, inverted, dothreshold, threshold, thinverse, minalpha);
}

OSREGIONHANDLE RegionI::alphaToRegionRect(void *pbits32, int bmX, int bmY, int bmWidth, int bmHeight, int fullw, int fullh, int xoffset, int yoffset, bool portion, int _x, int _y, int _w, int _h, bool inverted, int dothreshold, unsigned char threshold, int thinverse, int minalpha)
{
	OSREGIONHANDLE hRgn = NULL;
	if (!pbits32) return NULL;

	RGNDATA *pData;
	int y, x;

	// For better performances, we will use the ExtCreateRegion() function to create the
	// region. This function take a RGNDATA structure on entry. We will add rectangles by
	// amount of ALLOC_UNIT number in this structure.
	// JF> rects are 8 bytes, so this allocates just under 16kb of memory, no need to REALLOC
#define MAXRECTS 2000
	__int8 regionMemory[sizeof(RGNDATAHEADER) + (sizeof(RECT) * MAXRECTS)] = {0};
	//pData = (RGNDATA *)MALLOC(sizeof(RGNDATAHEADER) + (sizeof(RECT) * MAXRECTS));
	pData = (RGNDATA *)regionMemory;
	//if (!pData) return NULL;

	pData->rdh.dwSize = sizeof(RGNDATAHEADER);
	pData->rdh.iType = RDH_RECTANGLES;
	pData->rdh.nCount = pData->rdh.nRgnSize = 0;

	SetRect(&pData->rdh.rcBound, MAXLONG, MAXLONG, 0, 0);

	int x_end = (portion ? _w + _x : bmWidth);
	int y_end = (portion ? _h + _y : bmHeight);
	int x_start = (portion ? _x : 0);
	int y_start = (portion ? _y : 0);

	x_start += bmX;
	x_end += bmX;
	y_start += bmY;
	y_end += bmY;

	unsigned int iv = minalpha << 24; //inverted?0xff000000:0;

	int shiftx = xoffset - bmX;
	int shifty = yoffset - bmY;

	for (y = y_start; y < y_end; y++)
	{
		// Scan each bitmap pixel from left to right
		unsigned int *lineptr = ((unsigned int *)pbits32) + fullw * y;
		for (x = x_start; x < x_end; x++)
		{
			// Search for a continuous range of "non transparent pixels"
			int x0 = x;
			unsigned int *p = lineptr;
			if (dothreshold)
			{
				if (inverted)
				{
					if (thinverse)
					{
						while (x < x_end)
						{
							unsigned int a = p[x];
							if ((a&0xff000000) >= iv ||
							    (((((a & 0xFF) > threshold || ((a & 0xFF00) >> 8) > threshold || ((a & 0xFF0000) >> 16) > threshold)))))
								break;
							x++;
						}
					}
					else
					{
						while (x < x_end)
						{
							unsigned int a = p[x];
							if ((a&0xff000000) >= iv ||
							    (((((a & 0xFF) < threshold || ((a & 0xFF00) >> 8) < threshold || ((a & 0xFF0000) >> 16) < threshold)))))
								break;
							x++;
						}
					}
				}
				else
				{
					if (thinverse)
					{
						while (x < x_end)
						{
							unsigned int a = p[x];
							if ((a&0xff000000) < iv ||
							    (((((a & 0xFF) > threshold || ((a & 0xFF00) >> 8) > threshold || ((a & 0xFF0000) >> 16) > threshold)))))
								break;
							x++;
						}
					}
					else
					{
						while (x < x_end)
						{
							unsigned int a = p[x];
							if ((a&0xff000000) < iv ||
							    (((((a & 0xFF) < threshold || ((a & 0xFF00) >> 8) < threshold || ((a & 0xFF0000) >> 16) < threshold)))))
								break;
							x++;
						}
					}
				}
			}
			else
			{
				if (inverted)
				{
					while (x < x_end)
					{
						if ((p[x] & 0xFF000000) >= iv) break;
						x++;
					}
				}
				else
				{
					while (x < x_end)
					{
						if ((p[x] & 0xFF000000) < iv) break;
						x++;
					}
				}
			}

			if (x > x0)
			{
				SetRect(((RECT *)&pData->Buffer) + pData->rdh.nCount, x0 + shiftx, y + shifty, x + shiftx, y + 1 + shifty);

				pData->rdh.nCount++;

				if (x0 + shiftx < pData->rdh.rcBound.left) pData->rdh.rcBound.left = x0 + shiftx;
				if (y + shifty < pData->rdh.rcBound.top) pData->rdh.rcBound.top = y + shifty;
				if (x + shiftx > pData->rdh.rcBound.right) pData->rdh.rcBound.right = x + shiftx;
				if (y + 1 + shifty > pData->rdh.rcBound.bottom) pData->rdh.rcBound.bottom = y + 1 + shifty;

				// On Windows98, ExtCreateRegion() may fail if the number of rectangles is too
				// large (ie: > 4000). Therefore, we have to create the region by multiple steps.
				if (pData->rdh.nCount == MAXRECTS)
				{
					OSREGIONHANDLE h = ExtCreateRegion(NULL, sizeof(RGNDATAHEADER) + (sizeof(RECT) * pData->rdh.nCount), pData);
					if (hRgn)
					{
						CombineRgn(hRgn, hRgn, h, RGN_OR);
						DeleteObject(h);
					}
					else hRgn = h;
					pData->rdh.nCount = 0;
					SetRect(&pData->rdh.rcBound, MAXLONG, MAXLONG, 0, 0);
				}
			}
		}
	}

	// Create or extend the region with the remaining rectangles
	OSREGIONHANDLE h = ExtCreateRegion(NULL, sizeof(RGNDATAHEADER) + (sizeof(RECT) * pData->rdh.nCount), pData);
	if (hRgn)
	{
		CombineRgn(hRgn, hRgn, h, RGN_OR);
		DeleteObject(h);
	}
	else
		hRgn = h;

	// Clean up
	//FREE(pData);

	return hRgn;
}

bool RegionI::ptInRegion(const POINT *pt)
{
	if (optimized) return !!PtInRect(&optrect, *pt);
	CHECK_REGION
	return !!PtInRegion(hrgn, pt->x, pt->y);
}

void RegionI::offset(int x, int y)
{
	if (optimized)
	{
		optrect.left += x;
		optrect.top += y;
		optrect.right += x;
		optrect.bottom += y;
		return ;
	}
	CHECK_REGION
	if (srv)
	{
		hrgn = CreateRectRgn(0, 0, 0, 0);
		RegionServer *s = srv;
		srv = NULL;
		addRegion(s->getRegion());
		s->delRef(this);
	}
	if (x == 0 && y == 0) return ;
	deoptimize(); // because addregion may have optimized it
	OffsetRgn(hrgn, x, y);
	optimize();
}

void RegionI::getBox(RECT *r)
{
	if (optimized)
	{
		*r = optrect;
		return ;
	}
	CHECK_REGION
	GetRgnBox(hrgn, r);
}

OSREGIONHANDLE RegionI::getOSHandle()
{
	deoptimize();
	CHECK_REGION
	return hrgn;
}

void RegionI::subtractRect(const RECT *r)
{
	RegionI s(r);
	subtractRegion(&s);
}

void RegionI::subtractRegion(const api_region *reg)
{
	if (srv)
	{
		hrgn = CreateRectRgn(0, 0, 0, 0);
		RegionServer *s = srv;
		srv = NULL;
		addRegion(s->getRegion());
		s->delRef(this);
	}
	deoptimize();
	CombineRgn(hrgn, hrgn, GETOSHANDLE(reg), RGN_DIFF);
	optimize();
}

void RegionI::andRegion(const api_region *reg)
{
	if (srv)
	{
		hrgn = CreateRectRgn(0, 0, 0, 0);
		RegionServer *s = srv;
		srv = NULL;
		addRegion(s->getRegion());
		s->delRef(this);
	}

	deoptimize();
	CombineRgn(hrgn, hrgn, GETOSHANDLE(reg), RGN_AND);
	optimize();
}

void RegionI::addRect(const RECT *r)
{
	RegionI a(r);
	addRegion(&a);
}

void RegionI::addRegion(const api_region *reg)
{
	if (srv)
	{
		hrgn = CreateRectRgn(0, 0, 0, 0);
		RegionServer *s = srv;
		srv = NULL;
		addRegion(s->getRegion());
		s->delRef(this);
	}
	deoptimize();
	ASSERT(reg != NULL);
	CombineRgn(hrgn, hrgn, GETOSHANDLE(reg), RGN_OR);
	optimize();
}

int RegionI::isEmpty()
{
	RECT r;
	getBox(&r);
	if (r.left == r.right || r.bottom == r.top) return 1;
	return 0;
}

int RegionI::enclosed(const api_region *r, api_region *outside)
{
	deoptimize();
	OSREGIONHANDLE del = NULL;
	if (!outside)
		del = CreateRectRgn(0, 0, 0, 0);
	int rs = CombineRgn(outside ? outside->getOSHandle() : del, hrgn, GETOSHANDLE(r), RGN_DIFF);
	if (del != NULL) DeleteObject(del);
	optimize();
	return rs == NULLREGION;
}

#define IntersectRgn(hrgnResult, hrgnA, hrgnB) CombineRgn(hrgnResult, hrgnA, hrgnB, RGN_AND)

int RegionI::intersectRgn(const api_region *r, api_region *intersection)
{
	ASSERT(intersection != NULL);
	ASSERT(intersection != this);
	int rs;
	if (optimized)
	{
		deoptimize();
		rs = IntersectRgn(intersection->getOSHandle(), hrgn, GETOSHANDLE(r));
		DeleteObject(hrgn);
		hrgn=NULL;
		optimized=1;
	}
	else
	{
		rs = IntersectRgn(intersection->getOSHandle(), hrgn, GETOSHANDLE(r));
	}

	return (rs != NULLREGION && rs != ERROR);
}

int RegionI::doesIntersectRgn(const api_region *r)
{
	if (optimized)
	{
		return RectInRegion(GETOSHANDLE(r), &optrect);
	}
	else
	{
		CHECK_REGION
		HRGN del = CreateRectRgn(0, 0, 0, 0);
		int rs = IntersectRgn(del, hrgn, GETOSHANDLE(r));
		DeleteObject(del);
		return (rs != NULLREGION && rs != ERROR);
	}

}

int RegionI::intersectRect(const RECT *r, api_region *intersection)
{
	int	rs;
	ASSERT(intersection != NULL);
	ASSERT(intersection != this);
	if (optimized)
	{
		RECT temp = optrect;
		rs = IntersectRect(&temp, &optrect, r);
		intersection->setRect(&temp);
		return rs;
	}
	else
	{
		CHECK_REGION

		OSREGIONHANDLE iRgn = intersection->getOSHandle();
		SetRectRgn(iRgn, r->left, r->top, r->right, r->bottom);
		rs = IntersectRgn(iRgn, hrgn, iRgn);
	}
	return (rs != NULLREGION && rs != ERROR);
}

int RegionI::doesIntersectRect(const RECT *r)
{
	return RectInRegion(hrgn, r);
}

void RegionI::empty()
{
	if (srv)
	{
		hrgn = CreateRectRgn(0, 0, 0, 0);
		ASSERT(hrgn != NULL);
		srv->delRef(this);
		srv = NULL;
		optimize();
		return ;
	}
	//deoptimize();
	if (hrgn != NULL)
		DeleteObject(hrgn);
	hrgn=NULL;
	//hrgn = CreateRectRgn(0, 0, 0, 0);
	optrect.left=0;
	optrect.top=0;
	optrect.right=0;
	optrect.bottom=0;
	optimized=1;
	//ASSERT(hrgn != NULL);
	//optimize();
}

void RegionI::setRect(const RECT *r)
{
	if (srv)
	{
		hrgn = CreateRectRgnIndirect(r);
		srv->delRef(this);
		srv = NULL;
		optimize();
		return ;
	}
	//deoptimize();
	//CHECK_REGION
		if (hrgn)
			DeleteObject(hrgn);
	hrgn=NULL;
	//SetRectRgn(hrgn, r->left, r->top, r->right, r->bottom);
	optrect = *r;
	optimized = 1;
	//optimize();
}

int RegionI::equals(const api_region *r)
{
	ASSERT(r);
	api_region *cl = const_cast<api_region*>(r)->clone();
	cl->subtractRegion(this);
	int ret = cl->isEmpty();
	const_cast<api_region*>(r)->disposeClone(cl);
	cl = clone();
	cl->subtractRegion(r);
	ret &= cl->isEmpty();
	disposeClone(cl);
	return ret;
}

int RegionI::isRect()
{
	if (optimized) return 1;
	RECT r;
	getBox(&r);
	RegionI n(&r);
	return equals(&n);
}

void RegionI::scale(double sx, double sy, bool round)
{
	if (srv)
	{
		hrgn = CreateRectRgn(0, 0, 0, 0);
		RegionServer *s = srv;
		srv = NULL;
		addRegion(s->getRegion());
		s->delRef(this);
	}
	deoptimize();
	CHECK_REGION
	DWORD size = 0;
	RECT box;
	getBox(&box);
	size = GetRegionData(hrgn, size, NULL);
	if (!size) return ;
	RGNDATA *data = (RGNDATA *)MALLOC(size);
	RECT *r = (RECT *)data->Buffer;

	GetRegionData(hrgn, size, (RGNDATA *)data);
	double adj = round ? 0.99999 : 0.0;
	int iadj = round ? 1 : 0;

	if (data->rdh.nCount == 1)
	{
		RECT nr = box;
		nr.left = (int)((double)nr.left * sx - iadj);
		nr.top = (int)((double)nr.top * sy - iadj);
		nr.right = (int)((double)nr.right * sx + adj);
		nr.bottom = (int)((double)nr.bottom * sy + adj);
		setRect(&nr);
		FREE(data);
		return ;
	}

	for (int i = 0;i < (int)data->rdh.nCount;i++)
	{
		r[i].left = (int)((double)r[i].left * sx - iadj);
		r[i].top = (int)((double)r[i].top * sy - iadj);
		r[i].right = (int)((double)r[i].right * sx + adj);
		r[i].bottom = (int)((double)r[i].bottom * sy + adj);
	}

	OSREGIONHANDLE nhrgn = ExtCreateRegion(NULL, size, data);
	if (!nhrgn)
	{
		nhrgn = CreateRectRgn(0, 0, 0, 0);
	}
	FREE(data);
	DeleteObject(hrgn);
	hrgn = nhrgn;
	optimize();
}

void RegionI::debug(int async)
{
	if (!async)
	{
		SysCanvas c;
		RECT r;
		getBox(&r);
		//    c.fillRect(&r, 0);
		InvertRgn(c.getHDC(), getOSHandle());
		Sleep(200);
		InvertRgn(c.getHDC(), getOSHandle());
	}
	else
	{
		SysCanvas c;
		RECT r;
		getBox(&r);
		//    c.fillRect(&r, 0);
		if (lastdebug)
			InvertRgn(c.getHDC(), lastdebug->getOSHandle());
		delete lastdebug;
		lastdebug = new RegionI();
		lastdebug->addRegion(this);
		InvertRgn(c.getHDC(), getOSHandle());
	}
}

// later we can cache this data or something if needed
int RegionI::getNumRects()
{
	if (optimized) return 1;
	int bytes_needed = GetRegionData(hrgn, 0, NULL) + sizeof(RGNDATA);
	MemBlock<unsigned char> data(bytes_needed);
	GetRegionData(hrgn, bytes_needed, (LPRGNDATA)data.getMemory());
	RGNDATA *rgndata = reinterpret_cast<RGNDATA *>(data.getMemory());
	return rgndata->rdh.nCount;
}

int RegionI::enumRect(int n, RECT *r)
{
	if (optimized)
	{
		if (n == 0)
		{
			if (r != NULL) *r = optrect;
			return 1;
		}
		return 0;
	}
	if (n < 0) return 0;
	int bytes_needed = GetRegionData(hrgn, 0, NULL) + sizeof(RGNDATA);
	MemBlock<unsigned char> data(bytes_needed);
	GetRegionData(hrgn, bytes_needed, (LPRGNDATA)data.getMemory());
	RGNDATA *rgndata = reinterpret_cast<RGNDATA *>(data.getMemory());
	int nrects = rgndata->rdh.nCount;
	if (n >= nrects) return 0;
	RECT *rectlist = reinterpret_cast<RECT*>(rgndata->Buffer);
	*r = rectlist[n];
	return 1;
}

void RegionI::optimize()
{
	if (optimized) return ;
	if (srv != NULL) return ; // region is cached and shared, do not optimize
	CHECK_REGION
	getBox(&optrect);

	if (IsRectEmpty(&optrect))
		return;

	RECT br;
	OSREGIONHANDLE gr = CreateRectRgnIndirect(&optrect);
	OSREGIONHANDLE res = CreateRectRgn(0, 0, 0, 0);

/*
	// if they don't intersect, we may be offset
	IntersectRgn(res, gr, hrgn);
	GetRgnBox(res, &br);
	if (br.left == br.right || br.bottom == br.top)
	{
		DeleteObject(gr);
		DeleteObject(res);
		return ;
	}
	*/

	// if they intersect, but when subtracting the region from the rect, we get nothing, they're the same, let's optimize
	CombineRgn(res, gr, hrgn, RGN_DIFF);
	DeleteObject(gr);
	GetRgnBox(res, &br);
	DeleteObject(res);
	if (br.left == br.right || br.bottom == br.top)
	{
		optimized = 1;
		DeleteObject(hrgn);
		hrgn = NULL;
	}
}

void RegionI::deoptimize()
{
	if (!optimized) return ;
	CHECK_REGION
	SetRectRgn(hrgn, optrect.left, optrect.top, optrect.right, optrect.bottom);
	//if (hrgn != NULL) { DeleteObject(hrgn); hrgn = NULL; }
	//hrgn = CreateRectRgnIndirect(&optrect);
	//CHECK_REGION
	optimized = 0;
}


#define CBCLASS RegionServerI
START_DISPATCH;
VCB(REGIONSERVER_ADDREF, addRef);
VCB(REGIONSERVER_DELREF, delRef);
CB(REGIONSERVER_GETREGION, getRegion);
END_DISPATCH;

#endif//WIN32