/* Copyright (C) 2003-2015 LiveCode Ltd.

This file is part of LiveCode.

LiveCode is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License v3 as published by the Free

Software Foundation.

LiveCode is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with LiveCode. If not see <http://www.gnu.org/licenses/>. */

#include "core.h"

#include "w32browser.h"

#include <activscp.h>

#include <revolution/support.h>

///////////////////////////////////////////////////////////////////////////////

int CWebBrowser::browseridcounter= 121;

HRESULT LoadWebBrowserFromStream(IWebBrowser2* pWebBrowser, HGLOBAL pText);

HRESULT LoadWebBrowserFromStreamDo(IDispatch *pHtmlDoc, HGLOBAL pText);

extern HINSTANCE theInstance;

char *BStrToChar(const BSTR bstr)

{

int len = SysStringLen(bstr);

char *str = (char *)malloc(len+1);

str[len] = 0;

WideCharToMultiByte(CP_ACP, NULL, bstr,-1,str, len, NULL,NULL);

return str;

}

BSTR CharToBstr(const char *p_string)

{

int t_required_buffer_size;

t_required_buffer_size = MultiByteToWideChar(CP_ACP, NULL, p_string, -1, NULL, 0);

BSTR t_output_string;

t_output_string = SysAllocStringLen(NULL, t_required_buffer_size);

if (t_output_string == NULL)

return NULL;

MultiByteToWideChar(CP_ACP, NULL, p_string, -1, t_output_string, t_required_buffer_size);

return t_output_string;

}

typedef unsigned char uint1;

typedef unsigned short uint2;

typedef unsigned int uint4;

struct MYBITMAP

{

uint1 *data;

uint2 width;

uint2 height;

uint1 depth;

uint4 bytes_per_line;

HBITMAP bm;

};

MYBITMAP *createmybitmap(uint2 depth, uint2 width, uint2 height)

{

MYBITMAP *image = new (nothrow) MYBITMAP;

image->width = width;

image->height = height;

image->depth = (uint1)depth;

image->bytes_per_line = ((width * depth + 31) >> 3) & 0xFFFFFFFC;

image->data = NULL;

image->bm = NULL;

BITMAPINFO *bmi = NULL;

bmi = (BITMAPINFO *)new char[sizeof(BITMAPV4HEADER)];

memset(bmi, 0, sizeof(BITMAPV4HEADER));

bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);

bmi->bmiHeader.biCompression = BI_BITFIELDS;

BITMAPV4HEADER *b4 = (BITMAPV4HEADER *)bmi;

b4->bV4RedMask = 0xFF0000;

b4->bV4GreenMask = 0xFF00;

b4->bV4BlueMask = 0xFF;

b4->bV4AlphaMask = 0xFF000000;

bmi->bmiHeader.biWidth = width;

bmi->bmiHeader.biHeight = -height;

bmi->bmiHeader.biPlanes = 1;

bmi->bmiHeader.biBitCount = depth;

bmi->bmiHeader.biSizeImage = image->bytes_per_line * image->height;

image->bm = CreateDIBSection(GetDC(NULL), bmi, DIB_RGB_COLORS,

(void **)&image->data, NULL, 0);

if (image->data == NULL || image->bm == NULL)

image->data = (uint1 *)new char[image->bytes_per_line * image->height];

delete bmi;

return image;

}

void destroymybitmap(MYBITMAP *image)

{

if (image->bm == NULL)

delete image->data;

else

DeleteObject(image->bm);

delete image;

}

///////////////////////////////////////////////////////////////////////////////

HHOOK CWebBrowser::s_message_hook = NULL;

HHOOK CWebBrowser::s_window_hook = NULL;

CWebBrowser *CWebBrowser::s_browsers = NULL;

CWebBrowser *CWebBrowser::s_focused_browser = NULL;

CWebBrowserWindow::CWebBrowserWindow(void)

{

m_browser = NULL;

m_mouse_inside = false;

}

LRESULT CWebBrowserWindow::OnDestroy(UINT p_message, WPARAM p_wparam, LPARAM p_lparam, BOOL& r_handled)

{

if (m_browser != NULL)

m_browser -> WindowDestroyed();

return DefWindowProc(p_message, p_wparam, p_lparam);

}

CWebBrowser::CWebBrowser(HWND hparent, BOOL isvisible)

{

m_in_callback = false;

dummybrowser = NULL;

hostwindow = hparent;

browserid = browseridcounter++;

browsertype = BT_IE;

iwebbrowser2 = 0;

zoom=3;

instID=0;

webui = NULL;

contextmenuenabled = FALSE;

scrollbarsenabled = TRUE;

scaleenabled = TRUE;

borderenabled = FALSE;

allownewwindow = FALSE;

advancedMessages = FALSE;

inited = FALSE;

DWORD flags = WS_CHILD;

if (isvisible)

flags |= WS_VISIBLE;

browserwindow.Create(hostwindow, CWindow::rcDefault,

browsertype == BT_IE? _T("{8856F961-340A-11D0-A96B-00C04FD705A2}") : _T("{1339B54C-3453-11D2-93B9-000000000000}"),

flags,0,browserid);

browserwindowsubclass . SetBrowser(this);

browserwindowsubclass . SubclassWindow(browserwindow);

HRESULT hr = AtlAxGetControl(browserwindow.m_hWnd,&iunknown);

if (SUCCEEDED(hr))

iunknown->QueryInterface(IID_IWebBrowser2,(void**)&iwebbrowser2);

if (!iwebbrowser2) return;

browserevents = new (nothrow) CWebEvents(this);

browserevents->AddRef();

webui = new (nothrow) CWebUI(this);

webui->AddRef();

browserwindow.SetExternalUIHandler(webui);

AtlAdvise(iwebbrowser2, browserevents, DIID_DWebBrowserEvents2,

&browserevents2_cookie);

CComQIPtr<IOleInPlaceActiveObject> spl(iwebbrowser2);

m_spIOleInPlaceActiveObject = spl;

HRESULT mr = iwebbrowser2->get_HWND((SHANDLE_PTR *)&lhwnd);

document_events = NULL;

document_events_cookie = 0;

m_current_find = NULL;

inited = TRUE;

if (s_message_hook == NULL)

s_message_hook = SetWindowsHookExA(WH_GETMESSAGE, GetMessageHook, NULL, GetCurrentThreadId());

if (s_window_hook == NULL)

s_window_hook = SetWindowsHookExA(WH_CALLWNDPROC, CallWindowProcHook, NULL, GetCurrentThreadId());

next = s_browsers;

s_browsers = this;

}

CWebBrowser::~CWebBrowser()

{

if (s_browsers == this)

s_browsers = next;

else

for(CWebBrowser *t_browser = s_browsers; t_browser != NULL; t_browser = t_browser -> next)

if (t_browser -> next == this)

t_browser -> next = next;

if (s_focused_browser == this)

s_focused_browser = NULL;

if (s_browsers == NULL)

{

UnhookWindowsHookEx(s_message_hook);

s_message_hook = NULL;

UnhookWindowsHookEx(s_window_hook);

s_window_hook = NULL;

}

if (s_focused_browser == this)

s_focused_browser = NULL;

if (browserwindow.m_hWnd!=0) browserwindow.DestroyWindow();

inited = FALSE;

}

LRESULT CALLBACK CWebBrowser::GetMessageHook(int p_code, WPARAM p_wparam, LPARAM p_lparam)

{

if (p_code >= 0)

{

MSG *t_message;

t_message = (MSG *)p_lparam;

if (s_focused_browser != NULL && t_message -> message >= WM_KEYFIRST && t_message -> message <= WM_KEYLAST)

{

if (s_focused_browser -> m_spIOleInPlaceActiveObject -> TranslateAccelerator(t_message) == S_OK)

t_message -> message = WM_NULL;

}

}

return CallNextHookEx(s_message_hook, p_code, p_wparam, p_lparam);

}

LRESULT CALLBACK CWebBrowser::CallWindowProcHook(int p_code, WPARAM p_wparam, LPARAM p_lparam)

{

if (p_code >= 0)

{

CWPSTRUCT *t_message = (CWPSTRUCT *)p_lparam;

if (t_message -> message == WM_KILLFOCUS)

s_focused_browser = NULL;

else if (t_message -> message == WM_SETFOCUS)

{

HWND t_window;

t_window = t_message -> hwnd;

CWebBrowser *t_new_browser;

for(t_new_browser = s_browsers; t_new_browser != NULL; t_new_browser = t_new_browser -> next)

{

HWND t_parent;

for(t_parent = t_window; t_parent != NULL; t_parent = GetParent(t_parent))

if (t_parent == t_new_browser -> browserwindow)

break;

if (t_parent != NULL)

break;

}

s_focused_browser = t_new_browser;

}

}

return CallNextHookEx(s_window_hook, p_code, p_wparam, p_lparam);

}

void CWebBrowser::WindowDestroyed(void)

{

browserwindow . Detach();

inited = FALSE;

}

///////////////////////////////////////////////////////////////////////////////

//

// COMMAND HANDLING

//

void CWebBrowser::GoURL(const char *URL, const char *target_frame)

{

if (m_in_callback)

return;

if (!inited) return;

CComVariant vtEmpty;

CComVariant zlevel(zoom);

CComVariant vtURL(URL);

if (target_frame == NULL)

iwebbrowser2->Navigate2(&vtURL, &vtEmpty, &vtEmpty, &vtEmpty, &vtEmpty);

else

{

CComVariant t_frame(target_frame);

iwebbrowser2->Navigate2(&vtURL, &vtEmpty, &t_frame, &vtEmpty, &vtEmpty);

}

iwebbrowser2->get_HWND((SHANDLE_PTR *)&lhwnd);

}

void CWebBrowser::GoForward()

{

if (m_in_callback)

return;

if (!inited) return;

iwebbrowser2->GoForward();

}

void CWebBrowser::GoBack()

{

if (m_in_callback)

return;

if (!inited) return;

iwebbrowser2->GoBack();

}

void CWebBrowser::Stop()

{

if (m_in_callback)

return;

if (!inited) return;

iwebbrowser2->Stop();

}

void CWebBrowser::Refresh()

{

if (m_in_callback)

return;

if (!inited) return;

CComVariant va(3);

iwebbrowser2->Refresh2(&va);

}

void CWebBrowser::Focus(void)

{

s_focused_browser = this;

}

void CWebBrowser::Unfocus(void)

{

s_focused_browser = NULL;

}

void CWebBrowser::SetScale(bool willscale)

{

if( willscale )

{

scaleenabled = TRUE;

iwebbrowser2->put_Resizable(VARIANT_TRUE);

}

else

{

scaleenabled = FALSE;

iwebbrowser2->put_Resizable(VARIANT_FALSE);

}

}

bool CWebBrowser::GetScale()

{

return scaleenabled == TRUE;

}

void CWebBrowser::MakeTextSmaller()

{

if (m_in_callback)

return;

CComVariant zlevel(zoom);

if( zoom > 1 )

{

iwebbrowser2->ExecWB(OLECMDID_ZOOM,OLECMDEXECOPT_DONTPROMPTUSER,(VARIANT *)&zlevel,NULL);

zoom = zoom -1;

}

}

void CWebBrowser::Redraw()

{

browserwindow.SetRedraw();

}

void CWebBrowser::Print()

{

iwebbrowser2->ExecWB(OLECMDID_PRINT, OLECMDEXECOPT_DODEFAULT, NULL,NULL);

}

void CWebBrowser::MakeTextBigger()

{

if (m_in_callback)

return;

CComVariant zlevel(zoom);

if( zoom < 5)

{

iwebbrowser2->ExecWB(OLECMDID_ZOOM,OLECMDEXECOPT_DONTPROMPTUSER,(VARIANT *)&zlevel,NULL);

zoom = zoom + 1;

}

}

char *CWebBrowser::GetTitle()

{

CComBSTR bstrTitle;

iwebbrowser2->get_LocationName(&bstrTitle);

return BStrToChar(bstrTitle);

}

// Calls the specified active script function, passing the supplied arguments. Returns the function's value.

char *CWebBrowser::CallScript(const char *p_function_name, char **p_arguments, unsigned int p_argument_count)

{

HRESULT t_result;

t_result = S_OK;

char *t_return_string;

t_return_string = NULL;

IHTMLDocument2 *t_document;

t_document = GetHtmlDocument();

if (t_document == NULL)

t_result = S_FALSE;

IHTMLWindow2 *t_window;

t_window = NULL;

if (t_result == S_OK)

t_window = GetHtmlWindow(t_document);

if (t_window == NULL)

t_result = S_FALSE;

IDispatch *t_script;

t_script = NULL;

if (t_result == S_OK)

t_result = t_document -> get_Script(&t_script);

LPOLESTR t_ole_method;

t_ole_method = NULL;

if (t_result == S_OK)

{

t_ole_method = CharToBstr(p_function_name);

if (t_ole_method == NULL)

t_result = E_OUTOFMEMORY;

}

DISPID t_method_id;

if (t_result == S_OK)

t_result = t_script ->GetIDsOfNames(IID_NULL, &t_ole_method, 1, LOCALE_NEUTRAL, &t_method_id);

VARIANTARG *t_ole_arguments;

t_ole_arguments = NULL;

if (t_result == S_OK)

{

t_ole_arguments = new (nothrow) VARIANTARG[p_argument_count];

if (t_ole_arguments != NULL)

memset(t_ole_arguments, 0, sizeof(VARIANTARG) * p_argument_count);

else

t_result = E_OUTOFMEMORY;

}

if (t_result == S_OK)

{

for(unsigned int i = 0; i < p_argument_count; ++i)

{

VariantInit(&t_ole_arguments[i]);

t_ole_arguments[i] . vt = VT_BSTR;

t_ole_arguments[i] . bstrVal = CharToBstr(p_arguments[p_argument_count - i - 1]);

if (t_ole_arguments[i] . bstrVal == NULL)

t_result = E_OUTOFMEMORY;

}

}

char *t_return_value;

t_return_value = NULL;

if (t_result == S_OK)

{

DISPPARAMS t_params;

t_params . rgvarg = t_ole_arguments;

t_params . rgdispidNamedArgs = NULL;

t_params . cArgs = p_argument_count;

t_params . cNamedArgs = 0;

VARIANT t_function_result;

VariantInit(&t_function_result);

t_result = t_script -> Invoke(t_method_id, IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &t_params, &t_function_result, NULL, NULL);

if (t_result == S_OK)

{

t_result = VariantChangeType(&t_function_result, &t_function_result, VARIANT_ALPHABOOL, VT_BSTR);

if (t_result == S_OK)

{

t_return_value = BStrToChar(t_function_result . bstrVal);

if (t_return_value == NULL)

t_result = E_OUTOFMEMORY;

}

VariantClear(&t_function_result);

}

}

if (t_ole_arguments != NULL)

{

for(unsigned int i = 0; i < p_argument_count; ++i)

VariantClear(&t_ole_arguments[i]);

delete t_ole_arguments;

}

if (t_ole_method != NULL)

SysFreeString(t_ole_method);

if (t_script != NULL)

t_script -> Release();

if (t_window != NULL)

t_window -> Release();

if (t_document != NULL)

t_document -> Release();

return t_return_value;

}

IHTMLDocument2 *CWebBrowser::GetHtmlDocument(void)

{

bool t_success;

t_success = true;

HRESULT t_result;

char *t_return_string;

t_return_string = NULL;

// First we obtain the "active" document's dispatch interface, this will give us access to its

// scripting capabilities.

IDispatch *t_dispatch;

t_dispatch = NULL;

if (t_success)

{

t_result = iwebbrowser2 -> get_Document(&t_dispatch);

t_success = (SUCCEEDED(t_result));

}

if (t_dispatch == NULL || t_result == S_FALSE)

{

// According to the Microsoft docs at http://msdn.microsoft.com/en-us/library/aa752116(VS.85).aspx,

// If the document is not "safe for scripting", then null will be returned here, dispite the result being

// set to S_OK. Alternatively with IE7 and later, t_result will equal S_FALSE in this case.

return NULL;

}

// Get the document to give us a pointer to its IHTMLDocument2 interface. We can use this to obtain

// access to the document's parent window.

IHTMLDocument2 *t_document;

t_document = NULL;

if (t_success)

{

t_result = t_dispatch -> QueryInterface(IID_IHTMLDocument2, (void **)&t_document);

t_success = (SUCCEEDED(t_result));

}

t_dispatch -> Release();

if (t_success)

return t_document;

else

return NULL;

}

IHTMLWindow2 *CWebBrowser::GetHtmlWindow(IHTMLDocument2 *p_document)

{

if (p_document == NULL)

return NULL;

// Get the parent window, this interface should allow us to execute scripts in the document.

IHTMLWindow2 *t_window;

t_window = NULL;

HRESULT t_result;

t_result = p_document -> get_parentWindow(&t_window);

if (!SUCCEEDED(t_result))

t_window = NULL;

return t_window;

}

IHTMLWindow2 *CWebBrowser::GetHtmlWindow(void)

{

IHTMLDocument2 *t_document;

t_document = GetHtmlDocument();

if (t_document == NULL)

return NULL;

// Get the parent window, this interface should allow us to execute scripts in the document.

IHTMLWindow2 *t_window;

t_window = GetHtmlWindow(t_document);

t_document -> Release();

return t_window;

}

// Executes the specified script and returns the value of the "result" global variable, allowing users to return values

char *CWebBrowser::ExecuteScript(const char *p_javascript_string)

{

bool t_success;

t_success = true;

HRESULT t_result;

char *t_return_string;

t_return_string = NULL;

// Get the document to give us a pointer to its IHTMLDocument2 interface. We can use this to obtain

// access to the document's parent window, and its scripting object.

IHTMLDocument2 *t_document;

t_document = NULL;

if (t_success)

t_document = GetHtmlDocument();

if (t_document == NULL)

{

t_return_string = strdup("can't run script");

t_success = false;

}

// Get the HTML window interface, we need this in order too execute the script.

IHTMLWindow2 *t_window;

t_window = NULL;

if (t_success)

t_window = GetHtmlWindow(t_document);

if (t_window == NULL)

{

t_return_string = strdup("can't run script");

t_success = false;

}

// Convert the javascript code into the correct format for the API

BSTR t_code;

t_code = NULL;

if (t_success)

t_code = CharToBstr(p_javascript_string);

if (t_code == NULL)

{

t_return_string = strdup("out of memory");

t_success = false;

}

// Execute the code

VARIANT t_script_return;

VariantInit(&t_script_return);

if (t_success)

{

t_result = t_window -> execScript(t_code, L"JScript", &t_script_return);

t_success = (SUCCEEDED(t_result));

}

// Get the document's scripting environment, we need this in order to retrieve the value of the "result" global variable.

IDispatch *t_script;

t_script = NULL;

if (t_success)

{

t_result = t_document -> get_Script(&t_script);

t_success = (SUCCEEDED(t_result));

}

// Lookup the ID of the "result" variable

DISPID t_var_id;

LPOLESTR t_ole_var;

t_ole_var = OLESTR("result");

if (t_success)

t_result = t_script -> GetIDsOfNames(IID_NULL, &t_ole_var, 1, LOCALE_NEUTRAL, &t_var_id);

char *t_return_value;

t_return_value = NULL;

if (t_result == S_OK && t_success)

{

DISPPARAMS t_params;

t_params.cArgs = 0;

t_params.cNamedArgs = 0;

t_params.rgdispidNamedArgs = NULL;

t_params.rgvarg = NULL;

VARIANT t_function_result;

VariantInit(&t_function_result);

t_result = t_script -> Invoke(t_var_id, IID_NULL, LOCALE_NEUTRAL, DISPATCH_PROPERTYGET, &t_params, &t_function_result, NULL, NULL);

if (t_result == S_OK)

{

t_result = VariantChangeType(&t_function_result, &t_function_result, VARIANT_ALPHABOOL, VT_BSTR);

if (t_result == S_OK)

{

t_return_value = string_from_utf16((const unsigned short *)t_function_result . bstrVal, SysStringLen(t_function_result . bstrVal));

if (t_return_value == NULL)

{

t_result = E_OUTOFMEMORY;

t_success = false;

}

}

VariantClear(&t_function_result);

}

}

else

t_return_value = strdup("");

if (!t_success)

{

if (t_return_value != NULL)

{

delete t_return_value;

t_return_value = NULL;

}

}

if (t_code != NULL)

SysFreeString(t_code);

if (t_script != NULL)

t_script -> Release();

if (t_window != NULL)

t_window -> Release();

if (t_document != NULL)

t_document -> Release();

VariantClear(&t_script_return);

return t_return_value;

}

bool CWebBrowser::FindString(const char *p_string, bool p_search_up)

{

return false;

}

BOOL CWebBrowser::Draw(int twidth,int theight, HDC hdcMem)

{

if (!inited)

return FALSE;

HRESULT hr;

IViewObject2* pViewObject = NULL;

hr = iwebbrowser2->QueryInterface(IID_IViewObject2, (void**)&pViewObject);

if (FAILED(hr)) return FALSE;

HDC hdcMain = GetDC(NULL);

RECTL rcBounds = { 0, 0, twidth, theight };

DWORD freezeindex;

pViewObject->Freeze(DVASPECT_CONTENT, -1,NULL, &freezeindex);

hr = pViewObject->Draw(DVASPECT_CONTENT, -1, NULL, NULL, hdcMain, hdcMem,

&rcBounds, NULL, NULL, 0);

pViewObject->Unfreeze(freezeindex);

pViewObject->Release();

ReleaseDC(NULL,hdcMain);

if (SUCCEEDED(hr))

return TRUE;

return FALSE;

}

BOOL CWebBrowser::Draw( HDC hdcMem)

{

IHTMLElementRender * pRender;

IHTMLDocument2* pDoc;

IHTMLElement* pBodyElem = 0;

IDispatch * pdisp;

HRESULT hr;

if( SUCCEEDED(iwebbrowser2->get_Document(&pdisp)) )

{

if( pdisp != NULL )

{

hr = pdisp->QueryInterface(IID_IHTMLDocument2,(void **)&pDoc);

if( hr != S_OK )

return FALSE;

}

// got a doc lets get the element

HRESULT hr = pDoc->get_body(&pBodyElem);

if (SUCCEEDED(hr)) {

hr = pBodyElem->QueryInterface(IID_IHTMLElementRender, (void**)&pRender);

if (SUCCEEDED(hr)) {

hr = pRender->DrawToDC(hdcMem);

}

pRender->Release();

}

pBodyElem->Release();

}

return TRUE;

}

///////////////////////////////////////////////////////////////////////////////

//

// PROPERTY HANDLING

//

bool CWebBrowser::GetBusy()

{

if (!inited) return FALSE;

VARIANT_BOOL vBool;

iwebbrowser2->get_Busy(&vBool);

return vBool == VARIANT_TRUE;

}

bool CWebBrowser::GetOffline()

{

if (!inited) return FALSE;

VARIANT_BOOL vBool;

iwebbrowser2->get_Offline(&vBool);

return vBool == VARIANT_TRUE;

}

void CWebBrowser::SetOffline(bool isoffline)

{

if (m_in_callback)

return;

if (!inited) return;

iwebbrowser2->put_Offline(isoffline == TRUE? VARIANT_TRUE: VARIANT_FALSE);

}

bool CWebBrowser::GetContextMenu()

{

if (!inited) return false;

return contextmenuenabled == TRUE;

}

void CWebBrowser::SetContextMenu(bool isenabled)

{

contextmenuenabled = isenabled;

}

void CWebBrowser::SetNewWindow(bool isenabled)

{

allownewwindow = isenabled;

}

bool CWebBrowser::GetNewWindow()

{

return allownewwindow == TRUE;

}

void CWebBrowser::SetScrollbars(bool usescrollbars)

{

if (m_in_callback)

return;

scrollbarsenabled = usescrollbars;

iwebbrowser2->Refresh();

}

void CWebBrowser::SetMessages(bool getsMessages)

{

advancedMessages = getsMessages;

}

bool CWebBrowser::GetMessages()

{

return advancedMessages == TRUE;

}

bool CWebBrowser::GetScrollbars()

{

return scrollbarsenabled == TRUE;

}

void CWebBrowser::SetBorder(bool showborder)

{

if (m_in_callback)

return;

borderenabled = showborder;

iwebbrowser2->Refresh();

}

bool CWebBrowser::GetBorder()

{

return borderenabled == TRUE;

}

void CWebBrowser::SetVisible(bool isvisible)

{

if (!inited) return;

browserwindow.ShowWindow(isvisible == TRUE? SW_SHOW:SW_HIDE);

}

bool CWebBrowser::GetVisible()

{

if (!inited) return false;

return browserwindow.IsWindowVisible() == TRUE;

}

void CWebBrowser::SetRect(int p_left, int p_top, int p_right, int p_bottom)

{

if (!inited) return;

browserwindow.MoveWindow(p_left, p_top, p_right - p_left, p_bottom - p_top, FALSE);

iwebbrowser2->get_HWND((SHANDLE_PTR *)&lhwnd);

}

void CWebBrowser::GetRect(int& r_left, int& r_top, int& r_right, int& r_bottom)

{

RECT r;

if (!inited) return;

browserwindow.GetWindowRect(&r);

POINT p;

p.x = r.left;

p.y = r.top;

browserwindow.ScreenToClient(&r);

ScreenToClient(hostwindow,&p);

r.left = p.x;

r.top = p.y;

r.right += p.x;

r.bottom += p.y;

r_left = r . left;

r_top = r . top;

r_right = r . right;

r_bottom = r . bottom;

}

char *CWebBrowser::GetURL()

{

if (!inited) return NULL;

CComBSTR bstrURL;

if (SUCCEEDED(iwebbrowser2->get_LocationURL(&bstrURL)))

return BStrToChar(bstrURL);

else return NULL;

}

void CWebBrowser::SetBrowser(const char *browser)

{

if (m_in_callback)

return;

BrowserType t_new_type;

if (_strnicmp(browser, "IE", strlen(browser)) == 0)

t_new_type = BT_IE;

else

t_new_type = BT_NETSCAPE;

if (t_new_type != browsertype)

{

browsertype = t_new_type;

swapBrowser();

}

}

char *CWebBrowser::GetBrowser()

{

if(!inited) return NULL;

CComBSTR bstrReturn;

if( browsertype == BT_IE)

bstrReturn = "IE";

else

bstrReturn = "Netscape";

return BStrToChar(bstrReturn);

}

// Returns

// A pointer to an object that represents the body of the active document in the browser.

// Returns NULL if failed.

// Description

// Use this to obtain access to the body element of the active document. Note that the returned

// object must be freed by the caller when no longer needed.

IHTMLElement2 *CWebBrowser::GetBodyElement(void)

{

bool t_success;

t_success = true;

HRESULT t_result;

IDispatch *t_dispatch;

if (t_success)

{

t_result = iwebbrowser2 -> get_Document(&t_dispatch);

t_success = (SUCCEEDED(t_result));

}

IHTMLDocument2 *t_document;

if (t_success)

{

t_result = t_dispatch -> QueryInterface(IID_IHTMLDocument2, (void **)&t_document);

t_success = (SUCCEEDED(t_result));

}

IHTMLElement *t_body;

if (t_success)

{

t_result = t_document -> get_body(&t_body);