зеркало из https://github.com/mozilla/pjs.git
840 строки
19 KiB
C++
840 строки
19 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"
|
|
|
|
#include "prefapi.h"
|
|
|
|
#include "netsdoc.h"
|
|
#include "template.h"
|
|
#ifdef MOZ_LDAP
|
|
#include "dirprefs.h"
|
|
#endif
|
|
#ifdef MOZ_MAIL_NEWS
|
|
#include "compfrm.h"
|
|
#endif
|
|
#ifdef EDITOR
|
|
//#include "edview.h"
|
|
#endif
|
|
|
|
#ifdef NSPR20
|
|
#include "private/prpriv.h"
|
|
#endif
|
|
|
|
// This is the NSPR priority of the main GUI thread (ie. mozilla)
|
|
|
|
#ifndef NSPR20
|
|
#ifdef XP_WIN32
|
|
#define MOZILLA_THREAD_PRIORITY 15
|
|
#else
|
|
#define MOZILLA_THREAD_PRIORITY 2
|
|
#endif
|
|
#else
|
|
#ifdef XP_WIN32
|
|
#define MOZILLA_THREAD_PRIORITY PR_PRIORITY_NORMAL
|
|
#else
|
|
#define MOZILLA_THREAD_PRIORITY PR_PRIORITY_LOW
|
|
#endif
|
|
#endif
|
|
|
|
#if defined(JAVA) || defined(MOCHA)
|
|
|
|
#ifndef XP_PC
|
|
#define XP_PC
|
|
#endif
|
|
#ifdef XP_WIN32
|
|
#ifndef HW_THREADS
|
|
#define HW_THREADS
|
|
#endif
|
|
#else
|
|
#ifndef SW_THREADS
|
|
#define SW_THREADS
|
|
#endif
|
|
#endif
|
|
|
|
#ifndef X386
|
|
#define X386
|
|
#endif
|
|
|
|
#include "nspr.h"
|
|
#include "java.h"
|
|
#endif /* JAVA || MOCHA */
|
|
|
|
#if defined(XP_PC) && !defined(_WIN32)
|
|
#ifdef JAVA
|
|
extern "C" PR_PUBLIC_API(void) SuspendAllJavaThreads(void);
|
|
#endif
|
|
#endif
|
|
|
|
// Shared event queue used to pass messages between the java threads and
|
|
// the main navigator thread...
|
|
extern "C" {
|
|
PREventQueue *mozilla_event_queue;
|
|
PRThread *mozilla_thread;
|
|
};
|
|
|
|
|
|
//
|
|
// Call layout with the red green and blue values of the current COLORREF
|
|
//
|
|
MODULE_PRIVATE void
|
|
wfe_SetLayoutColor(int type, COLORREF color)
|
|
{
|
|
|
|
uint8 red = GetRValue(color);
|
|
uint8 green = GetGValue(color);
|
|
uint8 blue = GetBValue(color);
|
|
|
|
LO_SetDefaultColor(type, red, green, blue);
|
|
|
|
}
|
|
|
|
void OpenDraftExit (URL_Struct *url_struct, int/*status*/,MWContext *pContext)
|
|
{
|
|
XP_ASSERT (url_struct && pContext);
|
|
|
|
if (!url_struct) return;
|
|
|
|
NET_FreeURLStruct ( url_struct );
|
|
}
|
|
|
|
#ifdef MOZ_LDAP
|
|
// This function handles callbacks for all of the *bad* things which we
|
|
// are caching in netscape.h...In general, we should try to move these but
|
|
// the mnprefs.cpp & mnwizard.cpp are such a mess that I am punting for now
|
|
int PR_CALLBACK
|
|
DirServerListChanged(const char *pref, void *data)
|
|
{
|
|
CString msg = "abook.nab";
|
|
|
|
DIR_GetServerPreferences(&theApp.m_directories, msg);
|
|
return TRUE;
|
|
}
|
|
#endif // MOZ_LDAP
|
|
|
|
// This function handles callbacks for all of the *bad* things which we
|
|
// are caching in netscape.h...In general, we should try to move these but
|
|
// the mnprefs.cpp & mnwizard.cpp are such a mess that I am punting for now
|
|
int PR_CALLBACK
|
|
WinFEPrefChangedFunc(const char *pref, void *data)
|
|
{
|
|
if (!strcmpi(pref,"browser.startup.homepage")) {
|
|
LPSTR lpszHomePage = NULL;
|
|
|
|
PREF_CopyCharPref("browser.startup.homepage", &lpszHomePage);
|
|
theApp.m_pHomePage = lpszHomePage;
|
|
if (lpszHomePage)
|
|
XP_FREE(lpszHomePage);
|
|
|
|
} else if (!strcmpi(pref,"browser.cache.directory")) {
|
|
LPSTR lpszCacheDir;
|
|
|
|
PREF_CopyCharPref("browser.cache.directory",&lpszCacheDir);
|
|
theApp.m_pCacheDir = lpszCacheDir;
|
|
if (lpszCacheDir)
|
|
XP_FREE(lpszCacheDir);
|
|
} else if (!strcmpi(pref,"browser.bookmark_location")) {
|
|
LPSTR lpszPref;
|
|
|
|
PREF_CopyCharPref("browser.bookmark_location",&lpszPref);
|
|
theApp.m_pBookmarkFile = lpszPref;
|
|
if (lpszPref)
|
|
XP_FREE(lpszPref);
|
|
}
|
|
else if (!strcmpi(pref,"mime.types.all_defined")) { //Begin CRN_MIME
|
|
fe_UpdateMControlMimeTypes();
|
|
}//End CRN_MIME
|
|
|
|
return PREF_NOERROR;
|
|
};
|
|
|
|
#ifdef XP_WIN16
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// 16-bit RTL helper functions
|
|
//
|
|
// These functions are used by NSPR to access RTL functions that are
|
|
// not available from 16-bit DLLs... They provide the necessary
|
|
// "mov DS, SS" entry prolog to fix "DS == SS" which is assumed
|
|
// by the MS RTL...
|
|
//
|
|
#ifdef DEBUG
|
|
extern "C" int _heapchk();
|
|
extern "C" {
|
|
extern unsigned long hcCount;
|
|
extern unsigned long hcMallocCount;
|
|
extern unsigned long hcFreeCount;
|
|
extern unsigned long hcLimit;
|
|
}
|
|
|
|
static void chk()
|
|
{
|
|
static unsigned long checkCount;
|
|
|
|
if (_heapchk() != _HEAPOK)
|
|
__asm { int 3 }
|
|
hcCount += 1;
|
|
if (hcCount >= hcLimit)
|
|
__asm { int 3 }
|
|
}
|
|
|
|
extern "C" static void aFchkstk(void)
|
|
{
|
|
}
|
|
|
|
#endif
|
|
|
|
#if defined(XP_WIN16)
|
|
// Only used when debug build on win16.
|
|
BOOL PR_CALLBACK DefaultBlockingHook(void) {
|
|
MSG msg;
|
|
BOOL ret = FALSE;
|
|
|
|
/*
|
|
* Only dispatch messages if the current thread is mozilla...
|
|
*/
|
|
if (mozilla_thread == PR_CurrentThread()) {
|
|
/* get the next message if any */
|
|
ret = (BOOL)PeekMessage(&msg,NULL,0,0,PM_NOREMOVE);
|
|
/* if we got one, process it */
|
|
if (ret) {
|
|
ret = theApp.NSPumpMessage();
|
|
}
|
|
}
|
|
/* TRUE if we got a message */
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
#ifdef MOZ_USE_MS_MALLOC
|
|
/*--------------------------------------------------------------------------*/
|
|
/* 32-bit aligned memory management routines */
|
|
/*--------------------------------------------------------------------------*/
|
|
/* */
|
|
/* The strategy for aligning memory to 32-bit boundaries is to allocate an */
|
|
/* extra 32-bits for each allocation - A 16-bit header and a 16-bit padding */
|
|
/* */
|
|
/* If the memory returned from _fmalloc() is not 32-bit aligned, then the */
|
|
/* pointer is adjusted forward by 2 bytes to correctly align the memory. */
|
|
/* The resulting 2-byte header is initialized to PR_NON_ALIGNED_HEADER. */
|
|
/* There is also an "extra" 2 byte padding at the end of the block which */
|
|
/* are unused. */
|
|
/* */
|
|
/* If the memory returned from _fmalloc() is already 32-aligned, then the */
|
|
/* pointer is adjusted forward by 4 bytes to maintain alignment. The first */
|
|
/* 2 bytes are filled with a pad value in DEBUG mode and the next 2 bytes */
|
|
/* are initialized to PR_ALIGNED_HEADER */
|
|
/* */
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
#define PR_HEADER_SIZE 4
|
|
#define PR_ALIGNED_PAD 0xDEAD
|
|
#define PR_ALIGNED_HEADER 0xAD04
|
|
#define PR_NONALIGNED_HEADER 0xAD02
|
|
|
|
#define PR_IS_ALIGNED(p) ( !(OFFSETOF(p) & 0x03) )
|
|
#define PR_GET_HEADER_WORD(p) ( *((WORD*)(((char *)(p))-2)) )
|
|
#define PR_GET_HEADER_PAD(p) ( *((WORD*)(((char *)(p))-4)) )
|
|
#define PR_GET_ROOT(p) ( (void *)(((unsigned long)(p)) - (unsigned long)(PR_GET_HEADER_WORD(p) & 0x000F)) )
|
|
|
|
//
|
|
// This macro verifies that a memory block is 32-bit aligned and contains
|
|
// the proper header values...
|
|
//
|
|
#ifdef DEBUG
|
|
#define PR_VALIDATE_BLOCK(p) ASSERT( PR_IS_ALIGNED(p) ); \
|
|
if (p) { \
|
|
if (PR_GET_HEADER_WORD(p) == PR_ALIGNED_HEADER) { \
|
|
ASSERT( PR_GET_HEADER_PAD(p) == PR_ALIGNED_PAD ); \
|
|
} else { \
|
|
ASSERT( PR_GET_HEADER_WORD(p) == PR_NONALIGNED_HEADER ); \
|
|
} \
|
|
}
|
|
#else
|
|
#define PR_VALIDATE_BLOCK(p)
|
|
#endif
|
|
|
|
void * malloc(size_t size) {
|
|
char *p;
|
|
/* allocate a 16-bit aligned block of memory */
|
|
p = (char *)_fmalloc(size + PR_HEADER_SIZE);
|
|
|
|
/* Memory is already 32-bit aligned */
|
|
if ( PR_IS_ALIGNED(p) ) {
|
|
#ifdef DEBUG
|
|
*((WORD *)p) = PR_ALIGNED_PAD;
|
|
#endif
|
|
p = ((char *)p) + 2;
|
|
*((WORD *)p) = PR_ALIGNED_HEADER;
|
|
|
|
}
|
|
/* Align memory to 32-bit boundary */
|
|
else {
|
|
*((WORD *)p) = PR_NONALIGNED_HEADER;
|
|
}
|
|
p = ((char *)p) + 2;
|
|
|
|
PR_VALIDATE_BLOCK(p);
|
|
return (void *)p;
|
|
|
|
}
|
|
|
|
void free(void *p) {
|
|
void *h;
|
|
|
|
if (p) {
|
|
PR_VALIDATE_BLOCK(p);
|
|
|
|
h = PR_GET_ROOT(p);
|
|
ASSERT( (OFFSETOF(p) - OFFSETOF(h)) <= PR_HEADER_SIZE );
|
|
} else {
|
|
h = NULL;
|
|
}
|
|
_ffree(h);
|
|
}
|
|
|
|
void * realloc(void *p, size_t size) {
|
|
size_t old_size;
|
|
void *new_block;
|
|
void *h;
|
|
|
|
if (p) {
|
|
PR_VALIDATE_BLOCK(p);
|
|
|
|
h = PR_GET_ROOT(p);
|
|
old_size = _fmsize(h) - (PR_GET_HEADER_WORD(p) == PR_ALIGNED_HEADER ? 4 : 2);
|
|
ASSERT( (OFFSETOF(p) - OFFSETOF(h)) <= PR_HEADER_SIZE );
|
|
} else {
|
|
h = NULL;
|
|
old_size = 0;
|
|
}
|
|
|
|
|
|
/* allocate a 32-bit aligned block of memory */
|
|
new_block = malloc(size);
|
|
|
|
if (p && new_block) {
|
|
/* copy the original data into the new block of memory */
|
|
memcpy(new_block, p, (old_size < size ? old_size : size));
|
|
/* free the old block of memory */
|
|
_ffree(h);
|
|
}
|
|
|
|
p = new_block;
|
|
|
|
PR_VALIDATE_BLOCK(p);
|
|
return p;
|
|
}
|
|
|
|
void * calloc(size_t size, size_t number) {
|
|
void *p;
|
|
long bytes;
|
|
|
|
bytes = (long)size * (long)number;
|
|
ASSERT(bytes < 0xFFF0L);
|
|
|
|
/* allocate a 32-bit aligned block of memory */
|
|
p = malloc((size_t)bytes);
|
|
|
|
if (p) {
|
|
memset(p, 0x00, (size_t)bytes);
|
|
}
|
|
PR_VALIDATE_BLOCK(p);
|
|
return p;
|
|
}
|
|
#endif
|
|
/*--------------------------------------------------------------------------*/
|
|
|
|
|
|
void * PR_CALLBACK __ns_malloc(size_t size) {
|
|
return malloc(size);
|
|
}
|
|
|
|
void PR_CALLBACK __ns_free(void *p) {
|
|
free(p);
|
|
}
|
|
|
|
void* PR_CALLBACK __ns_realloc(void *p, size_t size) {
|
|
return realloc(p, size);
|
|
}
|
|
|
|
void* PR_CALLBACK __ns_calloc(size_t size, size_t number) {
|
|
return calloc(size, number);
|
|
}
|
|
|
|
int PR_CALLBACK __ns_gethostname(char * name, int namelen) {
|
|
return gethostname(name, namelen);
|
|
}
|
|
|
|
struct hostent * PR_CALLBACK __ns_gethostbyname(const char * name) {
|
|
return gethostbyname(name);
|
|
}
|
|
|
|
struct hostent * PR_CALLBACK __ns_gethostbyaddr(const char * addr, int len, int type) {
|
|
return gethostbyaddr(addr, len, type);
|
|
}
|
|
|
|
char* PR_CALLBACK __ns_getenv(const char *varname)
|
|
{
|
|
return getenv(varname);
|
|
}
|
|
|
|
int PR_CALLBACK __ns_putenv(const char *varname)
|
|
{
|
|
return putenv(varname);
|
|
}
|
|
|
|
int PR_CALLBACK __ns_auxOutput(const char *string)
|
|
{
|
|
#ifdef DEBUG
|
|
::OutputDebugString(string);
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
void PR_CALLBACK __ns_exit(int exitCode)
|
|
{
|
|
ASSERT(0);
|
|
exit(exitCode);
|
|
}
|
|
|
|
size_t PR_CALLBACK __ns_strftime(char *s, size_t len, const char *fmt, const struct tm *p)
|
|
{
|
|
return strftime(s, len, fmt, p);
|
|
}
|
|
|
|
|
|
u_long PR_CALLBACK __ns_ntohl(u_long netlong)
|
|
{
|
|
return ntohl(netlong);
|
|
}
|
|
|
|
u_short PR_CALLBACK __ns_ntohs(u_short netshort)
|
|
{
|
|
return ntohs(netshort);
|
|
}
|
|
|
|
int PR_CALLBACK __ns_closesocket(SOCKET s)
|
|
{
|
|
return closesocket(s);
|
|
}
|
|
|
|
int PR_CALLBACK __ns_setsockopt(SOCKET s, int level, int optname, const char FAR * optval, int optlen)
|
|
{
|
|
return setsockopt(s, level, optname, optval, optlen);
|
|
}
|
|
|
|
SOCKET PR_CALLBACK __ns_socket(int af, int type, int protocol)
|
|
{
|
|
return socket(af, type, protocol);
|
|
}
|
|
|
|
int PR_CALLBACK __ns_getsockname(SOCKET s, struct sockaddr FAR *name, int FAR * namelen)
|
|
{
|
|
return getsockname(s, name, namelen);
|
|
}
|
|
|
|
u_long PR_CALLBACK __ns_htonl(u_long hostlong)
|
|
{
|
|
return htonl(hostlong);
|
|
}
|
|
|
|
u_short PR_CALLBACK __ns_htons(u_short hostshort)
|
|
{
|
|
return htons(hostshort);
|
|
}
|
|
|
|
unsigned long PR_CALLBACK __ns_inet_addr(const char FAR * cp)
|
|
{
|
|
return inet_addr(cp);
|
|
}
|
|
|
|
int PR_CALLBACK __ns_WSAGetLastError(void)
|
|
{
|
|
return WSAGetLastError();
|
|
}
|
|
|
|
int PR_CALLBACK __ns_connect(SOCKET s, const struct sockaddr FAR *name, int namelen)
|
|
{
|
|
return connect(s, name, namelen);
|
|
}
|
|
|
|
int PR_CALLBACK __ns_recv(SOCKET s, char FAR * buf, int len, int flags)
|
|
{
|
|
return recv(s, buf, len, flags);
|
|
}
|
|
|
|
int PR_CALLBACK __ns_ioctlsocket(SOCKET s, long cmd, u_long FAR *argp)
|
|
{
|
|
return ioctlsocket(s, cmd, argp);
|
|
}
|
|
|
|
int PR_CALLBACK __ns_recvfrom(SOCKET s, char FAR * buf, int len, int flags, struct sockaddr FAR *from, int FAR * fromlen)
|
|
{
|
|
return recvfrom(s, buf, len, flags, from, fromlen);
|
|
}
|
|
|
|
int PR_CALLBACK __ns_send(SOCKET s, const char FAR * buf, int len, int flags)
|
|
{
|
|
return send(s, buf, len, flags);
|
|
}
|
|
|
|
int PR_CALLBACK __ns_sendto(SOCKET s, const char FAR * buf, int len, int flags, const struct sockaddr FAR *to, int tolen)
|
|
{
|
|
return sendto(s, buf, len, flags, to, tolen);
|
|
}
|
|
|
|
SOCKET PR_CALLBACK __ns_accept(SOCKET s, struct sockaddr FAR *addr, int FAR *addrlen)
|
|
{
|
|
return accept(s, addr, addrlen);
|
|
}
|
|
|
|
int PR_CALLBACK __ns_listen(SOCKET s, int backlog)
|
|
{
|
|
return listen(s, backlog);
|
|
}
|
|
|
|
int PR_CALLBACK __ns_bind(SOCKET s, const struct sockaddr FAR *addr, int namelen)
|
|
{
|
|
return bind(s, addr, namelen);
|
|
}
|
|
|
|
int PR_CALLBACK __ns_select(int nfds, fd_set FAR *readfds, fd_set FAR *writefds, fd_set FAR *exceptfds, const struct timeval FAR *timeout)
|
|
{
|
|
return select(nfds, readfds, writefds, exceptfds, timeout);
|
|
}
|
|
|
|
int PR_CALLBACK __ns_getsockopt(SOCKET s, int level, int optname, char FAR * optval, int FAR *optlen)
|
|
{
|
|
return getsockopt(s, level, optname, optval, optlen);
|
|
}
|
|
|
|
struct protoent * PR_CALLBACK __ns_getprotobyname(const char FAR * name)
|
|
{
|
|
return getprotobyname(name);
|
|
}
|
|
|
|
int PR_CALLBACK __ns_WSAAsyncSelect(SOCKET s, HWND hWnd, u_int wMsg,
|
|
long lEvent)
|
|
{
|
|
return WSAAsyncSelect(s, hWnd, wMsg, lEvent);
|
|
}
|
|
|
|
|
|
void PR_CALLBACK __ns_WSASetLastError(int iError)
|
|
{
|
|
WSASetLastError(iError);
|
|
}
|
|
|
|
int PR_CALLBACK MozillaNonblockingNetTicklerCallback(void)
|
|
{
|
|
// We need to tickle the network and the UI if we
|
|
// are stuck in java networking code.
|
|
|
|
MSG msg;
|
|
|
|
if (PR_CurrentThread() == mozilla_thread) {
|
|
/* get the next message if any */
|
|
if (PeekMessage(&msg,NULL,0,0,PM_NOREMOVE)) {
|
|
(void) theApp.NSPumpMessage();
|
|
return FALSE;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
#endif /* XP_WIN16 */
|
|
|
|
void fe_InitJava()
|
|
{
|
|
}
|
|
|
|
void fe_InitNSPR(void* stackBase)
|
|
{
|
|
#ifdef XP_WIN16
|
|
#if !defined(NSPR20)
|
|
//
|
|
// The 16-bit MS RTL prohibits 16-bit DLLs from calling some RTL functions.
|
|
// ie.
|
|
// malloc/free
|
|
// strftime
|
|
// sscanf
|
|
// etc...
|
|
// To fix this limitation, function pointers are passed to NSPR which
|
|
// route the RTL functions "into the EXE" where the actual RTL function
|
|
// is available. (Oh what a tangled web we weave :-( )
|
|
//
|
|
static struct PRMethodCallbackStr DLLCallbacks = {
|
|
__ns_malloc,
|
|
__ns_realloc,
|
|
__ns_calloc,
|
|
__ns_free,
|
|
__ns_gethostname,
|
|
__ns_gethostbyname,
|
|
__ns_gethostbyaddr,
|
|
__ns_getenv,
|
|
__ns_putenv,
|
|
__ns_auxOutput,
|
|
__ns_exit,
|
|
__ns_strftime,
|
|
|
|
__ns_ntohl,
|
|
__ns_ntohs,
|
|
__ns_closesocket,
|
|
__ns_setsockopt,
|
|
__ns_socket,
|
|
__ns_getsockname,
|
|
__ns_htonl,
|
|
__ns_htons,
|
|
__ns_inet_addr,
|
|
__ns_WSAGetLastError,
|
|
__ns_connect,
|
|
__ns_recv,
|
|
__ns_ioctlsocket,
|
|
__ns_recvfrom,
|
|
__ns_send,
|
|
__ns_sendto,
|
|
__ns_accept,
|
|
__ns_listen,
|
|
__ns_bind,
|
|
__ns_select,
|
|
__ns_getsockopt,
|
|
__ns_getprotobyname,
|
|
__ns_WSAAsyncSelect,
|
|
__ns_WSASetLastError
|
|
};
|
|
|
|
// Perform the 16-bit ONLY callback initialization...
|
|
PR_MDInit(&DLLCallbacks);
|
|
#endif /* NSPR20 */
|
|
#endif /* XP_WIN16 */
|
|
|
|
#if defined(JAVA) || defined(MOCHA)
|
|
#ifndef NSPR20
|
|
// Initialize the NSPR library
|
|
PR_Init( "mozilla", MOZILLA_THREAD_PRIORITY, 1, stackBase);
|
|
|
|
mozilla_thread = PR_CurrentThread();
|
|
#else
|
|
PR_STDIO_INIT()
|
|
mozilla_thread = PR_CurrentThread();
|
|
PR_SetThreadGCAble();
|
|
PR_SetThreadPriority(mozilla_thread, MOZILLA_THREAD_PRIORITY);
|
|
PL_InitializeEventsLib("mozilla");
|
|
#endif
|
|
#endif /* JAVA || MOCHA */
|
|
}
|
|
|
|
BOOL fe_ShutdownJava()
|
|
{
|
|
BOOL bRetval = TRUE;
|
|
|
|
#ifdef JAVA
|
|
bRetval = (LJ_ShutdownJava() == LJJavaStatus_Enabled);
|
|
#if defined(XP_PC) && !defined(_WIN32)
|
|
SuspendAllJavaThreads();
|
|
#endif
|
|
#endif
|
|
|
|
return(bRetval);
|
|
}
|
|
|
|
//
|
|
// Register our document icons
|
|
//
|
|
static const CString strMARKUP_KEY = "NetscapeMarkup";
|
|
|
|
BOOL fe_RegisterOLEIcon ( LPSTR szCLSIDObject, // Class ID of the Object
|
|
LPSTR szObjectName, // Human Readable Object Name
|
|
LPSTR szIconPath ) // Path and Index of Icon
|
|
{
|
|
HKEY hKey;
|
|
LONG lRes = 0L;
|
|
|
|
char lpszCLSID[] = "CLSID"; // OLE Class ID Section of eg DB
|
|
char lpszDefIcon[] = "\\DefaultIcon"; // Default Icon Subkey
|
|
char lpBuffer[64]; // Working buffer
|
|
|
|
// Open the reg db for the "CLSID" key, this top-level key
|
|
// is where OLE2 and other OLE aware apps will look for
|
|
// this information.
|
|
|
|
lRes = RegOpenKey(HKEY_CLASSES_ROOT, lpszCLSID, &hKey);
|
|
|
|
if (ERROR_SUCCESS != lRes)
|
|
{
|
|
TRACE("RegOpenKey failed.\n");
|
|
return FALSE;
|
|
}
|
|
|
|
// Register the Object
|
|
|
|
// Set the value of the CLSID Entry to the Human Readable
|
|
// name of the Object
|
|
|
|
lRes = RegSetValue( hKey,
|
|
szCLSIDObject,
|
|
REG_SZ,
|
|
szObjectName,
|
|
lstrlen(szObjectName)
|
|
);
|
|
|
|
if (ERROR_SUCCESS != lRes) // bail on failure
|
|
{
|
|
RegCloseKey(hKey);
|
|
return FALSE;
|
|
}
|
|
|
|
// Build "defaulticon" subkey string "{ <class id> }\\DefaultIcon"
|
|
lstrcpy (lpBuffer, szCLSIDObject);
|
|
lstrcat (lpBuffer, lpszDefIcon);
|
|
|
|
// Set Object's default icon entry to point to the
|
|
// default icon for the object
|
|
|
|
lRes = RegSetValue( hKey,
|
|
lpBuffer,
|
|
REG_SZ,
|
|
szIconPath,
|
|
lstrlen(szIconPath)
|
|
);
|
|
|
|
if (ERROR_SUCCESS != lRes) // bail on failure
|
|
{
|
|
RegCloseKey(hKey);
|
|
return FALSE;
|
|
}
|
|
|
|
// Close the reg db
|
|
|
|
RegCloseKey(hKey);
|
|
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
lRes = RegOpenKey(HKEY_CLASSES_ROOT, (const char*)strMARKUP_KEY, &hKey);
|
|
|
|
if (ERROR_SUCCESS != lRes)
|
|
{
|
|
TRACE("RegOpenKey failed.\n");
|
|
return FALSE;
|
|
}
|
|
|
|
// Set Object's default icon entry to point to the
|
|
// default icon for the object
|
|
|
|
lRes = RegSetValue( hKey,
|
|
lpszCLSID,
|
|
REG_SZ,
|
|
szCLSIDObject,
|
|
lstrlen(szCLSIDObject)
|
|
);
|
|
|
|
if (ERROR_SUCCESS != lRes) // bail on failure
|
|
{
|
|
RegCloseKey(hKey);
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// Set Object's default icon entry to point to the
|
|
// default icon for the object
|
|
|
|
lRes = RegSetValue( hKey,
|
|
"DefaultIcon",
|
|
REG_SZ,
|
|
szIconPath,
|
|
lstrlen(szIconPath)
|
|
);
|
|
|
|
if (ERROR_SUCCESS != lRes) // bail on failure
|
|
{
|
|
RegCloseKey(hKey);
|
|
return FALSE;
|
|
}
|
|
|
|
// Close the reg db
|
|
|
|
RegCloseKey(hKey);
|
|
|
|
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
#if defined(XP_WIN16)
|
|
/****************************************************************************/
|
|
/* */
|
|
/* BEWARE! BEWARE! BEWARE! BEWARE! BEWARE! BEWARE! BEWARE! BEWARE! BEWARE! */
|
|
/* */
|
|
/* The following code is duplicated from ns\modules\applet\src\lj_embed.c */
|
|
/* It is ONLY required for 16-bit until JAVA becomes integrated into the */
|
|
/* build! */
|
|
/* */
|
|
/* BEWARE! BEWARE! BEWARE! BEWARE! BEWARE! BEWARE! BEWARE! BEWARE! BEWARE! */
|
|
/* */
|
|
/****************************************************************************/
|
|
#if defined(MOCHA) && !defined(JAVA)
|
|
#include "prevent.h"
|
|
#include "prlog.h"
|
|
|
|
PR_LOG_DEFINE(Event);
|
|
|
|
/*
|
|
* There is currently a race between which thread destroys synchronous
|
|
* events. See bug 32832 for a full description.
|
|
*/
|
|
void
|
|
LJ_ProcessEvent()
|
|
{
|
|
PREvent* event;
|
|
|
|
for (;;) {
|
|
PR_LOG_BEGIN(Event, debug, ("$$$ getting event\n"));
|
|
|
|
event = PR_GetEvent(mozilla_event_queue);
|
|
if (event == NULL) {
|
|
return;
|
|
}
|
|
|
|
if(event->synchronousResult) {
|
|
PR_HandleEvent(event);
|
|
PR_LOG_END(Event, debug, ("$$$ done with sync event\n"));
|
|
}
|
|
else {
|
|
PR_HandleEvent(event);
|
|
PR_LOG_END(Event, debug, ("$$$ done with async event\n"));
|
|
PR_DestroyEvent(event);
|
|
}
|
|
|
|
}
|
|
}
|
|
#endif // MOCHA && !JAVA
|
|
#endif // XP_WIN16
|
|
|
|
#ifdef XP_WIN16
|
|
#if defined(NSPR20)
|
|
#include "private\prpriv.h"
|
|
#endif
|
|
void fe_yield(void)
|
|
{
|
|
PR_Sleep(PR_INTERVAL_NO_WAIT);
|
|
}
|
|
#endif
|