Initial community commit

Src/Wasabi/api/skin/widgets/mb/iebrowser.cpp

@@ -0,0 +1,637 @@
+#include <precomp.h>
+#include "iebrowser.h"
+#include "mbsvc.h"
+#include "main.h"
+#include "../nu/ns_wc.h"
+#include "../Winamp/buildtype.h"
+#include <api/config/items/cfgitem.h>
+#include <wa2frontend.h>
+#include <windows.h>
+#include <Mshtml.h>
+#include "minibrowserCOM.h"
+
+class BrowserMsgProc: public ifc_messageprocessor
+{
+public: 	
+	BrowserMsgProc(BrowserWnd *pBrowser) : pTarget(pBrowser) {} 
+	~BrowserMsgProc(void)  {} 
+
+public:
+	bool ProcessMessage(MSG *pMsg)
+	{
+		if (WM_KEYFIRST <= pMsg->message && WM_KEYLAST >= pMsg->message)
+		{
+			HWND hwndHost;
+			hwndHost = pTarget->gethWnd();
+			if ((hwndHost == pMsg->hwnd || IsChild(hwndHost, pMsg->hwnd)) && IsWindowVisible(pMsg->hwnd))
+			{
+				if (!(GetAsyncKeyState(VK_CONTROL)&0x8000) && !(GetAsyncKeyState(VK_MENU)&0x8000))
+				{
+					if (pTarget->TranslateKey(pMsg)) return true;
+				}
+				switch(pMsg->message)
+				{
+					case WM_KEYDOWN:
+					case WM_SYSKEYDOWN:
+					case WM_KEYUP:
+					case WM_SYSKEYUP:
+						switch(pMsg->wParam)
+						{
+							case VK_F1:
+								if (!(GetAsyncKeyState(VK_SHIFT)&0x8000)) pMsg->hwnd = plugin.hwndParent;
+								break;
+
+							case VK_F4:
+								if ((pMsg->message == WM_KEYDOWN || pMsg->message == WM_SYSKEYDOWN) && (GetAsyncKeyState(VK_MENU)&0x8000))
+										SendMessageW(plugin.hwndParent, WM_CLOSE, 0, 0);
+								pMsg->message = WM_NULL;
+								break;
+							case 'P':
+							case 'K':
+							case 'H':
+							case VK_TAB:
+								if ((GetAsyncKeyState(VK_CONTROL)&0x8000) && !(GetAsyncKeyState(VK_MENU)&0x8000)) pMsg->hwnd = plugin.hwndParent;
+								break;
+							case '3':
+							case VK_UP:
+							case VK_DOWN:
+								break;
+							default:
+								if ((GetAsyncKeyState(VK_MENU)&0x8000) && !(GetAsyncKeyState(VK_CONTROL)&0x8000)) pMsg->hwnd = plugin.hwndParent;
+								break;
+						}
+						break;
+				}
+				
+			}
+
+		}
+		return /*(IsDialogMessageW(pTarget->gethWnd(), pMsg)) ? true :*/ false;
+	}
+
+protected:
+	BrowserWnd *pTarget;
+	RECVS_DISPATCH;
+
+};
+
+extern HINSTANCE hInstance;
+STDAPI WriteBSTR(BSTR *pstrDest, LPCWSTR szSrc)
+{
+	*pstrDest = SysAllocString( szSrc );
+	if ( !(*pstrDest) ) return E_OUTOFMEMORY;
+	return NOERROR;
+}
+
+STDAPI FreeBSTR(BSTR* pstr)
+{
+	if ( *pstr == NULL ) return S_FALSE;
+	SysFreeString( *pstr );
+	return NOERROR;
+}
+
+HRESULT writeBString(BSTR* psz, const char *str)
+{
+	WCHAR WideStr[WA_MAX_PATH] = {0};
+	String s = str;
+	if (s.isempty()) s = "";
+	MultiByteToWideCharSZ(CP_ACP, 0, s, -1, WideStr, WA_MAX_PATH);
+	return WriteBSTR(psz, WideStr);
+}
+
+BrowserWnd::BrowserWnd() : HTMLContainer2(NULL, NULL), processor(NULL)
+{
+	setVirtual(0);
+
+	oleOk = FALSE;
+	homepage = L"about:blank";
+	timerset1 = 0;
+	timerset2 = 0;
+	cancelIEErrorPage = false;
+	scrollbarsflag = BROWSER_SCROLLBARS_DEFAULT;
+}
+
+BrowserWnd::~BrowserWnd()
+{
+	if (processor)
+	{
+		if (WASABI_API_APP) WASABI_API_APP->app_removeMessageProcessor(processor);
+		free(processor);
+		processor = NULL;
+	}
+	if (timerset1)
+	{
+		killTimer(MB_TIMERID1);
+		timerset1 = 0;
+	}
+	if (timerset2)
+	{
+		killTimer(MB_TIMERID2);
+		timerset2 = 0;
+	}
+
+	freeBrowserStuff();
+}
+
+bool BrowserWnd::InitializeLibrary()
+{
+	return (FALSE != HTMLContainer2_Initialize());
+}
+
+void BrowserWnd::UninitializeLibrary()
+{
+	HTMLContainer2_Uninitialize();
+}
+
+int BrowserWnd::onInit()
+{
+	BROWSER_PARENT::onInit();
+	if (isVisible())
+		onSetVisible(1);
+	updateScrollbars();
+	return 1;
+}
+
+void BrowserWnd::onSetVisible(int show)
+{
+	if (show) initBrowserStuff();
+}
+
+int BrowserWnd::initBrowserStuff()
+{
+	if (pUnk) return 1;
+	
+	if (SUCCEEDED(OleInitialize(NULL))) oleOk = TRUE;
+	if (!oleOk) return 1;
+
+	// {280876CF-48C0-40bc-8E86-73CE6BB462E5}
+	const GUID options_guid =
+	    { 0x280876cf, 0x48c0, 0x40bc, { 0x8e, 0x86, 0x73, 0xce, 0x6b, 0xb4, 0x62, 0xe5 } };
+	hParent = gethWnd();
+
+	int usemozilla = 0;
+
+#ifdef WASABI_COMPILE_CONFIG
+	usemozilla = _intVal(WASABI_API_CONFIG->config_getCfgItemByGuid(options_guid), L"Use Mozilla instead of IE for minibrowser");
+#endif
+
+	if (SUCCEEDED(Initialize()))
+	{
+		HRESULT hr;
+		IWebBrowser2 *pWeb2;
+		
+		hr = GetIWebBrowser2(&pWeb2);
+		if (SUCCEEDED(hr))
+		{
+			pWeb2->put_RegisterAsBrowser(VARIANT_TRUE);
+			
+			if (deferednavigate.isempty())
+			{
+				if (!homepage.isempty())
+					minibrowser_navigateUrl(homepage);
+				else
+					minibrowser_navigateUrl(L"about:blank");
+			}
+			else minibrowser_navigateUrl(deferednavigate);
+		}
+	}
+	if (!processor && WASABI_API_APP)
+	{
+		processor = new BrowserMsgProc(this);
+		WASABI_API_APP->app_addMessageProcessor(processor);
+		
+	}
+
+	ShowWindow(hParent, SW_SHOWNA);
+	
+	return 1;
+}
+
+void BrowserWnd::freeBrowserStuff()
+{
+	if (oleOk)
+	{
+		Finish();
+		OleUninitialize();
+		oleOk = FALSE;
+#ifndef WASABINOMAINAPI
+		api->hint_garbageCollect();
+#endif
+
+	}
+}
+
+int BrowserWnd::minibrowser_navigateUrl(const wchar_t *url)
+{
+	HRESULT hr;
+	
+	curpage = url;
+
+	hr = NavigateToName(url, 0);
+	if (FAILED(hr))
+	{
+		deferednavigate = url;
+		return 0;
+	}
+	return 1;
+}
+
+int BrowserWnd::minibrowser_back()
+{
+	HRESULT hr;
+	IWebBrowser2 *pWeb2;
+	hr = GetIWebBrowser2(&pWeb2);
+	if (SUCCEEDED(hr))
+	{
+		pWeb2->GoBack();
+		pWeb2->Release();
+	}
+	return 1;
+}
+
+int BrowserWnd::minibrowser_forward()
+{
+	HRESULT hr;
+	IWebBrowser2 *pWeb2;
+	hr = GetIWebBrowser2(&pWeb2);
+	if (SUCCEEDED(hr))
+	{
+		pWeb2->GoForward();
+		pWeb2->Release();
+	}
+	return 1;
+}
+
+int BrowserWnd::minibrowser_refresh()
+{
+	HRESULT hr;
+	IWebBrowser2 *pWeb2;
+	hr = GetIWebBrowser2(&pWeb2);
+	if (SUCCEEDED(hr))
+	{
+		pWeb2->Refresh();
+		pWeb2->Release();
+	}
+	return 1;
+}
+
+int BrowserWnd::minibrowser_home()
+{
+	minibrowser_navigateUrl(homepage);
+	return 1;
+}
+
+int BrowserWnd::minibrowser_stop()
+{
+	HRESULT hr;
+	IWebBrowser2 *pWeb2;
+	hr = GetIWebBrowser2(&pWeb2);
+	if (SUCCEEDED(hr))
+	{
+		pWeb2->Stop();
+		pWeb2->Release();
+	}
+	return 1;
+}
+
+HWND BrowserWnd::getOSHandle()
+{
+	return ::GetWindow(gethWnd(), GW_CHILD); // assumes setVirtual(0) in constructor
+}
+
+void BrowserWnd::onTargetNameTimer()
+{
+	updateTargetName();
+}
+
+void BrowserWnd::onScrollbarsFlagTimer()
+{
+	updateScrollbars();
+}
+
+void BrowserWnd::timerCallback(int id)
+{
+	switch (id)
+	{
+	case MB_TIMERID1:
+		onTargetNameTimer();
+		return ;
+	case MB_TIMERID2:
+		onScrollbarsFlagTimer();
+		return ;
+	}
+	BROWSER_PARENT::timerCallback(id);
+}
+
+void BrowserWnd::minibrowser_setTargetName(const wchar_t *name)
+{
+	targetname = name;
+	updateTargetName();
+}
+
+void BrowserWnd::updateTargetName()
+{
+	if (!doSetTargetName(targetname))
+	{
+		if (!timerset1) { setTimer(MB_TIMERID1, 100); timerset1 = 1; }
+		return ;
+	}
+	else
+	{
+		if (timerset1) { killTimer(MB_TIMERID1); timerset1 = 0; }
+	}
+}
+
+int BrowserWnd::doSetTargetName(const wchar_t *name)
+{
+	HRESULT hr;
+	IWebBrowser2 *pWeb2;
+	IDispatch *id;
+
+	hr = GetIWebBrowser2(&pWeb2);
+
+	if (FAILED(hr)) return FALSE;
+
+	if (SUCCEEDED(pWeb2->get_Document(&id)) && id)
+	{
+		IHTMLDocument2 *doc;
+		if (SUCCEEDED(id->QueryInterface(IID_IHTMLDocument2, (void **)&doc)) && doc)
+		{
+			IHTMLWindow2 *w;
+			if (SUCCEEDED(doc->get_parentWindow(&w)) && w)
+			{
+				w->put_name(SysAllocString(targetname.getValue()));
+				w->Release();
+				doc->Release();
+				id->Release();
+				pWeb2->Release();
+				return 1;
+			}
+			doc->Release();
+		}
+		id->Release();
+	}
+	pWeb2->Release();
+	return 0;
+}
+
+const wchar_t *BrowserWnd::minibrowser_getTargetName()
+{
+	return targetname;
+}
+
+void BrowserWnd::OnBeforeNavigate(IDispatch *pDispatch, VARIANT *URL, VARIANT *Flags, VARIANT *TargetFrameName, VARIANT *PostData, VARIANT *Headers, VARIANT_BOOL *Cancel)
+{
+	int i = 0;
+	foreach(callbacks)
+	int r = callbacks.getfor()->minibrowsercb_onBeforeNavigate(URL->bstrVal, Flags->intVal, TargetFrameName->bstrVal);
+	if (i++ == 0) *Cancel = (r) ? VARIANT_TRUE : VARIANT_FALSE;
+	endfor;
+	updateScrollbars();
+
+}
+
+void BrowserWnd::minibrowser_setScrollbarsFlag(int a)
+{
+	scrollbarsflag = a;
+	updateScrollbars();
+}
+
+void BrowserWnd::updateScrollbars()
+{
+	if (!doSetScrollbars())
+	{
+		if (!timerset2) { setTimer(MB_TIMERID2, 100); timerset2 = 1; }
+		return ;
+	}
+	else
+	{
+		if (timerset2) { killTimer(MB_TIMERID2); timerset2 = 0; }
+	}
+}
+
+void BrowserWnd::OnDocumentComplete(IDispatch *pDispatch, VARIANT *URL)
+{
+	if (!targetname.isempty())
+		minibrowser_setTargetName(targetname);
+	foreach(callbacks)
+	callbacks.getfor()->minibrowsercb_onDocumentComplete(URL->bstrVal);
+	endfor;
+	updateScrollbars();
+}
+
+void BrowserWnd::OnDocumentReady(IDispatch *pDispatch, VARIANT *URL)
+{
+	if (!targetname.isempty())
+		minibrowser_setTargetName(targetname);
+	foreach(callbacks)
+	callbacks.getfor()->minibrowsercb_onDocumentReady(URL->bstrVal);
+	endfor;
+	updateScrollbars();
+}
+
+void BrowserWnd::OnNavigateError(IDispatch *pDispatch, VARIANT *URL, VARIANT *TargetFrameName, VARIANT *StatusCode, VARIANT_BOOL *Cancel)
+{
+	if (TargetFrameName->bstrVal != NULL)
+		return; //TODO: send targetframe via api to script
+	foreach(callbacks)
+	callbacks.getfor()->minibrowsercb_onNavigateError(URL->bstrVal, StatusCode->intVal);
+	endfor;
+	if (cancelIEErrorPage) *Cancel = -1;
+}
+
+const wchar_t* BrowserWnd::messageToMaki(wchar_t* str1, wchar_t* str2, int i1, int i2, int i3)
+{
+	const wchar_t* ret = 0;
+	foreach(callbacks)
+		ret = callbacks.getfor()->minibrowsercb_messageToMaki(str1, str2, i1, i2, i3);
+		if (ret) break;
+	endfor;
+	return ret;
+}
+
+const wchar_t* BrowserWnd::minibrowser_messageToJS(const wchar_t* str1, const wchar_t* str2, int i1, int i2, int i3)
+{
+	// TODO feed JS w/ this info
+	return 0;
+}
+
+void BrowserWnd::minibrowser_scrape()
+{
+	IWebBrowser2 *browser=0;
+	GetIWebBrowser2(&browser);
+	IDispatch *docDisp=0;
+	IHTMLDocument2 *document = 0;
+	if (browser)
+	{
+		browser->get_Document(&docDisp);
+		if (docDisp)
+		{
+			docDisp->QueryInterface(&document);
+			docDisp->Release();
+		}
+		browser->Release();
+	}
+
+	if (document)
+	{
+		IHTMLElementCollection *links=0;
+		document->get_all(&links);
+		
+		if (links)
+		{
+			IDispatch *anchorDisp=0;
+			VARIANT index;
+
+			VariantInit(&index);
+			index.vt = VT_I4;
+			index.intVal = 0;
+
+			links->item(index, index, &anchorDisp);
+			while (anchorDisp)
+			{
+				IHTMLAnchorElement *anchor=0;
+				anchorDisp->QueryInterface(&anchor);
+				if (anchor)
+				{
+					BSTR href=0;
+					anchor->get_href(&href);
+					if (href && (wa2.CanPlay(href) || wa2.IsPlaylist(href)))
+					{
+						foreach(callbacks)
+						callbacks.getfor()->minibrowsercb_onMediaLink(href);
+						endfor;
+					}
+					SysFreeString(href);
+					anchor->Release();
+				}
+
+				index.intVal++;
+				anchorDisp->Release();
+				links->item(index, index, &anchorDisp);
+			}
+
+			links->Release();
+		}
+		document->Release();
+	}
+
+}
+
+void BrowserWnd::minibrowser_getDocumentTitle(wchar_t *str, size_t len)
+{
+	IWebBrowser2 *browser=0;
+	GetIWebBrowser2(&browser);
+	IDispatch *docDisp=0;
+	IHTMLDocument2 *document = 0;
+	if (browser)
+	{
+		browser->get_Document(&docDisp);
+		if (docDisp)
+		{
+			docDisp->QueryInterface(&document);
+			docDisp->Release();
+		}
+		browser->Release();
+	}
+
+	if (document)
+	{
+		BSTR title_bstr;
+		document->get_title(&title_bstr);
+		document->Release();
+
+		WCSCPYN(str, title_bstr, len);
+		// the COM object SysAllocString'd this for us, so we need to free it via COM also
+		SysFreeString(title_bstr);
+	}
+	else
+		str[0]=0;
+}
+
+void BrowserWnd::minibrowser_setCancelIEErrorPage (bool cancel)
+{
+	cancelIEErrorPage = cancel;
+}
+
+int BrowserWnd::doSetScrollbars()
+{
+	HRESULT hr;
+	IWebBrowser2 *pWeb2;
+	IDispatch *id;
+
+	hr = GetIWebBrowser2(&pWeb2);
+
+	if (FAILED(hr)) return 0;
+
+	if (scrollbarsflag == BROWSER_SCROLLBARS_DEFAULT) return 1;
+
+	if (SUCCEEDED(pWeb2->get_Document(&id)) && id)
+	{
+		IHTMLDocument2 *doc;
+		if (SUCCEEDED(id->QueryInterface(IID_IHTMLDocument2, (void **)&doc)) && doc)
+		{
+			IHTMLElement *e;
+			if (SUCCEEDED(doc->get_body(&e)))
+			{
+				IHTMLStyle *s;
+				if (SUCCEEDED(e->get_style(&s)))
+				{
+					BSTR a;
+					switch (scrollbarsflag)
+					{
+					case BROWSER_SCROLLBARS_ALWAYS:
+						writeBString(&a, "scroll");
+						break;
+					case BROWSER_SCROLLBARS_AUTO:
+						writeBString(&a, "auto");
+						break;
+					case BROWSER_SCROLLBARS_NEVER:
+						writeBString(&a, "hidden");
+						break;
+					default: 
+						a = NULL;
+						break;
+					}
+					if (a) s->put_overflow(a);
+					FreeBSTR(&a);
+					s->Release();
+					pWeb2->Release();
+					return 1;
+				}
+				e->Release();
+			}
+			doc->Release();
+		}
+		id->Release();
+	}
+	pWeb2->Release();
+	return 0;
+}
+
+const wchar_t *BrowserWnd::minibrowser_getCurrentUrl()
+{
+	return curpage;
+}
+
+STDMETHODIMP BrowserWnd::GetExternal(IDispatch __RPC_FAR *__RPC_FAR *ppDispatch)
+{
+	*ppDispatch = (IDispatch*) new MinibrowserCOM(this); //TODO we might need to delete this as well!
+	return S_OK;
+}
+
+DWORD BrowserWnd::OnGetDownlodFlags(void)
+{
+	return DLCTL_DLIMAGES | DLCTL_VIDEOS |															DLCTL_PRAGMA_NO_CACHE
+#ifdef WINAMP_FINAL_BUILD
+		|DLCTL_SILENT
+#endif
+	;
+}
+
+
+#define CBCLASS BrowserMsgProc
+START_DISPATCH;
+CB(IFC_MESSAGEPROCESSOR_PROCESS_MESSAGE, ProcessMessage)
+END_DISPATCH;
+#undef CBCLASS

Src/Wasabi/api/skin/widgets/mb/iebrowser.h

@@ -0,0 +1,102 @@
+#ifndef __BROWSER_H
+#define __BROWSER_H
+
+class BrowserWnd;
+
+#define BROWSER_PARENT OSWnd
+#define IDC_SINKOBJ 0x9871 // arbitrary unique id
+#define MB_TIMERID1 0x1927
+#define MB_TIMERID2 0x1928
+
+class String;
+
+#include <nu/HTMLContainer2.h>
+#include <api/wnd/wndclass/oswnd.h>
+#include <api/wnd/minibrowser.h>
+
+class BrowserWnd : public BROWSER_PARENT, public HTMLContainer2, public MiniBrowserI {
+public:
+  BrowserWnd();
+  virtual ~BrowserWnd();
+
+public:
+	static bool InitializeLibrary();
+	static void UninitializeLibrary();
+
+public:
+  // ifc_window
+  virtual int onInit();
+  virtual void onSetVisible(int show);
+  virtual int handleDesktopAlpha() { return 0; }
+	DWORD OnGetDownlodFlags(void);
+
+	virtual int onMouseWheelUp(int click, int lines){return 1;}
+    virtual int onMouseWheelDown(int click, int lines){return 1;}
+
+  // OSWnd
+  virtual HWND getOSHandle();
+
+  // MiniBrowser
+  virtual int minibrowser_navigateUrl(const wchar_t *url);
+  virtual void minibrowser_setHome(const wchar_t *url) { homepage = url; }
+  virtual int minibrowser_back();
+  virtual int minibrowser_forward();
+  virtual int minibrowser_home();
+  virtual int minibrowser_refresh();
+  virtual int minibrowser_stop();
+  virtual void minibrowser_setTargetName(const wchar_t *name);
+  const wchar_t *minibrowser_getTargetName();
+  const wchar_t *minibrowser_getCurrentUrl();
+  virtual void minibrowser_addCB(MiniBrowserCallback *cb) { callbacks.addItem(cb); }
+  virtual ifc_window *minibrowser_getRootWnd() { return this; }
+
+  virtual void minibrowser_setScrollbarsFlag(int a); //BROWSER_SCROLLBARS_ALWAYS, BROWSER_SCROLLBARS_AUTO, BROWSER_SCROLLBARS_NEVER
+	virtual void minibrowser_scrape();
+	virtual void minibrowser_setCancelIEErrorPage(bool cancel);
+	void minibrowser_getDocumentTitle(wchar_t *str, size_t len);
+	virtual const wchar_t* minibrowser_messageToJS(const wchar_t* str1, const wchar_t* str2, int i1, int i2, int i3);
+  //
+  virtual void timerCallback(int id);
+  void onTargetNameTimer();
+
+  bool ProcessMessage(MSG *msg); // return true to 'eat' the message
+
+  bool cancelIEErrorPage;
+	const wchar_t* messageToMaki(wchar_t* str1, wchar_t* str2, int i1, int i2, int i3);
+
+protected:
+  virtual void OnBeforeNavigate(IDispatch *pDispatch, VARIANT *URL, VARIANT *Flags, VARIANT *TargetFrameName, VARIANT *PostData, VARIANT *Headers, VARIANT_BOOL *Cancel);
+  virtual void OnDocumentComplete(IDispatch *pDispatch, VARIANT *URL);
+  virtual void OnDocumentReady(IDispatch *pDispatch, VARIANT *URL); // So we can get rid of all iFrame completes 
+  virtual void OnNavigateError(IDispatch *pDispatch, VARIANT *URL, VARIANT *TargetFrameName, VARIANT *StatusCode, VARIANT_BOOL *Cancel);
+  virtual STDMETHODIMP GetExternal(IDispatch __RPC_FAR *__RPC_FAR *ppDispatch);
+  virtual int initBrowserStuff();
+  virtual void freeBrowserStuff();
+  virtual void onScrollbarsFlagTimer();
+  virtual int wantFocus() { return 1; }
+
+
+private:
+  virtual int doSetTargetName(const wchar_t *name);
+  virtual int doSetScrollbars();
+
+  virtual void updateTargetName();
+  virtual void updateScrollbars();
+
+
+
+    
+  BOOL oleOk;
+  StringW homepage;
+  StringW deferednavigate;
+  StringW targetname;
+  StringW curpage;
+  int timerset1;
+  int timerset2;
+  PtrList<MiniBrowserCallback> callbacks;
+  int scrollbarsflag;
+  ifc_messageprocessor *processor;
+};
+
+#endif
+

Src/Wasabi/api/skin/widgets/mb/mainminibrowser.cpp

@@ -0,0 +1,70 @@
+#include <precomp.h>
+#include "mainminibrowser.h"
+#include <api/script/scriptguid.h>
+#include <api/script/objects/guiobject.h>
+
+ScriptObject *MainMiniBrowser::getScriptObject() 
+{
+  return WASABI_API_MAKI->maki_getObjectAtom(L"browser.main.object");
+}
+
+void MainMiniBrowser::back() {
+  ScriptObject *so = getScriptObject();
+  if (so) {
+    C_Browser browser(so);
+    browser.back();
+  }
+}
+
+void MainMiniBrowser::forward(){
+  ScriptObject *so = getScriptObject();
+  if (so) {
+    C_Browser browser(so);
+    browser.forward();
+  }
+}
+
+void MainMiniBrowser::refresh(){
+  ScriptObject *so = getScriptObject();
+  if (so) {
+    C_Browser browser(so);
+    browser.refresh();
+  }
+}
+
+void MainMiniBrowser::stop(){
+  ScriptObject *so = getScriptObject();
+  if (so) {
+    C_Browser browser(so);
+    browser.stop();
+  }
+}
+
+void MainMiniBrowser::home(){
+  ScriptObject *so = getScriptObject();
+  if (so) {
+    C_Browser browser(so);
+    browser.home();
+  }
+}
+
+void MainMiniBrowser::navigateUrl(const wchar_t *url){
+  ScriptObject *so = getScriptObject();
+  if (so) {
+    C_Browser browser(so);
+    browser.navigateUrl(url);
+  }
+}
+
+#ifdef WASABI_COMPILE_WNDMGR
+void MainMiniBrowser::popMb(){
+  ScriptObject *so = getScriptObject();
+  if (so) {
+    GuiObject *go = static_cast<GuiObject*>(so->vcpu_getInterface(guiObjectGuid));
+    if (go) {
+      go->guiobject_popParentLayout();
+    }
+  }
+}
+#endif
+

Src/Wasabi/api/skin/widgets/mb/mainminibrowser.h

@@ -0,0 +1,24 @@
+#ifndef __MAINMINIBROWSER_H
+#define __MAINMINIBROWSER_H
+
+#include <wasabicfg.h>
+#include <api/script/objects/c_script/c_browser.h>
+#include <api/script/objects/c_script/h_browser.h>
+
+class MainMiniBrowser {
+
+  public:
+  
+    static ScriptObject *getScriptObject();
+    static void back();
+    static void forward();
+    static void refresh();
+    static void stop();
+    static void home();
+    static void navigateUrl(const wchar_t *url);
+#ifdef WASABI_COMPILE_WNDMGR
+    static void popMb();
+#endif  
+};
+
+#endif

Src/Wasabi/api/skin/widgets/mb/mbsvc.cpp

@@ -0,0 +1,48 @@
+#include "precomp.h"
+#include <direct.h>
+#include "mbsvc.h"
+
+#ifndef _WASABIRUNTIME
+
+BEGIN_SERVICES(MbSvc_Svc);
+DECLARE_SERVICETSINGLE(svc_miniBrowser, MbSvc);
+END_SERVICES(MbSvc_Svc, _MbSvc_Svc);
+
+#ifdef _X86_
+extern "C" { int _link_MbSvc; }
+#else
+extern "C" { int __link_MbSvc; }
+#endif
+
+#endif
+
+MbSvc::MbSvc()
+{
+	BrowserWnd::InitializeLibrary();
+}
+
+MbSvc::~MbSvc()
+{
+	BrowserWnd::UninitializeLibrary();
+}
+
+int MbSvc::testGuid(GUID g) {
+  return (g == GUID_MINIBROWSER_ANY || g == GUID_MINIBROWSER_IEACTIVEX);
+}
+
+MiniBrowser *MbSvc::createMiniBrowser() {
+  BrowserWnd *w = new BrowserWnd;
+  browsers.addItem(w);
+  return w;
+}
+
+void MbSvc::destroyMiniBrowser(MiniBrowser *b) {
+  ASSERT(b != NULL);
+  BrowserWnd *bw = static_cast<BrowserWnd *>(b->minibrowser_getRootWnd());
+  ASSERT(bw != NULL);
+  int i = browsers.searchItem(bw);
+  if (i < 0) return;
+  browsers.removeByPos(i);
+  delete bw;
+}
+  

Src/Wasabi/api/skin/widgets/mb/mbsvc.h

@@ -0,0 +1,26 @@
+#ifndef _SVC_H
+#define _SVC_H
+
+#include <api/service/svcs/svc_minibrowser.h>
+#include <bfc/ptrlist.h>
+#include <api/service/svc_enum.h>
+#include "iebrowser.h"
+
+class MbSvc : public svc_miniBrowserI {
+public:
+  MbSvc();
+  ~MbSvc();
+
+  static const char *getServiceName() { return "Internet Explorer ActiveX MiniBrowser Service"; }
+  virtual int testQueryFormat(int queryformat) { return WaSvc::MINIBROWSER; }
+
+  virtual int testGuid(GUID g);
+  virtual MiniBrowser *createMiniBrowser();
+  virtual void destroyMiniBrowser(MiniBrowser *w);
+  
+private:
+
+  PtrList<BrowserWnd> browsers;
+};
+
+#endif

Src/Wasabi/api/skin/widgets/mb/mbsvcwac.cpp

@@ -0,0 +1,26 @@
+#include "precomp.h"
+#include "mbsvc.h"
+#include "svc.h"
+#include "../studio/genwnd.h"
+
+static WACNAME wac;
+WAComponentClient *the = &wac;
+WACNAME *wacmb = &wac;
+
+#include "../studio/services/servicei.h"
+
+// {181BE599-2249-4a1c-8283-4EE85FE8EC86}
+static const GUID guid = 
+{ 0x181be599, 0x2249, 0x4a1c, { 0x82, 0x83, 0x4e, 0xe8, 0x5f, 0xe8, 0xec, 0x86 } };
+
+WACNAME::WACNAME() {
+  registerService(new waServiceFactoryT<svc_miniBrowser, MbSvc>);
+}
+
+WACNAME::~WACNAME() {
+}
+
+GUID WACNAME::getGUID() {
+  return guid;
+}
+

Src/Wasabi/api/skin/widgets/mb/mbsvcwac.h

@@ -0,0 +1,24 @@
+#ifndef _MB_H
+#define _MB_H
+
+#include "../ns_database/nde.h"
+#include "../studio/wac.h"
+
+#define WACNAME WACmb
+
+class GenWnd;
+
+class WACNAME : public WAComponentClient {
+  public:
+    WACNAME();
+    virtual ~WACNAME();
+
+    virtual const char *getName() { return "Internet Explorer ActiveX MiniBrowser Service"; };
+    virtual GUID getGUID();
+
+  private:
+};
+
+extern WACNAME *wacmb;
+
+#endif

Src/Wasabi/api/skin/widgets/mb/minibrowser.cpp

@@ -0,0 +1,36 @@
+#include <precomp.h>
+#include "minibrowser.h"
+
+#define CBCLASS MiniBrowserCallbackI
+START_DISPATCH;
+  CB(MINIBROWSER_ONBEFORENAVIGATE,     minibrowsercb_onBeforeNavigate);
+  VCB(MINIBROWSER_ONDOCUMENTCOMPLETE,  minibrowsercb_onDocumentComplete);
+  VCB(MINIBROWSER_ONDOCUMENTREADY,  minibrowsercb_onDocumentReady);
+  VCB(MINIBROWSER_ONNAVIGATEERROR,  minibrowsercb_onNavigateError);
+	VCB(MINIBROWSER_ONMEDIALINK,  minibrowsercb_onMediaLink);
+	CB(MINIBROWSER_MESSAGETOMAKI,  minibrowsercb_messageToMaki);
+END_DISPATCH;
+#undef CBCLASS
+
+#define CBCLASS MiniBrowserI
+START_DISPATCH;
+  CB(MINIBROWSER_GETROOTWND,           minibrowser_getRootWnd);
+  CB(MINIBROWSER_NAVIGATEURL,          minibrowser_navigateUrl);
+  CB(MINIBROWSER_BACK,                 minibrowser_back);
+  CB(MINIBROWSER_FORWARD,              minibrowser_forward);
+  CB(MINIBROWSER_HOME,                 minibrowser_home);
+  CB(MINIBROWSER_REFRESH,              minibrowser_refresh);
+  CB(MINIBROWSER_STOP,                 minibrowser_stop);
+  VCB(MINIBROWSER_SETTARGETNAME,       minibrowser_setTargetName);
+  CB(MINIBROWSER_GETTARGETNAME,        minibrowser_getTargetName);
+  CB(MINIBROWSER_GETCURRENTURL,        minibrowser_getCurrentUrl);
+  VCB(MINIBROWSER_ADDCB,               minibrowser_addCB);
+  VCB(MINIBROWSER_SETHOME,             minibrowser_setHome);
+  VCB(MINIBROWSER_SETSCROLLFLAG,       minibrowser_setScrollbarsFlag);
+	VCB(MINIBROWSER_SCRAPE, minibrowser_scrape);
+	VCB(MINIBROWSER_SETCANCELIEERRORPAGE, minibrowser_setCancelIEErrorPage);
+	VCB(MINIBROWSER_GETDOCUMENTTITLE, minibrowser_getDocumentTitle);
+	CB(MINIBROWSER_MESSAGETOJS,		minibrowser_messageToJS);
+END_DISPATCH;
+#undef CBCLASS
+

Src/Wasabi/api/skin/widgets/mb/minibrowser.h

@@ -0,0 +1,215 @@
+#ifndef __MINIBROWSER_H
+#define __MINIBROWSER_H
+
+#include <bfc/dispatch.h>
+#include <bfc/common.h>
+
+class ifc_window;
+
+class MiniBrowserCallback : public Dispatchable {
+  public:
+	int minibrowsercb_onBeforeNavigate(const wchar_t *url, int flags, const wchar_t *frame);
+	void minibrowsercb_onDocumentComplete(const wchar_t *url);
+	void minibrowsercb_onDocumentReady(const wchar_t *url);
+	void minibrowsercb_onMediaLink(const wchar_t *url);
+	void minibrowsercb_onNavigateError(const wchar_t *url, int status);
+	const wchar_t* minibrowsercb_messageToMaki(wchar_t* str1, wchar_t* str2, int i1, int i2, int i3);
+
+  enum {
+	MINIBROWSER_ONBEFORENAVIGATE   = 10,
+	MINIBROWSER_ONDOCUMENTCOMPLETE = 20,
+	MINIBROWSER_ONMEDIALINK = 30,
+	MINIBROWSER_ONNAVIGATEERROR = 40,
+	MINIBROWSER_ONDOCUMENTREADY = 50,
+	MINIBROWSER_MESSAGETOMAKI = 60,
+  };
+};
+
+inline int MiniBrowserCallback ::minibrowsercb_onBeforeNavigate(const wchar_t *url, int flags, const wchar_t *frame) {
+  return _call(MINIBROWSER_ONBEFORENAVIGATE, 0, url, flags, frame);
+}
+
+inline void MiniBrowserCallback ::minibrowsercb_onDocumentComplete(const wchar_t *url) {
+  _voidcall(MINIBROWSER_ONDOCUMENTCOMPLETE, url);
+}
+
+inline void MiniBrowserCallback ::minibrowsercb_onDocumentReady(const wchar_t *url) {
+  _voidcall(MINIBROWSER_ONDOCUMENTREADY, url);
+}
+
+inline void MiniBrowserCallback ::minibrowsercb_onNavigateError(const wchar_t *url, int status) {
+  _voidcall(MINIBROWSER_ONNAVIGATEERROR, url, status);
+}
+
+inline void MiniBrowserCallback ::minibrowsercb_onMediaLink(const wchar_t *url) {
+  _voidcall(MINIBROWSER_ONMEDIALINK, url);
+}
+
+inline const wchar_t* MiniBrowserCallback ::minibrowsercb_messageToMaki(wchar_t* str1, wchar_t* str2, int i1, int i2, int i3) {
+  return _call(MINIBROWSER_MESSAGETOMAKI, (const wchar_t*)0, str1, str2, i1, i2, i3);
+}
+
+class MiniBrowserCallbackI : public MiniBrowserCallback {
+  public:
+    virtual int minibrowsercb_onBeforeNavigate(const wchar_t *url, int flags, const wchar_t *frame)=0;
+    virtual void minibrowsercb_onDocumentComplete(const wchar_t *url)=0;
+	virtual void minibrowsercb_onDocumentReady(const wchar_t *url)=0;
+		virtual void minibrowsercb_onMediaLink(const wchar_t *url)=0;
+		virtual void minibrowsercb_onNavigateError(const wchar_t *url, int status)=0;
+		virtual const wchar_t* minibrowsercb_messageToMaki(wchar_t* str1, wchar_t* str2, int i1, int i2, int i3)=0;
+
+  protected:
+    RECVS_DISPATCH;
+};
+
+class MiniBrowser : public Dispatchable  {
+
+  public:
+
+    ifc_window *minibrowser_getRootWnd();
+    int minibrowser_navigateUrl(const wchar_t *url);
+    int minibrowser_back();
+    int minibrowser_forward();
+    int minibrowser_home();
+    int minibrowser_refresh();
+    int minibrowser_stop();
+    void minibrowser_setTargetName(const wchar_t *name);
+    const wchar_t *minibrowser_getTargetName();
+    const wchar_t *minibrowser_getCurrentUrl();
+		void minibrowser_getDocumentTitle(wchar_t *str, size_t len);
+    void minibrowser_addCB(MiniBrowserCallback *cb);
+    void minibrowser_setHome(const wchar_t *url);
+    void minibrowser_setScrollbarsFlag(int a); // BROWSER_SCROLLBARS_ALWAYS, BROWSER_SCROLLBARS_AUTO, BROWSER_SCROLLBARS_NEVER
+		void minibrowser_scrape();
+		virtual void minibrowser_setCancelIEErrorPage(bool cancel);
+		virtual const wchar_t* minibrowser_messageToJS(const wchar_t* str1, const wchar_t* str2, int i1, int i2, int i3);
+
+  enum {
+    MINIBROWSER_GETROOTWND      =  100,
+    MINIBROWSER_NAVIGATEURL     =  200,
+    MINIBROWSER_BACK            =  300,
+    MINIBROWSER_FORWARD         =  400,
+    MINIBROWSER_HOME            =  500,
+    MINIBROWSER_REFRESH         =  600,
+    MINIBROWSER_STOP            =  700,
+    MINIBROWSER_SETTARGETNAME   =  800,
+    MINIBROWSER_GETTARGETNAME   =  900,
+    MINIBROWSER_GETCURRENTURL   = 1000,
+    MINIBROWSER_ADDCB           = 1100,
+    MINIBROWSER_SETHOME         = 1200,
+    MINIBROWSER_SETSCROLLFLAG   = 1300,
+		MINIBROWSER_SCRAPE = 2000,
+		MINIBROWSER_GETDOCUMENTTITLE = 2100,
+		MINIBROWSER_SETCANCELIEERRORPAGE = 2200,
+		MINIBROWSER_MESSAGETOJS = 2300,
+  };
+
+  enum {
+    BROWSER_SCROLLBARS_DEFAULT  = -1,
+    BROWSER_SCROLLBARS_ALWAYS   = 0, 
+    BROWSER_SCROLLBARS_AUTO     = 1, 
+    BROWSER_SCROLLBARS_NEVER    = 2,
+  };
+
+};
+
+inline ifc_window *MiniBrowser::minibrowser_getRootWnd() {
+  return _call(MINIBROWSER_GETROOTWND, (ifc_window *)NULL);
+}
+
+inline int MiniBrowser::minibrowser_navigateUrl(const wchar_t *url) {
+  return _call(MINIBROWSER_NAVIGATEURL, 0, url);
+}
+
+inline int MiniBrowser::minibrowser_back() {
+  return _call(MINIBROWSER_BACK, 0);
+}
+
+inline int MiniBrowser::minibrowser_forward() {
+  return _call(MINIBROWSER_FORWARD, 0);
+}
+
+inline int MiniBrowser::minibrowser_home() {
+  return _call(MINIBROWSER_HOME, 0);
+}
+
+inline int MiniBrowser::minibrowser_refresh() {
+  return _call(MINIBROWSER_REFRESH, 0);
+}
+
+inline int MiniBrowser::minibrowser_stop() {
+  return _call(MINIBROWSER_STOP, 0);
+}
+
+inline void MiniBrowser::minibrowser_setHome(const wchar_t *url) {
+  _voidcall(MINIBROWSER_SETHOME, url);
+}
+
+inline void MiniBrowser::minibrowser_setTargetName(const wchar_t *name) {
+  _voidcall(MINIBROWSER_SETTARGETNAME, name);
+}
+
+inline const wchar_t *MiniBrowser::minibrowser_getTargetName() {
+  return _call(MINIBROWSER_GETTARGETNAME, (const wchar_t *)NULL);
+}
+
+inline void MiniBrowser::minibrowser_getDocumentTitle(wchar_t *str, size_t len) {
+  _voidcall(MINIBROWSER_GETDOCUMENTTITLE, str, len);
+}
+
+inline const wchar_t *MiniBrowser::minibrowser_getCurrentUrl() {
+  return _call(MINIBROWSER_GETCURRENTURL, (const wchar_t *)NULL);
+}
+
+inline void MiniBrowser::minibrowser_addCB(MiniBrowserCallback *cb) {
+  _voidcall(MINIBROWSER_ADDCB, cb);
+}
+
+inline void MiniBrowser::minibrowser_setScrollbarsFlag(int a) {
+  _voidcall(MINIBROWSER_SETSCROLLFLAG, a);
+}
+
+inline void MiniBrowser::minibrowser_scrape()
+{
+	_voidcall(MINIBROWSER_SCRAPE);
+}
+
+inline void MiniBrowser::minibrowser_setCancelIEErrorPage(bool cancel)
+{
+	_voidcall(MINIBROWSER_SETCANCELIEERRORPAGE, cancel);
+}
+
+inline const wchar_t* MiniBrowser::minibrowser_messageToJS(const wchar_t* str1, const wchar_t* str2, int i1, int i2, int i3)
+{
+	return _call(MINIBROWSER_MESSAGETOJS, (const wchar_t *)NULL, str1, str2, i1, i2, i3);
+}
+
+class MiniBrowserI : public MiniBrowser {
+
+  public:
+
+    virtual ifc_window *minibrowser_getRootWnd()=0;
+    virtual int minibrowser_navigateUrl(const wchar_t *url)=0;
+    virtual int minibrowser_back()=0;
+    virtual int minibrowser_forward()=0;
+    virtual int minibrowser_home()=0;
+    virtual int minibrowser_refresh()=0;
+    virtual int minibrowser_stop()=0;
+    virtual void minibrowser_setTargetName(const wchar_t *name)=0;
+    virtual const wchar_t *minibrowser_getTargetName()=0;
+    virtual const wchar_t *minibrowser_getCurrentUrl()=0;
+		virtual void minibrowser_getDocumentTitle(wchar_t *str, size_t len)=0;
+    virtual void minibrowser_addCB(MiniBrowserCallback *cb)=0;
+    virtual void minibrowser_setHome(const wchar_t *url)=0;
+    virtual void minibrowser_setScrollbarsFlag(int a)=0;
+		virtual void minibrowser_scrape()=0;
+		virtual void minibrowser_setCancelIEErrorPage(bool cancel)=0;
+		virtual const wchar_t* minibrowser_messageToJS(const wchar_t* str1, const wchar_t* str2, int i1, int i2, int i3)=0;
+
+  protected:
+    RECVS_DISPATCH;
+};
+
+
+#endif
+

Src/Wasabi/api/skin/widgets/mb/minibrowserwnd.cpp

@@ -0,0 +1,173 @@
+#include <precomp.h>
+#include <api/skin/widgets/mb/minibrowserwnd.h>
+#include <api/skin/widgets/mb/minibrowser.h>
+#include <api/service/svcs/svc_minibrowser.h>
+#include <api/service/svc_enum.h>
+
+MiniBrowserWnd::MiniBrowserWnd(GUID mb_provider) {
+  mb = NULL;
+  mbsvc = MiniBrowserSvcEnum(mb_provider).getFirst();
+}
+
+MiniBrowserWnd::~MiniBrowserWnd() {
+  if (mbsvc) {
+    if (mb) mbsvc->destroyMiniBrowser(mb);
+    WASABI_API_SVC->service_release(mbsvc);  
+  }
+}
+
+int MiniBrowserWnd::onInit() {
+  int r = MBWND_PARENT::onInit();
+  if (mb) {
+    mb->minibrowser_getRootWnd()->setStartHidden(1);
+    mb->minibrowser_getRootWnd()->setParent(this);
+    r &= mb->minibrowser_getRootWnd()->init(this);
+  }
+  onSetVisible(1);
+  return r;
+}
+
+void MiniBrowserWnd::onSetVisible(int i) {
+  MBWND_PARENT::onSetVisible(i);
+  if (i) {
+    if (!mb && mbsvc) {
+      mb = mbsvc->createMiniBrowser();
+      if (mb) {
+        mb->minibrowser_addCB(this);
+        mb->minibrowser_getRootWnd()->setStartHidden(1);
+        mb->minibrowser_getRootWnd()->setParent(this);
+        mb->minibrowser_getRootWnd()->init(this);
+        if (isPostOnInit())
+          onResize();
+      }
+    }
+  } else {
+    if (mb) {
+      mbsvc->destroyMiniBrowser(mb);
+      mb = NULL;
+    }
+  }
+  if (mb && mb->minibrowser_getRootWnd()) {
+    mb->minibrowser_getRootWnd()->setVisible(i);
+  }
+}
+
+int MiniBrowserWnd::onResize() {
+  int r = MBWND_PARENT::onResize();
+  if (mb && mb->minibrowser_getRootWnd()) {
+    RECT r;
+    getClientRect(&r);
+    mb->minibrowser_getRootWnd()->resize(r.left, r.top, r.right-r.left, r.bottom-r.top);
+  }
+  return r;
+}
+
+
+int MiniBrowserWnd::handleDesktopAlpha() {
+  if (mb && mb->minibrowser_getRootWnd()) return mb->minibrowser_getRootWnd()->handleDesktopAlpha();
+  return 0;
+}
+
+int MiniBrowserWnd::handleRatio() { 
+  if (mb && mb->minibrowser_getRootWnd()) return mb->minibrowser_getRootWnd()->handleRatio();
+  return 0; 
+}
+
+int MiniBrowserWnd::navigateUrl(const wchar_t *url) {
+  if (mb) return mb->minibrowser_navigateUrl(url);
+  return 0;
+}
+
+int MiniBrowserWnd::back() {
+  if (mb) return mb->minibrowser_back();
+  return 0;
+}
+
+int MiniBrowserWnd::forward() {
+  if (mb) return mb->minibrowser_forward();
+  return 0;
+}
+
+int MiniBrowserWnd::home() {
+  if (mb) return mb->minibrowser_home();
+  return 0;
+}
+
+int MiniBrowserWnd::refresh() {
+  if (mb) return mb->minibrowser_refresh();
+  return 0;
+}
+
+int MiniBrowserWnd::stop() {
+  if (mb) return mb->minibrowser_stop();
+  return 0;
+}
+
+void MiniBrowserWnd::setTargetName(const wchar_t *name) {
+  if (mb) mb->minibrowser_setTargetName(name);
+}
+
+const wchar_t *MiniBrowserWnd::getTargetName() {
+  if (mb) return mb->minibrowser_getTargetName();
+  return NULL;
+}
+
+const wchar_t *MiniBrowserWnd::getCurrentUrl() {
+  if (mb) return mb->minibrowser_getCurrentUrl();
+  return NULL;
+}
+
+int MiniBrowserWnd::onBeforeNavigate(const wchar_t *url, int flags, const wchar_t *frame) {
+  return 0; // return 1 to cancel navigation
+}
+
+void MiniBrowserWnd::onDocumentComplete(const wchar_t *url) {
+}
+
+void MiniBrowserWnd::onDocumentReady(const wchar_t *url) {
+}
+
+void MiniBrowserWnd::onNavigateError(const wchar_t *url, int status) {
+}
+
+void MiniBrowserWnd::onMediaLink(const wchar_t *url) {
+}
+
+const wchar_t* MiniBrowserWnd::messageToMaki(wchar_t* str1, wchar_t* str2, int i1, int i2, int i3)
+{
+	return 0;
+}
+
+int MiniBrowserWnd::minibrowsercb_onBeforeNavigate(const wchar_t *url, int flags, const wchar_t *frame) {
+  return onBeforeNavigate(url, flags, frame);
+}
+
+void MiniBrowserWnd::minibrowsercb_onDocumentComplete(const wchar_t *url) {
+  onDocumentComplete(url);
+}
+
+void MiniBrowserWnd::minibrowsercb_onDocumentReady(const wchar_t *url) {
+  onDocumentReady(url);
+}
+
+void MiniBrowserWnd::minibrowsercb_onMediaLink(const wchar_t *url) {
+  onMediaLink(url);
+}
+
+void MiniBrowserWnd::minibrowsercb_onNavigateError(const wchar_t *url, int status) {
+  onNavigateError(url, status);
+}
+
+const wchar_t* MiniBrowserWnd::minibrowsercb_messageToMaki(wchar_t* str1, wchar_t* str2, int i1, int i2, int i3)
+{
+	return messageToMaki(str1, str2, i1, i2, i3);
+}
+
+void MiniBrowserWnd::setScrollbarsFlag(int a) {
+  if (mb) mb->minibrowser_setScrollbarsFlag(a);
+}
+
+MiniBrowser *MiniBrowserWnd::getBrowser() {
+  return mb;
+}
+

Src/Wasabi/api/skin/widgets/mb/minibrowserwnd.h

@@ -0,0 +1,57 @@
+#ifndef __MINIBROWSERWND_H
+#define __MINIBROWSERWND_H 
+
+#include <api/wnd/wndclass/guiobjwnd.h>
+#include <api/service/svcs/svc_minibrowser.h>
+#include <api/skin/widgets/mb/minibrowser.h>
+
+#define MBWND_PARENT GuiObjectWnd
+
+class MiniBrowserWnd : public MBWND_PARENT, public MiniBrowserCallbackI {
+
+  public:
+  
+    MiniBrowserWnd(GUID mb_provider=GUID_MINIBROWSER_ANY);
+    virtual ~MiniBrowserWnd();
+
+    virtual int handleDesktopAlpha();
+    virtual int handleRatio();
+    virtual void onSetVisible(int i);
+    virtual int onResize();
+    virtual int onInit();
+  
+    virtual int navigateUrl(const wchar_t *url);
+    virtual int back();
+    virtual int forward();
+    virtual int home();
+    virtual int refresh();
+    virtual int stop();
+    virtual void setTargetName(const wchar_t *name);
+    virtual const wchar_t *getTargetName();
+    virtual const wchar_t *getCurrentUrl();
+    virtual int onBeforeNavigate(const wchar_t *url, int flags, const wchar_t *frame); // return 1 to cancel navigation
+    virtual void onDocumentComplete(const wchar_t *url);
+	virtual void onDocumentReady(const wchar_t *url);
+	virtual void onNavigateError(const wchar_t *url, int status);
+	virtual void onMediaLink(const wchar_t *url);
+	virtual const wchar_t* messageToMaki(wchar_t* str1, wchar_t* str2, int i1, int i2, int i3);
+
+    virtual void setScrollbarsFlag(int a); // BROWSER_SCROLLBARS_ALWAYS, BROWSER_SCROLLBARS_AUTO, BROWSER_SCROLLBARS_NEVER
+
+    virtual int minibrowsercb_onBeforeNavigate(const wchar_t *url, int flags, const wchar_t *frame);
+    virtual void minibrowsercb_onDocumentComplete(const wchar_t *url);
+	virtual void minibrowsercb_onDocumentReady(const wchar_t *url);
+	virtual void minibrowsercb_onMediaLink(const wchar_t *url);
+	virtual void minibrowsercb_onNavigateError(const wchar_t *url, int status);
+	virtual const wchar_t* minibrowsercb_messageToMaki(wchar_t* str1, wchar_t* str2, int i1, int i2, int i3);
+
+    virtual MiniBrowser *getBrowser();
+
+  private:
+
+    MiniBrowser *mb;
+    svc_miniBrowser *mbsvc;
+};
+
+#endif
+

Src/Wasabi/api/skin/widgets/mb/scriptbrowser.cpp

@@ -0,0 +1,180 @@
+#include "precomp.h"
+
+#include "scriptbrowser.h"
+
+#include "main.h"
+
+#include "script/script.h"
+#include "script/scriptmgr.h"
+#include "script/vcpu.h"
+
+#include "mbmgr.h"
+
+BrowserScriptController _browserController;
+BrowserScriptController *browserController = &_browserController;
+
+// -- Functions table -------------------------------------
+function_descriptor_struct BrowserScriptController::exportedFunction[] = {
+  {"gotoUrl",            1, (void*)ScriptBrowserWnd::script_vcpu_gotoUrl },
+  {"back",               0, (void*)ScriptBrowserWnd::script_vcpu_back },
+  {"forward",            0, (void*)ScriptBrowserWnd::script_vcpu_forward },
+  {"home",               0, (void*)ScriptBrowserWnd::script_vcpu_home},
+  {"refresh",            0, (void*)ScriptBrowserWnd::script_vcpu_refresh},
+  {"setTargetName",      1, (void*)ScriptBrowserWnd::script_vcpu_setTargetName},
+  {"onBeforeNavigate",   3, (void*)ScriptBrowserWnd::script_vcpu_onBeforeNavigate},
+  {"onDocumentComplete", 1, (void*)ScriptBrowserWnd::script_vcpu_onDocumentComplete},
+  
+};
+// --------------------------------------------------------
+
+const wchar_t *BrowserScriptController::getClassName() {
+  return L"Browser";
+}
+
+const wchar_t *BrowserScriptController::getAncestorClassName() {
+  return L"GuiObject";
+}
+
+ScriptObject *BrowserScriptController::instantiate() {
+  ScriptBrowserWnd *sb = new ScriptBrowserWnd;
+  ASSERT(sb != NULL);
+  return sb->getScriptObject();
+}
+
+void BrowserScriptController::destroy(ScriptObject *o) {
+  ScriptBrowserWnd *sb = static_cast<ScriptBrowserWnd *>(o->vcpu_getInterface(browserGuid));
+  ASSERT(sb != NULL);
+  delete sb;
+}
+
+void *BrowserScriptController::encapsulate(ScriptObject *o) {
+  return NULL; // no encapsulation for browsers yet
+}
+
+void BrowserScriptController::deencapsulate(void *o) {
+}
+
+int BrowserScriptController::getNumFunctions() {
+  return sizeof(exportedFunction) / sizeof(function_descriptor_struct); 
+}
+
+const function_descriptor_struct *BrowserScriptController::getExportedFunctions() {
+  return exportedFunction;                                                        
+}
+
+GUID BrowserScriptController::getClassGuid() {
+  return browserGuid;
+}
+
+ScriptBrowserWnd::ScriptBrowserWnd() {
+  getScriptObject()->vcpu_setInterface(browserGuid, (void *)static_cast<ScriptBrowserWnd *>(this));
+  getScriptObject()->vcpu_setClassName("Browser");
+  getScriptObject()->vcpu_setController(browserController);
+}
+
+ScriptBrowserWnd::~ScriptBrowserWnd() {
+}
+
+int ScriptBrowserWnd::setXmlParam(const char *name, const char *value) {
+  if (SCRIPTBROWSERWND_PARENT::setParam(name, value)) return 1;
+  else if (STRCASEEQL(name,"url")) defurl = value;
+	else if (STRCASEEQL(name,"mainmb")) setMainMB(WTOI(value));
+	else if (STRCASEEQL(name,"targetname")) setTargetName(value);
+	else return 0;
+	return 1;
+}
+
+int ScriptBrowserWnd::onInit() {
+  SCRIPTBROWSERWND_PARENT::onInit();
+  if (!defurl.isempty()) navigateUrl(defurl);
+  return 1;
+}
+
+void ScriptBrowserWnd::setMainMB(int m) {
+  if (m)  
+    MBManager::setMainMB(this);
+  else
+    if (MBManager::getMainMB() == this)
+      MBManager::setMainMB(NULL);
+}
+
+int ScriptBrowserWnd::onBeforeNavigate(const char *url, int flags, const char *frame) {
+  if (SCRIPTBROWSERWND_PARENT::onBeforeNavigate(url, flags, frame)) return 1;
+  scriptVar v = script_vcpu_onBeforeNavigate(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_STRING(url), MAKE_SCRIPT_INT(flags), MAKE_SCRIPT_STRING(frame));
+  if (SOM::isNumeric(&v)) return GET_SCRIPT_BOOLEAN(v);
+  return 0;
+}
+
+void ScriptBrowserWnd::onDocumentComplete(const char *url) {
+  SCRIPTBROWSERWND_PARENT::onDocumentComplete(url);
+  script_vcpu_onDocumentComplete(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_STRING(url));
+}
+
+
+// VCPU
+
+scriptVar ScriptBrowserWnd::script_vcpu_gotoUrl(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar url) {
+  SCRIPT_FUNCTION_INIT
+  ASSERT(url.type == SCRIPT_STRING);
+  ScriptBrowserWnd *sb = static_cast<ScriptBrowserWnd*>(o->vcpu_getInterface(browserGuid));
+  if (sb) sb->navigateUrl(url.data.sdata);
+  RETURN_SCRIPT_VOID;  
+}
+
+scriptVar ScriptBrowserWnd::script_vcpu_back(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) {
+  SCRIPT_FUNCTION_INIT
+  ScriptBrowserWnd *sb = static_cast<ScriptBrowserWnd*>(o->vcpu_getInterface(browserGuid));
+  if (sb) sb->back();
+  RETURN_SCRIPT_VOID;  
+}
+
+scriptVar ScriptBrowserWnd::script_vcpu_forward(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) {
+  SCRIPT_FUNCTION_INIT
+  ScriptBrowserWnd *sb = static_cast<ScriptBrowserWnd*>(o->vcpu_getInterface(browserGuid));
+  if (sb) sb->forward();
+  RETURN_SCRIPT_VOID;  
+}
+
+scriptVar ScriptBrowserWnd::script_vcpu_home(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) {
+  SCRIPT_FUNCTION_INIT
+  ScriptBrowserWnd *sb = static_cast<ScriptBrowserWnd*>(o->vcpu_getInterface(browserGuid));
+  if (sb) sb->home();
+  RETURN_SCRIPT_VOID;  
+}
+
+scriptVar ScriptBrowserWnd::script_vcpu_refresh(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) {
+  SCRIPT_FUNCTION_INIT
+  ScriptBrowserWnd *sb = static_cast<ScriptBrowserWnd*>(o->vcpu_getInterface(browserGuid));
+  if (sb) sb->refresh();
+  RETURN_SCRIPT_VOID;  
+}
+
+scriptVar ScriptBrowserWnd::script_vcpu_stop(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) {
+  SCRIPT_FUNCTION_INIT
+  ScriptBrowserWnd *sb = static_cast<ScriptBrowserWnd*>(o->vcpu_getInterface(browserGuid));
+  if (sb) sb->stop();
+  RETURN_SCRIPT_VOID;  
+}
+
+scriptVar ScriptBrowserWnd::script_vcpu_setTargetName(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar name) {
+  SCRIPT_FUNCTION_INIT
+  ScriptBrowserWnd *sb = static_cast<ScriptBrowserWnd*>(o->vcpu_getInterface(browserGuid));
+  if (sb) sb->setTargetName(GET_SCRIPT_STRING(name));
+  RETURN_SCRIPT_VOID;  
+}
+
+scriptVar ScriptBrowserWnd::script_vcpu_onBeforeNavigate(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar url, scriptVar flags, scriptVar framename) {
+  SCRIPT_FUNCTION_INIT
+  PROCESS_HOOKS3(o, browserController, url, flags, framename);
+  SCRIPT_FUNCTION_CHECKABORTEVENT;    
+  SCRIPT_EXEC_EVENT3(o, url, flags, framename);
+}
+
+scriptVar ScriptBrowserWnd::script_vcpu_onDocumentComplete(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar url) {
+  SCRIPT_FUNCTION_INIT
+  PROCESS_HOOKS1(o, browserController, url);
+  SCRIPT_FUNCTION_CHECKABORTEVENT;
+  SCRIPT_EXEC_EVENT1(o, url);
+}
+
+

Src/Wasabi/api/skin/widgets/mb/scriptbrowser.h

@@ -0,0 +1,63 @@
+#ifndef _SCRIPTBROWSER_H
+#define _SCRIPTBROWSER_H
+
+#include <api/skin/widgets/mb/minibrowserwnd.h>
+#include <api/script/script.h>
+#include <api/script/objects/guiobj.h>
+
+class BrowserScriptController : public GuiObjectScriptController {
+  public:
+
+    virtual const wchar_t *getClassName();
+    virtual const wchar_t *getAncestorClassName();
+    virtual ScriptObjectController *getAncestorController() { return guiController; }
+    virtual int getNumFunctions();
+    virtual const function_descriptor_struct *getExportedFunctions();
+    virtual GUID getClassGuid();
+    virtual ScriptObject *instantiate();
+    virtual void destroy(ScriptObject *o);
+    virtual void *encapsulate(ScriptObject *o);
+    virtual void deencapsulate(void *o);
+
+  private:
+
+    static function_descriptor_struct exportedFunction[];
+    
+};
+
+extern BrowserScriptController *browserController;
+
+
+#define SCRIPTBROWSERWND_PARENT MiniBrowserWnd
+class ScriptBrowserWnd : public SCRIPTBROWSERWND_PARENT {
+public:
+
+  ScriptBrowserWnd();
+  virtual ~ScriptBrowserWnd();
+
+  void setMainMB(int m);
+  virtual int setXmlParam(const wchar_t *name, const wchar_t *value);
+  virtual int onInit();
+
+  virtual int handleDesktopAlpha() { return 0; } // showing the browser will turn off desktop alpha on the parent layout
+
+  virtual void onDocumentComplete(const char *url);
+  virtual int onBeforeNavigate(const char *url, int flags, const char *frame);
+
+public:
+  static scriptVar script_vcpu_gotoUrl(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar url);
+  static scriptVar script_vcpu_back(SCRIPT_FUNCTION_PARAMS, ScriptObject *o);
+  static scriptVar script_vcpu_forward(SCRIPT_FUNCTION_PARAMS, ScriptObject *o);
+  static scriptVar script_vcpu_home(SCRIPT_FUNCTION_PARAMS, ScriptObject *o);
+  static scriptVar script_vcpu_refresh(SCRIPT_FUNCTION_PARAMS, ScriptObject *o);
+  static scriptVar script_vcpu_stop(SCRIPT_FUNCTION_PARAMS, ScriptObject *o);
+  static scriptVar script_vcpu_setTargetName(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar name);
+  static scriptVar script_vcpu_onDocumentComplete(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar url);
+  static scriptVar script_vcpu_onBeforeNavigate(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar url, scriptVar flags, scriptVar framename);
+
+private:
+
+  String defurl;
+};
+
+#endif

Src/Wasabi/api/skin/widgets/mb/sharedminibrowser.cpp

@@ -0,0 +1,39 @@
+#include "precomp.h"
+#include "sharedminibrowser.h"
+#include "wnds/skinwnd.h"
+#include "../studio/api.h"
+#include "../common/mainminibrowser.h"
+
+void SharedMiniBrowser::navigateUrl(const char *url) {
+  if (!m_monitor) {
+    m_monitor = new SkinMonitor();
+  }
+
+  if (!MainMiniBrowser::getScriptObject()) {
+
+    if (!m_inserted) {
+      String xml = "buf:\n";
+      xml += "<WinampAbstractionLayer>\n";
+      xml += "  <groupdef id=\"addon.shared.minibrowser\" name=\"MiniBrowser\">\n";
+      xml += "    <browser mainmb=\"1\" x=\"0\" y=\"0\" w=\"0\" h=\"0\" relatw=\"1\" relath=\"1\" />\n";
+      xml += "  </groupdef>\n";
+      xml += "</WinampAbstractionLayer>\n";
+      WASABI_API_SKIN->loadSkinFile(xml);
+      m_inserted = 1;
+    }
+
+    SkinWnd("addon.shared.minibrowser", WASABISTDCONTAINER_RESIZABLE_NOSTATUS);
+    ASSERTPR(MainMiniBrowser::getScriptObject() != NULL, "Something is really wrong with wasabi");
+  }
+
+  MainMiniBrowser::navigateUrl(url);
+  MainMiniBrowser::popMb();
+}
+
+void SharedMiniBrowser::shutdown() {
+  if (m_monitor) delete m_monitor;
+  m_monitor = NULL;
+}
+
+int SharedMiniBrowser::m_inserted = 0;
+SkinMonitor *SharedMiniBrowser::m_monitor = NULL;

Src/Wasabi/api/skin/widgets/mb/sharedminibrowser.h

@@ -0,0 +1,33 @@
+#ifndef _SHAREDMINIBROWSER_H
+#define _SHAREDMINIBROWSER_H
+
+#include "../studio/skincb.h"
+
+class SkinMonitor;
+
+class SharedMiniBrowser {
+public:
+  static void navigateUrl(const char *url);
+  static void shutdown();
+
+  static int m_inserted;
+  static SkinMonitor *m_monitor;
+
+};
+
+class SkinMonitor : public SkinCallbackI {
+public:
+  SkinMonitor() {
+    WASABI_API_SYSCB->syscb_registerCallback(this);
+  }
+  virtual ~SkinMonitor() {
+    WASABI_API_SYSCB->syscb_deregisterCallback(this);
+  }
+  virtual int skincb_onReset() { 
+    SharedMiniBrowser::m_inserted = 0;
+    return 0;
+  }
+};
+
+
+#endif // _SHAREDMINIBROWSER_H

Src/Wasabi/api/skin/widgets/mb/xuibrowser.cpp

@@ -0,0 +1,385 @@
+#include <precomp.h>
+#include "xuibrowser.h"
+
+const wchar_t browserXuiObjectStr[] = L"Browser"; // This is the xml tag
+char browserXuiSvcName[] = "Browser xui object"; // this is the name of the xuiservice
+
+XMLParamPair ScriptBrowserWnd::params[] = {
+            {BROWSER_SETMAINMB, L"MAINMB"},
+            {BROWSER_SETSCROLLBARS, L"SCROLLBARS"},
+            {BROWSER_SETTARGETNAME, L"TARGETNAME"},
+            {BROWSER_SETURL, L"URL"},
+        };
+
+ScriptBrowserWnd::ScriptBrowserWnd()
+{
+	getScriptObject()->vcpu_setInterface(browserGuid, (void *)static_cast<ScriptBrowserWnd *>(this));
+	getScriptObject()->vcpu_setClassName(L"Browser"); // this is the script class name
+	getScriptObject()->vcpu_setController(browserController);
+
+	myxuihandle = newXuiHandle();
+CreateXMLParameters(myxuihandle);
+}
+
+void ScriptBrowserWnd::CreateXMLParameters(int master_handle)
+{
+	//SCRIPTBROWSERWND_PARENT::CreateXMLParameters(master_handle);
+	int numParams = sizeof(params) / sizeof(params[0]);
+	hintNumberOfParams(myxuihandle, numParams);
+	for (int i = 0;i < numParams;i++)
+		addParam(myxuihandle, params[i], XUI_ATTRIBUTE_IMPLIED);
+}
+
+ScriptBrowserWnd::~ScriptBrowserWnd()
+{
+
+	if (WASABI_API_MAKI->maki_getObjectAtom(MAIN_BROWSER_ATOM_NAME) == getScriptObject())
+		WASABI_API_MAKI->maki_setObjectAtom(MAIN_BROWSER_ATOM_NAME, NULL);
+}
+
+int ScriptBrowserWnd::setXuiParam(int xuihandle, int xmlattributeid, const wchar_t *xmlattributename, const wchar_t *value)
+{
+	if (xuihandle != myxuihandle)
+		return SCRIPTBROWSERWND_PARENT::setXuiParam(xuihandle, xmlattributeid, xmlattributename, value);
+
+	switch (xmlattributeid)
+	{
+	case BROWSER_SETURL:
+		setUrl(value);
+		break;
+	case BROWSER_SETMAINMB:
+		setMainMB(WTOI(value));
+		break;
+	case BROWSER_SETTARGETNAME:
+		setTargetName(value);
+		break;
+	case BROWSER_SETSCROLLBARS:
+		setScrollbarsFlag(translateScrollbarFlag(value));
+		break;
+	default:
+		return 0;
+	}
+	return 1;
+}
+
+int ScriptBrowserWnd::translateScrollbarFlag(const wchar_t *scrollbarflag)
+{
+	if (WCSCASEEQLSAFE(scrollbarflag, L"auto")) return MiniBrowser::BROWSER_SCROLLBARS_AUTO;
+	if (WCSCASEEQLSAFE(scrollbarflag, L"never")) return MiniBrowser::BROWSER_SCROLLBARS_NEVER;
+	if (WCSCASEEQLSAFE(scrollbarflag, L"always")) return MiniBrowser::BROWSER_SCROLLBARS_ALWAYS;
+	if (WCSCASEEQLSAFE(scrollbarflag, L"default")) return MiniBrowser::BROWSER_SCROLLBARS_DEFAULT; // as specified by HTML content
+	return MiniBrowser::BROWSER_SCROLLBARS_AUTO;
+}
+
+void ScriptBrowserWnd::onSetVisible(int v)
+{
+	SCRIPTBROWSERWND_PARENT::onSetVisible(v);
+	if (v && !defurl.isempty() && _wcsicmp(defurl, getCurrentUrl() ? getCurrentUrl() : L"")) 
+		navigateUrl(defurl);
+}
+
+void ScriptBrowserWnd::setMainMB(int m)
+{
+	if (m)
+		WASABI_API_MAKI->maki_setObjectAtom(MAIN_BROWSER_ATOM_NAME, getScriptObject());
+	else
+		if (WASABI_API_MAKI->maki_getObjectAtom(MAIN_BROWSER_ATOM_NAME) == getScriptObject())
+			WASABI_API_MAKI->maki_setObjectAtom(MAIN_BROWSER_ATOM_NAME, NULL);
+}
+
+void ScriptBrowserWnd::setUrl(const wchar_t *url)
+{
+	defurl = url;
+	if (isVisible())
+	{
+		if (!defurl.isempty())
+			navigateUrl(defurl);
+	}
+}
+
+void ScriptBrowserWnd::setCancelIEErrorPage(bool cancel)
+{
+	MiniBrowser *browser = getBrowser();
+	if (browser) browser->minibrowser_setCancelIEErrorPage(cancel);
+}
+
+void ScriptBrowserWnd::Scrape()
+{
+	MiniBrowser *browser = getBrowser();
+	if (browser) browser->minibrowser_scrape();
+}
+
+void ScriptBrowserWnd::getDocumentTitle(wchar_t *str, size_t len) 
+{
+	MiniBrowser *browser = getBrowser();
+	if (browser) 
+		browser->minibrowser_getDocumentTitle(str, len);
+	else
+		str[0]=0;
+}
+
+int ScriptBrowserWnd::navigateUrl(const wchar_t *url)
+{
+	defurl = url;
+	return SCRIPTBROWSERWND_PARENT::navigateUrl(url);
+}
+
+int ScriptBrowserWnd::onBeforeNavigate(const wchar_t *url, int flags, const wchar_t *frame)
+{
+	if (SCRIPTBROWSERWND_PARENT::onBeforeNavigate(url, flags, frame)) return 1;
+	scriptVar v = BrowserScriptController::browser_onBeforeNavigate(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_STRING(url), MAKE_SCRIPT_INT(flags), MAKE_SCRIPT_STRING(frame));
+	if (v.type != SCRIPT_VOID)
+		return GET_SCRIPT_BOOLEAN(v);
+	return 0;
+}
+
+void ScriptBrowserWnd::onDocumentComplete(const wchar_t *url)
+{
+	SCRIPTBROWSERWND_PARENT::onDocumentComplete(url);
+	if (url)
+		BrowserScriptController::browser_onDocumentComplete(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_STRING(url));
+}
+
+void ScriptBrowserWnd::onDocumentReady(const wchar_t *url)
+{
+	SCRIPTBROWSERWND_PARENT::onDocumentComplete(url);
+	if (url)
+		BrowserScriptController::browser_onDocumentReady(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_STRING(url));
+}
+
+void ScriptBrowserWnd::onNavigateError(const wchar_t *url, int status)
+{
+	SCRIPTBROWSERWND_PARENT::onNavigateError(url, status);
+	BrowserScriptController::browser_onNavigateError(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_STRING(url), MAKE_SCRIPT_INT(status));
+}
+
+void ScriptBrowserWnd::onMediaLink(const wchar_t *url)
+{
+	SCRIPTBROWSERWND_PARENT::onMediaLink(url);
+	if (url)
+		BrowserScriptController::browser_onMediaLink(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_STRING(url));
+}
+
+const wchar_t * ScriptBrowserWnd::messageToMaki(wchar_t* str1, wchar_t* str2, int intval1, int intval2, int intval3)
+{
+	const wchar_t* ret = SCRIPTBROWSERWND_PARENT::messageToMaki(str1, str2, intval1, intval2, intval3);
+	if (ret) return ret;
+
+	scriptVar v = BrowserScriptController::browser_messageToMaki(SCRIPT_CALL, getScriptObject(), MAKE_SCRIPT_STRING(str1), MAKE_SCRIPT_STRING(str2), MAKE_SCRIPT_INT(intval1), MAKE_SCRIPT_INT(intval2), MAKE_SCRIPT_INT(intval3));
+	if (v.type == SCRIPT_STRING)
+		return v.data.sdata;
+	return 0;
+}
+
+const wchar_t * ScriptBrowserWnd::messageToJS(const wchar_t* str1, const wchar_t* str2, int i1, int i2, int i3)
+{
+	MiniBrowser *browser = getBrowser();
+	if (browser) return browser->minibrowser_messageToJS(str1, str2, i1, i2, i3);
+	return 0;
+}
+
+// -----------------------------------------------------------------------
+// Script Object
+
+BrowserScriptController _browserController;
+BrowserScriptController *browserController = &_browserController;
+
+// -- Functions table -------------------------------------
+function_descriptor_struct BrowserScriptController::exportedFunction[] = {
+            {L"gotoUrl",			1, (void*)BrowserScriptController::browser_navigateUrl },
+            {L"navigateUrl",		1, (void*)BrowserScriptController::browser_navigateUrl },
+            {L"back",				0, (void*)BrowserScriptController::browser_back },
+            {L"forward",			0, (void*)BrowserScriptController::browser_forward },
+            {L"home",				0, (void*)BrowserScriptController::browser_home},
+            {L"stop",				0, (void*)BrowserScriptController::browser_stop},
+            {L"refresh",			0, (void*)BrowserScriptController::browser_refresh},
+			{L"scrape",				0, (void*)BrowserScriptController::browser_scrape},						
+            {L"setTargetName",		1, (void*)BrowserScriptController::browser_setTargetName},
+            {L"onBeforeNavigate",	3, (void*)BrowserScriptController::browser_onBeforeNavigate},
+            {L"onDocumentComplete", 1, (void*)BrowserScriptController::browser_onDocumentComplete},
+            {L"onDocumentReady",	1, (void*)BrowserScriptController::browser_onDocumentReady},
+			{L"onNavigateError",	2, (void*)BrowserScriptController::browser_onNavigateError},
+			{L"onMediaLink",		1, (void*)BrowserScriptController::browser_onMediaLink},
+			{L"getDocumentTitle",	0, (void*)BrowserScriptController::browser_getDocumentTitle},
+			{L"setCancelIEErrorPage",1, (void*)BrowserScriptController::browser_setCancelIEErrorPage}, 
+			{L"messageToMaki",		5, (void*)BrowserScriptController::browser_messageToMaki}, 
+			{L"messageToJS",		5, (void*)BrowserScriptController::browser_messageToJS}, 
+		};
+
+ScriptObject *BrowserScriptController::instantiate()
+{
+	ScriptBrowserWnd *sb = new ScriptBrowserWnd;
+	ASSERT(sb != NULL);
+	return sb->getScriptObject();
+}
+
+void BrowserScriptController::destroy(ScriptObject *o)
+{
+	ScriptBrowserWnd *sb = static_cast<ScriptBrowserWnd *>(o->vcpu_getInterface(browserGuid));
+	ASSERT(sb != NULL);
+	delete sb;
+}
+
+void *BrowserScriptController::encapsulate(ScriptObject *o)
+{
+	return NULL; // no encapsulation for browsers yet
+}
+
+void BrowserScriptController::deencapsulate(void *o)
+{}
+
+int BrowserScriptController::getNumFunctions()
+{
+	return sizeof(exportedFunction) / sizeof(function_descriptor_struct);
+}
+
+const function_descriptor_struct *BrowserScriptController::getExportedFunctions()
+{
+	return exportedFunction;
+}
+
+
+scriptVar BrowserScriptController::browser_navigateUrl(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar url)
+{
+	SCRIPT_FUNCTION_INIT
+	ASSERT(url.type == SCRIPT_STRING);
+	ScriptBrowserWnd *sb = static_cast<ScriptBrowserWnd*>(o->vcpu_getInterface(browserGuid));
+	if (sb) sb->navigateUrl(url.data.sdata);
+	RETURN_SCRIPT_VOID;
+}
+
+scriptVar BrowserScriptController::browser_back(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
+{
+	SCRIPT_FUNCTION_INIT
+	ScriptBrowserWnd *sb = static_cast<ScriptBrowserWnd*>(o->vcpu_getInterface(browserGuid));
+	if (sb) sb->back();
+	RETURN_SCRIPT_VOID;
+}
+
+scriptVar BrowserScriptController::browser_forward(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
+{
+	SCRIPT_FUNCTION_INIT
+	ScriptBrowserWnd *sb = static_cast<ScriptBrowserWnd*>(o->vcpu_getInterface(browserGuid));
+	if (sb) sb->forward();
+	RETURN_SCRIPT_VOID;
+}
+
+scriptVar BrowserScriptController::browser_home(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
+{
+	SCRIPT_FUNCTION_INIT
+	ScriptBrowserWnd *sb = static_cast<ScriptBrowserWnd*>(o->vcpu_getInterface(browserGuid));
+	if (sb) sb->home();
+	RETURN_SCRIPT_VOID;
+}
+
+scriptVar BrowserScriptController::browser_refresh(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
+{
+	SCRIPT_FUNCTION_INIT
+	ScriptBrowserWnd *sb = static_cast<ScriptBrowserWnd*>(o->vcpu_getInterface(browserGuid));
+	if (sb) sb->refresh();
+	RETURN_SCRIPT_VOID;
+}
+
+scriptVar BrowserScriptController::browser_stop(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
+{
+	SCRIPT_FUNCTION_INIT
+	ScriptBrowserWnd *sb = static_cast<ScriptBrowserWnd*>(o->vcpu_getInterface(browserGuid));
+	if (sb) sb->stop();
+	RETURN_SCRIPT_VOID;
+}
+
+scriptVar BrowserScriptController::browser_scrape(SCRIPT_FUNCTION_PARAMS, ScriptObject *o)
+{
+	SCRIPT_FUNCTION_INIT
+	ScriptBrowserWnd *sb = static_cast<ScriptBrowserWnd*>(o->vcpu_getInterface(browserGuid));
+	if (sb) sb->Scrape();
+	RETURN_SCRIPT_VOID;
+}
+
+scriptVar BrowserScriptController::browser_setCancelIEErrorPage(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar cancel)
+{
+	SCRIPT_FUNCTION_INIT
+	ScriptBrowserWnd *sb = static_cast<ScriptBrowserWnd*>(o->vcpu_getInterface(browserGuid));
+	if (sb) sb->setCancelIEErrorPage(!!cancel.data.idata);
+	RETURN_SCRIPT_VOID;
+}
+
+scriptVar BrowserScriptController::browser_setTargetName(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar name)
+{
+	SCRIPT_FUNCTION_INIT
+	ScriptBrowserWnd *sb = static_cast<ScriptBrowserWnd*>(o->vcpu_getInterface(browserGuid));
+	if (sb)
+		sb->setTargetName(GET_SCRIPT_STRING(name));
+	RETURN_SCRIPT_VOID;
+}
+
+scriptVar BrowserScriptController::browser_onBeforeNavigate(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar url, scriptVar flags, scriptVar framename)
+{
+	SCRIPT_FUNCTION_INIT
+	PROCESS_HOOKS3(o, browserController, url, flags, framename);
+	SCRIPT_FUNCTION_CHECKABORTEVENT;
+	SCRIPT_EXEC_EVENT3(o, url, flags, framename);
+}
+
+scriptVar BrowserScriptController::browser_messageToMaki(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar str1, scriptVar str2, scriptVar i1, scriptVar i2, scriptVar i3)
+{
+	SCRIPT_FUNCTION_INIT
+	PROCESS_HOOKS5(o, browserController, str1, str2, i1, i2, i3);
+	SCRIPT_FUNCTION_CHECKABORTEVENT;
+	SCRIPT_EXEC_EVENT5(o, str1, str2, i1, i2, i3);
+}
+
+scriptVar BrowserScriptController::browser_messageToJS(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar str1, scriptVar str2, scriptVar i1, scriptVar i2, scriptVar i3)
+{
+	SCRIPT_FUNCTION_INIT
+	ScriptBrowserWnd *sb = static_cast<ScriptBrowserWnd*>(o->vcpu_getInterface(browserGuid));
+	if (sb)
+	{
+		const wchar_t * ret = sb->messageToJS(str1.data.sdata, str2.data.sdata, i1.data.idata, i2.data.idata, i3.data.idata);
+		if (ret)
+			return MAKE_SCRIPT_STRING(ret);
+	}
+	return MAKE_SCRIPT_STRING(L"");
+}
+
+scriptVar BrowserScriptController::browser_onDocumentComplete(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar url)
+{
+	SCRIPT_FUNCTION_INIT
+	PROCESS_HOOKS1(o, browserController, url);
+	SCRIPT_FUNCTION_CHECKABORTEVENT;
+	SCRIPT_EXEC_EVENT1(o, url);
+}
+
+scriptVar BrowserScriptController::browser_onDocumentReady(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar url)
+{
+	SCRIPT_FUNCTION_INIT
+	PROCESS_HOOKS1(o, browserController, url);
+	SCRIPT_FUNCTION_CHECKABORTEVENT;
+	SCRIPT_EXEC_EVENT1(o, url);
+}
+
+scriptVar BrowserScriptController::browser_onNavigateError(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar url, scriptVar status)
+{
+	SCRIPT_FUNCTION_INIT
+	PROCESS_HOOKS2(o, browserController, url, status);
+	SCRIPT_FUNCTION_CHECKABORTEVENT;
+	SCRIPT_EXEC_EVENT2(o, url, status);
+}
+
+scriptVar BrowserScriptController::browser_onMediaLink(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar url)
+{
+	SCRIPT_FUNCTION_INIT
+	PROCESS_HOOKS1(o, browserController, url);
+	SCRIPT_FUNCTION_CHECKABORTEVENT;
+	SCRIPT_EXEC_EVENT1(o, url);
+}
+
+static wchar_t docTitle[1024];
+
+/*string*/ scriptVar BrowserScriptController::browser_getDocumentTitle(SCRIPT_FUNCTION_PARAMS, ScriptObject *o) {
+	SCRIPT_FUNCTION_INIT
+	ScriptBrowserWnd *sb = static_cast<ScriptBrowserWnd*>(o->vcpu_getInterface(browserGuid));
+	docTitle[0]=0;
+	if (sb) sb->getDocumentTitle(docTitle, 1024);
+	return MAKE_SCRIPT_STRING(docTitle);
+}

Src/Wasabi/api/skin/widgets/mb/xuibrowser.h

@@ -0,0 +1,106 @@
+#ifndef __XUIBROWSER_H
+#define __XUIBROWSER_H
+
+#include <api/skin/widgets/mb/minibrowserwnd.h>
+#include <api/script/objcontroller.h>
+
+#define MAIN_BROWSER_ATOM_NAME L"browser.main.object"
+#define SCRIPTBROWSERWND_PARENT MiniBrowserWnd 
+
+// -----------------------------------------------------------------------------------------------------
+class ScriptBrowserWnd : public SCRIPTBROWSERWND_PARENT {
+  
+  public:
+
+    ScriptBrowserWnd();
+    virtual ~ScriptBrowserWnd();
+
+    virtual void onSetVisible(int v);
+
+    // XuiObject
+
+    virtual int setXuiParam(int xuihandle, int xmlattributeid, const wchar_t *xmlattributename, const wchar_t *value);
+
+    // MiniBrowserWnd
+    int onBeforeNavigate(const wchar_t *url, int flags, const wchar_t *frame);
+    void onDocumentComplete(const wchar_t *url);
+	void onDocumentReady(const wchar_t *url);
+	void onNavigateError(const wchar_t *url, int status);
+		void onMediaLink(const wchar_t *url);
+		void getDocumentTitle(wchar_t *str, size_t len);
+
+    virtual int navigateUrl(const wchar_t *url);
+	const wchar_t* messageToMaki(wchar_t* str1, wchar_t* str2, int i1, int i2, int i3);
+	const wchar_t* messageToJS(const wchar_t* str1, const wchar_t* str2, int i1, int i2, int i3);
+
+    // --
+
+    void setUrl(const wchar_t *url);
+    void setMainMB(int tf);
+		void Scrape(); // benski> added Aug 17 2007
+
+		void setCancelIEErrorPage(bool cancel);
+
+protected:
+	/*static */void CreateXMLParameters(int master_handle);
+  private:
+
+    enum {
+      BROWSER_SETURL = 0,
+      BROWSER_SETMAINMB,
+      BROWSER_SETTARGETNAME,
+      BROWSER_SETSCROLLBARS,
+	  BROWSER_CANCELIEERRORPAGE,
+    };
+static XMLParamPair params[];
+    int translateScrollbarFlag(const wchar_t *scrollbarflag);
+
+    StringW defurl;
+    int myxuihandle;
+};
+
+// -----------------------------------------------------------------------------------------------------
+class BrowserScriptController : public ScriptObjectControllerI {
+  public:
+
+    virtual const wchar_t *getClassName() { return L"Browser"; }
+    virtual const wchar_t *getAncestorClassName() { return L"GuiObject"; }
+    virtual ScriptObjectController *getAncestorController() { return WASABI_API_MAKI->maki_getController(guiObjectGuid); }
+    virtual int getNumFunctions();
+    virtual const function_descriptor_struct *getExportedFunctions();
+    virtual GUID getClassGuid() { return browserGuid; }
+    virtual ScriptObject *instantiate();
+    virtual void destroy(ScriptObject *o);
+    virtual void *encapsulate(ScriptObject *o);
+    virtual void deencapsulate(void *o);
+
+  public:
+    static scriptVar browser_navigateUrl(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar url);
+    static scriptVar browser_back(SCRIPT_FUNCTION_PARAMS, ScriptObject *o);
+    static scriptVar browser_forward(SCRIPT_FUNCTION_PARAMS, ScriptObject *o);
+    static scriptVar browser_home(SCRIPT_FUNCTION_PARAMS, ScriptObject *o);
+    static scriptVar browser_stop(SCRIPT_FUNCTION_PARAMS, ScriptObject *o);
+    static scriptVar browser_refresh(SCRIPT_FUNCTION_PARAMS, ScriptObject *o);
+		static scriptVar browser_scrape(SCRIPT_FUNCTION_PARAMS, ScriptObject *o);
+    static scriptVar browser_setTargetName(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar name);
+    static scriptVar browser_onDocumentComplete(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar url);
+	static scriptVar browser_onDocumentReady(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar url);
+	static scriptVar browser_onNavigateError(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar url, scriptVar status);
+    static scriptVar browser_onBeforeNavigate(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar url, scriptVar flags, scriptVar framename);
+	static scriptVar browser_messageToMaki(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar str1, scriptVar str2, scriptVar i1, scriptVar i2, scriptVar i3);
+	static scriptVar browser_messageToJS(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar str1, scriptVar str2, scriptVar i1, scriptVar i2, scriptVar i3);
+		static scriptVar browser_onMediaLink(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar url);
+		static /*string*/ scriptVar browser_getDocumentTitle(SCRIPT_FUNCTION_PARAMS, ScriptObject *o);
+		static scriptVar browser_setCancelIEErrorPage(SCRIPT_FUNCTION_PARAMS, ScriptObject *o, scriptVar cancel);
+  private:
+
+    static function_descriptor_struct exportedFunction[];
+};
+
+extern BrowserScriptController *browserController;
+
+extern const wchar_t browserXuiObjectStr[];
+extern char browserXuiSvcName[];
+class BrowserXuiSvc : public XuiObjectSvc<ScriptBrowserWnd, browserXuiObjectStr, browserXuiSvcName> {};
+
+#endif