多媒体编程

开发平台：
Visual C++

JManager.h：源码内容
							/*
     File:       JManager.h
 
     Contains:   Routines that can be used to invoke the Java Virtual Machine in MRJ
 
     Version:    Technology: MRJ 2.1
                 Release:    QuickTime 6.0.2
 
     Copyright:  (c) 1996-2001 by Apple Computer, Inc., all rights reserved.
 
     Bugs?:      For bug reports, consult the following page on
                 the World Wide Web:
 
                     http://developer.apple.com/bugreporter/
 
*/
#ifndef __JMANAGER__
#define __JMANAGER__
/*
 *  Note:   If you want to use any JManger routines which use JNI or JRI functionality,
 *          you must #include "jni.h" or <jri.h> before this file.
 *
 */
#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
};
/*
 * Special codes for JMFrameKey, JMFrameKeyRelease:
 *
 * When your app notices that a modifiers is pressed (must be done by polling,
 * unless Mac OS changes to support sending modifiers as events)
 * you should notify the runtime using JMFrameKey, JMFrameKeyRelease, using
 * these constants for asciiChar and keyCode.  This will allow the AWT to
 * synthesize the appropriate events
 */
enum {
    kModifierAsciiChar          = 0,
    kModifierKeyCode            = 0
};
/*
 *  Private data structures
 *
 *  JMClientData        - enough bits to reliably store a pointer to arbitrary, client-specific data. 
 *  JMSessionRef        - references the entire java runtime 
 *  JMTextRef           - a Text string, length, and encoding 
 *  JMTextEncoding      - which encoding to use when converting in and out of Java strings.
 *  JMFrameRef          - a java frame 
 *  JMAWTContextRef     - a context for the AWT to request frames, process events 
 *  JMAppletLocatorRef  - a device for locating, fetching, and parsing URLs that may contain applets 
 *  JMAppletViewerRef   - an object that displays applets in a Frame 
 *  JMAppletPageRef     - a way to group JMAWTContextRef's so they share the same class loader
 */
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;
/*
 * The runtime requires certain callbacks be used to communicate between
 * session events and the embedding application.
 *
 * In general, you can pass nil as a callback and a "good" default will be used.
 *
 *  JMConsoleProcPtr        - redirect stderr or stdout - the message is delivered in the encoding specified when
 *                              you created the session, or possibly binary data.
 *  JMConsoleReadProcPtr    - take input from the user from a console or file.  The input is expected to 
 *                              be in the encoding specified when you opened the session.
 *  JMExitProcPtr           - called via System.exit(int), return "true" to kill the current thread,
 *                              false, to cause a 'QUIT' AppleEvent to be sent to the current process,
 *                              or just tear down the runtime and exit to shell immediately
 * JMLowMemoryProcPtr       - This callback is available to notify the embedding application that
 *                              a low memory situation has occurred so it can attempt to recover appropriately.
 * JMAuthenicateURLProcPtr  - prompt the user for autentication based on the URL.  If you pass
 *                              nil, JManager will prompt the user.  Return false if the user pressed cancel.
 */
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])/*  into C string parameters  */;
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;
/*
 * JMRuntimeOptions is a mask that allows you to specify certain attributes
 * for the runtime. Bitwise or the fields together, or use one of the "premade" entries.
 * eJManager2Defaults is the factory default, and best bet to use.
 */
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;
/*
 * Returns the version of the currently installed JManager library.
 * Compare to kJMVersion.  This is the only call that doesn't
 * require a session, or a reference to something that references
 * a session.
 */
#if CALL_NOT_IN_CARBON
EXTERN_API_C( unsigned long )
JMGetVersion                    (void);
/*
 * Returns the version number of the MRJ installation.  This is an
 * official version number that will change for each official release
 * of MRJ, whereas for an incremental MRJ release, the version number
 * returned by JMGetVersion may not change.
 */
EXTERN_API_C( UInt32 )
JMGetMRJRuntimeVersion          (void);
/*
 * JMOpenSession creates a new Java Runtime.  Note that JManger 2.0 doesn't set 
 * security options at the time of runtime instantiation.  AppletViewer Objecs have
 * seperate security attributes bound to them, and the verifier is availiable elsewhere
 * as well.  The client data parameter lets a client associate an arbitgrary tagged pointer
 * with the seession.
 * When you create the session, you must specify the desired Text Encoding to use for
 * console IO.  Usually, its OK to use "kTextEncodingMacRoman".  See TextCommon.h for the list.
 */
EXTERN_API_C( OSStatus )
JMOpenSession                   (JMSessionRef *         session,
                                 JMRuntimeOptions       runtimeOptions,
                                 JMVerifierOptions      verifyMode,
                                 const JMSessionCallbacks * callbacks,
                                 JMTextEncoding         desiredEncoding,
                                 JMClientData           data);
EXTERN_API_C( OSStatus )
JMCloseSession                  (JMSessionRef           session);
/*
 * Client data getter/setter functions.
 */
EXTERN_API_C( OSStatus )
JMGetSessionData                (JMSessionRef           session,
                                 JMClientData *         data);
EXTERN_API_C( OSStatus )
JMSetSessionData                (JMSessionRef           session,
                                 JMClientData           data);
/*
 * Prepend the target of the FSSpec to the class path.
 * If a file, .zip or other known archive file - not a .class file
 */
EXTERN_API_C( OSStatus )
JMAddToClassPath                (JMSessionRef           session,
                                 const FSSpec *         spec);
/*
 * Utility returns (client owned) null terminated handle containing "file://xxxx", or nil if fnfErr
 */
EXTERN_API_C( Handle )
JMFSSToURL                      (JMSessionRef           session,
                                 const FSSpec *         spec);
/*
 * Turns "file:///disk/file" into an FSSpec.  other handlers return paramErr
 */
EXTERN_API_C( OSStatus )
JMURLToFSS                      (JMSessionRef           session,
                                 JMTextRef              urlString,
                                 FSSpec *               spec);
/*
 * JMIdle gives time to all Java threads. Giving more time makes Java programs run faster,
 * but can reduce overall system responsiveness. JMIdle will return sooner if low-level (user)
 * events appear in the event queue.
 */
EXTERN_API_C( OSStatus )
JMIdle                          (JMSessionRef           session,
                                 UInt32                 jmTimeMillis);
#endif  /* CALL_NOT_IN_CARBON */
/*
 * JMGetCurrenvEnv gives access to the underlying JRI interface, if available.
 * This gives the client more control over the underlying Java runtime, without
 * exposing the implementation too much.
 * NOTE: JRI is deprecated; please upgrade your code to work with JNI instead.
 */
#ifdef JRI_H
#if CALL_NOT_IN_CARBON
EXTERN_API_C( JRIRuntimeInstance *)
JMGetJRIRuntimeInstance         (JMSessionRef           session);
EXTERN_API_C( JRIEnv *)
JMGetCurrentJRIEnv              (JMSessionRef           session);
#endif  /* CALL_NOT_IN_CARBON */
#endif  /* defined(JRI_H) */
/*
 * JNI is to be preferred.
 */
#ifdef JNI_H
#if CALL_NOT_IN_CARBON
EXTERN_API_C( JNIEnv *)
JMGetCurrentEnv                 (JMSessionRef           session);
#endif  /* CALL_NOT_IN_CARBON */
#endif  /* defined(JNI_H) */
/*
 * Since JManager calls reutrn jref (JRI Java references)
 * you need to convert between them and JNI references (jobjects) if you're
 * using JNI.  These routines facilitate that conversion.
 */
#if defined(JRI_H) && defined(JNI_H)
#if CALL_NOT_IN_CARBON
EXTERN_API_C( jobject )
JMJRIRefToJNIObject             (JMSessionRef           session,
                                 JNIEnv *               env,
                                 jref                   jriRef);
EXTERN_API_C( jref )
JMJNIObjectToJRIRef             (JMSessionRef           session,
                                 JNIEnv *               env,
                                 jobject                jniObject);
#endif  /* CALL_NOT_IN_CARBON */
#endif  /* defined(JRI_H) && defined(JNI_H) */
/*
 * Java defines system-wide properties that applets can use to make queries about the
 * host system. Many of these properties correspond to defaults provided by "Internet Config."
 * JMPutSessionProperty can be used by a client program to modify various system-wide properties.
 */
#if CALL_NOT_IN_CARBON
EXTERN_API_C( OSStatus )
JMGetSessionProperty            (JMSessionRef           session,
                                 JMTextRef              propertyName,
                                 JMTextRef *            propertyValue);
EXTERN_API_C( OSStatus )
JMPutSessionProperty            (JMSessionRef           session,
                                 JMTextRef              propertyName,
                                 JMTextRef              propertyValue);
#endif  /* CALL_NOT_IN_CARBON */
/*
 * Returns a com.apple.mrj.JManager.JMSession object
 */
#ifdef JNI_H
#if CALL_NOT_IN_CARBON
EXTERN_API_C( jobject )
JMGetSessionJNIObject           (JMSessionRef           session,
                                 JNIEnv *               env);
#endif  /* CALL_NOT_IN_CARBON */
#endif  /* defined(JNI_H) */
#ifdef JRI_H
#if CALL_NOT_IN_CARBON
EXTERN_API_C( jref )
JMGetSessionObject              (JMSessionRef           session);
#endif  /* CALL_NOT_IN_CARBON */
#endif  /* defined(JRI_H) */
/*
 * JMText: opaque object that encapsulates a string, length, and
 * character encoding.  Strings passed between JManager and the
 * embedding application goes through this interface.  Only the most
 * rudimentary conversion routines are supplied - it is expected that
 * the embedding application will most of its work in the System Script.
 *
 * These APIs present some questions about who actually owns the 
 * JMText.  The rule is, if you created a JMTextRef, you are responsible
 * for deleting it after passing it into the runtime.  If the runtime passes
 * one to you, it will be deleted after the callback.
 *
 * If a pointer to an uninitialised JMTextRef is passed in to a routine (eg JMGetSessionProperty),
 * it is assumed to have been created for the caller, and it is the callers responsibility to
 * dispose of it.
 *
 * The encoding types are taken verbatim from the Text Encoding Converter,
 * which handles the ugly backside of script conversion.
 */
/*
 * JMNewTextRef can create from a buffer of data in the specified encoding
 */
#if CALL_NOT_IN_CARBON
EXTERN_API_C( OSStatus )
JMNewTextRef                    (JMSessionRef           session,
                                 JMTextRef *            textRef,
                                 JMTextEncoding         encoding,
                                 const void *           charBuffer,
                                 UInt32                 bufferLengthInBytes);
/*
 * JMCopyTextRef clones a text ref.
 */
EXTERN_API_C( OSStatus )
JMCopyTextRef                   (JMTextRef              textRefSrc,
                                 JMTextRef *            textRefDst);
/*
 * Disposes of a text ref passed back from the runtime, or created explicitly through JMNewTextRef
 */
EXTERN_API_C( OSStatus )
JMDisposeTextRef                (JMTextRef              textRef);
/*
 * Returns the text length, in characters
 */
EXTERN_API_C( OSStatus )
JMGetTextLength                 (JMTextRef              textRef,
                                 UInt32 *               textLengthInCharacters);
/*
 * Returns the text length, in number of bytes taken in the destination encoding
 */
EXTERN_API_C( OSStatus )
JMGetTextLengthInBytes          (JMTextRef              textRef,
                                 JMTextEncoding         dstEncoding,
                                 UInt32 *               textLengthInBytes);
/*
 * Copies the specified number of characters to the destination buffer with the appropriate
 * destination encoding.
 */
EXTERN_API_C( OSStatus )
JMGetTextBytes                  (JMTextRef              textRef,
                                 JMTextEncoding         dstEncoding,
                                 void *                 textBuffer,
                                 UInt32                 textBufferLength,
                                 UInt32 *               numCharsCopied);
#endif  /* CALL_NOT_IN_CARBON */
/*
 * Return the JMText as a reference to a Java String.  Note that
 * this is the only reference to the string - it will be collected if you don't
 * hang on to it.
 */
#ifdef JNI_H
#if CALL_NOT_IN_CARBON
EXTERN_API_C( 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
EXTERN_API_C( jref )
JMTextToJavaString              (JMTextRef              textRef);
#endif  /* CALL_NOT_IN_CARBON */
#endif  /* defined(JRI_H) */
/*
 * Returns a Handle to a null terminated, "C" string in the System Script.
 * Note that using this routine could result in data loss, if the characters
 * are not availiable in the System Script.
 */
#if CALL_NOT_IN_CARBON
EXTERN_API_C( Handle )
JMTextToMacOSCStringHandle      (JMTextRef              textRef);
/*
 * Proxy properties in the runtime.
 *
 * These will only be checked if InternetConfig isn't used to specify properties,
 * or if it doesn't have the data for these.
 */
#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
EXTERN_API_C( OSStatus )
JMGetProxyInfo                  (JMSessionRef           session,
                                 JMProxyType            proxyType,
                                 JMProxyInfo *          proxyInfo);
EXTERN_API_C( OSStatus )
JMSetProxyInfo                  (JMSessionRef           session,
                                 JMProxyType            proxyType,
                                 const JMProxyInfo *    proxyInfo);
/*
 * Security - JManager 2.0 security is handled on a per-applet basis.
 * There are some security settings that are inherited from InternetConfig
 * (Proxy Servers) but the verifier can now be enabled and disabled.
 */
EXTERN_API_C( OSStatus )
JMGetVerifyMode                 (JMSessionRef           session,
                                 JMVerifierOptions *    verifierOptions);
EXTERN_API_C( OSStatus )
JMSetVerifyMode                 (JMSessionRef           session,
                                 JMVerifierOptions      verifierOptions);
/*
 * The basic unit of AWT interaction is the JMFrame.  A JMFrame is bound to top level
 * awt Frame, Window, or Dialog.  When a user event occurs for a MacOS window, the event is passed
 * to the corrosponding frame object.  Similarly, when an AWT event occurs that requires the
 * Mac OS Window to change, a callback is made.  JManager 1.x bound the frame to the window through
 * a callback to set and restore the windows GrafPort.  In JManager 2.0, a GrafPort, Offset, and 
 * ClipRgn are specified up front - changes in visibility and structure require that these be re-set.
 * This enables support for the JavaSoft DrawingSurface API - and also improves graphics performance.
 * You should reset the graphics attributes anytime the visiblity changes, like when scrolling.
 * You should also set it initially when the AWTContext requests the frame.
 * At various times, JM will call back to the client to register a new JMFrame, 
 * indicating the frame type.  The client should take the following steps:
 *
 *  o   Create a new invisible window of the specified type
 *  o   Fill in the callbacks parameter with function pointers
 *  o   Do something to bind the frame to the window (like stuff the WindowPtr in the JMClientData of the frame)
 *  o   Register the visiblity parameters (GrafPtr, etc) with the frame
 */
#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);
/*
 * New in JManager 2.1:
 *  If the AWT needs to set focus to a frame (in the case of multiple JMFrames within
 *  a single Mac OS Frame) it will call back to the embedding application using
 *  JMRRequestFocus.  The application should then defocus what it thought did have the
 *  focus, and set the focus to the new frame.
 *  If the user is tabbing within a JMFrame, and the focus reaches the last focusable
 *  component (or the first, if focus is traversing backwards) JMNexetFocus will be called.
 *  The application should defocus the component that requests this, and focus the next application
 *  visible focusable element.  (If none, send focus back to the frame.)
 */
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
EXTERN_API_C( OSStatus )
JMSetFrameVisibility            (JMFrameRef             frame,
                                 GrafPtr                famePort,
                                 Point                  frameOrigin,
                                 RgnHandle              frameClip);
EXTERN_API_C( OSStatus )
JMGetFrameData                  (JMFrameRef             frame,
                                 JMClientData *         data);
EXTERN_API_C( OSStatus )
JMSetFrameData                  (JMFrameRef             frame,
                                 JMClientData           data);
EXTERN_API_C( 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 */
EXTERN_API_C( OSStatus )
JMSetFrameSize                  (JMFrameRef             frame,
                                 const Rect *           newSize);
/*
 * Dispatch a particular event to an embedded frame
 */
EXTERN_API_C( OSStatus )
JMFrameClickWithEventRecord     (JMFrameRef             frame,
                                 Point                  localPos,
                                 const EventRecord *    event);
EXTERN_API_C( OSStatus )
JMFrameKey                      (JMFrameRef             frame,
                                 char                   asciiChar,
                                 char                   keyCode,
                                 short                  modifiers);
EXTERN_API_C( OSStatus )
JMFrameKeyRelease               (JMFrameRef             frame,
                                 char                   asciiChar,
                                 char                   keyCode,
                                 short                  modifiers);
EXTERN_API_C( OSStatus )
JMFrameUpdate                   (JMFrameRef             frame,
                                 RgnHandle              updateRgn);
EXTERN_API_C( OSStatus )
JMFrameActivate                 (JMFrameRef             frame,
                                 Boolean                activate);
EXTERN_API_C( OSStatus )
JMFrameResume                   (JMFrameRef             frame,
                                 Boolean                resume);
EXTERN_API_C( OSStatus )
JMFrameMouseOver                (JMFrameRef             frame,
                                 Point                  localPos,
                                 short                  modifiers);
EXTERN_API_C( OSStatus )
JMFrameShowHide                 (JMFrameRef             frame,
                                 Boolean                showFrame);
EXTERN_API_C( OSStatus )
JMFrameGoAway                   (JMFrameRef             frame);
EXTERN_API_C( JMAWTContextRef )
JMGetFrameContext               (JMFrameRef             frame);
EXTERN_API_C( OSStatus )
JMFrameDragTracking             (JMFrameRef             frame,
                                 DragTrackingMessage    message,
                                 DragReference          theDragRef);
EXTERN_API_C( OSStatus )
JMFrameDragReceive              (JMFrameRef             frame,
                                 DragReference          theDragRef);
/*
 * JMFrameClick is deprecated - please use JMFrameClickWithEventRecord instead.
 */
EXTERN_API_C( OSStatus )
JMFrameClick                    (JMFrameRef             frame,
                                 Point                  localPos,
                                 short                  modifiers);
/*
 * If you may have multiple JMFrames in a single Mac OS Window (for example,
 * in a browser) then use JMFrameFocus to control when you believe the
 * frame should logically contain the focus.  This will allow for the correct
 * appearance of Controls and Text Fields.  If you will only have one
 * JMFrame per Mac OS Window, use JMFrameFocus as well as JMFrameActivate to
 * control hiliting.
 */
EXTERN_API_C( OSStatus )
JMFrameFocus                    (JMFrameRef             frame,
                                 Boolean                gotFocus);
/*
 * Cause a Frame and its contents to be rendered in a GrafPort.
 * This is typically going to be used to cause an applet to print itself
 * into a PrGrafPort.
 * If you pass 'true' as the last parameter, the paint(Graphics) method of the
 * frame is called, rather than print(Graphics).
 */
EXTERN_API_C( OSStatus )
JMDrawFrameInPort               (JMFrameRef             frame,
                                 GrafPtr                framePort,
                                 Point                  frameOrigin,
                                 RgnHandle              clipRgn,
                                 Boolean                callPaintAsOpposedToPrint);
#endif  /* CALL_NOT_IN_CARBON */
/* 
 * returns the java.awt.Frame for this frame 
*/
#ifdef JNI_H
#if CALL_NOT_IN_CARBON
EXTERN_API_C( jobject )
JMGetAWTFrameJNIObject          (JMFrameRef             frame,
                                 JNIEnv *               env);
#endif  /* CALL_NOT_IN_CARBON */
#endif  /* defined(JNI_H) */
#ifdef JRI_H
#if CALL_NOT_IN_CARBON
EXTERN_API_C( jref )
JMGetAWTFrameObject             (JMFrameRef             frame);
#endif  /* CALL_NOT_IN_CARBON */
#endif  /* defined(JRI_H) */
/* 
 * returns the com.apple.mrj.JManager.JMFrame for this frame 
 */
#ifdef JNI_H
#if CALL_NOT_IN_CARBON
EXTERN_API_C( jobject )
JMGetJMFrameJNIObject           (JMFrameRef             frame,
                                 JNIEnv *               env);
#endif  /* CALL_NOT_IN_CARBON */
#endif  /* defined(JNI_H) */
#ifdef JRI_H
#if CALL_NOT_IN_CARBON
EXTERN_API_C( jref )
JMGetJMFrameObject              (JMFrameRef             frame);
#endif  /* CALL_NOT_IN_CARBON */
#endif  /* defined(JRI_H) */
/*
 * Window types
 */
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
EXTERN_API_C( OSStatus )
JMNewAppletPage                 (JMAppletPageRef *      page,
                                 JMSessionRef           session);
EXTERN_API_C( 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
EXTERN_API_C( OSStatus )
JMNewAWTContext                 (JMAWTContextRef *      context,
                                 JMSessionRef           session,
                                 const JMAWTContextCallbacks * callbacks,
                                 JMClientData           data);
EXTERN_API_C( OSStatus )
JMNewAWTContextInPage           (JMAWTContextRef *      context,
                                 JMSessionRef           session,
                                 JMAppletPageRef        page,
                                 const JMAWTContextCallbacks * callbacks,
                                 JMClientData           data);
EXTERN_API_C( OSStatus )
JMDisposeAWTContext             (JMAWTContextRef        context);
EXTERN_API_C( OSStatus )
JMGetAWTContextData             (JMAWTContextRef        context,
                                 JMClientData *         data);
EXTERN_API_C( OSStatus )
JMSetAWTContextData             (JMAWTContextRef        context,
                                 JMClientData           data);
EXTERN_API_C( OSStatus )
JMCountAWTContextFrames         (JMAWTContextRef        context,
                                 UInt32 *               frameCount);
EXTERN_API_C( OSStatus )
JMGetAWTContextFrame            (JMAWTContextRef        context,
                                 UInt32                 frameIndex,
                                 JMFrameRef *           frame);
/*
 * Starting in MRJ 2.1, JMMenuSelected is deprecated.  Please use JMMenuSelectedWithModifiers instead.
 */
EXTERN_API_C( OSStatus )
JMMenuSelected                  (JMAWTContextRef        context,
                                 MenuHandle             hMenu,
                                 short                  menuItem);
/*
 * Starting in MRJ 2.1, this call takes an additional 'modifiers' parameter that you can get
 * from your event record.
 */
EXTERN_API_C( OSStatus )
JMMenuSelectedWithModifiers     (JMAWTContextRef        context,
                                 MenuHandle             hMenu,
                                 short                  menuItem,
                                 short                  modifiers);
#endif  /* CALL_NOT_IN_CARBON */
#ifdef JRI_H
/*
 * JRI Access APIs
 */
#if CALL_NOT_IN_CARBON
EXTERN_API_C( OSStatus )
JMExecMethodInContext           (JMAWTContextRef        context,
                                 jref                   objref,
                                 JRIMethodID            methodID,
                                 UInt32                 argCount,
                                 JRIValue               args[]);
EXTERN_API_C( OSStatus )
JMExecStaticMethodInContext     (JMAWTContextRef        context,
                                 JRIClassID             classID,
                                 JRIMethodID            methodID,
                                 UInt32                 argCount,
                                 JRIValue               args[]);
#endif  /* CALL_NOT_IN_CARBON */
#endif  /* defined(JRI_H) */
#ifdef JNI_H
/*
 * JNI Access APIs
 * Note that you must pass the JNIEnv to these as well.
 */
#if CALL_NOT_IN_CARBON
EXTERN_API_C( OSStatus )
JMExecJNIMethodInContext        (JMAWTContextRef        context,
                                 JNIEnv *               env,
                                 jobject                objref,
                                 jmethodID              methodID,
                                 UInt32                 argCount,
                                 jvalue                 args[]);
EXTERN_API_C( OSStatus )
JMExecJNIStaticMethodInContext  (JMAWTContextRef        context,
                                 JNIEnv *               env,
                                 jclass                 classID,
                                 jmethodID              methodID,
                                 UInt32                 argCount,
                                 jvalue                 args[]);
#endif  /* CALL_NOT_IN_CARBON */
#endif  /* defined(JNI_H) */
/*
 * return a com.apple.mrj.JManager.JMAWTContext
 */
#ifdef JNI_H
#if CALL_NOT_IN_CARBON
EXTERN_API_C( jobject )
JMGetAwtContextJNIObject        (JMAWTContextRef        context,
                                 JNIEnv *               env);
#endif  /* CALL_NOT_IN_CARBON */
#endif  /* defined(JNI_H) */
#ifdef JRI_H
#if CALL_NOT_IN_CARBON
EXTERN_API_C( jref )
JMGetAwtContextObject           (JMAWTContextRef        context);
#endif  /* CALL_NOT_IN_CARBON */
#endif  /* defined(JRI_H) */
#ifdef JNI_H
/*
 * Beginning in 2.1, this function maps a JNIEnv to the owning AWTContext, if one exists
 */
#if CALL_NOT_IN_CARBON
EXTERN_API_C( JMAWTContextRef )
JMJNIToAWTContext               (JMSessionRef           session,
                                 JNIEnv *               env);
#endif  /* CALL_NOT_IN_CARBON */
#endif  /* defined(JNI_H) */
/*
 * JMAppletLocator - Since Java applets are always referenced by a Uniform Resource Locator
 * (see RFC 1737, http://www.w3.org/pub/WWW/Addressing/rfc1738.txt), we provide an object
 * that encapsulates the information about a set of applets. A JMAppletLocator is built
 * by providing a base URL, which must point at a valid HTML document containing applet
 * tags. To save a network transaction, the contents of the document may be passed optionally. 
 *
 * You can also use a JMLocatorInfoBlock for a synchronous resolution of the applet,
 * assuming that you already have the info for the tag.
 */
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;
/*
 * These structures are used to pass pre-parsed parameter
 * tags to the AppletLocator.  Implies synchronous semantics.
 */
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
EXTERN_API_C( OSStatus )
JMNewAppletLocator              (JMAppletLocatorRef *   locatorRef,
                                 JMSessionRef           session,
                                 const JMAppletLocatorCallbacks * callbacks,
                                 JMTextRef              url,
                                 JMTextRef              htmlText,
                                 JMClientData           data);
EXTERN_API_C( OSStatus )
JMNewAppletLocatorFromInfo      (JMAppletLocatorRef *   locatorRef,
                                 JMSessionRef           session,
                                 const JMLocatorInfoBlock * info,
                                 JMClientData           data);
EXTERN_API_C( OSStatus )
JMDisposeAppletLocator          (JMAppletLocatorRef     locatorRef);
EXTERN_API_C( OSStatus )
JMGetAppletLocatorData          (JMAppletLocatorRef     locatorRef,
                                 JMClientData *         data);
EXTERN_API_C( OSStatus )
JMSetAppletLocatorData          (JMAppletLocatorRef     locatorRef,
                                 JMClientData           data);
EXTERN_API_C( OSStatus )
JMCountApplets                  (JMAppletLocatorRef     locatorRef,
                                 UInt32 *               appletCount);
EXTERN_API_C( OSStatus )
JMGetAppletDimensions           (JMAppletLocatorRef     locatorRef,
                                 UInt32                 appletIndex,
                                 UInt32 *               width,
                                 UInt32 *               height);
EXTERN_API_C( OSStatus )
JMGetAppletTag                  (JMAppletLocatorRef     locatorRef,
                                 UInt32                 appletIndex,
                                 JMTextRef *            tagRef);
EXTERN_API_C( OSStatus )
JMGetAppletName                 (JMAppletLocatorRef     locatorRef,
                                 UInt32                 appletIndex,
                                 JMTextRef *            nameRef);
/*
 * JMAppletViewer - Applets are instantiated, one by one, by specifying a JMAppletLocator and
 * a zero-based index (Macintosh API's usually use one-based indexing, the Java language
 * uses zero, however.). The resulting applet is encapsulated in a JMAppletViewer object. 
 * Since applets can have one or more visible areas to draw in, one or more JMFrame objects
 * may be requested while the viewer is being created, or at a later time, thus the client
 * must provide callbacks to satisfy these requests.
 *
 * The window name for the ShowDocument callback is one of:
 *   _self      show in current frame
 *   _parent    show in parent frame
 *   _top       show in top-most frame
 *   _blank     show in new unnamed top-level window
 *   <other>    show in new top-level window named <other> 
 */
#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;
/*
 * NEW: per-applet security settings
 * Previously, these settings were attached to the session.
 * JManager 2.0 allows them to be attached to each viewer.
 */
enum JMNetworkSecurityOptions {
    eNoNetworkAccess            = 0,
    eAppletHostAccess           = 1,
    eUnrestrictedAccess         = 2
};
typedef enum JMNetworkSecurityOptions JMNetworkSecurityOptions;
enum JMFileSystemOptions {
    eNoFSAccess                 = 0,
    eLocalAppletAccess          = 1,
    eAllFSAccess                = 2
};
typedef enum JMFileSystemOptions JMFileSystemOptions;
/*
 * Lists of packages are comma separated,
 * the default for mrj.security.system.access is
 * "sun,netscape,com.apple".
 */
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;
/*
 * AppletViewer methods
 */
#if CALL_NOT_IN_CARBON
EXTERN_API_C( OSStatus )
JMNewAppletViewer               (JMAppletViewerRef *    viewer,
                                 JMAWTContextRef        context,
                                 JMAppletLocatorRef     locatorRef,
                                 UInt32                 appletIndex,
                                 const JMAppletSecurity * security,
                                 const JMAppletViewerCallbacks * callbacks,
                                 JMClientData           data);
EXTERN_API_C( OSStatus )
JMDisposeAppletViewer           (JMAppletViewerRef      viewer);
EXTERN_API_C( OSStatus )
JMGetAppletViewerData           (JMAppletViewerRef      viewer,
                                 JMClientData *         data);
EXTERN_API_C( OSStatus )
JMSetAppletViewerData           (JMAppletViewerRef      viewer,
                                 JMClientData           data);
/*
 * You can change the applet security on the fly
 */
EXTERN_API_C( OSStatus )
JMGetAppletViewerSecurity       (JMAppletViewerRef      viewer,
                                 JMAppletSecurity *     data);
EXTERN_API_C( OSStatus )
JMSetAppletViewerSecurity       (JMAppletViewerRef      viewer,
                                 const JMAppletSecurity * data);
/*
 * JMReloadApplet reloads viewer's applet from the source.
 * JMRestartApplet reinstantiates the applet without reloading.
 */
EXTERN_API_C( OSStatus )
JMReloadApplet                  (JMAppletViewerRef      viewer);
EXTERN_API_C( OSStatus )
JMRestartApplet                 (JMAppletViewerRef      viewer);
/*
 * JMSuspendApplet tells the Java thread scheduler to stop executing the viewer's applet.
 * JMResumeApplet resumes execution of the viewer's applet.
 */
EXTERN_API_C( OSStatus )
JMSuspendApplet                 (JMAppletViewerRef      viewer);
EXTERN_API_C( OSStatus )
JMResumeApplet                  (JMAppletViewerRef      viewer);
/* 
 * To get back to the JMAppletViewerRef instance from whence a frame came,
 * as well as the ultimate frame parent (the one created _for_ the applet viewer)
 */
EXTERN_API_C( OSStatus )
JMGetFrameViewer                (JMFrameRef             frame,
                                 JMAppletViewerRef *    viewer,
                                 JMFrameRef *           parentFrame);
/*
 * To get a ref back to the Frame that was created for this JMAppletViewerRef
 */
EXTERN_API_C( OSStatus )
JMGetViewerFrame                (JMAppletViewerRef      viewer,
                                 JMFrameRef *           frame);
#endif  /* CALL_NOT_IN_CARBON */
/*
 * To get the ref of the com.apple.mrj.JManager.JMAppletViewer java object
 */
#ifdef JNI_H
#if CALL_NOT_IN_CARBON
EXTERN_API_C( jobject )
JMGetAppletViewerJNIObject      (JMAppletViewerRef      viewer,
                                 JNIEnv *               env);
#endif  /* CALL_NOT_IN_CARBON */
#endif  /* defined(JNI_H) */
#ifdef JRI_H
#if CALL_NOT_IN_CARBON
EXTERN_API_C( jref )
JMGetAppletViewerObject         (JMAppletViewerRef      viewer);
#endif  /* CALL_NOT_IN_CARBON */
#endif  /* defined(JRI_H) */
/*
 * To get the ref of the java.applet.Applet itself
 */
#ifdef JNI_H
#if CALL_NOT_IN_CARBON
EXTERN_API_C( jobject )
JMGetAppletJNIObject            (JMAppletViewerRef      viewer,
                                 JNIEnv *               env);
#endif  /* CALL_NOT_IN_CARBON */
#endif  /* defined(JNI_H) */
#ifdef JRI_H
#if CALL_NOT_IN_CARBON
EXTERN_API_C( jref )
JMGetAppletObject               (JMAppletViewerRef      viewer);
#endif  /* CALL_NOT_IN_CARBON */
#endif  /* defined(JRI_H) */
/*
 * Tell MRJ to add connID to its list of shared libraries used when searching for
 * JNI (and JRI) native methods. This is useful for overriding or redirecting
 * a java call to System.loadLibrary().  In particular System.loadLibrary()
 * does not reuse CFM connections to libraries already open by someone outside
 * of the java session.  It always forces its own private copy of a shared library 
 * to be opened.  This can result in multiple instances of the data/TOC section
 * of a shared library.  
 * Note: This function has no effect on JDirect based native methods.
 * If connID exports a function named "JNI_OnLoad", it is immediately called.
 * If javaShouldClose is true, MRJ will close the connection when the session is closed.
 * Returns false and does nothing if a library with that name is already registered.
 */
#if CALL_NOT_IN_CARBON
EXTERN_API_C( 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__ */

						