Initial community commit

1 files changed, 733 insertions, 0 deletions

diff --git a/Src/Wasabi/api/wndmgr/skinembed.cpp b/Src/Wasabi/api/wndmgr/skinembed.cpp
new file mode 100644
index 00000000..079bc688
--- /dev/null
+++ b/Src/Wasabi/api/wndmgr/skinembed.cpp
@@ -0,0 +1,733 @@
+#include <precomp.h>
+#include "skinembed.h"
+#include <api/wndmgr/layout.h>
+#include <api/wnd/wndclass/wndholder.h>
+#include <api/skin/skinparse.h>
+#include <api/wnd/wndtrack.h>
+#include <api/config/items/cfgitemi.h>
+#include <api/config/items/attrint.h>
+#include <bfc/named.h>
+#include <api/wndmgr/autopopup.h>
+#include <api/syscb/callbacks/wndcb.h>
+#include <api/wndmgr/skinwnd.h>
+#include <api/script/scriptmgr.h>
+#include <bfc/critsec.h>
+
+CriticalSection skinembed_cs;
+
+SkinEmbedder *skinEmbedder = NULL;
+
+SkinEmbedder::SkinEmbedder()
+{
+	ASSERTPR(skinEmbedder == NULL, "only one skin embedder please!");
+	skinEmbedder = this;
+}
+
+SkinEmbedder::~SkinEmbedder()
+{
+	inserted.deleteAll();
+	allofthem.deleteAll();
+}
+
+int SkinEmbedder::toggle(GUID g, const wchar_t *prefered_container, int container_flag, RECT *r, int transcient)
+{
+	ifc_window *w = enumItem(g, 0);
+	if (w != NULL)
+	{
+		destroy(w, r);
+		return 0;
+	}
+	ifc_window *wnd = create(g, NULL, prefered_container, container_flag, r, transcient);
+	if (wnd == NULL)
+	{
+#ifdef ON_CREATE_EXTERNAL_WINDOW_GUID
+		int y;
+		ON_CREATE_EXTERNAL_WINDOW_GUID(g, y);
+#endif
+
+	}
+	return 1;
+}
+
+int SkinEmbedder::toggle(const wchar_t *groupid, const wchar_t *prefered_container, int container_flag, RECT *r, int transcient)
+{
+	ifc_window *w = enumItem(groupid, 0);
+	if (w != NULL)
+	{
+		destroy(w, r);
+		return 0;
+	}
+	create(INVALID_GUID, groupid, prefered_container, container_flag, r, transcient);
+	return 1;
+}
+
+ifc_window *SkinEmbedder::create(GUID g, const wchar_t *prefered_container, int container_flag, RECT *r, int transcient, int starthidden, int *isnew)
+{
+	return create(g, NULL, prefered_container, container_flag, r, transcient, starthidden, isnew);
+}
+
+ifc_window *SkinEmbedder::create(const wchar_t *groupid, const wchar_t *prefered_container, int container_flag, RECT *r, int transcient, int starthidden, int *isnew)
+{
+	return create(INVALID_GUID, groupid, prefered_container, container_flag, r, transcient, starthidden, isnew);
+}
+
+WindowHolder *SkinEmbedder::getSuitableWindowHolder(GUID g, const wchar_t *group_id, Container *cont, Layout *lay, int _visible, int _dynamic, int _empty, int _hasself, int _autoavail)
+{
+	foreach(wndholders)
+	WindowHolder *h = wndholders.getfor();
+
+	ifc_window *w = h->getRootWndPtr()->getDesktopParent();
+	int dyn = 1;
+	int visible = 0;
+	int hasself = 0;
+	int empty = 0;
+	int autoavail = h->wndholder_isAutoAvailable();
+
+	Layout *l = (NULL != w) ? static_cast<Layout *>(w->getInterface(layoutGuid)) : NULL;
+	Container *c = NULL;
+
+	if (l)
+	{
+		c = l->getParentContainer();
+		if (c)
+		{
+			dyn = c->isDynamic();
+		}
+	}
+
+	if (NULL == w || !w->isInited()) visible = -1;
+	else
+	{
+		if (_visible == 1)
+		{
+			if (h->getRootWndPtr()->isVisible()) visible = 1;
+		}
+		else if (_visible == 0)
+		{
+			if (w->isVisible()) visible = 1;
+		}
+	}
+	if (!h->getCurRootWnd()) empty = 1;
+
+	if (g != INVALID_GUID)
+	{
+		if (g == h->getCurGuid())
+			hasself = 1;
+	}
+	else if (group_id && h->getCurGroupId())
+	{
+		if (!WCSICMP(group_id, h->getCurGroupId()))
+			hasself = 1;
+	}
+
+	if (_visible != -1)
+	{
+		if (visible != _visible) continue;
+	}
+	if (_dynamic != -1)
+	{
+		if (_dynamic != dyn) continue;
+	}
+	if (_empty != -1)
+	{
+		if (empty != _empty) continue;
+	}
+	if (_hasself != -1)
+	{
+		if (hasself != _hasself) continue;
+	}
+	if (_autoavail != -1)
+	{
+		if (autoavail != _autoavail) continue;
+	}
+
+	if (cont != NULL)
+	{
+		if (c != cont) continue;
+	}
+
+	if (lay != NULL)
+	{
+		if (l != lay) continue;
+	}
+
+	if (g != INVALID_GUID)
+	{
+		if (h->wantGuid(g)) return h;
+	}
+	else if (group_id)
+	{
+		if (h->wantGroup(group_id)) return h;
+	}
+	endfor;
+
+	return NULL;
+}
+
+ifc_window *SkinEmbedder::create(GUID g, const wchar_t *groupid, const wchar_t *prefered_container, int container_flag, RECT *r, int transcient, int starthidden, int *isnew)
+{
+	//  InCriticalSection in_cs(&skinembed_cs);
+
+	foreach(in_deferred_callback)
+	SkinEmbedEntry *e = in_deferred_callback.getfor();
+	if ((e->guid != INVALID_GUID && e->guid == g) || WCSCASEEQLSAFE(groupid, e->groupid))
+	{
+#ifdef _DEBUG
+		DebugStringW(L"trying to show a window that is being destroyed, hm, try again later\n");
+#endif
+		// too soon! try later dude
+		return NULL;
+	}
+	endfor;
+
+	RECT destrect = {0};
+
+	if (isnew) *isnew = 0;
+
+	WindowHolder *wh = NULL;
+	// todo: get from c++ callback
+
+	if (SOM::checkAbortShowHideWindow(g, 1))
+		return NULL;
+
+	if (g != INVALID_GUID)
+		wh = SOM::getSuitableWindowHolderFromScript(g);
+
+	if (!wh) wh = getSuitableWindowHolder(g, groupid, NULL, NULL, 1 /*visible*/, 0 /*static*/, 1 /*empty*/, -1 /*donttest*/, -1 /*donttest*/);
+	if (!wh) wh = getSuitableWindowHolder(g, groupid, NULL, NULL, 0 /*hidden*/, 0 /*static*/, 0 /*notempty*/, 1 /*hasself*/, -1 /*donttest*/);
+	if (!wh) wh = getSuitableWindowHolder(g, groupid, NULL, NULL, 0 /*hidden*/, 0 /*static*/, 1 /*empty*/, -1 /*donttest*/, 1 /*autoavail*/);
+	if (!wh) wh = getSuitableWindowHolder(g, groupid, NULL, NULL, 1 /*visible*/, 1 /*dynamic*/, 1 /*empty*/, -1 /*donttest*/, -1 /*donttest*/);
+	ifc_window *whrw = wh ? wh->getRootWndPtr() : NULL;
+	Container *cont = NULL;
+	Layout *lay = NULL;
+	ifc_window *wnd = NULL;
+	int newcont = 0;
+
+	if (!wh)
+	{ // no hidden static container, so lets create a dynamic one
+		if (isnew) *isnew = 1;
+		if (container_flag == 0 && (prefered_container == NULL || !*prefered_container))
+		{
+			prefered_container = AutoPopup::getDefaultContainerParams(groupid, g, &container_flag);
+		}
+		if (container_flag == 0 && (prefered_container == NULL || !*prefered_container))
+		{
+			prefered_container = WASABI_DEFAULT_STDCONTAINER;
+		}
+		cont = SkinParser::loadContainerForWindowHolder(groupid, g, 0, transcient, prefered_container, container_flag);
+		if (cont)
+		{
+			cont->setTranscient(transcient);
+			newcont = 1;
+			lay = cont->enumLayout(0);
+			/*      if (prefered_layout) { // find its target layout
+			        cont->setDefaultLayout(prefered_layout);
+			        lay = cont->getLayout(prefered_layout);
+			        if (!lay) {
+			          if (!layout_flag) // see if we can fallback
+			            lay = cont->enumLayout(0);
+			          else {
+			            destroyContainer(cont); // deferred
+			            api->console_outputString(9, StringPrintf("could not find the requested layout (%s) to host the window", prefered_container));
+			            return NULL;
+			          }
+			        }*/
+		}
+		else
+		{
+			DebugStringW(L"no container found to hold the window... not even a default one :/\n");
+		}
+		wh = getSuitableWindowHolder(g, groupid, cont, lay, -1 /*donttest*/, -1 /*donttest*/, 0 /*notempty*/, 1 /*hasself*/, -1 /*donttest*/);
+		if (!wh) wh = getSuitableWindowHolder(g, groupid, cont, lay, -1 /*donttest*/, -1 /*donttest*/, 1 /*empty*/, -1 /*donttest*/, -1 /*donttest*/);
+		whrw = wh ? wh->getRootWndPtr() : NULL;
+	}
+
+	if (wh)
+	{
+		GuiObject *o = static_cast<GuiObject *>(whrw->getInterface(guiObjectGuid));
+		ASSERT(o != NULL);
+		if (o)
+		{
+			lay = o->guiobject_getParentLayout();
+			if (lay)
+				cont = lay->getParentContainer();
+		}
+		if ((g != INVALID_GUID && (g == wh->getCurGuid())) || (groupid && (wh->getCurGroupId() == groupid)))
+			wnd = wh->getCurRootWnd();
+		else
+		{
+			if (wh->getCurRootWnd())
+				wh->onRemoveWindow();
+			wnd = wh->onInsertWindow(g, groupid);
+		}
+	}
+
+	if (!wnd)
+	{
+		if (cont)
+		{
+			if (!WCSCASEEQLSAFE(cont->getId(), L"main"))
+				cont->close();
+		}
+		return NULL;
+	}
+
+	//int anim = 1;
+	//if (wh && !whrw->getAnimatedRects()) anim = 0; // FIXME!!
+
+	if (lay && r)
+	{
+		lay->getWindowRect(&destrect);
+	}
+
+	if (cont /*&& cont->isDynamic()*/)
+	{
+		const wchar_t *text = wnd->getRootWndName();
+		cont->setTranscient(transcient);
+		if (text != NULL)
+			if (cont->isDynamic()) cont->setName(text);
+		if (cont->isDynamic() && !transcient) cont->resetLayouts();
+		if (newcont) cont->onInit(1);
+	}
+
+#ifdef WASABI_COMPILE_CONFIG
+	// {280876CF-48C0-40bc-8E86-73CE6BB462E5}
+	const GUID options_guid =
+	    { 0x280876cf, 0x48c0, 0x40bc, { 0x8e, 0x86, 0x73, 0xce, 0x6b, 0xb4, 0x62, 0xe5 } };
+	CfgItem *cfgitem = WASABI_API_CONFIG->config_getCfgItemByGuid(options_guid);
+	int findopenrect = _int_getValue(cfgitem, L"Find open rect");
+#else
+	int findopenrect = WASABI_WNDMGR_FINDOPENRECT;
+#endif
+
+	if (wh && findopenrect)
+	{
+		if (lay)
+		{
+			RECT rl;
+			lay->getWindowRect(&rl);
+			RECT nr = windowTracker->findOpenRect(rl, lay);
+			destrect = nr;	// rewrite destrect
+			int w = rl.right - rl.left;
+			int h = rl.bottom - rl.top;
+			lay->divRatio(&w, &h);
+			nr.right = nr.left + w;
+			nr.bottom = nr.top + h;
+			lay->resizeToRect(&nr);
+		}
+	}
+
+	if (wh)
+	{
+		if (r)
+			/*if (anim)*/ WASABI_API_WNDMGR->drawAnimatedRects(r, &destrect);
+			/*else
+			{
+				RECT r;
+				r.left = destrect.left + (destrect.right - destrect.left) / 2 - 1;
+				r.top = destrect.top + (destrect.bottom - destrect.top) / 2 + 1;
+				r.right = r.left + 2;
+				r.bottom = r.top + 2;
+				if (anim) WASABI_API_WNDMGR->drawAnimatedRects(&r, &destrect);
+			}*/
+	}
+
+	if (!starthidden)
+	{
+		if (cont && cont->isVisible())
+		{ // we were already shown, duh
+			//      cont->setVisible(0);
+		}
+		else
+		{
+			if (cont) cont->setVisible(1);
+			else if (lay) lay->setVisible(1);
+		}
+	}
+
+	if (wnd && newcont && !transcient)
+	{
+		inserted.addItem(new SkinEmbedEntry(wnd->getDependencyPtr(), wnd, g, groupid, prefered_container, container_flag, cont, wh));
+		viewer_addViewItem(wnd->getDependencyPtr());
+	}
+
+	if (!transcient && wnd)
+		allofthem.addItem(new SkinEmbedEntry(wnd->getDependencyPtr(), wnd, g, groupid, prefered_container, container_flag, cont, wh));
+
+	return wnd;
+}
+
+void SkinEmbedder::destroy(ifc_window *w, RECT *r)
+{
+	int donecheck = 0;
+	SkinEmbedEntry *e = NULL;
+	for (int i = 0; i < allofthem.getNumItems();i++)
+	{
+		e = allofthem.enumItem(i);
+		if (e->wnd == w)
+		{
+			donecheck = 1;
+			if (SOM::checkAbortShowHideWindow(e->guid, 0))
+				return ;
+			break;
+		}
+	}
+	if (WASABI_API_WND->rootwndIsValid(w))
+	{
+		if (!donecheck)
+		{
+			ifc_window *ww = w->findWindowByInterface(windowHolderGuid);
+			if (ww)
+			{
+				WindowHolder *wh = static_cast<WindowHolder*>(ww->getInterface(windowHolderGuid));
+				if (wh)
+				{
+					GUID g = wh->getCurGuid();
+					if (g != INVALID_GUID)
+					{
+						donecheck = 1;
+						if (SOM::checkAbortShowHideWindow(g, 0))
+							return ;
+					}
+				}
+			}
+		}
+	}
+	// checkAbort can render w invalid !!! check again
+	if (WASABI_API_WND->rootwndIsValid(w))
+	{
+		ifc_window *wnd = w->getDesktopParent();
+		GuiObject *go = static_cast<GuiObject *>(wnd->getInterface(guiObjectGuid));
+		if (go)
+		{
+			Layout *l = go->guiobject_getParentLayout();
+			if (l)
+			{
+				Container *c = l->getParentContainer();
+				if (c)
+				{
+					if (!WCSCASEEQLSAFE(c->getId(), L"main"))
+					{
+						c->close(); // deferred if needed
+					}
+					else
+					{
+					softclose:
+						ifc_window *wnd = w->findWindowByInterface(windowHolderGuid);
+						if (wnd != NULL)
+						{
+							WindowHolder *wh = static_cast<WindowHolder *>(wnd->getInterface(windowHolderGuid));
+							if (wh != NULL)
+							{
+								wh->onRemoveWindow(1);
+							}
+						}
+					}
+				}
+				else goto softclose;
+			}
+		}
+	}
+}
+
+int SkinEmbedder::getNumItems(GUID g)
+{
+	int n = 0;
+	for (int i = 0;i < wndholders.getNumItems();i++)
+		if (wndholders.enumItem(i)->getRootWndPtr()->isVisible() && wndholders.enumItem(i)->getCurGuid() == g) n++;
+	return n;
+}
+
+int SkinEmbedder::getNumItems(const wchar_t *groupid)
+{
+	int n = 0;
+	for (int i = 0;i < wndholders.getNumItems();i++)
+	{
+		WindowHolder *wh = wndholders.enumItem(i);
+		if (wh->getRootWndPtr()->isVisible()
+		        && WCSCASEEQLSAFE(wh->getCurGroupId(), groupid))
+			n++;
+	}
+	return n;
+}
+
+ifc_window *SkinEmbedder::enumItem(GUID g, int n)
+{
+	ASSERT(n >= 0);
+	for (int i = 0;i < wndholders.getNumItems();i++)
+	{
+		WindowHolder *wh = wndholders.enumItem(i);
+		if (wh->getCurGuid() == g)
+		{
+			ifc_window *w = wh->getRootWndPtr();
+			Container *c = NULL;
+			if (w)
+			{
+				w = w->getDesktopParent();
+				if (w)
+				{
+					Layout *l = static_cast<Layout *>(w->getInterface(layoutGuid));
+					if (l)
+					{
+						c = l->getParentContainer();
+					}
+				}
+			}
+			if (c && c->isVisible() || (!c && wndholders.enumItem(i)->getRootWndPtr()->isVisible()))
+			{
+				if (n == 0)
+					return wndholders.enumItem(i)->getCurRootWnd();
+				n--;
+			}
+		}
+	}
+	return NULL;
+}
+
+ifc_window *SkinEmbedder::enumItem(const wchar_t *groupid, int n)
+{
+	ASSERT(n >= 0);
+	for (int i = 0;i < wndholders.getNumItems();i++)
+	{
+		WindowHolder *wh = wndholders.enumItem(i);
+		const wchar_t *curgroupid = wndholders[i]->getCurGroupId();
+		if (WCSCASEEQLSAFE(curgroupid, groupid))
+		{
+			ifc_window *w = wh->getRootWndPtr();
+			Container *c = NULL;
+			if (w)
+			{
+				w = w->getDesktopParent();
+				if (w)
+				{
+					Layout *l = static_cast<Layout *>(w->getInterface(layoutGuid));
+					if (l)
+					{
+						c = l->getParentContainer();
+					}
+				}
+			}
+			if (c && c->isVisible() || (!c && wndholders.enumItem(i)->getRootWndPtr()->isVisible()))
+			{
+				if (n == 0)
+					return wndholders.enumItem(i)->getCurRootWnd();
+				n--;
+			}
+		}
+	}
+	return NULL;
+}
+
+void SkinEmbedder::registerWindowHolder(WindowHolder *wh)
+{
+	if (wndholders.haveItem(wh)) return ;
+	wndholders.addItem(wh);
+}
+
+void SkinEmbedder::unregisterWindowHolder(WindowHolder *wh)
+{
+	if (!wndholders.haveItem(wh)) return ;
+	wndholders.removeItem(wh);
+}
+
+int SkinEmbedder::viewer_onItemDeleted(api_dependent *item)
+{
+	foreach(in_deferred_callback)
+	if (in_deferred_callback.getfor()->dep == item)
+		in_deferred_callback.removeByPos(foreach_index);
+	endfor
+	foreach(inserted)
+	SkinEmbedEntry *e = inserted.getfor();
+	if (e->dep == item)
+	{
+		inserted.removeItem(e);
+		allofthem.removeItem(e);
+		delete e;
+		break;
+	}
+	endfor;
+	foreach(allofthem)
+	SkinEmbedEntry *e = allofthem.getfor();
+	if (e->dep == item)
+	{
+		allofthem.removeItem(e);
+		delete e;
+		break;
+	}
+	endfor;
+	return 1;
+}
+
+void SkinEmbedder::cancelDestroyContainer(Container *c)
+{
+	if (!cancel_deferred_destroy.haveItem(c)) cancel_deferred_destroy.addItem(c);
+}
+
+void SkinEmbedder::destroyContainer(Container *o)
+{
+	ASSERT(o);
+	//fg>disabled as of 11/4/2003, side effect of cancelling fullscreen video (ie, notifier while playing video fullscreen)
+	//delt with the problem in basewnd directly
+	//#ifdef WIN32
+	//SetFocus(NULL); // FG> this avoids Win32 calling directly WM_KILLFOCUS into a child's wndproc (couldn't they just have posted the damn msg ?), who would then call some of his parent's virtual functions while it is being deleted
+	// perhaps it would be good to add a generic way to disable most child wnd messages while the parent is being deleted
+	//#endif
+
+	cancel_deferred_destroy.removeItem(o);
+
+	foreach(inserted)
+	SkinEmbedEntry *e = inserted.getfor();
+	if (e->container == o)
+	{
+		if (!in_deferred_callback.haveItem(e))
+		in_deferred_callback.addItem(e);
+		
+		break;
+	}
+	endfor
+	deferred_destroy.addItem(o);
+	timerclient_setTimer(CB_DESTROYCONTAINER, 20);
+	//o->setVisible(0);
+	//timerclient_postDeferredCallback(CB_DESTROYCONTAINER, (intptr_t)o);
+}
+
+void SkinEmbedder::timerclient_timerCallback(int id)
+{
+	if (id == CB_DESTROYCONTAINER)
+	{
+		foreach(deferred_destroy)
+		Container *c = deferred_destroy.getfor();
+		foreach(in_deferred_callback)
+		if (in_deferred_callback.getfor()->container == c)
+		{
+			in_deferred_callback.removeByPos(foreach_index);
+		}
+		endfor;
+		if (cancel_deferred_destroy.haveItem(c))
+		{
+			continue;
+		}
+		if (SkinParser::isContainer(c)) // otherwise i'ts already gone while we were waiting for the callback, duh!
+			delete c;
+		endfor
+		cancel_deferred_destroy.removeAll();
+		deferred_destroy.removeAll();
+		timerclient_killTimer(CB_DESTROYCONTAINER);
+		return ;
+	}
+	TimerClientDI::timerclient_timerCallback(id);
+}
+
+int SkinEmbedder::timerclient_onDeferredCallback(intptr_t p1, intptr_t p2)
+{
+	return TimerClientDI::timerclient_onDeferredCallback(p1, p2);
+}
+
+#ifdef WASABI_COMPILE_CONFIG
+void SkinEmbedder::saveState()
+{
+	int i = 0;
+	wchar_t t[1024] = {0};
+	foreach(inserted)
+	SkinEmbedEntry *e = inserted.getfor();
+	if (e->guid != INVALID_GUID)
+	{
+		nsGUID::toCharW(e->guid, t);
+	}
+	else
+	{
+		WCSCPYN(t, e->groupid, 1024);
+	}
+	WASABI_API_CONFIG->setStringPrivate(StringPrintfW(L"wndstatus/id/%d", i), t);
+	WASABI_API_CONFIG->setStringPrivate(StringPrintfW(L"wndstatus/layout/%d", i), !e->layout.isempty() ? e->layout.getValue() : L"");
+	WASABI_API_CONFIG->setIntPrivate(StringPrintfW(L"wndstatus/flag/%d", i), e->required);
+	i++;
+	endfor;
+	WASABI_API_CONFIG->setStringPrivate(StringPrintfW(L"wndstatus/id/%d", i), L"");
+	WASABI_API_CONFIG->setStringPrivate(StringPrintfW(L"wndstatus/layout/%d", i), L"");
+	WASABI_API_CONFIG->setIntPrivate(StringPrintfW(L"wndstatus/flag/%d", i), 0);
+}
+
+void SkinEmbedder::restoreSavedState()
+{
+	int i = 0;
+	wchar_t t[1024] = {0};
+	wchar_t l[256] = {0};
+	while (1)
+	{
+		WASABI_API_CONFIG->getStringPrivate(StringPrintfW(L"wndstatus/id/%d", i), t, 1024, L"");
+		if (!*t) break;
+		WASABI_API_CONFIG->getStringPrivate(StringPrintfW(L"wndstatus/layout/%d", i), l, 256, L"");
+		int flag = WASABI_API_CONFIG->getIntPrivate(StringPrintfW(L"wndstatus/flag/%d", i), 0);
+		GUID g = nsGUID::fromCharW(t);
+		//ifc_window *created = NULL;
+		//int tried = 0;
+		if (g != INVALID_GUID)
+		{
+			ifc_window *w = enumItem(g, 0);
+			if (w == NULL)
+			{
+				//tried = 1;
+				/*created = */create(g, l, flag);
+			}
+		}
+		else
+		{
+			ifc_window *w = enumItem(t, 0);
+			if (w == NULL)
+			{
+				//tried = 1;
+				/*created = */create(t, l, flag);
+			}
+		}
+		/*    if (tried && !created) {
+		      for (int j=0;j<inserted.getNumItems();j++) {
+		        SkinEmbedEntry *e = inserted.enumItem(j);
+		        int yes = 0;
+		        if (g != INVALID_GUID) {
+		          if (e->guid == g && e->required == flag && STRCASEEQLSAFE(e->layout, l))
+		            yes = 1;
+		        } else {
+		          if (STRCASEEQLSAFE(e->groupid, t) && e->required == flag && STRCASEEQLSAFE(e->layout, l))
+		            yes = 1;
+		        }
+		        if (yes) {
+		          inserted.removeByPos(j);
+		          j--;
+		          delete e;
+		        }
+		      }
+		    }*/
+		i++;
+	}
+}
+#endif
+
+void SkinEmbedder::attachToSkin(ifc_window *w, int side, int size)
+{
+	RECT r;
+	if (w == NULL) return ;
+	ifc_window *_w = w->getDesktopParent();
+	if (_w == NULL) _w = w;
+	SkinParser::getSkinRect(&r, _w);
+
+	switch (side)
+	{
+	case SKINWND_ATTACH_RIGHT:
+		_w->resize(r.right, r.top, size, r.bottom - r.top);
+		break;
+	case SKINWND_ATTACH_TOP:
+		_w->resize(r.left, r.top - size, r.right - r.left, size);
+		break;
+	case SKINWND_ATTACH_LEFT:
+		_w->resize(r.left - size, r.top, size, r.bottom - r.top);
+		break;
+	case SKINWND_ATTACH_BOTTOM:
+		_w->resize(r.left, r.bottom, r.right - r.left, size);
+		break;
+	}
+}
+
+PtrList<SkinEmbedEntry> SkinEmbedder::in_deferred_callback;
+PtrList<Container> SkinEmbedder::cancel_deferred_destroy;
+PtrList<Container> SkinEmbedder::deferred_destroy;