QTML.h

Go to the documentation of this file.

 
#ifndef __QTML__
#define __QTML__
 
#ifndef __MACTYPES__
#include <MacTypes.h>
#endif
 
#ifndef __MACMEMORY__
#include <MacMemory.h>
#endif
 
#ifndef __MACWINDOWS__
#include <MacWindows.h>
#endif
 
#ifndef __OSUTILS__
#include <OSUtils.h>
#endif
 
#ifndef __FILES__
#include <Files.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 CALL_NOT_IN_CARBON
    void
    QTMLYieldCPU(void);
 
    void
    QTMLYieldCPUTime(long milliSeconds, unsigned long flags);
 
#endif /* CALL_NOT_IN_CARBON */
 
    typedef struct OpaqueQTMLMutex *QTMLMutex;
#if !(TARGET_OS_MAC && TARGET_API_MAC_OS8)
    typedef struct OpaqueQTMLSyncVar *QTMLSyncVar;
    typedef QTMLSyncVar *QTMLSyncVarPtr;
    enum
    {
        kInitializeQTMLNoSoundFlag =
            (1L << 0), /* flag for requesting no sound when calling InitializeQTML*/
        kInitializeQTMLUseGDIFlag =
            (1L << 1), /* flag for requesting GDI when calling InitializeQTML*/
        kInitializeQTMLDisableDirectSound =
            (1L << 2), /* disables QTML's use of DirectSound*/
        kInitializeQTMLUseExclusiveFullScreenModeFlag =
            (1L << 3), /* later than QTML 3.0: qtml starts up in exclusive full screen
                          mode*/
        kInitializeQTMLDisableDDClippers =
            (1L << 4) /* flag for requesting QTML not to use DirectDraw clipper
                         objects; QTML 5.0 and later*/
    };
 
    enum
    {
        kQTMLHandlePortEvents =
            (1L << 0), /* flag for requesting requesting QTML to handle events*/
        kQTMLNoIdleEvents =
            (1L << 1) /* flag for requesting requesting QTML not to send Idle Events*/
    };
 
#if CALL_NOT_IN_CARBON
    OSErr
    InitializeQTML(long flag);
 
    void
    TerminateQTML(void);
 
    GrafPtr
    CreatePortAssociation(void *theWnd, Ptr storage, long flags);
 
    void
    DestroyPortAssociation(CGrafPtr cgp);
 
    void
    QTMLGrabMutex(QTMLMutex mu);
 
    Boolean
    QTMLTryGrabMutex(QTMLMutex mu);
 
    void
    QTMLReturnMutex(QTMLMutex mu);
 
    QTMLMutex
    QTMLCreateMutex(void);
 
    void
    QTMLDestroyMutex(QTMLMutex mu);
 
    QTMLSyncVarPtr
    QTMLCreateSyncVar(void);
 
    void
    QTMLDestroySyncVar(QTMLSyncVarPtr p);
 
    long
    QTMLTestAndSetSyncVar(QTMLSyncVarPtr sync);
 
    void
    QTMLWaitAndSetSyncVar(QTMLSyncVarPtr sync);
 
    void
    QTMLResetSyncVar(QTMLSyncVarPtr sync);
 
    void
    InitializeQHdr(QHdr *qhdr);
 
    void
    TerminateQHdr(QHdr *qhdr);
 
    void
    QTMLAcquireWindowList(void);
 
    void
    QTMLReleaseWindowList(void);
 
    long
    QTMLRegisterInterruptSafeThread(unsigned long threadID, void *threadInfo);
 
    long
    QTMLUnregisterInterruptSafeThread(unsigned long threadID);
 
    long
    NativeEventToMacEvent(void *nativeEvent, EventRecord *macEvent);
 
#endif /* CALL_NOT_IN_CARBON */
 
#if TARGET_OS_WIN32
#if CALL_NOT_IN_CARBON
    long
    WinEventToMacEvent(void *winMsg, EventRecord *macEvent);
 
#define WinEventToMacEvent NativeEventToMacEvent
    Boolean
    IsTaskBarVisible(void);
 
    void
    ShowHideTaskBar(Boolean showIt);
 
#endif /* CALL_NOT_IN_CARBON */
 
    enum
    {
        kDDSurfaceLocked = (1L << 0),
        kDDSurfaceStatic = (1L << 1)
    };
 
#if CALL_NOT_IN_CARBON
    OSErr
    QTGetDDObject(void **lpDDObject);
 
    OSErr
    QTSetDDObject(void *lpNewDDObject);
 
    OSErr
    QTSetDDPrimarySurface(void *lpNewDDSurface, unsigned long flags);
 
    OSErr
    QTMLGetVolumeRootPath(char *fullPath, char *volumeRootPath,
                          unsigned long volumeRootLen);
 
    void
    QTMLSetWindowWndProc(WindowRef theWindow, void *windowProc);
 
    void *
    QTMLGetWindowWndProc(WindowRef theWindow);
 
#endif /* CALL_NOT_IN_CARBON */
 
#endif /* TARGET_OS_WIN32 */
 
#if CALL_NOT_IN_CARBON
    OSErr
    QTMLGetCanonicalPathName(char *inName, char *outName, unsigned long outLen);
 
#endif /* CALL_NOT_IN_CARBON */
 
    enum
    {
        kFullNativePath = 0,
        kFileNameOnly = (1 << 0),
        kDirectoryPathOnly = (1 << 1),
        kUFSFullPathName = (1 << 2),
        kTryVDIMask = (1 << 3), /*    Used in NativePathNameToFSSpec to specify to
                                   search VDI mountpoints*/
        kFullPathSpecifiedMask =
            (1 << 4) /*    the passed in name is a fully qualified full path*/
    };
 
#if CALL_NOT_IN_CARBON
    OSErr
    FSSpecToNativePathName(const FSSpec *inFile, char *outName,
                           unsigned long outLen, long flags);
 
#endif /* CALL_NOT_IN_CARBON */
 
    enum
    {
        kErrorIfFileNotFound = 1L << 31
    };
 
#if CALL_NOT_IN_CARBON
    OSErr
    NativePathNameToFSSpec(char *inName, FSSpec *outFile, long flags);
 
    OSErr
    QTGetAliasInfo(AliasHandle alias, AliasInfoType index, char *outBuf,
                   long bufLen, long *outLen, unsigned long flags);
 
#endif /* CALL_NOT_IN_CARBON */
 
#endif /* !(TARGET_OS_MAC && TARGET_API_MAC_OS8) */
 
#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 /* __QTML__ */