winamp/Src/Wasabi/api/wnd/basewnd.cpp

#include <precomp.h>

#include <bfc/wasabi_std.h>
#include <bfc/wasabi_std_wnd.h>
#include <api/wnd/wndevent.h>

#include <bfc/bfc_assert.h>
#include <api/wnd/wndclass/tooltip.h>
#include <api/wnd/cursor.h>
#include <api/wnd/accessible.h>
#include <api/service/svcs/svc_accessibility.h>
#include <api/wnd/paintsets.h>
#include <api/wnd/PaintCanvas.h>

#ifdef _WIN32
#include <shellapi.h>	// for HDROP
#endif
#include <tataki/canvas/bltcanvas.h>

#define DESKTOPALPHA
#define REFRESH_RATE 25
#define DRAWTIMERID 125

#include <api/wnd/basewnd.h>
#include <api/wnd/usermsg.h>

#include <api/wnd/paintcb.h>
#include <tataki/canvas/canvas.h>
#include <bfc/file/filename.h>
#include <tataki/region/region.h>
#include <api/wnd/wndclass/guiobjwnd.h>
#include <api/script/scriptguid.h>
#include <api/wnd/notifmsg.h>
#include <api/metrics/metricscb.h>

#include <api/wndmgr/gc.h>
#include <api/wndmgr/layout.h>

namespace Agave
{
	#include "../Agave/Config/api_config.h"
}



//#define TIP_TIMER_ID        1601
#define TIP_DESTROYTIMER_ID 1602
#define TIP_AWAY_ID         1603
#define TIP_AWAY_DELAY       100

#define TIP_TIMER_THRESHOLD  350
#define TIP_LENGTH          3000

#define VCHILD_TIMER_ID_MIN	2000
#define VCHILD_TIMER_ID_MAX	2100

#define BUFFEREDMSG_TIMER_ID 1604

#define DEFERREDCB_INVALIDATE   0x201 // move to .h
#define DEFERREDCB_FOCUSFIRST   0x202 // move to .h
#define DC_KILLGHOST            0x204

#ifdef _WIN32
#define WM_DEFER_CALLBACK (WM_USER+0x333)
#endif
class DragSet : public PtrList<void>, public NamedW {};

//CUT? static void register_wndClass(HINSTANCE);

//CUT? #define ROOTSTRING "RootWnd"

//CUT? #define BASEWNDCLASSNAME "BaseWindow_" ROOTSTRING

#ifndef WM_MOUSEWHEEL
#define WM_MOUSEWHEEL 0x20A
#endif

static ifc_window *stickyWnd;
static RECT sticky;

static UINT WINAMP_WM_DIRECT_MOUSE_WHEEL = WM_NULL;

/*api_window *api_window::rootwndFromPoint(POINT &point, int level) {
  api_window *wnd;
  wnd = WASABI_API_WND->rootWndFromPoint(&point);
  return api_window::rootwndFromRootWnd(wnd, level, &point);
}

api_window *api_window::rootwndFromRootWnd(api_window *wnd, int level, POINT *point) {

  for (;;) {
    if (wnd == NULL || level < 0) return NULL;
    if (point) {
      RECT r;
      wnd->getWindowRect(&r);
      if (!PtInRect(&r, *point)) return NULL; // PORT ME
    }
    if (level == 0) return wnd;
    wnd = wnd->getRootWndParent();
    level--;
  }
  // should never get here
}*/

static BOOL DisabledWindow_OnMouseClick(HWND hwnd)
{
	DWORD windowStyle = (DWORD)GetWindowLongPtrW(hwnd, GWL_STYLE);
	if (WS_DISABLED != ((WS_CHILD | WS_DISABLED) & windowStyle))
		return FALSE;

	HWND hActive = GetActiveWindow();
	HWND hPopup = GetWindow(hwnd, GW_ENABLEDPOPUP);

	BOOL beepOk = (hPopup == hActive || hwnd == GetWindow(hActive, GW_OWNER));
	if (!beepOk && NULL == hPopup)
	{
		for (HWND hWalker = hwnd; ;)
		{											
			hWalker = GetWindow(hWalker, GW_OWNER);
			if (NULL == hWalker || (0 != (WS_CHILD & GetWindowLongPtrW(hWalker, GWL_STYLE))))
				break;
			if (hActive == GetWindow(hWalker, GW_ENABLEDPOPUP))
			{
				beepOk = TRUE;
				break;
			}
		}
	}
	
	if (beepOk)
	{	
		static const GUID accessibilityConfigGroupGUID = 
		{ 0xe2e7f4a, 0x7c51, 0x478f, { 0x87, 0x74, 0xab, 0xbc, 0xf6, 0xd5, 0xa8, 0x57 } };

		#define GetBoolConfig(__group, __itemName, __default)\
			((NULL != (__group)) && NULL != (item = group->GetItem(__itemName)) ? item->GetBool() : (__default))

		waServiceFactory *serviceFactory = WASABI_API_SVC->service_getServiceByGuid(Agave::AgaveConfigGUID);
		Agave::api_config *config = (NULL != serviceFactory) ? (Agave::api_config *)serviceFactory->getInterface() : NULL;
		Agave::ifc_configgroup *group = (NULL != config) ? config->GetGroup(accessibilityConfigGroupGUID) : NULL;
		Agave::ifc_configitem *item;
				
		if (GetBoolConfig(group, L"modalflash", true))
		{
			FLASHWINFO flashInfo;
			flashInfo.cbSize = sizeof(FLASHWINFO);
			flashInfo.hwnd = hActive;
			flashInfo.dwFlags = FLASHW_CAPTION;
			flashInfo.uCount = 2;
			flashInfo.dwTimeout = 100;
			FlashWindowEx(&flashInfo);
		}

		if (GetBoolConfig(group, L"modalbeep", false))
			MessageBeep(MB_OK);

		if (NULL != config)
			serviceFactory->releaseInterface(config);
	}
	else
	{		
		for (HWND hWalker = hwnd; NULL == hPopup;)
		{											
			hWalker = GetWindow(hWalker, GW_OWNER);
			if (NULL == hWalker || (0 != (WS_CHILD & GetWindowLongPtrW(hWalker, GWL_STYLE))))
				break;
			hPopup = GetWindow(hWalker, GW_ENABLEDPOPUP);
		}

		SetWindowPos(hwnd, HWND_TOP, 0, 0, 0, 0, SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOMOVE);
		if (NULL != hPopup && hPopup != hwnd)
		{
			BringWindowToTop(hPopup);
			SetActiveWindow(hPopup);
		}
	}

	return TRUE;
}
int WndWatcher::viewer_onItemDeleted(ifc_dependent *item)
{
	if (item == dep)
	{
		dep = NULL;
		watcher->wndwatcher_onDeleteWindow(watched);
		watched = NULL;
	}
	return 1;
}

BaseWnd::BaseWnd()
{
	uiwaslocked = 0;
	m_takenOver = 0;
	rootfocus = NULL;
	rootfocuswatcher.setWatcher(this);
	alwaysontop = 0;
	customdefaultcursor = NULL;
	preventcancelcapture = 0;
	ratiolinked = 1;
	deleting = 0;
	hinstance = NULL;
	hwnd = NULL;
	parentWnd = NULL;
	dragging = 0;
	prevtarg = NULL;
	inputCaptured = 0;
	btexture = NULL;
	postoninit = 0;
	inited = 0;
	skipnextfocus = 0;
	ncb = FALSE;
	accessible = NULL;

	tooltip = NULL;
	tip_done = FALSE;
	tipshowtimer = FALSE;
	tipawaytimer = FALSE;
	tipdestroytimer = FALSE;
	start_hidden = 0;
	notifyWindow = NULL;
	lastClick[0] = 0;
	lastClick[1] = 0;
	lastClickP[0].x = 0;
	lastClickP[0].y = 0;
	lastClickP[1].x = 0;
	lastClickP[1].y = 0;
	destroying = FALSE;

	curVirtualChildCaptured = NULL;
	curVirtualChildFocus = NULL;

	virtualCanvas = NULL; virtualCanvasH = virtualCanvasW = 0;
	deferedInvalidRgn = NULL;

	hasfocus = 0;
	focus_on_click = 1;
	lastnullregion = 0;
	ratio = 1;
	lastratio = 1;
	rwidth = rheight = 0;
	skin_id = -1;
	wndalpha = 255;
	activealpha = 255;
	inactivealpha = 255;
	w2k_alpha = 0; //FUCKO
	scalecanvas = NULL;
	clickthrough = 0;

	mustquit = 0;
	returnvalue = 0;
	notifyid = 0;
	cloaked = 0;
	disable_tooltip_til_recapture = 0;

	subtractorrgn = NULL;
	composedrgn = NULL;
	wndregioninvalid = 1;
	regionop = REGIONOP_NONE;
	rectrgn = 1;
	need_flush_cascaderepaint = 0;
	deferedCascadeRepaintRgn = NULL;
	this_visible = 0;
	this_enabled = 1;
	renderbasetexture = 0;
	oldCapture = NULL;
	my_guiobject = NULL;
	want_autoresize_after_init = 0;
	resizecount = 0;
	suggested_w = 320;
	suggested_h = 200;
	maximum_w = maximum_h = AUTOWH;
	minimum_w = minimum_h = AUTOWH;
	rx = 0;
	ry = 0;
	rwidth = 0;
	rheight = 0;
	allow_deactivate = 1;
	minimized = 0;
	inonresize = 0;
#ifndef WA3COMPATIBILITY
	m_target = NULL;
#endif

	nodoubleclick = noleftclick = norightclick = nomousemove = nocontextmnu = 0;
	focusEventsEnabled = 1;
	maximized = 0;
	MEMSET(&restore_rect, 0, sizeof(RECT));
	ghostbust = 0;

	lastActiveWnd = NULL;
}

BaseWnd::~BaseWnd()
{
	//ASSERT(virtualChildren.getNumItems() == 0);
	childtabs.deleteAll();
	if (WASABI_API_WND && WASABI_API_WND->getModalWnd() == this) WASABI_API_WND->popModalWnd(this);
	destroying = TRUE;
	curVirtualChildFocus = NULL;
#ifdef _WIN32
	if (inputCaptured && GetCapture() == getOsWindowHandle()) ReleaseCapture();
#else
#warning port me
#endif

	for (int i = 0;i < ghosthwnd.getNumItems();i++)
		Wasabi::Std::Wnd::destroyWnd(ghosthwnd.enumItem(i));

	if (hwnd != NULL && !m_takenOver)
	{
#ifdef URLDROPS
		if (acceptExternalDrops()) Wasabi::Std::Wnd::revokeDragNDrop(hwnd /*, &m_target*/);
#else
#ifndef WA3COMPATIBILITY
		if (m_target != NULL)
		{
			Wasabi::Std::Wnd::revokeDragNDrop(hwnd);
		}
#endif
#endif
		int popact = !wantActivation();
		if (popact) WASABI_API_WND->appdeactivation_push_disallow(this);

		Wasabi::Std::Wnd::destroyWnd(hwnd);

		if (popact) WASABI_API_WND->appdeactivation_pop_disallow(this);
	}

	deleteFrameBuffer(virtualCanvas);
	virtualCanvas = NULL;
	delete scalecanvas;
	scalecanvas = NULL;

	resetDragSet();

	notifyParent(ChildNotify::DELETED);
	if (tipdestroytimer)
		killTimer(TIP_DESTROYTIMER_ID);
	if (tipshowtimer)
	{
		// TODO: on the mac, use CreateMouseTrackingRegion
		TRACKMOUSEEVENT tracker;
		tracker.cbSize=sizeof(tracker);
		tracker.dwFlags = TME_HOVER|TME_CANCEL;
		tracker.hwndTrack = this->getOsWindowHandle();
		tracker.dwHoverTime = TIP_TIMER_THRESHOLD;

		TrackMouseEvent(&tracker);

	}
	if (tipawaytimer)
		killTimer(TIP_AWAY_ID);

	destroyTip();

	delete tooltip;

	if (uiwaslocked)
		killTimer(BUFFEREDMSG_TIMER_ID);

	if (deferedInvalidRgn)
		delete deferedInvalidRgn;

	delete composedrgn;
	delete subtractorrgn;
	delete deferedCascadeRepaintRgn;

	if (parentWnd != NULL)
		parentWnd->unregisterRootWndChild(this);

	if (!m_takenOver && WASABI_API_WND) WASABI_API_WND->unregisterRootWnd(this);
	hwnd = NULL;
}

int BaseWnd::init(ifc_window *parWnd, int nochild)
{
	if (parWnd == NULL)
		return 0;

	OSWINDOWHANDLE phwnd = parWnd->getOsWindowHandle();
	ASSERT(phwnd != NULL);

	parentWnd = parWnd;	// set default parent wnd
	int ret = init(parWnd->getOsModuleHandle(), phwnd, nochild);

	if (!ret)
		parentWnd = NULL;	// abort

	return ret;
}

int BaseWnd::init(OSMODULEHANDLE moduleHandle, OSWINDOWHANDLE parent, int nochild)
{
	RECT r;
	int w, h;

	ASSERTPR(getOsWindowHandle() == NULL, "don't you double init you gaybag");

	hinstance = moduleHandle;

#ifdef _WIN32
	ASSERT(hinstance != NULL);
#endif

	//CUT  register_wndClass(hinstance);

	if (parent != NULL)
	{
		Wasabi::Std::Wnd::getClientRect(parent, &r);
	}
	else
	{
		Wasabi::Std::setRect(&r, 0, 0, getPreferences(SUGGESTED_W), getPreferences(SUGGESTED_H));
	}

	w = (r.right - r.left);
	h = (r.bottom - r.top);

	rwidth  = w;
	rheight = h;
	rx      = r.left;
	ry      = r.top;

	int popact = !wantActivation();
	if (popact) WASABI_API_WND->appdeactivation_push_disallow(this);

	//CUThwnd = createWindow(r.left, r.top, w, h, nochild, parent, hinstance);
	hwnd = Wasabi::Std::Wnd::createWnd(&r, nochild, acceptExternalDrops(), parent, hinstance, static_cast<ifc_window*>(this));
#ifdef __APPLE__
#warning remove me
	Wasabi::Std::Wnd::showWnd(hwnd);
#endif

	if (popact) WASABI_API_WND->appdeactivation_pop_disallow(this);

	//ASSERT(hwnd != NULL); // lets fail nicely, this could happen for some win32 reason, we don't want to fail the whole app for it, so lets just fail the wnd
	if (hwnd == NULL) return 0;

	if (wantActivation()) bringToFront();

	//CUT  nreal++;

	//FUCKO
#ifdef _WIN32 // PORT ME
#ifdef URLDROPS
	if (acceptExternalDrops()) RegisterDragDrop(hwnd, &m_target);
#else
#ifndef WA3COMPATIBILITY
	if (!m_target && WASABI_API_WND != NULL)
		m_target = WASABI_API_WND->getDefaultDropTarget();
	if (m_target != NULL)
	{
		RegisterDragDrop(hwnd, (IDropTarget *)m_target);
	}
#endif
#endif
#endif

	this_visible = 0;

	onInit();

	this_visible = !start_hidden;

	onPostOnInit();

	return 1;
}

#ifndef WA3COMPATIBILITY
void BaseWnd::setDropTarget(void *dt)
{
#ifdef _WIN32
	if (isVirtual()) return ;
	if (isInited() && m_target != NULL)
	{
		Wasabi::Std::Wnd::revokeDragNDrop(getOsWindowHandle());
		m_target = NULL;
	}
	m_target = dt;
	if (m_target != NULL && isInited())
	{
		RegisterDragDrop(gethWnd(), (IDropTarget *)m_target);
	}
#else
#warning port me
#endif
}

void *BaseWnd::getDropTarget()
{
	return m_target;
}
#endif

int BaseWnd::onInit()
{

	const wchar_t *s = getName();
	if (s != NULL)
		setOSWndName(s);

	inited = 1;

	if (getParent())
		getParent()->registerRootWndChild(this);

	if (WASABI_API_WND != NULL)
		WASABI_API_WND->registerRootWnd(this);

#ifdef _WIN32
	if (!Wasabi::Std::Wnd::isDesktopAlphaAvailable())
		w2k_alpha = 0; //FUCKO

	if (w2k_alpha)
	{
		setLayeredWindow(1);
	}

	if (WM_NULL == WINAMP_WM_DIRECT_MOUSE_WHEEL)
		WINAMP_WM_DIRECT_MOUSE_WHEEL = RegisterWindowMessageW(L"WINAMP_WM_DIRECT_MOUSE_WHEEL");

#endif

	return 0;
}

int BaseWnd::onPostOnInit()
{
	postoninit = 1; // from now on, isInited() returns 1;
	if (want_autoresize_after_init) onResize();
	else invalidateWindowRegion();
	if (isVisible()) onSetVisible(1);
	if (getTabOrder() == -1) setAutoTabOrder();
	ifc_window *dp = getDesktopParent();
	if ((dp == NULL || dp == this) && WASABI_API_TIMER != NULL)
		postDeferredCallback(DEFERREDCB_FOCUSFIRST, 0, 500);
	return 0;
}

void BaseWnd::setLayeredWindow(int i)
{
	if (!Wasabi::Std::Wnd::isValidWnd(getOsWindowHandle())) return ;
	if (!isInited()) return ;
	Wasabi::Std::Wnd::setLayeredWnd(getOsWindowHandle(), i);
#if 0//CUT
	if (i)
	{
		SetWindowLong(getOsWindowHandle(), GWL_EXSTYLE, GetWindowLong(getOsWindowHandle(), GWL_EXSTYLE) & ~WS_EX_LAYERED);
		SetWindowLong(getOsWindowHandle(), GWL_EXSTYLE, GetWindowLong(getOsWindowHandle(), GWL_EXSTYLE) | WS_EX_LAYERED);
	}
	else
	{
		SetWindowLong(getOsWindowHandle(), GWL_EXSTYLE, GetWindowLong(getOsWindowHandle(), GWL_EXSTYLE) & ~WS_EX_LAYERED);
	}
#endif
	setTransparency(-1);
}

int BaseWnd::getCursorType(int x, int y)
{
	if (!customdefaultcursor)
		return BASEWND_CURSOR_POINTER;
	return BASEWND_CURSOR_USERSET;
}

void BaseWnd::onSetName()
{
	if (isInited() && !isVirtual())
		Wasabi::Std::Wnd::setWndName(getOsWindowHandle(), getNameSafe());
	notifyParent(ChildNotify::NAMECHANGED);
	if (accessible)
		accessible->onSetName(getName());
}

OSWINDOWHANDLE BaseWnd::getOsWindowHandle()
{
	OSWINDOWHANDLE handle;

	if ( isVirtual() )
		handle = getParent()->getOsWindowHandle();
	else
		handle = hwnd;
	

	return handle;
}

OSMODULEHANDLE BaseWnd::getOsModuleHandle()
{
	return hinstance;
}

void BaseWnd::onTip()
{
	tipshowtimer = FALSE;
	tip_done = TRUE;

	POINT p;
	Wasabi::Std::getMousePos(&p);
	if (WASABI_API_WND->rootWndFromPoint(&p) == (ifc_window *)this)
	{
		createTip();
		setTimer(TIP_DESTROYTIMER_ID, TIP_LENGTH);
		tipdestroytimer = TRUE;
	}
	setTimer(TIP_AWAY_ID, TIP_AWAY_DELAY);
	tipawaytimer = TRUE;
}

void BaseWnd::timerCallback(int id)
{
	switch (id)
	{
	case BUFFEREDMSG_TIMER_ID:
		checkLockedUI();
		break;
//	case TIP_TIMER_ID:
		//onTip();
		//break;
	case TIP_DESTROYTIMER_ID:
		killTimer(TIP_DESTROYTIMER_ID);
		killTimer(TIP_AWAY_ID);
		tipawaytimer = FALSE;
		tipdestroytimer = FALSE;
		destroyTip();
		break;
	case TIP_AWAY_ID:
		onTipMouseMove();
		break;
	}
}

int BaseWnd::isInited()
{
	return inited;
}

int BaseWnd::isDestroying()
{
	return destroying;
}

int BaseWnd::wantSiblingInvalidations()
{
	return FALSE;
}

void BaseWnd::setRSize(int x, int y, int w, int h)
{
	rwidth = w;
	rheight = h;
	rx = x;
	ry = y;
}

void BaseWnd::resize(int x, int y, int w, int h, int wantcb)
{
	inonresize = 1;

	if (x == AUTOWH) x = NOCHANGE;
	if (y == AUTOWH) y = NOCHANGE;
	if (w == AUTOWH) w = NOCHANGE;
	if (h == AUTOWH) h = NOCHANGE;

	if (getNumMinMaxEnforcers() > 0)
	{
		int min_w = getPreferences(MINIMUM_W);
		int min_h = getPreferences(MINIMUM_H);
		int max_w = getPreferences(MAXIMUM_W);
		int max_h = getPreferences(MAXIMUM_H);
		if (min_w != AUTOWH && w != NOCHANGE && w < min_w) w = min_w;
		if (max_w != AUTOWH && w != NOCHANGE && w > max_w) w = max_w;
		if (min_h != AUTOWH && h != NOCHANGE && h < min_h) h = min_h;
		if (max_h != AUTOWH && h != NOCHANGE && h > max_h) h = max_h;
	}

	int noresize = (w == NOCHANGE && h == NOCHANGE);
	int nomove = (x == NOCHANGE && y == NOCHANGE)/* || (x == rx && y == ry)*/;
	if (x == NOCHANGE) x = rx;
	if (y == NOCHANGE) y = ry;
	if (w == NOCHANGE) w = rwidth;
	if (h == NOCHANGE) h = rheight;

#ifdef _DEBUG
	ASSERT(x < 0xFFF0);
	ASSERT(y < 0xFFF0);
	ASSERT(w < 0xFFF0);
	ASSERT(h < 0xFFF0);
#endif

	double thisratio = getRenderRatio();
	int different_ratio = (lastratio != thisratio);
	lastratio = thisratio;

	int noevent = (resizecount > 1 && w == rwidth && h == rheight);
	//ifc_window *dp = getDesktopParent();
	if (different_ratio == 1 && noevent == 1)
	{
		if (Wasabi::Std::Wnd::getTopmostChild(getOsWindowHandle()) != INVALIDOSWINDOWHANDLE)
			noevent = 0;
		invalidateWindowRegion();
	}

	RECT oldsize, newsize = Wasabi::Std::makeRect(x, y, w, h);
	if (hwnd != NULL)
		BaseWnd::getNonClientRect(&oldsize);
	else
		oldsize = newsize;

	setRSize(x, y, w, h);

	if (handleRatio() && renderRatioActive())
	{
		multRatio(&w, &h);
		if (getParent() != NULL)
		{
			multRatio(&x, &y);
		}
	}

	if (!noevent)
	{
		if (wantcb && isPostOnInit())
		{
			resizecount = MIN(5, ++resizecount);
			if (!isVirtual())
				invalidateWindowRegion();
			onResize();
			if (ensureWindowRegionValid())
				updateWindowRegion();
		}
	}

	if (getOsWindowHandle() != NULL)
	{

		RECT oldsizescaled;
		getWindowRect(&oldsizescaled);
		RECT newsizescaled = {x, y, x + w, y + h};
		if (MEMCMP(&newsizescaled, &oldsizescaled, sizeof(RECT)))
		{
			//CUT      SetWindowPos(getOsWindowHandle(), NULL, x, y, w, h,
			//CUT      SWP_NOZORDER |
			//CUT      SWP_NOACTIVATE |
			//CUT      (!wantRedrawOnResize() ? SWP_NOCOPYBITS: 0) |
			//CUT      (ncb ? SWP_NOCOPYBITS : 0) |
			//CUT      ( nomove ? SWP_NOMOVE : 0) |
			//CUT      ( noresize ? SWP_NOSIZE : 0) |
			//CUT      0);
			Wasabi::Std::Wnd::setWndPos( getOsWindowHandle(), NULL, x, y, w, h, TRUE, TRUE, !wantRedrawOnResize() || ncb, nomove, noresize );
		}
		//else
		//{
		//	DebugStringW(L"BaseWnd::resize optimized\n");
		//}

		onAfterResize();

		if (ncb)
			invalidate();
		else
		{
			RECT r;
			if (hwnd != NULL)
			{
				if (newsize.left == oldsize.left && newsize.top == oldsize.top)
				{
					if (newsize.right > oldsize.right)
					{
						// growing in width
						r.left = oldsize.right;
						r.right = newsize.right;
						r.top = newsize.top;
						r.bottom = newsize.bottom;
						invalidateRect(&r);
						if (newsize.bottom > oldsize.bottom)
						{
							// growing in width & height
							r.left = oldsize.left;
							r.right = newsize.right;
							r.top = oldsize.bottom;
							r.bottom = newsize.bottom;
							invalidateRect(&r);
						}
					}
					else if (newsize.bottom > oldsize.bottom)
					{
						if (newsize.bottom > oldsize.bottom)
						{
							// growing in height
							r.left = oldsize.left;
							r.right = newsize.right;
							r.top = oldsize.bottom;
							r.bottom = newsize.bottom;
							invalidateRect(&r);
						}
					}
				}
			}
		}
	}
	inonresize = 0;
}

void BaseWnd::forcedOnResizeChain(ifc_window *w)
{
	w->triggerEvent(TRIGGER_ONRESIZE);
	int n = w->getNumRootWndChildren();
	for (int i = 0;i < n;i++)
	{
		forcedOnResizeChain(w->enumRootWndChildren(i));
	}
}

int BaseWnd::forcedOnResize()
{
	forcedOnResizeChain(this);
	return 1;
}

int BaseWnd::onResize()
{
	if (!isVirtual() || (getRegionOp() != REGIONOP_NONE))
		invalidateWindowRegion();
	// you are not supposed to call onResize until after onInit has returned. If what you wanted was to generate
	// an onResize event to do some custom client coordinates recalculations (ie: to apply on your children)
	// then you don't need to do anything since onResize is going to be called after onInit() is done. If you still want to
	// trigger it because your code might be called by onInit and after onInit, use isPostOnInit() as a test.
	// if what you wanted was to signal a object that you just resized it, then you don't need to do anything beside
	// resize(...), it will generate the event on its own if the window is inited, and will defer to until after onInit
	// if it is not.
	// shortly put: do not call onResize before or inside onInit()
	// if you have any valid reason for doing that, i'd like to know about it so i can make it possible. -FG
#ifdef _DEBUG
	if (!isPostOnInit())
	{
		//__asm int 3;
		ASSERTPR(isPostOnInit(), "do not call onResize before or inside onInit()");
	}
#endif
	return FALSE;
}

void BaseWnd::resizeToClient(BaseWnd *wnd)
{
	if (wnd != NULL)
		wnd->resize(&clientRect());
}

int BaseWnd::onPostedMove()
{
	/*
	if (w2k_alpha && Wasabi::Std::Wnd::isDesktopAlphaAvailable() && !cloaked)
	{
		RECT r;
		getWindowRect(&r);
	   Wasabi::Std::Wnd::moveLayeredWnd(hwnd, r.left, r.top);
	}*/
	return FALSE;
}

void BaseWnd::resize(RECT *r, int wantcb)
{
	resize(r->left, r->top, r->right - r->left, r->bottom - r->top, wantcb);
}

void BaseWnd::move(int x, int y)
{
	//DebugStringW( L"BaseWnd::move( x = %d, y = %d )\n", x, y );

	setRSize(x, y, rwidth, rheight);
	Wasabi::Std::Wnd::setWndPos( getOsWindowHandle(), NULL, x, y, 0, 0, TRUE, TRUE, ncb, FALSE, TRUE );
	//CUT  if (!ncb)
	//CUT    SetWindowPos(getOsWindowHandle(), NULL, x, y, 0, 0, SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE|SWP_DEFERERASE);
	//CUT  else
	//CUT    SetWindowPos(getOsWindowHandle(), NULL, x, y, 0, 0, SWP_NOSIZE|SWP_NOZORDER|SWP_NOCOPYBITS|SWP_NOACTIVATE|SWP_DEFERERASE);
}

#ifdef EXPERIMENTAL_INDEPENDENT_AOT
BOOL CALLBACK EnumOwnedTopMostWindows(HWND hwnd, LPARAM lParam)
{
	enumownedstruct *st = (enumownedstruct *)lParam;
	if (hwnd != st->hthis && GetWindow(hwnd, GW_OWNER) == st->owner)
	{
		ifc_window *w = (ifc_window*)GetWindowLong(hwnd, GWL_USERDATA);
		if (w != NULL && w->getAlwaysOnTop())
			st->hlist->addItem(w);
	}
	return TRUE;
}

void BaseWnd::saveTopMosts()
{
	HWND owner = GetWindow(getOsWindowHandle(), GW_OWNER);
	enumownedstruct st;
	ontoplist.removeAll();
	if (owner != NULL)
	{
		st.owner = owner;
		st.hlist = &ontoplist;
		st.hthis = getOsWindowHandle();
		EnumWindows(EnumOwnedTopMostWindows, (long)&st);
	}
}

void BaseWnd::restoreTopMosts()
{
	HWND owner = GetWindow(getOsWindowHandle(), GW_OWNER);
	if (owner != NULL)
	{
		for (int i = 0;i < ontoplist.getNumItems();i++)
		{
			ontoplist.enumItem(i)->setAlwaysOnTop(1);
		}
	}
}
#endif

void BaseWnd::bringToFront()
{
	// when we set a window to the top of the zorder (not topmost), win32 finds the owner and removes any topmost flag its children may
	// have because it assumes we want this window over these, which we definitly don't. so we need to first go thru all the owner's children,
	// make a list of the ones with a topmost flag, set this window on top, and set the topmost flags back. yay
	ASSERT(!isVirtual());
#ifdef EXPERIMENTAL_INDEPENDENT_AOT
	saveTopMosts();
#endif
	//CUT  SetWindowPos(getOsWindowHandle(), HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE|SWP_DEFERERASE|SWP_NOOWNERZORDER);
	Wasabi::Std::Wnd::bringToFront(getOsWindowHandle());
#ifdef EXPERIMENTAL_INDEPENDENT_AOT
	restoreTopMosts();
#endif
}

void BaseWnd::bringToBack()
{
	ASSERT(!isVirtual());
#ifdef EXPERIMENTAL_INDEPENDENT_AOT
	saveTopMosts();
#endif
	//CUT  SetWindowPos(getOsWindowHandle(), HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE|SWP_DEFERERASE|SWP_NOOWNERZORDER);
	Wasabi::Std::Wnd::sendToBack(getOsWindowHandle());
#ifdef EXPERIMENTAL_INDEPENDENT_AOT
	restoreTopMosts();
#endif
}

void BaseWnd::setVisible(int show)
{
	int visible = isVisible(1);
	if (!!visible == !!show) return ;
	invalidate();
	this_visible = !!show;
	/*if (!getParent() || getParent() == WASABI_API_WND->main_getRootWnd() && IsWindow(getOsWindowHandle())) {
	  if (!show) {
	    setLayeredWindow(0);
	    if (setLayeredWindowAttributes)
	      setLayeredWindowAttributes(hwnd, RGB(0,0,0), 255, LWA_ALPHA);
	  } else {
	    setLayeredWindow(w2k_alpha);
	  }
	}*/
	if (!getParent() || getParent() == WASABI_API_WND->main_getRootWnd() || getParent()->isVisible())
	{
		onSetVisible(show);
	}
}

void BaseWnd::setCloaked(int cloak)
{
	if (cloaked == cloak) return ;
	cloaked = cloak;
	if (isVirtual()) return ;
	if (cloaked)
	{
		//CUTif (IsWindowVisible(getOsWindowHandle()))
		//CUT  ShowWindow(getOsWindowHandle(), SW_HIDE);
		if (Wasabi::Std::Wnd::isWndVisible(getOsWindowHandle()))
			Wasabi::Std::Wnd::hideWnd(getOsWindowHandle());
	}
	else
	{
		if (isVisible(1))
			//CUTShowWindow(getOsWindowHandle(), SW_NORMAL);
			Wasabi::Std::Wnd::showWnd(getOsWindowHandle());
	}
}


void BaseWnd::onSetVisible(int show)
{
	/* for debug purposes - don't delete please
	  #include "../../../studio/container.h"
	  #include "../../../studio/layout.h"
	  if (!show && getGuiObject() && STRCASEEQLSAFE(getGuiObject()->guiobject_getId(), "normal")) {
	    Layout *l = (Layout *)getInterface(layoutGuid);
	    if (l) {
	      if (l->getParentContainer() && STRCASEEQLSAFE(l->getParentContainer()->getId(), "main")) {
	        DebugString("Hiding main player\n");
	      }
	    }
	  }*/
	if (!isVirtual())
		if (hwnd != NULL)
			if (!cloaked)
			{
				//CUT //      SetWindowPos(getOsWindowHandle(),NULL,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE|SWP_NOACTIVATE|SWP_NOZORDER|SWP_SHOWWINDOW);
				//CUT        ShowWindow(getOsWindowHandle(), show ? SW_SHOWNA : SW_HIDE);
				if (show)
					Wasabi::Std::Wnd::showWnd(getOsWindowHandle(), TRUE);
				else
					Wasabi::Std::Wnd::hideWnd(getOsWindowHandle());
			}
	/*  if (!show)
	    postDeferredCallback(0x7849);
	  else {*/
	foreach(rootwndchildren)
	ifc_window *w = rootwndchildren.getfor();
	if (w && w->isVisible(1)) // check internal flag only
		w->onSetVisible(show);
	endfor;
	dependent_sendEvent(BaseWnd::depend_getClassGuid(), Event_SETVISIBLE, show);
	//}
	/*  if (getDesktopParent() == this) {
	    cascadeRepaint(0);
	  }*/

	/*#ifdef WIN32 // os-specific non virtual child wnd support
	  if (!isVirtual()) {
	    HWND w = GetWindow(getOsWindowHandle(), GW_CHILD);
	    while (w != NULL) {
	      api_window *rootwnd = (api_window*)GetWindowLong(w, GWL_USERDATA);
	      if (rootwnd && rootwnd != this)
	        if (rootwnd->isInited())
	          rootwnd->onSetVisible(show);
	      w = GetWindow(w, GW_HWNDNEXT);
	    }
	  }
	#endif*/
	if (!isVirtual())
	{
		if (!show)
		{
			deferedInvalidate();
			delete virtualCanvas;
			virtualCanvas = NULL;
		}
	}
	invalidateWindowRegion();
}

void BaseWnd::setEnabled(int en)
{
	int enabled = isEnabled(1);
	if (!!enabled == !!en) return ;
	invalidate();
	this_enabled = !!en;
	if (!getParent() || getParent() == WASABI_API_WND->main_getRootWnd() || getParent()->isEnabled())
	{
		onEnable(en);
	}
}

int BaseWnd::isEnabled(int within)
{
	if (!isVirtual() && !getOsWindowHandle()) return 0;
	if (!this_enabled) return 0;

	if (within) return this_enabled; // whatever, local

	if (isVirtual()) // virtual, global
		if (getParent())
			return getParent()->isEnabled();
		else
			return 0;

	// non virtual, global
	//CUT  if (GetWindowLong(getOsWindowHandle(), GWL_STYLE) & WS_POPUP) return this_enabled;
	if (Wasabi::Std::Wnd::isPopup(getOsWindowHandle())) return this_enabled;
	//CUT  if (!Wasabi::Std::Wnd::isValidWnd(GetParent(gethWnd()))) return this_enabled;
	if (!Wasabi::Std::Wnd::isValidWnd(Wasabi::Std::Wnd::getParent(getOsWindowHandle()))) return this_enabled;
	if (getParent()) return getParent()->isEnabled(); // not a popup, check its parent or fail
	return this_enabled;
}

int BaseWnd::onEnable(int en)
{
	if (!isVirtual())
	{
		if (hwnd != NULL)
			//CUT      EnableWindow(getOsWindowHandle(), en);
			Wasabi::Std::Wnd::setEnabled(getOsWindowHandle(), en);
		foreach(rootwndchildren)
		ifc_window *w = rootwndchildren.getfor();
		if (w->isEnabled(1)) // check internal flag only
			w->onEnable(en);
		endfor;
	}
	return 1;
}

void BaseWnd::setFocus()
{
	if (curVirtualChildFocus != NULL)
	{
		curVirtualChildFocus->onKillFocus();
		curVirtualChildFocus = NULL;
	}
	onSetRootFocus(this);
	//CUT  SetFocus(getOsWindowHandle());
	Wasabi::Std::Wnd::setFocus(getOsWindowHandle());
}

void BaseWnd::setFocusOnClick(int f)
{
	focus_on_click = f;
}

api_region *BaseWnd::getDeferedInvalidRgn()
{
	return deferedInvalidRgn;
}

void BaseWnd::deferedInvalidate()
{
	if (!hasVirtualChildren() || !isVisible(1)) return ;
	RECT r = Wasabi::Std::makeRect(0, 0, 0, 0);
	getNonClientRect(&r);
	deferedInvalidateRect(&r);
}

void BaseWnd::deferedInvalidateRect(RECT *r)
{
	if (!hasVirtualChildren()) return ;
	RegionI h(r);
	deferedInvalidateRgn(&h);
}

void BaseWnd::deferedInvalidateRgn(api_region *h)
{
	if (!hasVirtualChildren()) return ;
	if (!deferedInvalidRgn)
	{
		deferedInvalidRgn = new RegionI();
	}

	deferedInvalidRgn->addRegion(h);
}

void BaseWnd::deferedValidate()
{
	if (!hasVirtualChildren() || !isVisible(1)) return ;
	RECT r = Wasabi::Std::makeRect(0,0,0,0);
	getNonClientRect(&r);
	deferedValidateRect(&r);
}

void BaseWnd::deferedValidateRect(RECT *r)
{
	if (!hasVirtualChildren()) return ;
	RegionI h(r);
	deferedValidateRgn(&h);
}

void BaseWnd::deferedValidateRgn(api_region *h)
{
	if (!hasVirtualChildren()) return ;
	if (!deferedInvalidRgn) return ;

	deferedInvalidRgn->subtractRgn(h);
}

int BaseWnd::hasVirtualChildren()
{
	return 1; //virtualChildren.getNumItems() > 0;
}

void BaseWnd::invalidate()
{
	invalidateFrom(this);
}

void BaseWnd::invalidateFrom(ifc_window *who)
{
	if (hasVirtualChildren()) deferedInvalidate();
	//CUT  if (hwnd != NULL && isVisible(1)) InvalidateRect(getOsWindowHandle(), NULL, FALSE);
	if (hwnd != NULL && isVisible(1))
		Wasabi::Std::Wnd::invalidateRect(getOsWindowHandle());
}

void BaseWnd::invalidateRectFrom(RECT *r, ifc_window *who)
{
	if (hasVirtualChildren()) deferedInvalidateRect(r);
	RegionI rg(r);
	invalidateRgnFrom(&rg, who);
}

void BaseWnd::invalidateRgn(api_region *r)
{
	invalidateRgnFrom(r, this);
}

void BaseWnd::invalidateRect(RECT *r)
{
	invalidateRectFrom(r, this);
}

void BaseWnd::invalidateRgnFrom(api_region *r, ifc_window *who)
{
	if (parentWnd) parentWnd->onChildInvalidate(r, who);
	PaintCallbackInfoI pc(NULL, r);
	dependent_sendEvent(BaseWnd::depend_getClassGuid(), Event_ONINVALIDATE, 0, &pc);
	if (hwnd != NULL && isVisible(1))
	{
		if (hasVirtualChildren())
		{
			api_region *_r = r->clone();
			int j = virtualChildren.searchItem(who);
			for (int i = 0;i < virtualChildren.getNumItems();i++)
			{
				ifc_window *w = virtualChildren[i];
				if (w != who && w->wantSiblingInvalidations())
					w->onSiblingInvalidateRgn(_r, who, j, i);
			}

			deferedInvalidateRgn(_r);
			physicalInvalidateRgn(_r);
			r->disposeClone(_r);
		}
		else
		{
			deferedInvalidateRgn(r);
			physicalInvalidateRgn(r);
		}
	}
}

void BaseWnd::physicalInvalidateRgn(api_region *r)
{
	if (hwnd != NULL && isVisible(1))
	{
		if (renderRatioActive())
		{
			api_region *clone = r->clone();
			clone->scale(getRenderRatio(), getRenderRatio(), TRUE);
			//CUT      InvalidateRgn(getOsWindowHandle(), clone->getOSHandle(), FALSE);
			Wasabi::Std::Wnd::invalidateRegion(getOsWindowHandle(), clone->getOSHandle());
			r->disposeClone(clone);
		}
		else
			//CUT      InvalidateRgn(getOsWindowHandle(), r->getOSHandle(), FALSE);
			Wasabi::Std::Wnd::invalidateRegion(getOsWindowHandle(), r->getOSHandle());
	}
}

void BaseWnd::validate()
{
	//CUT  if (hwnd != NULL) ValidateRect(getOsWindowHandle(), NULL);
	if (hwnd != NULL)
		Wasabi::Std::Wnd::validateRect(getOsWindowHandle());
}

void BaseWnd::validateRect(RECT *r)
{
	if (hwnd != NULL)
	{
		if (renderRatioActive())
		{
			RECT r2 = *r;
			Wasabi::Std::scaleRect(&r2, getRenderRatio());
			//CUT      ValidateRect(getOsWindowHandle(), &r2);
			Wasabi::Std::Wnd::validateRect(getOsWindowHandle(), &r2);
		}
		else
			//CUT    ValidateRect(getOsWindowHandle(), r);
			Wasabi::Std::Wnd::validateRect(getOsWindowHandle(), r);
	}
}

void BaseWnd::validateRgn(api_region *reg)
{
	if (hwnd != NULL)
	{
		if (renderRatioActive())
		{
			api_region *clone = reg->clone();
			clone->scale(getRenderRatio(), getRenderRatio(), TRUE);
			//CUT      ValidateRgn(getOsWindowHandle(), clone->getOSHandle());
			Wasabi::Std::Wnd::validateRegion(getOsWindowHandle(), clone->getOSHandle());
			reg->disposeClone(clone);
		}
		else
			//CUT      ValidateRgn(getOsWindowHandle(), reg->getOSHandle());
			Wasabi::Std::Wnd::validateRegion(getOsWindowHandle(), reg->getOSHandle());
	}
}

void BaseWnd::repaint()
{
	/*	if (hasVirtualChildren())	{
		  api_region *h = new api_region();
		  int s = GetUpdateRgn(getOsWindowHandle(), h->getHRGN(), FALSE);
		  if (s != NULLREGION && s != ERROR) {
	  		virtualDrawRgn(h);
		  }
		  delete h;
		}*/
	//CUTif (hwnd != NULL) UpdateWindow(getOsWindowHandle());
	if (hwnd != NULL)
		Wasabi::Std::Wnd::update(getOsWindowHandle());
}

void BaseWnd::getClientRect(RECT *rect)
{
	/*  rect->left = rx;
	  rect->right = rx + rwidth;
	  rect->top = ry;
	  rect->bottom = ry + rheight;*/
	//ASSERT(hwnd != NULL);
	if (!Wasabi::Std::Wnd::isValidWnd(hwnd))
	{
		MEMSET(rect, 0, sizeof(RECT));
		return ;
	}

	GetClientRect(getOsWindowHandle(), rect);
	////Wasabi::Std::Wnd::getClientRect(getOsWindowHandle(), rect);
	rect->right = rect->left + rwidth;
	rect->bottom = rect->top + rheight;
}

RECT BaseWnd::clientRect()
{
	RECT ret;
	getClientRect(&ret);
	return ret;
}

void BaseWnd::getNonClientRect(RECT *rect)
{
	//  ASSERT(hwnd != NULL);
	if (!hwnd)
		getClientRect(rect);
	else
	{
		Wasabi::Std::Wnd::getClientRect(getOsWindowHandle(), rect);
		if (getRenderRatio() != 1.0)
		{
			rect->right = rect->left + rwidth;
			rect->bottom = rect->left + rheight;
		}
	}
	/*  rect->left = rx;
	  rect->right = rx + rwidth;
	  rect->top = ry;
	  rect->bottom = ry + rheight;*/
}

RECT BaseWnd::nonClientRect()
{
	RECT ret;
	getNonClientRect(&ret);
	return ret;
}

void BaseWnd::getWindowRect(RECT *rect)
{
	//CUT#ifdef WIN32
	//CUT  ASSERT(hwnd != NULL);
	//CUT  GetWindowRect(getOsWindowHandle(), rect);
	//CUT#else
	//CUT#error port me
	//CUT#endif
	Wasabi::Std::Wnd::getWindowRect(getOsWindowHandle(), rect);
}

// get position relative to parent (same coordinate system for basewnd & virtualwnd)
void BaseWnd::getPosition(POINT *pt)
{
	pt->x = rx;
	pt->y = ry;
}

void *BaseWnd::dependent_getInterface(const GUID *classguid)
{
	HANDLEGETINTERFACE(ifc_window);
	//CUT  HANDLEGETINTERFACE(api_window);
	return NULL;
}

RECT BaseWnd::windowRect()
{
	RECT ret;
	getWindowRect(&ret);
	return ret;
}


void BaseWnd::clientToScreen(int *x, int *y)
{
	int _x = x ? *x : 0;
	int _y = y ? *y : 0;
	if (renderRatioActive())
	{
		_x = (int)((double)_x * getRenderRatio());
		_y = (int)((double)_y * getRenderRatio());
	}
	Wasabi::Std::Wnd::clientToScreen(getOsWindowHandle(), &_x, &_y);
	if (x) *x = _x;
	if (y) *y = _y;
}

void BaseWnd::clientToScreen(RECT *r)
{
	clientToScreen((int*)&r->left, (int*)&r->top);
	clientToScreen((int*)&r->right, (int*)&r->bottom);
}

void BaseWnd::clientToScreen(POINT *p)
{
	clientToScreen((int *)&p->x, (int *)&p->y);
}

void BaseWnd::screenToClient(int *x, int *y)
{
	//CUT  POINT p;
	int _x = x ? *x : 0;
	int _y = y ? *y : 0;
	//CUT  ScreenToClient(getOsWindowHandle(), &p);
	Wasabi::Std::Wnd::screenToClient(getOsWindowHandle(), &_x, &_y);
	if (renderRatioActive())
	{
		_x = (int)((double)_x / getRenderRatio());
		_y = (int)((double)_y / getRenderRatio());
	}
	if (x) *x = _x;
	if (y) *y = _y;
}

void BaseWnd::screenToClient(RECT *r)
{
	screenToClient((int*)&r->left, (int*)&r->top);
	screenToClient((int*)&r->right, (int*)&r->bottom);
}

void BaseWnd::screenToClient(POINT *p)
{
	screenToClient((int *)&p->x, (int *)&p->y);
}

void BaseWnd::setParent(ifc_window *newparent)
{
	ASSERTPR(newparent != NULL, "quit being a weeny");
	ASSERTPR(parentWnd == NULL || newparent == parentWnd, "can't reset parent");
	parentWnd = newparent;
	if (isInited())
	{
		OSWINDOWHANDLE w1 = getOsWindowHandle();
		OSWINDOWHANDLE w2 = newparent->getOsWindowHandle();
		if (w1 != w2)
			//CUT      SetParent(w1, w2);
			Wasabi::Std::Wnd::setParent(w1, w2);
	}
}

//FUCKO
int BaseWnd::reparent(ifc_window *newparent)
{
#ifdef _WIN32
	if (!isVirtual())
	{
		if (isInited())
		{
			ifc_window *old = getParent();
			if (!old && newparent)
			{
				::SetParent(getOsWindowHandle(), newparent->getOsWindowHandle());
				SetWindowLong(getOsWindowHandle() , GWL_STYLE, GetWindowLong(getOsWindowHandle(), GWL_STYLE) & ~WS_POPUP);
				SetWindowLong(getOsWindowHandle() , GWL_STYLE, GetWindowLong(getOsWindowHandle(), GWL_STYLE) | WS_CHILD);
			}
			else if (old && !newparent)
			{
				SetWindowLong(getOsWindowHandle() , GWL_STYLE, GetWindowLong(getOsWindowHandle(), GWL_STYLE) & ~WS_CHILD);
				SetWindowLong(getOsWindowHandle() , GWL_STYLE, GetWindowLong(getOsWindowHandle(), GWL_STYLE) | WS_POPUP);
				::SetParent(getOsWindowHandle(), NULL);
			}
			else
			{
				::SetParent(getOsWindowHandle(), newparent ? newparent->getOsWindowHandle() : NULL);
			}
		}
	}

	parentWnd = newparent;
	onSetParent(newparent);

#ifdef WASABI_ON_REPARENT
	WASABI_ON_REPARENT(getOsWindowHandle());
#endif
#else
#warning port me
#endif
	return 1;
}

ifc_window *BaseWnd::getParent()
{
	return parentWnd;
}

ifc_window *BaseWnd::getRootParent()
{
	return this;
}

//PORTME
ifc_window *BaseWnd::getDesktopParent()
{
#ifdef _WIN32
	// NONPORTABLE
	HWND w = getOsWindowHandle();
	HWND last = w;
	if (!w) return NULL;
	HWND p = w;
	wchar_t cn[256] = {0};
	while (p && !(GetWindowLong(p, GWL_STYLE) & WS_POPUP))
	{
		GetClassNameW(p, cn, 255); cn[255] = 0;
		if (!wcscmp(cn, BASEWNDCLASSNAME))
			last = p;
		p = GetParent(p);
	}
	if (p)
	{
		GetClassNameW(p, cn, 255); cn[255] = 0;
		if (!wcscmp(cn, BASEWNDCLASSNAME))
			return (ifc_window*)GetWindowLongPtrW(p, GWLP_USERDATA);
		else if (last != NULL)
			return (ifc_window*)GetWindowLongPtrW(last, GWLP_USERDATA);
	}
#else
#warning port me
#endif
	return NULL;
}

int BaseWnd::notifyParent(int msg, int param1, int param2)
{
	ifc_window *notifywnd = getNotifyWindow();
	if (getParent() == NULL && notifywnd == NULL) return 0;
	if (notifywnd == NULL) notifywnd = getParent();
	ASSERT(notifywnd != NULL);
	return notifywnd->childNotify(this, msg, param1, param2);
}

int BaseWnd::passNotifyUp(ifc_window *child, int msg, int param1, int param2)
{
	// Same code as above to decide for whom we should notify.
	ifc_window *notifywnd = getNotifyWindow();
	if (getParent() == NULL && notifywnd == NULL) return 0;
	if (notifywnd == NULL) notifywnd = getParent();
	ASSERT(notifywnd != NULL);
	// And here we just change the api_window pointer.
	return notifywnd->childNotify(child, msg, param1, param2);
}

void BaseWnd::setNotifyId(int id)
{
	notifyid = id;
}

int BaseWnd::getNotifyId()
{
	return notifyid;
}

DragInterface *BaseWnd::getDragInterface()
{
	return this;
}

ifc_window *BaseWnd::rootWndFromPoint(POINT *pt)
{
	// pt is in client coordinates
	int x = (int)((double)pt->x / getRenderRatio());
	int y = (int)((double)pt->y / getRenderRatio());

	ifc_window *ret = findRootWndChild(x, y);
	if (ret == NULL) ret = this;
	return ret;
}

int BaseWnd::rootwnd_paintTree(ifc_canvas *canvas, api_region *r)
{
	BaseCloneCanvas c(canvas);
	return paintTree(&c, r);
}

const wchar_t *BaseWnd::getRootWndName()
{
	return getName();
}

const wchar_t *BaseWnd::getId()
{
	return NULL;
}

void BaseWnd::setSkinId(int id)
{
	skin_id = id;
}

void BaseWnd::setPreferences(int what, int v)
{
	switch (what)
	{
	case MAXIMUM_W: maximum_w = v; break;
	case MAXIMUM_H: maximum_h = v; break;
	case MINIMUM_W: minimum_w = v; break;
	case MINIMUM_H: minimum_h = v; break;
	case SUGGESTED_W: suggested_w = v; break;
	case SUGGESTED_H: suggested_h = v; break;
	}
}

int BaseWnd::getPreferences(int what)
{
	if (getNumMinMaxEnforcers() > 0)
	{

		int min_x = minimum_w, min_y = minimum_h, max_x = maximum_w, max_y = maximum_h, sug_x = suggested_w, sug_y = suggested_h;

		for (int i = 0;i < getNumMinMaxEnforcers();i++)
		{

			int tmin_x = MINIMUM_W, tmin_y = MINIMUM_H, tmax_x = MAXIMUM_W, tmax_y = MAXIMUM_H, tsug_x = SUGGESTED_W, tsug_y = SUGGESTED_H;

			ifc_window *w = enumMinMaxEnforcer(i);

			if (w)
			{

				tmin_x = w->getPreferences(MINIMUM_W);
				tmin_y = w->getPreferences(MINIMUM_H);
				tmax_x = w->getPreferences(MAXIMUM_W);
				tmax_y = w->getPreferences(MAXIMUM_H);
				tsug_x = w->getPreferences(SUGGESTED_W);
				tsug_y = w->getPreferences(SUGGESTED_H);

				if (tmin_x == -1) tmin_x = AUTOWH;
				if (tmin_y == -1) tmin_y = AUTOWH;
				if (tmax_x == -1) tmax_x = AUTOWH;
				if (tmax_y == -1) tmax_y = AUTOWH;
				if (tsug_x == -1) tsug_x = AUTOWH;
				if (tsug_y == -1) tsug_y = AUTOWH;

#ifndef DISABLE_SYSFONTSCALE
				TextInfoCanvas textInfoCanvas(this);
				double fontScale = textInfoCanvas.getSystemFontScale();
				GuiObject *o = static_cast<GuiObject *>(getInterface(guiObjectGuid));
				if (o != NULL)
				{
					if (o->guiobject_getAutoSysMetricsW())
					{
						if (tmin_x != AUTOWH) tmin_x = (int)((float)tmin_x * fontScale);
						if (tmax_x != AUTOWH) tmax_x = (int)((float)tmax_x * fontScale);
						if (tsug_x != AUTOWH) tsug_x = (int)((float)tsug_x * fontScale);
					}
					if (o->guiobject_getAutoSysMetricsH())
					{
						if (tmin_y != AUTOWH) tmin_y = (int)((float)tmin_y * fontScale);
						if (tmax_y != AUTOWH) tmax_y = (int)((float)tmax_y * fontScale);
						if (tsug_y != AUTOWH) tsug_y = (int)((float)tsug_y * fontScale);
					}
				}
#endif

				RECT cor;
				w->getNonClientRect(&cor);
				RECT wr;
				getNonClientRect(&wr);

				int xdif = (wr.right - wr.left) - (cor.right - cor.left);
				int ydif = (wr.bottom - wr.top) - (cor.bottom - cor.top);
				if (tmin_x != AUTOWH) tmin_x += xdif;
				if (tmin_y != AUTOWH) tmin_y += ydif;
				if (tmax_x != AUTOWH) tmax_x += xdif;
				if (tmax_y != AUTOWH) tmax_y += ydif;
				if (tsug_x != AUTOWH) tsug_x += xdif;
				if (tsug_y != AUTOWH) tsug_y += ydif;
			}

			if (min_x != AUTOWH) min_x = (tmin_x != AUTOWH) ? MAX(min_x, tmin_x) : min_x; else min_x = tmin_x;
			if (max_x != AUTOWH) max_x = (tmax_x != AUTOWH) ? MAX(max_x, tmax_x) : max_x; else max_x = tmax_x;
			if (min_y != AUTOWH) min_y = (tmin_y != AUTOWH) ? MAX(min_y, tmin_y) : min_y; else min_y = tmin_y;
			if (max_y != AUTOWH) max_y = (tmax_y != AUTOWH) ? MAX(max_y, tmax_y) : max_y; else max_y = tmax_y;
			if (sug_x != AUTOWH) sug_x = (tsug_x != AUTOWH) ? MAX(sug_x, tsug_x) : sug_x; else sug_x = tsug_x;
			if (sug_y != AUTOWH) sug_y = (tsug_y != AUTOWH) ? MAX(sug_y, tsug_y) : sug_y; else sug_y = tsug_y;
		}

		if (min_x != AUTOWH && min_x == max_x) sug_x = min_x;
		if (min_y != AUTOWH && min_y == max_y) sug_y = min_y;

		switch (what)
		{
		case MINIMUM_W: return min_x;
		case MINIMUM_H: return min_y;
		case MAXIMUM_W: return max_x;
		case MAXIMUM_H: return max_y;
		case SUGGESTED_W: return sug_x;
		case SUGGESTED_H: return sug_y;
		}
	}

	switch (what)
	{
	case SUGGESTED_W: return suggested_w;
	case SUGGESTED_H: return suggested_h;
	case MAXIMUM_W: return maximum_w;
	case MAXIMUM_H: return maximum_h;
	case MINIMUM_W: return minimum_w;
	case MINIMUM_H: return minimum_h;
	}

	return AUTOWH;
}

void BaseWnd::setStartHidden(int wtf)
{
	start_hidden = wtf;
}

//PORTME
#ifdef _WIN32



#define EQUAL_CLSNAME(__name1, __name2)\
(CSTR_EQUAL == CompareStringW(MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT),\
NORM_IGNORECASE, (__name1), -1, (__name2), -1))

static BOOL BaseWnd_IsFrameWindow(HWND hwnd)
{
	WCHAR szClass[64] = {0};
	if (NULL == hwnd || !GetClassNameW(hwnd, szClass, ARRAYSIZE(szClass)))
		return FALSE;

	return EQUAL_CLSNAME(szClass, L"Winamp v1.x") || 
			EQUAL_CLSNAME(szClass, L"BaseWindow_RootWnd");
}


LRESULT BaseWnd::wndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	if (!isDestroying()) switch (uMsg)
		{
		case WM_DEFER_CALLBACK:
			timerclient_onDeferredCallback(wParam, lParam);
			break;
		case WM_SYSCOMMAND:
		{
			if ((wParam & 0xfff0) == SC_SCREENSAVE || (wParam & 0xfff0) == SC_MONITORPOWER)
			{
				ifc_window *main = WASABI_API_WND->main_getRootWnd();
				if (main && main != this)
					return SendMessageW(main->gethWnd(), uMsg, wParam, lParam);
			}
			break;
		}
		//CUT    case WM_CREATE:
		//CUT      hwnd = hWnd;
		//CUT    break;

		//CUT    case WM_CLOSE:
		//CUT      return 0;

		case WM_PAINT:
		{
			if (inonresize && !wantRedrawOnResize()) return 1;
			ASSERT(hwnd != NULL);
			if (!isVisible(1) || IsIconic(hWnd)) break;
			RECT r;
			if (GetUpdateRect(hWnd, &r, FALSE))
			{
				if (virtualOnPaint())
				{
					return 0;
				}
			}
		}
		break;
		
		case WM_PRINTCLIENT:
			{
				bool old_cloaked = (!!cloaked);
				cloaked = true;
				DCCanvas dc((HDC)wParam, this);
				paint(&dc, 0);
				cloaked = old_cloaked;

				if (lParam & PRF_CHILDREN)
				{
					RECT wnd_size;
					GetWindowRect(hwnd, &wnd_size);

					HWND child = GetWindow(hwnd, GW_CHILD);
					while (child != NULL) 
					{
						if (GetWindowLongPtrW(child, GWL_STYLE) & WS_VISIBLE) 
						{
							RECT child_size;
							GetWindowRect(child, &child_size);
							if (child_size.right && child_size.bottom)
							{
								BltCanvas bitmap(child_size.right, child_size.bottom, child);;
								SendMessageW(child, WM_PRINT, (WPARAM)bitmap.getHDC(),  PRF_CHILDREN | PRF_CLIENT | PRF_NONCLIENT/*| PRF_OWNED*/);
								//bitmap->makeAlpha(255);

								//set alpha to 255
								int w, h;
								bitmap.getDim(&w, &h, NULL);
								ARGB32 *m_pBits = (ARGB32 *)bitmap.getBits();
								int nwords = w*h;
								for (; nwords > 0; nwords--, m_pBits++)
								{
									unsigned char *pixel = (unsigned char *)m_pBits;
									pixel[3] = 255;	// alpha
								}

								POINT offset;
								offset.x = child_size.left - wnd_size.left;
								offset.y = child_size.top - wnd_size.top;

								//BLENDFUNCTION blendFn;
								//blendFn.BlendOp = AC_SRC_OVER;
								//blendFn.BlendFlags  = 0;
								//blendFn.SourceConstantAlpha  = 255;
								//blendFn.AlphaFormat = 0;
								//AlphaBlend((HDC)wParam, offset.x, offset.y, child_size.right-child_size.left, child_size.bottom-child_size.top, 
								//	bitmap->getHDC(), 0, 0, child_size.right-child_size.left, child_size.bottom-child_size.top, blendFn);
								StretchBlt((HDC)wParam, offset.x, offset.y, child_size.right-child_size.left, child_size.bottom-child_size.top, 
									bitmap.getHDC(), 0, 0, child_size.right-child_size.left, child_size.bottom-child_size.top, SRCCOPY);
							}
						}
						child = GetWindow(child, GW_HWNDNEXT);
					}

				}
			}
			return 0;
		//CUT    case WM_NCPAINT: return 0;
		//CUT    case WM_SYNCPAINT: return 0;

		case WM_SETCURSOR:
			if (checkModal()) return TRUE;
			if (hWnd == (HWND)wParam)
			{
				DWORD windowStyle = (DWORD)GetWindowLongPtrW(hWnd, GWL_STYLE);
				switch(HIWORD(lParam))
				{
					case WM_LBUTTONDOWN:
					case WM_RBUTTONDOWN:
					case WM_MBUTTONDOWN:
					case 0x020B/*WM_XBUTTONDOWN*/:
						DisabledWindow_OnMouseClick(hWnd);
						break;
				}
				int ct = BASEWND_CURSOR_POINTER;
				int _x, _y;
				Wasabi::Std::getMousePos(&_x, &_y);
				screenToClient(&_x, &_y);
				OSCURSORHANDLE c = NULL;

				if (0 == (WS_DISABLED & windowStyle))
				{					
					if (!handleVirtualChildMsg(WM_SETCURSOR, _x, _y, &ct, &c))
					{
						ct = getCursorType(_x, _y);
					}
				}
				wchar_t *wincursor = NULL;
				switch (ct)
				{
					case BASEWND_CURSOR_USERSET:

						if (c == NULL)
							c = getCustomCursor(_x, _y);
						if (c != NULL)
						{
							SetCursor(c);
							return TRUE;
						}
						else wincursor = IDC_ARROW; // Ensure to have at least a cursor
						break;
					case BASEWND_CURSOR_POINTER:
						wincursor = IDC_ARROW;
						break;
					case BASEWND_CURSOR_NORTHSOUTH:
						wincursor = IDC_SIZENS;
						break;
					case BASEWND_CURSOR_EASTWEST:
						wincursor = IDC_SIZEWE;
						break;
					case BASEWND_CURSOR_NORTHWEST_SOUTHEAST:
						wincursor = IDC_SIZENWSE;
						break;
					case BASEWND_CURSOR_NORTHEAST_SOUTHWEST:
						wincursor = IDC_SIZENESW;
						break;
					case BASEWND_CURSOR_4WAY:
						wincursor = IDC_SIZEALL;
						break;
					case BASEWND_CURSOR_EDIT:
						wincursor = IDC_IBEAM;
						break;
					default:
						wincursor = IDC_ARROW;
						break;
				}
				if (wincursor != NULL) 
				{
					SetCursor(LoadCursor(NULL, wincursor));
					return TRUE;
				}
			}
			return FALSE;

		case WM_TIMER:
			timerCallback((int)wParam);
			return 0;

		case WM_GETOBJECT:
			if (lParam == OBJID_CLIENT)
			{
				Accessible *acc = getAccessibleObject();
				if (acc != NULL)
				{
					LRESULT lAcc = acc->getOSHandle((int)wParam);
					return lAcc;
				}
			}
			break;  // Fall through to DefWindowProc


		case WM_SETFOCUS:
			if (!focusEventsEnabled) break;
			if (isInited())
			{
				if (rootfocus != NULL && rootfocus != this)
				{
					if (rootfocus != curVirtualChildFocus)
						rootfocus->setFocus();
					break;
				}
				else
				{
					if (wantFocus())
					{
						onGetFocus();
						break;
					}
					else
					{
						ifc_window *w = getTab(TAB_GETFIRST);
						if (w != NULL)
						{
							w->setFocus();
						}
					}
				}
			}
			break;

		case WM_KILLFOCUS:
		{
			ifc_window *rp = getRootParent();
			if (!WASABI_API_WND->rootwndIsValid(rp) || !Wasabi::Std::Wnd::isValidWnd(rp->getOsWindowHandle())) break;
			if (!focusEventsEnabled) break;
#ifdef WASABI_COMPILE_WND
			if (WASABI_API_WND) WASABI_API_WND->forwardOnKillFocus(); // resets the keyboard active keys buffer
#endif
			if (!WASABI_API_WND->rootwndIsValid(curVirtualChildFocus)) curVirtualChildFocus = NULL;
			if (curVirtualChildFocus)
			{
				curVirtualChildFocus->onKillFocus();
				curVirtualChildFocus = NULL;
			}
			else
				if (hasfocus) onKillFocus();
			break;
		}

		// dragging and dropping

		case WM_LBUTTONDOWN:
		{
			if (lParam == 0xdeadc0de)
				return 1;

			if (bufferizeLockedUIMsg(uMsg, (int)wParam, (int)lParam))
				return 0;

			WASABI_API_WND->popupexit_check(this);

			if (checkModal())
				return 0;

			abortTip();

			int xPos = (signed short)LOWORD(lParam);
			int yPos = (signed short)HIWORD(lParam);

			xPos = (int)((float)xPos / getRenderRatio());
			yPos = (int)((float)yPos / getRenderRatio());
			
			if (!getCapture() && hasVirtualChildren() && handleVirtualChildMsg(WM_LBUTTONDOWN, xPos, yPos))
				return 0;

			if (isEnabled() && !dragging)
			{
				autoFocus(this);

				int r = 0;

				if (wantLeftClicks())
					r = onLeftButtonDown(xPos, yPos);

				if (checkDoubleClick(uMsg, xPos, yPos) && wantDoubleClicks() && onLeftButtonDblClk(xPos, yPos))
					return 0;
				
				return r;
			}
		}
		break;

		case WM_RBUTTONDOWN:
		{
			if (lParam == 0xdeadc0de) return 1;
			if (bufferizeLockedUIMsg(uMsg, (int)wParam, (int)lParam)) return 0;
			WASABI_API_WND->popupexit_check(this);
			if (checkModal()) return 0;
			abortTip();
			int xPos = (signed short)LOWORD(lParam);
			int yPos = (signed short)HIWORD(lParam);
			xPos = (int)((float)xPos / getRenderRatio());
			yPos = (int)((float)yPos / getRenderRatio());
			if (!getCapture() && hasVirtualChildren())
				if (handleVirtualChildMsg(WM_RBUTTONDOWN, xPos, yPos))
					return 0;
			if (isEnabled() && !dragging)
			{
				autoFocus(this);
				int r = 0;
				if (wantRightClicks())
					r = onRightButtonDown(xPos, yPos);
				if (checkDoubleClick(uMsg, xPos, yPos) && wantDoubleClicks()) if (onRightButtonDblClk(xPos, yPos)) return 0;
				return r;
			}
		}
		break;
		case WM_MOUSEHOVER:
			if (checkModal()) return 0;
			if (!getCapture() && hasVirtualChildren())
				if (handleVirtualChildMsg(WM_MOUSEHOVER, 0, 0))
					return 0;
			break;
		case WM_MOUSEMOVE:
		{
			/*      static int mm=0;
			      DebugString("mousemove %d\n", mm++);*/
			if (checkModal()) return 0;
			int xPos = (signed short)LOWORD(lParam);
			int yPos = (signed short)HIWORD(lParam);
			xPos = (int)((float)xPos / getRenderRatio());
			yPos = (int)((float)yPos / getRenderRatio());
			if (dragging)
			{
				POINT pt = {xPos, yPos};
				clientToScreen(&pt);
				ifc_window *targ;
				int candrop = 0;
				// find the window the mouse is over

				targ = NULL;
				if (stickyWnd)
				{
					RECT wr;
					GetWindowRect(stickyWnd->getOsWindowHandle(), &wr);
					if (pt.x >= wr.left - sticky.left &&
					    pt.x <= wr.right + sticky.right &&
					    pt.y >= wr.top - sticky.top &&
					    pt.y <= wr.bottom + sticky.bottom) targ = stickyWnd;
					else stickyWnd = NULL;
				}

				if (targ == NULL && WASABI_API_WND) targ = WASABI_API_WND->rootWndFromPoint(&pt); // FG> not to self, check

				DI prevtargdi(prevtarg);
				DI targdi(targ);

				if (prevtarg != targ)
				{
					// window switch
					if (prevtarg != NULL) prevtargdi.dragLeave(this);
					if (targ != NULL) targdi.dragEnter(this);
				}
				if (targ != NULL)
					candrop = targdi.dragOver(pt.x, pt.y, this);
				if (targ == NULL || !candrop)
					SetCursor(LoadCursor(NULL, MAKEINTRESOURCE(IDC_NO)));
				else
					SetCursor(LoadCursor(NULL, MAKEINTRESOURCE(IDC_APPSTARTING)));
				prevtarg = targ;
			}
			else if (isEnabled())
			{
				tipbeenchecked = FALSE;
				if (!getCapture() && hasVirtualChildren())
				{
					if (handleVirtualChildMsg(WM_MOUSEMOVE, xPos, yPos))
						return 0;
				}
				if (getCapture())
				{
					if (wantMouseMoves())
						if (onMouseMove(xPos, yPos))
							return 0;
				}
				if (!tipbeenchecked) onTipMouseMove();
				return 0;
			}
		}
		break;

		case WM_LBUTTONUP:
		{
			if (lParam == 0xdeadc0de) return 1;
			if (bufferizeLockedUIMsg(uMsg, (int)wParam, (int)lParam)) return 0;
			if (checkModal()) return 0;
			int xPos = (signed short)LOWORD(lParam);
			int yPos = (signed short)HIWORD(lParam);
			xPos = (int)((float)xPos / getRenderRatio());
			yPos = (int)((float)yPos / getRenderRatio());
			abortTip();
			if (!dragging && !getCapture() && hasVirtualChildren())
			{
				if (handleVirtualChildMsg(WM_LBUTTONUP, xPos, yPos))
					return 0;
			}
			if (dragging)
			{
				clientToScreen(&xPos, &yPos);
				int res = 0;
				if (prevtarg != NULL)
				{
					res = DI(prevtarg).dragDrop(this, xPos, yPos);
				}

				// inform source what happened
				dragComplete(res);

				resetDragSet();
				prevtarg = NULL;
				stickyWnd = NULL;
				suggestedTitle = NULL;
				SetCursor(LoadCursor(NULL, MAKEINTRESOURCE(IDC_ARROW)));
				Wasabi::Std::Wnd::releaseCapture();
				dragging = 0;
			}
			else if (isEnabled())
			{
				if (wantLeftClicks())
					if (onLeftButtonUp(xPos, yPos)) return 0;
			}
		}
		break;

		case WM_RBUTTONUP:
		{
			if (lParam == 0xdeadc0de) return 1;
			if (bufferizeLockedUIMsg(uMsg, (int)wParam, (int)lParam)) return 0;
			if (checkModal()) return 0;
			abortTip();
			int xPos = (signed short)LOWORD(lParam);
			int yPos = (signed short)HIWORD(lParam);
			xPos = (int)((float)xPos / getRenderRatio());
			yPos = (int)((float)yPos / getRenderRatio());
			if (!getCapture() && hasVirtualChildren())
			{
				if (handleVirtualChildMsg(WM_RBUTTONUP, xPos, yPos))
					return 0;
			}
			if (isEnabled() && !dragging)
			{
				if (wantRightClicks())
					if (onRightButtonUp(xPos, yPos)) return 0;
			}
		}
		break;

		case WM_CONTEXTMENU:
		{
			if (bufferizeLockedUIMsg(uMsg, (int)wParam, (int)lParam)) return 0;
			if (checkModal()) return 0;
			ASSERT(hWnd != NULL);
			int xPos = (signed short)LOWORD(lParam);
			int yPos = (signed short)HIWORD(lParam);
			if (hWnd == getOsWindowHandle())
			{
				if (wantContextMenus())
					if (onContextMenu(xPos, yPos)) return 0;
			}
			else if (GetParent(hWnd) == getOsWindowHandle())
			{
				if (wantContextMenus())
					if (onChildContextMenu(xPos, yPos)) return 0;
			}
		}
		break;

		case WM_ERASEBKGND:
			return (onEraseBkgnd((HDC)wParam));

		case WM_MOUSEWHEEL:
		{
			abortTip();

			int l, a;
			l = (short)HIWORD(wParam) / 120;
			a = (short)HIWORD(wParam);
			if (!l)
				if (a > 0) l = 1;
				else if (a < 0)l = 0;
			a = l >= 0 ? l : -l;
			if (GetAsyncKeyState(VK_MBUTTON)&0x8000)
			{
				if (l >= 0) l = 0; // Fast Forward 5s
				else l = 1; // Rewind 5s
			}
			else
			{
				if (l >= 0) l = 2; // Volume up
				else l = 3; // Volume down
			}

			int r = 0;

			if (l & 1)
				r = onMouseWheelDown(!(BOOL)(l & 2), a);
			else
				r = onMouseWheelUp(!(BOOL)(l & 2), a);
			if (r == 0)
			{
				r = WASABI_API_WND->forwardOnMouseWheel(l, a);
			}
			// if it wasn't handled by this wnd, nor by the api, send it to the main wnd, unless we're it
			if (r == 0)
			{
				if (WASABI_API_WND->main_getRootWnd() != this)
					r = (int)SendMessageW(WASABI_API_WND->main_getRootWnd()->gethWnd(), uMsg, wParam, lParam);
			}

			return r;
		}

		case WM_WA_RELOAD:
		{
			if (wParam == 0)
				freeResources();
			else
				reloadResources();
			return 0;
		}

		case WM_WA_GETFBSIZE:
		{
			SIZE *s = (SIZE *)wParam;
			s->cx = rwidth;
			s->cy = rheight;
			return 0;
		}

		case WM_USER + 8976:  // wheel in tip, delete tip
			abortTip();
			return 0;

		case WM_CHAR:
			if (bufferizeLockedUIMsg(uMsg, (int)wParam, (int)lParam)) return 0;
			if (WASABI_API_WND->interceptOnChar((TCHAR) wParam)) return 0;
			if (curVirtualChildFocus == NULL)
			{
				if (onChar(((TCHAR) wParam))) return 0;
			}
			else
			{
				if (curVirtualChildFocus->onChar(((TCHAR) wParam))) return 0;
			}
			if (WASABI_API_WND && WASABI_API_WND->forwardOnChar(this, (TCHAR) wParam, (int)lParam)) return 0;
			break;

		case WM_KEYDOWN:
			if (bufferizeLockedUIMsg(uMsg, (int)wParam, (int)lParam)) return 0;
			if (WASABI_API_WND->interceptOnKeyDown((int) wParam)) return 0;
			if (curVirtualChildFocus == NULL)
			{
				if (onKeyDown((int) wParam)) return 0;
			}
			else
			{
				if (curVirtualChildFocus->onKeyDown((int)wParam)) return 0;
			}
			if (WASABI_API_WND && WASABI_API_WND->forwardOnKeyDown(this, (int) wParam, (int)lParam)) return 0;
			break;

		case WM_KEYUP:
			if (bufferizeLockedUIMsg(uMsg, (int)wParam, (int)lParam)) return 0;
			if (WASABI_API_WND->interceptOnKeyUp((int) wParam)) return 0;
			if (curVirtualChildFocus == NULL)
			{
				if (onKeyUp((int) wParam)) return 0;
			}
			else
			{
				if (curVirtualChildFocus->onKeyUp((int)wParam)) return 0;
			}
			if (WASABI_API_WND && WASABI_API_WND->forwardOnKeyUp(this, (int) wParam, (int)lParam)) return 0;
			break;

		case WM_SYSKEYDOWN:
			if (bufferizeLockedUIMsg(uMsg, (int)wParam, (int)lParam)) return 0;
			if (WASABI_API_WND->interceptOnSysKeyDown((int) wParam, (int)lParam)) return 0;
			if (curVirtualChildFocus == NULL)
			{
				if (onSysKeyDown((int) wParam, (int)lParam)) return 0;
			}
			else
			{
				if (curVirtualChildFocus->onSysKeyDown((int)wParam, (int)lParam)) return 0;
			}
			if (WASABI_API_WND && WASABI_API_WND->forwardOnSysKeyDown(this, (int) wParam, (int)lParam)) return 0;
			break;

		case WM_SYSKEYUP:
			if (bufferizeLockedUIMsg(uMsg, (int)wParam, (int)lParam)) return 0;
			if (WASABI_API_WND->interceptOnSysKeyUp((int) wParam, (int)lParam)) return 0;
			if (curVirtualChildFocus == NULL)
			{
				if (onSysKeyUp((int) wParam, (int)lParam)) return 0;
			}
			else
			{
				if (curVirtualChildFocus->onSysKeyUp((int)wParam, (int)lParam)) return 0;
			}
			if (WASABI_API_WND && WASABI_API_WND->forwardOnSysKeyUp(this, (int) wParam, (int)lParam)) return 0;
			break;

		case WM_MOUSEACTIVATE:
		{
			if (checkModal() || !wantActivation())
				return MA_NOACTIVATE;
			//SetFocus(getOsWindowHandle());
			return MA_ACTIVATE;
		}

		case WM_ACTIVATEAPP:

			if (wParam == FALSE)
			{
				
				if (WASABI_API_WND != NULL)
				{
					WASABI_API_WND->popupexit_signal();
					WASABI_API_SYSCB->syscb_issueCallback(SysCallback::GC, GarbageCollectCallback::GARBAGECOLLECT);
					WASABI_API_WND->kbdReset();
					if (ghosthwnd.getNumItems() > 0 && ghostbust)
					{
						ghostbust = 0; postDeferredCallback(DC_KILLGHOST);
					}
					return 0;
				}
			}
			
			break;

		case WM_ACTIVATE:
			switch(LOWORD(wParam))
			{
				case WA_ACTIVE:
				case WA_CLICKACTIVE: 
					if (WASABI_API_WND != NULL)
					WASABI_API_WND->popupexit_check(this);
					
					onActivate();

					if (WA_CLICKACTIVE == LOWORD(wParam))
					{
						POINT pt;
						DWORD pts = GetMessagePos();
						POINTSTOPOINT(pt, pts);
						MapWindowPoints(HWND_DESKTOP, hwnd, &pt, 1);
						HWND hTarget = ChildWindowFromPointEx(hwnd, pt, CWP_SKIPINVISIBLE | CWP_SKIPDISABLED | CWP_SKIPTRANSPARENT);
						if (hTarget && hTarget != hwnd) lastActiveWnd = hTarget;
					}
					
					if (lastActiveWnd != hwnd && NULL != lastActiveWnd && IsWindow(lastActiveWnd))
					{
						SendMessageW(lastActiveWnd, uMsg, wParam, lParam);
						return 0;
					}
					break;
				default:

					onDeactivate();
				
					lastActiveWnd = GetFocus();
					
					if (NULL != lastActiveWnd && !IsChild(hwnd, lastActiveWnd))
						lastActiveWnd = NULL;
					
					{
#ifndef ARRAYSIZE
#define ARRAYSIZE(x) (sizeof(x)/sizeof(*x))
#endif
						if (NULL != lastActiveWnd && !BaseWnd_IsFrameWindow(lastActiveWnd))
						{
							while (lastActiveWnd)
							{
								if (BaseWnd_IsFrameWindow(GetWindow(lastActiveWnd, GW_OWNER)))
									break;
								lastActiveWnd = GetAncestor(lastActiveWnd, GA_PARENT);
							}
						}
					}
				
					if (lastActiveWnd != hwnd && NULL != lastActiveWnd)
					{
						SendMessageW(lastActiveWnd, uMsg, wParam, lParam);
						return 0;
					}
				
					break;
			}
			break;
			
		case WM_NCACTIVATE:
			if (allowDeactivation())
				return TRUE;
			return FALSE;

		case WM_WINDOWPOSCHANGING:
		{
			if (!isVirtual() && Wasabi::Std::Wnd::isPopup(hwnd))
			{
				WINDOWPOS *wp = (WINDOWPOS *)lParam;
				if (wp->x != rx || wp->y != ry) wp->flags |= SWP_NOMOVE;
			}
		}
		break;

		case WM_WINDOWPOSCHANGED:
		{

			WINDOWPOS *lpwp = (WINDOWPOS *)lParam; // points to size and position data
			if (lpwp->flags & SWP_HIDEWINDOW)
			{
				minimized = 1;
				onMinimize();
			}
			else if (lpwp->flags & SWP_SHOWWINDOW)
			{
				minimized = 0;
				onRestore();
			}

			if (!inonresize)
			{
				int w = rwidth;
				int h = rheight;
				multRatio(&w, &h);
				if (lpwp->cx != w || lpwp->cy != h)
				{
					DebugStringW(L"external onResize\n");
					w = lpwp->cx;
					h = lpwp->cy;
					divRatio(&w, &h);
					setRSize(rx, ry, w, h);
					if (isPostOnInit())
						onResize();
				}
			}

			onPostedMove();
			return 0;
		}

		case WM_DROPFILES:
		{
			if (checkModal()) break;
			WASABI_API_WND->pushModalWnd();
			onExternalDropBegin();
			HDROP h = (HDROP)wParam;
			POINT dp = {0};
			DragQueryPoint(h, &dp);
			clientToScreen(&dp);
			// build a file list
			wchar_t buf[WA_MAX_PATH] = {0};
			PtrList<FilenamePS> keep;

			SetCursor(LoadCursor(NULL, IDC_WAIT));

			//CUT #if UTF8
			//CUT       // doesn't really need UTF8, the "buf" is never written to.
			//CUT       // made to be NULL to enforce this concept.
			int nfiles = DragQueryFile(h, 0xffffffff, NULL, 0);
			//CUT #else
			//CUT       int nfiles = DragQueryFile(h, 0xffffffff, buf, sizeof(buf));
			//CUT #endif

			// convert them all to PlayItem *'s
			for (int i = 0; i < nfiles; i++)
			{
				DragQueryFileW(h, i, buf, WA_MAX_PATH);
				addDroppedFile(buf, &keep);	// recursive

			}
			SetCursor(LoadCursor(NULL, IDC_ARROW));
			dragging = 1;
			if (dragEnter(this))
			{
				if (dragOver(dp.x, dp.y, this)) dragDrop(this, dp.x, dp.y);
			}
			else
			{
				dragLeave(this);
#ifdef FORWARD_DRAGNDROP
				HWND w = WASABI_API_WND->main_getRootWnd()->gethWnd();
				SendMessageW(w, WM_DROPFILES, wParam, lParam);
#endif

			}
			dragging = 0;

			// remove data
			keep.deleteAll();
			resetDragSet();

			onExternalDropEnd();
			WASABI_API_WND->popModalWnd();
		}
		return 0;	// dropfiles

		case WM_CAPTURECHANGED:
			/*    static int cc=0;
			    DebugString("capture changed! %d\n", cc++);*/
			if (preventcancelcapture) return 0;
			inputCaptured = 0;
			if (curVirtualChildCaptured != NULL)
			{
				ifc_window *w = curVirtualChildCaptured;
				curVirtualChildCaptured = NULL;
				w->onCancelCapture();
			}
			else
			{
				onCancelCapture();
			}
			return 0;

		} //switch

	if (WINAMP_WM_DIRECT_MOUSE_WHEEL == uMsg && 
		WM_NULL != WINAMP_WM_DIRECT_MOUSE_WHEEL)
	{
		wndProc(hWnd, WM_MOUSEWHEEL, wParam, lParam);
		return TRUE;
	}

	if (uMsg >= WM_USER)
	{
		int ret;
		if (onUserMessage(uMsg, (int)wParam, (int)lParam, &ret))
			return ret;
		return 0;
	}

	return DefWindowProcW(hWnd, uMsg, wParam, lParam);
}
#endif
int BaseWnd::onUserMessage(int msg, int w, int l, int *r)
{
	return 0;
}

int BaseWnd::checkDoubleClick(int b, int x, int y)
{
#ifdef _WIN32
	uint32_t now = Wasabi::Std::getTickCount();

	switch (b)
	{
	case WM_LBUTTONDOWN:
		if (lastClick[0] > now - Wasabi::Std::getDoubleClickDelay())
		{
			lastClick[0] = 0;
			if (ABS(lastClickP[0].x - x) > Wasabi::Std::getDoubleClickX() || ABS(lastClickP[0].y - y) > Wasabi::Std::getDoubleClickY()) return 0;
			return 1;
		}
		lastClick[0] = now;
		lastClickP[0].x = x;
		lastClickP[0].y = y;
		break;

	case WM_RBUTTONDOWN:
		if (lastClick[1] > now - Wasabi::Std::getDoubleClickDelay())
		{
			lastClick[1] = 0;
			if (ABS(lastClickP[1].x - x) > Wasabi::Std::getDoubleClickX() || ABS(lastClickP[1].y - y) > Wasabi::Std::getDoubleClickY()) return 0;
			return 1;
		}
		lastClick[1] = now;
		lastClickP[1].x = x;
		lastClickP[1].y = y;
		break;
	}
#else
#warning port me
#endif
	return 0;
}

int BaseWnd::onMouseWheelUp(int click, int lines)
{
	return 0;
}

int BaseWnd::onMouseWheelDown(int click, int lines)
{
	return 0;
}

int BaseWnd::onContextMenu(int x, int y)
{
	return 0;
}

int BaseWnd::onChildContextMenu(int x, int y)
{
	return 0;
}

int BaseWnd::onDeferredCallback(intptr_t param1, intptr_t param2)
{
	switch (param1)
	{
	case DEFERREDCB_FLUSHPAINT:
		do_flushPaint();
		break;
	case DEFERREDCB_INVALIDATE:
		if (isPostOnInit())
			invalidate();
		break;
	case DC_KILLGHOST:
		if (ghosthwnd.getNumItems() > 0)
		{
			preventcancelcapture = 1;
			for (int i = 0;i < ghosthwnd.getNumItems();i++)
				Wasabi::Std::Wnd::destroyWnd(ghosthwnd.enumItem(i));
			ghosthwnd.freeAll();
			preventcancelcapture = 0;
		}
		break;
	case DEFERREDCB_FOCUSFIRST:
		assignRootFocus(NULL);
		if (Wasabi::Std::Wnd::getFocus() == getOsWindowHandle())
		{
			focusNext();
		}
		break;
	case 0x7849 /*DEFERREDCB_ONHIDE*/:
	{
		foreach(rootwndchildren)
		ifc_window *w = rootwndchildren.getfor();
		if (w->isVisible(1)) // check internal flag only
			w->onSetVisible(0);
		endfor;
		dependent_sendEvent(BaseWnd::depend_getClassGuid(), Event_SETVISIBLE, 0);
		break;
	}
	}
	return 0;
}

int BaseWnd::onPaint(Canvas *canvas)
{
#if 0
	// example:
	PaintCanvas c;
	if (!c.beginPaint(this)) return 0;
	(do some painting)
	c will self -destruct on return
#endif
	  if (renderbasetexture)
	{
		PaintCanvas paintcanvas;
		if (canvas == NULL)
		{
			if (!paintcanvas.beginPaint(this)) return 0;
			canvas = &paintcanvas;
		}
		RECT r;
		getNonClientRect(&r);
		RenderBaseTexture(canvas, r);
	}
	return 0;
}

int BaseWnd::onPaint(Canvas *canvas, api_region *h)
{
	if (!canvas) return onPaint(canvas);

#ifdef _WIN32
	int sdc = SaveDC(canvas->getHDC());
#elif defined(__APPLE__)
	CGContextSaveGState(canvas->getHDC());
#endif

	canvas->selectClipRgn(h);

	int rs = onPaint(canvas);

#ifdef _WIN32
	RestoreDC(canvas->getHDC(), sdc);
#elif defined(__APPLE__)
	CGContextRestoreGState(canvas->getHDC());
#endif

	return rs;
}

int BaseWnd::getTransparency()
{
	return wndalpha;
}

void BaseWnd::setTransparency(int amount)
{
	//if (wndalpha == amount) return;
	if (amount == 254) amount = 255;
	if (amount == 1) amount = 0;

	if (amount != -1) wndalpha = amount; else amount = wndalpha;

	if (!Wasabi::Std::Wnd::isDesktopAlphaAvailable())
	{
		wndalpha = 255;
		return ;
	}

	if (w2k_alpha)
	{
		invalidate();
		return ;
	}

#ifdef WIN32

	if (!isInited() || isVirtual()) return ;
	if (!Wasabi::Std::Wnd::isValidWnd(getOsWindowHandle())) return ;

	if (amount < -1) amount = 0;
	else if (amount > 255) amount = 255;

	//CUT  DWORD dwLong = GetWindowLong(hwnd, GWL_EXSTYLE);
	if (amount == 255 && !forceTransparencyFlag())
	{
		Wasabi::Std::Wnd::setLayeredWnd(hwnd, FALSE);
		//CUT    if (dwLong & WS_EX_LAYERED)
		//CUT      SetWindowLong(hwnd, GWL_EXSTYLE, dwLong & ~WS_EX_LAYERED);
		has_alpha_flag = 0;
	}
	else
	{
		if (!Wasabi::Std::Wnd::isLayeredWnd(hwnd))
			Wasabi::Std::Wnd::setLayeredWnd(hwnd, TRUE);
		//CUT    if (!(dwLong & WS_EX_LAYERED))
		//CUT      SetWindowLong(hwnd, GWL_EXSTYLE, dwLong | WS_EX_LAYERED);
		Wasabi::Std::Wnd::setLayeredAlpha(hwnd, amount);
		//CUT    setLayeredWindowAttributes(hwnd, RGB(0,0,0), amount, LWA_ALPHA);
		has_alpha_flag = 1;
	}
#endif
}

int BaseWnd::forceTransparencyFlag()
{
	return 0;
}

int BaseWnd::beginCapture()
{
	if (!getCapture())
	{
		disable_tooltip_til_recapture = 0;
		curVirtualChildCaptured = NULL;
		/*    oldCapture = */Wasabi::Std::Wnd::setCapture(getOsWindowHandle());
		/*    if (oldCapture) {
		      DebugString("Stolen capture detected, this may be ok, but try to avoid it if possible. Saving old capture\n");
		    }*/
		inputCaptured = 1;
	}
	return 1;
}

int BaseWnd::endCapture()
{
	preventcancelcapture = 1;
	if (Wasabi::Std::Wnd::getCapture() == getOsWindowHandle()) Wasabi::Std::Wnd::releaseCapture();
	/*  if (oldCapture) {
	    DebugString("Restoring old capture\n");
	    SetCapture(oldCapture);
	    oldCapture = NULL;
	  }*/
	inputCaptured = 0;
	preventcancelcapture = 0;
	return 1;
}

int BaseWnd::getCapture()
{
	if (inputCaptured && Wasabi::Std::Wnd::getCapture() == getOsWindowHandle() && curVirtualChildCaptured == NULL) return 1;
	return 0;
}

void BaseWnd::cancelCapture()
{
	if (curVirtualChildCaptured != NULL)
	{
		curVirtualChildCaptured->cancelCapture();
		return ;
	}
	if (getCapture()) endCapture();
	onCancelCapture();
}

int BaseWnd::onMouseMove(int x, int y)
{
	onTipMouseMove();
	return 0;
}

void BaseWnd::onTipMouseMove()
{
	POINT p;

	if (dragging) return ;
	if (disable_tooltip_til_recapture) return ;

	tipbeenchecked = TRUE;

	Wasabi::Std::getMousePos(&p);

	if (WASABI_API_WND->rootWndFromPoint(&p) != (ifc_window *)this)
	{
		// leaving area
		tip_done = FALSE;
		if (tipawaytimer)
			killTimer(TIP_AWAY_ID);
		tipawaytimer = FALSE;
		if (tipshowtimer)
		{
			// TODO: on the mac, use CreateMouseTrackingRegion
			TRACKMOUSEEVENT tracker;
			tracker.cbSize=sizeof(tracker);
			tracker.dwFlags = TME_HOVER|TME_CANCEL;
			tracker.hwndTrack = this->getOsWindowHandle();
			tracker.dwHoverTime = TIP_TIMER_THRESHOLD;

			TrackMouseEvent(&tracker);
		}
		tipshowtimer = FALSE;
		destroyTip();
	}
	else
	{
		// moving in area
		const wchar_t *t = getTip();
		if (!disable_tooltip_til_recapture && !tipshowtimer && !tip_done && t != NULL && *t != 0)
		{
			//entering area & need tip

			// TODO: on the mac, use CreateMouseTrackingRegion
			TRACKMOUSEEVENT tracker;
			tracker.cbSize=sizeof(tracker);
			tracker.dwFlags = TME_HOVER;
			tracker.hwndTrack = this->getOsWindowHandle();
			tracker.dwHoverTime = TIP_TIMER_THRESHOLD;

			TrackMouseEvent(&tracker);

			tipshowtimer = TRUE;
		}
		/*else if (tipshowtimer)
		{
		TRACKMOUSEEVENT tracker;
		tracker.cbSize=sizeof(tracker);
		tracker.dwFlags = TME_HOVER;
		tracker.hwndTrack = this->getOsWindowHandle();
		tracker.dwHoverTime = TIP_TIMER_THRESHOLD;

		TrackMouseEvent(&tracker);
		}*/
	}
}

int BaseWnd::onLeftButtonDblClk(int x, int y)
{
	return 0;
}

int BaseWnd::onRightButtonDblClk(int x, int y)
{
	return 0;
}

int BaseWnd::onGetFocus()
{
	// return TRUE if you override this
	hasfocus = 1;
	notifyParent(ChildNotify::GOTFOCUS);
	getRootParent()->onSetRootFocus(this);
	invalidate();
	Accessible *a = getAccessibleObject();
	if (a != NULL)
		a->onGetFocus();
	return 1;
}

int BaseWnd::onKillFocus()
{
	// return TRUE if you override this
	hasfocus = 0;
	notifyParent(ChildNotify::KILLFOCUS);
	invalidate();
	return 1;
}

#if defined(_WIN64)
int BaseWnd::childNotify(ifc_window* child, int msg, int p1, int p2)
{
	return 0;
}
#else
int BaseWnd::childNotify(ifc_window *child, int msg, intptr_t p1, intptr_t p2)
{
	return 0;
}
#endif

int BaseWnd::addDragItem(const wchar_t *droptype, void *item)
{
	ASSERT(droptype != NULL);
	if (item == NULL) return -1;
	DragSet *set;
	int pos = dragCheckData(droptype);
	if (pos == -1)
	{
		set = new DragSet();
		set->setName(droptype);
		dragsets.addItem(set);
		pos = dragsets.getNumItems() - 1;
	}
	else set = dragsets[pos];
	set->addItem(item);
	return pos;
}

#ifdef _WIN32
int BaseWnd::handleDrag()
{
	abortTip();
	if (dragsets.getNumItems() == 0) return 0;

	Wasabi::Std::Wnd::setCapture(hwnd);
	SetCursor(LoadCursor(NULL, MAKEINTRESOURCE(IDC_APPSTARTING)));

	dragging = 1;
	stickyWnd = NULL;

	return 1;
}
#endif

int BaseWnd::resetDragSet()
{
	dragsets.deleteAll();
	return 1;
}

int BaseWnd::dragEnter(ifc_window *sourceWnd)
{
	ifc_window *rw = getParent(); //api_window::rootwndFromRootWnd(getParent()); //FG> note to self, check!
	if (rw) return DI(rw).dragEnter(sourceWnd);
	return 0;
}

int BaseWnd::dragSetSticky(ifc_window *wnd, int left, int right, int up, int down)
{
	ASSERT(dragging);
	stickyWnd = wnd;

	if (left < 0) left = 0;
	if (right < 0) right = 0;
	if (up < 0) up = 0;
	if (down < 0) down = 0;

	Wasabi::Std::setRect(&sticky, left, up, right, down);

	return 1;
}

void BaseWnd::setSuggestedDropTitle(const wchar_t *title)
{
	ASSERT(title != NULL);
	suggestedTitle = title;
}

const wchar_t *BaseWnd::dragGetSuggestedDropTitle()
{
	return suggestedTitle;	// can be NULL
}

int BaseWnd::dragCheckData(const wchar_t *type, int *nitems)
{
	for (int i = 0; i < dragsets.getNumItems(); i++)
	{
		if (!WCSICMP(type, dragsets[i]->getName()))
		{
			if (nitems != NULL) *nitems = dragsets[i]->getNumItems();
			return i;
		}
	}
	return -1;
}

void *BaseWnd::dragGetData(int slot, int itemnum)
{
	if (slot < 0 || slot >= dragsets.getNumItems()) return 0;
	if (itemnum < 0 || itemnum >= dragsets[slot]->getNumItems()) return 0;
	return dragsets[slot]->enumItem(itemnum);
}

void BaseWnd::addDroppedFile(const wchar_t *filename, PtrList<FilenamePS> *plist)
{
#ifdef RECURSE_SUBDIRS_ON_DROP
	const char *slash = filename + STRLEN(filename) - 1;
	for (; slash > filename; slash--) if (*slash == '/' || *slash == '\\') break;
	if (STREQL(slash + 1, ".") || STREQL(slash + 1, "..")) return ;

	char buf[WA_MAX_PATH] = {0};
	STRCPY(buf, filename);
	// try to resolve shortcuts
	char *ext = buf + STRLEN(buf) - 1;
	for (; ext > buf; ext--) if (*ext == '.' || *ext == '\\' || *ext == '/') break;
#ifdef WIN32
	if (!STRICMP(ext, ".lnk"))
	{
		char buf2[MAX_PATH] = {0};
		if (StdFile::resolveShortcut(buf, buf2)) STRCPY(buf, buf2);
	}
#endif

	int isdir = 0;

	// handle root dir specially?
	WIN32_FIND_DATA data = {0};
	HANDLE r = FindFirstFile(buf, &data);
	if (!r) return ;
	FindClose(r);
	if (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) isdir = 1;

	if (isdir)
	{
		onExternalDropDirScan(buf);

		// enumerate that dir
		char search[WA_MAX_PATH] = {0};
		wsprintf(search, "%s\\*.*", buf);
		HANDLE files = FindFirstFile(search, &data);
		if (files == INVALID_HANDLE_VALUE) return ;	// nothin' in it
		for (;;)
		{
			wchar_t obuf[WA_MAX_PATH] = {0};
			swprintf(obuf, L"%s\\%s", buf, data.cFileName);
			addDroppedFile(obuf, plist);
			if (!FindNextFile(files, &data))
			{
				FindClose(files);
				return ;
			}
		}

		// should never get here
	}
	else
	{
		addDragItem(DD_FILENAME, plist->addItem(new FilenamePS(StringPrintfW(L"file:%s", buf))));
	}
#else
	addDragItem(DD_FILENAME, plist->addItem(new FilenamePS(StringPrintfW(L"file:%s", filename))));
#endif
}

bool BaseWnd::getNoCopyBits(void)
{
	return ncb;
}

void BaseWnd::setNoCopyBits(bool newncb)
{
	ncb = newncb;
}

int BaseWnd::onEraseBkgnd(HDC dc)
{
	return 1;
}

void BaseWnd::setIcon(OSICONHANDLE icon, int _small)
{
	Wasabi::Std::Wnd::setIcon(getOsWindowHandle(), icon, !_small);
	//CUT  SendMessageW(getOsWindowHandle(), WM_SETICON, _small ? ICON_SMALL : ICON_BIG, (int)icon);
}

const wchar_t *BaseWnd::getTip()
{
	return tip;
}

void BaseWnd::setTip(const wchar_t *_tooltip)
{
	tip = _tooltip;
	abortTip();
}

int BaseWnd::getStartHidden()
{
	return start_hidden;
}

void BaseWnd::abortTip()
{
	if (tipshowtimer)
	{
		// TODO: on the mac, use CreateMouseTrackingRegion
		TRACKMOUSEEVENT tracker;
		tracker.cbSize=sizeof(tracker);
		tracker.dwFlags = TME_HOVER|TME_CANCEL;
		tracker.hwndTrack = this->getOsWindowHandle();
		tracker.dwHoverTime = TIP_TIMER_THRESHOLD;

		TrackMouseEvent(&tracker);
	}
	tipshowtimer = FALSE;
	if (tipawaytimer)
		killTimer(TIP_AWAY_ID);
	tipawaytimer = FALSE;
	if (tipdestroytimer)
		killTimer(TIP_DESTROYTIMER_ID);
	tipdestroytimer = FALSE;
	destroyTip();
	tip_done = FALSE;
	RECT r;
	if (getOsWindowHandle() && Wasabi::Std::Wnd::getUpdateRect(getOsWindowHandle(), &r) != 0) // FG> avoids xoring over disapearing tip
		repaint();
}

int BaseWnd::isVisible(int within)
{
	if (!isVirtual() && !getOsWindowHandle()) return 0;
	if (!this_visible) return 0;

	if (within) return this_visible; // whatever, local

	if (isVirtual()) // virtual, global
		if (getParent())
			return getParent()->isVisible();
		else
			return 0;

	// non virtual, global
	if (Wasabi::Std::Wnd::isPopup(getOsWindowHandle())) return this_visible;
	if (!Wasabi::Std::Wnd::isValidWnd(Wasabi::Std::Wnd::getParent(getOsWindowHandle()))) return 0;
	if (getParent()) return getParent()->isVisible(); // not a popup, check its parent or fail
	return this_visible;
}

void BaseWnd::registerRootWndChild(ifc_window *child)
{
	rootwndchildren.addItem(child);
	if (child->isVirtual())
		virtualChildren.addItem(child);
}

void BaseWnd::unregisterRootWndChild(ifc_window *child)
{
	delTabOrderEntry(child);
	rootwndchildren.removeItem(child);
	if (curVirtualChildCaptured == child)
	{
		setVirtualChildCapture(NULL);
	}
	if (curVirtualChildFocus == child)
		curVirtualChildFocus = NULL;
	virtualChildren.removeItem(child);
	//WASABI_API_WND->timer_remove(this, -1);
	if (isPostOnInit() && isVisible())
		postDeferredCallback(DEFERREDCB_INVALIDATE, 0);
}

int BaseWnd::isVirtual()
{
	return 0;
}

//CUT?inline int isInRect(RECT *r,int x,int y) {
//CUT?  if (x>=r->left&&x<=r->right&&y>=r->top&&y<=r->bottom) return 1;
//CUT?  return 0;
//CUT?}

int BaseWnd::ensureVirtualCanvasOk()
{
	RECT ncr;

	if (isVirtual() && getParent()) return 1;

	int size_w = rwidth;
	int size_h = rheight;

	if (!size_w || !size_h) return 0;

	if (!virtualCanvas || virtualCanvasH != size_h || virtualCanvasW != size_w)
	{
		if (virtualCanvas)
		{
			deleteFrameBuffer(virtualCanvas);
			virtualCanvas = NULL;
		}
		delete scalecanvas;
		scalecanvas = NULL;
		virtualCanvas = createFrameBuffer(size_w, size_h);
		prepareFrameBuffer(virtualCanvas, size_w, size_h);
		virtualCanvas->setBaseWnd(this);
		virtualCanvasH = size_h; virtualCanvasW = size_w;
		BaseWnd::getNonClientRect(&ncr);
		deferedInvalidateRect(&ncr);
	}
	return 1;
}

Canvas *BaseWnd::createFrameBuffer(int w, int h)
{
	return new BltCanvas(w, h, getOsWindowHandle());
}

void BaseWnd::prepareFrameBuffer(Canvas *canvas, int w, int h)
{
	RECT r = {0, 0, w, h};
	RegionI reg(&r);
	virtualBeforePaint(&reg);
#ifdef _WIN32
	canvas->selectClipRgn(NULL);
	canvas->fillRect(&r, 0);
#elif defined(__APPLE__)
	CGContextClearRect(canvas->getHDC(), CGRectInfinite); // TODO: make "clear" function in canvas
#endif
	virtualAfterPaint(&reg);
}

void BaseWnd::deleteFrameBuffer(Canvas *canvas)
{
	delete canvas;
}

// paints the client content, followed by the virtual child tree. recursive
int BaseWnd::paintTree(Canvas *canvas, api_region *r)
{
	onPaint(canvas, r);

#ifdef WASABI_DRAW_FOCUS_RECT
	if (gotFocus())
	{
		RECT ncr;
		getNonClientRect(&ncr);
		// try to use skinned focus rect
		if (WASABI_API_WND->paintset_present(Paintset::FOCUSRECT))
			WASABI_API_WND->paintset_render(Paintset::FOCUSRECT, canvas, &ncr, 128);
		else // otherwise this looks kinda nice :P
			canvas->drawRect(&ncr, 0, 0xFFFFFF, 128);
	}
#endif

	if (isVirtual() && !hasVirtualChildren()) return 0;

	api_region *hostrgn = NULL;
	api_region *update = r;

	if (!(hwnd != NULL && getParent() == NULL))
	{
		hostrgn = getRegion();
		update = r->clone();
		if (hostrgn && !isRectRgn())
		{
			RECT ncr = clientRect();
			api_region *hostclone = hostrgn->clone();
			hostclone->addRegion(getComposedRegion());
			hostclone->offset(ncr.left, ncr.top);
			update->andRegion(hostclone);
			hostrgn->disposeClone(hostclone);
		}
	}

	RegionI client_update;
	for (int i = 0;i < virtualChildren.getNumItems();i++)
	{
		if (!virtualChildren[i]->isVisible(1)) continue;
		RECT rChild;
		ifc_window *w = virtualChildren[i];
		w->getNonClientRect(&rChild);
		if ((rChild.right != rChild.left) && (rChild.bottom != rChild.top))
			if (update->intersectRect(&rChild, &client_update))
			{
				w->paintTree(canvas, &client_update);
			}
	}

	if (update != r) r->disposeClone(update);

	return 1;
}

void BaseWnd::setVirtualCanvas(Canvas *c)
{
	virtualCanvas = c;
}

int BaseWnd::pointInWnd(POINT *p)
{
	RECT r;
	if (!isVisible(1)) return 0;
	getWindowRect(&r);
	if (!Wasabi::Std::pointInRect(r, *p))
		return 0;
	for (int i = 0; i < getNumRootWndChildren(); i++)
	{
		ifc_window *c = enumRootWndChildren(i);
		if (!c->isVisible(1)) continue;
		RECT rChild;
		c->getWindowRect(&rChild);
		if (Wasabi::Std::pointInRect(rChild, *p))
			return 0;
	}
	//NONPORTABLE
	/*  HWND child = GetWindow(getOsWindowHandle(), GW_CHILD);
	  while (child != NULL) {
	    if (IsWindowVisible(child)) {
	      RECT r2;
	      GetWindowRect(child, &r2);
	      if (Std::pointInRect(r2, *p))
	        return 0;
	    }
	    child = GetWindow(child, GW_HWNDNEXT);
	  }*/
	return 1;
}

int BaseWnd::paint(Canvas *c, api_region *r)
{
	if (isVirtual())
	{
		RegionI d;
		RECT cr;
		getClientRect(&cr);
		if (r == NULL)
		{
			d.addRect(&cr);
		}
		else
		{
			d.addRegion(r);
			d.offset(cr.left, cr.top);
		}
		ifc_window *rp = getRootParent();
		deferedInvalidate();
		rp->paint(NULL, &d);
		BltCanvas *cc = static_cast<BltCanvas*>(rp->getFrameBuffer());
		if (r != NULL) c->selectClipRgn(r);
		cc->blit(cr.left, cr.top, c, 0, 0, cr.right - cr.left, cr.bottom - cr.top);
		return 1;
	}

	if (!ensureVirtualCanvasOk()) return 0;
	RegionI *deleteme = NULL;
	if (r == NULL)
	{
		RECT cr;
		getNonClientRect(&cr);
		deleteme = new RegionI(&cr);
		r = deleteme;
	}

	virtualBeforePaint(r);

	RECT rcPaint;
	r->getBox(&rcPaint);

	double ra = getRenderRatio();

	if (deferedInvalidRgn)
	{
		api_region *nr = NULL;
		if (renderRatioActive())
		{
			nr = r->clone();
			double d = 1.0 / ra;
			nr->scale(d, d, TRUE);
		}

		if (deferedInvalidRgn->isEmpty() == 0)
		{
			// some deferednvalidated regions needs to be repainted
			// TODO: need a "clear region" function in canvas
			api_region *i = deferedInvalidRgn->clone();
#ifdef _WIN32
			FillRgn(virtualCanvas->getHDC(), i->getOSHandle(), (HBRUSH)GetStockObject(BLACK_BRUSH));
#elif defined(__APPLE__)
			CGContextSaveGState(virtualCanvas->getHDC());
			virtualCanvas->selectClipRgn(i);
			CGContextClearRect(virtualCanvas->getHDC(), CGRectInfinite);
//      virtualCanvas->selectClipRgn(0);
			CGContextRestoreGState(virtualCanvas->getHDC());
#endif
			paintTree(virtualCanvas, i);

			deferedValidateRgn(i);
			deferedInvalidRgn->disposeClone(i);

		}
		if (nr) r->disposeClone(nr);
	}

	virtualAfterPaint(r);

	if (c != NULL)
	{
		commitFrameBuffer(c, &rcPaint, ra);  //TH WDP2-212
	}

	delete deleteme;
	return 1;
}

int BaseWnd::virtualOnPaint()
{
#ifdef _WIN32
	RECT cr;
	getNonClientRect(&cr);
	if (cr.left >= cr.right || cr.top >= cr.bottom) return 0;

	if (!ensureVirtualCanvasOk()) return 0;

	RegionI reg;

	//CUT  GetUpdateRgn(getOsWindowHandle(), r->getOSHandle(), FALSE);
	Wasabi::Std::Wnd::getUpdateRegion(getOsWindowHandle(), reg.getOSHandle());

	PaintCanvas paintcanvas;
	if (!paintcanvas.beginPaint(this))
	{
		virtualAfterPaint(&reg); return 0;
	}

	// DO NOT DELETE - This looks like it does nothing, but it actually makes the GDI call us again with WM_PAINT if some window
	// moves over this one between BeginPaint and EndPaint. We still use GetUpdateRgn so we don't have to check for
	// the version of Windows. See doc. If this function is not available (should be here in 95/98/NT/2K, but we never know)
	// then we use the rcPaint rect... less precise, but still works.
	//CUT  if (getRandomRgn) {
	if (Wasabi::Std::Wnd::haveGetRandomRegion())
	{
		RegionI zap;
		//CUT    getRandomRgn(paintcanvas.getHDC(), zap.getOSHandle(), SYSRGN);
		Wasabi::Std::Wnd::getRandomRegion(paintcanvas.getHDC(), zap.getOSHandle());
	}
	else
	{
		RECT z;
		paintcanvas.getRcPaint(&z);
		reg.setRect(&z);
	}

	// -------------

	/*// for debug
	  HDC dc = GetDC(getOsWindowHandle());
	  InvertRgn(dc, r->getHRGN());
	  InvertRgn(dc, r->getHRGN());
	  ReleaseDC(getOsWindowHandle(), dc);*/

	paint(&paintcanvas, &reg);
#else
#warning port me or remove me
#endif

	return 1;
}

ifc_window *BaseWnd::enumVirtualChild(int _enum)
{
	return virtualChildren[_enum];
}

int BaseWnd::getNumVirtuals()
{
	return virtualChildren.getNumItems();
}

ifc_window *BaseWnd::enumRootWndChildren(int n)
{
	return rootwndchildren.enumItem(n);
}

int BaseWnd::getNumRootWndChildren()
{
	return rootwndchildren.getNumItems();
}

ifc_window *BaseWnd::findRootWndChild(int x, int y, int only_virtuals)
{
	for (int i = getNumRootWndChildren() - 1; i > -1; i--)
	{
		RECT r;
		ifc_window *child = enumRootWndChildren(i);
		//DebugStringW(L"findRootWndChild = entering = %s\n", child->getId());
		if (only_virtuals && !child->isVirtual()) continue;
		child->getNonClientRect(&r);
		int _x = x;
		int _y = y;
		if (!child->isVirtual())
		{
			POINT pt;
			child->getPosition(&pt);
			_x -= pt.x;
			_y -= pt.y;
		}
		int iv = child->isVisible(1);
		//int gpa = child->getPaintingAlpha();
		POINT _p = Wasabi::Std::makePoint(_x, _y);
		if (iv /*&& gpa > 0*/ && Wasabi::Std::pointInRect(r, _p))
		{
			// GROUP
			ifc_window *z = child->findRootWndChild(_x, _y);
			if (z) return z;
		}
		/*gpa > 0 &&*/
		/*if (iv && _x>=r.left&&_x<=r.right&&_y>=r.top&&_y<=r.bottom && !child->isClickThrough() && child->ptInRegion(_x, _y)) {
		  return child;
		}*/
	}
	return (!isClickThrough() && ptInRegion(x, y)) ? this : NULL;
}

//PORTME
int BaseWnd::handleVirtualChildMsg(UINT uMsg, int x, int y, void *p, void *d)
{
#ifdef _WIN32
	ifc_window *child = NULL;

	if (curVirtualChildCaptured)
		child = curVirtualChildCaptured;
	else
		child = findRootWndChild(x, y, 1); // warning, can return this which is not virtual

	//  ASSERT(child != NULL);	// BU this came up and I don't know why, looks like it should never happen
	// FG> actually it can happen when coming back from a popup menu when cpu usage is high, the window might be
	// hidden (destroying) and ptInRegion returns false.
	if (!child) return 0;

	//int isvirtual = child->isVirtual();

	if (child) child = child->getForwardWnd();

	if (child && child->isEnabled())
	{
		switch (uMsg)
		{
		case WM_LBUTTONDOWN:
			/*        if (isvirtual && child != curVirtualChildFocus)
			          focusVirtualChild(child);*/
			autoFocus(child);
			if (child->wantLeftClicks())
				child->onLeftButtonDown(x, y);
			if (child->checkDoubleClick(uMsg, x, y) && child->wantDoubleClicks())
				child->onLeftButtonDblClk(x, y);
			return 1;
		case WM_RBUTTONDOWN:
			/*        if (isvirtual && child != curVirtualChildFocus)
			          focusVirtualChild(child);*/
			autoFocus(child);
			if (child->wantRightClicks())
				child->onRightButtonDown(x, y);
			if (child->checkDoubleClick(uMsg, x, y) && child->wantDoubleClicks())
				child->onRightButtonDblClk(x, y);
			return 1;
		case WM_LBUTTONUP:
			if (child->wantLeftClicks())
				child->onLeftButtonUp(x, y);
			return 1;
		case WM_RBUTTONUP:
			if (child->wantRightClicks())
				child->onRightButtonUp(x, y);
			return 1;
		case WM_MOUSEMOVE:
		{
			if (curVirtualChildCaptured == child || (curVirtualChildCaptured == NULL))
			{
				if (child->wantMouseMoves())
					child->onMouseMove(x, y);
				return 1;
			}
			return 0;
		}
		case WM_MOUSEHOVER:
			((BaseWnd *)child)->onTip();
			break;
		case WM_SETCURSOR:
			int a = child->getCursorType(x, y);
			if (!p) return 0;
			*(int *)p = a;
			if (a == BASEWND_CURSOR_USERSET)
			{
				OSCURSORHANDLE c = child->getCustomCursor(x, y);
				if (!d) return 0;
				*(OSCURSORHANDLE *)d = c;
			}
			return 1;
		}
	}
#else
#warning port me or remove me
#endif
	return 0;
}

int BaseWnd::onLeftButtonDown(int x, int y)
{
	disable_tooltip_til_recapture = 1;
	abortTip();
	return 0;
}

int BaseWnd::onLeftButtonUp(int x, int y)
{
	disable_tooltip_til_recapture = 1;
	abortTip();
	return 0;
}

void BaseWnd::setVirtualChildCapture(ifc_window *child)
{
	if (child)
	{
		if (!inputCaptured)
		{
			beginCapture();
		}
	}
	else
	{
		endCapture();
	}
	curVirtualChildCaptured = child;
}

ifc_window *BaseWnd::getVirtualChildCapture()
{
	if (inputCaptured && Wasabi::Std::Wnd::getCapture() == getOsWindowHandle())
		return curVirtualChildCaptured;
	else
		if (inputCaptured) inputCaptured = 0;
	return NULL;
}

ifc_window *BaseWnd::getBaseTextureWindow()
{
	// return our base texture window if we have it
	if (btexture)
		return btexture;
	// return our parent's if they have it
	if (getParent())
		return getParent()->getBaseTextureWindow();
	else
		return NULL;
}

void BaseWnd::renderBaseTexture(ifc_canvas *c, const RECT &r, int alpha)
{
	WASABI_API_WND->skin_renderBaseTexture(getBaseTextureWindow(), c, r, this, alpha);
}

void BaseWnd::setBaseTextureWindow(ifc_window *w)
{
	btexture = w;
}

void BaseWnd::setNotifyWindow(ifc_window *newnotify)
{
	notifyWindow = newnotify;
}

ifc_window *BaseWnd::getNotifyWindow()
{
	return destroying ? NULL : notifyWindow;
}

int BaseWnd::gotFocus()
{
	return hasfocus && curVirtualChildFocus == NULL;
}

int BaseWnd::isActive()
{
	OSWINDOWHANDLE h = hwnd;
	if (h == NULL)
	{
		ifc_window *par = getParent();
		if (par == NULL) return 0;
		h = par->getOsWindowHandle();
	}
	if (h == NULL) return 0;
	return (Wasabi::Std::Wnd::getActiveWindow() == h);
}

int BaseWnd::onChar(unsigned int c)
{
	switch (c)
	{
	case 9:  // TAB
		if (Std::keyModifier(STDKEY_SHIFT))
			focusPrevious();
		else
			focusNext();
		return 1;
	}
	return 0;
}

/*int BaseWnd::focusVirtualChild(api_window *child) {
  if (!gotFocus()) setFocus();
  if (!child->wantFocus()) return 0;
  setVirtualChildFocus(child);
  return 1;
}*/

int BaseWnd::wantFocus()
{
	return 0;
}

// Return 1 if there is a modal window that is not this
int BaseWnd::checkModal()
{
	if (bypassModal()) return 0;
	ifc_window *w = WASABI_API_WND->getModalWnd();
	if (w && w != static_cast<ifc_window*>(this) && w != getDesktopParent())
	{
		return 1;
	}
	return 0;
}

int BaseWnd::cascadeRepaintFrom(ifc_window *who, int pack)
{
	RECT r;
	BaseWnd::getNonClientRect(&r);
	return BaseWnd::cascadeRepaintRect(&r, pack);
}

int BaseWnd::cascadeRepaint(int pack)
{
	return cascadeRepaintFrom(this, pack);
}

int BaseWnd::cascadeRepaintRgn(api_region *r, int pack)
{
	return cascadeRepaintRgnFrom(r, this, pack);
}

int BaseWnd::cascadeRepaintRect(RECT *r, int pack)
{
	return cascadeRepaintRectFrom(r, this, pack);
}

int BaseWnd::cascadeRepaintRectFrom(RECT *r, ifc_window *who, int pack)
{
	RegionI reg(r);
	int rt = cascadeRepaintRgnFrom(&reg, who, pack);
	return rt;
}

void BaseWnd::_cascadeRepaintRgn(api_region *rg)
{
	if (!ensureVirtualCanvasOk()) return ;

	WndCanvas paintcanvas;
	if (paintcanvas.attachToClient(this) == 0)
		return;

	virtualBeforePaint(rg);

	deferedInvalidateRgn(rg);
	paintTree(virtualCanvas, rg);

	virtualAfterPaint(rg);

	double ra = getRenderRatio();

	RECT rcPaint;
	rg->getBox(&rcPaint);

	RECT rc;
	getClientRect(&rc); //JF> this gets it in virtual (non-scaled) coordinates,
	// so we need to do these comparisons before scaling.
	rcPaint.bottom = MIN((int)rc.bottom, (int)rcPaint.bottom);
	rcPaint.right = MIN((int)rc.right, (int)rcPaint.right);

	if (renderRatioActive()) // probably faster than scaling the clone
	{
		rcPaint.left = (int)((rcPaint.left - 1) * ra);
		rcPaint.top = (int)((rcPaint.top - 1) * ra);
		rcPaint.right = (int)(rcPaint.right * ra + 0.999999);
		rcPaint.bottom = (int)(rcPaint.bottom * ra + 0.999999);
	}
	rcPaint.left = MAX(0, (int)rcPaint.left);
	rcPaint.top = MAX(0, (int)rcPaint.top);
	rcPaint.right = MIN((int)rcPaint.right, (int)(rwidth * ra));
	rcPaint.bottom = MIN((int)rcPaint.bottom, (int)(rheight * ra));

	commitFrameBuffer(&paintcanvas, &rcPaint, ra);
}


void BaseWnd::packCascadeRepaintRgn(api_region *rg)
{
	if (!deferedCascadeRepaintRgn) deferedCascadeRepaintRgn = new RegionI;
	deferedCascadeRepaintRgn->addRegion(rg);
	need_flush_cascaderepaint = 1;
}

int BaseWnd::cascadeRepaintRgnFrom(api_region *_rg, ifc_window *who, int pack)
{

	api_region *rg = _rg->clone();

	int j = virtualChildren.searchItem(who);
	for (int i = 0; i < virtualChildren.getNumItems(); i++)
	{
		ifc_window *w = virtualChildren[i];
		if (w != who && w->wantSiblingInvalidations())
			w->onSiblingInvalidateRgn(rg, who, j, i);
	}

	if (!pack)
	{
		_cascadeRepaintRgn(rg);
	}
	else
	{
		packCascadeRepaintRgn(rg);
	}

	_rg->disposeClone(rg);

	return 1;
}

void BaseWnd::setDesktopAlpha(int a)
{
	if (a && !Wasabi::Std::Wnd::isDesktopAlphaAvailable()) return ;
	if (a == w2k_alpha) return ;
	w2k_alpha = a;
	if (!a && scalecanvas)
	{
		delete scalecanvas;
		scalecanvas = NULL;
	}
	setLayeredWindow(w2k_alpha);
	onSetDesktopAlpha(a);
}

void BaseWnd::onSetDesktopAlpha(int a) { }

void BaseWnd::commitFrameBuffer(Canvas *paintcanvas, RECT *r, double ra)
{
	if (w2k_alpha && Wasabi::Std::Wnd::isDesktopAlphaAvailable() && !cloaked)
	{
		//CUT    BLENDFUNCTION blend= {AC_SRC_OVER, 0, wndalpha, AC_SRC_ALPHA };
		//CUT    POINT pt={0,0};
		RECT spr;
		getWindowRect(&spr);
		//CUT    POINT sp={spr.left,spr.top};
		//CUT    SIZE ss={spr.right-spr.left, spr.bottom-spr.top};
		int sw = spr.right - spr.left, sh = spr.bottom - spr.top;
		//CUT    SysCanvas c;

		if (handleRatio() && renderRatioActive())
		{
			// eek slow!
			RECT r;
			getWindowRect(&r);
			int w = r.right - r.left;
			int h = r.bottom - r.top;
			if (!scalecanvas) scalecanvas = new BltCanvas(w, h, getOsWindowHandle());
			virtualCanvas->stretchblit(0, 0, (int)((double)virtualCanvasW * 65536.0), (int)((double)virtualCanvasH * 65536.0), scalecanvas, 0, 0, w, h);
		}

		//CUT    updateLayeredWindow(hwnd, c.getHDC(), &sp, &ss, (scalecanvas ? scalecanvas : virtualCanvas)->getHDC(), &pt, 0, &blend, ULW_ALPHA);
		Wasabi::Std::Wnd::updateLayeredWnd(hwnd, spr.left, spr.top, sw, sh, (scalecanvas ? scalecanvas : virtualCanvas)->getHDC(), wndalpha);
	}
	else
	{
		if (ABS(ra - 1.0) <= 0.01)
		{
			virtualCanvas->blit(r->left, r->top, paintcanvas, r->left, r->top, r->right - r->left, r->bottom - r->top);
		}
		else
		{
			RECT tr = *r;

			double invra = 65536.0 / ra;
			int lp = tr.left;
			int tp = tr.top;
			int w = tr.right - tr.left;
			int h = tr.bottom - tr.top;

			int sx = (int)((double)lp * invra);
			int sy = (int)((double)tp * invra);
			int sw = (int)((double)w * invra);
			int sh = (int)((double)h * invra);

			virtualCanvas->stretchblit(sx, sy, sw, sh, paintcanvas, lp, tp, w, h);
		}
	}
}

void BaseWnd::flushPaint()
{
	postDeferredCallback(DEFERREDCB_FLUSHPAINT, 0);
}

void BaseWnd::do_flushPaint()
{
	if (!deferedInvalidRgn || deferedInvalidRgn->isEmpty()) return ;
	api_region *r = deferedInvalidRgn->clone();
	cascadeRepaintRgn(r);
	deferedInvalidRgn->disposeClone(r);
	deferedInvalidRgn->empty();
}

int BaseWnd::isMouseOver(int x, int y)
{
	POINT pt = {x, y};
	clientToScreen(&pt);

	return (WASABI_API_WND->rootWndFromPoint(&pt) == this);
}

void BaseWnd::freeResources()
{}

void BaseWnd::reloadResources()
{
	invalidate();
}

double BaseWnd::getRenderRatio()
{
	if (!handleRatio()) return 1.0;
	if (!ratiolinked) return ratio;
	return getParent() ? getParent()->getRenderRatio() : ratio;
}

void BaseWnd::setRenderRatio(double r)
{
	// "snap" to 1.0
	if (ABS(r - 1.0) <= 0.02f) r = 1.0;
	if (scalecanvas)
	{
		delete scalecanvas;
		scalecanvas = NULL;
	}
	if (isInited() && r != ratio && !isVirtual() && (!getParent() || !ratiolinked))
	{
		// must scale size & region accordingly
		RECT rc;
		BaseWnd::getWindowRect(&rc);
		rc.right = rc.left + rwidth;
		rc.bottom = rc.top + rheight;
		ratio = r;

		resize(&rc);

		invalidate();
		if (isPostOnInit())
			onRatioChanged();
	}
}

void BaseWnd::setRatioLinked(int l)
{
	ratiolinked = l;
	if (isPostOnInit())
		setRenderRatio(ratio);
}

int BaseWnd::renderRatioActive()
{
	return ABS(getRenderRatio() - 1.0) > 0.01f;
}

void BaseWnd::multRatio(int *x, int *y)
{
	double rr = getRenderRatio();
	if (x) *x = (int)((double)(*x) * rr);
	if (y) *y = (int)((double)(*y) * rr);
}

void BaseWnd::multRatio(RECT *r)
{
	Wasabi::Std::scaleRect(r, getRenderRatio());
}

void BaseWnd::divRatio(int *x, int *y)
{
	double rr = getRenderRatio();
	if (x) *x = (int)((double)(*x) / rr + 0.5);
	if (y) *y = (int)((double)(*y) / rr + 0.5);
}

void BaseWnd::divRatio(RECT *r)
{
	double rr = getRenderRatio();
	Wasabi::Std::scaleRect(r, 1./rr);
}

void BaseWnd::bringVirtualToFront(ifc_window *w)
{
	changeChildZorder(w, 0);
}

void BaseWnd::bringVirtualToBack(ifc_window *w)
{
	changeChildZorder(w, virtualChildren.getNumItems()-1);
}

void BaseWnd::bringVirtualAbove(ifc_window *w, ifc_window *b)
{
	ASSERT(b->isVirtual());
	int p = virtualChildren.searchItem(b);
	if (p == -1) return ;
	changeChildZorder(w, p);
}

void BaseWnd::bringVirtualBelow(ifc_window *w, ifc_window *b)
{
	ASSERT(b->isVirtual());
	int p = virtualChildren.searchItem(b);
	if (p == -1) return ;
	changeChildZorder(w, p + 1);
}

void BaseWnd::changeChildZorder(ifc_window *w, int newpos)
{
	int p = newpos;
	p = MAX(p, (int)0);
	p = MIN(p, virtualChildren.getNumItems()-1);
	RECT cr;
	w->getClientRect(&cr);

	PtrList<ifc_window> l;
	int i;
	for (i = 0;i < virtualChildren.getNumItems();i++)
		if (virtualChildren[i] != w)
			l.addItem(virtualChildren[i]);

	p = virtualChildren.getNumItems() - newpos - 1;
	virtualChildren.removeAll();

	int done = 0;

	for (i = 0;i < l.getNumItems();i++)
		if (i == p && !done)
		{
			virtualChildren.addItem(w);
			i--;
			done++;
		}
		else
		{
			RECT dr, intersection;
			l.enumItem(i)->getClientRect(&dr);
			if (Wasabi::Std::rectIntersect(intersection, dr, &cr))
				l[i]->invalidateRect(&intersection);
			virtualChildren.addItem(l.enumItem(i));
		}
	if (i == p && !done)
		virtualChildren.addItem(w);
	w->invalidate();
}

int BaseWnd::onActivate()
{
	if (hasVirtualChildren())
	{
		int l = getNumVirtuals();
		for (int i = 0; i < l; i++)
		{
			ifc_window *r = enumVirtualChild(i);
			r->onActivate();
		}
	}
		
	return 0;
}

int BaseWnd::onDeactivate()
{
	if (hasVirtualChildren())
	{
		int l = getNumVirtuals();
		for (int i = 0; i < l; i++)
		{
			ifc_window *r = enumVirtualChild(i);
			r->onDeactivate();
		}
	}
	return 0;
}

int BaseWnd::getDesktopAlpha()
{
	return w2k_alpha;
}

api_region *BaseWnd::getRegion()
{
	return NULL;
}

//CUT int BaseWnd::isTransparencyAvailable() {
//CUT #ifdef WIN32
//CUT #else
//CUT #pragma warning port me!
//CUT #endif
//CUT   return 0;
//CUT }

int BaseWnd::handleTransparency()
{
	return 1; // by default all windows handle transparency, only windows blitting directly on the SCREEN (if you blit directly on the DC it's still ok),
}           // for instance, a vis or a video using overlay should return 0, this will let the layout auto manage its alpha as that window is shown/hiden

void BaseWnd::setAlpha(int active, int inactive)
{
	if (active == 254) active = 255;
	if (active == 1) active = 0;
	if (inactive == 254) inactive = 255;
	if (inactive == 1) inactive = 0;
	int oldactivealpha = activealpha;
	active = MIN(255, MAX(0, active));
	if (inactive != -1) inactive = MIN(255, MAX(0, inactive));

	if (active != activealpha)
	{
		activealpha = active;
		if (isActive())
		{
			invalidate();
			if ((oldactivealpha == 0 || activealpha == 0) && (oldactivealpha != 0 || activealpha != 0))
				invalidateWindowRegion();
		}
	}
	if (inactive == -1) inactive = active;
	if (inactive != inactivealpha)
	{
		inactivealpha = inactive;
		if (!isActive())
		{
			invalidate();
			if ((oldactivealpha == 0 || activealpha == 0) && (oldactivealpha != 0 || activealpha != 0))
				invalidateWindowRegion();
		}
	}
}

void BaseWnd::getAlpha(int *active, int *inactive)
{
	if (active) *active = activealpha;
	if (inactive) *inactive = inactivealpha;
}

int BaseWnd::getPaintingAlpha(void)
{
	int a = isActive() ? MIN(255, MAX(0, activealpha)) : MIN(255, MAX(0, inactivealpha));
	ASSERT(a >= 0 && a <= 255);
	if (getParent() && getParent()->isVirtual())
	{
		int b = getParent()->getPaintingAlpha();
		a = (int)((double)a / 255.0 * (double)b);
	}
	if (a == 254) a = 255;
	if (a == 1) a = 0;
	if (!isEnabled()) a = (int)(a*0.6);
	return a;
}

void BaseWnd::setClickThrough(int ct)
{
	clickthrough = ct;
}

int BaseWnd::isClickThrough()
{
	return clickthrough;
}

int BaseWnd::handleRatio()
{
	return 1;
}

#include <api/script/objects/c_script/c_rootobj.h>

int BaseWnd::createTip()
{
	destroyTip();
	tooltip = new Tooltip(getTip());
	return -1;
}

void BaseWnd::destroyTip()
{
	// this is to avoid pb if destroytip() is being called by a time while destroying tip
	Tooltip *tt = tooltip;
	tooltip = NULL;
	delete tt;
}


int BaseWnd::runModal()
{
	//PORTME
#ifdef _WIN32
	ifc_window *dp = getDesktopParent();
	if (dp && dp != this)
		return dp->runModal();

	MSG msg;

	//  SetCapture(NULL);
	SetFocus(getOsWindowHandle());

	WASABI_API_WND->pushModalWnd(this);
	returnvalue = 0;
	mustquit = 0;

	// Main message loop:
	while (!mustquit)
	{
		mustquit = !GetMessage(&msg, NULL, 0, 0);
		if (!msg.hwnd || !TranslateAccelerator(msg.hwnd, NULL, &msg))
		{
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
	}

	WASABI_API_WND->popModalWnd(this);
	//  SetCapture(NULL);
	return returnvalue;
#else
#warning port me
	return 0;
#endif
}

void BaseWnd::endModal(int ret)
{
	ifc_window *dp = getDesktopParent();
	if (dp && dp != this)
	{
		dp->endModal(ret);
		return ;
	}
	returnvalue = ret;
	mustquit = 1;
}

int BaseWnd::wantAutoContextMenu()
{
	return 1;
}

void BaseWnd::onCancelCapture()
{}

ifc_window *BaseWnd::getNextVirtualFocus(ifc_window *w)
{
	if (w == NULL)
	{
		if (childtabs.getNumItems() > 0)
			return childtabs.getFirst()->wnd;
	}

	int a = getTabOrderEntry(w) + 1;

	if (a < childtabs.getNumItems())
		return childtabs.enumItem(a)->wnd;

	return NULL;
}


void BaseWnd::setVirtualChildFocus(ifc_window *w)
{
	ASSERT(w && w->isVirtual());
	if (curVirtualChildFocus)
		curVirtualChildFocus->onKillFocus();
	curVirtualChildFocus = w;
	onSetRootFocus(w);
	Wasabi::Std::Wnd::setFocus(getOsWindowHandle());
	if (curVirtualChildFocus)
	curVirtualChildFocus->onGetFocus();
}

int BaseWnd::ptInRegion(int x, int y)
{
	RECT cr;
	getNonClientRect(&cr);
	POINT pt = {x - cr.left, y - cr.top};
	api_region *reg = getRegion();
	if (isRectRgn())
		return (x >= cr.left && x <= cr.right && y >= cr.top && y <= cr.bottom);
	return reg ? reg->ptInRegion(&pt) : 0;
}

api_region *BaseWnd::getComposedRegion()
{
	ensureWindowRegionValid();
	return composedrgn;
}

api_region *BaseWnd::getSubtractorRegion()
{
	ensureWindowRegionValid();
	return subtractorrgn;
}

int BaseWnd::ensureWindowRegionValid()
{
	if (!isInited()) return 0;
	if (wndregioninvalid)
	{
		computeComposedRegion();
		return 1;
	}
	return 0;
}

void BaseWnd::invalidateWindowRegion()
{
	wndregioninvalid = 1;
	if (getParent()) getParent()->invalidateWindowRegion();
}

void BaseWnd::computeComposedRegion()
{
	if (!isPostOnInit()) return ;

	wndregioninvalid = 0;

	RECT r;
	getNonClientRect(&r);

	api_region *reg = getRegion();
	RegionI *_reg = NULL;

	if (!reg)
	{
		_reg = new RegionI;
		reg = _reg;
		if (isRectRgn())
			reg->setRect(&r);
	}
	else
		if (isRectRgn())
			reg->setRect(&r);

	api_region *wr = reg->clone();

	if (!subtractorrgn) subtractorrgn = new RegionI();
	subtractorrgn->empty();
	if (!composedrgn) composedrgn = new RegionI;
	composedrgn->empty();

	RegionI *subme = NULL;
	RegionI *andme = NULL;
	RegionI *orme = NULL;

	// if subregion is now empty, we need to only use our region
	RECT gr;
	getNonClientRect(&gr);
	for (int i = 0;i < virtualChildren.getNumItems();i++)
	{
		ifc_window *srw = virtualChildren.enumItem(i);
		if (!srw->isVisible(1) || srw->getPaintingAlpha() == 0) continue;
		if (srw->getRegionOp() != REGIONOP_NONE)
		{
			api_region *sr = srw->getComposedRegion();
			if (sr)
			{
				api_region *osr = sr->clone();
				RECT r;
				srw->getNonClientRect(&r);
				r.left -= gr.left;
				r.top -= gr.top;
				osr->offset(r.left, r.top);
				/*        sr->debug();
				        osr->debug();*/
				if (srw->getRegionOp() == REGIONOP_OR)
				{
					if (!orme) orme = new RegionI;
					orme->addRegion(osr);
				}
				else if (srw->getRegionOp() == REGIONOP_AND)
				{
					if (!andme) andme = new RegionI;
					andme->addRegion(osr);
				}
				else if (srw->getRegionOp() == REGIONOP_SUB)
				{
					if (!subme) subme = new RegionI;
					subme->addRegion(osr);
				}
				else if (srw->getRegionOp() == REGIONOP_SUB2)
				{
					if (!subme) subme = new RegionI;
					subtractorrgn->addRegion(osr);
				}
				sr->disposeClone(osr);
			}
		}
		api_region *sr = srw->getSubtractorRegion();
		if (sr != NULL && !sr->isEmpty())
		{
			api_region *osr = sr->clone();
			RECT r;
			srw->getNonClientRect(&r);
			r.left -= gr.left;
			r.top -= gr.top;
			osr->offset(r.left, r.top);
			subtractorrgn->addRegion(osr);
			sr->disposeClone(osr);
		}
	}

	if (andme)
	{
		wr->andRegion(andme);
		delete andme;
	}
	if (orme)
	{
		wr->addRegion(orme);
		delete orme;
	}
	if (subme)
	{
		wr->subtractRgn(subme);
		delete subme;
	}

	composedrgn->addRegion(wr);
	reg->disposeClone(wr);
	delete _reg;
}

void BaseWnd::updateWindowRegion()
{
	if (!isPostOnInit() || isVirtual()) return ;
	if (getDesktopAlpha())
	{
		// if desktopalpha is on, we can't use regions (thanks MS), we have to rely on the framebuffer correctness
		//CUT    SetWindowRgn(getOsWindowHandle(), NULL, FALSE);
		Wasabi::Std::Wnd::setWndRegion(getOsWindowHandle(), NULL);
		return ;
	}
	api_region *_r = getComposedRegion();
	api_region *_s = getSubtractorRegion();
	ASSERT(_r != NULL && _s != NULL);

	api_region *z = _r->clone();
	z->subtractRgn(_s);

	assignWindowRegion(z);
	_r->disposeClone(z);
}

// wr is NOT scaled!!!
void BaseWnd::assignWindowRegion(api_region *wr)
{
	ASSERT(wr != NULL);

	if (!isPostOnInit()) return ;

	int isrect = wr->isRect();

	RECT r;
	BaseWnd::getWindowRect(&r);

	//DebugStringW( L"\nBaseWnd::assignWindowRegion() r  before - x = %d, y = %d, w = %d, h = %d \n", r.left, r.top, r.right - r.left, r.bottom - r.top );

	r.right  -= r.left;
	r.left    = 0;
	r.bottom -= r.top;
	r.top     = 0;

	//DebugStringW( L"BaseWnd::assignWindowRegion() r  after  - x = %d, y = %d, w = %d, h = %d \n", r.left, r.top, r.right - r.left, r.bottom - r.top );

	RECT z;
	wr->getBox(&z);

	//DebugStringW( L"BaseWnd::assignWindowRegion() z  before - x = %d, y = %d, w = %d, h = %d \n", z.left, z.top, z.right - z.left, z.bottom - z.top );

	z.left = 0;
	z.top = 0;

	//DebugStringW( L"BaseWnd::assignWindowRegion() z  after  - x = %d, y = %d, w = %d, h = %d \n", z.left, z.top, z.right - z.left, z.bottom - z.top );

	if (renderRatioActive())
	{
		double i = getRenderRatio();
		wr->scale(i, i, FALSE);
	}

	RECT sz;
	wr->getBox(&sz);

	//DebugStringW( L"BaseWnd::assignWindowRegion() sz before - x = %d, y = %d, w = %d, h = %d \n", sz.left, sz.top, sz.right - sz.left, sz.bottom - sz.top );

	sz.right  -= sz.left;
	sz.bottom -= sz.top;
	sz.left    = 0;
	sz.top     = 0;

	//DebugStringW( L"BaseWnd::assignWindowRegion() sz after  - x = %d, y = %d, w = %d, h = %d \n", sz.left, sz.top, sz.right - sz.left, sz.bottom - sz.top );

	if (isrect &&
	    ((z.right == rwidth && z.bottom == rheight) ||
	     (sz.left == r.left && sz.right == r.right && sz.top == r.top && sz.bottom == r.bottom) ||
	     (0)
	    )
	   )
	{
		//CUT    SetWindowRgn(getOsWindowHandle(), NULL, TRUE);
		if (!lastnullregion)
		{
			Wasabi::Std::Wnd::setWndRegion(getOsWindowHandle(), NULL, TRUE);
			lastnullregion = 1;
		}
	}
	else
	{
		//DebugStringW(L"setting region, rwidth = %d, rheight = %d, z.right = %d, z.bottom = %d\n", rwidth, rheight, z.right, z.bottom);
		//CUT    SetWindowRgn(getOsWindowHandle(), wr->makeWindowRegion(), TRUE);
		Wasabi::Std::Wnd::setWndRegion(getOsWindowHandle(), wr->makeWindowRegion(), TRUE);
		lastnullregion = 0;
	}
}

void BaseWnd::performBatchProcesses()
{
	// recompute the window region if needed and apply it to the HWND
	if (wndregioninvalid && !isVirtual())
		if (ensureWindowRegionValid())
			updateWindowRegion();
	if (need_flush_cascaderepaint)
	{
		_cascadeRepaintRgn(deferedCascadeRepaintRgn);
		deferedCascadeRepaintRgn->empty();
		need_flush_cascaderepaint = 0;
	}
}

int BaseWnd::getRegionOp()
{
	return regionop;
}

void BaseWnd::setRegionOp(int op)
{
	if (regionop != op)
	{
		regionop = op;
		invalidateWindowRegion();
	}
}

int BaseWnd::isRectRgn()
{
	return rectrgn;
}

void BaseWnd::setRectRgn(int i)
{
	rectrgn = i;
}

TimerClient *BaseWnd::timerclient_getMasterClient()
{
	if (!isVirtual()) return this;
	ifc_window *w = getParent();
	if (w)
	{
		TimerClient *tc = w->getTimerClient();
		if (tc)
			return tc->timerclient_getMasterClient();
	}
	return NULL;
}

void BaseWnd::timerclient_onMasterClientMultiplex()
{
	performBatchProcesses();
}

TimerClient *BaseWnd::getTimerClient()
{
	return this;
}

ifc_dependent *BaseWnd::rootwnd_getDependencyPtr()
{
	return this;
}

ifc_dependent *BaseWnd::timerclient_getDependencyPtr()
{
	return this;
}

void BaseWnd::addMinMaxEnforcer(ifc_window *w)
{
	minmaxEnforcers.addItem(w);
	signalMinMaxEnforcerChanged();
}

void BaseWnd::removeMinMaxEnforcer(ifc_window *w)
{
	minmaxEnforcers.removeItem(w);
	signalMinMaxEnforcerChanged();
}

void BaseWnd::signalMinMaxEnforcerChanged(void)
{
	ifc_window *w = getDesktopParent();
	if (w == NULL || w == this) onMinMaxEnforcerChanged();
	else w->signalMinMaxEnforcerChanged();
}

int BaseWnd::getNumMinMaxEnforcers()
{
	return minmaxEnforcers.getNumItems();
}

ifc_window *BaseWnd::enumMinMaxEnforcer(int n)
{
	return minmaxEnforcers.enumItem(n);
}

int BaseWnd::onAction(const wchar_t *action, const wchar_t *param, int x, int y, intptr_t p1, intptr_t p2, void *data, size_t datalen, ifc_window *source)
{
	return 1;
}

int BaseWnd::sendAction(ifc_window *target, const wchar_t *action, const wchar_t *param, int x, int y, intptr_t p1, intptr_t p2, void *data, size_t datalen)
{
	ASSERT(target != NULL);
	return target->onAction(action, param, x, y, p1, p2, data, datalen, this);
}

int BaseWnd::virtualBeforePaint(api_region *r)
{
	if (!virtualCanvas) return 0;
	PaintCallbackInfoI pc(virtualCanvas, r);
	dependent_sendEvent(BaseWnd::depend_getClassGuid(), Event_ONPAINT, PaintCallback::BEFOREPAINT, &pc);
	return 1;
}

int BaseWnd::virtualAfterPaint(api_region *r)
{
	if (!virtualCanvas) return 0;
	PaintCallbackInfoI pc(virtualCanvas, r);
	dependent_sendEvent(BaseWnd::depend_getClassGuid(), Event_ONPAINT, PaintCallback::AFTERPAINT, &pc);
	return 1;
}

int BaseWnd::timerclient_onDeferredCallback(intptr_t p1, intptr_t p2)
{
	TimerClientI::timerclient_onDeferredCallback(p1, p2);
	return onDeferredCallback(p1, p2);
}

void BaseWnd::timerclient_timerCallback(int id)
{
	TimerClientI::timerclient_timerCallback(id);
	timerCallback(id);
}

int BaseWnd::setTimer(int id, int ms)
{
	return timerclient_setTimer(id, ms);
}

int BaseWnd::killTimer(int id)
{
	return timerclient_killTimer(id);
}

void BaseWnd::postDeferredCallback(intptr_t p1, intptr_t p2, int mindelay)
{
#ifdef _WIN32
	// TODO: re-enable, but post to some other window (e.g. some singleton window), not this window
	// because our message pump might be blocked
	// maybe make a hidden window in api_timer for this purpose

	//if (mindelay)
	timerclient_postDeferredCallback(p1, p2, mindelay);
	//else
	//PostMessage(hwnd, WM_DEFER_CALLBACK, p1, p2);
#else
#warning "port me - I can be optimized - don't use timers for this, use mac os x equiv of PostMessage!"
	timerclient_postDeferredCallback(p1, p2, mindelay);
#endif
}

int BaseWnd::bypassModal()
{
	return 0;
}

void BaseWnd::setRenderBaseTexture(int r)
{
	renderbasetexture = r;
	if (isInited()) invalidate();
}

int BaseWnd::getRenderBaseTexture()
{
	return renderbasetexture;
}

GuiObject *BaseWnd::getGuiObject()
{
	if (my_guiobject == NULL)
	{
		my_guiobject = static_cast<GuiObject *>(getInterface(guiObjectGuid));
	}
	return my_guiobject;
}

//CUT someday
int BaseWnd::getFlag(int flag)
{
	/*  switch (flag) {
	  }*/
	return 0;
}

int BaseWnd::triggerEvent(int event, intptr_t p1, intptr_t p2)
{
	//PORTME
	switch (event)
	{
	case TRIGGER_ONRESIZE:
		if (isPostOnInit())
			onResize();
		break;
	case TRIGGER_INVALIDATE:
		if (isPostOnInit())
			invalidate();
		break;
	}
	return 0;
}

void BaseWnd::registerAcceleratorSection(const wchar_t *name, int global)
{
#if defined(WASABI_COMPILE_LOCALES)
	WASABI_API_LOCALE->locales_registerAcceleratorSection(name, this, global);
#endif
}

int BaseWnd::onAcceleratorEvent(const wchar_t *name)
{
	for (int i = 0;i < getNumRootWndChildren();i++)
		if (enumRootWndChildren(i)->onAcceleratorEvent(name))
			return 1;
	return 0;
}

int BaseWnd::allowDeactivation()
{
	return allow_deactivate & ((WASABI_API_WND == NULL) || WASABI_API_WND->appdeactivation_isallowed(this));
}

void BaseWnd::onMinimize()
{
	if (!isVirtual())
	{
		dropVirtualCanvas();
	}
}

void BaseWnd::dropVirtualCanvas()
{
	deferedInvalidate();
	delete virtualCanvas;
	virtualCanvas = NULL;
}

void BaseWnd::onRestore()
{
	if (getDesktopParent() == this)
	{
		cascadeRepaint(TRUE);
	}
}

ifc_window *BaseWnd::findWindow(const wchar_t *id)
{
	RootWndFinder find_object;
	find_object.reset();
	find_object.setFindId(id);
	ifc_window *ret = findWindowChain(&find_object);

#ifdef _DEBUG
	if (ret == NULL)
		DebugStringW(L"findWindow : window not found by id ! %s \n", id);
#endif

	return ret;
}

ifc_window *BaseWnd::findWindowByInterface(GUID interface_guid)
{
	RootWndFinder find_object;
	find_object.reset();
	find_object.setFindGuid(interface_guid);
	ifc_window *ret = findWindowChain(&find_object);

#ifdef _DEBUG
	char str[256] = {0};
	nsGUID::toChar(interface_guid, str);
	if (ret == NULL)
		DebugStringW(L"findWindow : object not found by guid ! %s \n", str);
#endif

	return ret;
}

ifc_window *BaseWnd::findWindowByCallback(FindObjectCallback *cb)
{
	ifc_window *ret = findWindowChain(cb);
#ifdef _DEBUG
	if (ret == NULL)
		DebugStringW(L"findWindow : object not found by callback!\n");
#endif

	return ret;
}

ifc_window *BaseWnd::findWindowChain(FindObjectCallback *cb, ifc_window *wcaller)
{

	if (!cb) return NULL;

	if (cb->findobjectcb_matchObject(this)) return this;

	// first lets not look in subdirectories

	for (int i = 0;i < getNumRootWndChildren();i++)
	{
		ifc_window *child = enumRootWndChildren(i);
		if (!child || child == wcaller) continue;
		if (cb->findobjectcb_matchObject(child))
			return child;
	}

	// ok so it wasn't in our content, lets try to find it as a grandchildren

	for (int i = 0;i < getNumRootWndChildren();i++)
	{
		ifc_window *child = enumRootWndChildren(i);
		if (child->getNumRootWndChildren() > 0)
		{
			ifc_window *ret = child->findWindowChain(cb, this);
			if (ret) return ret;
		}
	}

	// so it wasnt one of our children, we'll hop the tree up one level and ask our parent to find it
	// for us. of course, our parents are smart, they won't ask us back when asking our sibblings
	ifc_window *p = getParent();
	if (p != NULL && wcaller != p)
	{
		return p->findWindowChain(cb, this);
	}

	return NULL;
}


const wchar_t *BaseWnd::timerclient_getName()
{
	tcname = StringPrintfW(L"name=\"%S\", id=\"%s\"", getRootWndName(), getId());
	return tcname;
}

void BaseWnd::setTabOrder(int a)
{
	if (getParent() != NULL)
		getParent()->setVirtualTabOrder(this, a);
}

int BaseWnd::getTabOrder()
{
	if (getParent() != NULL)
		return getParent()->getVirtualTabOrder(this);
	return -1;
}

void BaseWnd::recursive_setVirtualTabOrder(ifc_window *w, float a, float lambda)
{
	ASSERT(w != NULL);
	childtabs.setAutoSort(0);
	int i = getTabOrderEntry(a);
	if (i != -1)
	{
		TabOrderEntry *toe = childtabs.enumItem(i);
		if (toe->wnd != w)
		{
			lambda += TABORDER_K;
			if (lambda != 1.0)
				recursive_setVirtualTabOrder(toe->wnd, a + lambda, lambda);
		}
		else
		{
			return ;
		}
	}
	i = getTabOrderEntry(w);
	if (i != -1)
	{
		delete childtabs.enumItem(i);
		childtabs.removeByPos(i);
	}
	TabOrderEntry *toe = new TabOrderEntry;
	toe->wnd = w;
	toe->order = a;
	childtabs.addItem(toe);
}

void BaseWnd::setVirtualTabOrder(ifc_window *w, int a)
{
	if (a == -1)
	{
		delTabOrderEntry(w);
		return ;
	}
	recursive_setVirtualTabOrder(w, (float)a);
}

int BaseWnd::getVirtualTabOrder(ifc_window *w)
{
	int a = (int)getTabOrderEntry(w);
	if (a == -1) return -1;
	return (int)childtabs.enumItem(a);
}

int BaseWnd::getTabOrderEntry(ifc_window *w)
{
	foreach(childtabs)
	if (childtabs.getfor()->wnd == w)
		return foreach_index;
	endfor;
	return -1;
}

void BaseWnd::delTabOrderEntry(int i)
{
	int a = getTabOrderEntry((float)i);
	if (a == -1) return ;
	childtabs.removeByPos(a);
}

void BaseWnd::delTabOrderEntry(ifc_window *w)
{
	int a = getTabOrderEntry(w);
	if (a == -1) return ;
	delete childtabs.enumItem(a);
	childtabs.removeByPos(a);
}

int BaseWnd::getTabOrderEntry(float order)
{
	foreach(childtabs)
	if (childtabs.getfor()->order == order)
		return foreach_index;
	endfor;
	return -1;
}

void BaseWnd::setAutoTabOrder()
{
	if (!getParent()) return ;
	getParent()->setVirtualAutoTabOrder(this);
}

void BaseWnd::setVirtualAutoTabOrder(ifc_window *w)
{
	delTabOrderEntry(w);
	float o = 0;
	for (int i = 0;i < childtabs.getNumItems();i++)
	{
		o = MAX(o, childtabs.enumItem(i)->order);
	}
	setVirtualTabOrder(w, ((int)o) + 1);
}

void BaseWnd::focusNext()
{
	ifc_window *dp = getDesktopParent();
	if (dp != this)
	{
		if (dp != NULL)
			dp->focusNext();
		return ;
	}
	ifc_window *w = getTab(TAB_GETNEXT);
	if (w != NULL) w->setFocus();
}

void BaseWnd::focusPrevious()
{
	ifc_window *dp = getDesktopParent();
	if (dp != this)
	{
		if (dp != NULL)
			getDesktopParent()->focusPrevious();
		return ;
	}
	ifc_window *w = getTab(TAB_GETPREVIOUS);
	if (w != NULL) w->setFocus();
}

void BaseWnd::recursive_buildTabList(ifc_window *from, PtrList<ifc_window> *list)
{
	for (int i = 0;i < from->getNumTabs();i++)
	{
		ifc_window *r = from->enumTab(i);
		if (r->isVisible() && r->getPaintingAlpha() > 0)
		{
			if (r->wantFocus())
				list->addItem(r);
			recursive_buildTabList(r, list);
		}
	}
}

ifc_window *BaseWnd::getTab(int what)
{
	PtrList<ifc_window> listnow;

	recursive_buildTabList(this, &listnow);

	int p = listnow.searchItem(rootfocus);

	if (p == -1)
		for (int i = 0; i < listnow.getNumItems(); i++)
		{
			ifc_window *r = listnow.enumItem(i);
			if (r->gotFocus())
			{
				//DebugString("desync of rootfocus, fixing\n");
				p = i;
				assignRootFocus(r);
				break;
			}
		}

	if (what == TAB_GETNEXT && rootfocus != NULL)
	{

		p++;
		if (p >= listnow.getNumItems())
			p = 0;
		return listnow.enumItem(p);

	}
	else if (what == TAB_GETPREVIOUS && rootfocus != NULL)
	{

		p--;
		if (p < 0) p = listnow.getNumItems() - 1;
		return listnow.enumItem(p);

	}
	else if (what == TAB_GETCURRENT)
	{

		return rootfocus;

	}
	else if (what == TAB_GETFIRST || (what == TAB_GETNEXT && rootfocus == NULL))
	{

		return listnow.getFirst();

	}
	else if (what == TAB_GETLAST || (what == TAB_GETPREVIOUS && rootfocus == NULL))
	{

		return listnow.getLast();

	}

	return NULL;
}

int BaseWnd::getNumTabs()
{
	return childtabs.getNumItems();
}

ifc_window *BaseWnd::enumTab(int i)
{
	childtabs.sort();
	return childtabs.enumItem(i)->wnd;
}

void BaseWnd::onSetRootFocus(ifc_window *w)
{
	assignRootFocus(w);
	ifc_window *dp = getDesktopParent();
	if (dp && dp != this) dp->onSetRootFocus(w);
}

void BaseWnd::autoFocus(ifc_window *w)
{
	if (w->getFocusOnClick() && w->wantFocus())
	{
		w->setFocus();
		return ;
	}
	ifc_window *g = w;
	while (1)
	{
		ifc_window *p = g->getParent();
		if (p == NULL) break;
		ifc_window *dp = p->getDesktopParent();
		if (dp && dp != p)
		{
			if (p->wantFocus() && p->getFocusOnClick())
			{
				p->setFocus();
				return ;
			}
			g = p;
		}
		else
			break;
	}
}

void BaseWnd::setNoLeftClicks(int no)
{
	noleftclick = no;
}

void BaseWnd::setNoRightClicks(int no)
{
	norightclick = no;
}

void BaseWnd::setNoDoubleClicks(int no)
{
	nodoubleclick = no;
}

void BaseWnd::setNoMouseMoves(int no)
{
	nomousemove = no;
}

void BaseWnd::setNoContextMenus(int no)
{
	nocontextmnu = no;
}

void BaseWnd::setDefaultCursor(Cursor *c)
{
	customdefaultcursor = c;
}


OSCURSORHANDLE BaseWnd::getCustomCursor(int x, int y)
{
#ifdef _WIN32
	return customdefaultcursor ? customdefaultcursor->getOSHandle() : NULL;
#else
#warning port me
	return 0;
#endif
}

Accessible *BaseWnd::createNewAccObj()
{
	waServiceFactory *f = WASABI_API_SVC->service_enumService(WaSvc::ACCESSIBILITY, 0);
	if (f != NULL)
	{
		svc_accessibility *svc = castService<svc_accessibility>(f);
		if (svc != NULL)
		{
			Accessible *a = svc->createAccessibleObject(this);
			WASABI_API_SVC->service_release(svc);
			return a;
		}
	}
	return NULL;
}

Accessible *BaseWnd::getAccessibleObject(int createifnotexist)
{
	if (!createifnotexist) return accessible;
	if (!accessible)
		accessible = createNewAccObj();
	else
		accessible->addRef();
	return accessible;
}

int BaseWnd::accessibility_getState()
{
	int state = 0;
	if (!isVisible()) state |= STATE_SYSTEM_INVISIBLE;
	//if (isVirtual() && !wantFocus()) state |= STATE_SYSTEM_INVISIBLE;
	if (gotFocus()) state |= STATE_SYSTEM_FOCUSED;
	return state;
}

void BaseWnd::activate()
{
	Wasabi::Std::Wnd::setActiveWindow(getRootParent()->getOsWindowHandle());
}

void BaseWnd::setOSWndName(const wchar_t *name)
{
	if (isVirtual()) return ;
//#ifdef COMPILE_WASABI_SKIN // for some reason this isn't being correctly defined
	if (name)
	{
		Wasabi::Std::Wnd::setWndName(getOsWindowHandle(), name);
	}
	else
		Wasabi::Std::Wnd::setWndName(getOsWindowHandle(), L"");

}

const wchar_t *BaseWnd::getOSWndName()
{
	if (isVirtual()) return NULL;
	wchar_t str[4096] = {0};
	Wasabi::Std::Wnd::getWndName(getOsWindowHandle(), str, 4095);
	str[4095] = '\0';
	osname = str;
	return osname;
}

#ifdef EXPERIMENTAL_INDEPENDENT_AOT
void BaseWnd::setAlwaysOnTop(int i)
{
	// this function should not optimize itself
	if (getDesktopParent() == this)
	{
		if (i)
		{
			//CUT      SetWindowPos(getOsWindowHandle(), HWND_TOPMOST, 0,0,0,0, SWP_NOMOVE|SWP_NOSIZE|SWP_NOOWNERZORDER);
			Wasabi::Std::Wnd::setTopmost(getOsWindowHandle(), TRUE);
		}
		else
		{
			saveTopMosts();
			//CUT      SetWindowPos(getOsWindowHandle(), HWND_NOTOPMOST, 0,0,0,0, SWP_NOMOVE|SWP_NOSIZE|SWP_NOOWNERZORDER);
			Wasabi::Std::Wnd::setTopmost(getOsWindowHandle(), FALSE);
			restoreTopMosts();
		}
		alwaysontop = i;
		return ;
	}
	ifc_window *p = getParent();
	if (p != NULL)
		p->setAlwaysOnTop(i);
}

int BaseWnd::getAlwaysOnTop()
{
	if (getDesktopParent() == this)
		return alwaysontop;
	ifc_window *p = getParent();
	if (!p) return 0;
	return p->getAlwaysOnTop();
}
#endif

void BaseWnd::wndwatcher_onDeleteWindow(ifc_window *w)
{
	if (w == rootfocus)
	{
		rootfocus = NULL;
	}
}

void BaseWnd::assignRootFocus(ifc_window *w)
{
	rootfocuswatcher.watchWindow(w);
	rootfocus = w;
}


Canvas *BaseWnd::getFrameBuffer()
{
	return virtualCanvas;
}

void BaseWnd::setForeignWnd(int i)
{
	m_takenOver = i;
}

int BaseWnd::bufferizeLockedUIMsg(int uMsg, int wParam, int lParam)
{
	if (WASABI_API_SKIN && !WASABI_API_SKIN->skin_getLockUI()) return 0;
	if (!uiwaslocked)
	{
		uiwaslocked = 1;
		setTimer(BUFFEREDMSG_TIMER_ID, 20);
	}
	bufferedMsgStruct msg;
	msg.msg = uMsg;
	msg.wparam = wParam;
	msg.lparam = lParam;
	bufferedmsgs.addItem(msg);
	return 1;
}

void BaseWnd::checkLockedUI()
{
	//PORTME :(
#ifdef _WIN32

	if (WASABI_API_SKIN && !WASABI_API_SKIN->skin_getLockUI())
	{
		uiwaslocked = 0;
		killTimer(BUFFEREDMSG_TIMER_ID);
		while (bufferedmsgs.getNumItems() > 0)
		{
			bufferedMsgStruct msg = bufferedmsgs.enumItem(0);
			bufferedmsgs.delByPos(0);
			SendMessageW(gethWnd(), msg.msg, msg.wparam, msg.lparam);
		}
		uiwaslocked = 0;
		killTimer(BUFFEREDMSG_TIMER_ID);
	}
#else
#warning port me
#endif
}

int BaseWnd::isMinimized()
{
	ifc_window *w = getDesktopParent();
	if (w == this || w == NULL) return minimized;
	return w->isMinimized();
}

int BaseWnd::reinit()
{
#ifdef _WIN32
	int nochild = (GetWindowLong(gethWnd(), GWL_STYLE) & WS_POPUP) ? 1 : 0;
	int r = reinit(parentWnd ? parentWnd : WASABI_API_WND->main_getRootWnd(), nochild);

	if (w2k_alpha)
		setLayeredWindow(1);

	return r;
#else
#warning port me!
#endif
}


int BaseWnd::reinit(ifc_window *parWnd, int nochild)
{
	OSWINDOWHANDLE phwnd = parWnd->getOsWindowHandle();
	ASSERT(phwnd != NULL);
	int ret;
	if (!nochild) parentWnd = parWnd;
	else parentWnd = NULL;
	ret = reinit(parWnd->getOsModuleHandle(), phwnd, nochild);
	if (!ret) parentWnd = NULL;	// abort
	return ret;
}

int BaseWnd::reinit(OSMODULEHANDLE moduleHandle, OSWINDOWHANDLE parent, int nochild)
{
	RECT r;
	int w, h;

	onBeforeReinit();

	pushWindowRect();
	preventcancelcapture = 1;

	int _isvisible = isVisible(1);
	int hadcapture = inputCaptured;
	//DebugString("had capture = %d\n", hadcapture);
	Wasabi::Std::Wnd::releaseCapture();

	unparentHWNDChildren();

	BaseWnd::getClientRect(&r);

	hinstance = moduleHandle;

	ASSERT(hinstance != NULL);

	w = (r.right - r.left);
	h = (r.bottom - r.top);

	rwidth = w;
	rheight = h;
	rx = r.left;
	ry = r.top;

	WASABI_API_WND->appdeactivation_push_disallow(this);

	// destroy old window
	Wasabi::Std::Wnd::hideWnd(hwnd); //Wasabi::Std::Wnd::destroyWnd(hwnd);
	ghosthwnd.addItem(hwnd);

	hwnd = Wasabi::Std::Wnd::createWnd(&r, nochild, acceptExternalDrops(), parent, hinstance, static_cast<ifc_window*>(this));
#ifdef __APPLE__
#warning remove me
	Wasabi::Std::Wnd::showWnd(hwnd);
#endif

	WASABI_API_WND->appdeactivation_pop_disallow(this);

	//ASSERT(hwnd != NULL); // lets fail nicely, this could happen for some win32 reason, we don't want to fail the whole app for it, so lets just fail the wnd
	if (hwnd == NULL)
	{
		preventcancelcapture = 0;
		return 0;
	}

	//CUT  nreal++;

#ifdef _WIN32
	//FUCKO
#ifdef URLDROPS
	if (acceptExternalDrops()) RegisterDragDrop(hwnd, &m_target);
#elif !defined(WA3COMPATIBILITY)
	if (!m_target && WASABI_API_WND != NULL)
		m_target = WASABI_API_WND->getDefaultDropTarget();
	if (m_target != NULL)
	{
		RegisterDragDrop(hwnd, (IDropTarget *)m_target);
	}
#endif
#else
#warning port me - register drag & drop
#endif

	this_visible = _isvisible;

	//onInit();
	//this_visible = !start_hidden;

	reparentHWNDChildren();

	popWindowRect();

	invalidateWindowRegion();
	updateWindowRegion();

	if (this_visible)
		Wasabi::Std::Wnd::showWnd(hwnd, FALSE);

	if (hadcapture)
	{
		Wasabi::Std::Wnd::setCapture(hwnd);
	}
	preventcancelcapture = 0;

	forcedOnResize();
	redrawHWNDChildren();
	//onPostOnInit();

	onAfterReinit();

#ifdef WASABI_ON_REPARENT
	WASABI_ON_REINIT(getOsWindowHandle());
#endif

	return 1;
}

ReparentWndEntry::ReparentWndEntry(OSWINDOWHANDLE _wnd, OSWINDOWHANDLE parentwnd)
{
	wnd = _wnd;
	Wasabi::Std::Wnd::getWindowRect(wnd, &rect);
	Wasabi::Std::Wnd::screenToClient(wnd, (int *)&(rect.left), (int *)&(rect.top));
	Wasabi::Std::Wnd::clientToScreen(parentwnd, (int *)&(rect.left), (int *)&(rect.top));
}

void ReparentWndEntry::unparent()
{
	Wasabi::Std::Wnd::setWndPos(wnd, NULL, rect.left, -30000, 0, 0, TRUE, TRUE, FALSE, FALSE, TRUE);
	Wasabi::Std::Wnd::setParent(wnd, NULL);
}

void ReparentWndEntry::reparent(OSWINDOWHANDLE newparent)
{
	Wasabi::Std::Wnd::setParent(wnd, newparent);
	Wasabi::Std::Wnd::setWndPos(wnd, NULL, rect.left, rect.top, 0, 0, TRUE, TRUE, FALSE, FALSE, TRUE);
}

#ifdef _WIN32
void BaseWnd::unparentHWNDChildren()
{
	// just in case
	reparentwnds.deleteAll();

#ifndef WIN32
#error port me ! // make a list of all the children oswindows and reparent them to the desktop somewhere we can't see
#endif

	OSWINDOWHANDLE wnd = GetWindow(getOsWindowHandle(), GW_CHILD);
	while (wnd)
	{
		reparentwnds.addItem(new ReparentWndEntry(wnd, getOsWindowHandle()));
		wnd = GetWindow(wnd, GW_HWNDNEXT);
	}
	foreach(reparentwnds)
	reparentwnds.getfor()->unparent();
	endfor;
}
#endif

void BaseWnd::reparentHWNDChildren()
{
	// reparent to the new oswindowhandle
	foreach(reparentwnds)
	reparentwnds.getfor()->reparent(getOsWindowHandle());
	endfor;
}

void BaseWnd::redrawHWNDChildren()
{
	// reparent to the new oswindowhandle
	foreach(reparentwnds)
	Wasabi::Std::Wnd::update(getOsWindowHandle());
	endfor;
}

void BaseWnd::maximize(int axis)
{
	//DebugString("maximize!\n");
	// if already maximized, don't use current rect, use restore_rect
	if (!maximized)
	{
		restore_rect.left = rx;
		restore_rect.top = ry;
		restore_rect.right = rx + rwidth;
		restore_rect.bottom = ry + rheight;
	}

	RECT nr = restore_rect;
	RECT dr;

	Wasabi::Std::getViewport(&dr, NULL, NULL, getOsWindowHandle(), 0);

	if (axis & MAXIMIZE_WIDTH)
	{
		nr.left = dr.left;
		nr.right = dr.right;
	}
	if (axis & MAXIMIZE_HEIGHT)
	{
		nr.top = dr.top;
		nr.bottom = dr.bottom;
	}
	maximized = 1;
	if (axis != 0) resize(&nr);
	onMaximize();
}

void BaseWnd::restore(int what)
{
	if (maximized)
	{
		//DebugString("restore!\n");
		if (what == (RESTORE_X | RESTORE_Y | RESTORE_WIDTH | RESTORE_HEIGHT))
			resize(&restore_rect);
		else
		{
			resize((what & RESTORE_X) ? restore_rect.left : NOCHANGE,
			       (what & RESTORE_Y) ? restore_rect.top : NOCHANGE,
			       (what & RESTORE_WIDTH) ? restore_rect.right - restore_rect.left : NOCHANGE,
			       (what & RESTORE_HEIGHT) ? restore_rect.bottom - restore_rect.top : NOCHANGE);
		}
		maximized = 0;
		onRestore();
	}
}

void BaseWnd::pushWindowRect()
{
	//DebugString("pushWindowRect\n");
	RECT wr;
	getWindowRect(&wr);
	wr.right = wr.left + rwidth;
	wr.bottom = wr.top + rheight;
	windowrectstack.push(wr);
}

int BaseWnd::popWindowRect(RECT *rc, int applyhow)
{
	//DebugString("popWindowRect\n");
	if (windowrectstack.peek() == 0) return 0;
	RECT _rc;
	windowrectstack.pop(&_rc);
	RECT r;
	getWindowRect(&r);
	divRatio(&r);
	if (applyhow)
	{
		if (applyhow == PWR_POSITION)
		{
			move(_rc.left, _rc.top);
			if (rc)
			{
				int w = r.right - r.left;
				int h = r.bottom - r.top;
				rc->left = _rc.left;
				rc->top = _rc.top;
				rc->right = rc->left + w;
				rc->bottom = rc->top + h;
			}
		}
		else
		{
			if (applyhow & PWR_X) r.left = _rc.left;
			if (applyhow & PWR_Y) r.top = _rc.top;
			if (applyhow & PWR_WIDTH) r.right = r.left + (_rc.right - _rc.left);
			if (applyhow & PWR_HEIGHT) r.bottom = r.top + (_rc.bottom - _rc.top);
			resizeToRect(&r);
			if (rc) *rc = _rc;
		}
	}
	else if (rc) *rc = _rc;
	return 1;
}

void BaseWnd::setRestoredRect(RECT *r)
{
	if (!r)
		return ;

	restore_rect = *r;
	maximized = 1;
}

int BaseWnd::getRestoredRect(RECT *r)
{
	if (!r)
		return 0;

	if (!maximized)
		return 0;

	*r = restore_rect;

	return 1;
}

void BaseWnd::notifyDeferredMove(int x, int y)
{
	rx = x;
	ry = y;
}

void BaseWnd::setWindowTitle(const wchar_t *title)
{
	Layout *l = static_cast<Layout *>(getInterface(layoutGuid));
	if (l) 
	{
		Container *c = l->getParentContainer();
		if (c)
		{
			c->setName(title);
		}
	}
}

#ifdef __APPLE__
OSStatus BaseWnd::eventHandler(EventHandlerCallRef	inHandlerCallRef, EventRef inEvent, void *inUserData)
{
	return eventNotHandledErr;
}
#endif