зеркало из https://github.com/mozilla/gecko-dev.git
2463 строки
63 KiB
C++
2463 строки
63 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
*
|
|
* The contents of this file are subject to the Netscape Public License
|
|
* Version 1.0 (the "NPL"); you may not use this file except in
|
|
* compliance with the NPL. You may obtain a copy of the NPL at
|
|
* http://www.mozilla.org/NPL/
|
|
*
|
|
* Software distributed under the NPL is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
|
|
* for the specific language governing rights and limitations under the
|
|
* NPL.
|
|
*
|
|
* The Initial Developer of this code under the NPL is Netscape
|
|
* Communications Corporation. Portions created by Netscape are
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
|
|
* Reserved.
|
|
*/
|
|
|
|
#include "stdafx.h"
|
|
#ifndef _WIN32
|
|
#include <ole2ui.h>
|
|
#include <dispatch.h>
|
|
#endif
|
|
#include "prefs.h"
|
|
#include <olectl.h>
|
|
#include "winprefs/isppageo.h"
|
|
#include "winprefs/brprefid.h"
|
|
#include "winprefs/wprefid.h"
|
|
#include "nsIDefaultBrowser.h"
|
|
#ifdef MOZ_LOC_INDEP
|
|
#include "winprefs/liprefid.h"
|
|
#include "winprefs/iliprefs.h"
|
|
#endif // MOZ_LOC_INDEP
|
|
#ifdef EDITOR
|
|
#include "winprefs/edprefid.h"
|
|
#endif /* EDITOR */
|
|
#ifdef MOZ_MAIL_NEWS
|
|
#include "winprefs/mnprefid.h"
|
|
#include "winprefs/mninterf.h"
|
|
#endif /* MOZ_MAIL_NEWS */
|
|
#include "winprefs/intlfont.h"
|
|
#include "winprefs/ibrprefs.h"
|
|
#include "winprefs/prefuiid.h"
|
|
#include "winprefs/prefui.h"
|
|
#ifdef EDITOR
|
|
#include "edt.h"
|
|
#endif // EDITOR
|
|
#include "prefapi.h"
|
|
#include "helper.h"
|
|
#ifdef MOZ_MAIL_NEWS
|
|
#include "mnprefs.h"
|
|
#include "mailmisc.h"
|
|
#include "wfemsg.h"
|
|
#include "addrbook.h"
|
|
#include "addrfrm.h" // for creating vcards
|
|
#ifdef FEATURE_ADDRPROP
|
|
#include "addrprop.h"
|
|
#endif
|
|
#endif /* MOZ_MAIL_NEWS */
|
|
#ifdef MOZ_SMARTUPDATE
|
|
#include "VerReg.h"
|
|
#include "softupdt.h"
|
|
#endif /* MOZ_SMARTUPDATE */
|
|
#ifdef MOZ_OFFLINE
|
|
#include "offpkdlg.h"
|
|
#endif // MOZ_OFFLINE
|
|
|
|
extern "C" {
|
|
#include "xpgetstr.h"
|
|
#ifdef MOZ_MAIL_NEWS
|
|
extern int MK_ADDR_BOOK_CARD;
|
|
extern int MK_ADDR_NEW_CARD;
|
|
extern int MK_MSG_SENT_L10N_NAME; //Sent folder
|
|
extern int MK_MSG_TEMPLATES_L10N_NAME;
|
|
extern int MK_MSG_DRAFTS_L10N_NAME;
|
|
extern int MK_MSG_REMOVE_HOST_CONFIRM;
|
|
extern int MK_POP3_ONLY_ONE;
|
|
extern int MK_MSG_REMOVE_MAILHOST_CONFIRM;
|
|
#endif /* MOZ_MAIL_NEWS */
|
|
};
|
|
#include "nethelp.h"
|
|
#include "ngdwtrst.h"
|
|
#include "prefinfo.h" //cmanske: for access to global prefInfo struct
|
|
|
|
BOOL g_bReloadAllWindows;
|
|
BOOL g_bReloadChangeColor;
|
|
|
|
#ifdef MOZ_MAIL_NEWS
|
|
extern "C" void GetFolderServerNames
|
|
(char* lpName, int nDefaultID, CString& folder, CString& server);
|
|
extern "C" MSG_Host *DoAddNewsServer(CWnd* pParent, int nFromWhere);
|
|
#endif
|
|
|
|
extern "C" char *FE_GetProgramDirectory(char *buffer, int length);
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Helper functions
|
|
|
|
#ifndef _WIN32
|
|
static LPVOID
|
|
CoTaskMemAlloc(ULONG cb)
|
|
{
|
|
LPMALLOC pMalloc;
|
|
|
|
if (SUCCEEDED(CoGetMalloc(MEMCTX_TASK, &pMalloc))) {
|
|
LPVOID pv = pMalloc->Alloc(cb);
|
|
|
|
pMalloc->Release();
|
|
return pv;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
// Convert an ANSI string to an OLE string (UNICODE string)
|
|
static LPOLESTR NEAR
|
|
AllocTaskOleString(LPCSTR lpszString)
|
|
{
|
|
LPOLESTR lpszResult;
|
|
UINT nLen;
|
|
|
|
if (lpszString == NULL)
|
|
return NULL;
|
|
|
|
// Convert from ANSI to UNICODE
|
|
nLen = lstrlen(lpszString) + 1;
|
|
lpszResult = (LPOLESTR)CoTaskMemAlloc(nLen * sizeof(OLECHAR));
|
|
if (lpszResult) {
|
|
#ifdef _WIN32
|
|
MultiByteToWideChar(CP_ACP, 0, lpszString, -1, lpszResult, nLen);
|
|
#else
|
|
lstrcpy(lpszResult, lpszString); // Win 16 doesn't use any UNICODE
|
|
#endif
|
|
}
|
|
|
|
return lpszResult;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CEnumHelpers
|
|
|
|
// Helper class to encapsulate enumeration of the helper apps
|
|
class CEnumHelpers : public IEnumHelpers {
|
|
public:
|
|
CEnumHelpers();
|
|
|
|
// IUnknown methods
|
|
STDMETHODIMP QueryInterface(REFIID riid, LPVOID FAR* ppvObj);
|
|
STDMETHODIMP_(ULONG) AddRef();
|
|
STDMETHODIMP_(ULONG) Release();
|
|
|
|
// IEnumHelpers methods
|
|
STDMETHODIMP Next(NET_cdataStruct **ppcdata);
|
|
STDMETHODIMP Reset();
|
|
|
|
private:
|
|
ULONG m_uRef;
|
|
XP_List *m_pInfoList;
|
|
};
|
|
|
|
CEnumHelpers::CEnumHelpers()
|
|
{
|
|
m_uRef = 0;
|
|
m_pInfoList = cinfo_MasterListPointer();
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CEnumHelpers::QueryInterface(REFIID riid, LPVOID FAR* ppvObj)
|
|
{
|
|
*ppvObj = NULL;
|
|
|
|
if (riid == IID_IUnknown || riid == IID_IEnumHelpers) {
|
|
*ppvObj = (LPVOID)this;
|
|
AddRef();
|
|
return NOERROR;
|
|
}
|
|
|
|
return ResultFromScode(E_NOINTERFACE);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG)
|
|
CEnumHelpers::AddRef()
|
|
{
|
|
return ++m_uRef;
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG)
|
|
CEnumHelpers::Release()
|
|
{
|
|
if (--m_uRef == 0) {
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
return m_uRef;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CEnumHelpers::Next(NET_cdataStruct **ppcdata)
|
|
{
|
|
CHelperApp *pHelperApp;
|
|
|
|
while ((*ppcdata = (NET_cdataStruct *)XP_ListNextObject(m_pInfoList))) {
|
|
// Ignore items that don't have a MIME type
|
|
if (!(*ppcdata)->ci.type)
|
|
continue;
|
|
|
|
// Don't give the user an opportunity to change application/octet-stream
|
|
// or proxy auto-config
|
|
if (strcmp((*ppcdata)->ci.type, APPLICATION_OCTET_STREAM) == 0 ||
|
|
strcmp((*ppcdata)->ci.type, APPLICATION_NS_PROXY_AUTOCONFIG) == 0) {
|
|
continue;
|
|
}
|
|
|
|
// Ignore items that don't have a description
|
|
if (!(*ppcdata)->ci.desc) {
|
|
#ifdef DEBUG
|
|
TRACE1("PREFS: Ignoring MIME type %s\n", (*ppcdata)->ci.type);
|
|
#endif
|
|
continue;
|
|
}
|
|
|
|
// Make sure there's a CHelperApp associated with the item
|
|
pHelperApp = (CHelperApp *)(*ppcdata)->ci.fe_data;
|
|
|
|
if (!pHelperApp) {
|
|
#ifdef DEBUG
|
|
TRACE1("PREFS: Ignoring MIME type %s\n", (*ppcdata)->ci.type);
|
|
#endif
|
|
continue;
|
|
}
|
|
|
|
// Ignore items that have HANDLE_UNKNOWN or HANDLE_MOREINFO as how to handle
|
|
if (pHelperApp->how_handle == HANDLE_UNKNOWN || pHelperApp->how_handle == HANDLE_MOREINFO) {
|
|
#ifdef DEBUG
|
|
TRACE1("PREFS: Ignoring MIME type %s\n", (*ppcdata)->ci.type);
|
|
#endif
|
|
continue;
|
|
}
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
return ResultFromScode(S_FALSE);
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CEnumHelpers::Reset()
|
|
{
|
|
m_pInfoList = cinfo_MasterListPointer();
|
|
return NOERROR;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CBrowserPrefs
|
|
|
|
class CBrowserPrefs : public IBrowserPrefs {
|
|
public:
|
|
CBrowserPrefs(LPCSTR lpszCurrentPage);
|
|
|
|
// IUnknown methods
|
|
STDMETHODIMP QueryInterface(REFIID riid, LPVOID FAR* ppvObj);
|
|
STDMETHODIMP_(ULONG) AddRef();
|
|
STDMETHODIMP_(ULONG) Release();
|
|
|
|
// IBrowserPrefs methods
|
|
STDMETHODIMP GetCurrentPage(LPOLESTR *lpoleStr);
|
|
|
|
STDMETHODIMP EnumHelpers(LPENUMHELPERS *ppenumHelpers);
|
|
STDMETHODIMP GetHelperInfo(NET_cdataStruct *, LPHELPERINFO);
|
|
STDMETHODIMP SetHelperInfo(NET_cdataStruct *, LPHELPERINFO);
|
|
STDMETHODIMP NewFileType(LPCSTR lpszDescription,
|
|
LPCSTR lpszExtension,
|
|
LPCSTR lpszMimeType,
|
|
LPCSTR lpszOpenCmd,
|
|
NET_cdataStruct **ppcdata);
|
|
STDMETHODIMP RemoveFileType(NET_cdataStruct *);
|
|
|
|
// Initialization routine to create contained and aggregated objects
|
|
HRESULT Init();
|
|
|
|
private:
|
|
ULONG m_uRef;
|
|
LPUNKNOWN m_pCategory; // inner object supporting ISpecifyPropertyPageObjects
|
|
LPCSTR m_lpszCurrentPage;
|
|
};
|
|
|
|
CBrowserPrefs::CBrowserPrefs(LPCSTR lpszCurrentPage)
|
|
{
|
|
m_uRef = 0;
|
|
m_pCategory = NULL;
|
|
m_lpszCurrentPage = lpszCurrentPage ? strdup(lpszCurrentPage) : NULL;
|
|
}
|
|
|
|
HRESULT
|
|
CBrowserPrefs::Init()
|
|
{
|
|
// Create the object as part of an aggregate
|
|
return FEU_CoCreateInstance(CLSID_BrowserPrefs, (LPUNKNOWN)this,
|
|
CLSCTX_INPROC_SERVER, IID_IUnknown, (LPVOID *)&m_pCategory);
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CBrowserPrefs::QueryInterface(REFIID riid, LPVOID FAR* ppvObj)
|
|
{
|
|
*ppvObj = NULL;
|
|
|
|
if (riid == IID_IUnknown || riid == IID_IBrowserPrefs) {
|
|
*ppvObj = (LPVOID)this;
|
|
AddRef();
|
|
return NOERROR;
|
|
|
|
} else if (riid == IID_ISpecifyPropertyPageObjects) {
|
|
assert(m_pCategory);
|
|
return m_pCategory->QueryInterface(riid, ppvObj);
|
|
}
|
|
|
|
return ResultFromScode(E_NOINTERFACE);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG)
|
|
CBrowserPrefs::AddRef()
|
|
{
|
|
return ++m_uRef;
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG)
|
|
CBrowserPrefs::Release()
|
|
{
|
|
if (--m_uRef == 0) {
|
|
if (m_pCategory)
|
|
m_pCategory->Release();
|
|
if (m_lpszCurrentPage)
|
|
XP_FREE((void *)m_lpszCurrentPage);
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
return m_uRef;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CBrowserPrefs::GetCurrentPage(LPOLESTR *lpoleStr)
|
|
{
|
|
if (!lpoleStr)
|
|
return ResultFromScode(E_INVALIDARG);
|
|
|
|
*lpoleStr = 0;
|
|
|
|
if (m_lpszCurrentPage) {
|
|
*lpoleStr = AllocTaskOleString(m_lpszCurrentPage);
|
|
|
|
if (!*lpoleStr)
|
|
return ResultFromScode(E_OUTOFMEMORY);
|
|
}
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CBrowserPrefs::EnumHelpers(LPENUMHELPERS *ppEnumHelpers)
|
|
{
|
|
CEnumHelpers *pEnumHelpers = new CEnumHelpers;
|
|
HRESULT hres;
|
|
|
|
if (!pEnumHelpers)
|
|
return ResultFromScode(E_OUTOFMEMORY);
|
|
|
|
pEnumHelpers->AddRef();
|
|
hres = pEnumHelpers->QueryInterface(IID_IEnumHelpers, (LPVOID *)ppEnumHelpers);
|
|
pEnumHelpers->Release();
|
|
return hres;
|
|
}
|
|
|
|
// Returns the command string value (path and filename for the application plus any
|
|
// command line options) associated with the given file extension
|
|
static BOOL
|
|
GetOpenCommandForExt(LPCSTR lpszExt, LPSTR lpszCmdString, DWORD cbCmdString)
|
|
{
|
|
char szBuf[_MAX_PATH + 32];
|
|
char szFileClass[60];
|
|
LONG lResult;
|
|
LONG lcb;
|
|
#ifdef _WIN32
|
|
DWORD cbData;
|
|
DWORD dwType;
|
|
#else
|
|
LONG cbData;
|
|
#endif
|
|
|
|
*lpszCmdString = '\0';
|
|
|
|
// Look up the file association key which maps a file extension
|
|
// to an application identifier (also called the file type class
|
|
// identifier or just file class)
|
|
PR_snprintf(szBuf, sizeof(szBuf), ".%s", lpszExt);
|
|
lcb = sizeof(szFileClass);
|
|
lResult = RegQueryValue(HKEY_CLASSES_ROOT, szBuf, szFileClass, &lcb);
|
|
|
|
#ifdef _WIN32
|
|
ASSERT(lResult != ERROR_MORE_DATA);
|
|
#endif
|
|
if (lResult != ERROR_SUCCESS)
|
|
return FALSE;
|
|
|
|
// Get the key for shell\open\command
|
|
HKEY hKey;
|
|
|
|
#ifdef _WIN32
|
|
PR_snprintf(szBuf, sizeof(szBuf), "%s\\shell\\open\\command", szFileClass);
|
|
lResult = RegOpenKeyEx(HKEY_CLASSES_ROOT, szBuf, 0, KEY_QUERY_VALUE, &hKey);
|
|
#else
|
|
PR_snprintf(szBuf, sizeof(szBuf), "%s\\shell\\open\\command", szFileClass);
|
|
lResult = RegOpenKey(HKEY_CLASSES_ROOT, szBuf, &hKey);
|
|
#endif
|
|
if (lResult != ERROR_SUCCESS)
|
|
return FALSE;
|
|
|
|
// Get the value of the key
|
|
cbData = sizeof(szBuf);
|
|
#ifdef _WIN32
|
|
lResult = RegQueryValueEx(hKey, NULL, NULL, &dwType, (LPBYTE)szBuf, &cbData);
|
|
#else
|
|
lResult = RegQueryValue(hKey, NULL, (LPSTR)szBuf, &cbData);
|
|
#endif
|
|
RegCloseKey(hKey);
|
|
if (lResult != ERROR_SUCCESS)
|
|
return FALSE;
|
|
|
|
#ifdef _WIN32
|
|
// Win32 doesn't expand automatically environment variables (for value
|
|
// data of type REG_EXPAND_SZ). We need this for things like %SystemRoot%
|
|
if (dwType == REG_EXPAND_SZ)
|
|
ExpandEnvironmentStrings(szBuf, lpszCmdString, cbCmdString);
|
|
else
|
|
lstrcpy(lpszCmdString, szBuf);
|
|
#else
|
|
lstrcpy(lpszCmdString, szBuf);
|
|
#endif
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// Returns the path of the helper application associated with the
|
|
// given pcdata
|
|
static BOOL
|
|
GetApplication(NET_cdataStruct *pcdata, LPSTR lpszApp)
|
|
{
|
|
CHelperApp *pHelperApp = (CHelperApp *)pcdata->ci.fe_data;
|
|
char *lpszFile;
|
|
char szExtension[_MAX_EXT];
|
|
LPSTR lpszStrip;
|
|
|
|
if (!pHelperApp)
|
|
return FALSE;
|
|
|
|
// How we do this depends on how it's handled
|
|
switch (pHelperApp->how_handle) {
|
|
case HANDLE_EXTERNAL:
|
|
lstrcpy(lpszApp, (LPCSTR)pHelperApp->csCmd);
|
|
|
|
// XXX - this is what the code in display.cpp does, but it's really
|
|
// wrong...
|
|
lpszStrip = strrchr(lpszApp, '%');
|
|
|
|
if (lpszStrip)
|
|
*lpszStrip = '\0';
|
|
return TRUE;
|
|
|
|
case HANDLE_SHELLEXECUTE:
|
|
case HANDLE_BY_OLE:
|
|
// Have FindExecutable() tell us what the executable name is
|
|
wsprintf(szExtension, ".%s", pcdata->exts[0]);
|
|
lpszFile = WH_TempFileName(xpTemporary, "M", szExtension);
|
|
if (lpszFile) {
|
|
BOOL bResult = FEU_FindExecutable(lpszFile, lpszApp, TRUE);
|
|
|
|
XP_FREE(lpszFile);
|
|
return bResult;
|
|
}
|
|
return FALSE;
|
|
|
|
default:
|
|
ASSERT(FALSE);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
//Begin CRN_MIME
|
|
static BOOL
|
|
IsMimeTypeLocked(const char *pPrefix)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
|
|
//???????Any holes here??????
|
|
//I'm looking at just the ".type" field to see if a pref is locked.
|
|
char* setup_buf = PR_smprintf("%s.%s", pPrefix, "mimetype");
|
|
|
|
bRet = PREF_PrefIsLocked(setup_buf);
|
|
|
|
if(setup_buf && setup_buf[0])
|
|
XP_FREEIF(setup_buf);
|
|
|
|
return bRet;
|
|
}
|
|
|
|
static int
|
|
GetPrefLoadAction(int how_handle)
|
|
{
|
|
switch(how_handle) {
|
|
case HANDLE_SAVE:
|
|
return 1;
|
|
|
|
case HANDLE_SHELLEXECUTE:
|
|
return 2;
|
|
|
|
case HANDLE_UNKNOWN:
|
|
return 3;
|
|
|
|
case HANDLE_VIA_PLUGIN:
|
|
return 4;
|
|
|
|
default:
|
|
return 2;
|
|
}
|
|
}
|
|
//End CRN_MIME
|
|
|
|
STDMETHODIMP
|
|
CBrowserPrefs::GetHelperInfo(NET_cdataStruct *pcdata, LPHELPERINFO lpInfo)
|
|
{
|
|
CHelperApp *pHelperApp;
|
|
char szApp[_MAX_PATH];
|
|
|
|
if (!pcdata || !lpInfo)
|
|
return ResultFromScode(E_INVALIDARG);
|
|
|
|
pHelperApp = (CHelperApp *)pcdata->ci.fe_data;
|
|
if (!pHelperApp)
|
|
return ResultFromScode(E_UNEXPECTED);
|
|
|
|
//Begin CRN_MIME
|
|
if(! pHelperApp->csMimePrefPrefix.IsEmpty())
|
|
{
|
|
//This is a mime type associcated with a helper for a type specified thru' prefs.
|
|
//Use the csMimePrefPrefix to generate the pref and see if it's locked.
|
|
lpInfo->bIsLocked = IsMimeTypeLocked((LPCSTR)pHelperApp->csMimePrefPrefix);
|
|
|
|
}
|
|
else
|
|
lpInfo->bIsLocked = FALSE;
|
|
//End CRN_MIME
|
|
|
|
lpInfo->nHowToHandle = pHelperApp->how_handle;
|
|
lpInfo->szOpenCmd[0] = '\0';
|
|
|
|
switch (pHelperApp->how_handle) {
|
|
case HANDLE_EXTERNAL:
|
|
lstrcpy(lpInfo->szOpenCmd, (LPCSTR)pHelperApp->csCmd);
|
|
if (GetApplication(pcdata, szApp))
|
|
lpInfo->bAskBeforeOpening = theApp.m_pSpawn->PromptBeforeOpening(szApp);
|
|
break;
|
|
|
|
case HANDLE_SHELLEXECUTE:
|
|
case HANDLE_BY_OLE:
|
|
ASSERT(pcdata->num_exts > 0);
|
|
if (pcdata->num_exts > 0) {
|
|
GetOpenCommandForExt(pcdata->exts[0], lpInfo->szOpenCmd, sizeof(lpInfo->szOpenCmd));
|
|
if (GetApplication(pcdata, szApp))
|
|
lpInfo->bAskBeforeOpening = theApp.m_pSpawn->PromptBeforeOpening(szApp);
|
|
}
|
|
break;
|
|
|
|
case HANDLE_SAVE:
|
|
if (pcdata->num_exts > 0) {
|
|
// Even though it's marked as Save to Disk get the shell open command anyway. This
|
|
// way if the user changes the association to launch the application they'll already
|
|
// have it
|
|
GetOpenCommandForExt(pcdata->exts[0], lpInfo->szOpenCmd, sizeof(lpInfo->szOpenCmd));
|
|
lpInfo->bAskBeforeOpening = TRUE;
|
|
}
|
|
break;
|
|
//~~~
|
|
case HANDLE_VIA_PLUGIN:
|
|
case HANDLE_VIA_PLUGINAPPLET:
|
|
if (pcdata->num_exts > 0) {
|
|
GetOpenCommandForExt(pcdata->exts[0], lpInfo->szOpenCmd, sizeof(lpInfo->szOpenCmd));
|
|
lpInfo->bAskBeforeOpening = FALSE;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CBrowserPrefs::SetHelperInfo(NET_cdataStruct *pcdata, LPHELPERINFO lpInfo)
|
|
{
|
|
fe_ChangeFileType(pcdata, lpInfo->lpszMimeType, lpInfo->nHowToHandle, lpInfo->szOpenCmd);
|
|
|
|
//Begin CRN_MIME
|
|
//Set user pref values only for mime types setup from the pref file
|
|
CHelperApp *pHelperApp;
|
|
pHelperApp = (CHelperApp *)pcdata->ci.fe_data;
|
|
if(pHelperApp)
|
|
{
|
|
if(! pHelperApp->csMimePrefPrefix.IsEmpty())
|
|
{
|
|
char* setup_buf = PR_smprintf("%s.%s", (LPCSTR)pHelperApp->csMimePrefPrefix, "mimetype");
|
|
PREF_SetCharPref(setup_buf, lpInfo->lpszMimeType);
|
|
if(setup_buf && setup_buf[0])
|
|
XP_FREEIF(setup_buf);
|
|
|
|
setup_buf = PR_smprintf("%s.%s", (LPCSTR)pHelperApp->csMimePrefPrefix, "win_appname");
|
|
PREF_SetCharPref(setup_buf, lpInfo->szOpenCmd);
|
|
if(setup_buf && setup_buf[0])
|
|
XP_FREEIF(setup_buf);
|
|
|
|
setup_buf = PR_smprintf("%s.%s", (LPCSTR)pHelperApp->csMimePrefPrefix, "load_action");
|
|
PREF_SetIntPref(setup_buf, GetPrefLoadAction(lpInfo->nHowToHandle));
|
|
if(setup_buf && setup_buf[0])
|
|
XP_FREEIF(setup_buf);
|
|
}
|
|
}
|
|
|
|
//End CRN_MIME
|
|
|
|
if (lpInfo->nHowToHandle == HANDLE_EXTERNAL ||
|
|
lpInfo->nHowToHandle == HANDLE_SHELLEXECUTE ||
|
|
lpInfo->nHowToHandle == HANDLE_BY_OLE) {
|
|
|
|
// Update whether we should prompt before opening the file
|
|
char szApp[_MAX_PATH];
|
|
|
|
if (GetApplication(pcdata, szApp))
|
|
theApp.m_pSpawn->SetPromptBeforeOpening(szApp, lpInfo->bAskBeforeOpening);
|
|
}
|
|
return NOERROR;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CBrowserPrefs::NewFileType(LPCSTR lpszDescription,
|
|
LPCSTR lpszExtension,
|
|
LPCSTR lpszMimeType,
|
|
LPCSTR lpszOpenCmd,
|
|
NET_cdataStruct **ppcdata)
|
|
{
|
|
*ppcdata = fe_NewFileType(lpszDescription, lpszExtension, lpszMimeType, lpszOpenCmd);
|
|
return *ppcdata ? NOERROR : ResultFromScode(S_FALSE);
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CBrowserPrefs::RemoveFileType(NET_cdataStruct *pcdata)
|
|
{
|
|
//Begin CRN_MIME
|
|
//Clear user pref values only for mime types setup from the pref file
|
|
CHelperApp *pHelperApp;
|
|
pHelperApp = (CHelperApp *)pcdata->ci.fe_data;
|
|
if(pHelperApp)
|
|
{
|
|
if(! pHelperApp->csMimePrefPrefix.IsEmpty())
|
|
{
|
|
char* setup_buf = PR_smprintf("%s.%s", (LPCSTR)pHelperApp->csMimePrefPrefix, "mimetype");
|
|
PREF_ClearUserPref(setup_buf);
|
|
if(setup_buf && setup_buf[0])
|
|
XP_FREEIF(setup_buf);
|
|
|
|
setup_buf = PR_smprintf("%s.%s", (LPCSTR)pHelperApp->csMimePrefPrefix, "win_appname");
|
|
PREF_ClearUserPref(setup_buf);
|
|
if(setup_buf && setup_buf[0])
|
|
XP_FREEIF(setup_buf);
|
|
|
|
setup_buf = PR_smprintf("%s.%s", (LPCSTR)pHelperApp->csMimePrefPrefix, "load_action");
|
|
PREF_ClearUserPref(setup_buf);
|
|
if(setup_buf && setup_buf[0])
|
|
XP_FREEIF(setup_buf);
|
|
|
|
setup_buf = PR_smprintf("%s.%s", (LPCSTR)pHelperApp->csMimePrefPrefix, "extension");
|
|
PREF_ClearUserPref(setup_buf);
|
|
if(setup_buf && setup_buf[0])
|
|
XP_FREEIF(setup_buf);
|
|
|
|
setup_buf = PR_smprintf("%s.%s", (LPCSTR)pHelperApp->csMimePrefPrefix, "description");
|
|
PREF_ClearUserPref(setup_buf);
|
|
if(setup_buf && setup_buf[0])
|
|
XP_FREEIF(setup_buf);
|
|
}
|
|
}
|
|
//End CRN_MIME
|
|
|
|
return fe_RemoveFileType(pcdata) ? NOERROR : ResultFromScode(S_FALSE);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CAppearancePreferences
|
|
|
|
class CAppearancePrefs : public IIntlFont {
|
|
public:
|
|
CAppearancePrefs(int nCharsetId);
|
|
|
|
// IUnknown methods
|
|
STDMETHODIMP QueryInterface(REFIID riid, LPVOID FAR* ppvObj);
|
|
STDMETHODIMP_(ULONG) AddRef();
|
|
STDMETHODIMP_(ULONG) Release();
|
|
|
|
// IIntlFont methods
|
|
STDMETHODIMP GetNumEncodings(LPDWORD pdwEncodings);
|
|
STDMETHODIMP GetEncodingName(DWORD dwCharsetNum, LPOLESTR *pszName);
|
|
STDMETHODIMP GetEncodingInfo(DWORD dwCharsetNum, LPENCODINGINFO lpInfo);
|
|
STDMETHODIMP SetEncodingFonts(DWORD dwCharsetNum, LPENCODINGINFO lpInfo);
|
|
STDMETHODIMP GetCurrentCharset(LPDWORD pdwCharsetNum);
|
|
|
|
// Initialization routine to create contained and aggregated objects
|
|
HRESULT Init();
|
|
|
|
private:
|
|
ULONG m_uRef;
|
|
int m_nCharsetId;
|
|
LPUNKNOWN m_pCategory; // inner object supporting ISpecifyPropertyPageObjects
|
|
};
|
|
|
|
CAppearancePrefs::CAppearancePrefs(int nCharsetId)
|
|
{
|
|
m_uRef = 0;
|
|
m_nCharsetId = nCharsetId;
|
|
m_pCategory = NULL;
|
|
}
|
|
|
|
HRESULT
|
|
CAppearancePrefs::Init()
|
|
{
|
|
// Create the object as part of an aggregate
|
|
return FEU_CoCreateInstance(CLSID_AppearancePrefs, (LPUNKNOWN)this,
|
|
CLSCTX_INPROC_SERVER, IID_IUnknown, (LPVOID *)&m_pCategory);
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CAppearancePrefs::QueryInterface(REFIID riid, LPVOID FAR* ppvObj)
|
|
{
|
|
*ppvObj = NULL;
|
|
|
|
if (riid == IID_IUnknown || riid == IID_IIntlFont) {
|
|
*ppvObj = (LPVOID)this;
|
|
AddRef();
|
|
return NOERROR;
|
|
|
|
} else if (riid == IID_ISpecifyPropertyPageObjects) {
|
|
assert(m_pCategory);
|
|
return m_pCategory->QueryInterface(riid, ppvObj);
|
|
}
|
|
|
|
return ResultFromScode(E_NOINTERFACE);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG)
|
|
CAppearancePrefs::AddRef()
|
|
{
|
|
return ++m_uRef;
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG)
|
|
CAppearancePrefs::Release()
|
|
{
|
|
if (--m_uRef == 0) {
|
|
if (m_pCategory)
|
|
m_pCategory->Release();
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
return m_uRef;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CAppearancePrefs::GetNumEncodings(LPDWORD pdwEncodings)
|
|
{
|
|
if (!pdwEncodings)
|
|
return ResultFromScode(E_INVALIDARG);
|
|
|
|
*pdwEncodings = (DWORD)MAXLANGNUM;
|
|
return NOERROR;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CAppearancePrefs::GetEncodingName(DWORD dwCharsetNum, LPOLESTR *lpoleName)
|
|
{
|
|
if (dwCharsetNum >= (DWORD)MAXLANGNUM || !lpoleName)
|
|
return ResultFromScode(E_INVALIDARG);
|
|
|
|
LPCSTR lpszName = theApp.m_pIntlFont->GetEncodingName((int)dwCharsetNum);
|
|
|
|
if (lpszName) {
|
|
*lpoleName = AllocTaskOleString(lpszName);
|
|
return *lpoleName ? NOERROR : ResultFromScode(E_OUTOFMEMORY);
|
|
}
|
|
|
|
return ResultFromScode(E_UNEXPECTED);
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CAppearancePrefs::GetEncodingInfo(DWORD dwCharsetNum, LPENCODINGINFO lpInfo)
|
|
{
|
|
EncodingInfo *lpEncoding;
|
|
|
|
if (dwCharsetNum >= (DWORD)MAXLANGNUM || !lpInfo)
|
|
return ResultFromScode(E_INVALIDARG);
|
|
|
|
lpEncoding = theApp.m_pIntlFont->GetEncodingInfo((int)dwCharsetNum);
|
|
lpInfo->bIgnorePitch = ( CIntlWin::FontSelectIgnorePitch(lpEncoding->iCSID) );
|
|
lstrcpy(lpInfo->szVariableWidthFont, lpEncoding->szPropName);
|
|
lpInfo->nVariableWidthSize = lpEncoding->iPropSize;
|
|
lstrcpy(lpInfo->szFixedWidthFont, lpEncoding->szFixName);
|
|
lpInfo->nFixedWidthSize = lpEncoding->iFixSize;
|
|
return NOERROR;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CAppearancePrefs::SetEncodingFonts(DWORD dwCharsetNum, LPENCODINGINFO lpInfo)
|
|
{
|
|
EncodingInfo *lpEncoding;
|
|
BOOL bFixedWidthChanged;
|
|
BOOL bVariableWidthChanged;
|
|
|
|
if (dwCharsetNum >= (DWORD)MAXLANGNUM || !lpInfo)
|
|
return ResultFromScode(E_INVALIDARG);
|
|
|
|
lpEncoding = theApp.m_pIntlFont->GetEncodingInfo((int)dwCharsetNum);
|
|
|
|
// See if anything has changed. We don't want to reset everything
|
|
// if nothing has changed
|
|
bFixedWidthChanged = lstrcmp(lpInfo->szFixedWidthFont, lpEncoding->szFixName) != 0 ||
|
|
lpInfo->nFixedWidthSize != lpEncoding->iFixSize;
|
|
bVariableWidthChanged = lstrcmp(lpInfo->szVariableWidthFont, lpEncoding->szPropName) != 0 ||
|
|
lpInfo->nVariableWidthSize != lpEncoding->iPropSize;
|
|
|
|
if (bFixedWidthChanged || bVariableWidthChanged) {
|
|
lstrcpy(lpEncoding->szFixName, lpInfo->szFixedWidthFont);
|
|
lpEncoding->iFixSize = lpInfo->nFixedWidthSize;
|
|
lstrcpy(lpEncoding->szPropName, lpInfo->szVariableWidthFont);
|
|
lpEncoding->iPropSize = lpInfo->nVariableWidthSize;
|
|
|
|
// Reset the assorted font caches...
|
|
CDCCX::ClearAllFontCaches();
|
|
#ifdef MOZ_NGLAYOUT
|
|
XP_ASSERT(0);
|
|
#endif /* MOZ_NGLAYOUT */
|
|
theApp.m_pIntlFont->WriteToIniFile();
|
|
|
|
// Indicate we need to reload all of the windows
|
|
g_bReloadAllWindows = TRUE;
|
|
}
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CAppearancePrefs::GetCurrentCharset(LPDWORD pdwCharsetNum)
|
|
{
|
|
if (!pdwCharsetNum)
|
|
return ResultFromScode(E_INVALIDARG);
|
|
|
|
*pdwCharsetNum = (DWORD)m_nCharsetId;
|
|
return NOERROR;
|
|
}
|
|
|
|
#ifdef MOZ_MAIL_NEWS
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CMailNewsPreferences
|
|
|
|
class CMailNewsPreferences : public IMailNewsInterface {
|
|
public:
|
|
CMailNewsPreferences(MWContext *pContext);
|
|
~CMailNewsPreferences();
|
|
|
|
// IUnknown methods
|
|
STDMETHODIMP QueryInterface(REFIID riid, LPVOID FAR* ppvObj);
|
|
STDMETHODIMP_(ULONG) AddRef();
|
|
STDMETHODIMP_(ULONG) Release();
|
|
|
|
// IMailNewsInterface methods
|
|
STDMETHODIMP_(BOOL) CreateAddressBookCard(HWND hParent);
|
|
STDMETHODIMP EditAddressBookCard(HWND hParent);
|
|
|
|
STDMETHODIMP GetSigFile(HWND hParent, LPOLESTR *pszSigFile);
|
|
STDMETHODIMP ShowDirectoryPicker(HWND hParent, LPOLESTR lpIniDir, LPOLESTR *pszNewDir);
|
|
|
|
STDMETHODIMP ShowChooseFolder(HWND hParent, LPOLESTR lpFolderPath, DWORD dwType,
|
|
LPOLESTR *lpFolder, LPOLESTR *lpServer, LPOLESTR *lpPref);
|
|
STDMETHODIMP GetFolderServer(LPOLESTR lpFolderPath, DWORD dwType,
|
|
LPOLESTR *lpFolder, LPOLESTR *lpServer);
|
|
|
|
STDMETHODIMP FillNewsServerList(HWND hControl, LPOLESTR lpServerName, LPVOID FAR* ppServer);
|
|
STDMETHODIMP_(BOOL) AddNewsServer(HWND hParent, HWND hControl);
|
|
STDMETHODIMP_(BOOL) EditNewsServer(HWND hParent, HWND hControl, BOOL *pChanged);
|
|
STDMETHODIMP DeleteNewsServer(HWND hParent, HWND hControl, LPVOID FAR* lpDefault);
|
|
|
|
STDMETHODIMP_(BOOL) AddMailServer(HWND hParent, HWND hControl, BOOL bAllowBoth, DWORD dwType);
|
|
STDMETHODIMP_(BOOL) EditMailServer(HWND hParent, HWND hControl, BOOL bAllowBoth, DWORD dwType);
|
|
STDMETHODIMP_(BOOL) DeleteMailServer(HWND hParent, HWND hControl, DWORD dwType);
|
|
STDMETHODIMP SetImapDefaultServer(HWND hControl);
|
|
|
|
STDMETHODIMP FillLdapDirList(HWND hControl, LPOLESTR lpServerName);
|
|
STDMETHODIMP SetLdapDirAutoComplete(HWND hControl, BOOL bOnOrOff);
|
|
STDMETHODIMP SaveLdapDirAutoComplete();
|
|
|
|
|
|
// Initialization routine to create contained and aggregated objects
|
|
HRESULT Init();
|
|
|
|
private:
|
|
|
|
ULONG m_uRef;
|
|
LPUNKNOWN m_pCategory; // inner object supporting ISpecifyPropertyPageObjects
|
|
|
|
BOOL m_bStaticCtl;
|
|
int m_iInitialDepth;
|
|
LPIMAGEMAP m_pIImageMap;
|
|
LPUNKNOWN m_pIImageUnk;
|
|
HFONT m_hFont, m_hBoldFont;
|
|
XP_List *m_pLdapServers;
|
|
MSG_NewsHost** m_hNewsHost;
|
|
MWContext *m_pContext;
|
|
};
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CMailNewsPreferences
|
|
|
|
CMailNewsPreferences::CMailNewsPreferences(MWContext *pContext)
|
|
{
|
|
m_uRef = 0;
|
|
m_pCategory = NULL;
|
|
m_pIImageMap = NULL;
|
|
m_pIImageUnk = NULL;
|
|
m_hFont = NULL;
|
|
m_hBoldFont = NULL;
|
|
m_pLdapServers = NULL;
|
|
m_hNewsHost = NULL;
|
|
char location[256];
|
|
int nLen = 255;
|
|
m_pContext = pContext;
|
|
m_pLdapServers = XP_ListNew();
|
|
PREF_GetDefaultCharPref("browser.addressbook_location", location, &nLen);
|
|
DIR_GetServerPreferences (&m_pLdapServers, location);
|
|
}
|
|
|
|
CMailNewsPreferences::~CMailNewsPreferences()
|
|
{
|
|
if (m_pIImageUnk && m_pIImageMap ) {
|
|
m_pIImageUnk->Release();
|
|
}
|
|
if (m_hFont)
|
|
theApp.ReleaseAppFont(m_hFont);
|
|
if (m_hBoldFont)
|
|
theApp.ReleaseAppFont(m_hBoldFont);
|
|
if (m_pLdapServers)
|
|
{
|
|
m_pLdapServers = NULL;
|
|
}
|
|
if (m_hNewsHost)
|
|
delete [] m_hNewsHost;
|
|
m_hNewsHost = NULL;
|
|
}
|
|
|
|
HRESULT
|
|
CMailNewsPreferences::Init()
|
|
{
|
|
|
|
// Create the object as part of an aggregate
|
|
return FEU_CoCreateInstance(CLSID_MailNewsPrefs, (LPUNKNOWN)this,
|
|
CLSCTX_INPROC_SERVER, IID_IUnknown, (LPVOID *)&m_pCategory);
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CMailNewsPreferences::QueryInterface(REFIID riid, LPVOID FAR* ppvObj)
|
|
{
|
|
*ppvObj = NULL;
|
|
|
|
if (riid == IID_IUnknown || riid == IID_MailNewsInterface) {
|
|
*ppvObj = (LPVOID)this;
|
|
AddRef();
|
|
return NOERROR;
|
|
|
|
} else if (riid == IID_ISpecifyPropertyPageObjects) {
|
|
assert(m_pCategory);
|
|
return m_pCategory->QueryInterface(riid, ppvObj);
|
|
}
|
|
|
|
return ResultFromScode(E_NOINTERFACE);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG)
|
|
CMailNewsPreferences::AddRef()
|
|
{
|
|
return ++m_uRef;
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG)
|
|
CMailNewsPreferences::Release()
|
|
{
|
|
if (--m_uRef == 0) {
|
|
if (m_pCategory)
|
|
m_pCategory->Release();
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
return m_uRef;
|
|
}
|
|
|
|
|
|
STDMETHODIMP_(BOOL)
|
|
CMailNewsPreferences::CreateAddressBookCard(HWND hParent)
|
|
{
|
|
char* email = NULL;
|
|
char* name = NULL;
|
|
PersonEntry person;
|
|
person.Initialize();
|
|
ABID entryID;
|
|
DIR_Server *pab = NULL;
|
|
CWnd parent;
|
|
BOOL result = TRUE;
|
|
|
|
#ifdef FEATURE_ADDRPROP
|
|
parent.Attach(hParent);
|
|
|
|
if (FE_UsersMailAddress())
|
|
email = XP_STRDUP (FE_UsersMailAddress());
|
|
if (FE_UsersFullName())
|
|
name = XP_STRDUP (FE_UsersFullName());
|
|
person.pGivenName = name;
|
|
person.pEmailAddress = email;
|
|
DIR_GetPersonalAddressBook (theApp.m_directories, &pab);
|
|
XP_ASSERT (pab);
|
|
|
|
if (pab)
|
|
{
|
|
AB_GetEntryIDForPerson(pab, theApp.m_pABook, &entryID, &person);
|
|
|
|
if (entryID == MSG_MESSAGEIDNONE)
|
|
{
|
|
CDialog createCardDlg(IDD_PREF_MNCREATECARD, NULL);
|
|
if (IDOK == createCardDlg.DoModal())
|
|
{
|
|
CString formattedString;
|
|
if (name)
|
|
formattedString.Format(XP_GetString (MK_ADDR_BOOK_CARD), name);
|
|
else
|
|
formattedString = XP_GetString (MK_ADDR_NEW_CARD);
|
|
#ifndef MOZ_NEWADDR
|
|
CAddrEditProperties prop(NULL, pab,
|
|
(const char *) formattedString, &parent, 0, &person);
|
|
prop.SetCurrentPage(0);
|
|
if (prop.DoModal() == IDCANCEL)
|
|
result = FALSE;
|
|
#else
|
|
MSG_Pane *pPane = NULL;
|
|
AB_GetIdentityPropertySheet(m_pContext, WFE_MSGGetMaster(),
|
|
&pPane);
|
|
CAddrEditProperties prop(NULL, (const char *) formattedString,
|
|
&parent, pPane, m_pContext, TRUE);
|
|
if(prop.DoModal() == IDCANCEL)
|
|
result = FALSE;
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
result = FALSE;
|
|
}
|
|
}
|
|
}
|
|
parent.Detach();
|
|
#endif
|
|
return result;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CMailNewsPreferences::EditAddressBookCard(HWND hParent)
|
|
{
|
|
#ifdef FEATURE_ADDRPROP
|
|
char* email = NULL;
|
|
char* name = NULL;
|
|
PersonEntry person;
|
|
person.Initialize();
|
|
ABID entryID;
|
|
DIR_Server *pab = NULL;
|
|
CWnd parent;
|
|
|
|
parent.Attach(hParent);
|
|
|
|
if (FE_UsersMailAddress())
|
|
email = XP_STRDUP (FE_UsersMailAddress());
|
|
if (FE_UsersFullName())
|
|
name = XP_STRDUP (FE_UsersFullName());
|
|
person.pGivenName = name;
|
|
person.pEmailAddress = email;
|
|
DIR_GetPersonalAddressBook (theApp.m_directories, &pab);
|
|
XP_ASSERT (pab);
|
|
|
|
if (pab)
|
|
{
|
|
AB_GetEntryIDForPerson(pab, theApp.m_pABook, &entryID, &person);
|
|
|
|
if (entryID != MSG_MESSAGEIDNONE)
|
|
{
|
|
CString formattedString;
|
|
char fullname [kMaxFullNameLength];
|
|
AB_GetFullName(pab, theApp.m_pABook, entryID, fullname);
|
|
formattedString.Format(XP_GetString (MK_ADDR_BOOK_CARD), fullname);
|
|
#ifndef MOZ_NEWADDR
|
|
CAddrEditProperties prop(NULL, pab,
|
|
(const char *) formattedString, &parent, entryID);
|
|
prop.SetCurrentPage(0);
|
|
prop.DoModal();
|
|
#else
|
|
MSG_Pane *pPane = NULL;
|
|
AB_GetIdentityPropertySheet(m_pContext, WFE_MSGGetMaster(),
|
|
&pPane);
|
|
CAddrEditProperties prop(NULL, (const char *) formattedString,
|
|
&parent, pPane, m_pContext);
|
|
prop.DoModal();
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
CString formattedString;
|
|
formattedString.Format(XP_GetString (MK_ADDR_BOOK_CARD), name);
|
|
#ifndef MOZ_NEWADDR
|
|
CAddrEditProperties prop(NULL, pab,
|
|
(const char *) formattedString, &parent, 0, &person);
|
|
prop.SetCurrentPage(0);
|
|
prop.DoModal();
|
|
#else
|
|
MSG_Pane *pPane = NULL;
|
|
AB_GetIdentityPropertySheet(m_pContext, WFE_MSGGetMaster(),
|
|
&pPane);
|
|
CAddrEditProperties prop(NULL, (const char *) formattedString,
|
|
&parent, pPane, m_pContext);
|
|
prop.DoModal();
|
|
|
|
#endif
|
|
}
|
|
}
|
|
|
|
if (email)
|
|
XP_FREE (email);
|
|
if (name)
|
|
XP_FREE (name);
|
|
parent.Detach();
|
|
#endif
|
|
return NOERROR;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CMailNewsPreferences::GetSigFile(HWND hParent, LPOLESTR *lpoleStr)
|
|
{
|
|
char* pName = NULL;
|
|
|
|
if (!lpoleStr)
|
|
return ResultFromScode(E_INVALIDARG);
|
|
|
|
pName = wfe_GetExistingFileName(hParent, szLoadString(IDS_SIG_FILE),
|
|
ALL, TRUE);
|
|
*lpoleStr = 0;
|
|
|
|
if (pName)
|
|
{
|
|
*lpoleStr = AllocTaskOleString(pName);
|
|
|
|
if (!*lpoleStr)
|
|
return ResultFromScode(E_OUTOFMEMORY);
|
|
}
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
STDMETHODIMP CMailNewsPreferences::ShowDirectoryPicker
|
|
(HWND hParent, LPOLESTR lpIniDir, LPOLESTR *pszNewDir)
|
|
{
|
|
CWnd parent;
|
|
parent.Attach(hParent);
|
|
|
|
*pszNewDir = 0;
|
|
|
|
CDirDialog directory(&parent, (char*)lpIniDir);
|
|
if (IDOK == directory.DoModal())
|
|
{
|
|
CString fileName = directory.GetPathName();
|
|
int nPos = fileName.GetLength() - strlen("\\k5bg");
|
|
CString pathName(fileName.Left(nPos));
|
|
|
|
*pszNewDir = AllocTaskOleString(LPCTSTR(pathName));
|
|
|
|
if (!*pszNewDir)
|
|
return ResultFromScode(E_OUTOFMEMORY);
|
|
}
|
|
parent.Detach();
|
|
return NOERROR;
|
|
}
|
|
|
|
STDMETHODIMP CMailNewsPreferences::ShowChooseFolder
|
|
(HWND hParent, LPOLESTR lpFolderPath, DWORD dwType, LPOLESTR *lpFolder,
|
|
LPOLESTR *lpServer, LPOLESTR *lpPref)
|
|
{
|
|
char* lpPath = (char*)lpFolderPath;
|
|
CWnd parent;
|
|
parent.Attach(hParent);
|
|
CChooseFolderDialog folderDialog(&parent, lpPath, (int)dwType);
|
|
if (IDOK == folderDialog.DoModal())
|
|
{
|
|
*lpFolder = AllocTaskOleString(LPCTSTR(folderDialog.m_szFolder));
|
|
*lpServer = AllocTaskOleString(LPCTSTR(folderDialog.m_szServer));
|
|
*lpPref = AllocTaskOleString(LPCTSTR(folderDialog.m_szPrefUrl));
|
|
}
|
|
|
|
parent.Detach();
|
|
return NOERROR;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CMailNewsPreferences::GetFolderServer
|
|
(LPOLESTR lpFolderPath, DWORD dwType, LPOLESTR *lpFolder, LPOLESTR *lpServer)
|
|
{
|
|
|
|
char* lpPath = (char*)lpFolderPath;
|
|
int nDefaultID;
|
|
if (dwType == TYPE_SENTMAIL || dwType == TYPE_SENTNEWS)
|
|
nDefaultID = MK_MSG_SENT_L10N_NAME;
|
|
else if (dwType == TYPE_DRAFT)
|
|
nDefaultID = MK_MSG_DRAFTS_L10N_NAME;
|
|
else if (dwType == TYPE_TEMPLATE)
|
|
nDefaultID = MK_MSG_TEMPLATES_L10N_NAME;
|
|
|
|
CString folder;
|
|
CString server;
|
|
|
|
GetFolderServerNames(lpPath, nDefaultID, folder, server);
|
|
|
|
if (folder.GetLength())
|
|
*lpFolder = AllocTaskOleString(LPCTSTR(folder));
|
|
if (server.GetLength())
|
|
*lpServer = AllocTaskOleString(LPCTSTR(server));
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
STDMETHODIMP CMailNewsPreferences::FillNewsServerList
|
|
(HWND hControl, LPOLESTR lpServerName, LPVOID FAR* ppServer)
|
|
{
|
|
int nDefaultHost = 0;
|
|
int nSelectedIndex = -1;
|
|
char* lpPrefName = (char*)lpServerName;
|
|
|
|
MSG_Master * pMaster = WFE_MSGGetMaster();
|
|
int32 nTotal = MSG_GetNewsHosts(pMaster, NULL, 0);
|
|
if (nTotal)
|
|
{
|
|
m_hNewsHost = new MSG_NewsHost* [nTotal];
|
|
MSG_GetNewsHosts(pMaster, m_hNewsHost, nTotal);
|
|
for (int i = 0; i < nTotal; i++)
|
|
{
|
|
int nAddedIndex = (int)SendMessage(hControl, LB_ADDSTRING, 0,
|
|
(LPARAM)(LPCTSTR)MSG_GetNewsHostUIName(m_hNewsHost[i]));
|
|
if (nAddedIndex != CB_ERR)
|
|
{
|
|
SendMessage(hControl, LB_SETITEMDATA, (WPARAM)nAddedIndex,
|
|
(LPARAM)(DWORD)m_hNewsHost[i]);
|
|
const char *pName = MSG_GetNewsHostUIName(m_hNewsHost[i]);
|
|
if (!XP_FILENAMECMP(lpPrefName, pName))
|
|
{
|
|
nSelectedIndex = nAddedIndex;
|
|
*ppServer = m_hNewsHost[i];
|
|
}
|
|
}
|
|
}
|
|
if (nSelectedIndex >= 0)
|
|
SendMessage(hControl, LB_SETCURSEL, (WPARAM)nSelectedIndex, (LPARAM)0);
|
|
}
|
|
return NOERROR;
|
|
}
|
|
|
|
STDMETHODIMP_(BOOL)
|
|
CMailNewsPreferences::AddNewsServer(HWND hParent, HWND hControl)
|
|
{
|
|
BOOL result = FALSE;
|
|
CWnd parent;
|
|
parent.Attach(hParent);
|
|
|
|
MSG_Host *pNewHost = DoAddNewsServer(&parent, FROM_PREFERENCE);
|
|
if (pNewHost)
|
|
{
|
|
int nIndex = (int)SendMessage(hControl, LB_ADDSTRING, 0,
|
|
(LPARAM)(LPCTSTR)MSG_GetHostUIName(pNewHost));
|
|
SendMessage(hControl, LB_SETCURSEL, (WPARAM)nIndex, (LPARAM)0);
|
|
SendMessage(hControl, LB_SETITEMDATA, (WPARAM)nIndex,
|
|
(LPARAM)(DWORD)pNewHost);
|
|
result = TRUE;
|
|
}
|
|
else
|
|
result = FALSE;
|
|
parent.Detach();
|
|
return result;
|
|
}
|
|
|
|
STDMETHODIMP_(BOOL)
|
|
CMailNewsPreferences::EditNewsServer(HWND hParent, HWND hControl, BOOL *pChanged)
|
|
{
|
|
CWnd parent;
|
|
|
|
int nIndex = (int)SendMessage(hControl, LB_GETCURSEL, 0, 0);
|
|
if (nIndex >= 0)
|
|
{
|
|
parent.Attach(hParent);
|
|
MSG_NewsHost* pServer = (MSG_NewsHost*)SendMessage(hControl, LB_GETITEMDATA,
|
|
(WPARAM)nIndex, 0);
|
|
MSG_Host* pMsgHost = MSG_GetMSGHostFromNewsHost(pServer);
|
|
|
|
CString csTitle;
|
|
csTitle.LoadString(IDS_NEWSHOSTPROP);
|
|
CNewsFolderPropertySheet editServerDialog(csTitle, &parent);
|
|
MSG_FolderInfo *pFolderInfo = MSG_GetFolderInfoForHost(pMsgHost);
|
|
editServerDialog.m_pNewsHostPage= new CNewsHostGeneralPropertyPage;
|
|
editServerDialog.m_pNewsHostPage->SetFolderInfo(pFolderInfo, pServer);
|
|
editServerDialog.AddPage(editServerDialog.m_pNewsHostPage);
|
|
if (IDOK == editServerDialog.DoModal())
|
|
*pChanged = TRUE;
|
|
|
|
parent.Detach();
|
|
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
STDMETHODIMP CMailNewsPreferences::DeleteNewsServer
|
|
(HWND hParent, HWND hControl, LPVOID FAR* lpDefault)
|
|
{
|
|
|
|
CWnd parent;
|
|
parent.Attach(hParent);
|
|
|
|
MSG_NewsHost* pDefaultServer = (MSG_NewsHost*)(*lpDefault);
|
|
int nIndex = (int)SendMessage(hControl, LB_GETCURSEL, 0, 0);
|
|
if (nIndex >= 0)
|
|
{
|
|
MSG_NewsHost* pServer = (MSG_NewsHost*)SendMessage(hControl, LB_GETITEMDATA,
|
|
(WPARAM)nIndex, 0);
|
|
MSG_Host* pMsgHost = MSG_GetMSGHostFromNewsHost(pServer);
|
|
|
|
char* tmp = PR_smprintf(XP_GetString(MK_MSG_REMOVE_HOST_CONFIRM),
|
|
MSG_GetHostUIName(pMsgHost));
|
|
if (IDOK == parent.MessageBox(tmp, szLoadString(AFX_IDS_APP_TITLE), MB_OKCANCEL))
|
|
{
|
|
MSG_Master * pMaster = WFE_MSGGetMaster();
|
|
MSG_DeleteNewsHost(pMaster, pServer);
|
|
SendMessage(hControl, LB_DELETESTRING, nIndex, 0);
|
|
if (pDefaultServer == pServer)
|
|
{
|
|
int nNewDefault;
|
|
int nTotal = (int)SendMessage(hControl, LB_GETCOUNT, 0, 0);
|
|
if (nIndex >= nTotal)
|
|
nNewDefault = nTotal -1;
|
|
else
|
|
nNewDefault = nIndex;
|
|
|
|
*lpDefault = (LPVOID)SendMessage(hControl, LB_GETITEMDATA,
|
|
(WPARAM)nNewDefault, 0);
|
|
}
|
|
}
|
|
if(tmp && tmp[0])
|
|
XP_FREE(tmp);
|
|
}
|
|
parent.Detach();
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
STDMETHODIMP_(BOOL) CMailNewsPreferences::AddMailServer
|
|
(HWND hParent, HWND hControl, BOOL bAllowBoth, DWORD dwType)
|
|
{
|
|
CWnd parent;
|
|
parent.Attach(hParent);
|
|
int nType = (int)dwType;
|
|
|
|
if (nType == TYPE_POP && !bAllowBoth)
|
|
{
|
|
parent.MessageBox(szLoadString(IDS_POP3_ONLY_ONE),
|
|
szLoadString(AFX_IDS_APP_TITLE), MB_OK);
|
|
parent.Detach();
|
|
return FALSE;
|
|
}
|
|
|
|
CString title;
|
|
title.LoadString(IDS_MAIL_SERVER_PROPERTY);
|
|
CMailServerPropertySheet addMailServer(&parent, title, NULL, TYPE_IMAP, FALSE, bAllowBoth);
|
|
if (IDOK == addMailServer.DoModal())
|
|
{
|
|
PREF_SavePrefFile();
|
|
if (nType == TYPE_POP)
|
|
{
|
|
SendMessage(hControl, LB_ADDSTRING, 0,
|
|
(LPARAM) (LPCTSTR)addMailServer.GetMailHostName());
|
|
}
|
|
parent.Detach();
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
parent.Detach();
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
STDMETHODIMP_(BOOL) CMailNewsPreferences::EditMailServer
|
|
(HWND hParent, HWND hControl, BOOL bAllowBoth, DWORD dwType)
|
|
{
|
|
CWnd parent;
|
|
parent.Attach(hParent);
|
|
CString title;
|
|
title.LoadString(IDS_MAIL_SERVER_PROPERTY);
|
|
int nType = (int)dwType;
|
|
|
|
char serverName[MSG_MAXGROUPNAMELENGTH];
|
|
int nIndex = (int)SendMessage(hControl, LB_GETCURSEL, 0, 0);
|
|
SendMessage(hControl, LB_GETTEXT, (WPARAM)nIndex,
|
|
(LPARAM)(DWORD)serverName);
|
|
|
|
char* pDefault = XP_STRSTR(serverName, szLoadString(IDS_DEFAULT_STRING));
|
|
if (pDefault)
|
|
*pDefault = '\0'; //get rid of (Default)
|
|
|
|
CMailServerPropertySheet editMailServer(&parent, title, serverName,
|
|
nType, TRUE, bAllowBoth);
|
|
if (IDOK == editMailServer.DoModal())
|
|
{
|
|
PREF_SavePrefFile();
|
|
|
|
char* pNewName = editMailServer.GetMailHostName();
|
|
if ((nType == TYPE_POP && 0 != lstrcmp(pNewName, serverName)) ||
|
|
(nType == TYPE_IMAP && editMailServer.IsPopServer()))
|
|
{
|
|
SendMessage(hControl, LB_DELETESTRING, nIndex, 0);
|
|
SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM)(LPCTSTR)pNewName);
|
|
}
|
|
parent.Detach();
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
parent.Detach();
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
//delete imap server
|
|
STDMETHODIMP_(BOOL) CMailNewsPreferences::DeleteMailServer
|
|
(HWND hParent, HWND hControl, DWORD dwType)
|
|
{
|
|
CWnd parent;
|
|
parent.Attach(hParent);
|
|
if (IDCANCEL == parent.MessageBox(szLoadString(IDS_REMOVE_MAILHOST_CONFIRM),
|
|
szLoadString(AFX_IDS_APP_TITLE), MB_OKCANCEL))
|
|
{
|
|
parent.Detach();
|
|
return FALSE;
|
|
}
|
|
|
|
int nIndex = (int)SendMessage(hControl, LB_GETCURSEL, 0, 0);
|
|
int nType = (int)dwType;
|
|
if (nType == TYPE_IMAP)
|
|
{
|
|
char serverName[MSG_MAXGROUPNAMELENGTH];
|
|
|
|
MSG_Master* pMaster = WFE_MSGGetMaster();
|
|
|
|
SendMessage(hControl, LB_GETTEXT, (WPARAM)nIndex,
|
|
(LPARAM)(DWORD)serverName);
|
|
|
|
char* pDefault = XP_STRSTR(serverName, szLoadString(IDS_DEFAULT_STRING));
|
|
if (pDefault)
|
|
*pDefault = '\0'; //get rid of (Default)
|
|
int nTotal = MSG_GetIMAPHosts(pMaster, NULL, 0);
|
|
if (nTotal)
|
|
{
|
|
MSG_IMAPHost** hImapHost = NULL;
|
|
hImapHost = new MSG_IMAPHost* [nTotal];
|
|
ASSERT(hImapHost != NULL);
|
|
nTotal = MSG_GetIMAPHosts(pMaster, hImapHost, nTotal);
|
|
for (int i = 0; i < nTotal; i++)
|
|
{
|
|
MSG_Host* pMsgHost = MSG_GetMSGHostFromIMAPHost(hImapHost[i]);
|
|
if (0 == lstrcmp(serverName, MSG_GetHostName(pMsgHost)))
|
|
{
|
|
MSG_DeleteIMAPHost(pMaster, hImapHost[i]);
|
|
break;
|
|
}
|
|
}
|
|
if (hImapHost)
|
|
delete [] hImapHost;
|
|
}
|
|
}
|
|
else
|
|
SendMessage(hControl, LB_DELETESTRING, (WPARAM)nIndex, 0);
|
|
|
|
parent.Detach();
|
|
return TRUE;
|
|
}
|
|
|
|
STDMETHODIMP CMailNewsPreferences::SetImapDefaultServer(HWND hControl)
|
|
{
|
|
char serverName[MSG_MAXGROUPNAMELENGTH];
|
|
SendMessage(hControl, LB_GETTEXT, (WPARAM)0, (LPARAM)(DWORD)serverName);
|
|
|
|
MSG_Master* pMaster = WFE_MSGGetMaster();
|
|
|
|
int nTotal = MSG_GetIMAPHosts(pMaster, NULL, 0);
|
|
if (nTotal)
|
|
{
|
|
MSG_IMAPHost** hImapHost = NULL;
|
|
hImapHost = new MSG_IMAPHost* [nTotal];
|
|
ASSERT(hImapHost != NULL);
|
|
nTotal = MSG_GetIMAPHosts(pMaster, hImapHost, nTotal);
|
|
for (int i = 0; i < nTotal; i++)
|
|
{
|
|
MSG_Host* pMsgHost = MSG_GetMSGHostFromIMAPHost(hImapHost[i]);
|
|
if (XP_STRSTR(serverName, MSG_GetHostName(pMsgHost)))
|
|
{
|
|
MSG_ReorderIMAPHost(pMaster, hImapHost[i], NULL);
|
|
break;
|
|
}
|
|
}
|
|
if (hImapHost)
|
|
delete [] hImapHost;
|
|
}
|
|
return NOERROR;
|
|
}
|
|
|
|
STDMETHODIMP CMailNewsPreferences::FillLdapDirList(HWND hControl, LPOLESTR lpServerName)
|
|
{
|
|
if (0 == XP_ListCount(m_pLdapServers))
|
|
return NOERROR;
|
|
|
|
DIR_Server* pServer;
|
|
//Keep m_pLdapServers, XP_ListNextObject will reset pointer
|
|
XP_List *pList = m_pLdapServers;
|
|
int nSelectedIndex = 0;
|
|
while (pServer = (DIR_Server*)XP_ListNextObject(pList))
|
|
{
|
|
if (pServer->description && pServer->dirType == LDAPDirectory)
|
|
{
|
|
int nIndex = (int)SendMessage(hControl, CB_ADDSTRING, 0,
|
|
(LPARAM)(LPCTSTR)pServer->description);
|
|
if (nIndex >= 0)
|
|
{
|
|
SendMessage(hControl, CB_SETITEMDATA, (WPARAM)nIndex,
|
|
(LPARAM)(DWORD)pServer);
|
|
if (DIR_TestFlag(pServer, DIR_AUTO_COMPLETE_ENABLED))
|
|
nSelectedIndex = nIndex;
|
|
}
|
|
}
|
|
}
|
|
SendMessage(hControl, CB_SETCURSEL, nSelectedIndex, 0);
|
|
return NOERROR;
|
|
}
|
|
|
|
STDMETHODIMP CMailNewsPreferences::SetLdapDirAutoComplete(HWND hControl, BOOL bOnOrOff)
|
|
{
|
|
int nIndex = (int)SendMessage(hControl, CB_GETCURSEL, 0,0);
|
|
DIR_Server* pServer = (DIR_Server*)SendMessage(hControl, CB_GETITEMDATA,
|
|
(WPARAM)nIndex, 0);
|
|
DIR_SetAutoCompleteEnabled(m_pLdapServers, pServer, bOnOrOff);
|
|
|
|
return NOERROR;
|
|
}
|
|
|
|
STDMETHODIMP CMailNewsPreferences::SaveLdapDirAutoComplete()
|
|
{
|
|
DIR_SaveServerPreferences(m_pLdapServers);
|
|
return NOERROR;
|
|
}
|
|
#endif /* MOZ_MAIL_NEWS */
|
|
|
|
#ifdef MOZ_OFFLINE
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// COfflinePreference
|
|
|
|
class COfflinePreference : public IOfflineInterface {
|
|
public:
|
|
COfflinePreference();
|
|
|
|
// IUnknown methods
|
|
STDMETHODIMP QueryInterface(REFIID riid, LPVOID FAR* ppvObj);
|
|
STDMETHODIMP_(ULONG) AddRef();
|
|
STDMETHODIMP_(ULONG) Release();
|
|
|
|
// IIntlFont methods
|
|
STDMETHODIMP DoSelectDiscussion(HWND hParent);
|
|
|
|
// Initialization routine to create contained and aggregated objects
|
|
HRESULT Init();
|
|
|
|
private:
|
|
|
|
ULONG m_uRef;
|
|
LPUNKNOWN m_pCategory; // inner object supporting ISpecifyPropertyPageObjects
|
|
};
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// COfflinePreference
|
|
|
|
COfflinePreference::COfflinePreference()
|
|
{
|
|
m_uRef = 0;
|
|
m_pCategory = NULL;
|
|
}
|
|
|
|
HRESULT
|
|
COfflinePreference::Init()
|
|
{
|
|
// Create the object as part of an aggregate
|
|
return FEU_CoCreateInstance(CLSID_OfflinePrefs, (LPUNKNOWN)this,
|
|
CLSCTX_INPROC_SERVER, IID_IUnknown, (LPVOID *)&m_pCategory);
|
|
}
|
|
|
|
STDMETHODIMP
|
|
COfflinePreference::QueryInterface(REFIID riid, LPVOID FAR* ppvObj)
|
|
{
|
|
*ppvObj = NULL;
|
|
|
|
if (riid == IID_IUnknown || riid == IID_OfflineInterface) {
|
|
*ppvObj = (LPVOID)this;
|
|
AddRef();
|
|
return NOERROR;
|
|
|
|
} else if (riid == IID_ISpecifyPropertyPageObjects) {
|
|
assert(m_pCategory);
|
|
return m_pCategory->QueryInterface(riid, ppvObj);
|
|
}
|
|
|
|
return ResultFromScode(E_NOINTERFACE);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG)
|
|
COfflinePreference::AddRef()
|
|
{
|
|
return ++m_uRef;
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG)
|
|
COfflinePreference::Release()
|
|
{
|
|
if (--m_uRef == 0) {
|
|
if (m_pCategory)
|
|
m_pCategory->Release();
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
return m_uRef;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
COfflinePreference::DoSelectDiscussion(HWND hParent)
|
|
{
|
|
CWnd parent;
|
|
|
|
parent.Attach(hParent);
|
|
|
|
CDlgOfflinePicker selDiscussionDlg(&parent);
|
|
selDiscussionDlg.DoModal();
|
|
|
|
parent.Detach();
|
|
return NOERROR;
|
|
}
|
|
#endif // MOZ_OFFLINE
|
|
|
|
typedef HRESULT (*DllServerFunction)(void);
|
|
|
|
static BOOL
|
|
RegisterCLSIDForDll(char * dllName)
|
|
{
|
|
BOOL bRetval = FALSE;
|
|
char szLib[_MAX_PATH + 32];
|
|
FE_GetProgramDirectory( szLib, _MAX_PATH + 32 );
|
|
if ( *szLib ) {
|
|
strcat( szLib, dllName );
|
|
|
|
if(szLib) {
|
|
HINSTANCE hLibInstance = hLibInstance = LoadLibrary(szLib);
|
|
#ifdef WIN32
|
|
if(hLibInstance)
|
|
#else
|
|
if(hLibInstance > (HINSTANCE)HINSTANCE_ERROR)
|
|
#endif
|
|
{
|
|
FARPROC RegistryFunc = NULL;
|
|
|
|
RegistryFunc = ::GetProcAddress(hLibInstance, "DllRegisterServer");
|
|
|
|
if(RegistryFunc) {
|
|
HRESULT hResult = (RegistryFunc)();
|
|
|
|
if(GetScode(hResult) == S_OK) {
|
|
bRetval = TRUE;
|
|
}
|
|
|
|
RegistryFunc = NULL;
|
|
}
|
|
else {
|
|
/* If the DLL doesn't have those functions then it just doesn't support
|
|
* self-registration. We don't consider that to be an error
|
|
*
|
|
* We should consider checking for the "OleSelfRegister" string in the
|
|
* StringFileInfo section of the version information resource. If the DLL
|
|
* has "OleSelfRegister" but doesn't have the self-registration functions
|
|
* then that would be an error
|
|
*/
|
|
bRetval = TRUE;
|
|
}
|
|
|
|
FreeLibrary(hLibInstance);
|
|
hLibInstance = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
return bRetval;
|
|
}
|
|
|
|
#ifdef MOZ_MAIL_NEWS
|
|
static BOOL
|
|
CreateMailNewsCategory(MWContext *pContext, LPSPECIFYPROPERTYPAGEOBJECTS *pCategory)
|
|
{
|
|
BOOL bResult = FALSE;
|
|
|
|
// Create the property page providers
|
|
CMailNewsPreferences *pMailNews = new CMailNewsPreferences(pContext);
|
|
pMailNews->AddRef();
|
|
|
|
// Initialize the mail news object. This allows it to load any objects that are
|
|
// contained or aggregated
|
|
if (SUCCEEDED(pMailNews->Init())) {
|
|
// Get the interface pointer for ISpecifyPropertyPageObjects
|
|
if (SUCCEEDED(pMailNews->QueryInterface(IID_ISpecifyPropertyPageObjects, (LPVOID *)pCategory)))
|
|
bResult = TRUE;
|
|
}
|
|
else {
|
|
// Try to register the dll and initialize again
|
|
#ifdef _WIN32
|
|
bResult = RegisterCLSIDForDll("mnpref32.dll");
|
|
#else
|
|
bResult = RegisterCLSIDForDll("mnpref16.dll");
|
|
#endif
|
|
if (bResult) {
|
|
if (SUCCEEDED(pMailNews->Init())) {
|
|
// Get the interface pointer for ISpecifyPropertyPageObjects
|
|
if (SUCCEEDED(pMailNews->QueryInterface(IID_ISpecifyPropertyPageObjects, (LPVOID *)pCategory)))
|
|
bResult = TRUE;
|
|
}
|
|
else
|
|
bResult = FALSE;
|
|
}
|
|
}
|
|
|
|
// We're all done with the object
|
|
pMailNews->Release();
|
|
return bResult;
|
|
}
|
|
#endif /* MOZ_MAIL_NEWS */
|
|
|
|
#ifdef MOZ_LOC_INDEP
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CLIPreference
|
|
|
|
class CLIPreference : public ILIPrefs {
|
|
public:
|
|
CLIPreference();
|
|
|
|
// IUnknown methods
|
|
STDMETHODIMP QueryInterface(REFIID riid, LPVOID FAR* ppvObj);
|
|
STDMETHODIMP_(ULONG) AddRef();
|
|
STDMETHODIMP_(ULONG) Release();
|
|
|
|
// Initialization routine to create contained and aggregated objects
|
|
HRESULT Init();
|
|
|
|
private:
|
|
|
|
ULONG m_uRef;
|
|
LPUNKNOWN m_pCategory; // inner object supporting ISpecifyPropertyPageObjects
|
|
};
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CLIPreference
|
|
|
|
CLIPreference::CLIPreference()
|
|
{
|
|
m_uRef = 0;
|
|
m_pCategory = NULL;
|
|
}
|
|
|
|
HRESULT
|
|
CLIPreference::Init()
|
|
{
|
|
// Create the object as part of an aggregate
|
|
return FEU_CoCreateInstance(CLSID_LIPrefs, (LPUNKNOWN)this,
|
|
CLSCTX_INPROC_SERVER, IID_IUnknown, (LPVOID *)&m_pCategory);
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CLIPreference::QueryInterface(REFIID riid, LPVOID FAR* ppvObj)
|
|
{
|
|
*ppvObj = NULL;
|
|
|
|
if (riid == IID_IUnknown || riid == IID_ILIlogin) {
|
|
*ppvObj = (LPVOID)this;
|
|
AddRef();
|
|
return NOERROR;
|
|
|
|
} else if (riid == IID_ISpecifyPropertyPageObjects) {
|
|
assert(m_pCategory);
|
|
return m_pCategory->QueryInterface(riid, ppvObj);
|
|
}
|
|
|
|
return ResultFromScode(E_NOINTERFACE);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG)
|
|
CLIPreference::AddRef()
|
|
{
|
|
return ++m_uRef;
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG)
|
|
CLIPreference::Release()
|
|
{
|
|
if (--m_uRef == 0) {
|
|
if (m_pCategory)
|
|
m_pCategory->Release();
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
return m_uRef;
|
|
}
|
|
#endif /* MOZ_LOC_INDEP */
|
|
|
|
#ifdef MOZ_SMARTUPDATE
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CSmartUpdatePreference
|
|
|
|
class CSmartUpdatePrefs : public ISmartUpdatePrefs {
|
|
public:
|
|
CSmartUpdatePrefs();
|
|
|
|
// IUnknown methods
|
|
STDMETHODIMP QueryInterface(REFIID riid, LPVOID FAR* ppvObj);
|
|
STDMETHODIMP_(ULONG) AddRef();
|
|
STDMETHODIMP_(ULONG) Release();
|
|
|
|
// ISmartUpdatePrefs methods
|
|
STDMETHODIMP_(LONG) Uninstall(char* regPackageName);
|
|
STDMETHODIMP_(LONG) EnumUninstall(void** context, char* packageName,
|
|
LONG len1, char*regPackageName, LONG len2);
|
|
|
|
private:
|
|
|
|
ULONG m_uRef;
|
|
};
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CSmartUpdatePrefs
|
|
CSmartUpdatePrefs::CSmartUpdatePrefs()
|
|
{
|
|
m_uRef = 0;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CSmartUpdatePrefs::QueryInterface(REFIID riid, LPVOID FAR* ppvObj)
|
|
{
|
|
*ppvObj = NULL;
|
|
|
|
if (riid == IID_IUnknown || riid == IID_ISmartUpdatePrefs) {
|
|
*ppvObj = (LPVOID)this;
|
|
AddRef();
|
|
return NOERROR;
|
|
|
|
}
|
|
|
|
return ResultFromScode(E_NOINTERFACE);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG)
|
|
CSmartUpdatePrefs::AddRef()
|
|
{
|
|
return ++m_uRef;
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG)
|
|
CSmartUpdatePrefs::Release()
|
|
{
|
|
if (--m_uRef == 0) {
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
return m_uRef;
|
|
}
|
|
|
|
STDMETHODIMP_(LONG)
|
|
CSmartUpdatePrefs::Uninstall(char* regPackageName)
|
|
{
|
|
return SU_Uninstall(regPackageName);
|
|
}
|
|
|
|
STDMETHODIMP_(LONG)
|
|
CSmartUpdatePrefs::EnumUninstall(void** context, char* packageName,
|
|
LONG len1, char*regPackageName, LONG len2)
|
|
{
|
|
return SU_EnumUninstall(context, packageName,len1, regPackageName,len2);
|
|
}
|
|
|
|
#endif /* MOZ_SMARTUPDATE */
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CAdvancedPrefs
|
|
|
|
class CAdvancedPrefs : public IAdvancedPrefs {
|
|
public:
|
|
CAdvancedPrefs();
|
|
|
|
// IUnknown methods
|
|
STDMETHODIMP QueryInterface(REFIID riid, LPVOID FAR* ppvObj);
|
|
STDMETHODIMP_(ULONG) AddRef();
|
|
STDMETHODIMP_(ULONG) Release();
|
|
|
|
// Initialization routine to create contained and aggregated objects
|
|
HRESULT Init();
|
|
|
|
private:
|
|
|
|
ULONG m_uRef;
|
|
LPUNKNOWN m_pCategory; // inner object supporting ISpecifyPropertyPageObjects
|
|
#ifdef MOZ_SMARTUPDATE
|
|
CSmartUpdatePrefs *m_pSmartUpdatePrefs;
|
|
#endif /* MOZ_SMARTUPDATE */
|
|
};
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CAdvancedPrefs
|
|
CAdvancedPrefs::CAdvancedPrefs()
|
|
{
|
|
m_uRef = 0;
|
|
m_pCategory = NULL;
|
|
#ifdef MOZ_SMARTUPDATE
|
|
m_pSmartUpdatePrefs = new CSmartUpdatePrefs;
|
|
m_pSmartUpdatePrefs->AddRef();
|
|
#endif /* MOZ_SMARTUPDATE */
|
|
}
|
|
|
|
HRESULT
|
|
CAdvancedPrefs::Init()
|
|
{
|
|
// Create the object as part of an aggregate
|
|
return FEU_CoCreateInstance(CLSID_AdvancedPrefs, (LPUNKNOWN)this,
|
|
CLSCTX_INPROC_SERVER, IID_IUnknown, (LPVOID *)&m_pCategory);
|
|
}
|
|
|
|
STDMETHODIMP
|
|
CAdvancedPrefs::QueryInterface(REFIID riid, LPVOID FAR* ppvObj)
|
|
{
|
|
*ppvObj = NULL;
|
|
|
|
if (riid == IID_IUnknown || riid == IID_IAdvancedPrefs) {
|
|
*ppvObj = (LPVOID)this;
|
|
AddRef();
|
|
return NOERROR;
|
|
#ifdef MOZ_SMARTUPDATE
|
|
} else if (riid == IID_ISmartUpdatePrefs) {
|
|
assert(m_pSmartUpdatePrefs);
|
|
return m_pSmartUpdatePrefs->QueryInterface(riid, ppvObj);
|
|
#endif /* MOZ_SMARTUPDATE */
|
|
} else if (riid == IID_ISpecifyPropertyPageObjects) {
|
|
assert(m_pCategory);
|
|
return m_pCategory->QueryInterface(riid, ppvObj);
|
|
}
|
|
|
|
return ResultFromScode(E_NOINTERFACE);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG)
|
|
CAdvancedPrefs::AddRef()
|
|
{
|
|
return ++m_uRef;
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG)
|
|
CAdvancedPrefs::Release()
|
|
{
|
|
if (--m_uRef == 0) {
|
|
if (m_pCategory)
|
|
m_pCategory->Release();
|
|
#ifdef MOZ_SMARTUPDATE
|
|
if (m_pSmartUpdatePrefs)
|
|
m_pSmartUpdatePrefs->Release();
|
|
#endif /* MOZ_SMARTUPDATE */
|
|
delete this;
|
|
return 0;
|
|
}
|
|
|
|
return m_uRef;
|
|
}
|
|
|
|
void wfe_ReloadAllWindows()
|
|
{
|
|
for (CGenericFrame *f = theApp.m_pFrameList; f; f = f->m_pNext)
|
|
{
|
|
CWinCX *pContext = f->GetMainWinContext();
|
|
MWContext *pMWContext = pContext ? pContext->GetContext() : 0;
|
|
if( pMWContext )
|
|
{
|
|
#ifdef EDITOR
|
|
if (EDT_IS_EDITOR(pMWContext))
|
|
{
|
|
// Edit can relayout page without having to do NET_GetURL
|
|
EDT_RefreshLayout(pMWContext);
|
|
|
|
} else
|
|
#endif // EDITOR
|
|
{
|
|
/* Must use NET_NORMAL_RELOAD when changing colors.
|
|
Default reload now uses NET_RESIZE_RELOAD
|
|
and the window colors are not updated.
|
|
Note: if we ever change layout to be able to determine which
|
|
elements are using the default color, we could use NET_RESIZE_RELOAD,
|
|
but we would have to set the changed colors here first.
|
|
*/
|
|
pContext->NiceReload(g_bReloadChangeColor ?
|
|
NET_NORMAL_RELOAD : NET_RESIZE_RELOAD);
|
|
}
|
|
}
|
|
}
|
|
g_bReloadChangeColor = FALSE;
|
|
g_bReloadAllWindows = FALSE;
|
|
}
|
|
|
|
static BOOL
|
|
CreateAppearancesCategory(CGenericFrame *pFrame, LPSPECIFYPROPERTYPAGEOBJECTS *pCategory)
|
|
{
|
|
int nCharsetId = pFrame ? theApp.m_pIntlFont->DocCSIDtoID(pFrame->m_iCSID) : theApp.m_iCSID;
|
|
CAppearancePrefs *pAppearance = new CAppearancePrefs(nCharsetId);
|
|
BOOL bResult = FALSE;
|
|
|
|
pAppearance->AddRef();
|
|
|
|
// Initialize the appearances object. This allows it to load any objects that are
|
|
// contained or aggregated
|
|
if (SUCCEEDED(pAppearance->Init())) {
|
|
// Get the interface pointer for ISpecifyPropertyPageObjects
|
|
if (SUCCEEDED(pAppearance->QueryInterface(IID_ISpecifyPropertyPageObjects, (LPVOID *)pCategory)))
|
|
bResult = TRUE;
|
|
}
|
|
else {
|
|
// Try to register the dll and initialize again
|
|
#ifdef _WIN32
|
|
bResult = RegisterCLSIDForDll("brpref32.dll");
|
|
#else
|
|
bResult = RegisterCLSIDForDll("brpref16.dll");
|
|
#endif
|
|
if (bResult) {
|
|
if (SUCCEEDED(pAppearance->Init())) {
|
|
// Get the interface pointer for ISpecifyPropertyPageObjects
|
|
if (SUCCEEDED(pAppearance->QueryInterface(IID_ISpecifyPropertyPageObjects, (LPVOID *)pCategory)))
|
|
bResult = TRUE;
|
|
}
|
|
else
|
|
bResult = FALSE;
|
|
}
|
|
}
|
|
|
|
// We're all done with the object
|
|
pAppearance->Release();
|
|
return bResult;
|
|
}
|
|
|
|
static BOOL
|
|
CreateBrowserCategory(MWContext *pContext, LPSPECIFYPROPERTYPAGEOBJECTS *pCategory)
|
|
{
|
|
CBrowserPrefs *pBrowser;
|
|
History_entry *pEntry;
|
|
BOOL bResult = FALSE;
|
|
|
|
// If this is the browser then use the URL for the current page
|
|
pEntry = pContext ? ( pContext->type == MWContextBrowser ? pContext->hist.cur_doc_ptr : NULL ) : NULL;
|
|
pBrowser = new CBrowserPrefs(pEntry ? pEntry->address : NULL);
|
|
pBrowser->AddRef();
|
|
|
|
// Initialize the browser pref object. This allows it to load any objects that are
|
|
// contained or aggregated
|
|
if (SUCCEEDED(pBrowser->Init())) {
|
|
// Get the interface pointer for ISpecifyPropertyPageObjects
|
|
if (SUCCEEDED(pBrowser->QueryInterface(IID_ISpecifyPropertyPageObjects, (LPVOID *)pCategory)))
|
|
bResult = TRUE;
|
|
}
|
|
else {
|
|
// Try to register the dll and initialize again
|
|
#ifdef _WIN32
|
|
bResult = RegisterCLSIDForDll("brpref32.dll");
|
|
#else
|
|
bResult = RegisterCLSIDForDll("brpref16.dll");
|
|
#endif
|
|
if (bResult) {
|
|
if (SUCCEEDED(pBrowser->Init())) {
|
|
// Get the interface pointer for ISpecifyPropertyPageObjects
|
|
if (SUCCEEDED(pBrowser->QueryInterface(IID_ISpecifyPropertyPageObjects, (LPVOID *)pCategory)))
|
|
bResult = TRUE;
|
|
}
|
|
else
|
|
bResult = FALSE;
|
|
}
|
|
}
|
|
|
|
// We're all done with the object
|
|
pBrowser->Release();
|
|
return bResult;
|
|
}
|
|
|
|
#ifdef EDITOR
|
|
static BOOL
|
|
CreateComposerCategory(LPSPECIFYPROPERTYPAGEOBJECTS *pCategory)
|
|
{
|
|
if (SUCCEEDED(CoCreateInstance(CLSID_EditorPrefs,
|
|
NULL,
|
|
CLSCTX_INPROC_SERVER,
|
|
IID_ISpecifyPropertyPageObjects,
|
|
(LPVOID *)pCategory))) {
|
|
return TRUE;
|
|
}
|
|
else {
|
|
// Try to register the dll and initialize again
|
|
#ifdef _WIN32
|
|
if (RegisterCLSIDForDll("edpref32.dll")) {
|
|
#else
|
|
if (RegisterCLSIDForDll("edpref16.dll")) {
|
|
#endif
|
|
if (SUCCEEDED(CoCreateInstance(CLSID_EditorPrefs,
|
|
NULL,
|
|
CLSCTX_INPROC_SERVER,
|
|
IID_ISpecifyPropertyPageObjects,
|
|
(LPVOID *)pCategory))) {
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
#endif /* EDITOR */
|
|
|
|
#ifdef MOZ_OFFLINE
|
|
static BOOL
|
|
CreateOfflineCategory(LPSPECIFYPROPERTYPAGEOBJECTS *pCategory)
|
|
{
|
|
BOOL bResult = FALSE;
|
|
|
|
// Create the property page providers
|
|
COfflinePreference *pOffline = new COfflinePreference;
|
|
pOffline->AddRef();
|
|
|
|
// Initialize the offline object. This allows it to load any objects that are
|
|
// contained or aggregated
|
|
if (SUCCEEDED(pOffline->Init())) {
|
|
// Get the interface pointer for ISpecifyPropertyPageObjects
|
|
if (SUCCEEDED(pOffline->QueryInterface(IID_ISpecifyPropertyPageObjects, (LPVOID *)pCategory)))
|
|
bResult = TRUE;
|
|
}
|
|
else {
|
|
// Try to register the dll and initialize again
|
|
#ifdef _WIN32
|
|
bResult = RegisterCLSIDForDll("mnpref32.dll");
|
|
#else
|
|
bResult = RegisterCLSIDForDll("mnpref16.dll");
|
|
#endif
|
|
if (bResult) {
|
|
if (SUCCEEDED(pOffline->Init())) {
|
|
// Get the interface pointer for ISpecifyPropertyPageObjects
|
|
if (SUCCEEDED(pOffline->QueryInterface(IID_ISpecifyPropertyPageObjects, (LPVOID *)pCategory)))
|
|
bResult = TRUE;
|
|
}
|
|
else
|
|
bResult = FALSE;
|
|
}
|
|
}
|
|
|
|
// We're all done with the object
|
|
pOffline->Release();
|
|
return bResult;
|
|
}
|
|
#endif /* MOZ_OFFLINE */
|
|
|
|
static BOOL
|
|
CreateAdvancedCategory(MWContext *pContext, LPSPECIFYPROPERTYPAGEOBJECTS *pCategory)
|
|
{
|
|
CAdvancedPrefs *pAdvanced;
|
|
BOOL bResult = FALSE;
|
|
|
|
|
|
pAdvanced = new CAdvancedPrefs();
|
|
pAdvanced->AddRef();
|
|
|
|
// Initialize the browser pref object. This allows it to load any objects that are
|
|
// contained or aggregated
|
|
if (SUCCEEDED(pAdvanced->Init())) {
|
|
// Get the interface pointer for ISpecifyPropertyPageObjects
|
|
if (SUCCEEDED(pAdvanced->QueryInterface(IID_ISpecifyPropertyPageObjects, (LPVOID *)pCategory)))
|
|
bResult = TRUE;
|
|
}
|
|
|
|
// We're all done with the object
|
|
pAdvanced->Release();
|
|
return bResult;
|
|
}
|
|
|
|
|
|
#ifdef MOZ_LOC_INDEP
|
|
static BOOL
|
|
CreateLICategory(LPSPECIFYPROPERTYPAGEOBJECTS *pCategory)
|
|
{
|
|
BOOL bResult = FALSE;
|
|
|
|
// Create the property page providers
|
|
CLIPreference *pLI = new CLIPreference;
|
|
pLI->AddRef();
|
|
|
|
// Initialize the offline object. This allows it to load any objects that are
|
|
// contained or aggregated
|
|
if (SUCCEEDED(pLI->Init())) {
|
|
// Get the interface pointer for ISpecifyPropertyPageObjects
|
|
if (SUCCEEDED(pLI->QueryInterface(IID_ISpecifyPropertyPageObjects, (LPVOID *)pCategory)))
|
|
bResult = TRUE;
|
|
}
|
|
|
|
// We're all done with the object
|
|
pLI->Release();
|
|
return bResult;
|
|
}
|
|
#endif // MOZ_LOC_INDEP
|
|
|
|
typedef HRESULT (STDAPICALLTYPE *PFNPREFS)(HWND, int, int, LPCSTR, ULONG, LPSPECIFYPROPERTYPAGEOBJECTS *, ULONG, NETHELPFUNC);
|
|
|
|
// Callback for prefs to display a NetHelp window
|
|
void CALLBACK
|
|
#ifndef _WIN32
|
|
__export
|
|
#endif
|
|
NetHelpWrapper(LPCSTR lpszHelpTopic)
|
|
{
|
|
// Call internal NetHelp routine
|
|
NetHelp(lpszHelpTopic);
|
|
}
|
|
|
|
void
|
|
wfe_DisplayPreferences(CGenericFrame *pFrame)
|
|
{
|
|
HINSTANCE hPrefDll;
|
|
LPSPECIFYPROPERTYPAGEOBJECTS categories[7];
|
|
PFNPREFS pfnCreatePropertyFrame;
|
|
ULONG nCategories = 0;
|
|
ULONG nInitialCategory;
|
|
ULONG nDesktopCategory = -1;
|
|
MWContext *pContext = pFrame ? pFrame->GetMainContext()->GetContext() : NULL;
|
|
static CGenericFrame *pCurrentFrame = NULL;
|
|
|
|
// Ensure all the helper information is loaded.
|
|
fe_MimeProtocolHelperInit();
|
|
|
|
// We only allow one pref UI window up at a time
|
|
if (pCurrentFrame) {
|
|
HWND hwnd = ::GetLastActivePopup(pCurrentFrame->m_hWnd);
|
|
|
|
#ifdef _WIN32
|
|
::SetForegroundWindow(hwnd);
|
|
#else
|
|
::BringWindowToTop(hwnd);
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
// Load the preferences UI DLL
|
|
#ifdef _WIN32
|
|
hPrefDll = LoadLibrary("prefui32.dll");
|
|
if (hPrefDll) {
|
|
#else
|
|
hPrefDll = LoadLibrary("prefui16.dll");
|
|
if ((UINT)hPrefDll > 32) {
|
|
#endif
|
|
|
|
// Get the address of the routine to create the property frame
|
|
pfnCreatePropertyFrame = (PFNPREFS)GetProcAddress(hPrefDll, "NS_CreatePropertyFrame");
|
|
if (!pfnCreatePropertyFrame) {
|
|
#ifdef _DEBUG
|
|
const char * const pText = "Unable to get proc address for NS_CreatePropertyFrame";
|
|
if ( pFrame ) {
|
|
pFrame->MessageBox( pText, NULL, MB_OK | MB_ICONEXCLAMATION);
|
|
} else {
|
|
AfxMessageBox( pText, MB_OK | MB_ICONEXCLAMATION );
|
|
}
|
|
#endif
|
|
FreeLibrary(hPrefDll);
|
|
return;
|
|
}
|
|
|
|
// Remember that this window is displaying the pref UI
|
|
pCurrentFrame = pFrame;
|
|
|
|
// Appearances category
|
|
if (CreateAppearancesCategory(pFrame, &categories[nCategories]))
|
|
nCategories++;
|
|
|
|
// Browser category
|
|
if (CreateBrowserCategory(pContext, &categories[nCategories]))
|
|
nCategories++;
|
|
|
|
#ifdef MOZ_MAIL_NEWS
|
|
// Mail and News category
|
|
CStubsCX *pStubCX = NULL; // Stub to use if we don't have a context.
|
|
// Get stub CX if we need it.
|
|
if ( !pContext ) {
|
|
pStubCX = new CStubsCX();
|
|
}
|
|
if (CreateMailNewsCategory(pContext ? pContext : pStubCX->GetContext(), &categories[nCategories]))
|
|
nCategories++;
|
|
// Free stub CX if we created one.
|
|
if ( pStubCX ) {
|
|
delete pStubCX;
|
|
}
|
|
#endif // MOZ_MAIL_NEWS
|
|
|
|
#ifdef MOZ_LOC_INDEP
|
|
// LI category
|
|
if (CreateLICategory(&categories[nCategories]))
|
|
nCategories++;
|
|
#endif // MOZ_LOC_INDEP
|
|
|
|
#ifdef EDITOR
|
|
// Editor category
|
|
if (SUCCEEDED(FEU_CoCreateInstance(CLSID_EditorPrefs,
|
|
NULL,
|
|
CLSCTX_INPROC_SERVER,
|
|
IID_ISpecifyPropertyPageObjects,
|
|
(LPVOID *)&categories[nCategories]))) {
|
|
nCategories++;
|
|
}
|
|
#endif EDITOR
|
|
|
|
#ifdef MOZ_OFFLINE
|
|
// Offline category
|
|
if (CreateOfflineCategory(&categories[nCategories]))
|
|
nCategories++;
|
|
#endif // MOZ_OFFLINE
|
|
|
|
// Advanced category
|
|
if (CreateAdvancedCategory(pContext, &categories[nCategories])) {
|
|
nCategories++;
|
|
}
|
|
|
|
// Windows Desktop Integration category.
|
|
if (SUCCEEDED(FEU_CoCreateInstance(CLSID_WindowsPrefs,
|
|
NULL,
|
|
CLSCTX_INPROC_SERVER,
|
|
IID_ISpecifyPropertyPageObjects,
|
|
(LPVOID *)&categories[nCategories]))) {
|
|
IWindowsPrefs *pWinPrefs;
|
|
if( SUCCEEDED( categories[nCategories]->QueryInterface( IID_IWindowsPrefs, (LPVOID*)&pWinPrefs ) ) ) {
|
|
pWinPrefs->SetDefaultBrowser( nsIDefaultBrowser::GetInterface() );
|
|
pWinPrefs->Release();
|
|
nDesktopCategory = nCategories++;
|
|
}
|
|
} else {
|
|
// Register DLL and try again.
|
|
RegisterCLSIDForDll( "winpref.dll" );
|
|
if (SUCCEEDED(FEU_CoCreateInstance(CLSID_WindowsPrefs,
|
|
NULL,
|
|
CLSCTX_INPROC_SERVER,
|
|
IID_ISpecifyPropertyPageObjects,
|
|
(LPVOID *)&categories[nCategories]))) {
|
|
IWindowsPrefs *pWinPrefs;
|
|
if( SUCCEEDED( categories[nCategories]->QueryInterface( IID_IWindowsPrefs, (LPVOID*)&pWinPrefs ) ) ) {
|
|
pWinPrefs->SetDefaultBrowser( nsIDefaultBrowser::GetInterface() );
|
|
pWinPrefs->Release();
|
|
nDesktopCategory = nCategories++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Make sure we have at least one category
|
|
if (nCategories == 0) {
|
|
if ( pFrame ) {
|
|
pFrame->MessageBox(szLoadString(IDS_CANT_LOAD_PREFS), NULL, MB_OK | MB_ICONEXCLAMATION);
|
|
} else {
|
|
AfxMessageBox(szLoadString(IDS_CANT_LOAD_PREFS), MB_OK | MB_ICONEXCLAMATION);
|
|
}
|
|
FreeLibrary(hPrefDll);
|
|
return;
|
|
}
|
|
|
|
// Hack to indicate whether we need to reload the windows because something
|
|
// like a color or a font changed
|
|
//
|
|
// We do have code that observes the XP prefs, but if more than one preference
|
|
// changes we'll get several callbacks (we don't have a way to do batch changes)
|
|
// and we'll reload the windows multiple times which is very sloppy...
|
|
g_bReloadAllWindows = FALSE;
|
|
g_bReloadChangeColor = FALSE;
|
|
|
|
// Figure out what the initial category we display should be
|
|
if (pFrame && pFrame->IsEditFrame()) {
|
|
nInitialCategory = 3;
|
|
|
|
} else if ( !pContext && !theApp.m_bShowPrefsOnStartup && nDesktopCategory!=-1 ) {
|
|
nInitialCategory = nDesktopCategory;
|
|
|
|
} else if (pContext && (pContext->type == MWContextMail ||
|
|
pContext->type == MWContextMailMsg ||
|
|
pContext->type == MWContextMessageComposition ||
|
|
pContext->type == MWContextAddressBook)) {
|
|
nInitialCategory = 2;
|
|
|
|
} else {
|
|
nInitialCategory = 1;
|
|
}
|
|
|
|
// Display the preferences
|
|
pfnCreatePropertyFrame(pFrame ? pFrame->m_hWnd : NULL, -1, -1, "Preferences", nCategories, categories,
|
|
nInitialCategory, NetHelpWrapper);
|
|
pCurrentFrame = NULL;
|
|
|
|
// Release the interface pointers for the preference categories
|
|
for (ULONG i = 0; i < nCategories; i++)
|
|
categories[i]->Release();
|
|
|
|
// Unload the library
|
|
FreeLibrary(hPrefDll);
|
|
|
|
// See if we need to reload the windows
|
|
if (g_bReloadAllWindows) {
|
|
wfe_ReloadAllWindows();
|
|
g_bReloadAllWindows = FALSE;
|
|
}
|
|
|
|
// Save out the preferences
|
|
PREF_SavePrefFile();
|
|
|
|
} else {
|
|
#ifdef _DEBUG
|
|
MessageBox(NULL, "Unable to load NSPREFUI.DLL", "Navigator",
|
|
MB_OK | MB_ICONEXCLAMATION);
|
|
#endif
|
|
}
|
|
}
|
|
|