mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-09-10 11:54:40 +00:00
1543 lines
56 KiB
C++
1543 lines
56 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "nsNativeAppSupportBase.h"
|
|
#include "nsNativeAppSupportWin.h"
|
|
#include "nsAppRunner.h"
|
|
#include "nsXULAppAPI.h"
|
|
#include "nsString.h"
|
|
#include "nsIBrowserDOMWindow.h"
|
|
#include "nsICommandLineRunner.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsXPIDLString.h"
|
|
#include "nsIComponentManager.h"
|
|
#include "nsIServiceManager.h"
|
|
#include "nsIDOMChromeWindow.h"
|
|
#include "nsXPCOM.h"
|
|
#include "nsISupportsPrimitives.h"
|
|
#include "nsIWindowWatcher.h"
|
|
#include "nsPIDOMWindow.h"
|
|
#include "nsGlobalWindow.h"
|
|
#include "nsIDocShell.h"
|
|
#include "nsIDocShellTreeItem.h"
|
|
#include "nsIBaseWindow.h"
|
|
#include "nsIWidget.h"
|
|
#include "nsIAppShellService.h"
|
|
#include "nsIXULWindow.h"
|
|
#include "nsIInterfaceRequestor.h"
|
|
#include "nsIInterfaceRequestorUtils.h"
|
|
#include "nsIPromptService.h"
|
|
#include "nsNetCID.h"
|
|
#include "nsNetUtil.h"
|
|
#include "mozilla/Services.h"
|
|
#include "nsIFile.h"
|
|
#include "nsIObserver.h"
|
|
#include "nsIObserverService.h"
|
|
#include "nsIDOMLocation.h"
|
|
#include "nsIWebNavigation.h"
|
|
#include "nsIWindowMediator.h"
|
|
#include "nsNativeCharsetUtils.h"
|
|
#include "nsIAppStartup.h"
|
|
|
|
#include <windows.h>
|
|
#include <shellapi.h>
|
|
#include <ddeml.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <io.h>
|
|
#include <direct.h>
|
|
#include <fcntl.h>
|
|
|
|
using namespace mozilla;
|
|
|
|
static HWND hwndForDOMWindow( nsISupports * );
|
|
|
|
static
|
|
nsresult
|
|
GetMostRecentWindow(const char16_t* aType, nsIDOMWindow** aWindow) {
|
|
nsresult rv;
|
|
nsCOMPtr<nsIWindowMediator> med( do_GetService( NS_WINDOWMEDIATOR_CONTRACTID, &rv ) );
|
|
if ( NS_FAILED( rv ) )
|
|
return rv;
|
|
|
|
if ( med )
|
|
return med->GetMostRecentWindow( aType, aWindow );
|
|
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
static
|
|
void
|
|
activateWindow( nsIDOMWindow *win ) {
|
|
// Try to get native window handle.
|
|
HWND hwnd = hwndForDOMWindow( win );
|
|
if ( hwnd ) {
|
|
// Restore the window if it is minimized.
|
|
if ( ::IsIconic( hwnd ) ) {
|
|
::ShowWindow( hwnd, SW_RESTORE );
|
|
}
|
|
// Use the OS call, if possible.
|
|
::SetForegroundWindow( hwnd );
|
|
} else {
|
|
// Use internal method.
|
|
nsCOMPtr<nsPIDOMWindow> piWin = do_QueryInterface(win);
|
|
piWin->Focus();
|
|
}
|
|
}
|
|
|
|
|
|
#ifdef DEBUG_law
|
|
#undef MOZ_DEBUG_DDE
|
|
#define MOZ_DEBUG_DDE 1
|
|
#endif
|
|
|
|
// Simple Win32 mutex wrapper.
|
|
struct Win32Mutex {
|
|
Win32Mutex( const char16_t *name )
|
|
: mName( name ),
|
|
mHandle( 0 ),
|
|
mState( -1 ) {
|
|
mHandle = CreateMutexW( 0, FALSE, mName.get() );
|
|
#if MOZ_DEBUG_DDE
|
|
printf( "CreateMutex error = 0x%08X\n", (int)GetLastError() );
|
|
#endif
|
|
}
|
|
~Win32Mutex() {
|
|
if ( mHandle ) {
|
|
// Make sure we release it if we own it.
|
|
Unlock();
|
|
|
|
BOOL rc = CloseHandle( mHandle );
|
|
#if MOZ_DEBUG_DDE
|
|
if ( !rc ) {
|
|
printf( "CloseHandle error = 0x%08X\n", (int)GetLastError() );
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
BOOL Lock( DWORD timeout ) {
|
|
if ( mHandle ) {
|
|
#if MOZ_DEBUG_DDE
|
|
printf( "Waiting (%d msec) for DDE mutex...\n", (int)timeout );
|
|
#endif
|
|
mState = WaitForSingleObject( mHandle, timeout );
|
|
#if MOZ_DEBUG_DDE
|
|
printf( "...wait complete, result = 0x%08X, GetLastError=0x%08X\n", (int)mState, (int)::GetLastError() );
|
|
#endif
|
|
return mState == WAIT_OBJECT_0 || mState == WAIT_ABANDONED;
|
|
} else {
|
|
return FALSE;
|
|
}
|
|
}
|
|
void Unlock() {
|
|
if ( mHandle && mState == WAIT_OBJECT_0 ) {
|
|
#if MOZ_DEBUG_DDE
|
|
printf( "Releasing DDE mutex\n" );
|
|
#endif
|
|
ReleaseMutex( mHandle );
|
|
mState = -1;
|
|
}
|
|
}
|
|
private:
|
|
nsString mName;
|
|
HANDLE mHandle;
|
|
DWORD mState;
|
|
};
|
|
|
|
/* DDE Notes
|
|
*
|
|
* This section describes the Win32 DDE service implementation for
|
|
* Mozilla. DDE is used on Win32 platforms to communicate between
|
|
* separate instances of mozilla.exe (or other Mozilla-based
|
|
* executables), or, between the Win32 desktop shell and Mozilla.
|
|
*
|
|
* The first instance of Mozilla will become the "server" and
|
|
* subsequent executables (and the shell) will use DDE to send
|
|
* requests to that process. The requests are DDE "execute" requests
|
|
* that pass the command line arguments.
|
|
*
|
|
* Mozilla registers the DDE application "Mozilla" and currently
|
|
* supports only the "WWW_OpenURL" topic. This should be reasonably
|
|
* compatible with applications that interfaced with Netscape
|
|
* Communicator (and its predecessors?). Note that even that topic
|
|
* may not be supported in a compatible fashion as the command-line
|
|
* options for Mozilla are different than for Communiator.
|
|
*
|
|
* It is imperative that at most one instance of Mozilla execute in
|
|
* "server mode" at any one time. The "native app support" in Mozilla
|
|
* on Win32 ensures that only the server process performs XPCOM
|
|
* initialization (that is not required for subsequent client processes
|
|
* to communicate with the server process).
|
|
*
|
|
* To guarantee that only one server starts up, a Win32 "mutex" is used
|
|
* to ensure only one process executes the server-detection code. That
|
|
* code consists of initializing DDE and doing a DdeConnect to Mozilla's
|
|
* application/topic. If that connection succeeds, then a server process
|
|
* must be running already.
|
|
*
|
|
* Otherwise, no server has started. In that case, the current process
|
|
* calls DdeNameService to register that application/topic. Only at that
|
|
* point does the mutex get released.
|
|
*
|
|
* There are a couple of subtleties that one should be aware of:
|
|
*
|
|
* 1. It is imperative that DdeInitialize be called only after the mutex
|
|
* lock has been obtained. The reason is that at shutdown, DDE
|
|
* notifications go out to all initialized DDE processes. Thus, if
|
|
* the mutex is owned by a terminating intance of Mozilla, then
|
|
* calling DdeInitialize and then WaitForSingleObject will cause the
|
|
* DdeUninitialize from the terminating process to "hang" until the
|
|
* process waiting for the mutex times out (and can then service the
|
|
* notification that the DDE server is terminating). So, don't mess
|
|
* with the sequence of things in the startup/shutdown logic.
|
|
*
|
|
* 2. All mutex requests are made with a reasonably long timeout value and
|
|
* are designed to "fail safe" (i.e., a timeout is treated as failure).
|
|
*
|
|
* 3. An attempt has been made to minimize the degree to which the main
|
|
* Mozilla application logic needs to be aware of the DDE mechanisms
|
|
* implemented herein. As a result, this module surfaces a very
|
|
* large-grained interface, consisting of simple start/stop methods.
|
|
* As a consequence, details of certain scenarios can be "lost."
|
|
* Particularly, incoming DDE requests can arrive after this module
|
|
* initiates the DDE server, but before Mozilla is initialized to the
|
|
* point where those requests can be serviced (e.g., open a browser
|
|
* window to a particular URL). Since the client process sends the
|
|
* request early on, it may not be prepared to respond to that error.
|
|
* Thus, such situations may fail silently. The design goal is that
|
|
* they fail harmlessly. Refinements on this point will be made as
|
|
* details emerge (and time permits).
|
|
*/
|
|
|
|
/* Update 2001 March
|
|
*
|
|
* A significant DDE bug in Windows is causing Mozilla to get wedged at
|
|
* startup. This is detailed in Bugzill bug 53952
|
|
* (http://bugzilla.mozilla.org/show_bug.cgi?id=53952).
|
|
*
|
|
* To resolve this, we are using a new strategy:
|
|
* o Use a "message window" to detect that Mozilla is already running and
|
|
* to pass requests from a second instance back to the first;
|
|
* o Run only as a "DDE server" (not as DDE client); this avoids the
|
|
* problematic call to DDEConnect().
|
|
*
|
|
* We still use the mutex semaphore to protect the code that detects
|
|
* whether Mozilla is already running.
|
|
*/
|
|
|
|
/* Update 2007 January
|
|
*
|
|
* A change in behavior was implemented in July 2004 which made the
|
|
* application on launch to add and on quit to remove the ddexec registry key.
|
|
* See bug 246078.
|
|
* Windows Vista has changed the methods used to set an application as default
|
|
* and the new methods are incompatible with removing the ddeexec registry key.
|
|
* See bug 353089.
|
|
*
|
|
* OS DDE Sequence:
|
|
* 1. OS checks if the dde name is registered.
|
|
* 2. If it is registered the OS sends a DDE request with the WWW_OpenURL topic
|
|
* and the params as specified in the default value of the ddeexec registry
|
|
* key for the verb (e.g. open).
|
|
* 3. If it isn't registered the OS launches the executable defined in the
|
|
* verb's (e.g. open) command registry key.
|
|
* 4. If the ifexec registry key is not present the OS sends a DDE request with
|
|
* the WWW_OpenURL topic and the params as specified in the default value of
|
|
* the ddeexec registry key for the verb (e.g. open).
|
|
* 5. If the ifexec registry key is present the OS sends a DDE request with the
|
|
* WWW_OpenURL topic and the params as specified in the ifexec registry key
|
|
* for the verb (e.g. open).
|
|
*
|
|
* Application DDE Sequence:
|
|
* 1. If the application is running a DDE request is received with the
|
|
* WWW_OpenURL topic and the params as specified in the default value of the
|
|
* ddeexec registry key (e.g. "%1",,0,0,,,, where '%1' is the url to open)
|
|
* for the verb (e.g. open).
|
|
* 2. If the application is not running it is launched with the --requestPending
|
|
* and the --url argument.
|
|
* 2.1 If the application does not need to restart and the --requestPending
|
|
* argument is present the accompanying url will not be used. Instead the
|
|
* application will wait for the DDE message to open the url.
|
|
* 2.2 If the application needs to restart the --requestPending argument is
|
|
* removed from the arguments used to restart the application and the url
|
|
* will be handled normally.
|
|
*
|
|
* Note: Due to a bug in IE the ifexec key should not be used (see bug 355650).
|
|
*/
|
|
|
|
class nsNativeAppSupportWin : public nsNativeAppSupportBase,
|
|
public nsIObserver
|
|
{
|
|
public:
|
|
NS_DECL_NSIOBSERVER
|
|
NS_DECL_ISUPPORTS_INHERITED
|
|
|
|
// Overrides of base implementation.
|
|
NS_IMETHOD Start( bool *aResult );
|
|
NS_IMETHOD Stop( bool *aResult );
|
|
NS_IMETHOD Quit();
|
|
NS_IMETHOD Enable();
|
|
// The "old" Start method (renamed).
|
|
NS_IMETHOD StartDDE();
|
|
// Utility function to handle a Win32-specific command line
|
|
// option: "--console", which dynamically creates a Windows
|
|
// console.
|
|
void CheckConsole();
|
|
|
|
private:
|
|
~nsNativeAppSupportWin() {}
|
|
static void HandleCommandLine(const char* aCmdLineString, nsIFile* aWorkingDir, uint32_t aState);
|
|
static HDDEDATA CALLBACK HandleDDENotification( UINT uType,
|
|
UINT uFmt,
|
|
HCONV hconv,
|
|
HSZ hsz1,
|
|
HSZ hsz2,
|
|
HDDEDATA hdata,
|
|
ULONG_PTR dwData1,
|
|
ULONG_PTR dwData2 );
|
|
static void ParseDDEArg( HSZ args, int index, nsString& string);
|
|
static void ParseDDEArg( const WCHAR* args, int index, nsString& aString);
|
|
static HDDEDATA CreateDDEData( DWORD value );
|
|
static HDDEDATA CreateDDEData( LPBYTE value, DWORD len );
|
|
static bool InitTopicStrings();
|
|
static int FindTopic( HSZ topic );
|
|
static void ActivateLastWindow();
|
|
static nsresult OpenWindow( const char *urlstr, const char *args );
|
|
static nsresult OpenBrowserWindow();
|
|
static void SetupSysTrayIcon();
|
|
static void RemoveSysTrayIcon();
|
|
|
|
static int mConversations;
|
|
enum {
|
|
topicOpenURL,
|
|
topicActivate,
|
|
topicCancelProgress,
|
|
topicVersion,
|
|
topicRegisterViewer,
|
|
topicUnRegisterViewer,
|
|
topicGetWindowInfo,
|
|
// Note: Insert new values above this line!!!!!
|
|
topicCount // Count of the number of real topics
|
|
};
|
|
static HSZ mApplication, mTopics[ topicCount ];
|
|
static DWORD mInstance;
|
|
static bool mCanHandleRequests;
|
|
static char16_t mMutexName[];
|
|
friend struct MessageWindow;
|
|
}; // nsNativeAppSupportWin
|
|
|
|
NS_INTERFACE_MAP_BEGIN(nsNativeAppSupportWin)
|
|
NS_INTERFACE_MAP_ENTRY(nsIObserver)
|
|
NS_INTERFACE_MAP_END_INHERITING(nsNativeAppSupportBase)
|
|
|
|
NS_IMPL_ADDREF_INHERITED(nsNativeAppSupportWin, nsNativeAppSupportBase)
|
|
NS_IMPL_RELEASE_INHERITED(nsNativeAppSupportWin, nsNativeAppSupportBase)
|
|
|
|
void
|
|
UseParentConsole()
|
|
{
|
|
// Try to attach console to the parent process.
|
|
// It will succeed when the parent process is a command line,
|
|
// so that stdio will be displayed in it.
|
|
if (AttachConsole(ATTACH_PARENT_PROCESS)) {
|
|
// Change std handles to refer to new console handles.
|
|
// Before doing so, ensure that stdout/stderr haven't been
|
|
// redirected to a valid file.
|
|
// The return value for _fileno(<a std handle>) for GUI apps was changed over.
|
|
// Until VC7, it was -1. Starting from VC8, it was changed to -2.
|
|
// http://msdn.microsoft.com/en-us/library/zs6wbdhx%28v=vs.80%29.aspx
|
|
// Starting from VC11, the return value was cahnged to 0 for stdin,
|
|
// 1 for stdout, 2 for stdout. Accroding to Microsoft, this is a bug
|
|
// which will be fixed in VC14.
|
|
// https://connect.microsoft.com/VisualStudio/feedback/details/785119/
|
|
// Although the document does not make it explicit, it looks like
|
|
// the return value from _get_osfhandle(_fileno(<a std handle>)) also
|
|
// changed to -2 and VC11 and 12 do not have a bug about _get_osfhandle().
|
|
// We support VC10 or later, so it's sufficient to compare the return
|
|
// value with -2.
|
|
if (_fileno(stdout) == -2 ||
|
|
_get_osfhandle(fileno(stdout)) == -2)
|
|
freopen("CONOUT$", "w", stdout);
|
|
// Merge stderr into CONOUT$ since there isn't any `CONERR$`.
|
|
// http://msdn.microsoft.com/en-us/library/windows/desktop/ms683231%28v=vs.85%29.aspx
|
|
if (_fileno(stderr) == -2 ||
|
|
_get_osfhandle(fileno(stderr)) == -2)
|
|
freopen("CONOUT$", "w", stderr);
|
|
if (_fileno(stdin) == -2 || _get_osfhandle(fileno(stdin)) == -2)
|
|
freopen("CONIN$", "r", stdin);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsNativeAppSupportWin::CheckConsole() {
|
|
for ( int i = 1; i < gArgc; i++ ) {
|
|
if ( strcmp( "-console", gArgv[i] ) == 0 ||
|
|
strcmp( "--console", gArgv[i] ) == 0 ||
|
|
strcmp( "/console", gArgv[i] ) == 0 ) {
|
|
// Users wants to make sure we have a console.
|
|
// Try to allocate one.
|
|
BOOL rc = ::AllocConsole();
|
|
if ( rc ) {
|
|
// Console allocated. Fix it up so that output works in
|
|
// all cases. See http://support.microsoft.com/support/kb/articles/q105/3/05.asp.
|
|
|
|
// stdout
|
|
int hCrt = ::_open_osfhandle( (intptr_t)GetStdHandle( STD_OUTPUT_HANDLE ),
|
|
_O_TEXT );
|
|
if ( hCrt != -1 ) {
|
|
FILE *hf = ::_fdopen( hCrt, "w" );
|
|
if ( hf ) {
|
|
*stdout = *hf;
|
|
#ifdef DEBUG
|
|
::fprintf( stdout, "stdout directed to dynamic console\n" );
|
|
#endif
|
|
}
|
|
}
|
|
|
|
// stderr
|
|
hCrt = ::_open_osfhandle( (intptr_t)::GetStdHandle( STD_ERROR_HANDLE ),
|
|
_O_TEXT );
|
|
if ( hCrt != -1 ) {
|
|
FILE *hf = ::_fdopen( hCrt, "w" );
|
|
if ( hf ) {
|
|
*stderr = *hf;
|
|
#ifdef DEBUG
|
|
::fprintf( stderr, "stderr directed to dynamic console\n" );
|
|
#endif
|
|
}
|
|
}
|
|
|
|
// stdin?
|
|
/* Don't bother for now.
|
|
hCrt = ::_open_osfhandle( (long)::GetStdHandle( STD_INPUT_HANDLE ),
|
|
_O_TEXT );
|
|
if ( hCrt != -1 ) {
|
|
FILE *hf = ::_fdopen( hCrt, "r" );
|
|
if ( hf ) {
|
|
*stdin = *hf;
|
|
}
|
|
}
|
|
*/
|
|
} else {
|
|
// Failed. Probably because there already is one.
|
|
// There's little we can do, in any case.
|
|
}
|
|
// Remove the console argument from the command line.
|
|
do {
|
|
gArgv[i] = gArgv[i + 1];
|
|
++i;
|
|
} while (gArgv[i]);
|
|
|
|
--gArgc;
|
|
|
|
} else if ( strcmp( "-attach-console", gArgv[i] ) == 0
|
|
||
|
|
strcmp( "/attach-console", gArgv[i] ) == 0 ) {
|
|
UseParentConsole();
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
// Create and return an instance of class nsNativeAppSupportWin.
|
|
nsresult
|
|
NS_CreateNativeAppSupport( nsINativeAppSupport **aResult ) {
|
|
nsNativeAppSupportWin *pNative = new nsNativeAppSupportWin;
|
|
if (!pNative) return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
// Check for dynamic console creation request.
|
|
pNative->CheckConsole();
|
|
|
|
*aResult = pNative;
|
|
NS_ADDREF( *aResult );
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
// Constants
|
|
#define MOZ_DDE_APPLICATION "Mozilla"
|
|
#define MOZ_MUTEX_NAMESPACE L"Local\\"
|
|
#define MOZ_STARTUP_MUTEX_NAME L"StartupMutex"
|
|
#define MOZ_DDE_START_TIMEOUT 30000
|
|
#define MOZ_DDE_STOP_TIMEOUT 15000
|
|
#define MOZ_DDE_EXEC_TIMEOUT 15000
|
|
|
|
// The array entries must match the enum ordering!
|
|
const char * const topicNames[] = { "WWW_OpenURL",
|
|
"WWW_Activate",
|
|
"WWW_CancelProgress",
|
|
"WWW_Version",
|
|
"WWW_RegisterViewer",
|
|
"WWW_UnRegisterViewer",
|
|
"WWW_GetWindowInfo" };
|
|
|
|
// Static member definitions.
|
|
int nsNativeAppSupportWin::mConversations = 0;
|
|
HSZ nsNativeAppSupportWin::mApplication = 0;
|
|
HSZ nsNativeAppSupportWin::mTopics[nsNativeAppSupportWin::topicCount] = { 0 };
|
|
DWORD nsNativeAppSupportWin::mInstance = 0;
|
|
bool nsNativeAppSupportWin::mCanHandleRequests = false;
|
|
|
|
char16_t nsNativeAppSupportWin::mMutexName[ 128 ] = { 0 };
|
|
|
|
|
|
// Message window encapsulation.
|
|
struct MessageWindow {
|
|
// ctor/dtor are simplistic
|
|
MessageWindow() {
|
|
// Try to find window.
|
|
mHandle = ::FindWindowW( className(), 0 );
|
|
}
|
|
|
|
// Act like an HWND.
|
|
operator HWND() {
|
|
return mHandle;
|
|
}
|
|
|
|
// Class name: appName + "MessageWindow"
|
|
static const wchar_t *className() {
|
|
static wchar_t classNameBuffer[128];
|
|
static wchar_t *mClassName = 0;
|
|
if ( !mClassName ) {
|
|
::_snwprintf(classNameBuffer,
|
|
128, // size of classNameBuffer in PRUnichars
|
|
L"%s%s",
|
|
NS_ConvertUTF8toUTF16(gAppData->remotingName).get(),
|
|
L"MessageWindow" );
|
|
mClassName = classNameBuffer;
|
|
}
|
|
return mClassName;
|
|
}
|
|
|
|
// Create: Register class and create window.
|
|
NS_IMETHOD Create() {
|
|
WNDCLASSW classStruct = { 0, // style
|
|
&MessageWindow::WindowProc, // lpfnWndProc
|
|
0, // cbClsExtra
|
|
0, // cbWndExtra
|
|
0, // hInstance
|
|
0, // hIcon
|
|
0, // hCursor
|
|
0, // hbrBackground
|
|
0, // lpszMenuName
|
|
className() }; // lpszClassName
|
|
|
|
// Register the window class.
|
|
NS_ENSURE_TRUE( ::RegisterClassW( &classStruct ), NS_ERROR_FAILURE );
|
|
|
|
// Create the window.
|
|
NS_ENSURE_TRUE( ( mHandle = ::CreateWindowW(className(),
|
|
0, // title
|
|
WS_CAPTION, // style
|
|
0,0,0,0, // x, y, cx, cy
|
|
0, // parent
|
|
0, // menu
|
|
0, // instance
|
|
0 ) ), // create struct
|
|
NS_ERROR_FAILURE );
|
|
|
|
#if MOZ_DEBUG_DDE
|
|
printf( "Message window = 0x%08X\n", (int)mHandle );
|
|
#endif
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
// Destory: Get rid of window and reset mHandle.
|
|
NS_IMETHOD Destroy() {
|
|
nsresult retval = NS_OK;
|
|
|
|
if ( mHandle ) {
|
|
// DestroyWindow can only destroy windows created from
|
|
// the same thread.
|
|
BOOL desRes = DestroyWindow( mHandle );
|
|
if ( FALSE != desRes ) {
|
|
mHandle = nullptr;
|
|
}
|
|
else {
|
|
retval = NS_ERROR_FAILURE;
|
|
}
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
// SendRequest: Pass the command line via WM_COPYDATA to message window.
|
|
NS_IMETHOD SendRequest() {
|
|
WCHAR *cmd = ::GetCommandLineW();
|
|
WCHAR cwd[MAX_PATH];
|
|
_wgetcwd(cwd, MAX_PATH);
|
|
|
|
// Construct a narrow UTF8 buffer <commandline>\0<workingdir>\0
|
|
NS_ConvertUTF16toUTF8 utf8buffer(cmd);
|
|
utf8buffer.Append('\0');
|
|
AppendUTF16toUTF8(cwd, utf8buffer);
|
|
utf8buffer.Append('\0');
|
|
|
|
// We used to set dwData to zero, when we didn't send the working dir.
|
|
// Now we're using it as a version number.
|
|
COPYDATASTRUCT cds = {
|
|
1,
|
|
utf8buffer.Length(),
|
|
(void*) utf8buffer.get()
|
|
};
|
|
// Bring the already running Mozilla process to the foreground.
|
|
// nsWindow will restore the window (if minimized) and raise it.
|
|
::SetForegroundWindow( mHandle );
|
|
::SendMessage( mHandle, WM_COPYDATA, 0, (LPARAM)&cds );
|
|
return NS_OK;
|
|
}
|
|
|
|
// Window proc.
|
|
static LRESULT CALLBACK WindowProc( HWND msgWindow, UINT msg, WPARAM wp, LPARAM lp ) {
|
|
if ( msg == WM_COPYDATA ) {
|
|
if (!nsNativeAppSupportWin::mCanHandleRequests)
|
|
return FALSE;
|
|
|
|
// This is an incoming request.
|
|
COPYDATASTRUCT *cds = (COPYDATASTRUCT*)lp;
|
|
#if MOZ_DEBUG_DDE
|
|
printf( "Incoming request: %s\n", (const char*)cds->lpData );
|
|
#endif
|
|
nsCOMPtr<nsIFile> workingDir;
|
|
|
|
if (1 >= cds->dwData) {
|
|
char* wdpath = (char*) cds->lpData;
|
|
// skip the command line, and get the working dir of the
|
|
// other process, which is after the first null char
|
|
while (*wdpath)
|
|
++wdpath;
|
|
|
|
++wdpath;
|
|
|
|
#ifdef MOZ_DEBUG_DDE
|
|
printf( "Working dir: %s\n", wdpath);
|
|
#endif
|
|
|
|
NS_NewLocalFile(NS_ConvertUTF8toUTF16(wdpath),
|
|
false,
|
|
getter_AddRefs(workingDir));
|
|
}
|
|
(void)nsNativeAppSupportWin::HandleCommandLine((char*)cds->lpData, workingDir, nsICommandLine::STATE_REMOTE_AUTO);
|
|
|
|
// Get current window and return its window handle.
|
|
nsCOMPtr<nsIDOMWindow> win;
|
|
GetMostRecentWindow( 0, getter_AddRefs( win ) );
|
|
return win ? (LRESULT)hwndForDOMWindow( win ) : 0;
|
|
}
|
|
return DefWindowProc( msgWindow, msg, wp, lp );
|
|
}
|
|
|
|
private:
|
|
HWND mHandle;
|
|
}; // struct MessageWindow
|
|
|
|
/* Start: Tries to find the "message window" to determine if it
|
|
* exists. If so, then Mozilla is already running. In that
|
|
* case, we use the handle to the "message" window and send
|
|
* a request corresponding to this process's command line
|
|
* options.
|
|
*
|
|
* If not, then this is the first instance of Mozilla. In
|
|
* that case, we create and set up the message window.
|
|
*
|
|
* The checking for existence of the message window must
|
|
* be protected by use of a mutex semaphore.
|
|
*/
|
|
NS_IMETHODIMP
|
|
nsNativeAppSupportWin::Start( bool *aResult ) {
|
|
NS_ENSURE_ARG( aResult );
|
|
NS_ENSURE_TRUE( mInstance == 0, NS_ERROR_NOT_INITIALIZED );
|
|
NS_ENSURE_STATE( gAppData );
|
|
|
|
if (getenv("MOZ_NO_REMOTE"))
|
|
{
|
|
*aResult = true;
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult rv = NS_ERROR_FAILURE;
|
|
*aResult = false;
|
|
|
|
// Grab mutex first.
|
|
|
|
// Build mutex name from app name.
|
|
::_snwprintf(reinterpret_cast<wchar_t*>(mMutexName),
|
|
sizeof mMutexName / sizeof(char16_t), L"%s%s%s",
|
|
MOZ_MUTEX_NAMESPACE,
|
|
NS_ConvertUTF8toUTF16(gAppData->name).get(),
|
|
MOZ_STARTUP_MUTEX_NAME );
|
|
Win32Mutex startupLock = Win32Mutex( mMutexName );
|
|
|
|
NS_ENSURE_TRUE( startupLock.Lock( MOZ_DDE_START_TIMEOUT ), NS_ERROR_FAILURE );
|
|
|
|
// Search for existing message window.
|
|
MessageWindow msgWindow;
|
|
if ( (HWND)msgWindow ) {
|
|
// We are a client process. Pass request to message window.
|
|
rv = msgWindow.SendRequest();
|
|
} else {
|
|
// We will be server.
|
|
rv = msgWindow.Create();
|
|
if ( NS_SUCCEEDED( rv ) ) {
|
|
// Start up DDE server.
|
|
this->StartDDE();
|
|
// Tell caller to spin message loop.
|
|
*aResult = true;
|
|
}
|
|
}
|
|
|
|
startupLock.Unlock();
|
|
|
|
return rv;
|
|
}
|
|
|
|
bool
|
|
nsNativeAppSupportWin::InitTopicStrings() {
|
|
for ( int i = 0; i < topicCount; i++ ) {
|
|
if ( !( mTopics[ i ] = DdeCreateStringHandleA( mInstance, const_cast<char *>(topicNames[ i ]), CP_WINANSI ) ) ) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
int
|
|
nsNativeAppSupportWin::FindTopic( HSZ topic ) {
|
|
for ( int i = 0; i < topicCount; i++ ) {
|
|
if ( DdeCmpStringHandles( topic, mTopics[i] ) == 0 ) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
|
|
// Start DDE server.
|
|
//
|
|
// This used to be the Start() method when we were using DDE as the
|
|
// primary IPC mechanism between secondary Mozilla processes and the
|
|
// initial "server" process.
|
|
//
|
|
// Now, it simply initializes the DDE server. The caller must check
|
|
// that this process is to be the server, and, must acquire the DDE
|
|
// startup mutex semaphore prior to calling this routine. See ::Start(),
|
|
// above.
|
|
NS_IMETHODIMP
|
|
nsNativeAppSupportWin::StartDDE() {
|
|
NS_ENSURE_TRUE( mInstance == 0, NS_ERROR_NOT_INITIALIZED );
|
|
|
|
// Initialize DDE.
|
|
NS_ENSURE_TRUE( DMLERR_NO_ERROR == DdeInitialize( &mInstance,
|
|
nsNativeAppSupportWin::HandleDDENotification,
|
|
APPCLASS_STANDARD,
|
|
0 ),
|
|
NS_ERROR_FAILURE );
|
|
|
|
// Allocate DDE strings.
|
|
NS_ENSURE_TRUE( ( mApplication = DdeCreateStringHandleA( mInstance, (char*) gAppData->name, CP_WINANSI ) ) && InitTopicStrings(),
|
|
NS_ERROR_FAILURE );
|
|
|
|
// Next step is to register a DDE service.
|
|
NS_ENSURE_TRUE( DdeNameService( mInstance, mApplication, 0, DNS_REGISTER ), NS_ERROR_FAILURE );
|
|
|
|
#if MOZ_DEBUG_DDE
|
|
printf( "DDE server started\n" );
|
|
#endif
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
// If no DDE conversations are pending, terminate DDE.
|
|
NS_IMETHODIMP
|
|
nsNativeAppSupportWin::Stop( bool *aResult ) {
|
|
NS_ENSURE_ARG( aResult );
|
|
NS_ENSURE_TRUE( mInstance, NS_ERROR_NOT_INITIALIZED );
|
|
|
|
nsresult rv = NS_OK;
|
|
*aResult = true;
|
|
|
|
Win32Mutex ddeLock( mMutexName );
|
|
|
|
if ( ddeLock.Lock( MOZ_DDE_STOP_TIMEOUT ) ) {
|
|
if ( mConversations == 0 ) {
|
|
this->Quit();
|
|
} else {
|
|
*aResult = false;
|
|
}
|
|
|
|
ddeLock.Unlock();
|
|
}
|
|
else {
|
|
// No DDE application name specified, but that's OK. Just
|
|
// forge ahead.
|
|
*aResult = true;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsNativeAppSupportWin::Observe(nsISupports* aSubject, const char* aTopic,
|
|
const char16_t* aData)
|
|
{
|
|
if (strcmp(aTopic, "quit-application") == 0) {
|
|
Quit();
|
|
} else {
|
|
NS_ERROR("Unexpected observer topic.");
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
// Terminate DDE regardless.
|
|
NS_IMETHODIMP
|
|
nsNativeAppSupportWin::Quit() {
|
|
// If another process wants to look for the message window, they need
|
|
// to wait to hold the lock, in which case they will not find the
|
|
// window as we will destroy ours under our lock.
|
|
// When the mutex goes off the stack, it is unlocked via destructor.
|
|
Win32Mutex mutexLock(mMutexName);
|
|
NS_ENSURE_TRUE(mutexLock.Lock(MOZ_DDE_START_TIMEOUT), NS_ERROR_FAILURE);
|
|
|
|
// If we've got a message window to receive IPC or new window requests,
|
|
// get rid of it as we are shutting down.
|
|
// Note: Destroy calls DestroyWindow, which will only work on a window
|
|
// created by the same thread.
|
|
MessageWindow mw;
|
|
mw.Destroy();
|
|
|
|
if ( mInstance ) {
|
|
// Unregister application name.
|
|
DdeNameService( mInstance, mApplication, 0, DNS_UNREGISTER );
|
|
// Clean up strings.
|
|
if ( mApplication ) {
|
|
DdeFreeStringHandle( mInstance, mApplication );
|
|
mApplication = 0;
|
|
}
|
|
for ( int i = 0; i < topicCount; i++ ) {
|
|
if ( mTopics[i] ) {
|
|
DdeFreeStringHandle( mInstance, mTopics[i] );
|
|
mTopics[i] = 0;
|
|
}
|
|
}
|
|
DdeUninitialize( mInstance );
|
|
mInstance = 0;
|
|
#if MOZ_DEBUG_DDE
|
|
printf( "DDE server stopped\n" );
|
|
#endif
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsNativeAppSupportWin::Enable()
|
|
{
|
|
mCanHandleRequests = true;
|
|
|
|
nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
|
|
if (obs) {
|
|
obs->AddObserver(this, "quit-application", false);
|
|
} else {
|
|
NS_ERROR("No observer service?");
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
#if MOZ_DEBUG_DDE
|
|
// Macro to generate case statement for a given XTYP value.
|
|
#define XTYP_CASE(t) \
|
|
case t: result = #t; break
|
|
|
|
static nsCString uTypeDesc( UINT uType ) {
|
|
nsCString result;
|
|
switch ( uType ) {
|
|
XTYP_CASE(XTYP_ADVSTART);
|
|
XTYP_CASE(XTYP_CONNECT);
|
|
XTYP_CASE(XTYP_ADVREQ);
|
|
XTYP_CASE(XTYP_REQUEST);
|
|
XTYP_CASE(XTYP_WILDCONNECT);
|
|
XTYP_CASE(XTYP_ADVDATA);
|
|
XTYP_CASE(XTYP_EXECUTE);
|
|
XTYP_CASE(XTYP_POKE);
|
|
XTYP_CASE(XTYP_ADVSTOP);
|
|
XTYP_CASE(XTYP_CONNECT_CONFIRM);
|
|
XTYP_CASE(XTYP_DISCONNECT);
|
|
XTYP_CASE(XTYP_ERROR);
|
|
XTYP_CASE(XTYP_MONITOR);
|
|
XTYP_CASE(XTYP_REGISTER);
|
|
XTYP_CASE(XTYP_XACT_COMPLETE);
|
|
XTYP_CASE(XTYP_UNREGISTER);
|
|
default: result = "XTYP_?????";
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static nsCString hszValue( DWORD instance, HSZ hsz ) {
|
|
// Extract string from HSZ.
|
|
nsCString result("[");
|
|
DWORD len = DdeQueryString( instance, hsz, nullptr, nullptr, CP_WINANSI );
|
|
if ( len ) {
|
|
char buffer[ 256 ];
|
|
DdeQueryString( instance, hsz, buffer, sizeof buffer, CP_WINANSI );
|
|
result += buffer;
|
|
}
|
|
result += "]";
|
|
return result;
|
|
}
|
|
#else
|
|
// These are purely a safety measure to avoid the infamous "won't
|
|
// build non-debug" type Tinderbox flames.
|
|
static nsCString uTypeDesc( UINT ) {
|
|
return nsCString( "?" );
|
|
}
|
|
static nsCString hszValue( DWORD, HSZ ) {
|
|
return nsCString( "?" );
|
|
}
|
|
#endif
|
|
|
|
|
|
// Utility function to escape double-quotes within a string.
|
|
static void escapeQuotes( nsAString &aString ) {
|
|
int32_t offset = -1;
|
|
while( 1 ) {
|
|
// Find next '"'.
|
|
offset = aString.FindChar( '"', ++offset );
|
|
if ( offset == kNotFound ) {
|
|
// No more quotes, exit.
|
|
break;
|
|
} else {
|
|
// Insert back-slash ahead of the '"'.
|
|
aString.Insert( char16_t('\\'), offset );
|
|
// Increment offset because we just inserted a slash
|
|
offset++;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
HDDEDATA CALLBACK
|
|
nsNativeAppSupportWin::HandleDDENotification( UINT uType, // transaction type
|
|
UINT uFmt, // clipboard data format
|
|
HCONV hconv, // handle to the conversation
|
|
HSZ hsz1, // handle to a string
|
|
HSZ hsz2, // handle to a string
|
|
HDDEDATA hdata, // handle to a global memory object
|
|
ULONG_PTR dwData1, // transaction-specific data
|
|
ULONG_PTR dwData2 ) { // transaction-specific data
|
|
|
|
if (!mCanHandleRequests)
|
|
return 0;
|
|
|
|
|
|
#if MOZ_DEBUG_DDE
|
|
printf( "DDE: uType =%s\n", uTypeDesc( uType ).get() );
|
|
printf( " uFmt =%u\n", (unsigned)uFmt );
|
|
printf( " hconv =%08x\n", (int)hconv );
|
|
printf( " hsz1 =%08x:%s\n", (int)hsz1, hszValue( mInstance, hsz1 ).get() );
|
|
printf( " hsz2 =%08x:%s\n", (int)hsz2, hszValue( mInstance, hsz2 ).get() );
|
|
printf( " hdata =%08x\n", (int)hdata );
|
|
printf( " dwData1=%08x\n", (int)dwData1 );
|
|
printf( " dwData2=%08x\n", (int)dwData2 );
|
|
#endif
|
|
|
|
HDDEDATA result = 0;
|
|
if ( uType & XCLASS_BOOL ) {
|
|
switch ( uType ) {
|
|
case XTYP_CONNECT:
|
|
// Make sure its for our service/topic.
|
|
if ( FindTopic( hsz1 ) != -1 ) {
|
|
// We support this connection.
|
|
result = (HDDEDATA)1;
|
|
}
|
|
break;
|
|
case XTYP_CONNECT_CONFIRM:
|
|
// We don't care about the conversation handle, at this point.
|
|
result = (HDDEDATA)1;
|
|
break;
|
|
}
|
|
} else if ( uType & XCLASS_DATA ) {
|
|
if ( uType == XTYP_REQUEST ) {
|
|
switch ( FindTopic( hsz1 ) ) {
|
|
case topicOpenURL: {
|
|
// Open a given URL...
|
|
|
|
// Get the URL from the first argument in the command.
|
|
nsAutoString url;
|
|
ParseDDEArg(hsz2, 0, url);
|
|
|
|
// Read the 3rd argument in the command to determine if a
|
|
// new window is to be used.
|
|
nsAutoString windowID;
|
|
ParseDDEArg(hsz2, 2, windowID);
|
|
// "" means to open the URL in a new window.
|
|
if ( windowID.IsEmpty() ) {
|
|
url.Insert(NS_LITERAL_STRING("mozilla -new-window "), 0);
|
|
}
|
|
else {
|
|
url.Insert(NS_LITERAL_STRING("mozilla -url "), 0);
|
|
}
|
|
|
|
#if MOZ_DEBUG_DDE
|
|
printf( "Handling dde XTYP_REQUEST request: [%s]...\n", NS_ConvertUTF16toUTF8(url).get() );
|
|
#endif
|
|
// Now handle it.
|
|
HandleCommandLine(NS_ConvertUTF16toUTF8(url).get(), nullptr, nsICommandLine::STATE_REMOTE_EXPLICIT);
|
|
|
|
// Return pseudo window ID.
|
|
result = CreateDDEData( 1 );
|
|
break;
|
|
}
|
|
case topicGetWindowInfo: {
|
|
// This topic has to get the current URL, get the current
|
|
// page title and then format the output into the DDE
|
|
// return string. The return value is "URL","Page Title",
|
|
// "Window ID" however the window ID is not used for this
|
|
// command, therefore it is returned as a null string
|
|
|
|
// This isn't really a loop. We just use "break"
|
|
// statements to bypass the remaining steps when
|
|
// something goes wrong.
|
|
do {
|
|
// Get most recently used Nav window.
|
|
nsCOMPtr<nsIDOMWindow> navWin;
|
|
GetMostRecentWindow( NS_LITERAL_STRING( "navigator:browser" ).get(),
|
|
getter_AddRefs( navWin ) );
|
|
nsCOMPtr<nsPIDOMWindow> piNavWin = do_QueryInterface(navWin);
|
|
if ( !piNavWin ) {
|
|
// There is not a window open
|
|
break;
|
|
}
|
|
|
|
// Get content window.
|
|
nsCOMPtr<nsIDOMWindow> internalContent_ = nsGlobalWindow::Cast(piNavWin)->GetContent();
|
|
nsCOMPtr<nsPIDOMWindow> internalContent = do_QueryInterface(internalContent_);
|
|
if ( !internalContent ) {
|
|
break;
|
|
}
|
|
// Get location.
|
|
nsCOMPtr<nsIDOMLocation> location = internalContent->GetLocation();
|
|
if ( !location ) {
|
|
break;
|
|
}
|
|
// Get href for URL.
|
|
nsAutoString url;
|
|
if ( NS_FAILED( location->GetHref( url ) ) ) {
|
|
break;
|
|
}
|
|
// Escape any double-quotes.
|
|
escapeQuotes( url );
|
|
|
|
// Now for the title...
|
|
|
|
// Get the base window from the doc shell...
|
|
nsCOMPtr<nsIBaseWindow> baseWindow =
|
|
do_QueryInterface( internalContent->GetDocShell() );
|
|
if ( !baseWindow ) {
|
|
break;
|
|
}
|
|
// And from the base window we can get the title.
|
|
nsXPIDLString title;
|
|
if(!baseWindow) {
|
|
break;
|
|
}
|
|
baseWindow->GetTitle(getter_Copies(title));
|
|
// Escape any double-quotes in the title.
|
|
escapeQuotes( title );
|
|
|
|
// Use a string buffer for the output data, first
|
|
// save a quote.
|
|
nsAutoCString outpt( NS_LITERAL_CSTRING("\"") );
|
|
// Now copy the URL converting the Unicode string
|
|
// to a single-byte ASCII string
|
|
nsAutoCString tmpNativeStr;
|
|
NS_CopyUnicodeToNative( url, tmpNativeStr );
|
|
outpt.Append( tmpNativeStr );
|
|
// Add the "," used to separate the URL and the page
|
|
// title
|
|
outpt.Append( NS_LITERAL_CSTRING("\",\"") );
|
|
// Now copy the current page title to the return string
|
|
NS_CopyUnicodeToNative( title, tmpNativeStr );
|
|
outpt.Append( tmpNativeStr );
|
|
// Fill out the return string with the remainin ",""
|
|
outpt.Append( NS_LITERAL_CSTRING( "\",\"\"" ));
|
|
|
|
// Create a DDE handle to a char string for the data
|
|
// being returned, this copies and creates a "shared"
|
|
// copy of the DDE response until the calling APP
|
|
// reads it and says it can be freed.
|
|
result = CreateDDEData( (LPBYTE)(const char*)outpt.get(),
|
|
outpt.Length() + 1 );
|
|
#if MOZ_DEBUG_DDE
|
|
printf( "WWW_GetWindowInfo->%s\n", outpt.get() );
|
|
#endif
|
|
} while ( false );
|
|
break;
|
|
}
|
|
case topicActivate: {
|
|
// Activate a Nav window...
|
|
nsAutoString windowID;
|
|
ParseDDEArg(hsz2, 0, windowID);
|
|
// 4294967295 is decimal for 0xFFFFFFFF which is also a
|
|
// correct value to do that Activate last window stuff
|
|
if ( windowID.EqualsLiteral( "-1" ) ||
|
|
windowID.EqualsLiteral( "4294967295" ) ) {
|
|
// We only support activating the most recent window (or a new one).
|
|
ActivateLastWindow();
|
|
// Return pseudo window ID.
|
|
result = CreateDDEData( 1 );
|
|
}
|
|
break;
|
|
}
|
|
case topicVersion: {
|
|
// Return version. We're restarting at 1.0!
|
|
DWORD version = 1 << 16; // "1.0"
|
|
result = CreateDDEData( version );
|
|
break;
|
|
}
|
|
case topicRegisterViewer: {
|
|
// Register new viewer (not implemented).
|
|
result = CreateDDEData( false );
|
|
break;
|
|
}
|
|
case topicUnRegisterViewer: {
|
|
// Unregister new viewer (not implemented).
|
|
result = CreateDDEData( false );
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
} else if ( uType & XTYP_POKE ) {
|
|
switch ( FindTopic( hsz1 ) ) {
|
|
case topicCancelProgress: {
|
|
// "Handle" progress cancel (actually, pretty much ignored).
|
|
result = (HDDEDATA)DDE_FACK;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
} else if ( uType & XCLASS_FLAGS ) {
|
|
if ( uType == XTYP_EXECUTE ) {
|
|
// Prove that we received the request.
|
|
DWORD bytes;
|
|
LPBYTE request = DdeAccessData( hdata, &bytes );
|
|
#if MOZ_DEBUG_DDE
|
|
printf( "Handling dde request: [%s]...\n", (char*)request );
|
|
#endif
|
|
|
|
nsAutoString url;
|
|
ParseDDEArg((const WCHAR*) request, 0, url);
|
|
|
|
// Read the 3rd argument in the command to determine if a
|
|
// new window is to be used.
|
|
nsAutoString windowID;
|
|
ParseDDEArg((const WCHAR*) request, 2, windowID);
|
|
|
|
// "" means to open the URL in a new window.
|
|
if ( windowID.IsEmpty() ) {
|
|
url.Insert(NS_LITERAL_STRING("mozilla -new-window "), 0);
|
|
}
|
|
else {
|
|
url.Insert(NS_LITERAL_STRING("mozilla -url "), 0);
|
|
}
|
|
#if MOZ_DEBUG_DDE
|
|
printf( "Handling dde XTYP_REQUEST request: [%s]...\n", NS_ConvertUTF16toUTF8(url).get() );
|
|
#endif
|
|
// Now handle it.
|
|
HandleCommandLine(NS_ConvertUTF16toUTF8(url).get(), nullptr, nsICommandLine::STATE_REMOTE_EXPLICIT);
|
|
|
|
// Release the data.
|
|
DdeUnaccessData( hdata );
|
|
result = (HDDEDATA)DDE_FACK;
|
|
} else {
|
|
result = (HDDEDATA)DDE_FNOTPROCESSED;
|
|
}
|
|
} else if ( uType & XCLASS_NOTIFICATION ) {
|
|
}
|
|
#if MOZ_DEBUG_DDE
|
|
printf( "DDE result=%d (0x%08X)\n", (int)result, (int)result );
|
|
#endif
|
|
return result;
|
|
}
|
|
|
|
// Utility function to advance to end of quoted string.
|
|
// p+offset must point to the comma preceding the arg on entry.
|
|
// On return, p+result points to the closing '"' (or end of the string
|
|
// if the closing '"' is missing) if the arg is quoted. If the arg
|
|
// is not quoted, then p+result will point to the first character
|
|
// of the arg.
|
|
static int32_t advanceToEndOfQuotedArg( const WCHAR *p, int32_t offset, int32_t len ) {
|
|
// Check whether the current arg is quoted.
|
|
if ( p[++offset] == '"' ) {
|
|
// Advance past the closing quote.
|
|
while ( offset < len && p[++offset] != '"' ) {
|
|
// If the current character is a backslash, then the
|
|
// next character can't be a *real* '"', so skip it.
|
|
if ( p[offset] == '\\' ) {
|
|
offset++;
|
|
}
|
|
}
|
|
}
|
|
return offset;
|
|
}
|
|
|
|
void nsNativeAppSupportWin::ParseDDEArg( const WCHAR* args, int index, nsString& aString) {
|
|
if ( args ) {
|
|
nsDependentString temp(args);
|
|
|
|
// offset points to the comma preceding the desired arg.
|
|
int32_t offset = -1;
|
|
// Skip commas till we get to the arg we want.
|
|
while( index-- ) {
|
|
// If this arg is quoted, then go to closing quote.
|
|
offset = advanceToEndOfQuotedArg( args, offset, temp.Length());
|
|
// Find next comma.
|
|
offset = temp.FindChar( ',', offset );
|
|
if ( offset == kNotFound ) {
|
|
// No more commas, give up.
|
|
aString = args;
|
|
return;
|
|
}
|
|
}
|
|
// The desired argument starts just past the preceding comma,
|
|
// which offset points to, and extends until the following
|
|
// comma (or the end of the string).
|
|
//
|
|
// Since the argument might be enclosed in quotes, we need to
|
|
// deal with that before searching for the terminating comma.
|
|
// We advance offset so it ends up pointing to the start of
|
|
// the argument we want.
|
|
int32_t end = advanceToEndOfQuotedArg( args, offset++, temp.Length() );
|
|
// Find next comma (or end of string).
|
|
end = temp.FindChar( ',', end );
|
|
if ( end == kNotFound ) {
|
|
// Arg is the rest of the string.
|
|
end = temp.Length();
|
|
}
|
|
// Extract result.
|
|
aString.Assign( args + offset, end - offset );
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Utility to parse out argument from a DDE item string.
|
|
void nsNativeAppSupportWin::ParseDDEArg( HSZ args, int index, nsString& aString) {
|
|
DWORD argLen = DdeQueryStringW( mInstance, args, nullptr, 0, CP_WINUNICODE );
|
|
// there wasn't any string, so return empty string
|
|
if ( !argLen ) return;
|
|
nsAutoString temp;
|
|
// Ensure result's buffer is sufficiently big.
|
|
temp.SetLength( argLen );
|
|
// Now get the string contents.
|
|
DdeQueryString( mInstance, args, reinterpret_cast<wchar_t*>(temp.BeginWriting()), temp.Length(), CP_WINUNICODE );
|
|
// Parse out the given arg.
|
|
ParseDDEArg(temp.get(), index, aString);
|
|
return;
|
|
}
|
|
|
|
HDDEDATA nsNativeAppSupportWin::CreateDDEData( DWORD value ) {
|
|
return CreateDDEData( (LPBYTE)&value, sizeof value );
|
|
}
|
|
|
|
HDDEDATA nsNativeAppSupportWin::CreateDDEData( LPBYTE value, DWORD len ) {
|
|
HDDEDATA result = DdeCreateDataHandle( mInstance,
|
|
value,
|
|
len,
|
|
0,
|
|
mApplication,
|
|
CF_TEXT,
|
|
0 );
|
|
return result;
|
|
}
|
|
|
|
void nsNativeAppSupportWin::ActivateLastWindow() {
|
|
nsCOMPtr<nsIDOMWindow> navWin;
|
|
GetMostRecentWindow( MOZ_UTF16("navigator:browser"), getter_AddRefs( navWin ) );
|
|
if ( navWin ) {
|
|
// Activate that window.
|
|
activateWindow( navWin );
|
|
} else {
|
|
// Need to create a Navigator window, then.
|
|
OpenBrowserWindow();
|
|
}
|
|
}
|
|
|
|
void
|
|
nsNativeAppSupportWin::HandleCommandLine(const char* aCmdLineString,
|
|
nsIFile* aWorkingDir,
|
|
uint32_t aState)
|
|
{
|
|
nsresult rv;
|
|
|
|
int justCounting = 1;
|
|
char **argv = 0;
|
|
// Flags, etc.
|
|
int init = 1;
|
|
int between, quoted, bSlashCount;
|
|
int argc;
|
|
const char *p;
|
|
nsAutoCString arg;
|
|
|
|
nsCOMPtr<nsICommandLineRunner> cmdLine
|
|
(do_CreateInstance("@mozilla.org/toolkit/command-line;1"));
|
|
if (!cmdLine) {
|
|
NS_ERROR("Couldn't create command line!");
|
|
return;
|
|
}
|
|
|
|
// Parse command line args according to MS spec
|
|
// (see "Parsing C++ Command-Line Arguments" at
|
|
// http://msdn.microsoft.com/library/devprods/vs6/visualc/vclang/_pluslang_parsing_c.2b2b_.command.2d.line_arguments.htm).
|
|
// We loop if we've not finished the second pass through.
|
|
while ( 1 ) {
|
|
// Initialize if required.
|
|
if ( init ) {
|
|
p = aCmdLineString;
|
|
between = 1;
|
|
argc = quoted = bSlashCount = 0;
|
|
|
|
init = 0;
|
|
}
|
|
if ( between ) {
|
|
// We are traversing whitespace between args.
|
|
// Check for start of next arg.
|
|
if ( *p != 0 && !isspace( *p ) ) {
|
|
// Start of another arg.
|
|
between = 0;
|
|
arg = "";
|
|
switch ( *p ) {
|
|
case '\\':
|
|
// Count the backslash.
|
|
bSlashCount = 1;
|
|
break;
|
|
case '"':
|
|
// Remember we're inside quotes.
|
|
quoted = 1;
|
|
break;
|
|
default:
|
|
// Add character to arg.
|
|
arg += *p;
|
|
break;
|
|
}
|
|
} else {
|
|
// Another space between args, ignore it.
|
|
}
|
|
} else {
|
|
// We are processing the contents of an argument.
|
|
// Check for whitespace or end.
|
|
if ( *p == 0 || ( !quoted && isspace( *p ) ) ) {
|
|
// Process pending backslashes (interpret them
|
|
// literally since they're not followed by a ").
|
|
while( bSlashCount ) {
|
|
arg += '\\';
|
|
bSlashCount--;
|
|
}
|
|
// End current arg.
|
|
if ( !justCounting ) {
|
|
argv[argc] = new char[ arg.Length() + 1 ];
|
|
strcpy( argv[argc], arg.get() );
|
|
}
|
|
argc++;
|
|
// We're now between args.
|
|
between = 1;
|
|
} else {
|
|
// Still inside argument, process the character.
|
|
switch ( *p ) {
|
|
case '"':
|
|
// First, digest preceding backslashes (if any).
|
|
while ( bSlashCount > 1 ) {
|
|
// Put one backsplash in arg for each pair.
|
|
arg += '\\';
|
|
bSlashCount -= 2;
|
|
}
|
|
if ( bSlashCount ) {
|
|
// Quote is literal.
|
|
arg += '"';
|
|
bSlashCount = 0;
|
|
} else {
|
|
// Quote starts or ends a quoted section.
|
|
if ( quoted ) {
|
|
// Check for special case of consecutive double
|
|
// quotes inside a quoted section.
|
|
if ( *(p+1) == '"' ) {
|
|
// This implies a literal double-quote. Fake that
|
|
// out by causing next double-quote to look as
|
|
// if it was preceded by a backslash.
|
|
bSlashCount = 1;
|
|
} else {
|
|
quoted = 0;
|
|
}
|
|
} else {
|
|
quoted = 1;
|
|
}
|
|
}
|
|
break;
|
|
case '\\':
|
|
// Add to count.
|
|
bSlashCount++;
|
|
break;
|
|
default:
|
|
// Accept any preceding backslashes literally.
|
|
while ( bSlashCount ) {
|
|
arg += '\\';
|
|
bSlashCount--;
|
|
}
|
|
// Just add next char to the current arg.
|
|
arg += *p;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// Check for end of input.
|
|
if ( *p ) {
|
|
// Go to next character.
|
|
p++;
|
|
} else {
|
|
// If on first pass, go on to second.
|
|
if ( justCounting ) {
|
|
// Allocate argv array.
|
|
argv = new char*[ argc ];
|
|
|
|
// Start second pass
|
|
justCounting = 0;
|
|
init = 1;
|
|
} else {
|
|
// Quit.
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
rv = cmdLine->Init(argc, argv, aWorkingDir, aState);
|
|
|
|
// Cleanup.
|
|
while ( argc ) {
|
|
delete [] argv[ --argc ];
|
|
}
|
|
delete [] argv;
|
|
|
|
if (NS_FAILED(rv)) {
|
|
NS_ERROR("Error initializing command line.");
|
|
return;
|
|
}
|
|
|
|
cmdLine->Run();
|
|
}
|
|
|
|
nsresult
|
|
nsNativeAppSupportWin::OpenWindow( const char*urlstr, const char *args ) {
|
|
|
|
nsresult rv = NS_ERROR_FAILURE;
|
|
|
|
nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID));
|
|
nsCOMPtr<nsISupportsCString> sarg(do_CreateInstance(NS_SUPPORTS_CSTRING_CONTRACTID));
|
|
if (sarg)
|
|
sarg->SetData(nsDependentCString(args));
|
|
|
|
if (wwatch && sarg) {
|
|
nsCOMPtr<nsIDOMWindow> newWindow;
|
|
rv = wwatch->OpenWindow(0, urlstr, "_blank", "chrome,dialog=no,all",
|
|
sarg, getter_AddRefs(newWindow));
|
|
#if MOZ_DEBUG_DDE
|
|
} else {
|
|
printf("Get WindowWatcher (or create string) failed\n");
|
|
#endif
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
HWND hwndForDOMWindow( nsISupports *window ) {
|
|
nsCOMPtr<nsPIDOMWindow> pidomwindow( do_QueryInterface(window) );
|
|
if ( !pidomwindow ) {
|
|
return 0;
|
|
}
|
|
|
|
nsCOMPtr<nsIBaseWindow> ppBaseWindow =
|
|
do_QueryInterface( pidomwindow->GetDocShell() );
|
|
if ( !ppBaseWindow ) {
|
|
return 0;
|
|
}
|
|
|
|
nsCOMPtr<nsIWidget> ppWidget;
|
|
ppBaseWindow->GetMainWidget( getter_AddRefs( ppWidget ) );
|
|
|
|
return (HWND)( ppWidget->GetNativeData( NS_NATIVE_WIDGET ) );
|
|
}
|
|
|
|
nsresult
|
|
nsNativeAppSupportWin::OpenBrowserWindow()
|
|
{
|
|
nsresult rv = NS_OK;
|
|
|
|
// Open the argument URL in the most recently used Navigator window.
|
|
// If there is no Nav window, open a new one.
|
|
|
|
// If at all possible, hand the request off to the most recent
|
|
// browser window.
|
|
|
|
nsCOMPtr<nsIDOMWindow> navWin;
|
|
GetMostRecentWindow( NS_LITERAL_STRING( "navigator:browser" ).get(), getter_AddRefs( navWin ) );
|
|
|
|
// This isn't really a loop. We just use "break" statements to fall
|
|
// out to the OpenWindow call when things go awry.
|
|
do {
|
|
// If caller requires a new window, then don't use an existing one.
|
|
if ( !navWin ) {
|
|
// Have to open a new one.
|
|
break;
|
|
}
|
|
|
|
nsCOMPtr<nsIBrowserDOMWindow> bwin;
|
|
{ // scope a bunch of temporary cruft used to generate bwin
|
|
nsCOMPtr<nsIWebNavigation> navNav( do_GetInterface( navWin ) );
|
|
nsCOMPtr<nsIDocShellTreeItem> navItem( do_QueryInterface( navNav ) );
|
|
if ( navItem ) {
|
|
nsCOMPtr<nsIDocShellTreeItem> rootItem;
|
|
navItem->GetRootTreeItem( getter_AddRefs( rootItem ) );
|
|
nsCOMPtr<nsIDOMWindow> rootWin =
|
|
rootItem ? rootItem->GetWindow() : nullptr;
|
|
nsCOMPtr<nsIDOMChromeWindow> chromeWin(do_QueryInterface(rootWin));
|
|
if ( chromeWin )
|
|
chromeWin->GetBrowserDOMWindow( getter_AddRefs ( bwin ) );
|
|
}
|
|
}
|
|
if ( bwin ) {
|
|
nsCOMPtr<nsIURI> uri;
|
|
NS_NewURI( getter_AddRefs( uri ), NS_LITERAL_CSTRING("about:blank"), 0, 0 );
|
|
if ( uri ) {
|
|
nsCOMPtr<nsIDOMWindow> container;
|
|
rv = bwin->OpenURI( uri, 0,
|
|
nsIBrowserDOMWindow::OPEN_DEFAULTWINDOW,
|
|
nsIBrowserDOMWindow::OPEN_EXTERNAL,
|
|
getter_AddRefs( container ) );
|
|
if ( NS_SUCCEEDED( rv ) )
|
|
return NS_OK;
|
|
}
|
|
}
|
|
|
|
NS_ERROR("failed to hand off external URL to extant window");
|
|
} while ( false );
|
|
|
|
// open a new window if caller requested it or if anything above failed
|
|
|
|
char* argv[] = { 0 };
|
|
nsCOMPtr<nsICommandLineRunner> cmdLine
|
|
(do_CreateInstance("@mozilla.org/toolkit/command-line;1"));
|
|
NS_ENSURE_TRUE(cmdLine, NS_ERROR_FAILURE);
|
|
|
|
rv = cmdLine->Init(0, argv, nullptr, nsICommandLine::STATE_REMOTE_EXPLICIT);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
return cmdLine->Run();
|
|
}
|
|
|