winmm.odl

The code for this article was written for version 1.0 of the Active Template Library (ATL). The cu

    [
    usesgetlasterror,
    entry("timeGetTime"),
    helpstring("Gets the time in milliseconds"),
    ]
    DWORD WINAPI timeGetTime();

    // ****** Joystick support ******

    /*
    // joystick error return values
    //define JOYERR_NOERROR       (0)                  // no error
    //define JOYERR_PARMS         (JOYERR_BASE+5)      // bad parameters
    //define JOYERR_NOCANDO       (JOYERR_BASE+6)      // request not completed
    //define JOYERR_UNPLUGGED     (JOYERR_BASE+7)      // joystick is unplugged

    // constants used with JOYINFO structure and MM_JOY* messages
    //define JOY_BUTTON1        0x0001
    //define JOY_BUTTON2        0x0002
    //define JOY_BUTTON3        0x0004
    //define JOY_BUTTON4        0x0008
    //define JOY_BUTTON1CHG     0x0100
    //define JOY_BUTTON2CHG     0x0200
    //define JOY_BUTTON3CHG     0x0400
    //define JOY_BUTTON4CHG     0x0800

    // joystick ID constants
    //define JOYSTICKID1        0
    //define JOYSTICKID2        1

    // joystick device capabilities data structure
    typedef struct joycaps_tag {
        UINT wMid;                  // manufacturer ID
        UINT wPid;                  // product ID
        char szPname[MAXPNAMELEN];  // product name (NULL terminated string)
        UINT wXmin;                 // minimum x position value
        UINT wXmax;                 // maximum x position value
        UINT wYmin;                 // minimum y position value
        UINT wYmax;                 // maximum y position value
        UINT wZmin;                 // minimum z position value
        UINT wZmax;                 // maximum z position value
        UINT wNumButtons;           // number of buttons
        UINT wPeriodMin;            // minimum message period when captured
        UINT wPeriodMax;            // maximum message period when captured
        } JOYCAPS;
    typedef JOYCAPS       *PJOYCAPS;
    typedef JOYCAPS NEAR *NPJOYCAPS;
    typedef JOYCAPS FAR  *LPJOYCAPS;

    // joystick information data structure
    typedef struct joyinfo_tag {
        UINT wXpos;                 // x position
        UINT wYpos;                 // y position
        UINT wZpos;                 // z position
        UINT wButtons;              // button states
        } JOYINFO;
    typedef JOYINFO       *PJOYINFO;
    typedef JOYINFO NEAR *NPJOYINFO;
    typedef JOYINFO FAR  *LPJOYINFO;

    // joystick function prototypes
    UINT WINAPI joyGetDevCaps(UINT uJoyID, JOYCAPS FAR* lpCaps, UINT uSize);
    UINT WINAPI joyGetNumDevs(void);
    UINT WINAPI joyGetPos(UINT uJoyID, JOYINFO FAR* lpInfo);
    UINT WINAPI joyGetThreshold(UINT uJoyID, UINT FAR* lpuThreshold);
    UINT WINAPI joyReleaseCapture(UINT uJoyID);
    UINT WINAPI joySetCapture([in] HWND hwnd hwnd, UINT uJoyID, UINT uPeriod,
        BOOL bChanged);
    UINT WINAPI joySetThreshold(UINT uJoyID, UINT uThreshold);
    */


    // ****** Multimedia File I/O support *******

    /*
    // MMIO error return values
    //define MMIOERR_BASE           256
    //define MMIOERR_FILENOTFOUND   (MMIOERR_BASE + 1)  // file not found
    //define MMIOERR_OUTOFMEMORY    (MMIOERR_BASE + 2)  // out of memory
    //define MMIOERR_CANNOTOPEN     (MMIOERR_BASE + 3)  // cannot open
    //define MMIOERR_CANNOTCLOSE    (MMIOERR_BASE + 4)  // cannot close
    //define MMIOERR_CANNOTREAD     (MMIOERR_BASE + 5)  // cannot read
    //define MMIOERR_CANNOTWRITE    (MMIOERR_BASE + 6)  // cannot write
    //define MMIOERR_CANNOTSEEK     (MMIOERR_BASE + 7)  // cannot seek
    //define MMIOERR_CANNOTEXPAND   (MMIOERR_BASE + 8)  // cannot expand file
    //define MMIOERR_CHUNKNOTFOUND  (MMIOERR_BASE + 9)  // chunk not found
    //define MMIOERR_UNBUFFERED     (MMIOERR_BASE + 10) // file is unbuffered

    // MMIO constants
    //define CFSEPCHAR      '+'             // compound file name separator char.

    // MMIO data types
    typedef DWORD           FOURCC;         // a four character code
    typedef char _huge *    HPSTR;          // a huge version of LPSTR
    DECLARE_HANDLE(HMMIO);                  // a handle to an open file
    typedef LRESULT (CALLBACK MMIOPROC)(LPSTR lpmmioinfo, UINT uMessage,
                LPARAM lParam1, LPARAM lParam2);
    typedef MMIOPROC FAR *LPMMIOPROC;

    // general MMIO information data structure
    typedef struct _MMIOINFO
    {
            // general fields
            DWORD           dwFlags;        // general status flags
            FOURCC          fccIOProc;      // pointer to I/O procedure
            LPMMIOPROC      pIOProc;        // pointer to I/O procedure
            UINT            wErrorRet;      // place for error to be returned
            HTASK           htask;          // alternate local task

            // fields maintained by MMIO functions during buffered I/O
            LONG            cchBuffer;      // size of I/O buffer (or 0L)
            HPSTR           pchBuffer;      // start of I/O buffer (or NULL)
            HPSTR           pchNext;        // pointer to next byte to read/write
            HPSTR           pchEndRead;     // pointer to last valid byte to read
            HPSTR           pchEndWrite;    // pointer to last byte to write
            LONG            lBufOffset;     // disk offset of start of buffer

            // fields maintained by I/O procedure
            LONG            lDiskOffset;    // disk offset of next read or write
            DWORD           adwInfo[3];     // data specific to type of MMIOPROC

            // other fields maintained by MMIO
            DWORD           dwReserved1;    // reserved for MMIO use
            DWORD           dwReserved2;    // reserved for MMIO use
            HMMIO           hmmio;          // handle to open file
    } MMIOINFO;
    typedef MMIOINFO       *PMMIOINFO;
    typedef MMIOINFO NEAR *NPMMIOINFO;
    typedef MMIOINFO FAR  *LPMMIOINFO;

    // RIFF chunk information data structure
    typedef struct _MMCKINFO
    {
            FOURCC          ckid;           // chunk ID
            DWORD           cksize;         // chunk size
            FOURCC          fccType;        // form type or list type
            DWORD           dwDataOffset;   // offset of data portion of chunk
            DWORD           dwFlags;        // flags used by MMIO functions
    } MMCKINFO;
    typedef MMCKINFO       *PMMCKINFO;
    typedef MMCKINFO NEAR *NPMMCKINFO;
    typedef MMCKINFO FAR  *LPMMCKINFO;

    // bit field masks
    //define MMIO_RWMODE    0x00000003      // open file for reading/writing/both
    //define MMIO_SHAREMODE 0x00000070      // file sharing mode number

    // constants for dwFlags field of MMIOINFO
    //define MMIO_CREATE    0x00001000      // create new file (or truncate file)
    //define MMIO_PARSE     0x00000100      // parse new file returning path
    //define MMIO_DELETE    0x00000200      // create new file (or truncate file)
    //define MMIO_EXIST     0x00004000      // checks for existence of file
    //define MMIO_ALLOCBUF  0x00010000      // mmioOpen() should allocate a buffer
    //define MMIO_GETTEMP   0x00020000      // mmioOpen() should retrieve temp name

    //define MMIO_DIRTY     0x10000000      // I/O buffer is dirty


    // read/write mode numbers (bit field MMIO_RWMODE)
    //define MMIO_READ      0x00000000      // open file for reading only
    //define MMIO_WRITE     0x00000001      // open file for writing only
    //define MMIO_READWRITE 0x00000002      // open file for reading and writing

    // share mode numbers (bit field MMIO_SHAREMODE)
    //define MMIO_COMPAT    0x00000000      // compatibility mode
    //define MMIO_EXCLUSIVE 0x00000010      // exclusive-access mode
    //define MMIO_DENYWRITE 0x00000020      // deny writing to other processes
    //define MMIO_DENYREAD  0x00000030      // deny reading to other processes
    //define MMIO_DENYNONE  0x00000040      // deny nothing to other processes

    // various MMIO flags
    //define MMIO_FHOPEN            0x0010  // mmioClose: keep file handle open
    //define MMIO_EMPTYBUF          0x0010  // mmioFlush: empty the I/O buffer
    //define MMIO_TOUPPER           0x0010  // mmioStringToFOURCC: to u-case
    //define MMIO_INSTALLPROC   0x00010000  // mmioInstallIOProc: install MMIOProc
    //define MMIO_GLOBALPROC    0x10000000  // mmioInstallIOProc: install globally
    //define MMIO_REMOVEPROC    0x00020000  // mmioInstallIOProc: remove MMIOProc
    //define MMIO_FINDPROC      0x00040000  // mmioInstallIOProc: find an MMIOProc
    //define MMIO_FINDCHUNK         0x0010  // mmioDescend: find a chunk by ID
    //define MMIO_FINDRIFF          0x0020  // mmioDescend: find a LIST chunk
    //define MMIO_FINDLIST          0x0040  // mmioDescend: find a RIFF chunk
    //define MMIO_CREATERIFF        0x0020  // mmioCreateChunk: make a LIST chunk
    //define MMIO_CREATELIST        0x0040  // mmioCreateChunk: make a RIFF chunk


    // message numbers for MMIOPROC I/O procedure functions
    //define MMIOM_READ     MMIO_READ       // read
    //define MMIOM_WRITE    MMIO_WRITE      // write
    //define MMIOM_SEEK             2       // seek to a new position in file
    //define MMIOM_OPEN             3       // open file
    //define MMIOM_CLOSE            4       // close file
    //define MMIOM_WRITEFLUSH       5       // write and flush

    //define MMIOM_RENAME           6       // rename specified file

    //define MMIOM_USER        0x8000       // beginning of user-defined messages

    // standard four character codes
    //define FOURCC_RIFF    mmioFOURCC('R', 'I', 'F', 'F')
    //define FOURCC_LIST    mmioFOURCC('L', 'I', 'S', 'T')

    // four character codes used to identify standard built-in I/O procedures
    //define FOURCC_DOS     mmioFOURCC('D', 'O', 'S', ' ')
    //define FOURCC_MEM     mmioFOURCC('M', 'E', 'M', ' ')

    // flags for mmioSeek()

    // other constants
    //define MMIO_DEFAULTBUFFER     8192    // default buffer size

    // MMIO macros
    //define mmioFOURCC( ch0, ch1, ch2, ch3 )                               \
                    ( (DWORD)(BYTE)(ch0) | ( (DWORD)(BYTE)(ch1) << 8 ) |    \
                    ( (DWORD)(BYTE)(ch2) << 16 ) | ( (DWORD)(BYTE)(ch3) << 24 ) )

    // MMIO function prototypes
    FOURCC WINAPI mmioStringToFOURCC(LPCSTR sz, UINT uFlags);
    LPMMIOPROC WINAPI mmioInstallIOProc(FOURCC fccIOProc, LPMMIOPROC pIOProc,
        DWORD dwFlags);
    HMMIO WINAPI mmioOpen(LPSTR szFileName, MMIOINFO FAR* lpmmioinfo,
        DWORD dwOpenFlags);

    UINT WINAPI mmioRename(LPCSTR szFileName, LPCSTR szNewFileName,
         MMIOINFO FAR* lpmmioinfo, DWORD dwRenameFlags);

    UINT WINAPI mmioClose(HMMIO hmmio, UINT uFlags);
    LONG WINAPI mmioRead(HMMIO hmmio, HPSTR pch, LONG cch);
    LONG WINAPI mmioWrite(HMMIO hmmio, const char _huge* pch, LONG cch);
    LONG WINAPI mmioSeek(HMMIO hmmio, LONG lOffset, int iOrigin);
    UINT WINAPI mmioGetInfo(HMMIO hmmio, MMIOINFO FAR* lpmmioinfo, UINT uFlags);
    UINT WINAPI mmioSetInfo(HMMIO hmmio, const MMIOINFO FAR* lpmmioinfo, UINT uFlags);
    UINT WINAPI mmioSetBuffer(HMMIO hmmio, LPSTR pchBuffer, LONG cchBuffer,
        UINT uFlags);
    UINT WINAPI mmioFlush(HMMIO hmmio, UINT uFlags);
    UINT WINAPI mmioAdvance(HMMIO hmmio, MMIOINFO FAR* lpmmioinfo, UINT uFlags);
    LRESULT WINAPI mmioSendMessage(HMMIO hmmio, UINT uMessage,
        LPARAM lParam1, LPARAM lParam2);
    UINT WINAPI mmioDescend(HMMIO hmmio, MMCKINFO FAR* lpck,
        const MMCKINFO FAR* lpckParent, UINT uFlags);
    UINT WINAPI mmioAscend(HMMIO hmmio, MMCKINFO FAR* lpck, UINT uFlags);
    UINT WINAPI mmioCreateChunk(HMMIO hmmio, MMCKINFO FAR* lpck, UINT uFlags);
    */

    // ****** Omit All MCI support *******

    // ****** DISPLAY Driver extensions ******

    /*
        //define QUERYROPSUPPORT 40         // use to determine ROP support
    */

    // ****** DIB Driver extensions ********

    //define SELECTDIB      41                      // DIB.DRV select dib escape
    //define DIBINDEX(n)    MAKELONG((n),0x10FF)


    // ****** ScreenSaver support *******

    // The current application will receive a syscommand of SC_SCREENSAVE just
    // before the screen saver is invoked.  If the app wishes to prevent a
    // screen save, return non-zero value, otherwise call DefWindowProc().

        //define SC_SCREENSAVE  0xF140
}