JManager.h

Go to the documentation of this file.

 
#ifndef __JMANAGER__
#define __JMANAGER__
 
#ifndef __CONDITIONALMACROS__
#include <ConditionalMacros.h>
#endif
 
#ifndef __MACTYPES__
#include <MacTypes.h>
#endif
 
#ifndef __FILES__
#include <Files.h>
#endif
 
#ifndef __DRAG__
#include <Drag.h>
#endif
 
#ifndef __QUICKDRAW__
#include <Quickdraw.h>
#endif
 
#ifndef __MENUS__
#include <Menus.h>
#endif
 
#ifndef __TEXTCOMMON__
#include <TextCommon.h>
#endif
 
#ifndef __CODEFRAGMENTS__
#include <CodeFragments.h>
#endif
 
#if PRAGMA_ONCE
#pragma once
#endif
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#if PRAGMA_IMPORT
#pragma import on
#endif
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = mac68k
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
#pragma pack(2)
#endif
 
#if PRAGMA_ENUM_ALWAYSINT
#if defined(__fourbyteints__) && !__fourbyteints__
#define __JMANAGER__RESTORE_TWOBYTEINTS
#pragma fourbyteints on
#endif
#pragma enumsalwaysint on
#elif PRAGMA_ENUM_OPTIONS
#pragma option enum =int
#elif PRAGMA_ENUM_PACK
#if __option(pack_enums)
#define __JMANAGER__RESTORE_PACKED_ENUMS
#pragma options(!pack_enums)
#endif
#endif
 
  enum
  {
    kJMVersion = 0x11800007,    /* using Sun's 1.1.8 APIs, our rev 7 APIs. */
    kDefaultJMTime = 0x00000400 /* how much time to give the JM library on "empty"
                                   events, in milliseconds. */
  };
 
  enum
  {
    kJMVersionError = -60000L,
    kJMExceptionOccurred = -60001L,
    kJMBadClassPathError = -60002L
  };
 
  enum
  {
    kModifierAsciiChar = 0,
    kModifierKeyCode = 0
  };
 
  typedef void *JMClientData;
  typedef struct OpaqueJMSessionRef *JMSessionRef;
  typedef struct OpaqueJMFrameRef *JMFrameRef;
  typedef struct OpaqueJMTextRef *JMTextRef;
  typedef struct OpaqueJMAWTContextRef *JMAWTContextRef;
  typedef struct OpaqueJMAppletLocatorRef *JMAppletLocatorRef;
  typedef struct OpaqueJMAppletViewerRef *JMAppletViewerRef;
  typedef struct OpaqueJMAppletPageRef *JMAppletPageRef;
  typedef TextEncoding JMTextEncoding;
 
  typedef CALLBACK_API_C(void, JMConsoleProcPtr)(JMSessionRef session,
                                                 const void *message,
                                                 SInt32 messageLengthInBytes);
  typedef CALLBACK_API_C(SInt32, JMConsoleReadProcPtr)(JMSessionRef session,
                                                       void *buffer,
                                                       SInt32 maxBufferLength);
  typedef CALLBACK_API_C(Boolean, JMExitProcPtr)(JMSessionRef session,
                                                 SInt32 status);
  typedef CALLBACK_API_C(Boolean, JMAuthenticateURLProcPtr)(JMSessionRef session,
                                                            const char *url,
                                                            const char *realm,
                                                            char userName[255],
                                                            char password[255]);
  typedef CALLBACK_API_C(void, JMLowMemoryProcPtr)(JMSessionRef session);
  struct JMSessionCallbacks
  {
    UInt32 fVersion; /* should be set to kJMVersion */
    JMConsoleProcPtr
        fStandardOutput; /* JM will route "stdout" to this function. */
    JMConsoleProcPtr
        fStandardError;               /* JM will route "stderr" to this function. */
    JMConsoleReadProcPtr fStandardIn; /* read from console - can be nil for
                                         default behavior (no console IO) */
    JMExitProcPtr fExitProc;          /* handle System.exit(int) requests */
    JMAuthenticateURLProcPtr
        fAuthenticateProc;          /* present basic authentication dialog */
    JMLowMemoryProcPtr fLowMemProc; /* Low Memory notification Proc */
  };
  typedef struct JMSessionCallbacks JMSessionCallbacks;
  enum JMVerifierOptions
  {
    eDontCheckCode = 0,
    eCheckRemoteCode = 1,
    eCheckAllCode = 2
  };
  typedef enum JMVerifierOptions JMVerifierOptions;
 
  enum JMRuntimeOptions
  {
    eJManager2Defaults = 0,
    eUseAppHeapOnly = (1 << 0),
    eDisableJITC = (1 << 1),
    eEnableDebugger = (1 << 2),
    eDisableInternetConfig = (1 << 3),
    eInhibitClassUnloading = (1 << 4),
    eEnableProfiling = (1 << 5),
    eJManager1Compatible = (eDisableInternetConfig | eInhibitClassUnloading)
  };
  typedef enum JMRuntimeOptions JMRuntimeOptions;
 
#if CALL_NOT_IN_CARBON
  unsigned long
  JMGetVersion(void);
 
  UInt32
  JMGetMRJRuntimeVersion(void);
 
  OSStatus
  JMOpenSession(JMSessionRef *session, JMRuntimeOptions runtimeOptions,
                JMVerifierOptions verifyMode, const JMSessionCallbacks *callbacks,
                JMTextEncoding desiredEncoding, JMClientData data);
 
  OSStatus
  JMCloseSession(JMSessionRef session);
 
  OSStatus
  JMGetSessionData(JMSessionRef session, JMClientData *data);
 
  OSStatus
  JMSetSessionData(JMSessionRef session, JMClientData data);
 
  OSStatus
  JMAddToClassPath(JMSessionRef session, const FSSpec *spec);
 
  Handle
  JMFSSToURL(JMSessionRef session, const FSSpec *spec);
 
  OSStatus
  JMURLToFSS(JMSessionRef session, JMTextRef urlString, FSSpec *spec);
 
  OSStatus
  JMIdle(JMSessionRef session, UInt32 jmTimeMillis);
 
#endif /* CALL_NOT_IN_CARBON */
 
#ifdef JRI_H
#if CALL_NOT_IN_CARBON
  JRIRuntimeInstance *
  JMGetJRIRuntimeInstance(JMSessionRef session);
 
  JRIEnv *
  JMGetCurrentJRIEnv(JMSessionRef session);
 
#endif /* CALL_NOT_IN_CARBON */
 
#endif /* defined(JRI_H) */
 
#ifdef JNI_H
#if CALL_NOT_IN_CARBON
  JNIEnv *
  JMGetCurrentEnv(JMSessionRef session);
 
#endif /* CALL_NOT_IN_CARBON */
 
#endif /* defined(JNI_H) */
 
#if defined(JRI_H) && defined(JNI_H)
#if CALL_NOT_IN_CARBON
  jobject
  JMJRIRefToJNIObject(JMSessionRef session, JNIEnv *env, jref jriRef);
 
  jref
  JMJNIObjectToJRIRef(JMSessionRef session, JNIEnv *env, jobject jniObject);
 
#endif /* CALL_NOT_IN_CARBON */
 
#endif /* defined(JRI_H) && defined(JNI_H) */
 
#if CALL_NOT_IN_CARBON
  OSStatus
  JMGetSessionProperty(JMSessionRef session, JMTextRef propertyName,
                       JMTextRef *propertyValue);
 
  OSStatus
  JMPutSessionProperty(JMSessionRef session, JMTextRef propertyName,
                       JMTextRef propertyValue);
 
#endif /* CALL_NOT_IN_CARBON */
 
#ifdef JNI_H
#if CALL_NOT_IN_CARBON
  jobject
  JMGetSessionJNIObject(JMSessionRef session, JNIEnv *env);
 
#endif /* CALL_NOT_IN_CARBON */
 
#endif /* defined(JNI_H) */
 
#ifdef JRI_H
#if CALL_NOT_IN_CARBON
  jref
  JMGetSessionObject(JMSessionRef session);
 
#endif /* CALL_NOT_IN_CARBON */
 
#endif /* defined(JRI_H) */
 
#if CALL_NOT_IN_CARBON
  OSStatus
  JMNewTextRef(JMSessionRef session, JMTextRef *textRef, JMTextEncoding encoding,
               const void *charBuffer, UInt32 bufferLengthInBytes);
 
  OSStatus
  JMCopyTextRef(JMTextRef textRefSrc, JMTextRef *textRefDst);
 
  OSStatus
  JMDisposeTextRef(JMTextRef textRef);
 
  OSStatus
  JMGetTextLength(JMTextRef textRef, UInt32 *textLengthInCharacters);
 
  OSStatus
  JMGetTextLengthInBytes(JMTextRef textRef, JMTextEncoding dstEncoding,
                         UInt32 *textLengthInBytes);
 
  OSStatus
  JMGetTextBytes(JMTextRef textRef, JMTextEncoding dstEncoding, void *textBuffer,
                 UInt32 textBufferLength, UInt32 *numCharsCopied);
 
#endif /* CALL_NOT_IN_CARBON */
 
#ifdef JNI_H
#if CALL_NOT_IN_CARBON
  jstring
  JMTextToJNIJavaString(JMTextRef textRef, JMSessionRef session, JNIEnv *env);
 
#endif /* CALL_NOT_IN_CARBON */
 
#endif /* defined(JNI_H) */
 
#ifdef JRI_H
#if CALL_NOT_IN_CARBON
  jref
  JMTextToJavaString(JMTextRef textRef);
 
#endif /* CALL_NOT_IN_CARBON */
 
#endif /* defined(JRI_H) */
 
#if CALL_NOT_IN_CARBON
  Handle
  JMTextToMacOSCStringHandle(JMTextRef textRef);
 
#endif /* CALL_NOT_IN_CARBON */
 
  struct JMProxyInfo
  {
    Boolean useProxy;
    char proxyHost[255];
    UInt16 proxyPort;
  };
  typedef struct JMProxyInfo JMProxyInfo;
  enum JMProxyType
  {
    eHTTPProxy = 0,
    eFirewallProxy = 1,
    eFTPProxy = 2
  };
  typedef enum JMProxyType JMProxyType;
 
#if CALL_NOT_IN_CARBON
  OSStatus
  JMGetProxyInfo(JMSessionRef session, JMProxyType proxyType,
                 JMProxyInfo *proxyInfo);
 
  OSStatus
  JMSetProxyInfo(JMSessionRef session, JMProxyType proxyType,
                 const JMProxyInfo *proxyInfo);
 
  OSStatus
  JMGetVerifyMode(JMSessionRef session, JMVerifierOptions *verifierOptions);
 
  OSStatus
  JMSetVerifyMode(JMSessionRef session, JMVerifierOptions verifierOptions);
 
#endif /* CALL_NOT_IN_CARBON */
 
  enum ReorderRequest
  {
    eBringToFront = 0,   /* bring the window to front */
    eSendToBack = 1,     /* send the window to back */
    eSendBehindFront = 2 /* send the window behind the front window */
  };
  typedef enum ReorderRequest ReorderRequest;
 
  typedef CALLBACK_API_C(void, JMSetFrameSizeProcPtr)(JMFrameRef frame,
                                                      const Rect *newBounds);
  typedef CALLBACK_API_C(void, JMFrameInvalRectProcPtr)(JMFrameRef frame,
                                                        const Rect *r);
  typedef CALLBACK_API_C(void,
                         JMFrameShowHideProcPtr)(JMFrameRef frame,
                                                 Boolean showFrameRequested);
  typedef CALLBACK_API_C(void, JMSetTitleProcPtr)(JMFrameRef frame,
                                                  JMTextRef title);
  typedef CALLBACK_API_C(void, JMCheckUpdateProcPtr)(JMFrameRef frame);
  typedef CALLBACK_API_C(void, JMReorderFrame)(JMFrameRef frame,
                                               ReorderRequest theRequest);
  typedef CALLBACK_API_C(void, JMSetResizeable)(JMFrameRef frame,
                                                Boolean resizeable);
  typedef CALLBACK_API_C(void, JMGetFrameInsets)(JMFrameRef frame, Rect *insets);
  typedef CALLBACK_API_C(void, JMNextFocus)(JMFrameRef frame, Boolean forward);
  typedef CALLBACK_API_C(void, JMRequestFocus)(JMFrameRef frame);
  struct JMFrameCallbacks
  {
    UInt32 fVersion; /* should be set to kJMVersion */
    JMSetFrameSizeProcPtr fSetFrameSize;
    JMFrameInvalRectProcPtr fInvalRect;
    JMFrameShowHideProcPtr fShowHide;
    JMSetTitleProcPtr fSetTitle;
    JMCheckUpdateProcPtr fCheckUpdate;
    JMReorderFrame fReorderFrame;
    JMSetResizeable fSetResizeable;
    JMGetFrameInsets fGetInsets;
    JMNextFocus fNextFocus;
    JMRequestFocus fRequestFocus;
  };
  typedef struct JMFrameCallbacks JMFrameCallbacks;
#if CALL_NOT_IN_CARBON
  OSStatus
  JMSetFrameVisibility(JMFrameRef frame, GrafPtr famePort, Point frameOrigin,
                       RgnHandle frameClip);
 
  OSStatus
  JMGetFrameData(JMFrameRef frame, JMClientData *data);
 
  OSStatus
  JMSetFrameData(JMFrameRef frame, JMClientData data);
 
  OSStatus
  JMGetFrameSize(JMFrameRef frame, Rect *result);
 
  /* note that the top left indicates the "global" position of this frame */
  /* use this to update the frame position when it gets moved */
  OSStatus
  JMSetFrameSize(JMFrameRef frame, const Rect *newSize);
 
  OSStatus
  JMFrameClickWithEventRecord(JMFrameRef frame, Point localPos,
                              const EventRecord *event);
 
  OSStatus
  JMFrameKey(JMFrameRef frame, char asciiChar, char keyCode, short modifiers);
 
  OSStatus
  JMFrameKeyRelease(JMFrameRef frame, char asciiChar, char keyCode,
                    short modifiers);
 
  OSStatus
  JMFrameUpdate(JMFrameRef frame, RgnHandle updateRgn);
 
  OSStatus
  JMFrameActivate(JMFrameRef frame, Boolean activate);
 
  OSStatus
  JMFrameResume(JMFrameRef frame, Boolean resume);
 
  OSStatus
  JMFrameMouseOver(JMFrameRef frame, Point localPos, short modifiers);
 
  OSStatus
  JMFrameShowHide(JMFrameRef frame, Boolean showFrame);
 
  OSStatus
  JMFrameGoAway(JMFrameRef frame);
 
  JMAWTContextRef
  JMGetFrameContext(JMFrameRef frame);
 
  OSStatus
  JMFrameDragTracking(JMFrameRef frame, DragTrackingMessage message,
                      DragReference theDragRef);
 
  OSStatus
  JMFrameDragReceive(JMFrameRef frame, DragReference theDragRef);
 
  OSStatus
  JMFrameClick(JMFrameRef frame, Point localPos, short modifiers);
 
  OSStatus
  JMFrameFocus(JMFrameRef frame, Boolean gotFocus);
 
  OSStatus
  JMDrawFrameInPort(JMFrameRef frame, GrafPtr framePort, Point frameOrigin,
                    RgnHandle clipRgn, Boolean callPaintAsOpposedToPrint);
 
#endif /* CALL_NOT_IN_CARBON */
 
#ifdef JNI_H
#if CALL_NOT_IN_CARBON
  jobject
  JMGetAWTFrameJNIObject(JMFrameRef frame, JNIEnv *env);
 
#endif /* CALL_NOT_IN_CARBON */
 
#endif /* defined(JNI_H) */
 
#ifdef JRI_H
#if CALL_NOT_IN_CARBON
  jref
  JMGetAWTFrameObject(JMFrameRef frame);
 
#endif /* CALL_NOT_IN_CARBON */
 
#endif /* defined(JRI_H) */
 
#ifdef JNI_H
#if CALL_NOT_IN_CARBON
  jobject
  JMGetJMFrameJNIObject(JMFrameRef frame, JNIEnv *env);
 
#endif /* CALL_NOT_IN_CARBON */
 
#endif /* defined(JNI_H) */
 
#ifdef JRI_H
#if CALL_NOT_IN_CARBON
  jref
  JMGetJMFrameObject(JMFrameRef frame);
 
#endif /* CALL_NOT_IN_CARBON */
 
#endif /* defined(JRI_H) */
 
  enum JMFrameKind
  {
    eBorderlessModelessWindowFrame = 0,
    eModelessWindowFrame = 1,
    eModalWindowFrame = 2,
    eModelessDialogFrame = 3
  };
  typedef enum JMFrameKind JMFrameKind;
 
/* JMAppletPageRef -
 * Creating a "page" is optional.
 * Applets will share the same class loader (and thus static variables) iff
 * they are share the same JMAppletPageRef and have the same codebase.
 */
#if CALL_NOT_IN_CARBON
  OSStatus
  JMNewAppletPage(JMAppletPageRef *page, JMSessionRef session);
 
  OSStatus
  JMDisposeAppletPage(JMAppletPageRef page);
 
/* JMAWTContext -
 * To create a top level frame, you must use a JMAWTContext object.
 * The JMAWTContext provides a context for the AWT to request frames.
 * A AWTContext has a threadgroup associated with it - all events and processing
 * occurs there.  When you create one, it is quiescent, you must call resume
 * before it begins executing.
 */
#endif /* CALL_NOT_IN_CARBON */
 
  typedef CALLBACK_API_C(OSStatus, JMRequestFrameProcPtr)(
      JMAWTContextRef context, JMFrameRef newFrame, JMFrameKind kind,
      const Rect *initialBounds, Boolean resizeable, JMFrameCallbacks *callbacks);
  typedef CALLBACK_API_C(OSStatus, JMReleaseFrameProcPtr)(JMAWTContextRef context,
                                                          JMFrameRef oldFrame);
  typedef CALLBACK_API_C(SInt16, JMUniqueMenuIDProcPtr)(JMAWTContextRef context,
                                                        Boolean isSubmenu);
  typedef CALLBACK_API_C(void,
                         JMExceptionOccurredProcPtr)(JMAWTContextRef context,
                                                     JMTextRef exceptionName,
                                                     JMTextRef exceptionMsg,
                                                     JMTextRef stackTrace);
  struct JMAWTContextCallbacks
  {
    UInt32 fVersion;                     /* should be set to kJMVersion */
    JMRequestFrameProcPtr fRequestFrame; /* a new frame is being created. */
    JMReleaseFrameProcPtr
        fReleaseFrame; /* an existing frame is being destroyed. */
    JMUniqueMenuIDProcPtr
        fUniqueMenuID; /* a new menu will be created with this id. */
    JMExceptionOccurredProcPtr
        fExceptionOccurred; /* just some notification that some recent operation
                               caused an exception.  You can't do anything really
                               from here. */
  };
  typedef struct JMAWTContextCallbacks JMAWTContextCallbacks;
#if CALL_NOT_IN_CARBON
  OSStatus
  JMNewAWTContext(JMAWTContextRef *context, JMSessionRef session,
                  const JMAWTContextCallbacks *callbacks, JMClientData data);
 
  OSStatus
  JMNewAWTContextInPage(JMAWTContextRef *context, JMSessionRef session,
                        JMAppletPageRef page,
                        const JMAWTContextCallbacks *callbacks,
                        JMClientData data);
 
  OSStatus
  JMDisposeAWTContext(JMAWTContextRef context);
 
  OSStatus
  JMGetAWTContextData(JMAWTContextRef context, JMClientData *data);
 
  OSStatus
  JMSetAWTContextData(JMAWTContextRef context, JMClientData data);
 
  OSStatus
  JMCountAWTContextFrames(JMAWTContextRef context, UInt32 *frameCount);
 
  OSStatus
  JMGetAWTContextFrame(JMAWTContextRef context, UInt32 frameIndex,
                       JMFrameRef *frame);
 
  OSStatus
  JMMenuSelected(JMAWTContextRef context, MenuRef hMenu, short menuItem);
 
  OSStatus
  JMMenuSelectedWithModifiers(JMAWTContextRef context, MenuRef hMenu,
                              short menuItem, short modifiers);
 
#endif /* CALL_NOT_IN_CARBON */
 
#ifdef JRI_H
#if CALL_NOT_IN_CARBON
  OSStatus
  JMExecMethodInContext(JMAWTContextRef context, jref objref,
                        JRIMethodID methodID, UInt32 argCount, JRIValue args[]);
 
  OSStatus
  JMExecStaticMethodInContext(JMAWTContextRef context, JRIClassID classID,
                              JRIMethodID methodID, UInt32 argCount,
                              JRIValue args[]);
 
#endif /* CALL_NOT_IN_CARBON */
 
#endif /* defined(JRI_H) */
 
#ifdef JNI_H
#if CALL_NOT_IN_CARBON
  OSStatus
  JMExecJNIMethodInContext(JMAWTContextRef context, JNIEnv *env, jobject objref,
                           jmethodID methodID, UInt32 argCount, jvalue args[]);
 
  OSStatus
  JMExecJNIStaticMethodInContext(JMAWTContextRef context, JNIEnv *env,
                                 jclass classID, jmethodID methodID,
                                 UInt32 argCount, jvalue args[]);
 
#endif /* CALL_NOT_IN_CARBON */
 
#endif /* defined(JNI_H) */
 
#ifdef JNI_H
#if CALL_NOT_IN_CARBON
  jobject
  JMGetAwtContextJNIObject(JMAWTContextRef context, JNIEnv *env);
 
#endif /* CALL_NOT_IN_CARBON */
 
#endif /* defined(JNI_H) */
 
#ifdef JRI_H
#if CALL_NOT_IN_CARBON
  jref
  JMGetAwtContextObject(JMAWTContextRef context);
 
#endif /* CALL_NOT_IN_CARBON */
 
#endif /* defined(JRI_H) */
 
#ifdef JNI_H
#if CALL_NOT_IN_CARBON
  JMAWTContextRef
  JMJNIToAWTContext(JMSessionRef session, JNIEnv *env);
 
#endif /* CALL_NOT_IN_CARBON */
 
#endif /* defined(JNI_H) */
 
  enum JMLocatorErrors
  {
    eLocatorNoErr = 0,   /* the html was retrieved successfully*/
    eHostNotFound = 1,   /* the host specified by the url could not be found*/
    eFileNotFound = 2,   /* the file could not be found on the host*/
    eLocatorTimeout = 3, /* a timeout occurred retrieving the html text*/
    eLocatorKilled =
        4 /* in response to a JMDisposeAppletLocator before it has completed*/
  };
  typedef enum JMLocatorErrors JMLocatorErrors;
 
  typedef CALLBACK_API_C(void, JMFetchCompleted)(JMAppletLocatorRef ref,
                                                 JMLocatorErrors status);
  struct JMAppletLocatorCallbacks
  {
    UInt32 fVersion; /* should be set to kJMVersion */
    JMFetchCompleted
        fCompleted; /* called when the html has been completely fetched */
  };
  typedef struct JMAppletLocatorCallbacks JMAppletLocatorCallbacks;
  struct JMLIBOptionalParams
  {
    JMTextRef fParamName;  /* could be from a <parameter name=foo value=bar> or
                              "zipbase", etc */
    JMTextRef fParamValue; /* the value of this optional tag */
  };
  typedef struct JMLIBOptionalParams JMLIBOptionalParams;
  struct JMLocatorInfoBlock
  {
    UInt32 fVersion; /* should be set to kJMVersion */
 
    /* These are required to be present and not nil */
 
    JMTextRef fBaseURL;    /* the URL of this applet's host page */
    JMTextRef fAppletCode; /* code= parameter */
    short fWidth;          /* width= parameter */
    short fHeight;         /* height= parameter */
 
    /* These are optional parameters */
    SInt32 fOptionalParameterCount; /* how many in this array */
    JMLIBOptionalParams
        *fParams; /* pointer to an array of these (points to first element) */
  };
  typedef struct JMLocatorInfoBlock JMLocatorInfoBlock;
#if CALL_NOT_IN_CARBON
  OSStatus
  JMNewAppletLocator(JMAppletLocatorRef *locatorRef, JMSessionRef session,
                     const JMAppletLocatorCallbacks *callbacks, JMTextRef url,
                     JMTextRef htmlText, JMClientData data);
 
  OSStatus
  JMNewAppletLocatorFromInfo(JMAppletLocatorRef *locatorRef, JMSessionRef session,
                             const JMLocatorInfoBlock *info, JMClientData data);
 
  OSStatus
  JMDisposeAppletLocator(JMAppletLocatorRef locatorRef);
 
  OSStatus
  JMGetAppletLocatorData(JMAppletLocatorRef locatorRef, JMClientData *data);
 
  OSStatus
  JMSetAppletLocatorData(JMAppletLocatorRef locatorRef, JMClientData data);
 
  OSStatus
  JMCountApplets(JMAppletLocatorRef locatorRef, UInt32 *appletCount);
 
  OSStatus
  JMGetAppletDimensions(JMAppletLocatorRef locatorRef, UInt32 appletIndex,
                        UInt32 *width, UInt32 *height);
 
  OSStatus
  JMGetAppletTag(JMAppletLocatorRef locatorRef, UInt32 appletIndex,
                 JMTextRef *tagRef);
 
  OSStatus
  JMGetAppletName(JMAppletLocatorRef locatorRef, UInt32 appletIndex,
                  JMTextRef *nameRef);
 
#endif /* CALL_NOT_IN_CARBON */
 
  typedef CALLBACK_API_C(void, JMShowDocumentProcPtr)(JMAppletViewerRef viewer,
                                                      JMTextRef urlString,
                                                      JMTextRef windowName);
  typedef CALLBACK_API_C(void, JMSetStatusMsgProcPtr)(JMAppletViewerRef viewer,
                                                      JMTextRef statusMsg);
  struct JMAppletViewerCallbacks
  {
    UInt32 fVersion; /* should be set to kJMVersion */
    JMShowDocumentProcPtr
        fShowDocument;                   /* go to a url, optionally in a new window */
    JMSetStatusMsgProcPtr fSetStatusMsg; /* applet changed status message */
  };
  typedef struct JMAppletViewerCallbacks JMAppletViewerCallbacks;
  enum JMNetworkSecurityOptions
  {
    eNoNetworkAccess = 0,
    eAppletHostAccess = 1,
    eUnrestrictedAccess = 2
  };
  typedef enum JMNetworkSecurityOptions JMNetworkSecurityOptions;
 
  enum JMFileSystemOptions
  {
    eNoFSAccess = 0,
    eLocalAppletAccess = 1,
    eAllFSAccess = 2
  };
  typedef enum JMFileSystemOptions JMFileSystemOptions;
 
  struct JMAppletSecurity
  {
    UInt32 fVersion; /* should be set to kJMVersion */
    JMNetworkSecurityOptions
        fNetworkSecurity; /* can this applet access network resources */
    JMFileSystemOptions
        fFileSystemSecurity; /* can this applet access network resources */
 
    Boolean
        fRestrictSystemAccess; /* restrict access to system packages (com.apple.*,
                                  sun.*, netscape.*) also found in the property
                                  "mrj.security.system.access" */
    Boolean
        fRestrictSystemDefine; /* restrict classes from loading system packages
                                  (com.apple.*, sun.*, netscape.*) also found in
                                  the property "mrj.security.system.define" */
 
    Boolean fRestrictApplicationAccess; /* restrict access to application packages
                                           found in the property
                                           "mrj.security.application.access" */
    Boolean fRestrictApplicationDefine; /* restrict access to application packages
                                           found in the property
                                           "mrj.security.application.access" */
  };
  typedef struct JMAppletSecurity JMAppletSecurity;
#if CALL_NOT_IN_CARBON
  OSStatus
  JMNewAppletViewer(JMAppletViewerRef *viewer, JMAWTContextRef context,
                    JMAppletLocatorRef locatorRef, UInt32 appletIndex,
                    const JMAppletSecurity *security,
                    const JMAppletViewerCallbacks *callbacks, JMClientData data);
 
  OSStatus
  JMDisposeAppletViewer(JMAppletViewerRef viewer);
 
  OSStatus
  JMGetAppletViewerData(JMAppletViewerRef viewer, JMClientData *data);
 
  OSStatus
  JMSetAppletViewerData(JMAppletViewerRef viewer, JMClientData data);
 
  OSStatus
  JMGetAppletViewerSecurity(JMAppletViewerRef viewer, JMAppletSecurity *data);
 
  OSStatus
  JMSetAppletViewerSecurity(JMAppletViewerRef viewer,
                            const JMAppletSecurity *data);
 
  OSStatus
  JMReloadApplet(JMAppletViewerRef viewer);
 
  OSStatus
  JMRestartApplet(JMAppletViewerRef viewer);
 
  OSStatus
  JMSuspendApplet(JMAppletViewerRef viewer);
 
  OSStatus
  JMResumeApplet(JMAppletViewerRef viewer);
 
  OSStatus
  JMGetFrameViewer(JMFrameRef frame, JMAppletViewerRef *viewer,
                   JMFrameRef *parentFrame);
 
  OSStatus
  JMGetViewerFrame(JMAppletViewerRef viewer, JMFrameRef *frame);
 
#endif /* CALL_NOT_IN_CARBON */
 
#ifdef JNI_H
#if CALL_NOT_IN_CARBON
  jobject
  JMGetAppletViewerJNIObject(JMAppletViewerRef viewer, JNIEnv *env);
 
#endif /* CALL_NOT_IN_CARBON */
 
#endif /* defined(JNI_H) */
 
#ifdef JRI_H
#if CALL_NOT_IN_CARBON
  jref
  JMGetAppletViewerObject(JMAppletViewerRef viewer);
 
#endif /* CALL_NOT_IN_CARBON */
 
#endif /* defined(JRI_H) */
 
#ifdef JNI_H
#if CALL_NOT_IN_CARBON
  jobject
  JMGetAppletJNIObject(JMAppletViewerRef viewer, JNIEnv *env);
 
#endif /* CALL_NOT_IN_CARBON */
 
#endif /* defined(JNI_H) */
 
#ifdef JRI_H
#if CALL_NOT_IN_CARBON
  jref
  JMGetAppletObject(JMAppletViewerRef viewer);
 
#endif /* CALL_NOT_IN_CARBON */
 
#endif /* defined(JRI_H) */
 
#if CALL_NOT_IN_CARBON
  Boolean
  JMRegisterLibrary(JMSessionRef session, ConstStr63Param libraryName,
                    CFragConnectionID connID, Boolean javaShouldClose);
 
#endif /* CALL_NOT_IN_CARBON */
 
#if PRAGMA_ENUM_ALWAYSINT
#pragma enumsalwaysint reset
#ifdef __JMANAGER__RESTORE_TWOBYTEINTS
#pragma fourbyteints off
#endif
#elif PRAGMA_ENUM_OPTIONS
#pragma option enum =reset
#elif defined(__JMANAGER__RESTORE_PACKED_ENUMS)
#pragma options(pack_enums)
#endif
 
#if PRAGMA_STRUCT_ALIGN
#pragma options align = reset
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
#pragma pack()
#endif
 
#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif /* __JMANAGER__ */