I am pasting the code to embed browser in SDK environment.code is litle bit
long so please understand your self
/*Initialization code*/
void WBROW_InitEmbedding()
{
VStrPtr envPath = VSTR_New();
CStr env;
nsCOMPtr<nsILocalFile> binDir;
env = ENV_Translate("ND_SOURCE");
if(env == NULL)
env = ENV_Translate("ND_HOME");
if(env)
{
VSTR_AppendStrSub(envPath,env,STR_Len(env));
#if MCH_WIN == MCH_WINX11
VSTR_AppendStr(envPath,"/firefox/dll");
#else
VSTR_AppendStr(envPath,"\\firefox\\dll");
#endif
}
#if MCH_WIN == MCH_WINX11
#ifdef XPCOM_GLUE
XPCOMGlueStartup(GRE_GetXPCOMPath());
#endif
#endif
NS_NewNativeLocalFile(nsDependentCString(VSTR_GetStr(envPath)), BOOL_TRUE,
getter_AddRefs(binDir));
NS_InitEmbedding(binDir,nsnull);
}
/*
FUNCTION: StartupProfile()
PURPOSE:
*/
nsresult WBROW_StartupProfile()
{
nsCOMPtr<nsIFile> appDataDir;
nsresult rv =
NS_GetSpecialDirectory(NS_APP_APPLICATION_REGISTRY_DIR,
getter_AddRefs(appDataDir));
if (NS_FAILED(rv))
return rv;
/*appDataDir->Append(NS_LITERAL_STRING("wbrow"));*/
nsCOMPtr<nsILocalFile>
localAppDataDir(do_QueryInterface(appDataDir));
nsCOMPtr<nsProfileDirServiceProvider> locProvider;
NS_NewProfileDirServiceProvider(PR_TRUE,
getter_AddRefs(locProvider));
if (!locProvider)
return NS_ERROR_FAILURE;
rv = locProvider->Register();
if (NS_FAILED(rv))
return rv;
else
rv = locProvider->SetProfileDir(localAppDataDir);
#if MCH_WIN == MCH_WINX11
WBROW_StartAppShell();
#endif
return NS_OK;
}
/* InitializeWindowCreator creates and hands off an object with a callback
to a window creation function. This is how all new windows are opened,
except any created directly by the embedding app. */
nsresult WBROW_InitializeWindowCreator()
{
/* create an nsWindowCreator and give it to the WindowWatcher service*/
WindowCreator *creatorCallback = new WindowCreator();
if (creatorCallback)
{
nsCOMPtr<nsIWindowCreator>
windowCreator(NS_STATIC_CAST(nsIWindowCreator *, creatorCallback));
if (windowCreator)
{
nsCOMPtr<nsIWindowWatcher>
wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID));
if (wwatch)
{
wwatch->SetWindowCreator(windowCreator);
return NS_OK;
}
}
}
return NS_ERROR_FAILURE;
}
/*End initialization code*/
________________________________________widnow ceration
code_________________________________________
/*Firefox headers */
#include "nsDirectoryService.h"
#include "nsDirectoryServiceDefs.h"
#include "nsProfileDirServiceProvider.h"
#include "nsAppDirectoryServiceDefs.h"
#include "nsIWebBrowserFind.h"
#include "WebBrowserChrome.h"
#include "WindowCreator.h"
#include "nsIPrintSettings.h"
#include "nsIWebBrowserPrint.h"
#ifdef _BUILD_STATIC_BIN
#include "nsStaticComponent.h"
nsresult PR_CALLBACK app_getModuleInfo(nsStaticModuleInfo **info, PRUint32
*count);
#endif
/* Foward declarations of functions included in this code module:*/
LRESULT CALLBACK BrowserWndProc(HWND, UINT, WPARAM, LPARAM);
static BOOL CALLBACK BrowserDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,
LPARAM lParam);
static nsresult ResizeEmbedding(nsIWebBrowserChrome* chrome);
/* Profile chooser stuff */
static nsresult StartupProfile();
/* Global variables*/
static UINT gDialogCount = 0;
/*
FUNCTION: GetBrowserFromChrome()
PURPOSE: Returns the HWND for the webbrowser container associated
with the specified chrome.
*/
HWND GetBrowserFromChrome(nsIWebBrowserChrome *aChrome)
{
if (!aChrome)
{
return NULL;
}
nsCOMPtr<nsIEmbeddingSiteWindow> baseWindow = do_QueryInterface(aChrome);
HWND hwnd = NULL;
baseWindow->GetSiteWindow((void **) & hwnd);
return hwnd;
}
/*
FUNCTION: GetBrowserDlgFromChrome()
PURPOSE: Returns the HWND for the browser dialog associated with
the specified chrome.
*/
HWND GetBrowserDlgFromChrome(nsIWebBrowserChrome *aChrome)
{
return GetParent(GetBrowserFromChrome(aChrome));
}
/*
FUNCTION: ResizeEmbedding()
PURPOSE: Resizes the webbrowser window to fit its container.
*/
nsresult ResizeEmbedding(nsIWebBrowserChrome* chrome)
{
if (!chrome)
return NS_ERROR_FAILURE;
nsCOMPtr<nsIEmbeddingSiteWindow> embeddingSite = do_QueryInterface(chrome);
HWND hWnd;
embeddingSite->GetSiteWindow((void **) & hWnd);
if (!hWnd)
return NS_ERROR_NULL_POINTER;
RECT rect;
GetClientRect(hWnd, &rect);
/* Make sure the browser is visible and sized*/
nsCOMPtr<nsIWebBrowser> webBrowser;
chrome->GetWebBrowser(getter_AddRefs(webBrowser));
nsCOMPtr<nsIBaseWindow> webBrowserAsWin = do_QueryInterface(webBrowser);
if (webBrowserAsWin)
{
webBrowserAsWin->SetPositionAndSize(rect.left,
rect.top,
rect.right - rect.left,
rect.bottom - rect.top,
PR_TRUE);
webBrowserAsWin->SetVisibility(PR_TRUE);
}
return NS_OK;
}
/*
FUNCTION: BrowserDlgProc()
PURPOSE: Browser dialog windows message handler.
COMMENTS:
The code for handling buttons and menu actions is here.
*/
BOOL CALLBACK BrowserDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM
lParam)
{
/* Get the browser and other pointers since they are used a lot below*/
BrowserPtr BroPtr = (BrowserPtr)GetWindowLong(hwndDlg,
GWL_USERDATA);
HWND hwndBrowser;
nsIWebBrowserChrome *chrome = nsnull ;
if(!BroPtr)
return CallWindowProc(m_lpfnOldWndProc, hwndDlg, uMsg,
wParam,lParam);
hwndBrowser = (HWND)BroPtr->hWnd;
if (hwndBrowser)
chrome = BroPtr->chrome;
nsCOMPtr<nsIWebBrowser> webBrowser;
nsCOMPtr<nsIWebNavigation> webNavigation;
nsCOMPtr<nsIWebBrowserPrint> webBrowserPrint;
if (chrome)
{
chrome->GetWebBrowser(getter_AddRefs(webBrowser));
webNavigation = do_QueryInterface(webBrowser);
webBrowserPrint = do_GetInterface(webBrowser);
}
/* Test the message*/
switch (uMsg)
{
case WM_SYSCOMMAND:
if (wParam == SC_CLOSE)
{
if(chrome)
WebBrowserChromeUI::Destroy(chrome);
return TRUE;
}
break;
case WM_ACTIVATE:
{
nsCOMPtr<nsIWebBrowserFocus> focus(do_GetInterface(webBrowser));
if(focus)
{
switch (wParam)
{
case WA_ACTIVE:
focus->Activate();
break;
case WA_INACTIVE:
focus->Deactivate();
break;
default:
break;
}
}
}
break;
case WM_WINDOWPOSCHANGED:
{
WgtRectCPtr cResbox;
WinMetricsRec met;
UInt
frameLeft=0,frameTop=0;
WgtPtr WBrow =
(WgtPtr)BroPtr->wbrow;
WinPtr win =
WGT_GetWin((WgtPtr)WBrow);
DefWindowProc(hwndDlg, uMsg, wParam, lParam);
/*CallWindowProc(m_lpfnOldWndProc, hwndDlg,
uMsg, wParam,lParam);*/
cResbox =
WGT_GetBox(WGT_FROMSUBCLASS((WBrowPtr)WBrow));
if(!WinIsControlledByWm(WGT_GetWin((WgtPtr)WBrow)))
{
WinQueryMetrics(win,&met);
frameLeft = met.FrameW;
frameTop = met.TitleH +
met.FrameRimH +
(WIN_GetMenuBar(win)?WinGetMenuHeight(WGT_GetWin((WgtPtr)WBrow)):0);
}
MoveWindow(hwndBrowser,
cResbox->Ori.x+frameLeft, cResbox->Ori.y+frameTop,
cResbox->Ext.x,
cResbox->Ext.y,
TRUE);
if(!WinIsControlledByWm(win))
WIN_DrawFrame(win);
}
return TRUE;
}
/*return FALSE;*/
/*return CallWindowProc(m_lpfnOldWndProc, hwndDlg, uMsg,
wParam,lParam);*/
return DefWindowProc(hwndDlg, uMsg, wParam, lParam);
}
/*
FUNCTION: BrowserWndProc(HWND, unsigned, WORD, LONG)
PURPOSE: Processes messages for the browser container window.
*/
LRESULT CALLBACK BrowserWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM
lParam)
{
nsIWebBrowserChrome *chrome = nsnull;
BrowserPtr BroPtr = (BrowserPtr)GetWindowLong(hWnd,
GWL_USERDATA);
if(BroPtr)
chrome = (nsIWebBrowserChrome *) BroPtr->chrome;
else
return DefWindowProc(hWnd, message, wParam, lParam);
switch (message)
{
case WM_SIZE:
/* Resize the embedded browser*/
ResizeEmbedding(chrome);
return 0;
case WM_MOUSEACTIVATE:
{
break;
}
case WM_ERASEBKGND:
/* Reduce flicker by not painting the non-visible background*/
if(chrome)
{
return 1;
}
else
break;
}
return DefWindowProc(hWnd, message, wParam, lParam);
/*return CallWindowProc(m_lpfnOldWBrowProc, hWnd, message,
wParam,lParam);*/
}
//
// FUNCTION: StartupProfile()
//
// PURPOSE:
//
////////////////////////////////////////////////////////////////////////////
// WebBrowserChromeUI
//
// FUNCTION: CreateNativeWindow()
//
// PURPOSE: Creates a new browser dialog.
//
// COMMENTS:
//
// This function loads the browser dialog from a resource template
// and returns the HWND for the webbrowser container dialog item
// to the caller.
//
nativeWindow WebBrowserChromeUI::CreateNativeWindow(nsIWebBrowserChrome*
chrome,WgtPtr WBrow,Int Index)
{
/* Load the browser dialog from resource*/
HWND hwndDialog=NULL;
PRUint32 chromeFlags;
HWND hwndBrowser;
NoChromeWinPtr LoginWin=NULL;
BrowserPtr BroPtr = NULL;
chrome->GetChromeFlags(&chromeFlags);
ERR_TRACEIN;
if (((chromeFlags & nsIWebBrowserChrome::CHROME_ALL) ==
nsIWebBrowserChrome::CHROME_ALL) && WBrow)
{
hwndDialog = /*cerate native window and set its handler
here*/
m_lpfnOldWndProc =
(FARPROC)SetWindowLong(hwndDialog,GWL_WNDPROC,(long)BrowserDlgProc);
::ShowWindow(hwndBrowser, SW_HIDE);
}
if (!hwndDialog)
ERR_TRACERET(NULL);
SetWindowLong(hwndBrowser, GWL_STYLE, GetWindowLong(hwndBrowser, GWL_STYLE)
| WS_CLIPCHILDREN);
/* Activate the window */
PostMessage(hwndDialog, WM_ACTIVATE, WA_ACTIVE, 0);
gDialogCount++;
ERR_TRACERET(hwndBrowser);
}
/*
FUNCTION: Destroy()
PURPOSE: Destroy the window specified by the chrome
*/
void WebBrowserChromeUI::Destroy(nsIWebBrowserChrome* chrome)
{
nsCOMPtr<nsIWebBrowser> webBrowser;
nsCOMPtr<nsIWebNavigation> webNavigation;
chrome->GetWebBrowser(getter_AddRefs(webBrowser));
webNavigation = do_QueryInterface(webBrowser);
if (webNavigation)
webNavigation->Stop(nsIWebNavigation::STOP_ALL);
chrome->ExitModalEventLoop(NS_OK);
HWND hwndDlg = GetBrowserDlgFromChrome(chrome);
if (hwndDlg == NULL)
return;
/* Explicitly destroy the embedded browser and then the chrome*/
/* First the browser*/
nsCOMPtr<nsIWebBrowser> browser = nsnull;
chrome->GetWebBrowser(getter_AddRefs(browser));
nsCOMPtr<nsIBaseWindow> browserAsWin = do_QueryInterface(browser);
if (browserAsWin)
browserAsWin->Destroy();
/* Now the chrome*/
chrome->SetWebBrowser(nsnull);
NS_RELEASE(chrome);
}
/*
FUNCTION: Called as the final act of a chrome object during its destructor
*/
void WebBrowserChromeUI::Destroyed(nsIWebBrowserChrome* chrome)
{
// Clear the window user data
HWND hwndBrowser = GetBrowserFromChrome(chrome);
HWND hwndBroCont = GetBrowserDlgFromChrome(chrome);
WinPtr win = MSW_MswWindowGetWin(GetParent(hwndBrowser));
WinPtr winCont = MSW_MswWindowGetWin(hwndBroCont);
SetWindowLong(hwndBrowser, GWL_USERDATA, nsnull);
DestroyWindow(hwndBrowser);
--gDialogCount;
if (gDialogCount == 0)
{
// Quit when there are no more browser objects
PostQuitMessage(0);
}
}
//
// FUNCTION: Set the input focus onto the browser window
//
void WebBrowserChromeUI::SetFocus(nsIWebBrowserChrome *chrome)
{
HWND hwndBrowser = GetBrowserFromChrome(chrome);
::SetFocus(hwndBrowser);
}
//
// FUNCTION: UpdateStatusBarText()
//
// PURPOSE: Set the status bar text.
//
void WebBrowserChromeUI::UpdateStatusBarText(nsIWebBrowserChrome *aChrome,
const PRUnichar* aStatusText)
{
BrowserPtr BroPtr =
(BrowserPtr)GetWindowLong(GetBrowserFromChrome(aChrome), GWL_USERDATA);
nsCString status;
if (aStatusText)
status.AssignWithConversion(aStatusText);
}
//
// FUNCTION: UpdateTabText()
//
// PURPOSE: Set the avtive tab text.
//
void WebBrowserChromeUI::UpdateTabText(nsIWebBrowserChrome *aChrome, const
PRUnichar* aStatusText)
{
BrowserPtr BroPtr =
(BrowserPtr)GetWindowLong(GetBrowserFromChrome(aChrome), GWL_USERDATA);
Int tab;
nsCString status;
if (aStatusText)
status.AssignWithConversion(aStatusText);
}
//
// FUNCTION: UpdateCurrentURI()
//
// PURPOSE: Updates the URL address field
//
void WebBrowserChromeUI::UpdateCurrentURI(nsIWebBrowserChrome *aChrome)
{
nsCOMPtr<nsIWebBrowser> webBrowser;
nsCOMPtr<nsIWebNavigation> webNavigation;
aChrome->GetWebBrowser(getter_AddRefs(webBrowser));
webNavigation = do_QueryInterface(webBrowser);
nsCOMPtr<nsIURI> currentURI;
webNavigation->GetCurrentURI(getter_AddRefs(currentURI));
if (currentURI)
{
nsCAutoString uriString;
currentURI->GetAsciiSpec(uriString);
}
}
//
// FUNCTION: UpdateBusyState()
//
// PURPOSE: Refreshes the stop/go buttons in the browser dialog
//
void WebBrowserChromeUI::UpdateBusyState(nsIWebBrowserChrome *aChrome, PRBool
aBusy)
{
// TODO code to show a tooltip should go here
}
//
// FUNCTION: UpdateProgress()
//
// PURPOSE: Refreshes the progress bar in the browser dialog
//
void WebBrowserChromeUI::UpdateProgress(nsIWebBrowserChrome *aChrome, PRInt32
aCurrent, PRInt32 aMax)
{
BrowserPtr BroPtr =
(BrowserPtr)GetWindowLong(GetBrowserFromChrome(aChrome), GWL_USERDATA);
if(aCurrent < 0)
aCurrent = 0;
if (aCurrent > aMax)
{
aMax = aCurrent + 20;
}
}
//
// FUNCTION: ShowContextMenu()
//
// PURPOSE: Display a context menu for the given node
//
void WebBrowserChromeUI::ShowContextMenu(nsIWebBrowserChrome *aChrome, PRUint32
aContextFlags, nsIDOMEvent *aEvent, nsIDOMNode *aNode)
{
// TODO code to test context flags and display a popup menu should go here
Int type;
ERR_TRACEIN;
if(BroPtr == NULL)
{
ERR_TRACEOUT;
}
if(aContextFlags & nsIContextMenuListener::CONTEXT_LINK)
type = 1;
else if(aContextFlags & nsIContextMenuListener::CONTEXT_IMAGE)
type = 2;
else if(aContextFlags & nsIContextMenuListener::CONTEXT_DOCUMENT)
type = 4;
else if(aContextFlags & nsIContextMenuListener::CONTEXT_TEXT)
type = 8;
ERR_TRACEOUT;
}
//
// FUNCTION: ShowTooltip()
//
// PURPOSE: Show a tooltip
//
void WebBrowserChromeUI::ShowTooltip(nsIWebBrowserChrome *aChrome, PRInt32
aXCoords, PRInt32 aYCoords, const PRUnichar *aTipText)
{
// TODO code to show a tooltip should go here
}
//
// FUNCTION: HideTooltip()
//
// PURPOSE: Hide the tooltip
//
void WebBrowserChromeUI::HideTooltip(nsIWebBrowserChrome *aChrome)
{
// TODO code to hide a tooltip should go here
}
void WebBrowserChromeUI::ShowWindow(nsIWebBrowserChrome *aChrome, PRBool aShow)
{
HWND win = GetBrowserDlgFromChrome(aChrome);
::ShowWindow(win, aShow ? SW_SHOW : SW_HIDE);
}
void WebBrowserChromeUI::SizeTo(nsIWebBrowserChrome *aChrome, PRInt32 aWidth,
PRInt32 aHeight)
{
HWND hchrome = GetBrowserDlgFromChrome(aChrome);
HWND hbrowser = GetBrowserFromChrome(aChrome);
RECT chromeRect, browserRect;
::GetWindowRect(hchrome, &chromeRect);
::GetWindowRect(hbrowser, &browserRect);
PRInt32 decoration_x = (browserRect.left - chromeRect.left) +
(chromeRect.right - browserRect.right);
PRInt32 decoration_y = (browserRect.top - chromeRect.top) +
(chromeRect.bottom - browserRect.bottom);
if((aWidth+decoration_x) > (browserRect.right-browserRect.left))
aWidth = aWidth+decoration_x;
else
aWidth = browserRect.right-browserRect.left;
if((aHeight+decoration_y) > (browserRect.bottom-browserRect.top))
aHeight = aHeight+decoration_y;
else
aHeight = browserRect.bottom-browserRect.top;
/*::MoveWindow(hchrome, chromeRect.left, chromeRect.top,
aWidth+decoration_x,
aHeight+decoration_y, TRUE);*/
::MoveWindow(hchrome, chromeRect.left, chromeRect.top,
aWidth,
aHeight, TRUE);
}
//-----------------------------------------------------------------------------
// AppCallbacks
//-----------------------------------------------------------------------------
nsresult AppCallbacks::CreateBrowserWindow(PRUint32 aChromeFlags,
nsIWebBrowserChrome *aParent,
nsIWebBrowserChrome **aNewWindow,WgtPtr WBrow,Int Index)
{
WebBrowserChrome * chrome = new WebBrowserChrome();
if (!chrome)
return NS_ERROR_FAILURE;
// the interface to return and one addref, which we assume will be
// immediately released
CallQueryInterface(NS_STATIC_CAST(nsIWebBrowserChrome*, chrome), aNewWindow);
// now an extra addref; the window owns itself (to be released by
// WebBrowserChromeUI::Destroy)
NS_ADDREF(*aNewWindow);
chrome->SetChromeFlags(aChromeFlags);
chrome->SetParent(aParent);
// Insert the browser
nsCOMPtr<nsIWebBrowser> newBrowser;
chrome->CreateBrowser(-1, -1, -1, -1,
getter_AddRefs(newBrowser),WBrow,Index);
if (!newBrowser)
return NS_ERROR_FAILURE;
/* Place it where we want it.*/
ResizeEmbedding(NS_STATIC_CAST(nsIWebBrowserChrome*, chrome));
/* if opened as chrome, it'll be made visible after the chrome has loaded.*/
/* otherwise, go ahead and show it now.*/
if (!(aChromeFlags & nsIWebBrowserChrome::CHROME_OPENAS_CHROME))
WebBrowserChromeUI::ShowWindow(*aNewWindow, PR_TRUE);
return NS_OK;
}
void AppCallbacks::EnableChromeWindow(nsIWebBrowserChrome *aWindow,PRBool
aEnabled)
{
HWND hwnd = GetBrowserDlgFromChrome(aWindow);
::EnableWindow(hwnd, aEnabled ? TRUE : FALSE);
}
PRUint32 AppCallbacks::RunEventLoop(PRBool &aRunCondition)
{
MSG msg;
HANDLE hFakeEvent = ::CreateEvent(NULL, TRUE, FALSE, NULL);
while (aRunCondition ) {
/* Process pending messages*/
while (::PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) {
if (!::GetMessage(&msg, NULL, 0, 0)) {
/* WM_QUIT*/
aRunCondition = PR_FALSE;
break;
}
PRBool wasHandled = PR_FALSE;
::NS_HandleEmbeddingEvent(msg, wasHandled);
if (wasHandled)
continue;
::TranslateMessage(&msg);
::DispatchMessage(&msg);
}
/* Do idle stuff*/
::MsgWaitForMultipleObjects(1, &hFakeEvent, FALSE, 100, QS_ALLEVENTS);
}
::CloseHandle(hFakeEvent);
return msg.wParam;
}
Int S_MswRegisterWindowClass (Str cname)
{
HWND hWnd =NULL;
HINSTANCE hInst;
WNDCLASS cls;
hInst = (HINSTANCE)MSWOS_GetInstance();
if (GetClassInfo(hInst, cname, &cls) == 0) {
cls.style = CS_HREDRAW | CS_VREDRAW;
cls.cbClsExtra = 0;
cls.hInstance = hInst;
cls.hIcon = NULL;
cls.hCursor = NULL;
cls.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
cls.lpszMenuName = NULL;
cls.lpszClassName = cname;
cls.lpfnWndProc = BrowserWndProc;
cls.cbWndExtra = 3 * sizeof(WinPtr);
if (RegisterClass(&cls) == BOOL_FALSE) {
return FALSE;
}
}
return TRUE;
}
HWND WBROW_CreateBrowWin(HINSTANCE hInst,WgtPtr wbrow,LPRECT lpRect,HWND
hWndApp)
{
Str nameStr;
HWND WBrowWin=NULL;
C_STATIC Int sWBrowWin;
WinChildFlagsSetEnum winFlags = 0;
WinPtr win=NULL;
nameStr = (Str)PTR_New(128*sizeof(Char));
STR_Sprintf(nameStr, "OI_X%4x_%6d", hInst, 0xff);
if(!S_MswRegisterWindowClass(nameStr))
goto error;
/* create the document Window */
WBrowWin = CreateWindow(
nameStr,
NULL,
WS_CHILD | WS_VISIBLE
|WS_BORDER,
lpRect->left,
lpRect->top ,
lpRect->right,
lpRect->bottom,
hWndApp,
NULL,
hInst,
NULL);
PTR_Dispose(nameStr);
return WBrowWin;
error:
PTR_Dispose(nameStr);
return NULL;
}
/*End Widnow creatin code*/
/*Chrome ceration code*/
WebBrowserChrome::WebBrowserChrome()
{
mNativeWindow = nsnull;
mSizeSet = PR_FALSE;
}
WebBrowserChrome::~WebBrowserChrome()
{
WebBrowserChromeUI::Destroyed(this);
}
nsresult WebBrowserChrome::CreateBrowser(PRInt32 aX, PRInt32 aY,
PRInt32 aCX, PRInt32 aCY,
nsIWebBrowser **aBrowser,WgtPtr
wbrow,Int Index)
{
NS_ENSURE_ARG_POINTER(aBrowser);
*aBrowser = nsnull;
mWebBrowser = do_CreateInstance(NS_WEBBROWSER_CONTRACTID);
if (!mWebBrowser)
return NS_ERROR_FAILURE;
(void)mWebBrowser->SetContainerWindow(NS_STATIC_CAST(nsIWebBrowserChrome*,
this));
nsCOMPtr<nsIDocShellTreeItem> dsti = do_QueryInterface(mWebBrowser);
dsti->SetItemType(nsIDocShellTreeItem::typeContentWrapper);
nsCOMPtr<nsIBaseWindow> browserBaseWindow = do_QueryInterface(mWebBrowser);
mNativeWindow =
WebBrowserChromeUI::CreateNativeWindow(NS_STATIC_CAST(nsIWebBrowserChrome*,
this),wbrow,Index);
if (!mNativeWindow)
return NS_ERROR_FAILURE;
#if MCH_WIN == MCH_WINMSW
nsresult rv = browserBaseWindow->InitWindow( mNativeWindow,
nsnull,
aX, aY, aCX, aCY);
#else
nsresult rv = browserBaseWindow->InitWindow(
nsNativeWidget(mNativeWindow),
nsnull,
aX, aY, aCX, aCY);
#endif
browserBaseWindow->Create();
nsCOMPtr<nsIWebProgressListener>
listener(NS_STATIC_CAST(nsIWebProgressListener*, this));
nsCOMPtr<nsIWeakReference> thisListener(do_GetWeakReference(listener));
(void)mWebBrowser->AddWebBrowserListener(thisListener,
NS_GET_IID(nsIWebProgressListener));
/* The window has been created. Now register for history notifications*/
mWebBrowser->AddWebBrowserListener(thisListener,
NS_GET_IID(nsISHistoryListener));
if (mWebBrowser)
{
*aBrowser = mWebBrowser;
NS_ADDREF(*aBrowser);
return NS_OK;
}
return NS_ERROR_FAILURE;
}
/*****************************************************************************/
/* WebBrowserChrome::nsISupports */
/*****************************************************************************/
NS_IMPL_ADDREF(WebBrowserChrome)
NS_IMPL_RELEASE(WebBrowserChrome)
NS_INTERFACE_MAP_BEGIN(WebBrowserChrome)
NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIWebBrowserChrome)
NS_INTERFACE_MAP_ENTRY(nsIInterfaceRequestor)
NS_INTERFACE_MAP_ENTRY(nsIWebBrowserChrome)
NS_INTERFACE_MAP_ENTRY(nsIEmbeddingSiteWindow)
NS_INTERFACE_MAP_ENTRY(nsIWebProgressListener) /* optional*/
NS_INTERFACE_MAP_ENTRY(nsISHistoryListener)
NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
NS_INTERFACE_MAP_ENTRY(nsIObserver)
NS_INTERFACE_MAP_ENTRY(nsIContextMenuListener)
NS_INTERFACE_MAP_ENTRY(nsITooltipListener)
NS_INTERFACE_MAP_END
/*****************************************************************************
WebBrowserChrome::nsIInterfaceRequestor
*****************************************************************************/
NS_IMETHODIMP WebBrowserChrome::GetInterface(const nsIID &aIID, void**
aInstancePtr)
{
NS_ENSURE_ARG_POINTER(aInstancePtr);
*aInstancePtr = 0;
if (aIID.Equals(NS_GET_IID(nsIDOMWindow)))
{
if (mWebBrowser)
{
return mWebBrowser->GetContentDOMWindow((nsIDOMWindow **)
aInstancePtr);
}
return NS_ERROR_NOT_INITIALIZED;
}
return QueryInterface(aIID, aInstancePtr);
}
/*****************************************************************************
WebBrowserChrome::nsIWebBrowserChrome
*****************************************************************************/
NS_IMETHODIMP WebBrowserChrome::SetStatus(PRUint32 aType, const PRUnichar*
aStatus)
{
WebBrowserChromeUI::UpdateStatusBarText(this, aStatus);
return NS_OK;
}
NS_IMETHODIMP WebBrowserChrome::GetWebBrowser(nsIWebBrowser** aWebBrowser)
{
NS_ENSURE_ARG_POINTER(aWebBrowser);
*aWebBrowser = mWebBrowser;
NS_IF_ADDREF(*aWebBrowser);
return NS_OK;
}
NS_IMETHODIMP WebBrowserChrome::SetWebBrowser(nsIWebBrowser* aWebBrowser)
{
mWebBrowser = aWebBrowser;
return NS_OK;
}
NS_IMETHODIMP WebBrowserChrome::GetChromeFlags(PRUint32* aChromeMask)
{
*aChromeMask = mChromeFlags;
return NS_OK;
}
NS_IMETHODIMP WebBrowserChrome::SetChromeFlags(PRUint32 aChromeMask)
{
mChromeFlags = aChromeMask;
return NS_OK;
}
NS_IMETHODIMP WebBrowserChrome::DestroyBrowserWindow(void)
{
WebBrowserChromeUI::Destroy(this);
return NS_OK;
}
/* IN: The desired browser client area dimensions.*/
NS_IMETHODIMP WebBrowserChrome::SizeBrowserTo(PRInt32 aWidth, PRInt32 aHeight)
{
/* This isn't exactly correct: we're setting the whole window to
the size requested for the browser. At time of writing, though,
it's fine and useful for winEmbed's purposes. */
WebBrowserChromeUI::SizeTo(this, aWidth, aHeight);
mSizeSet = PR_TRUE;
return NS_OK;
}
NS_IMETHODIMP WebBrowserChrome::ShowAsModal(void)
{
nsCOMPtr<nsIWebBrowser> browser = nsnull;
this->GetWebBrowser(getter_AddRefs(browser));
nsCOMPtr<nsIBaseWindow> browserAsWin = do_QueryInterface(browser);
/* Copied from nsXULWindow */
nsCOMPtr<nsIAppShell> appShell(do_CreateInstance(kAppShellCID));
if (!appShell)
return NS_ERROR_FAILURE;
appShell->Create(0, nsnull);
appShell->Spinup();
// Store locally so it doesn't die on us
nsCOMPtr<nsIWidget> window;
browserAsWin->GetMainWidget(getter_AddRefs(window));
window->SetModal(PR_TRUE);
mContinueModalLoop = PR_TRUE;
nsCOMPtr<nsIJSContextStack>
stack(do_GetService("@mozilla.org/js/xpc/ContextStack;1"));
nsresult rv = NS_OK;
if (stack && NS_SUCCEEDED(stack->Push(nsnull))) {
while (NS_SUCCEEDED(rv) && mContinueModalLoop) {
void* data;
PRBool isRealEvent;
PRBool processEvent;
rv = appShell->GetNativeEvent(isRealEvent, data);
data = nsnull;
if (NS_SUCCEEDED(rv)) {
window->ModalEventFilter(isRealEvent, data, &processEvent);
if (processEvent)
appShell->DispatchNativeEvent(isRealEvent, data);
}
}
JSContext* cx;
stack->Pop(&cx);
NS_ASSERTION(!cx, "JSContextStack mismatch");
} else
rv = NS_ERROR_FAILURE;
mContinueModalLoop = PR_FALSE;
window->SetModal(PR_FALSE);
appShell->Spindown();
if (mDependentParent)
AppCallbacks::EnableChromeWindow(mDependentParent, PR_TRUE);
return NS_OK;
}
NS_IMETHODIMP WebBrowserChrome::IsWindowModal(PRBool *_retval)
{
*_retval = PR_FALSE;
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP WebBrowserChrome::ExitModalEventLoop(nsresult aStatus)
{
WinPtr win;
mContinueModalLoop = PR_FALSE;
return NS_OK;
}
/*****************************************************************************
WebBrowserChrome::nsIWebBrowserChromeFocus
*****************************************************************************/
NS_IMETHODIMP WebBrowserChrome::FocusNextElement()
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP WebBrowserChrome::FocusPrevElement()
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/*****************************************************************************
WebBrowserChrome::nsIWebProgressListener
*****************************************************************************/
NS_IMETHODIMP WebBrowserChrome::OnProgressChange(nsIWebProgress *progress,
nsIRequest *request,
PRInt32 curSelfProgress,
PRInt32 maxSelfProgress,
PRInt32 curTotalProgress,
PRInt32 maxTotalProgress)
{
WebBrowserChromeUI::UpdateProgress(this, curTotalProgress,
maxTotalProgress);
return NS_OK;
}
NS_IMETHODIMP WebBrowserChrome::OnStateChange(nsIWebProgress *progress,
nsIRequest *request,
PRUint32 progressStateFlags,
nsresult status)
{
if ((progressStateFlags & STATE_START) && (progressStateFlags &
STATE_IS_DOCUMENT))
{
WebBrowserChromeUI::UpdateBusyState(this, PR_TRUE);
}
if ((progressStateFlags & STATE_STOP) && (progressStateFlags &
STATE_IS_DOCUMENT))
{
WebBrowserChromeUI::UpdateBusyState(this, PR_FALSE);
WebBrowserChromeUI::UpdateProgress(this, 0, 100);
WebBrowserChromeUI::UpdateStatusBarText(this, nsnull);
ContentFinishedLoading();
}
return NS_OK;
}
NS_IMETHODIMP WebBrowserChrome::OnLocationChange(nsIWebProgress* aWebProgress,
nsIRequest* aRequest,
nsIURI *location)
{
PRBool isSubFrameLoad = PR_FALSE; /* Is this a subframe load*/
if (aWebProgress) {
nsCOMPtr<nsIDOMWindow> domWindow;
nsCOMPtr<nsIDOMWindow> topDomWindow;
aWebProgress->GetDOMWindow(getter_AddRefs(domWindow));
if (domWindow) { /*Get root domWindow*/
domWindow->GetTop(getter_AddRefs(topDomWindow));
}
if (domWindow != topDomWindow)
isSubFrameLoad = PR_TRUE;
}
if (!isSubFrameLoad)
WebBrowserChromeUI::UpdateCurrentURI(this);
return NS_OK;
}
NS_IMETHODIMP
WebBrowserChrome::OnStatusChange(nsIWebProgress* aWebProgress,
nsIRequest* aRequest,
nsresult aStatus,
const PRUnichar* aMessage)
{
WebBrowserChromeUI::UpdateStatusBarText(this, aMessage);
return NS_OK;
}
NS_IMETHODIMP
WebBrowserChrome::OnSecurityChange(nsIWebProgress *aWebProgress,
nsIRequest *aRequest,
PRUint32 state)
{
return NS_OK;
}
//*****************************************************************************
// WebBrowserChrome::nsISHistoryListener
//*****************************************************************************
NS_IMETHODIMP
WebBrowserChrome::OnHistoryNewEntry(nsIURI * aNewURI)
{
return SendHistoryStatusMessage(aNewURI, "add");
}
NS_IMETHODIMP
WebBrowserChrome::OnHistoryGoBack(nsIURI * aBackURI, PRBool * aContinue)
{
// For now, let the operation continue
*aContinue = PR_TRUE;
return SendHistoryStatusMessage(aBackURI, "back");
}
NS_IMETHODIMP
WebBrowserChrome::OnHistoryGoForward(nsIURI * aForwardURI, PRBool * aContinue)
{
// For now, let the operation continue
*aContinue = PR_TRUE;
return SendHistoryStatusMessage(aForwardURI, "forward");
}
NS_IMETHODIMP
WebBrowserChrome::OnHistoryGotoIndex(PRInt32 aIndex, nsIURI * aGotoURI, PRBool
* aContinue)
{
// For now, let the operation continue
*aContinue = PR_TRUE;
return SendHistoryStatusMessage(aGotoURI, "goto", aIndex);
}
NS_IMETHODIMP
WebBrowserChrome::OnHistoryReload(nsIURI * aURI, PRUint32 aReloadFlags, PRBool
* aContinue)
{
// For now, let the operation continue
*aContinue = PR_TRUE;
return SendHistoryStatusMessage(aURI, "reload", 0 /* no info to pass here
*/, aReloadFlags);
}
NS_IMETHODIMP
WebBrowserChrome::OnHistoryPurge(PRInt32 aNumEntries, PRBool *aContinue)
{
// For now let the operation continue
*aContinue = PR_FALSE;
return SendHistoryStatusMessage(nsnull, "purge", aNumEntries);
}
nsresult
WebBrowserChrome::SendHistoryStatusMessage(nsIURI * aURI, char * operation,
PRInt32 info1, PRUint32 aReloadFlags)
{
nsCAutoString uriCStr;
if (aURI)
{
aURI->GetSpec(uriCStr);
}
nsString uriAStr;
if(!(nsCRT::strcmp(operation, "back")))
{
// Going back. XXX Get string from a resource file
uriAStr.Append(NS_LITERAL_STRING("Going back to url:"));
uriAStr.Append(NS_ConvertUTF8toUCS2(uriCStr));
}
else if (!(nsCRT::strcmp(operation, "forward")))
{
// Going forward. XXX Get string from a resource file
uriAStr.Append(NS_LITERAL_STRING("Going forward to url:"));
uriAStr.Append(NS_ConvertUTF8toUCS2(uriCStr));
}
else if (!(nsCRT::strcmp(operation, "reload")))
{
// Reloading. XXX Get string from a resource file
if (aReloadFlags & nsIWebNavigation::LOAD_FLAGS_BYPASS_PROXY &&
aReloadFlags & nsIWebNavigation::LOAD_FLAGS_BYPASS_CACHE)
{
uriAStr.Append(NS_LITERAL_STRING("Reloading url,(bypassing proxy
and cache) :"));
}
else if (aReloadFlags & nsIWebNavigation::LOAD_FLAGS_BYPASS_PROXY)
{
uriAStr.Append(NS_LITERAL_STRING("Reloading url, (bypassing
proxy):"));
}
else if (aReloadFlags & nsIWebNavigation::LOAD_FLAGS_BYPASS_CACHE)
{
uriAStr.Append(NS_LITERAL_STRING("Reloading url, (bypassing
cache):"));
}
else
{
uriAStr.Append(NS_LITERAL_STRING("Reloading url, (normal):"));
}
uriAStr.Append(NS_ConvertASCIItoUCS2(uriCStr));
}
else if (!(nsCRT::strcmp(operation, "add")))
{
// Adding new entry. XXX Get string from a resource file
uriAStr.Append(NS_ConvertASCIItoUCS2(uriCStr));
uriAStr.Append(NS_LITERAL_STRING(" added to session History"));
}
else if (!(nsCRT::strcmp(operation, "goto")))
{
// Goto. XXX Get string from a resource file
uriAStr.Append(NS_LITERAL_STRING("Going to HistoryIndex:"));
uriAStr.AppendInt(info1);
uriAStr.Append(NS_LITERAL_STRING(" Url:"));
uriAStr.Append(NS_ConvertASCIItoUCS2(uriCStr));
}
else if (!(nsCRT::strcmp(operation, "purge")))
{
// Purging old entries
uriAStr.AppendInt(info1);
uriAStr.Append(NS_LITERAL_STRING(" purged from Session History"));
}
WebBrowserChromeUI::UpdateStatusBarText(this, uriAStr.get());
return NS_OK;
}
void WebBrowserChrome::ContentFinishedLoading()
{
// if it was a chrome window and no one has already specified a size,
// size to content
if (mWebBrowser && !mSizeSet &&
(mChromeFlags & nsIWebBrowserChrome::CHROME_OPENAS_CHROME)) {
nsCOMPtr<nsIDOMWindow> contentWin;
mWebBrowser->GetContentDOMWindow(getter_AddRefs(contentWin));
if (contentWin)
contentWin->SizeToContent();
WebBrowserChromeUI::ShowWindow(this, PR_TRUE);
}
}
//*****************************************************************************
// WebBrowserChrome::nsIEmbeddingSiteWindow
//*****************************************************************************
NS_IMETHODIMP WebBrowserChrome::SetDimensions(PRUint32 aFlags, PRInt32 x,
PRInt32 y, PRInt32 cx, PRInt32 cy)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP WebBrowserChrome::GetDimensions(PRUint32 aFlags, PRInt32 *x,
PRInt32 *y, PRInt32 *cx, PRInt32 *cy)
{
if (aFlags & nsIEmbeddingSiteWindow::DIM_FLAGS_POSITION)
{
*x = 0;
*y = 0;
}
if (aFlags & nsIEmbeddingSiteWindow::DIM_FLAGS_SIZE_INNER ||
aFlags & nsIEmbeddingSiteWindow::DIM_FLAGS_SIZE_OUTER)
{
*cx = 0;
*cy = 0;
}
return NS_ERROR_NOT_IMPLEMENTED;
}
/* void setFocus (); */
NS_IMETHODIMP WebBrowserChrome::SetFocus()
{
WebBrowserChromeUI::SetFocus(this);
return NS_OK;
}
/* attribute wstring title; */
NS_IMETHODIMP WebBrowserChrome::GetTitle(PRUnichar * *aTitle)
{
NS_ENSURE_ARG_POINTER(aTitle);
*aTitle = nsnull;
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP WebBrowserChrome::SetTitle(const PRUnichar * aTitle)
{
WebBrowserChromeUI::UpdateTabText(this,aTitle);
return NS_OK;
}
/* attribute boolean visibility; */
NS_IMETHODIMP WebBrowserChrome::GetVisibility(PRBool * aVisibility)
{
NS_ENSURE_ARG_POINTER(aVisibility);
*aVisibility = PR_TRUE;
return NS_OK;
}
NS_IMETHODIMP WebBrowserChrome::SetVisibility(PRBool aVisibility)
{
return NS_OK;
}
/* attribute nativeSiteWindow siteWindow */
NS_IMETHODIMP WebBrowserChrome::GetSiteWindow(void * *aSiteWindow)
{
NS_ENSURE_ARG_POINTER(aSiteWindow);
#if MCH_WIN == MCH_WINMSW
*aSiteWindow = mNativeWindow;
#else
*aSiteWindow = (void *)mNativeWindow;
#endif
return NS_OK;
}
//*****************************************************************************
// WebBrowserChrome::nsIObserver
//*****************************************************************************
NS_IMETHODIMP WebBrowserChrome::Observe(nsISupports *aSubject, const char
*aTopic, const PRUnichar *someData)
{
nsresult rv = NS_OK;
if (nsCRT::strcmp(aTopic, "profile-change-teardown") == 0)
{
// A profile change means death for this window
WebBrowserChromeUI::Destroy(this);
}
return rv;
}
//*****************************************************************************
// WebBrowserChrome::nsIContextMenuListener
//*****************************************************************************
/* void OnShowContextMenu (in unsigned long aContextFlags, in nsIDOMEvent
aEvent, in nsIDOMNode aNode); */
NS_IMETHODIMP WebBrowserChrome::OnShowContextMenu(PRUint32 aContextFlags,
nsIDOMEvent *aEvent, nsIDOMNode *aNode)
{
WebBrowserChromeUI::ShowContextMenu(this, aContextFlags, aEvent, aNode);
return NS_OK;
}
//*****************************************************************************
// WebBrowserChrome::nsITooltipListener
//*****************************************************************************
/* void OnShowTooltip (in long aXCoords, in long aYCoords, in wstring
aTipText); */
NS_IMETHODIMP WebBrowserChrome::OnShowTooltip(PRInt32 aXCoords, PRInt32
aYCoords, const PRUnichar *aTipText)
{
WebBrowserChromeUI::ShowTooltip(this, aXCoords, aYCoords, aTipText);
return NS_OK;
}
/* void OnHideTooltip (); */
NS_IMETHODIMP WebBrowserChrome::OnHideTooltip()
{
WebBrowserChromeUI::HideTooltip(this);
return NS_OK;
}
/*end chrome creation code*/
Hope that messy code help your some extent.further query accepted
Neeraj
-----Original Message-----
From: [EMAIL PROTECTED]
[mailto:[EMAIL PROTECTED] Behalf Of Callum Prentice
Sent: Saturday, July 09, 2005 4:37 AM
To: [email protected]
Subject: Statically linked build of an application that embeds Gecko
using MSVC
Does anyone know how to build a Gecko embedding application that is
statically linked against the Mozilla SDK using MSVC 6.0 or MSVC.net
rather than makefiles?
I understand that it's possible but everything I've tried has failed
for one reason or another - any advice or examples appreciated.
I know that the makefiles use tools like sed to generate some of the
makefile input but I can always do that as a separate process once when
I know the magic fu that's required.
Callum.
_______________________________________________
mozilla-embedding mailing list
[email protected]
http://mail.mozilla.org/listinfo/mozilla-embedding
_______________________________________________
mozilla-embedding mailing list
[email protected]
http://mail.mozilla.org/listinfo/mozilla-embedding
