gecko-dev/cmd/winfe/feorphan.cpp

/* -*- 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
#include "prefs.h" //To access g_bReloadChangeColor;

#include "private/prpriv.h"

// This is the NSPR priority of the main GUI thread (ie. mozilla)

#ifdef XP_WIN32
#define MOZILLA_THREAD_PRIORITY PR_PRIORITY_NORMAL
#else
#define MOZILLA_THREAD_PRIORITY PR_PRIORITY_LOW
#endif

#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 "plevent.h"

#if defined(OJI)
#include "jvmmgr.h"
#elif defined(JAVA)
#include "java.h"
#endif

#if defined(XP_PC) && !defined(_WIN32)
#if defined(JAVA) || defined(OJI)
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)
{
#ifndef MOZ_NGLAYOUT
	uint8 red   = GetRValue(color);
	uint8 green	= GetGValue(color);
	uint8 blue  = GetBValue(color);

	LO_SetDefaultColor(type, red, green, blue);
    if( type != LO_COLOR_BG )
        g_bReloadChangeColor = TRUE;

#endif /* MOZ_NGLAYOUT */
}

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)
{
	theApp.m_directories = DIR_GetDirServers();
	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)
{
    PR_STDIO_INIT()
    mozilla_thread = PR_CurrentThread();
    PR_SetThreadGCAble();
    PR_SetThreadPriority(mozilla_thread, MOZILLA_THREAD_PRIORITY);
    PL_InitializeEventsLib("mozilla");
}

BOOL fe_ShutdownJava()
{
	BOOL bRetval = TRUE;

#if defined(OJI)
    (void)JVM_ShutdownJVM();
    // XXX set pCmdUI->Enable(FALSE);

#elif defined(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(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	// !JAVA
#endif	// XP_WIN16

#ifdef XP_WIN16
#include "private\prpriv.h"
void fe_yield(void)
{
	PR_Sleep(PR_INTERVAL_NO_WAIT);
}
#endif