diff options
Diffstat (limited to 'Src/Wasabi/api/skin/widgets/mb')
18 files changed, 2244 insertions, 0 deletions
diff --git a/Src/Wasabi/api/skin/widgets/mb/iebrowser.cpp b/Src/Wasabi/api/skin/widgets/mb/iebrowser.cpp new file mode 100644 index 00000000..5be43319 --- /dev/null +++ b/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 diff --git a/Src/Wasabi/api/skin/widgets/mb/iebrowser.h b/Src/Wasabi/api/skin/widgets/mb/iebrowser.h new file mode 100644 index 00000000..e0e61e35 --- /dev/null +++ b/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 + diff --git a/Src/Wasabi/api/skin/widgets/mb/mainminibrowser.cpp b/Src/Wasabi/api/skin/widgets/mb/mainminibrowser.cpp new file mode 100644 index 00000000..bdf22f41 --- /dev/null +++ b/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 + diff --git a/Src/Wasabi/api/skin/widgets/mb/mainminibrowser.h b/Src/Wasabi/api/skin/widgets/mb/mainminibrowser.h new file mode 100644 index 00000000..10af16ad --- /dev/null +++ b/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 diff --git a/Src/Wasabi/api/skin/widgets/mb/mbsvc.cpp b/Src/Wasabi/api/skin/widgets/mb/mbsvc.cpp new file mode 100644 index 00000000..59dd1c34 --- /dev/null +++ b/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; +} + diff --git a/Src/Wasabi/api/skin/widgets/mb/mbsvc.h b/Src/Wasabi/api/skin/widgets/mb/mbsvc.h new file mode 100644 index 00000000..c1c1b4b8 --- /dev/null +++ b/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 diff --git a/Src/Wasabi/api/skin/widgets/mb/mbsvcwac.cpp b/Src/Wasabi/api/skin/widgets/mb/mbsvcwac.cpp new file mode 100644 index 00000000..1f68199b --- /dev/null +++ b/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; +} + diff --git a/Src/Wasabi/api/skin/widgets/mb/mbsvcwac.h b/Src/Wasabi/api/skin/widgets/mb/mbsvcwac.h new file mode 100644 index 00000000..e7d94564 --- /dev/null +++ b/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 diff --git a/Src/Wasabi/api/skin/widgets/mb/minibrowser.cpp b/Src/Wasabi/api/skin/widgets/mb/minibrowser.cpp new file mode 100644 index 00000000..f70c8609 --- /dev/null +++ b/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 + diff --git a/Src/Wasabi/api/skin/widgets/mb/minibrowser.h b/Src/Wasabi/api/skin/widgets/mb/minibrowser.h new file mode 100644 index 00000000..f08a5564 --- /dev/null +++ b/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 + diff --git a/Src/Wasabi/api/skin/widgets/mb/minibrowserwnd.cpp b/Src/Wasabi/api/skin/widgets/mb/minibrowserwnd.cpp new file mode 100644 index 00000000..87cc8d30 --- /dev/null +++ b/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; +} + diff --git a/Src/Wasabi/api/skin/widgets/mb/minibrowserwnd.h b/Src/Wasabi/api/skin/widgets/mb/minibrowserwnd.h new file mode 100644 index 00000000..093e466e --- /dev/null +++ b/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 + diff --git a/Src/Wasabi/api/skin/widgets/mb/scriptbrowser.cpp b/Src/Wasabi/api/skin/widgets/mb/scriptbrowser.cpp new file mode 100644 index 00000000..bb86a227 --- /dev/null +++ b/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); +} + + diff --git a/Src/Wasabi/api/skin/widgets/mb/scriptbrowser.h b/Src/Wasabi/api/skin/widgets/mb/scriptbrowser.h new file mode 100644 index 00000000..3ff2b5d0 --- /dev/null +++ b/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 diff --git a/Src/Wasabi/api/skin/widgets/mb/sharedminibrowser.cpp b/Src/Wasabi/api/skin/widgets/mb/sharedminibrowser.cpp new file mode 100644 index 00000000..f22f3580 --- /dev/null +++ b/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;
\ No newline at end of file diff --git a/Src/Wasabi/api/skin/widgets/mb/sharedminibrowser.h b/Src/Wasabi/api/skin/widgets/mb/sharedminibrowser.h new file mode 100644 index 00000000..57dbf15c --- /dev/null +++ b/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 diff --git a/Src/Wasabi/api/skin/widgets/mb/xuibrowser.cpp b/Src/Wasabi/api/skin/widgets/mb/xuibrowser.cpp new file mode 100644 index 00000000..a8c82408 --- /dev/null +++ b/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); +}
\ No newline at end of file diff --git a/Src/Wasabi/api/skin/widgets/mb/xuibrowser.h b/Src/Wasabi/api/skin/widgets/mb/xuibrowser.h new file mode 100644 index 00000000..90989240 --- /dev/null +++ b/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 |