Bommels05/Mozilla
Bommels05/Mozilla
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

removing no-longer-used winhooks directory

Browse Source 
git-svn-id: svn://10.0.0.236/trunk@154700 18797224-902f-48f8-a5cc-f745e15eee43
This commit is contained in:
bryner%brianryner.com 2004-04-11 22:51:59 +00:00
parent 88da858ca1
commit 0ca629dbd8
10 changed files with 0 additions and 2399 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

61
mozilla/browser/components/winhooks/Makefile.in
View File

@ -1,61 +0,0 @@
#
# The contents of this file are subject to the Netscape Public
# License Version 1.1 (the "License"); you may not use this file
# except in compliance with the License. You may obtain a copy of
# the License at http://www.mozilla.org/NPL/
#
# Software distributed under the License is distributed on an "AS
# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
# implied. See the License for the specific language governing
# rights and limitations under the License.
#
# The Original Code is mozilla.org code.
#
# The Initial Developer of the Original Code is Netscape
# Communications Corporation. Portions created by Netscape are
# Copyright (C) 1998 Netscape Communications Corporation. All
# Rights Reserved.
#
# Contributor(s):
#
DEPTH = ../../..
topsrcdir = @top_srcdir@
srcdir = @srcdir@
VPATH = @srcdir@
include $(DEPTH)/config/autoconf.mk
MODULE = winhooks
LIBRARY_NAME = winhooks_s
REQUIRES = \
xpcom \
string \
dom \
windowwatcher \
intl \
appshell \
necko \
layout \
content \
widget \
imglib2 \
gfx \
locale \
$(NULL)
CPPSRCS = nsWindowsHooks.cpp
FORCE_STATIC_LIB = 1
include $(topsrcdir)/config/rules.mk
JS_SET_BROWSER_COMPONENT = nsSetDefaultBrowser.js
libs::
$(INSTALL) $(srcdir)/$(JS_SET_BROWSER_COMPONENT) $(DIST)/bin/components
clobber::
rm -f $(DIST)/lib/$(LIBRARY_NAME).lib
rm -f $(DIST)/bin/components/$(JS_SET_BROWSER_COMPONENT)

46
mozilla/browser/components/winhooks/dummyWindow.xul
View File

@ -1,46 +0,0 @@
<?xml version="1.0"?>
<!-- ***** BEGIN LICENSE BLOCK *****
- Version: MPL 1.1/GPL 2.0/LGPL 2.1
-
- The contents of this file are subject to the Mozilla Public License Version
- 1.1 (the "License"); you may not use this file except in compliance with
- the License. You may obtain a copy of the License at
- http://www.mozilla.org/MPL/
-
- Software distributed under the License is distributed on an "AS IS" basis,
- WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- for the specific language governing rights and limitations under the
- License.
-
- The Original Code is Mozilla WinXP SP1 Support.
-
- The Initial Developer of the Original Code is
- Netscape Communications Corporation.
- Portions created by the Initial Developer are Copyright (C) 2002
- the Initial Developer. All Rights Reserved.
-
- Contributor(s):
- Bill Law <law@netscape.com>
-
- Alternatively, the contents of this file may be used under the terms of
- either the GNU General Public License Version 2 or later (the "GPL"), or
- the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- in which case the provisions of the GPL or the LGPL are applicable instead
- of those above. If you wish to allow use of your version of this file only
- under the terms of either the GPL or the LGPL, and not to allow others to
- use your version of this file under the terms of the MPL, indicate your
- decision by deleting the provisions above and replace them with the notice
- and other provisions required by the LGPL or the GPL. If you do not delete
- the provisions above, a recipient may use your version of this file under
- the terms of any one of the MPL, the GPL or the LGPL.
-
- ***** END LICENSE BLOCK ***** -->
<!-- This is a dummy window that autocloses. See nsDefaultBrowser.js. -->
<!DOCTYPE window>
<window id="dummyWindow" onload="window.close()"
xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
</window>

4
mozilla/browser/components/winhooks/jar.mn
View File

@ -1,4 +0,0 @@
toolkit.jar:
content/global/dummyWindow.xul (dummyWindow.xul)
en-win.jar:
locale/en-US/global-platform/nsWindowsHooks.properties (locale/nsWindowsHooks.properties)

6
mozilla/browser/components/winhooks/locale/nsWindowsHooks.properties
View File

@ -1,6 +0,0 @@
yesButtonLabel=Yes
noButtonLabel=No
cancelButtonLabel=Cancel
checkBoxLabel=Check at startup next time, too.
promptText=%S is not currently set as your default browser. Would you like to make it your default browser?
prefsLabel=Pr&eferences

180
mozilla/browser/components/winhooks/nsSetDefaultBrowser.js
View File

@ -1,180 +0,0 @@
/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Mozilla Default Browser.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corp.
* Portions created by the Initial Developer are Copyright (C) 2002
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Bill Law <law@netscape.com>
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
/* This file implements the nsICmdLineHandler interface. See nsICmdLineHandler.idl
* at http://lxr.mozilla.org/seamonkey/source/xpfe/appshell/public/nsICmdLineHandler.idl.
*
* This component handles the startup command line argument of the form:
* -setDefaultBrowser
* by making the current executable the "default browser." It accomplishes
* that via use of the nsIWindowsHooks interface (see implementation below).
*
* The module is registered under the contractid
* "@mozilla.org/commandlinehandler/general-startup;1?type=setDefaultBrowser"
*
* The implementation consists of a JavaScript "class" named nsKillAll,
* comprised of:
* - a JS constructor function
* - a prototype providing all the interface methods and implementation stuff
*
* In addition, this file implements an nsIModule object that registers the
* nsSetDefaultBrowser component.
*/
/* ctor
*/
function nsSetDefaultBrowser() {
}
nsSetDefaultBrowser.prototype = {
// nsICmdLineHandler interface
get commandLineArgument() { throw Components.results.NS_ERROR_NOT_IMPLEMENTED; },
get prefNameForStartup() { throw Components.results.NS_ERROR_NOT_IMPLEMENTED; },
get chromeUrlForTask() {
// First, get winhooks service.
var winHooks = Components.classes[ "@mozilla.org/winhooks;1" ]
.getService( Components.interfaces.nsIWindowsHooks );
// Next, extract current settings (these are what the user
// had previously checked on the Advanced/System pref panel).
var settings = winHooks.settings;
// Now, turn on all "default browser" settings.
settings.isHandlingHTTP = true;
settings.isHandlingHTTPS = true;
settings.isHandlingHTML = true;
settings.isHandlingXHTML = true;
// Finally, apply the (new) settings.
winHooks.settings = settings;
// Now, get the cmd line service.
var cmdLineService = Components.classes[ "@mozilla.org/appshell/commandLineService;1" ]
.getService( Components.interfaces.nsICmdLineService );
// See if "-setDefaultBrowser" was specified. The value will be "1" if
// -setDefaultBrowser is in the service's list of cmd line arguments, and
// null otherwise. -setDefaultBrowser will only be in the service's
// arg list if the application was not already running. That's because
// if it was already running, then the service reflects the arguments
// that were specified when *that* process was started, *not* the ones
// passed via IPC from the second instance.
var option = cmdLineService.getCmdLineValue( "-setDefaultBrowser" );
if (!option) {
// Already running, so we don't have to worry about opening
// another window, etc.
throw Components.results.NS_ERROR_NOT_AVAILABLE;
}
// Return URL for dummy window that will auto-close. We do this rather
// than throw NS_ERROR_NOT_AVAILABLE, which *should* work, because it
// seems that if we don't open a window, we get a crash when trying to
// release this (or some other) JS component during XPCOM shutdown.
return "chrome://global/content/dummyWindow.xul";
},
get helpText() { throw Components.results.NS_ERROR_NOT_IMPLEMENTED; },
get handlesArgs() { return false; },
get defaultArgs() { throw Components.results.NS_ERROR_NOT_IMPLEMENTED; },
get openWindowWithArgs() { throw Components.results.NS_ERROR_NOT_IMPLEMENTED; },
// nsISupports interface
// This "class" supports nsICmdLineHandler and nsISupports.
QueryInterface: function (iid) {
if (!iid.equals(Components.interfaces.nsICmdLineHandler) &&
!iid.equals(Components.interfaces.nsISupports)) {
throw Components.results.NS_ERROR_NO_INTERFACE;
}
return this;
},
// This Component's module implementation. All the code below is used to get this
// component registered and accessible via XPCOM.
module: {
// registerSelf: Register this component.
registerSelf: function (compMgr, fileSpec, location, type) {
var compReg = compMgr.QueryInterface( Components.interfaces.nsIComponentRegistrar );
compReg.registerFactoryLocation( this.cid,
"Default Browser Component",
this.contractId,
fileSpec,
location,
type );
},
// getClassObject: Return this component's factory object.
getClassObject: function (compMgr, cid, iid) {
if (!cid.equals(this.cid))
throw Components.results.NS_ERROR_NO_INTERFACE;
if (!iid.equals(Components.interfaces.nsIFactory))
throw Components.results.NS_ERROR_NOT_IMPLEMENTED;
return this.factory;
},
/* CID for this class */
cid: Components.ID("{C66E05DC-509C-4972-A1F2-EE5AC34B9800}"),
/* Contract ID for this class */
contractId: "@mozilla.org/commandlinehandler/general-startup;1?type=setDefaultBrowser",
/* factory object */
factory: {
// createInstance: Return a new nsSetDefaultBrowser object.
createInstance: function (outer, iid) {
if (outer != null)
throw Components.results.NS_ERROR_NO_AGGREGATION;
return (new nsSetDefaultBrowser()).QueryInterface(iid);
}
},
// canUnload: n/a (returns true)
canUnload: function(compMgr) {
return true;
}
}
}
// NSGetModule: Return the nsIModule object.
function NSGetModule(compMgr, fileSpec) {
return nsSetDefaultBrowser.prototype.module;
}

891
mozilla/browser/components/winhooks/nsWindowsHooks.cpp
View File

@ -1,891 +0,0 @@
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: NPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Netscape Public License
* Version 1.1 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://www.mozilla.org/NPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is mozilla.org code.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 1998
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Bill Law <law@netscape.com>
* Syd Logan <syd@netscape.com> added turbo mode stuff
* Joe Elwell <jelwell@netscape.com>
* Håkan Waara <hwaara@chello.se>
* Aaron Kaluszka <ask@swva.net>
* Blake Ross <blake@blakeross.com>
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the NPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the NPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#ifndef MAX_BUF
#define MAX_BUF 4096
#endif
// Implementation utilities.
#include "nsIDOMWindowInternal.h"
#include "nsIServiceManager.h"
#include "nsIPromptService.h"
#include "nsIStringBundle.h"
#include "nsIAllocator.h"
#include "nsICmdLineService.h"
#include "nsXPIDLString.h"
#include "nsString.h"
#include "nsMemory.h"
#include "nsNetUtil.h"
#include "nsWindowsHooksUtil.cpp"
#include "nsWindowsHooks.h"
#include <windows.h>
#include <shlobj.h>
#include <shlguid.h>
// for set as wallpaper
#include "nsIDocument.h"
#include "nsIContent.h"
#include "nsIDOMElement.h"
#include "nsIDOMDocument.h"
#include "nsIFrame.h"
#include "nsIPresShell.h"
#include "nsIImageLoadingContent.h"
#include "imgIRequest.h"
#include "imgIContainer.h"
#include "gfxIImageFrame.h"
#define RUNKEY "Software\\Microsoft\\Windows\\CurrentVersion\\Run"
// Objects that describe the Windows registry entries that we need to tweak.
static ProtocolRegistryEntry
http( "http" ),
https( "https" ),
ftp( "ftp" ),
chrome( "chrome" ),
gopher( "gopher" );
const char *xhtmExts[] = { ".xht", ".xhtml", 0 };
const char *htmExts[] = { ".htm", ".html", ".shtml", 0 };
static FileTypeRegistryEntry
xhtml( xhtmExts, "MozillaXHTML", "XHTML Document", "", "doc-file.ico"),
mozillaMarkup( htmExts, "MozillaHTML", "HTML Document", "htmlfile", "doc-file.ico");
// Implementation of the nsIWindowsHooksSettings interface.
// Use standard implementation of nsISupports stuff.
NS_IMPL_ISUPPORTS1( nsWindowsHooksSettings, nsIWindowsHooksSettings )
nsWindowsHooksSettings::nsWindowsHooksSettings() {
}
nsWindowsHooksSettings::~nsWindowsHooksSettings() {
}
// Generic getter.
NS_IMETHODIMP
nsWindowsHooksSettings::Get( PRBool *result, PRBool nsWindowsHooksSettings::*member ) {
NS_ENSURE_ARG( result );
NS_ENSURE_ARG( member );
*result = this->*member;
return NS_OK;
}
// Generic setter.
NS_IMETHODIMP
nsWindowsHooksSettings::Set( PRBool value, PRBool nsWindowsHooksSettings::*member ) {
NS_ENSURE_ARG( member );
this->*member = value;
return NS_OK;
}
// Macros to define specific getter/setter methods.
#define DEFINE_GETTER_AND_SETTER( attr, member ) \
NS_IMETHODIMP \
nsWindowsHooksSettings::Get##attr ( PRBool *result ) { \
return this->Get( result, &nsWindowsHooksSettings::member ); \
} \
NS_IMETHODIMP \
nsWindowsHooksSettings::Set##attr ( PRBool value ) { \
return this->Set( value, &nsWindowsHooksSettings::member ); \
}
// Define all the getter/setter methods:
DEFINE_GETTER_AND_SETTER( IsHandlingHTML, mHandleHTML )
DEFINE_GETTER_AND_SETTER( IsHandlingXHTML, mHandleXHTML )
DEFINE_GETTER_AND_SETTER( IsHandlingHTTP, mHandleHTTP )
DEFINE_GETTER_AND_SETTER( IsHandlingHTTPS, mHandleHTTPS )
DEFINE_GETTER_AND_SETTER( ShowDialog, mShowDialog )
DEFINE_GETTER_AND_SETTER( HaveBeenSet, mHaveBeenSet )
// Implementation of the nsIWindowsHooks interface.
// Use standard implementation of nsISupports stuff.
NS_IMPL_ISUPPORTS2( nsWindowsHooks, nsIWindowsHooks, nsIWindowsRegistry )
nsWindowsHooks::nsWindowsHooks() {
}
nsWindowsHooks::~nsWindowsHooks() {
}
// Internal GetPreferences.
NS_IMETHODIMP
nsWindowsHooks::GetSettings( nsWindowsHooksSettings **result ) {
nsresult rv = NS_OK;
// Validate input arg.
NS_ENSURE_ARG( result );
// Allocate prefs object.
nsWindowsHooksSettings *prefs = *result = new nsWindowsHooksSettings;
NS_ENSURE_TRUE( prefs, NS_ERROR_OUT_OF_MEMORY );
// Got it, increment ref count.
NS_ADDREF( prefs );
// Get each registry value and copy to prefs structure.
prefs->mHandleHTTP = BoolRegistryEntry( "isHandlingHTTP" );
prefs->mHandleHTTPS = BoolRegistryEntry( "isHandlingHTTPS" );
prefs->mHandleHTML = BoolRegistryEntry( "isHandlingHTML" );
prefs->mHandleXHTML = BoolRegistryEntry( "isHandlingXHTML" );
prefs->mShowDialog = BoolRegistryEntry( "showDialog" );
prefs->mHaveBeenSet = BoolRegistryEntry( "haveBeenSet" );
#ifdef DEBUG_law
NS_WARN_IF_FALSE( NS_SUCCEEDED( rv ), "GetPreferences failed" );
#endif
return rv;
}
// Public interface uses internal plus a QI to get to the proper result.
NS_IMETHODIMP
nsWindowsHooks::GetSettings( nsIWindowsHooksSettings **_retval ) {
// Allocate prefs object.
nsWindowsHooksSettings *prefs;
nsresult rv = this->GetSettings( &prefs );
if ( NS_SUCCEEDED( rv ) ) {
// QI to proper interface.
rv = prefs->QueryInterface( NS_GET_IID( nsIWindowsHooksSettings ), (void**)_retval );
// Release (to undo our Get...).
NS_RELEASE( prefs );
}
return rv;
}
static PRBool misMatch( const PRBool &flag, const ProtocolRegistryEntry &entry ) {
PRBool result = PR_FALSE;
// Check if we care.
if ( flag ) {
// Compare registry entry setting to what it *should* be.
if ( entry.currentSetting() != entry.setting ) {
result = PR_TRUE;
}
}
return result;
}
// isAccessRestricted - Returns PR_TRUE iff this user only has restricted access
// to the registry keys we need to modify.
static PRBool isAccessRestricted() {
char subKey[] = "Software\\Mozilla - Test Key";
PRBool result = PR_FALSE;
DWORD dwDisp = 0;
HKEY key;
// Try to create/open a subkey under HKLM.
DWORD rc = ::RegCreateKeyEx( HKEY_LOCAL_MACHINE,
subKey,
0,
NULL,
REG_OPTION_NON_VOLATILE,
KEY_WRITE,
NULL,
&key,
&dwDisp );
if ( rc == ERROR_SUCCESS ) {
// Key was opened; first close it.
::RegCloseKey( key );
// Delete it if we just created it.
switch( dwDisp ) {
case REG_CREATED_NEW_KEY:
::RegDeleteKey( HKEY_LOCAL_MACHINE, subKey );
break;
case REG_OPENED_EXISTING_KEY:
break;
}
} else {
// Can't create/open it; we don't have access.
result = PR_TRUE;
}
return result;
}
// Implementation of method that checks whether the settings match what's in the
// Windows registry.
NS_IMETHODIMP
nsWindowsHooksSettings::GetRegistryMatches( PRBool *_retval ) {
NS_ENSURE_ARG( _retval );
*_retval = PR_TRUE;
// Test registry for all selected attributes.
if ( misMatch( mHandleHTTP, http )
||
misMatch( mHandleHTTPS, https )
||
misMatch( mHandleHTML, mozillaMarkup )
||
misMatch( mHandleXHTML, xhtml ) ) {
// Registry is out of synch.
*_retval = PR_FALSE;
}
return NS_OK;
}
// Implementation of method that checks settings versus registry and prompts user
// if out of synch.
NS_IMETHODIMP
nsWindowsHooks::CheckSettings( nsIDOMWindowInternal *aParent,
PRBool *_retval ) {
nsresult rv = NS_OK;
*_retval = PR_FALSE;
// Only do this once!
static PRBool alreadyChecked = PR_FALSE;
if ( alreadyChecked ) {
return NS_OK;
} else {
alreadyChecked = PR_TRUE;
// Don't check further if we don't have sufficient access.
if ( isAccessRestricted() ) {
return NS_OK;
}
}
// Get settings.
nsWindowsHooksSettings *settings;
rv = this->GetSettings( &settings );
if ( NS_SUCCEEDED( rv ) && settings ) {
// If not set previously, set to defaults so that they are
// set properly when/if the user says to.
if ( !settings->mHaveBeenSet ) {
settings->mHandleHTTP = PR_TRUE;
settings->mHandleHTTPS = PR_TRUE;
settings->mHandleHTML = PR_TRUE;
settings->mHandleXHTML = PR_TRUE;
settings->mShowDialog = PR_TRUE;
}
// If launched with "-installer" then override mShowDialog.
PRBool installing = PR_FALSE;
if ( !settings->mShowDialog ) {
// Get command line service.
nsCID cmdLineCID = NS_COMMANDLINE_SERVICE_CID;
nsCOMPtr<nsICmdLineService> cmdLineArgs( do_GetService( cmdLineCID, &rv ) );
if ( NS_SUCCEEDED( rv ) && cmdLineArgs ) {
// See if "-installer" was specified.
nsXPIDLCString installer;
rv = cmdLineArgs->GetCmdLineValue( "-installer", getter_Copies( installer ) );
if ( NS_SUCCEEDED( rv ) && installer ) {
installing = PR_TRUE;
}
}
}
// First, make sure the user cares.
if ( settings->mShowDialog || installing ) {
// Look at registry setting for all things that are set.
PRBool matches = PR_TRUE;
settings->GetRegistryMatches( &matches );
if ( !matches ) {
// Need to prompt user.
// First:
// o We need the common dialog service to show the dialog.
// o We need the string bundle service to fetch the appropriate
// dialog text.
nsCID bundleCID = NS_STRINGBUNDLESERVICE_CID;
nsCOMPtr<nsIPromptService> promptService( do_GetService("@mozilla.org/embedcomp/prompt-service;1"));
nsCOMPtr<nsIStringBundleService> bundleService( do_GetService( bundleCID, &rv ) );
if ( promptService && bundleService ) {
// Next, get bundle that provides text for dialog.
nsCOMPtr<nsIStringBundle> bundle;
nsCOMPtr<nsIStringBundle> brandBundle;
rv = bundleService->CreateBundle( "chrome://global-platform/locale/nsWindowsHooks.properties",
getter_AddRefs( bundle ) );
rv = bundleService->CreateBundle( "chrome://global/locale/brand.properties",
getter_AddRefs( brandBundle ) );
if ( NS_SUCCEEDED( rv ) && bundle && brandBundle ) {
nsXPIDLString text, label, shortName;
if ( NS_SUCCEEDED( ( rv = brandBundle->GetStringFromName( NS_LITERAL_STRING( "brandShortName" ).get(),
getter_Copies( shortName ) ) ) ) ) {
const PRUnichar* formatStrings[] = { shortName.get() };
if ( NS_SUCCEEDED( ( rv = bundle->FormatStringFromName( NS_LITERAL_STRING( "promptText" ).get(),
formatStrings, 1, getter_Copies( text ) ) ) )
&&
NS_SUCCEEDED( ( rv = bundle->GetStringFromName( NS_LITERAL_STRING( "checkBoxLabel" ).get(),
getter_Copies( label ) ) ) ) ) {
// Got the text, now show dialog.
PRBool showDialog = settings->mShowDialog;
PRInt32 dlgResult = -1;
// No checkbox for initial display.
const PRUnichar *labelArg = 0;
if ( settings->mHaveBeenSet ) {
// Subsequent display uses label string.
labelArg = label;
}
// Note that the buttons need to be passed in this order:
// o Yes
// o Cancel
// o No
rv = promptService->ConfirmEx(aParent, shortName, text,
(nsIPromptService::BUTTON_TITLE_YES * nsIPromptService::BUTTON_POS_0) +
(nsIPromptService::BUTTON_TITLE_CANCEL * nsIPromptService::BUTTON_POS_1) +
(nsIPromptService::BUTTON_TITLE_NO * nsIPromptService::BUTTON_POS_2),
nsnull, nsnull, nsnull, labelArg, &showDialog, &dlgResult);
if ( NS_SUCCEEDED( rv ) ) {
// Dialog was shown
*_retval = PR_TRUE;
// Did they say go ahead?
switch ( dlgResult ) {
case 0:
// User says: make the changes.
// Remember "show dialog" choice.
settings->mShowDialog = showDialog;
// Apply settings; this single line of
// code will do different things depending
// on whether this is the first time (i.e.,
// when "haveBeenSet" is false). The first
// time, this will set all prefs to true
// (because that's how we initialized 'em
// in GetSettings, above) and will update the
// registry accordingly. On subsequent passes,
// this will only update the registry (because
// the settings we got from GetSettings will
// not have changed).
//
// BTW, the term "prefs" in this context does not
// refer to conventional Mozilla "prefs." Instead,
// it refers to "Desktop Integration" prefs which
// are stored in the windows registry.
rv = SetSettings( settings );
#ifdef DEBUG_law
printf( "Yes, SetSettings returned 0x%08X\n", (int)rv );
#endif
break;
case 2:
// User says: Don't mess with Windows.
// We update only the "showDialog" and
// "haveBeenSet" keys. Note that this will
// have the effect of setting all the prefs
// *off* if the user says no to the initial
// prompt.
BoolRegistryEntry( "haveBeenSet" ).set();
if ( showDialog ) {
BoolRegistryEntry( "showDialog" ).set();
} else {
BoolRegistryEntry( "showDialog" ).reset();
}
#ifdef DEBUG_law
printf( "No, haveBeenSet=1 and showDialog=%d\n", (int)showDialog );
#endif
break;
default:
// User says: I dunno. Make no changes (which
// should produce the same dialog next time).
#ifdef DEBUG_law
printf( "Cancel\n" );
#endif
break;
}
}
}
}
}
}
}
#ifdef DEBUG_law
else { printf( "Registry and prefs match\n" ); }
#endif
}
#ifdef DEBUG_law
else { printf( "showDialog is false and not installing\n" ); }
#endif
// Release the settings.
settings->Release();
}
return rv;
}
// Utility to set PRBool registry value from getter method.
nsresult putPRBoolIntoRegistry( const char* valueName,
nsIWindowsHooksSettings *prefs,
nsWindowsHooksSettings::getter memFun ) {
// Use getter method to extract attribute from prefs.
PRBool boolValue;
(void)(prefs->*memFun)( &boolValue );
// Convert to DWORD.
DWORD dwordValue = boolValue;
// Store into registry.
BoolRegistryEntry pref( valueName );
nsresult rv = boolValue ? pref.set() : pref.reset();
return rv;
}
/* void setPreferences (in nsIWindowsHooksSettings prefs); */
NS_IMETHODIMP
nsWindowsHooks::SetSettings(nsIWindowsHooksSettings *prefs) {
nsresult rv = NS_ERROR_FAILURE;
putPRBoolIntoRegistry( "isHandlingHTTP", prefs, &nsIWindowsHooksSettings::GetIsHandlingHTTP );
putPRBoolIntoRegistry( "isHandlingHTTPS", prefs, &nsIWindowsHooksSettings::GetIsHandlingHTTPS );
putPRBoolIntoRegistry( "isHandlingHTML", prefs, &nsIWindowsHooksSettings::GetIsHandlingHTML );
putPRBoolIntoRegistry( "isHandlingXHTML", prefs, &nsIWindowsHooksSettings::GetIsHandlingXHTML );
putPRBoolIntoRegistry( "showDialog", prefs, &nsIWindowsHooksSettings::GetShowDialog );
// Indicate that these settings have indeed been set.
BoolRegistryEntry( "haveBeenSet" ).set();
rv = SetRegistry();
return rv;
}
// Get preferences and start handling everything selected.
NS_IMETHODIMP
nsWindowsHooks::SetRegistry() {
nsresult rv = NS_OK;
// Get raw prefs object.
nsWindowsHooksSettings *prefs;
rv = this->GetSettings( &prefs );
NS_ENSURE_TRUE( NS_SUCCEEDED( rv ), rv );
if ( prefs->mHandleHTML ) {
(void) mozillaMarkup.set();
} else {
(void) mozillaMarkup.reset();
}
if ( prefs->mHandleXHTML ) {
(void) xhtml.set();
} else {
(void) xhtml.reset();
}
if ( prefs->mHandleHTTP ) {
(void) http.set();
} else {
(void) http.reset();
}
if ( prefs->mHandleHTTPS ) {
(void) https.set();
} else {
(void) https.reset();
}
// Call SHChangeNotify() to notify the windows shell that file
// associations changed, and that an update of the icons need to occur.
SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, NULL, NULL);
return NS_OK;
}
NS_IMETHODIMP nsWindowsHooks::GetRegistryEntry( PRInt32 aHKEYConstant, const char *aSubKeyName, const char *aValueName, char **aResult ) {
NS_ENSURE_ARG( aResult );
*aResult = 0;
// Calculate HKEY_* starting point based on input nsIWindowsHooks constant.
HKEY hKey;
switch ( aHKEYConstant ) {
case HKCR:
hKey = HKEY_CLASSES_ROOT;
break;
case HKCC:
hKey = HKEY_CURRENT_CONFIG;
break;
case HKCU:
hKey = HKEY_CURRENT_USER;
break;
case HKLM:
hKey = HKEY_LOCAL_MACHINE;
break;
case HKU:
hKey = HKEY_USERS;
break;
default:
return NS_ERROR_INVALID_ARG;
}
// Get requested registry entry.
nsCAutoString entry( RegistryEntry( hKey, aSubKeyName, aValueName, 0 ).currentSetting() );
// Copy to result.
*aResult = PL_strdup( entry.get() );
return *aResult ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
}
nsresult
WriteBitmap(nsString& aPath, gfxIImageFrame* aImage)
{
PRInt32 width, height;
aImage->GetWidth(&width);
aImage->GetHeight(&height);
PRUint8* bits;
PRUint32 length;
aImage->GetImageData(&bits, &length);
if (!bits) return NS_ERROR_FAILURE;
PRUint32 bpr;
aImage->GetImageBytesPerRow(&bpr);
PRInt32 bitCount = bpr/width;
// initialize these bitmap structs which we will later
// serialize directly to the head of the bitmap file
LPBITMAPINFOHEADER bmi = (LPBITMAPINFOHEADER)new BITMAPINFO;
bmi->biSize = sizeof(BITMAPINFOHEADER);
bmi->biWidth = width;
bmi->biHeight = height;
bmi->biPlanes = 1;
bmi->biBitCount = (WORD)bitCount*8;
bmi->biCompression = BI_RGB;
bmi->biSizeImage = 0; // don't need to set this if bmp is uncompressed
bmi->biXPelsPerMeter = 0;
bmi->biYPelsPerMeter = 0;
bmi->biClrUsed = 0;
bmi->biClrImportant = 0;
BITMAPFILEHEADER bf;
bf.bfType = 0x4D42; // 'BM'
bf.bfReserved1 = 0;
bf.bfReserved2 = 0;
bf.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
bf.bfSize = bf.bfOffBits + bmi->biSizeImage;
// get a file output stream
nsresult rv;
nsCOMPtr<nsILocalFile> path;
rv = NS_NewLocalFile(aPath, PR_TRUE, getter_AddRefs(path));
if (NS_FAILED(rv))
return rv;
nsCOMPtr<nsIOutputStream> stream;
NS_NewLocalFileOutputStream(getter_AddRefs(stream), path);
// write the bitmap headers and rgb pixel data to the file
rv = NS_ERROR_FAILURE;
if (stream) {
PRUint32 written;
stream->Write((const char*)&bf, sizeof(BITMAPFILEHEADER), &written);
if (written == sizeof(BITMAPFILEHEADER)) {
stream->Write((const char*)bmi, sizeof(BITMAPINFOHEADER), &written);
if (written == sizeof(BITMAPINFOHEADER)) {
stream->Write((const char*)bits, length, &written);
if (written == length)
rv = NS_OK;
}
}
stream->Close();
}
return rv;
}
NS_IMETHODIMP
nsWindowsHooks::GetDesktopColor(PRUint32* aColors)
{
PRUint32 color = ::GetSysColor(COLOR_DESKTOP);
*aColors = (GetRValue(color) << 16) | (GetGValue(color) << 8) | GetBValue(color);
return NS_OK;
}
NS_IMETHODIMP
nsWindowsHooks::SetDesktopColor(PRUint32 aColor)
{
int aParameters[2] = { COLOR_BACKGROUND, COLOR_DESKTOP };
BYTE r = (aColor >> 16);
BYTE g = (aColor << 16) >> 24;
BYTE b = (aColor << 24) >> 24;
COLORREF colors[2] = { RGB(r,g,b), RGB(r,g,b) };
::SetSysColors(sizeof(aParameters) / sizeof(int), aParameters, colors);
char subKey[] = "Control Panel\\Colors";
PRBool result = PR_FALSE;
DWORD dwDisp = 0;
HKEY key;
// Try to create/open a subkey under HKLM.
DWORD rc = ::RegCreateKeyEx(HKEY_CURRENT_USER,
subKey,
0,
NULL,
REG_OPTION_NON_VOLATILE,
KEY_WRITE,
NULL,
&key,
&dwDisp);
if (rc == ERROR_SUCCESS) {
char* rgb = new char[12];
sprintf(rgb, "%u %u %u\0", r, g, b);
::RegSetValueEx(key, "Background", 0, REG_SZ, (const unsigned char*)rgb, strlen(rgb));
delete[] rgb;
}
return NS_OK;
}
NS_IMETHODIMP
nsWindowsHooks::SetImageAsWallpaper(nsIDOMElement* aElement, PRBool aUseBackground, PRInt32 position)
{
nsresult rv;
nsCOMPtr<gfxIImageFrame> gfxFrame;
if (aUseBackground) {
// XXX write background loading stuff!
} else {
nsCOMPtr<nsIImageLoadingContent> imageContent = do_QueryInterface(aElement, &rv);
if (!imageContent) return rv;
// get the image container
nsCOMPtr<imgIRequest> request;
rv = imageContent->GetRequest(nsIImageLoadingContent::CURRENT_REQUEST,
getter_AddRefs(request));
if (!request) return rv;
nsCOMPtr<imgIContainer> container;
rv = request->GetImage(getter_AddRefs(container));
if (!request) return rv;
// get the current frame, which holds the image data
container->GetCurrentFrame(getter_AddRefs(gfxFrame));
}
if (!gfxFrame)
return NS_ERROR_FAILURE;
// get the windows directory ('c:\windows' usually)
char winDir[256];
::GetWindowsDirectory(winDir, sizeof(winDir));
nsAutoString winPath;
winPath.AssignWithConversion(winDir);
// get the product brand name from localized strings
nsXPIDLString brandName;
nsCID bundleCID = NS_STRINGBUNDLESERVICE_CID;
nsCOMPtr<nsIStringBundleService> bundleService(do_GetService(bundleCID));
if (bundleService) {
nsCOMPtr<nsIStringBundle> brandBundle;
rv = bundleService->CreateBundle("chrome://global/locale/brand.properties",
getter_AddRefs(brandBundle));
if (NS_SUCCEEDED(rv) && brandBundle) {
if (NS_FAILED(rv = brandBundle->GetStringFromName(NS_LITERAL_STRING("brandShortName").get(),
getter_Copies(brandName))))
return rv;
}
}
// build the file name
winPath.Append(NS_LITERAL_STRING("\\").get());
winPath.Append(brandName);
winPath.Append(NS_LITERAL_STRING(" Wallpaper.bmp").get());
// write the bitmap to a file in the windows dir
rv = WriteBitmap(winPath, gfxFrame);
// if the file was written successfully, set it as the system wallpaper
if (NS_SUCCEEDED(rv)) {
char subKey[] = "Control Panel\\Desktop";
PRBool result = PR_FALSE;
DWORD dwDisp = 0;
HKEY key;
// Try to create/open a subkey under HKLM.
DWORD rc = ::RegCreateKeyEx( HKEY_CURRENT_USER,
subKey,
0,
NULL,
REG_OPTION_NON_VOLATILE,
KEY_WRITE,
NULL,
&key,
&dwDisp );
if (rc == ERROR_SUCCESS) {
unsigned char tile[2];
unsigned char style[2];
if (position == WALLPAPER_TILE) {
tile[0] = '1';
style[0] = '1';
}
else if (position == WALLPAPER_CENTER) {
tile[0] = '0';
style[0] = '0';
}
else if (position == WALLPAPER_STRETCH) {
tile[0] = '0';
style[0] = '2';
}
tile[1] = '\0';
style[1] = '\0';
::RegSetValueEx(key, "TileWallpaper", 0, REG_SZ, tile, sizeof(tile));
::RegSetValueEx(key, "WallpaperStyle", 0, REG_SZ, style, sizeof(style));
::SystemParametersInfo(SPI_SETDESKWALLPAPER, 0, ToNewCString(winPath), SPIF_UPDATEINIFILE | SPIF_SENDWININICHANGE);
}
}
return rv;
}
NS_IMETHODIMP
nsWindowsHooks::OpenDefaultClient(const char* aClient)
{
nsresult rv;
// The Default Client section of the Windows Registry looks like this:
//
// Clients\aClient\
// e.g. aClient = "Mail"...
// \Mail\(default) = Client Subkey Name
// \Client Subkey Name
// \Client Subkey Name\shell\open\command\
// \Client Subkey Name\shell\open\command\(default) = path to exe
//
nsCAutoString clientKey(NS_LITERAL_CSTRING("SOFTWARE\\Clients\\"));
clientKey += aClient;
nsXPIDLCString defaultClient;
rv = GetRegistryEntry(nsIWindowsRegistry::HKLM, clientKey.get(), "",
getter_Copies(defaultClient));
if (NS_FAILED(rv) || defaultClient.IsEmpty())
return rv;
clientKey.Append("\\");
clientKey.Append(defaultClient.get());
clientKey.Append("\\shell\\open\\command");
nsXPIDLCString path;
rv = GetRegistryEntry(nsIWindowsRegistry::HKLM, clientKey.get(), "",
getter_Copies(path));
if (NS_FAILED(rv) || path.IsEmpty())
return rv;
// Look for any embedded environment variables and substitute their
// values, as |::CreateProcess| is unable to do this.
PRInt32 end = path.Length();
PRInt32 cursor = 0, temp = 0;
char buf[_MAX_PATH];
do {
cursor = path.FindChar('%', cursor);
if (cursor < 0)
break;
temp = path.FindChar('%', cursor + 1);
++cursor;
::ZeroMemory(&buf, sizeof(buf));
::GetEnvironmentVariable(nsCAutoString(Substring(path, cursor, temp - cursor)).get(),
buf, sizeof(buf));
// "+ 2" is to subtract the extra characters used to delimit the environment
// variable ('%').
path.Replace((cursor - 1), temp - cursor + 2, nsDependentCString(buf));
++cursor;
}
while (cursor < end);
STARTUPINFO si;
PROCESS_INFORMATION pi;
::ZeroMemory(&si, sizeof(STARTUPINFO));
::ZeroMemory(&pi, sizeof(PROCESS_INFORMATION));
char* pathCStr = ToNewCString(path);
BOOL success = ::CreateProcess(NULL, pathCStr, NULL, NULL, FALSE, 0, NULL,
NULL, &si, &pi);
nsCRT::free(pathCStr);
if (!success)
return NS_ERROR_FAILURE;
return NS_OK;
}
NS_IMETHODIMP
nsWindowsHooks::GetUnreadMailCount(PRUint32* aResult)
{
*aResult = 0;
HKEY accountKey;
if (GetMailAccountKey(&accountKey)) {
DWORD type, length, unreadCount;
DWORD result = ::RegQueryValueEx(accountKey, "MessageCount", 0, &type,
(LPBYTE)&unreadCount, &length);
if (result == ERROR_SUCCESS) {
*aResult = unreadCount;
}
}
return NS_OK;
}
PRBool
nsWindowsHooks::GetMailAccountKey(HKEY* aResult)
{
HKEY mailKey;
DWORD result = ::RegOpenKeyEx(HKEY_CURRENT_USER,
"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\UnreadMail\\",
0, KEY_ENUMERATE_SUB_KEYS, &mailKey);
PRInt32 i = 0;
do {
char subkeyName[_MAX_PATH];
DWORD len = sizeof subkeyName;
result = ::RegEnumKeyEx(mailKey, i++, subkeyName, &len, 0, 0, 0, 0);
if (result == ERROR_SUCCESS) {
HKEY accountKey;
result = ::RegOpenKeyEx(mailKey, subkeyName, 0, KEY_READ, &accountKey);
if (result == ERROR_SUCCESS) {
*aResult = accountKey;
return PR_TRUE;
}
}
else
break;
}
while (1);
return PR_FALSE;
}

128
mozilla/browser/components/winhooks/nsWindowsHooks.h
View File

@ -1,128 +0,0 @@
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: NPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Netscape Public License
* Version 1.1 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://www.mozilla.org/NPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is mozilla.org code.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 1998
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Aaron Kaluszka <ask@swva.net>
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the NPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the NPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#ifndef nswindowshooks_h____
#define nswindowshooks_h____
#include "nscore.h"
#include "nsIWindowsHooks.h"
#include <windows.h>
#ifndef MAX_BUF
#define MAX_BUF 4096
#endif
/* c09bc130-0a71-11d4-8076-00600811a9c3 */
#define NS_IWINDOWSHOOKS_CID \
{ 0xc09bc130, 0x0a71, 0x11d4, {0x80, 0x76, 0x00, 0x60, 0x08, 0x11, 0xa9, 0xc3} }
class nsWindowsHooksSettings : public nsIWindowsHooksSettings {
public:
// ctor/dtor
nsWindowsHooksSettings();
virtual ~nsWindowsHooksSettings();
// Declare all interface methods we must implement.
NS_DECL_ISUPPORTS
NS_DECL_NSIWINDOWSHOOKSSETTINGS
// Typedef for nsIWindowsHooksSettings getter/setter member functions.
typedef
NS_STDCALL_FUNCPROTO(nsresult,
getter,
nsIWindowsHooksSettings, GetShowDialog,
(PRBool*));
typedef
NS_STDCALL_FUNCPROTO(nsresult,
setter,
nsIWindowsHooksSettings, SetShowDialog,
(PRBool));
protected:
// General purpose getter.
NS_IMETHOD Get( PRBool *result, PRBool nsWindowsHooksSettings::*member );
// General purpose setter.
NS_IMETHOD Set( PRBool value, PRBool nsWindowsHooksSettings::*member );
private:
// Internet shortcut protocols.
PRBool mHandleHTTP;
PRBool mHandleHTTPS;
// File types.
PRBool mHandleHTML;
PRBool mHandleXHTML;
// Dialog
PRBool mShowDialog;
// Special member to handle initialization.
PRBool mHaveBeenSet;
NS_IMETHOD GetHaveBeenSet( PRBool * );
NS_IMETHOD SetHaveBeenSet( PRBool );
// Give nsWindowsHooks full access.
friend class nsWindowsHooks;
}; // nsWindowsHooksSettings
class nsWindowsHooks : public nsIWindowsHooks, public nsIWindowsRegistry {
public:
// ctor/dtor
nsWindowsHooks();
virtual ~nsWindowsHooks();
// Declare all interface methods we must implement.
NS_DECL_ISUPPORTS
NS_DECL_NSIWINDOWSHOOKS
NS_DECL_NSIWINDOWSREGISTRY
protected:
// Internal flavor of GetPreferences.
NS_IMETHOD GetSettings( nsWindowsHooksSettings ** );
PRBool GetMailAccountKey(HKEY* aResult);
// Set registry according to settings.
NS_IMETHOD SetRegistry();
char mShortcutPath[MAX_BUF];
char mShortcutName[MAX_BUF];
char mShortcutBase[MAX_BUF];
char mShortcutProg[MAX_BUF];
}; // nsWindowsHooksSettings
#endif // nswindowshooks_h____

795
mozilla/browser/components/winhooks/nsWindowsHooksUtil.cpp
View File

@ -1,795 +0,0 @@
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: NPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Netscape Public License
* Version 1.1 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://www.mozilla.org/NPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is mozilla.org code.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 1998
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Bill Law <law@netscape.com>
* Dean Tessman <dean_tessman@hotmail.com>
* Blake Ross <blake@blakeross.com>
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the NPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the NPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#include <windows.h>
#include <stdlib.h>
#include <string.h>
#include "nsString.h"
#include "nsINativeAppSupportWin.h"
#include "nsIStringBundle.h"
#include "nsDirectoryService.h"
#include "nsAppDirectoryServiceDefs.h"
#define MOZ_HWND_BROADCAST_MSG_TIMEOUT 5000
#define MOZ_CLIENT_BROWSER_KEY "Software\\Clients\\StartMenuInternet"
// Where Mozilla stores its own registry values.
const char * const mozillaKeyName = "Software\\Mozilla\\Desktop";
static const char shortcutSuffix[] = " -url \"%1\"";
static const char chromeSuffix[] = " -chrome \"%1\"";
static const char iconSuffix[] = ",0";
// Returns the (fully-qualified) name of this executable.
static nsCString thisApplication() {
static nsCAutoString result;
if ( result.IsEmpty() ) {
char buffer[MAX_PATH] = { 0 };
DWORD len = ::GetModuleFileName( NULL, buffer, sizeof buffer );
len = ::GetShortPathName( buffer, buffer, sizeof buffer );
result = buffer;
ToUpperCase(result);
}
return result;
}
// Returns the "short" name of this application (in upper case). This is for
// use as a StartMenuInternet value.
static nsCString shortAppName() {
static nsCAutoString result;
if ( result.IsEmpty() ) {
// Find last backslash in thisApplication().
nsCAutoString thisApp( thisApplication() );
PRInt32 n = thisApp.RFind( "\\" );
if ( n != kNotFound ) {
// Use what comes after the last backslash.
result = (const char*)thisApp.get() + n + 1;
} else {
// Use entire string.
result = thisApp;
}
}
return result;
}
// RegistryEntry
//
// Generic registry entry (no saving of previous values). Each is comprised of:
// o A base HKEY
// o A subkey name.
// o An optional value name (empty for the "default" value).
// o The registry setting we'd like this entry to have when set.
struct RegistryEntry {
HKEY baseKey; // e.g., HKEY_CURRENT_USER
PRBool isNull; // i.e., should use ::RegDeleteValue
nsCString keyName; // Key name.
nsCString valueName; // Value name (can be empty, which implies NULL).
nsCString setting; // What we set it to.
RegistryEntry( HKEY baseKey, const char* keyName, const char* valueName, const char* setting )
: baseKey( baseKey ), isNull( setting == 0 ), keyName( keyName ), valueName( valueName ), setting( setting ? setting : "" ) {
}
PRBool isAlreadySet() const;
nsresult set();
nsresult reset();
nsCString currentSetting( PRBool *currentUndefined = 0 ) const;
// Return value name in proper form for passing to ::Reg functions
// (i.e., emptry string is converted to a NULL pointer).
const char* valueNameArg() const {
return valueName.IsEmpty() ? NULL : valueName.get();
}
nsCString fullName() const;
};
// BoolRegistryEntry
//
// These are used to store the "windows integration" preferences.
// You can query the value via operator void* (i.e., if ( boolPref )... ).
// These are stored under HKEY_LOCAL_MACHINE\Software\Mozilla\Desktop.
// Set sets the stored value to "1". Reset deletes it (which implies 0).
struct BoolRegistryEntry : public RegistryEntry {
BoolRegistryEntry( const char *name )
: RegistryEntry( HKEY_LOCAL_MACHINE, mozillaKeyName, name, "1" ) {
}
operator PRBool();
};
// SavedRegistryEntry
//
// Like a plain RegistryEntry, but set/reset save/restore the
// it had before we set it.
struct SavedRegistryEntry : public RegistryEntry {
SavedRegistryEntry( HKEY baseKey, const char *keyName, const char *valueName, const char *setting )
: RegistryEntry( baseKey, keyName, valueName, setting ) {
}
nsresult set();
nsresult reset();
};
// ProtocolRegistryEntry
//
// For setting entries for a given Internet Shortcut protocol.
// The key name is calculated as
// HKEY_LOCAL_MACHINE\Software\Classes\protocol\shell\open\command.
// The setting is this executable (with appropriate suffix).
// Set/reset are trickier in this case.
struct ProtocolRegistryEntry : public SavedRegistryEntry {
nsCString protocol;
ProtocolRegistryEntry( const char* protocol )
: SavedRegistryEntry( HKEY_LOCAL_MACHINE, "", "", thisApplication().get() ),
protocol( protocol ) {
keyName = "Software\\Classes\\";
keyName += protocol;
keyName += "\\shell\\open\\command";
// Append appropriate suffix to setting.
if ( this->protocol.Equals( "chrome" ) || this->protocol.Equals( "MozillaXUL" ) ) {
// Use "-chrome" command line flag.
setting += chromeSuffix;
} else {
// Use standard "-url" command line flag.
setting += shortcutSuffix;
}
}
nsresult set();
nsresult reset();
};
// ProtocolIconRegistryEntry
//
// For setting icon entries for a given Internet Shortcut protocol.
// The key name is calculated as
// HKEY_LOCAL_MACHINE\Software\Classes\protocol\DefaultIcon.
// The setting is this executable (with appropriate suffix).
struct ProtocolIconRegistryEntry : public SavedRegistryEntry {
nsCString protocol;
ProtocolIconRegistryEntry( const char* aprotocol )
: SavedRegistryEntry( HKEY_LOCAL_MACHINE, "", "", thisApplication().get() ),
protocol( aprotocol ) {
keyName = NS_LITERAL_CSTRING("Software\\Classes\\") + protocol + NS_LITERAL_CSTRING("\\DefaultIcon");
// Append appropriate suffix to setting.
setting += iconSuffix;
}
};
// DDERegistryEntry
//
// Like a protocol registry entry, but for the shell\open\ddeexec subkey.
//
// We need to remove this subkey entirely to ensure we work properly with
// various programs on various platforms (see Bugzilla bugs 59078, 58770, etc.).
//
// We don't try to save everything, though. We do save the known useful info
// under the ddeexec subkey:
// ddeexec\@
// ddeexec\NoActivateHandler
// ddeexec\Application\@
// ddeexec\Topic\@
//
// set/reset save/restore these values and remove/restore the ddeexec subkey
struct DDERegistryEntry : public SavedRegistryEntry {
DDERegistryEntry( const char *protocol )
: SavedRegistryEntry( HKEY_LOCAL_MACHINE, "", "", 0 ),
activate( HKEY_LOCAL_MACHINE, "", "NoActivateHandler", 0 ),
app( HKEY_LOCAL_MACHINE, "", "", 0 ),
topic( HKEY_LOCAL_MACHINE, "", "", 0 ) {
// Derive keyName from protocol.
keyName = "Software\\Classes\\";
keyName += protocol;
keyName += "\\shell\\open\\ddeexec";
// Set subkey names.
activate.keyName = keyName;
app.keyName = keyName;
app.keyName += "\\Application";
topic.keyName = keyName;
topic.keyName += "\\Topic";
}
nsresult set();
nsresult reset();
SavedRegistryEntry activate, app, topic;
};
// FileTypeRegistryEntry
//
// For setting entries relating to a file extension (or extensions).
// This object itself is for the "file type" associated with the extension.
// Set/reset manage the mapping from extension to the file type, as well.
// The description is taken from defDescKey if available. Otherwise desc
// is used.
struct FileTypeRegistryEntry : public ProtocolRegistryEntry {
nsCString fileType;
const char **ext;
nsCString desc;
nsCString defDescKey;
nsCString iconFile;
FileTypeRegistryEntry ( const char **ext, const char *fileType,
const char *desc, const char *defDescKey, const char *iconFile )
: ProtocolRegistryEntry( fileType ),
fileType( fileType ),
ext( ext ),
desc( desc ),
defDescKey(defDescKey),
iconFile(iconFile) {
}
nsresult set();
nsresult reset();
};
// Generate the "full" name of this registry entry.
nsCString RegistryEntry::fullName() const {
nsCString result;
if ( baseKey == HKEY_CURRENT_USER ) {
result = "HKEY_CURRENT_USER\\";
} else if ( baseKey == HKEY_LOCAL_MACHINE ) {
result = "HKEY_LOCAL_MACHINE\\";
} else {
result = "\\";
}
result += keyName;
if ( !valueName.IsEmpty() ) {
result += "[";
result += valueName;
result += "]";
}
return result;
}
// Tests whether registry entry already has desired setting.
PRBool RegistryEntry::isAlreadySet() const {
PRBool result = FALSE;
nsCAutoString current( currentSetting() );
result = ( current == setting );
return result;
}
// Gives registry entry the desired setting.
nsresult RegistryEntry::set() {
#ifdef DEBUG_law
if ( isNull && setting.IsEmpty() ) printf( "Deleting %s\n", fullName().get() );
else printf( "Setting %s=%s\n", fullName().get(), setting.get() );
#endif
nsresult result = NS_ERROR_FAILURE;
HKEY key;
LONG rc = ::RegOpenKey( baseKey, keyName.get(), &key );
// See if key doesn't exist yet...
if ( rc == ERROR_FILE_NOT_FOUND ) {
rc = ::RegCreateKey( baseKey, keyName.get(), &key );
}
if ( rc == ERROR_SUCCESS ) {
if ( isNull && setting.IsEmpty() ) {
// This means we need to actually remove the value, not merely set it to an
// empty string.
rc = ::RegDeleteValue( key, valueNameArg() );
if ( rc == ERROR_SUCCESS ) {
result = NS_OK;
}
} else {
// Get current value to see if it is set properly already.
char buffer[4096] = { 0 };
DWORD len = sizeof buffer;
rc = ::RegQueryValueEx( key, valueNameArg(), NULL, NULL, (LPBYTE)buffer, &len );
if ( rc != ERROR_SUCCESS || strcmp( setting.get(), buffer ) != 0 ) {
rc = ::RegSetValueEx( key, valueNameArg(), 0, REG_SZ, (LPBYTE)setting.get(), setting.Length() );
#ifdef DEBUG_law
NS_WARN_IF_FALSE( rc == ERROR_SUCCESS, fullName().get() );
#endif
if ( rc == ERROR_SUCCESS ) {
result = NS_OK;
}
} else {
// Already has desired setting.
result = NS_OK;
}
}
::RegCloseKey( key );
} else {
#ifdef DEBUG_law
NS_WARN_IF_FALSE( rc == ERROR_SUCCESS, fullName().get() );
#endif
}
return result;
}
// Get current setting, set new one, then save the previous.
nsresult SavedRegistryEntry::set() {
nsresult rv = NS_OK;
PRBool currentlyUndefined = PR_TRUE;
nsCAutoString prev( currentSetting( &currentlyUndefined ) );
// See if value is changing.
// We need an extra check for the case where we have an empty entry
// and we need to remove it entirely.
if ( setting != prev || ( !currentlyUndefined && isNull ) ) {
// Set new.
rv = RegistryEntry::set();
if ( NS_SUCCEEDED( rv ) ) {
// Save old.
RegistryEntry tmp( HKEY_LOCAL_MACHINE, "Software\\Mozilla\\Desktop", fullName().get(), prev.get() );
tmp.set();
}
}
return rv;
}
// setWindowsXP
//
// We need to:
// a. Make sure this application is registered as a "Start Menu
// internet app" under HKLM\Software\Clients\StartMenuInternet.
// b. Make this app the default "Start Menu internet app" for this
// user.
static void setWindowsXP() {
// We test for the presence of this subkey as a WindowsXP test.
// We do it this way so that vagueries of future Windows versions
// are handled as best we can.
HKEY key;
nsCAutoString baseKey( NS_LITERAL_CSTRING( "Software\\Clients\\StartMenuInternet" ) );
LONG rc = ::RegOpenKey( HKEY_LOCAL_MACHINE, baseKey.get(), &key );
if ( rc == ERROR_SUCCESS ) {
// OK, this is WindowsXP (or equivalent). Add this application to the
// set registered as "Start Menu internet apps." These entries go
// under the subkey MOZILLA.EXE (or whatever the name of this executable is),
// that subkey name is generated by the utility function shortAppName.
if ( rc == ERROR_SUCCESS ) {
// The next 3 go under this subkey.
nsCAutoString subkey( baseKey + NS_LITERAL_CSTRING( "\\" ) + shortAppName() );
// Pretty name. This goes into the LocalizedString value. It is the
// name of the executable (preceded by '@'), followed by ",-nnn" where
// nnn is the resource identifier of the string in the .exe. That value
// comes from nsINativeAppSupportWin.h.
char buffer[ _MAX_PATH + 8 ]; // Path, plus '@', comma, minus, and digits (5)
_snprintf( buffer, sizeof buffer, "@%s,-%d", thisApplication().get(), IDS_STARTMENU_APPNAME );
RegistryEntry tmp_entry1( HKEY_LOCAL_MACHINE,
subkey.get(),
"LocalizedString",
buffer );
tmp_entry1.set();
// Default icon (from .exe resource).
RegistryEntry tmp_entry2( HKEY_LOCAL_MACHINE,
nsCAutoString( subkey + NS_LITERAL_CSTRING( "\\DefaultIcon" ) ).get(),
"",
nsCAutoString( thisApplication() + NS_LITERAL_CSTRING( ",0" ) ).get() );
tmp_entry2.set();
// Command to open.
RegistryEntry tmp_entry3( HKEY_LOCAL_MACHINE,
nsCAutoString( subkey + NS_LITERAL_CSTRING( "\\shell\\open\\command" ) ).get(),
"",
thisApplication().get() );
tmp_entry3.set();
// "Properties" verb. The default value is the text that will appear in the menu.
// The default value under the command subkey is the name of this application, with
// arguments to cause the Preferences window to appear.
nsCOMPtr<nsIStringBundleService> bundleService( do_GetService( "@mozilla.org/intl/stringbundle;1" ) );
nsCOMPtr<nsIStringBundle> bundle;
nsXPIDLString label;
if ( bundleService &&
NS_SUCCEEDED( bundleService->CreateBundle( "chrome://global-platform/locale/nsWindowsHooks.properties",
getter_AddRefs( bundle ) ) ) &&
NS_SUCCEEDED( bundle->GetStringFromName( NS_LITERAL_STRING( "prefsLabel" ).get(), getter_Copies( label ) ) ) ) {
// Set the label that will appear in the start menu context menu.
RegistryEntry tmp_entry4( HKEY_LOCAL_MACHINE,
nsCAutoString( subkey + NS_LITERAL_CSTRING( "\\shell\\properties" ) ).get(),
"",
NS_ConvertUCS2toUTF8( label ).get() );
tmp_entry4.set();
}
RegistryEntry tmp_entry5( HKEY_LOCAL_MACHINE,
nsCAutoString( subkey + NS_LITERAL_CSTRING( "\\shell\\properties\\command" ) ).get(),
"", nsCAutoString( thisApplication() +
#ifndef MOZ_PHOENIX
NS_LITERAL_CSTRING(" -chrome \"chrome://communicator/content/pref/pref.xul\"") ).get()
#else
NS_LITERAL_CSTRING(" -chrome \"chrome://browser/content/pref/pref.xul\"") ).get()
#endif
);
tmp_entry5.set();
// Now we need to select our application as the default start menu internet application.
// This is accomplished by first trying to store our subkey name in
// HKLM\Software\Clients\StartMenuInternet's default value. See
// http://support.microsoft.com/directory/article.asp?ID=KB;EN-US;Q297878 for detail.
SavedRegistryEntry hklmAppEntry( HKEY_LOCAL_MACHINE, baseKey.get(), "", shortAppName().get() );
hklmAppEntry.set();
// That may or may not have worked (depending on whether we have sufficient access).
if ( hklmAppEntry.currentSetting() == hklmAppEntry.setting ) {
// We've set the hklm entry, so we can delete the one under hkcu.
SavedRegistryEntry tmp_entry6( HKEY_CURRENT_USER, baseKey.get(), "", 0 );
tmp_entry6.set();
} else {
// All we can do is set the default start menu internet app for this user.
SavedRegistryEntry tmp_entry7( HKEY_CURRENT_USER, baseKey.get(), "", shortAppName().get() );
}
// Notify the system of the changes.
::SendMessageTimeout( HWND_BROADCAST,
WM_SETTINGCHANGE,
0,
(LPARAM)MOZ_CLIENT_BROWSER_KEY,
SMTO_NORMAL|SMTO_ABORTIFHUNG,
MOZ_HWND_BROADCAST_MSG_TIMEOUT,
NULL);
}
}
}
// Set this entry and its corresponding DDE entry. The DDE entry
// must be turned off to stop Windows from trying to use DDE.
nsresult ProtocolRegistryEntry::set() {
// If the protocol is http, then we have to do special stuff.
// We must take care of this first because setting the "protocol entry"
// for http will cause WindowsXP to do stuff automatically for us,
// thereby making it impossible for us to propertly reset.
if ( protocol == NS_LITERAL_CSTRING( "http" ) ) {
setWindowsXP();
}
// Set this entry.
nsresult rv = SavedRegistryEntry::set();
// Save and set corresponding DDE entry(ies).
DDERegistryEntry( protocol.get() ).set();
// Set icon.
ProtocolIconRegistryEntry( protocol.get() ).set();
return rv;
}
// Not being a "saved" entry, we can't restore, so just delete it.
nsresult RegistryEntry::reset() {
HKEY key;
LONG rc = ::RegOpenKey( baseKey, keyName.get(), &key );
if ( rc == ERROR_SUCCESS ) {
rc = ::RegDeleteValue( key, valueNameArg() );
#ifdef DEBUG_law
if ( rc == ERROR_SUCCESS ) printf( "Deleting key=%s\n", (const char*)fullName().get() );
#endif
}
return NS_OK;
}
// Resets registry entry to the saved value (if there is one). We first
// ensure that we still "own" that entry (by comparing its value to what
// we would set it to).
nsresult SavedRegistryEntry::reset() {
nsresult result = NS_OK;
// Get current setting for this key/value.
nsCAutoString current( currentSetting() );
// Test if we "own" it.
if ( current == setting ) {
// Unset it, then. First get saved value it had previously.
PRBool noSavedValue = PR_TRUE;
RegistryEntry saved = RegistryEntry( HKEY_LOCAL_MACHINE, mozillaKeyName, fullName().get(), "" );
// There are 3 cases:
// - no saved entry
// - empty saved entry
// - a non-empty saved entry
// We delete the current entry in the first case, and restore
// the saved entry (empty or otherwise) in the other two.
setting = saved.currentSetting( &noSavedValue );
if ( !setting.IsEmpty() || !noSavedValue ) {
// Set to previous value.
isNull = PR_FALSE; // Since we're resetting and the saved value may be empty, we
// need to make sure set() doesn't mistakenly delete this entry.
result = RegistryEntry::set();
// Remove saved entry.
saved.reset();
} else {
// No saved value, just delete this entry.
result = RegistryEntry::reset();
}
}
return result;
}
// resetWindowsXP
//
// This function undoes "setWindowsXP," more or less. It only needs to restore the selected
// default Start Menu internet application. The registration of this application as one of
// the start menu internet apps can remain. There is no check for the presence of anything
// because the SaveRegistryEntry::reset calls will have no effect if there is no value at that
// location (or, if that value has been changed by another application).
static void resetWindowsXP() {
NS_NAMED_LITERAL_CSTRING( baseKey, "Software\\Clients\\StartMenuInternet" );
// First, try to restore the HKLM setting. This will fail if either we didn't
// set that, or, if we don't have access).
SavedRegistryEntry tmp_entry8( HKEY_LOCAL_MACHINE, baseKey.get(), "", shortAppName().get() );
tmp_entry8.reset();
// The HKCU setting is trickier. We may have set it, but we may also have
// removed it (see setWindowsXP(), above). We first try to reverse the
// setting. If we had removed it, then this will fail.
SavedRegistryEntry tmp_entry9( HKEY_CURRENT_USER, baseKey.get(), "", shortAppName().get() );
tmp_entry9.reset();
// Now, try to reverse the removal of this key. This will fail if there is a current
// setting, and will only work if this key is unset, and, we have a saved value.
SavedRegistryEntry tmp_entry10( HKEY_CURRENT_USER, baseKey.get(), "", 0 );
tmp_entry10.reset();
// Notify the system of the changes.
::SendMessageTimeout( HWND_BROADCAST,
WM_SETTINGCHANGE,
0,
(LPARAM)MOZ_CLIENT_BROWSER_KEY,
SMTO_NORMAL|SMTO_ABORTIFHUNG,
MOZ_HWND_BROADCAST_MSG_TIMEOUT,
NULL);
}
// Restore this entry and corresponding DDE entry.
nsresult ProtocolRegistryEntry::reset() {
// Restore this entry.
nsresult rv = SavedRegistryEntry::reset();
// Do same for corresponding DDE entry.
DDERegistryEntry( protocol.get() ).reset();
// Reset icon.
ProtocolIconRegistryEntry( protocol.get() ).reset();
// For http:, on WindowsXP, we need to do some extra cleanup.
if ( protocol == NS_LITERAL_CSTRING( "http" ) ) {
resetWindowsXP();
}
return rv;
}
static DWORD deleteKey( HKEY baseKey, const char *keyName ) {
// Make sure input subkey isn't null.
DWORD rc;
if ( keyName && ::strlen(keyName) ) {
// Open subkey.
HKEY key;
rc = ::RegOpenKeyEx( baseKey,
keyName,
0,
KEY_ENUMERATE_SUB_KEYS | DELETE,
&key );
// Continue till we get an error or are done.
while ( rc == ERROR_SUCCESS ) {
char subkeyName[_MAX_PATH];
DWORD len = sizeof subkeyName;
// Get first subkey name. Note that we always get the
// first one, then delete it. So we need to get
// the first one next time, also.
rc = ::RegEnumKeyEx( key,
0,
subkeyName,
&len,
0,
0,
0,
0 );
if ( rc == ERROR_NO_MORE_ITEMS ) {
// No more subkeys. Delete the main one.
rc = ::RegDeleteKey( baseKey, keyName );
break;
} else if ( rc == ERROR_SUCCESS ) {
// Another subkey, delete it, recursively.
rc = deleteKey( key, subkeyName );
}
}
// Close the key we opened.
::RegCloseKey( key );
} else {
rc = ERROR_BADKEY;
}
return rc;
}
// Set the "dde" entry by deleting the main ddexec subkey
// under HKLM\Software\Classes\<protocol>\shell\open.
// We "set" the various subkeys in order to preserve useful
// information.
nsresult DDERegistryEntry::set() {
nsresult rv = SavedRegistryEntry::set();
rv = activate.set();
rv = app.set();
rv = topic.set();
// We've saved what we can. Now recurse through this key and
// subkeys. This is necessary due to the fact that
// ::RegDeleteKey won't work on WinNT (and Win2k?) if there are
// subkeys.
if ( deleteKey( baseKey, keyName.get() ) != ERROR_SUCCESS ) {
rv = NS_ERROR_FAILURE;
}
return rv;
}
// Reset the main (ddeexec) value but also the Application and Topic.
// We reset the app/topic even though we no longer set them. This
// handles cases where the user installed a prior version, and then
// upgraded.
nsresult DDERegistryEntry::reset() {
nsresult rv = SavedRegistryEntry::reset();
rv = activate.reset();
rv = app.reset();
rv = topic.reset();
return rv;
}
// Return current setting for this registry entry.
// Optionally, the caller can ask that a boolean be set to indicate whether
// the registry value is undefined. This flag can be used to distinguish
// between not defined at all versus simply empty (both of which return an
// empty string).
nsCString RegistryEntry::currentSetting( PRBool *currentlyUndefined ) const {
nsCString result;
if ( currentlyUndefined ) {
*currentlyUndefined = PR_TRUE;
}
HKEY key;
LONG rc = ::RegOpenKey( baseKey, keyName.get(), &key );
if ( rc == ERROR_SUCCESS ) {
char buffer[4096] = { 0 };
DWORD len = sizeof buffer;
rc = ::RegQueryValueEx( key, valueNameArg(), NULL, NULL, (LPBYTE)buffer, &len );
if ( rc == ERROR_SUCCESS ) {
result = buffer;
if ( currentlyUndefined ) {
*currentlyUndefined = PR_FALSE; // Indicate entry is present.
}
}
::RegCloseKey( key );
}
return result;
}
// For each file extension, map it to this entry's file type.
// Set the file type so this application opens files of that type.
nsresult FileTypeRegistryEntry::set() {
nsresult rv = NS_OK;
// Set file extensions.
for ( int i = 0; NS_SUCCEEDED( rv ) && ext[i]; i++ ) {
nsCAutoString thisExt( "Software\\Classes\\" );
thisExt += ext[i];
rv = SavedRegistryEntry( HKEY_LOCAL_MACHINE, thisExt.get(), "", fileType.get() ).set();
}
// If OK, set file type opener.
if ( NS_SUCCEEDED( rv ) ) {
rv = ProtocolRegistryEntry::set();
// If we just created this file type entry, set description and default icon.
if ( NS_SUCCEEDED( rv ) ) {
nsCAutoString iconFileToUse( "%1" );
nsCAutoString descKey( "Software\\Classes\\" );
descKey += protocol;
RegistryEntry descEntry( HKEY_LOCAL_MACHINE, descKey.get(), NULL, "" );
if ( descEntry.currentSetting().IsEmpty() ) {
nsCAutoString defaultDescKey( "Software\\Classes\\" );
defaultDescKey += defDescKey;
RegistryEntry defaultDescEntry( HKEY_LOCAL_MACHINE, defaultDescKey.get(), NULL, "" );
descEntry.setting = defaultDescEntry.currentSetting();
if ( descEntry.setting.IsEmpty() )
descEntry.setting = desc;
descEntry.set();
}
nsCAutoString iconKey( "Software\\Classes\\" );
iconKey += protocol;
iconKey += "\\DefaultIcon";
if ( !iconFile.Equals(iconFileToUse) ) {
iconFileToUse = thisApplication() + NS_LITERAL_CSTRING( ",0" );
// Check to see if there's an icon file name associated with this extension.
// If there is, then we need to use this icon file. If not, then we default
// to the main app's icon.
if ( !iconFile.IsEmpty() ) {
nsCOMPtr<nsIFile> iconFileSpec;
PRBool flagExists;
// Use the directory service to get the path to the chrome folder. The
// icons will be located in [chrome dir]\icons\default.
// The abs path to the icon has to be in the short filename
// format, else it won't work under win9x systems.
rv = NS_GetSpecialDirectory( NS_APP_CHROME_DIR, getter_AddRefs( iconFileSpec ) );
if ( NS_SUCCEEDED( rv ) ) {
iconFileSpec->AppendNative( NS_LITERAL_CSTRING( "icons" ) );
iconFileSpec->AppendNative( NS_LITERAL_CSTRING( "default" ) );
iconFileSpec->AppendNative( iconFile );
// Check to make sure that the icon file exists on disk.
iconFileSpec->Exists( &flagExists );
if ( flagExists ) {
rv = iconFileSpec->GetNativePath( iconFileToUse );
if ( NS_SUCCEEDED( rv ) ) {
TCHAR buffer[MAX_PATH];
DWORD len;
// Get the short path name (8.3) format for iconFileToUse
// else it won't work under win9x.
len = ::GetShortPathName( iconFileToUse.get(), buffer, sizeof buffer );
NS_ASSERTION ( (len > 0) && ( len < sizeof buffer ), "GetShortPathName failed!" );
iconFileToUse.Assign( buffer );
iconFileToUse.Append( NS_LITERAL_CSTRING( ",0" ) );
}
}
}
}
}
RegistryEntry iconEntry( HKEY_LOCAL_MACHINE, iconKey.get(), NULL, iconFileToUse.get() );
if( !iconEntry.currentSetting().Equals( iconFileToUse ) )
iconEntry.set();
}
}
return rv;
}
// Basically, the inverse of set().
// First, reset the opener for this entry's file type.
// Then, reset the file type associated with each extension.
nsresult FileTypeRegistryEntry::reset() {
nsresult rv = ProtocolRegistryEntry::reset();
for ( int i = 0; ext[ i ]; i++ ) {
nsCAutoString thisExt( "Software\\Classes\\" );
thisExt += ext[i];
(void)SavedRegistryEntry( HKEY_LOCAL_MACHINE, thisExt.get(), "", fileType.get() ).reset();
}
return rv;
}
// Convert current registry setting to boolean.
BoolRegistryEntry::operator PRBool() {
return currentSetting().Equals( "1" ) ? PR_TRUE : PR_FALSE;
}

34
mozilla/browser/components/winhooks/public/Makefile.in
View File

@ -1,34 +0,0 @@
#
# The contents of this file are subject to the Mozilla Public
# License Version 1.1 (the "License"); you may not use this file
# except in compliance with the License. You may obtain a copy of
# the License at http://www.mozilla.org/MPL/
#
# Software distributed under the License is distributed on an "AS
# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
# implied. See the License for the specific language governing
# rights and limitations under the License.
#
# The Original Code is mozilla.org code
#
# The Initial Developer of the Original Code is Netscape
# Communications Corporation. Portions created by Netscape are
# Copyright (C) 2001 Netscape Communications Corporation. All
# Rights Reserved.
#
# Contributor(s):
#
DEPTH = ../../../..
topsrcdir = @top_srcdir@
srcdir = @srcdir@
VPATH = @srcdir@
include $(DEPTH)/config/autoconf.mk
MODULE = winhooks
XPIDL_MODULE = winhooks
XPIDLSRCS = nsIWindowsHooks.idl
include $(topsrcdir)/config/rules.mk

254
mozilla/browser/components/winhooks/public/nsIWindowsHooks.idl
View File

@ -1,254 +0,0 @@
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* ***** BEGIN LICENSE BLOCK *****
* Version: NPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Netscape Public License
* Version 1.1 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://www.mozilla.org/NPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is mozilla.org code.
*
* The Initial Developer of the Original Code is
* Netscape Communications Corporation.
* Portions created by the Initial Developer are Copyright (C) 1998
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* Bill Law <law@netscape.com>
* Aaron Kaluszka <ask@swva.net>
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the NPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the NPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#include "nsISupports.idl"
/* These interface provides support for integrating Mozilla into Windows.
* This integration consists primarily of setting Mozilla as the "default
* browser." Or more precisely, setting Mozilla as the executable to
* handle certain file types.
*
* There are two subtly different types of desktop objects that Mozilla
* can be configured to "handle:"
* o File types (based on file extension)
* o Internet shortcuts (based on URL protocol).
*
* While these are different types of objects, the mechanism by which
* applications are matched with them is essentially the same.
*
* In the case of files, there is one more level of indirection. File
* extensions are assigned a "file type" via a Windows registry entry.
* For example, given the file extension ".foo", the file type is
* determined by examing the value stored in the "default" value stored
* at the registry key HKEY_LOCAL_MACHINE\Software\Classes\.foo.
*
* Once you have the "file type" then you use that the same way you use
* Internet Shortcut protocol names to determine which application to
* launch. The application is specified by the default value stored in
* the registry key
* HKEY_LOCAL_MACHINE\Software\Classes\<X>\shell\open\command, where
* <X> is the "file type" or protocol name.
*
* If there are additional keys under "shell" then these appear on the
* context menu for files/shortcuts of this type. Typically, there are
* entries for "print." But Mozilla does not currently support a command
* line option to print so we don't offer that.
*
* Previously, Netscape Communicator made itself the handler of standard
* web things by creating a new file type "NetscapeMarkup" and mapping
* extensions to that (.htm, .html, .shtml, .xbm), or, by setting itself
* up as the "handler" for the file types of other web things (.jpg, .gif)
* and Internet Shortcut protocols (ftp, gopher, http, https, mailto, news,
* snews).
*
* In order to better enable Mozilla to co-exist with other browsers
* (including Communicator), it will create yet another new file type,
* "MozillaMarkup," that will be used to make Mozilla the default handler
* for certain file extensions. This will be done by remapping those
* extensions to this new type.
*
* Mozilla will attempt to remember the original mapping and restore it
* when the user decides to no longer have Mozilla be the default handler
* for that extension.
*
* Mozilla will drop support for some items that are no longer germane:
* the .shtml file extension and the gopher: protocol. We will also, perhaps
* only temporarily, drop support for protocols that aren't accessible from
* the command line: mailto:, news:, and snews:.
*
* We will be adding support for the chrome: protocol (using the "-chrome"
* command line option) and for .png, .xul and .xml file extensions.
*
* Missing Features:
*
* Currently, there is no way to extend the set of file types or protocols
* that Mozilla can be associated with (save manually tweaking the Windows
* registry). This is likely to be a problem for branded Mozilla browsers
* that might support specialized file types or protocols (e.g., .aim files).
*
* The plan is to extend this interface so that such file types and protocols
* can be set up using the implementation of the interfaces defined here.
*/
interface nsIDOMWindowInternal;
interface nsIDOMElement;
/* nsIWindowsHooksSettings
*
* This interface is used to get/set the user preferences relating to
* "windows hooks" (aka "windows integration"). It is basically just
* a conglomeration of a bunch of boolean attributes; it exists mainly
* for historical reasons (it corresponds to the internal Prefs struct
* that was in nsIDefaultBrowser.h in Mozilla Classic).
*/
[scriptable, uuid(4ce9aa90-0a6a-11d4-8076-00600811a9c3)]
interface nsIWindowsHooksSettings : nsISupports {
// Internet shortcuts (based on "protocol").
attribute boolean isHandlingHTTP;
attribute boolean isHandlingHTTPS;
// File handling (based on extension).
attribute boolean isHandlingHTML;
attribute boolean isHandlingXHTML;
// Nag dialog flag. Set this so that dialog
// appears on startup if there is a mismatch
// between registry and these settings.
attribute boolean showDialog;
// Registry mismatch indicator.
// This is true if the Win32 registry is
// currently set to match the preferences
// in this object.
readonly attribute boolean registryMatches;
};
/* nsIWindowsHooks
*
* This interface describes the service that you can use to
* get/set the various windows integration features specified
* by the nsIWindowsHooksPrefs attributes.
*/
[scriptable, uuid(19c9fbb0-06a3-11d4-8076-00600811a9c3)]
interface nsIWindowsHooks : nsISupports
{
/**
* See nsIWindowsHooksSettings; The Windows Registry is updated when
* this attribute is set.
*/
attribute nsIWindowsHooksSettings settings;
/**
* Check that registry matches settings and if not, prompt user for whether
* to reset. This is controlled by the showDialog setting. This will
* perform the check only the first time the service is called.
*
* @param aParent parent window for any dialogs that will appear.
* @return true if the windows integration dialog was shown, false if not.
*/
boolean checkSettings(in nsIDOMWindowInternal aParent);
const PRInt32 WALLPAPER_TILE = 0;
const PRInt32 WALLPAPER_STRETCH = 1;
const PRInt32 WALLPAPER_CENTER = 2;
/**
* Sets the desktop background image using either the HTML <IMG>
* element supplied or the background image of the element supplied.
*
* @param aImageElement Either a HTML <IMG> element or an element with
* a background image from which to source the
* background image.
* @param useBackground Determines whether or not to interpret aImageElement
* as a HTML <IMG> element or as another element whose
* background image should be used.
* @param position How to place the image on the desktop
*/
void setImageAsWallpaper(in nsIDOMElement aImageElement, in boolean useBackground, in PRInt32 position);
/**
* Retrieves the current desktop background color.
*/
PRUint32 getDesktopColor();
/**
* Sets the current desktop background color.
*
* @param color The color to use, in rgb format.
*/
void setDesktopColor(in PRUint32 color);
/**
* Launches one of the Windows default clients.
*
* @param aClient The client type to open, as specified in the Windows Registry under:
* HKEY_LOCAL_MACHINE\Software\Clients\
* Typical values include "Mail", "News", "Contacts" etc.
*/
void openDefaultClient(in string aClient);
/**
* Retrieve the number of unread mail messages from the system for the current user.
*
* @return The number of unread (new) mail messages for the current user.
*/
readonly attribute unsigned long unreadMailCount;
};
/* nsIWindowsRegistry
*
* This interface describes the service that you can use to
* get/set Win32 registry entries.
*
* Notice: This interface is incomplete and should be used at your own risk!
*/
[scriptable, uuid(e07e7430-8d11-417c-83ee-c994400c452f)]
interface nsIWindowsRegistry : nsISupports {
/**
* Valid starting keys for the Windows Registry.
*/
const long HKCR = 0; // HKEY_CLASSES_ROOT
const long HKCC = 1; // HKEY_CURRENT_CONFIG
const long HKCU = 2; // HKEY_CURRENT_USER
const long HKLM = 3; // HKEY_LOCAL_MACHINE
const long HKU = 4; // HKEY_USERS
/**
* Retrieves a Windows Registry entry value.
*
* @param aHKeyConstant The starting key, using the constants defined above.
* @param aSubKeyName The sub key to locate
* @param aValueName The value to locate in the sub key. The empty string
* returns the default value of the sub key.
* @return The value of the specified sub key/value, truncated to 4096 bytes.
*/
string getRegistryEntry(in long aHKeyConstant, in string aSubKeyName, in string aValueName);
};
%{C++
#define NS_IWINDOWSHOOKS_CONTRACTID "@mozilla.org/winhooks;1"
#define NS_IWINDOWSHOOKS_CLASSNAME "Mozilla Windows Integration Hooks"
// XXXben - get rid of this
// The key that is used to write the quick launch appname in the windows registry
#define NS_QUICKLAUNCH_RUN_KEY "Mozilla Quick Launch"
%}