Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## quicktime.std.qtcomponents
Class MovieImporter

    java.lang.Object
      |
      +--quicktime.QTObject
            |
            +--quicktime.std.comp.ComponentIdentifier
                  |
                  +--quicktime.std.comp.Component
                        |
                        +--quicktime.std.qtcomponents.MovieImporter

All Implemented Interfaces:
  quicktime.jdirect.InterfaceLib, quicktime.jdirect.PrimitivesLib, quicktime.jdirect.QuickTimeLib, com.apple.jdirect.SharedLibrary, quicktime.jdirect.SharedLibrary

public final class MovieImporter
extends Component
implements quicktime.jdirect.QuickTimeLib

Assists in importing movie data. The MovieImporter implements methods for a corresponding QuickTime ComponentInstance structure. Refer to Movie Data Exchange in QuickTime

Fields inherited from interface quicktime.jdirect.QuickTimeLib
`JDirect_MacOSX, libraryInstance, name`

Constructor Summary
`MovieImporter()` Opens the specified movie import component,'eat ', with any subType.
`MovieImporter(ComponentIdentifier comp)` Given a component identifier it opens the specified component.
`MovieImporter(DataRef dataRef, int flags)` This returns an appropriate instance of the MovieImporter for the DataRef object.
`MovieImporter(DataRef dataRef, int flags, java.lang.String fileExt)` This returns an appropriate instance of the MovieImporter for the DataRef object.
`MovieImporter(int subType)` Opens the specified movie import component,'eat ', with the given subType.

Method Summary
`boolean` | `doUserDialog(QTFile fileIn)` Allows an application to request that your component display its user dialog box.
`boolean` | `doUserDialog(QTHandleRef theData)` Specifies the use of.
`MovieImportInfo` | `fromDataRef(DataRef dataRef, Movie theMovie, Track targetTrack, int atTime, int inFlags)` Determines information revelant to the movie import component.
`MovieImportInfo` | `fromFile(QTFile fileIn, Movie theMovie, Track targetTrack, int atTime, int inFlags)` Allows the MovieToolbox to import data from a file using the movie import component.
`MovieImportInfo` | `fromHandle(QTHandleRef dataRef, Movie theMovie, Track targetTrack, int atTime, int inFlags)` Allows the MovieToolbox to import data from a handle using the movie import component.
`static MovieImporter` | `fromTrack(Track t)` Looks on the System scrap to find out if it can translate any of the track data into a movie.
`int` | `getAuxiliaryDataType()` Determines the data type for the component.
`int` | `getFileType()` Determines the file type for the component.
`AtomContainer` | `getImportSettingsFromAtomContainer()` Retrieves the current settings from the movie import component..
`int` | `getMediaType()` Determines the media type of the component.
`AtomContainer` | `getMIMETypeList()` Returns a list of MIME types supported by the movie import component.
`SampleDescription` | `getSampleDescription()` Determines the sample description of the component.
`void` | `removeProgressProc()` This method removes a MovieProgress callback for the MovieImporter.
`void` | `setAuxiliaryData(QTHandleRef data, int handleType)` Specifies the handle and its type for the component.
`void` | `setChunkSize(int chunkSize)` Specifies the size to allocate for the component.
`void` | `setDimensions(float width, float height)` Specifies the dimensions for the component.
`void` | `setDuration(int duration)` Specifies the duration for the component.
`void` | `setFromScrap(boolean fromScrap)` Specifies the scrap for the component.
`void` | `setImportSettingsFromAtomContainer(AtomContainer settings)` Sets the movie import componentŐs current configuration from the passed settings data.
`void` | `setMediaFile(AliasHandle alias)` Allows an application to specify a media file that is to receive the imported movie data.
`void` | `setOffsetAndLimit(int offset, int limit)` NO QT DOCUMENTATION.
`void` | `setProgressProc(MovieProgress mp)` This method establishes a MovieProgress object for the MovieImporter that will be called for you by the Movie Toolbox whenever it has to do a lengthy movie import process with this MovieImporter QuickTime::MovieImportSetProgressProc
`void` | `setSampleDescription(SampleDescription desc, int mediaType)` Specifies the SampleDescription and media type for the component.
`void` | `setSampleDuration(int duration, int scale)` Specifies the duration for the component.
`boolean` | `validate(QTFile fileIn)` Determines the validity of the file to be imported.
`boolean` | `validate(QTHandleRef theData)` Determines the validity of the data in the handle to be imported.

Methods inherited from class quicktime.std.comp.Component
`count`

Methods inherited from class quicktime.std.comp.ComponentIdentifier
`find, find, getInfo, toString`

Methods inherited from class quicktime.QTObject
`disposeQTObject, equals, ID`

Methods inherited from class java.lang.Object
`getClass, hashCode, notify, notifyAll, wait, wait, wait`

Constructor Detail

### MovieImporter

    public MovieImporter()
                  throws QTException

  Opens the specified movie import component,'eat ', with any subType.
  QuickTime::OpenADefaultComponent

  ### MovieImporter

      public MovieImporter(int subType)
                    throws QTException

    Opens the specified movie import component,'eat ', with the given subType.
    QuickTime::OpenADefaultComponent
  Parameters:
    `subType` - The movie import component sub type

### MovieImporter

    public MovieImporter(ComponentIdentifier comp)
                  throws QTException

  Given a component identifier it opens the specified component. The component type must be 'eat ' or an exception will be thrown as it is not a MovieImporter.
  QuickTime::OpenAComponent
Parameters:
  `comp` - the component identifier to open

### MovieImporter

    public MovieImporter(DataRef dataRef,
                         int flags)
                  throws QTException

  This returns an appropriate instance of the MovieImporter for the DataRef object.
  QuickTime::GetMovieImporterForDataRef()
Parameters:
  `dr` - the DataRef from which the movie importer is made
  `flags` - flags that control the kinds of importer components that are searched by this call

### MovieImporter

    public MovieImporter(DataRef dataRef,
                         int flags,
                         java.lang.String fileExt)
                  throws QTException

  This returns an appropriate instance of the MovieImporter for the DataRef object.
  QuickTime::GetMovieImporterForDataRef()
Parameters:
  `dr` - the DataRef from which the movie importer is made
  `flags` - flags that control the kinds of importer components that are searched by this call
  `fileExt` - file extension for the source of the data. This is useful to provide the importer as a guide for it to know about the data format.

Method Detail

### fromTrack

    public static MovieImporter fromTrack(Track t)
                                   throws StdQTException

  Looks on the System scrap to find out if it can translate any of the track data into a movie.
  QuickTime::IsScrapMovie()

  See Also:
    `Track.isScrapMovie()`

### fromFile

    public MovieImportInfo fromFile(QTFile fileIn,
                                    Movie theMovie,
                                    Track targetTrack,
                                    int atTime,
                                    int inFlags)
                             throws QTException

  Allows the MovieToolbox to import data from a file using the movie import component.
  QuickTime::MovieImportFile

  Parameters:
    `fileIn` - Specifies the source file to the importing data.
    `theMovie` - Specifies the movie to receive the data.
    `targetTrack` - Specifies the track to receive the data, if to be recipent, then inFlags use movieImportMustUseTrack.
    `atTime` - Specifies the start time of the movie time base to place the imported data.
    `inFlags` - Specifies the control flags governing the operation.
  Returns:
    The results pertinent to the operation.

### fromHandle

    public MovieImportInfo fromHandle(QTHandleRef dataRef,
                                      Movie theMovie,
                                      Track targetTrack,
                                      int atTime,
                                      int inFlags)
                               throws QTException

  Allows the MovieToolbox to import data from a handle using the movie import component.
  QuickTime::MovieImportHandle

  Parameters:
    `dataRef` - Specifies the handle to the importing data.
    `theMovie` - Specifies the movie to receive the data.
    `targetTrack` - Specifies the track to receive the data, if to be recipent, then inFlags use movieImportMustUseTrack.
    `atTime` - Specifies the start time of the movie time base to place the imported data.
    `inFlags` - Specifies the control flags governing the operation.
  Returns:
    The results pertinent to the operation.

### fromDataRef

    public MovieImportInfo fromDataRef(DataRef dataRef,
                                       Movie theMovie,
                                       Track targetTrack,
                                       int atTime,
                                       int inFlags)
                                throws QTException

  Determines information revelant to the movie import component. The info kept are the track used, time value added, and flags describing the operation.
  QuickTime::MovieImportDataRef
  Parameters:
    `dataRef` - Specifies the data reference.
    `theMovie` - Specifies the movie.
    `targetTrack` - Specifies the track to receive the data, if to be recipent, then inFlags use movieImportMustUseTrack.
    `atTime` - Specifies the start time of the movie time base.
    `inFlags` - Specifies the flags in for the operation.
  Returns:
    The results returned from the query operation.

### setSampleDuration

    public void setSampleDuration(int duration,
                                  int scale)
                           throws StdQTException

  Specifies the duration for the component.
  QuickTime::MovieImportSetSampleDuration

  Parameters:
    `duration` - Specifies the time base.
    `scale` - Specifies the time base scale.

### setSampleDescription

    public void setSampleDescription(SampleDescription desc,
                                     int mediaType)
                              throws StdQTException

  Specifies the SampleDescription and media type for the component.
  QuickTime::MovieImportSetSampleDescription

  Parameters:
    `desc` - Specifies the sample description.
    `mediaType` - Specifies the media type.

### setMediaFile

    public void setMediaFile(AliasHandle alias)
                      throws QTException

  Allows an application to specify a media file that is to receive the imported movie data.
  QuickTime::MovieImportSetMediaFile

  Parameters:
    `alias` - the media file that is to receive the imported movie data.

### setDimensions

    public void setDimensions(float width,
                              float height)
                       throws StdQTException

  Specifies the dimensions for the component.
  QuickTime::MovieImportSetDimensions

  Parameters:
    `width` - Specifies the width.
    `height` - Specifies the height.

### setChunkSize

    public void setChunkSize(int chunkSize)
                      throws StdQTException

  Specifies the size to allocate for the component.
  QuickTime::MovieImportSetChunkSize

  Parameters:
    `chunkSize` - Specifies the size.

### setProgressProc

    public void setProgressProc(MovieProgress mp)
                         throws StdQTException

  This method establishes a MovieProgress object for the MovieImporter that will be called for you by the Movie Toolbox whenever it has to do a lengthy movie import process with this MovieImporter
  QuickTime::MovieImportSetProgressProc

  Parameters:
    `mp` - the MovieProgress object, or null for no progress object

### removeProgressProc

    public void removeProgressProc()
                            throws StdQTException

  This method removes a MovieProgress callback for the MovieImporter.
  QuickTime::MovieImportSetProgressProc

  Parameters:
    `mp` - the MovieProgress object, or null for no progress object

### setAuxiliaryData

    public void setAuxiliaryData(QTHandleRef data,
                                 int handleType)
                          throws StdQTException

  Specifies the handle and its type for the component.
  QuickTime::MovieImportSetAuxiliaryData

  Parameters:
    `data` - Specifies the data handle.
    `handleType` - Specifies the handle type.

### setFromScrap

    public void setFromScrap(boolean fromScrap)
                      throws StdQTException

  Specifies the scrap for the component.
  QuickTime::MovieImportSetFromScrap

  Parameters:
    `fromScrap` - Specifies weather to use the scrap manager.

### doUserDialog

    public boolean doUserDialog(QTFile fileIn)
                         throws QTException

  Allows an application to request that your component display its user dialog box.
  QuickTime::MovieImportDoUserDialog

  Parameters:
    `fileIn` - Specifies the source file.
  Returns:
    True, if the user canceled the operation, false otherwise.

### doUserDialog

    public boolean doUserDialog(QTHandleRef theData)
                         throws QTException

  Specifies the use of.
  QuickTime::MovieImportDoUserDialog

  Parameters:
    `theData` - Specifies the data handle.
  Returns:
    True, if the user canceled the operation, false otherwise.

### setDuration

    public void setDuration(int duration)
                     throws StdQTException

  Specifies the duration for the component.
  QuickTime::MovieImportSetDuration

  Parameters:
    `duration` - Specifies the time base duration.

### getAuxiliaryDataType

    public int getAuxiliaryDataType()
                             throws StdQTException

  Determines the data type for the component.
  QuickTime::MovieImportGetAuxiliaryDataType

  Returns:
    The handle type.

### validate

    public boolean validate(QTFile fileIn)
                     throws QTException

  Determines the validity of the file to be imported.
  QuickTime::MovieImportValidate

  Parameters:
    `fileIn` - Specifies the source file.
  Returns:
    True, if the handle data or file from stream is valid, otherwise false.

### validate

    public boolean validate(QTHandleRef theData)
                     throws QTException

  Determines the validity of the data in the handle to be imported.
  QuickTime::MovieImportValidate

  Parameters:
    `theData` - Specifies the data handle.
  Returns:
    True, if the handle data or file from stream is valid, otherwise false.

### getFileType

    public int getFileType()
                    throws StdQTException

  Determines the file type for the component.
  QuickTime::MovieImportGetFileType

  Returns:
    The file type.

### getSampleDescription

    public SampleDescription getSampleDescription()
                                           throws StdQTException

  Determines the sample description of the component.
  QuickTime::MovieImportGetSampleDescription

  Returns:
    The sample description.

### getMediaType

    public int getMediaType()
                     throws StdQTException

  Determines the media type of the component.
  QuickTime::MovieImportGetSampleDescription

  Returns:
    The media type.

### getMIMETypeList

    public AtomContainer getMIMETypeList()
                                  throws StdQTException

  Returns a list of MIME types supported by the movie import component.
  QuickTime::MovieImportGetMIMETypeList

  Returns:
    an AtomContainer that contains a list of MIME types

### setOffsetAndLimit

    public void setOffsetAndLimit(int offset,
                                  int limit)
                           throws StdQTException

  NO QT DOCUMENTATION.
  QuickTime::MovieImportSetOffsetAndLimit

  Parameters:
    `offset` - the offset within the source data from which to start importing
    `limit` - how many bytes from the offset to import.

### setImportSettingsFromAtomContainer

    public void setImportSettingsFromAtomContainer(AtomContainer settings)
                                            throws StdQTException

  Sets the movie import componentŐs current configuration from the passed settings data.
  QuickTime::MovieImportSetSettingsFromAtomContainer

  Parameters:
    `Contains` - a QT atom container reference to the settings.

### getImportSettingsFromAtomContainer

    public AtomContainer getImportSettingsFromAtomContainer()
                                                     throws StdQTException

  Retrieves the current settings from the movie import component..
  QuickTime::MovieImportGetSettingsAsAtomContainer

  Returns:
    an AtomContainer with the current settings.

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD