### IMMRecordable

  The IMMRecordable class is a base class and provides all of the common behavior for all recordable media devices. There are functions for cutting, copying, and pasting from a clipboard. Also, it includes delete, undo, and save functions.

### IMMRecordable - Member Functions and Data by Group

### Constructors & Destructor

Derived classes can use these members to create objects of this class.

~IMMRecordable

      public:
      virtual ~IMMRecordable()

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | No

IMMRecordable

  Overload 1

      protected:
      IMMRecordable( const IString& deviceName,
                     bool openNow,
                     unsigned long instance,
                     bool openShareable )

  A derived class can construct an IMMRecordable from the following:

  deviceName
    You must specify what device you want to construct.
  openNow
    If true, it causes the device to automatically open the device before returning from the constructor; otherwise, you have to call one of the open functions to open the device yourself.
  instance
    You can provide your own instance number instead of letting IMMRecordable generate one.
  openShareable
    If true, it allows the hardware device to be shared by different programs; otherwise, the hardware cannot be shared.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | No

  Overload 2

      protected:
      IMMRecordable( unsigned long deviceIdentifier,
                     const IString& newAlias = IString ( ) )

  A derived class can construct an IMMRecordable from the following:

  deviceIdentifier
    The value the system uses to identify the device.
  newAlias
    The name you can use to associate a string to the device. Optional.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | No

### Editing

Use these members to edit and record data by the device.

canRedo

      public:
      bool canRedo() const

  Returns true if the device has any actions to be redone.

Exception

  IAccessError | The device identifier is not valid; possibly the device is closed.
  IAccessError | The device cannot acquire access to the hardware device; possibly another device of this same type was acquired for exclusive use in this or another process.
  IAccessError | An internal driver error occurred.
  IInvalidRequest | The device must be in the open state before calling this function.

Supported Platforms

  Windows | OS/2 | AIX
  No | Yes | No

canUndo

      public:
      bool canUndo() const

  Returns true if the device has any actions that can be undone.

Exception

  IAccessError | The device identifier is not valid; possibly the device is closed.
  IAccessError | The device cannot acquire access to the hardware device; possibly another device of this same type was acquired for exclusive use in this or another process.
  IAccessError | An internal driver error occurred.
  IInvalidRequest | The device must be in the open state before calling this function.

Supported Platforms

  Windows | OS/2 | AIX
  No | Yes | No

copy

      public:
      virtual IMMRecordable&
        copy( const IMMTime& from = IMMTime ( ),
              const IMMTime& to = IMMTime ( ),
              CallType call = wait ) const

  Copies data from the passed-in start position to the passed-in end position into the clipboard. If from is omitted, it uses the current position; if to is omitted, it uses the end of the data. The clipboard is cleared before the copy occurs.

Exception

  IAccessError | The device identifier is not valid; possibly the device is closed.
  IAccessError | The device cannot acquire access to the hardware device; possibly another device of this same type was acquired for exclusive use in this or another process.
  IAccessError | An internal driver error occurred.
  IInvalidRequest | The device must be in the open state before calling this function.
  IAccessError | Invalid from position; possibly the from position is greater than the end position or the from position is greater than the to position.
  IAccessError | Invalid to position; possibly the to position is greater than the length of the data.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | No

cueForRecording

      public:
      virtual IMMRecordable&
        cueForRecording( CallType call = nowait )

  Cues the device for recording. This function causes any up front work that can occur to occur, thereby making the start of recording quick. This function does not have to be issued before recording; however, depending on the device, it might reduce the delay associated with the record function. For example, a sound card might have to clear some internal buffers before it can start recording from a microphone. This function would clear out those internal buffers for the sound card.

Exception

  IAccessError | The device identifier is not valid; possibly the device is closed.
  IAccessError | The device cannot acquire access to the hardware device; possibly another device of this same type was acquired for exclusive use in this or another process.
  IAccessError | An internal driver error occurred.
  IInvalidRequest | The device must be in the open state before calling this function.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | No

cut

      public:
      virtual IMMRecordable&
        cut( const IMMTime& from = IMMTime ( ),
             const IMMTime& to = IMMTime ( ),
             CallType call = wait )

  Cuts the data from the passed-in start position to the passed-in end position into the clipboard. If data is already in the clipboard, it is overwritten. If from is omitted, it uses the current position; if to is omitted, it uses the end of the data.

Exception

  IAccessError | The device identifier is not valid; possibly the device is closed.
  IAccessError | The device cannot acquire access to the hardware device; possibly another device of this same type was acquired for exclusive use in this or another process.
  IAccessError | An internal driver error occurred.
  IInvalidRequest | The device must be in the open state before calling this function.
  IAccessError | Invalid from position; possibly the from position is greater than the end position or the from position is greater than the to position.
  IAccessError | Invalid to position; possibly if the to position is greater than the length of the data.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | No

deleteSelection

      public:
      virtual IMMRecordable&
        deleteSelection( const IMMTime& from = IMMTime ( ),
                         const IMMTime& to = IMMTime ( ),
                         CallType call = wait )

  Deletes data from the passed-in start position to the passed-in end position. If from is omitted, it uses the current position; if to is omitted, it uses the end of the data.

Exception

  IAccessError | The device identifier is not valid; possibly the device is closed.
  IAccessError | The device cannot acquire access to the hardware device; possibly another device of this same type was acquired for exclusive use in this or another process.
  IAccessError | An internal driver error occurred.
  IInvalidRequest | The device must be in the open state before calling this function.
  IAccessError | Invalid from position; possibly the from position is greater than the end position or the from position is greater than the to position.
  IAccessError | Invalid to position; possibly if the to position is greater than the length of the data.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | No

paste

      public:
      virtual IMMRecordable&
        paste( const IMMTime& from = IMMTime ( ),
               const IMMTime& to = IMMTime ( ),
               bool convert = true,
               CallType call = wait )

  Replaces the data with data from the clipboard, from the passed-in start position to the passed-in end position. If neither from nor to is specified, it inserts the data at the current position. If from is omitted, it uses the start of the buffer; if to is omitted, it uses the end of the audio data in the buffer. If convert is true, it causes the audio data in the clipboard to be converted to the current audio format before being pasted; otherwise, no conversion occurs. If you are pasting audio data, and audio format for data in the clipboard is incompatible with this device's audio format, then convert should be set to true; otherwise, an exception occurs.

Exception

  IAccessError | The device identifier is not valid; possibly the device is closed.
  IAccessError | The device cannot acquire access to the hardware device; possibly another device of this same type was acquired for exclusive use in this or another process.
  IAccessError | An internal driver error occurred.
  IInvalidRequest | The device must be in the open state before calling this function.
  IAccessError | Invalid from position; possibly the from position is greater than the end position or the from position is greater than the to position.
  IAccessError | Invalid to position; possibly the to position is greater than the length of the data.
  IAccessError | The disk or buffer is full.
  IAccessError | There is insufficient memory to perform the operation requested.
  IAccessError | The clipboard format is not valid.
  IAccessError | The clipboard cannot be opened.
  IAccessError | No recognizable information is in the clipboard.
  IAccessError | Unable to convert audio format in the clipboard to the destination audio format.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | No

record

      public:
      virtual IMMRecordable&
        record( bool insert = true,
                const IMMTime& begin = IMMTime ( ),
                const IMMTime& end = IMMTime ( ),
                bool resumeIfPaused = true,
                CallType call = nowait )

  Starts recording at the begin location till it reaches the end location. If the end location is not specified, recording continues until a pause or stop occurs. If the begin location is not specified, recording starts at the current location. It is recommended that you temporarily acquire the device exclusively while you are recording; otherwise, the recording can become inactive if another device requests access to the device.

Exception

  IAccessError | The device identifier is not valid; possibly the device is closed.
  IAccessError | The device cannot acquire access to the hardware device; possibly another device of this same type was acquired for exclusive use in this or another process.
  IAccessError | An internal driver error occurred.
  IInvalidRequest | The device must be in the open state before calling this function.
  IAccessError | Invalid begin position; possibly the begin position is greater than the length of the data or the begin position is greater than the end position.
  IAccessError | Invalid end position; possibly if the end position is greater than the length of the data.
  IAccessError | The disk or buffer is full.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | No

redo

      public:
      virtual IMMRecordable& redo(CallType call = wait)

  Redoes the record, cut, paste, or delete operation most recently undone by undo. The position is at the beginning of the file after a redo. You can redo up to the last save, which causes any previous actions to be cleared and cannot be redone. Not all devices support his function.

Exception

  IAccessError | The device identifier is not valid; possibly the device is closed.
  IAccessError | The device cannot acquire access to the hardware device; possibly another device of this same type was acquired for exclusive use in this or another process.
  IAccessError | An internal driver error occurred.
  IInvalidRequest | The device must be in the open state before calling this function.
  IAccessError | Cannot redo. Redo is not possible in the current state; possibly there are no actions to be redone (that is, the file was just saved).

Supported Platforms

  Windows | OS/2 | AIX
  No | Yes | No

save

      public:
      virtual IMMRecordable& save(CallType call = nowait)

  Saves the current file.

Exception

  IAccessError | The device identifier is not valid; possibly the device is closed.
  IAccessError | The device cannot acquire access to the hardware device; possibly another device of this same type was acquired for exclusive use in this or another process.
  IAccessError | An internal driver error occurred.
  IInvalidRequest | The device must be in the open state before calling this function.
  IAccessError | The file is not found; possibly the current data does not have a name. Use saveAs with the file name.
  IAccessError | Save to a read-only file; possibly the currently loaded file was loaded as read-only.
  IAccessError | The disk or buffer is full.
  IAccessError | There is insufficient memory to perform the save operation.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | No

saveAs

      public:
      virtual IMMRecordable&
        saveAs( const IString& filename,
                CallType call = nowait )

  Saves the current file as a different file. Any subsequent calls to the save function will overwrite this file.

Exception

  IAccessError | The device identifier is not valid; possibly the device is closed.
  IAccessError | The device cannot acquire access to the hardware device; possibly another device of this same type was acquired for exclusive use in this or another process.
  IAccessError | An internal driver error occurred.
  IInvalidRequest | The device must be in the open state before calling this function.
  IAccessError | The file is not found; possibly the file name string does not contain a valid file name.
  IAccessError | Save to a read-only file; possibly if the currently loaded file was loaded as read-only.
  IAccessError | The disk or buffer is full.
  IAccessError | There is insufficient memory to perform the save operation.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | Yes | No

undo

      public:
      virtual IMMRecordable& undo(CallType call = wait)

  Undoes the operation most recently performed by cut, record, paste, or delete. After an undo, the position is at the beginning of the media. You can undo up to the last save, which causes any previous actions to be cleared and cannot be undone. Not all devices support his function.

Exception

  IAccessError | The device identifier is not valid; possibly the device is closed.
  IAccessError | The device cannot acquire access to the hardware device; possibly another device of this same type was acquired for exclusive use in this or another process.
  IAccessError | An internal driver error occurred.
  IInvalidRequest | The device must be in the open state before calling this function.
  IAccessError | Cannot undo. Undo is not possible in the current state; possibly there are no actions to be undone (that is, the file is in the state where the last change was made).

Supported Platforms

  Windows | OS/2 | AIX
  No | Yes | No

### Hidden Functions

We have hidden these functions to prevent you from using them.

restoreDeviceSettings

      protected:
      virtual IMMRecordable&
        restoreDeviceSettings( bool newRecordMode = false )

  Restores settings for the current device. Derived classes should override this function, handle class-specific settings, and call the corresponding inherited function.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | No | No

saveDeviceSettings

      protected:
      virtual IMMRecordable& saveDeviceSettings()

  Saves settings for the current device. Derived classes should override this function, handle class-specific settings, and call the corresponding inherited function.

Supported Platforms

  Windows | OS/2 | AIX
  Yes | No | No

### IMMRecordable - Inherited Member Functions and Data

#### Inherited Public Functions

  IMMDevice

  -     virtual ~IMMDevice()

  -     virtual IMMDevice&
          acquire( ShareMode acquire = shareable,
                   bool queuedForResources = false,
                   CallType call = wait )

  -     IString aliasName() const

  -     virtual IMMDevice& close(CallType call = wait)

  -     unsigned long
          connectedDeviceId( ConnectorType type,
                             CallType call = wait ) const

  -     virtual IMMDevice&
          deletePendingEvents( EventType event = allEvents )

  -     IString description(CallType call = wait) const

  -     unsigned long deviceId() const

  -     IString deviceName() const

  -     unsigned long deviceType(CallType call = wait) const

  -     virtual IMMDevice&
          disableAudio( AudioChannel channel = all,
                        const IMMMillisecondTime& over = IMMMillisecondTime ( ),
                        CallType call = wait )

  -     virtual IMMDevice&
          disableConnector( ConnectorType type,
                            CallType call = wait )

  -     virtual IMMDevice&
          enableAudio( bool enable = true,
                       AudioChannel channel = all,
                       const IMMMillisecondTime& over = IMMMillisecondTime ( ),
                       CallType call = wait )

  -     virtual IMMDevice&
          enableConnector( ConnectorType type,
                           bool enable = true,
                           CallType call = wait )

  -     virtual IMMDevice& enableNotification(bool enabled = true)

  -     bool isAcquired(CallType call = wait) const

  -     bool
          isAudioEnabled( AudioChannel channel = all,
                          CallType call = wait )

  -     bool isCloseOnDestroy() const

  -     bool
          isConnectionSupported( ConnectorType type,
                                 CallType call = wait ) const

  -     bool
          isConnectorEnabled( ConnectorType type,
                              CallType call = wait ) const

  -     bool isOpen() const

  -     virtual Mode mode(CallType call = wait) const

  -     virtual IMMDevice&
          open( const IString& fileOrDevice = IString ( ),
                bool shareable = true,
                CallType call = wait )

  -     virtual IMMDevice&
          openOnThread( const IString& fileOrDevice = IString ( ),
                        bool shareable = true,
                        CallType call = wait )

  -     IMMTime prerollTime(CallType call = wait) const

  -     PrerollType prerollType(CallType call = wait) const

  -     virtual IMMDevice& release(CallType call = wait)

  -     bool requiresFiles(CallType call = wait) const

  -     IMMDevice& setCloseOnDestroy(bool close = true)

  -     virtual IMMDevice&
          setSpeedFormat( IMMSpeed::Format format,
                          CallType call = wait )

  -     virtual IMMDevice&
          setTimeFormat( IMMTime::Format format,
                         CallType call = wait )

  -     virtual IMMDevice&
          setVolume( unsigned long volume,
                     AudioChannel channel = all,
                     const IMMMillisecondTime& over = IMMMillisecondTime ( ),
                     CallType call = wait )

  -     IMMSpeed::Format speedFormat(CallType call = wait) const

  -     bool supportsAudio(CallType call = wait) const

  -     bool
          supportsCommand( IMMNotifyEvent::Command command,
                           CallType call = wait ) const

  -     bool supportsDigitalTransfer(CallType call = wait) const

  -     bool supportsDisableEject(CallType call = wait) const

  -     bool supportsEject(CallType call = wait) const

  -     bool supportsPlay(CallType call = wait) const

  -     bool supportsRecord(CallType call = wait) const

  -     bool supportsRecordInsertion(CallType call = wait) const

  -     bool supportsSave(CallType call = wait) const

  -     bool supportsStreaming(CallType call = wait) const

  -     bool supportsVideo(CallType call = wait) const

  -     bool supportsVolumeAdjustment(CallType call = wait) const

  -     IMMTime::Format timeFormat(CallType call = wait) const

  -     virtual unsigned long
          volume( AudioChannel channel = left,
                  CallType call = wait ) const

  IMMFileMedia

  -     virtual ~IMMFileMedia()

  -     IString filename(CallType call = wait) const

  -     virtual bool isWriteable() const

  -     virtual IMMFileMedia&
          load( const IString& filename,
                bool readOnly = false,
                CallType call = wait )

  -     virtual IMMFileMedia&
          loadOnThread( const IString& filename,
                        bool readOnly = false )

  -     virtual IMMFileMedia&
          open( const IString& fileOrDevice = IString ( ),
                bool shareable = true,
                CallType call = wait )

  -     virtual IMMFileMedia&
          openOnThread( const IString& fileOrDevice = IString ( ),
                        bool shareable = true,
                        CallType call = wait )

  IMMPlayableDevice

  -     virtual ~IMMPlayableDevice()

  -     virtual IMMPlayableDevice&
          addCuePoint( const IMMTime& time,
                       CallType call = wait )

  -     virtual IMMPlayableDevice&
          cueForPlayback( CallType call = wait )

  -     unsigned long length(CallType call = wait) const

  -     virtual IMMPlayableDevice& pause(CallType call = wait)

  -     virtual IMMPlayableDevice&
          play( const IMMTime& from = IMMTime ( ),
                const IMMTime& to = IMMTime ( ),
                bool resumeIfPaused = true,
                CallType call = nowait )

  -     unsigned long position(CallType call = wait) const

  -     virtual IMMPlayableDevice&
          removeCuePoint( const IMMTime& time,
                          CallType call = wait )

  -     virtual IMMPlayableDevice&
          resume( bool resume = true,
                  CallType call = wait )

  -     virtual IMMPlayableDevice&
          seek( const IMMTime& to,
                CallType call = wait )

  -     virtual IMMPlayableDevice& seekToEnd(CallType call = wait)

  -     virtual IMMPlayableDevice&
          seekToStart( CallType call = wait )

  -     virtual IMMPlayableDevice&
          startPositionTracking( const IMMTime& timeInterval,
                                 CallType call = wait )

  -     virtual IMMPlayableDevice&
          stepFrame( unsigned long frames = 1,
                     bool forward = true,
                     CallType call = wait )

  -     virtual IMMPlayableDevice& stop(CallType call = wait)

  -     virtual IMMPlayableDevice&
          stopPositionTracking( CallType call = wait )

  INotifier

  -     virtual ~INotifier()

  -     virtual INotifier& disableNotification() = 0

  -     virtual INotifier&
          enableNotification( bool enable = true ) = 0

  -     INotifier()

  -     virtual bool isEnabledForNotification() const = 0

  -     virtual INotifier&
          notifyObservers( const INotificationEvent& event ) = 0

  -     virtual INotifier&
          notifyObserversAsync( const INotificationEvent& event )

  -     const IThreadId& threadId() const

  IStandardNotifier

  -     virtual ~IStandardNotifier()

  -     virtual IStandardNotifier& disableNotification()

  -     virtual IStandardNotifier&
          enableNotification( bool enable = true )

  -     virtual bool isEnabledForNotification() const

  -     IStandardNotifier(const IStandardNotifier& copy)

  -     IStandardNotifier()

  -     virtual INotifierAddress notifierAddress() const

  -     virtual IStandardNotifier&
          notifyObservers( const INotificationEvent& anEvent )

  -     virtual IStandardNotifier&
          notifyObserversAsync( const INotificationEvent& anEvent )

  -     IStandardNotifier&
          operator =( const IStandardNotifier& aStandardNotifier )

#### Inherited Public Data

  INotifier

  -     static INotificationId const allChangesId

  -     static INotificationId const deleteId

  IMMDevice

  -     static const unsigned long allDevices

  -     static const unsigned long ampMixer

  -     static const unsigned long animation

  -     static const unsigned long audioCD

  -     static const unsigned long audioTape

  -     static const unsigned long cdxa

  -     static INotificationId const commandNotifyId

  -     static INotificationId const cuePointId

  -     static const unsigned long dat

  -     static INotificationId const deviceEventId

  -     static const unsigned long digitalVideo

  -     static const unsigned long headphone

  -     static const unsigned long microphone

  -     static const unsigned long monitor

  -     static const unsigned long other

  -     static const unsigned long overlay

  -     static INotificationId const passDeviceId

  -     static INotificationId const positionChangeId

  -     static const unsigned long sequencer

  -     static const unsigned long speaker

  -     static const unsigned long videoDisc

  -     static const unsigned long videoTape

  -     static const unsigned long waveAudio

#### Inherited Protected Functions

  INotifier

  -     virtual INotifier&
          addObserver( IObserver& observer,
                       const IInterest& interest )

  -     virtual INotifier&
          notifyObservers( const INotificationId& id ) = 0

  -     virtual IObserverList&
          observerList( const IInterest* anInterest = 0 ) const = 0

  -     virtual INotifier& removeAllObservers() = 0

  -     virtual INotifier&
          removeObserver( IObserver& observer,
                          const IInterest& interest )

  -     virtual INotifier& removeObserver(IObserver& observer) = 0

  IStandardNotifier

  -     virtual IStandardNotifier&
          addObserver( IObserver& observer,
                       const IInterest& interest )

  -     virtual IStandardNotifier&
          notifyObservers( const INotificationId& nId )

  -     virtual IObserverList&
          observerList( const IInterest* anInterest = 0 ) const

  -     virtual IStandardNotifier& removeAllObservers()

  -     virtual IStandardNotifier&
          removeObserver( IObserver& observer )

  -     virtual IStandardNotifier&
          removeObserver( IObserver& observer,
                          const IInterest& interest )

  IMMDevice

  -     IMMMessageWindow& deviceWindow() const

  -     IMMDevice( unsigned long deviceIdentifier,
                   const IString& newAlias = IString ( ) )

  -     IMMDevice(const IString& fileOrDevice)

  -     virtual bool
          isOpenStringValid( const IString& deviceName ) const

  -     unsigned long
          itemCapability( unsigned long item,
                          CallType call ) const

  -     unsigned long
          itemStatus( unsigned long item,
                      unsigned long value = 0,
                      CallType call = wait ) const

  -     unsigned long lastError() const

  -     virtual bool
          mixerControlValues( unsigned long dwComponentType,
                              unsigned long dwControlType,
                              unsigned short* usDetails,
                              bool uniform = true,
                              unsigned long multipleItems = 0,
                              unsigned long hmx = NULL )

  -     virtual bool
          mixerControlValues( unsigned long dwComponentType,
                              unsigned long dwControlType,
                              unsigned long* ulDetails,
                              bool uniform = true,
                              unsigned long multipleItems = 0,
                              unsigned long hmx = NULL )

  -     IMMDeviceNotifyHandler* notificationHandler() const

  -     virtual IMMDevice&
          open( unsigned long instanceNumber,
                bool shareable = true,
                CallType call = nowait )

  -     virtual IMMDevice&
          openOnThread( unsigned long instanceNumber,
                        bool shareable = true )

  -     OpenStatus openStatus() const

  -     virtual IMMDevice&
          restoreDeviceSettings( bool newRecordMode = false )

  -     virtual IMMDevice& saveDeviceSettings()

  -     IMMDevice&
          sendCommand( unsigned short message,
                       unsigned long param1,
                       void* param2 )

  -     IString
          sendCommand( const IString& command,
                       unsigned short userParm )

  -     IString sendCommand(const IString& command)

  -     IMMDevice&
          sendCommand( unsigned short message,
                       unsigned long param1,
                       void* param2,
                       unsigned short userParm )

  -     IMMDevice& setLastError(unsigned long errorId)

  -     virtual bool
          setMixerControlValues( unsigned long dwComponentType,
                                 unsigned long dwControlType,
                                 unsigned long* ulDetails,
                                 bool uniform = true,
                                 unsigned long multipleItems = 0,
                                 unsigned long hmx = NULL )

  -     virtual bool
          setMixerControlValues( unsigned long dwComponentType,
                                 unsigned long dwControlType,
                                 unsigned short* usDetails,
                                 bool uniform = true,
                                 unsigned long multipleItems = 0,
                                 unsigned long hmx = NULL )

  -     IMMDevice&
          setNotificationHandler( IMMDeviceNotifyHandler* notifyHandler )

  -     IMMDevice& setOpenStatus(OpenStatus status)

  -     IMMDevice& setPassDeviceRequested(bool sawPassDevice)

  -     IMMDevice& setSystemMixerHandle(unsigned long hmx)

  -     IMMDevice& setUserParameter(unsigned short userParm = 0)

  -     unsigned long systemMixerHandle() const

  -     unsigned short userParameter() const

  -     bool wasPassDeviceRequested() const

  IMMFileMedia

  -     virtual IMMFileMedia& enableDataUpdate(bool update = true)

  -     IMMFileMedia( unsigned long deviceIdentifier,
                      const IString& newAlias = IString ( ) )

  -     IMMFileMedia( const IString& deviceName,
                      bool openNow,
                      unsigned long instance,
                      bool openShareable )

  -     virtual IMMFileMedia&
          open( unsigned long instanceNumber,
                bool shareable = true,
                CallType call = nowait )

  -     virtual IMMFileMedia&
          openOnThread( unsigned long instanceNumber,
                        bool shareable = true )

  -     virtual IMMFileMedia&
          restoreDeviceSettings( bool newRecordMode = false )

  -     virtual IMMFileMedia& saveDeviceSettings()

  IMMPlayableDevice

  -     IMMPlayableDevice( unsigned long deviceIdentifier,
                           const IString& newAlias = IString ( ) )

  -     IMMPlayableDevice( const IString& deviceOrFileName,
                           bool openNow = true,
                           unsigned long instance = 0,
                           bool openShareable = true )

  -     virtual IMMPlayableDevice&
          restoreDeviceSettings( bool newRecordMode = false )

  -     virtual IMMPlayableDevice& saveDeviceSettings()

#### Inherited Protected Data

  - None