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.image
Class GraphicsExporter

    java.lang.Object
      |
      +--quicktime.QTObject
            |
            +--quicktime.std.comp.ComponentIdentifier
                  |
                  +--quicktime.std.comp.Component
                        |
                        +--quicktime.std.image.GraphicsExporter

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

public final class GraphicsExporter
extends Component
implements quicktime.jdirect.QuickTimeLib, Errors

Graphics exporter components provide a standard interface for exporting graphics to image files in a variety of formats. QuickTime selects a graphic exporter component based on the desired output format, such as GIF or PNG. Different image formats support a wide range of configurable features, such as depth, resolution and compression quality. Assists in managing still images. Allows display and manipulation of various types of image data. This is regardless of file format or compression used in the document. The QIF(QuickTime File Format, 'qtif') accepts gif, jfif, pict, photoshop, and sgi.rgb files. This class implements methods for a corresponding QuickTime ComponentInstance structure. refer to GraphicsImportComponent in QuickTime The base exporter communicates with data handler components to negotiate access to image file data. If necessary, it calls the Image Compression Manager to perform compression operations. There are three modes that format-specific exporters can operate in: - Transcode. Data is transferred from one image file to another without decompressing and recompressing. (The data may be modified along the way, if appropriate.) - Using a Compressor. The graphics exporter provides an atom container identifying which compressor to use, and any settings to be passed to that compressor. - Standalone Export. The graphics exporter component does all the work itself, without using an image compressor.

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

Fields inherited from interface quicktime.Errors
`AAPNotCreatedErr, AAPNotFoundErr, abortErr, addResFailed, afpAccessDenied, afpObjectTypeErr, ASDBadForkErr, ASDBadHeaderErr, ASDEntryNotFoundErr, atomIndexInvalidErr, atomsNotOfSameTypeErr, auxiliaryExportDataUnavailable, badCallOrderErr, badChannel, badComponentInstance, badComponentSelector, badComponentType, badControllerHeight, badDataRefIndex, badDepthErr, badEditIndex, badEditList, badFileFormat, badFormat, badImageDescription, badPublicMovieAtom, badSGChannel, badTrackIndex, badUnitErr, bdNamErr, buffersTooSmall, callNotSupportedByNodeErr, cannotBeLeafAtomErr, cannotFindAtomErr, cannotMoveAttachedController, cannotSetWidthOfAttachedController, cantCreateSingleForkFile, cantDoThatInCurrentMode, cantEnableTrack, cantFindHandler, cantOpenHandler, cantPutPublicMovieAtom, cantReceiveFromSynthesizerOSErr, cantSendToSynthesizerOSErr, cDepthErrInvalid, channelBusy, channelNotBusy, closErr, codecAbortErr, codecBadDataErr, codecCantQueueErr, codecCantWhenErr, codecConditionErr, codecDataVersErr, codecDisabledErr, codecDroppedFrameErr, codecErr, codecExtensionNotFoundErr, codecImageBufErr, codecNeedAccessKeyErr, codecNeedToFlushChainErr, codecNoMemoryPleaseWaitErr, codecNothingToBlitErr, codecOffscreenFailedErr, codecOpenErr, codecParameterDialogConfirm, codecScreenBufErr, codecSizeErr, codecSpoolErr, codecUnimpErr, codecWouldOffscreenErr, componentDllEntryNotFoundErr, componentDllLoadErr, componentDontRegister, componentNotCaptured, constraintReachedErr, controlErr, controllerBoundsNotExact, controllerHasFixedHeight, couldNotResolveDataRef, couldNotUseAnExistingSample, couldntGetRequiredComponent, dataAlreadyClosed, dataAlreadyOpenForWrite, dataNoDataRef, dataNotOpenForRead, dataNotOpenForWrite, destPortErr, deviceCantMeetRequest, digiUnimpErr, dInstErr, dirFulErr, dirNFErr, dRemovErr, dskFulErr, dupFNErr, duplicateAtomTypeAndIDErr, duplicateHandlerErr, editingNotAllowed, emptyPathErr, endOfDataReached, eofErr, fBsyErr, featureUnsupported, fileOffsetTooBigErr, fnfErr, grabTimeComplete, gWorldsNotSameDepthAndSizeErr, handlerNotFoundErr, illegalChannelOSErr, illegalControllerOSErr, illegalInstrumentOSErr, illegalKnobOSErr, illegalKnobValueOSErr, illegalNoteChannelOSErr, illegalPartOSErr, illegalVoiceAllocationOSErr, internalComponentErr, internalQuickTimeError, invalidAtomContainerErr, invalidAtomErr, invalidAtomTypeErr, invalidChunkCache, invalidChunkNum, invalidComponentID, invalidDataRef, invalidDataRefContainer, invalidDuration, invalidEditState, invalidHandler, invalidHotSpotIDErr, invalidImageIndexErr, invalidMedia, invalidMovie, invalidNodeFormatErr, invalidNodeIDErr, invalidRect, invalidSampleDescIndex, invalidSampleDescription, invalidSampleNum, invalidSampleTable, invalidSpriteIDErr, invalidSpriteIndexErr, invalidSpritePropertyErr, invalidSpriteWorldPropertyErr, invalidTime, invalidTrack, invalidViewStateErr, ioErr, kIllegalInstrumentErr, kInvalidPartNumberErr, kQ3ErrorAcceleratorAlreadySet, kQ3ErrorAccessRestricted, kQ3ErrorAlreadyInitialized, kQ3ErrorAlreadyRendering, kQ3ErrorAttributeInvalidType, kQ3ErrorAttributeNotContained, kQ3ErrorBadDrawContext, kQ3ErrorBadDrawContextFlag, kQ3ErrorBadDrawContextType, kQ3ErrorBadStringType, kQ3ErrorBeginWriteAlreadyCalled, kQ3ErrorBeginWriteNotCalled, kQ3ErrorBoundingLoopFailed, kQ3ErrorBoundsNotStarted, kQ3ErrorCameraNotSet, kQ3ErrorController, kQ3ErrorDataNotAvailable, kQ3ErrorDegenerateGeometry, kQ3ErrorDisplayNotSet, kQ3ErrorDrawContextNotSet, kQ3ErrorEndOfContainer, kQ3ErrorEndOfFile, kQ3ErrorEndWriteNotCalled, kQ3ErrorExtensionError, kQ3ErrorFileAlreadyOpen, kQ3ErrorFileCancelled, kQ3ErrorFileIsOpen, kQ3ErrorFileModeRestriction, kQ3ErrorFileNotOpen, kQ3ErrorFileVersionExists, kQ3ErrorGeometryInsufficientNumberOfPoints, kQ3ErrorImmediateModeUnderflow, kQ3ErrorInternalError, kQ3ErrorInvalidCameraValues, kQ3ErrorInvalidData, kQ3ErrorInvalidGeometryType, kQ3ErrorInvalidHexString, kQ3ErrorInvalidMetafile, kQ3ErrorInvalidMetafileLabel, kQ3ErrorInvalidMetafileObject, kQ3ErrorInvalidMetafilePrimitive, kQ3ErrorInvalidMetafileSubObject, kQ3ErrorInvalidObject, kQ3ErrorInvalidObjectClass, kQ3ErrorInvalidObjectForGroup, kQ3ErrorInvalidObjectForPosition, kQ3ErrorInvalidObjectName, kQ3ErrorInvalidObjectType, kQ3ErrorInvalidParameter, kQ3ErrorInvalidPositionForGroup, kQ3ErrorInvalidSubObjectForObject, kQ3ErrorLastFatalError, kQ3ErrorMacintoshError, kQ3ErrorMemoryLeak, kQ3ErrorMetaHandlerRequired, kQ3ErrorNeedRequiredMethods, kQ3ErrorNoBeginGroup, kQ3ErrorNoExtensionsFolder, kQ3ErrorNonInvertibleMatrix, kQ3ErrorNonUniqueLabel, kQ3ErrorNoRecovery, kQ3ErrorNoStorageSetForFile, kQ3ErrorNoSubClassType, kQ3ErrorNothingToPop, kQ3ErrorNotInitialized, kQ3ErrorNotSupported, kQ3ErrorNULLParameter, kQ3ErrorObjectClassInUse, kQ3ErrorOutOfMemory, kQ3ErrorParameterOutOfRange, kQ3ErrorPickingLoopFailed, kQ3ErrorPickingNotStarted, kQ3ErrorPrivateExtensionError, kQ3ErrorReadLessThanSize, kQ3ErrorReadMoreThanSize, kQ3ErrorReadStateInactive, kQ3ErrorRegistrationFailed, kQ3ErrorRendererNotSet, kQ3ErrorRenderingIsActive, kQ3ErrorRenderingLoopFailed, kQ3ErrorRenderingNotStarted, kQ3ErrorScaleOfZero, kQ3ErrorSizeMismatch, kQ3ErrorSizeNotLongAligned, kQ3ErrorStartGroupRange, kQ3ErrorStateUnavailable, kQ3ErrorStorageAlreadyOpen, kQ3ErrorStorageInUse, kQ3ErrorStorageIsOpen, kQ3ErrorStorageNotOpen, kQ3ErrorStringExceedsMaximumLength, kQ3ErrorTracker, kQ3ErrorTypeAlreadyExistsAndHasObjectInstances, kQ3ErrorTypeAlreadyExistsAndHasSubclasses, kQ3ErrorTypeAlreadyExistsAndOtherClassesDependOnIt, kQ3ErrorUnimplemented, kQ3ErrorUnixError, kQ3ErrorUnknownElementType, kQ3ErrorUnknownObject, kQ3ErrorUnknownStudioType, kQ3ErrorUnmatchedEndGroup, kQ3ErrorUnresolvableReference, kQ3ErrorUnsupportedFunctionality, kQ3ErrorUnsupportedGeometryType, kQ3ErrorUnsupportedPixelDepth, kQ3ErrorValueExceedsMaximumSize, kQ3ErrorVector3DNotUnitLength, kQ3ErrorVector3DZeroLength, kQ3ErrorViewIsStarted, kQ3ErrorViewNotStarted, kQ3ErrorWin32Error, kQ3ErrorWriteStateInactive, kQ3ErrorWritingLoopFailed, kQ3ErrorWroteLessThanSize, kQ3ErrorWroteMoreThanSize, kQ3ErrorX11Error, kQ3NoticeBrightnessGreaterThanOne, kQ3NoticeDataAlreadyEmpty, kQ3NoticeDrawContextNotSetUsingInternalDefaults, kQ3NoticeFileAliasWasChanged, kQ3NoticeFileCancelled, kQ3NoticeInvalidAttenuationTypeUsingInternalDefaults, kQ3NoticeMeshEdgeIsNotBoundary, kQ3NoticeMeshEdgeVertexDoNotCorrespond, kQ3NoticeMeshInvalidVertexFacePair, kQ3NoticeMeshVertexHasNoComponent, kQ3NoticeMethodNotSupported, kQ3NoticeObjectAlreadySet, kQ3NoticeParameterOutOfRange, kQ3NoticeScaleContainsZeroEntries, kQ3NoticeSystemAlreadyInitialized, kQ3NoticeViewSyncCalledAgain, kQ3WarningExtensionNotLoading, kQ3WarningFilePointerRedefined, kQ3WarningFilePointerResolutionFailed, kQ3WarningFunctionalityNotSupported, kQ3WarningInconsistentData, kQ3WarningInternalException, kQ3WarningInvalidHexString, kQ3WarningInvalidMetafileObject, kQ3WarningInvalidObjectInGroupMetafile, kQ3WarningInvalidPaneDimensions, kQ3WarningInvalidSubObjectForObject, kQ3WarningInvalidTableOfContents, kQ3WarningLowMemory, kQ3WarningNoAttachMethod, kQ3WarningNone, kQ3WarningNonInvertibleMatrix, kQ3WarningNoObjectSupportForDrawMethod, kQ3WarningNoObjectSupportForDuplicateMethod, kQ3WarningNoObjectSupportForReadMethod, kQ3WarningNoObjectSupportForWriteMethod, kQ3WarningParameterOutOfRange, kQ3WarningPickParamOutside, kQ3WarningPossibleMemoryLeak, kQ3WarningQuaternionEntriesAreZero, kQ3WarningReadLessThanSize, kQ3WarningScaleContainsNegativeEntries, kQ3WarningScaleEntriesAllZero, kQ3WarningStringExceedsMaximumLength, kQ3WarningTypeAlreadyRegistered, kQ3WarningTypeAndMethodAlreadyDefined, kQ3WarningTypeHasNotBeenRegistered, kQ3WarningTypeIsOutOfRange, kQ3WarningTypeNewerVersionAlreadyRegistered, kQ3WarningTypeSameVersionAlreadyRegistered, kQ3WarningUnknownElementType, kQ3WarningUnknownObject, kQ3WarningUnmatchedBeginGroup, kQ3WarningUnmatchedEndGroup, kQ3WarningUnresolvableReference, kQ3WarningVector3DNotUnitLength, kQ3WarningViewTraversalInProgress, kUnspecifiedErr, limitReachedErr, lockPortBitsBadPortErr, lockPortBitsBadSurfaceErr, lockPortBitsSurfaceLostErr, lockPortBitsWindowClippedErr, lockPortBitsWindowMovedErr, lockPortBitsWindowResizedErr, matrixErr, maxSizeToGrowTooSmall, mediaTypesDontMatch, memFullErr, midiManagerAbsentOSErr, missingRequiredParameterErr, movieTextNotFoundErr, movieToolboxUninitialized, noCodecErr, noDataHandler, noDefaultDataRef, noDeviceForChannel, noDMAErr, noErr, noExportProcAvailableErr, noGlobalsErr, noMediaHandler, noMemoryNodeFailedInitialize, noMoreKeyColorsErr, noMoreRealTime, noMovieFound, nonMatchingEditState, noPathMappingErr, noPortErr, noRecordOfApp, noSoundTrackInMovieErr, noSourceTreeFoundErr, notAllowedToSaveMovieErr, notAQTVRMovieErr, noteChannelNotAllocatedOSErr, notEnoughBufferSpace, notEnoughDataErr, notEnoughDiskSpaceToGrab, notEnoughHardwareErr, notEnoughMemoryToGrab, notExactMatrixErr, notExactSizeErr, notImplementedMusicOSErr, notLeafAtomErr, noVideoTrackInMovieErr, nsvErr, openErr, paramErr, pathNotVerifiedErr, pathTooLongErr, permErr, pictIsOpenErr, progressProcAborted, propertyNotSupportedByNodeErr, qfcbNotCreatedErr, qfcbNotFoundErr, qtActionNotHandledErr, qtmlDllEntryNotFoundErr, qtmlDllLoadErr, qtmlUninitialized, qtNetworkAlreadyAllocatedErr, qtParamErr, qtvrLibraryLoadErr, qtvrUninitialized, queueFull, readErr, resFNotFound, resNotFound, resProblem, rgnTooBigErr, rmvResFailed, samplesAlreadyInMediaErr, scTypeNotFoundErr, selectorNotSupportedByNodeErr, seqGrabInfoNotAvailable, settingNotSupportedByNodeErr, siBadDeviceName, siBadRefNum, siBadSoundInDevice, siDeviceBusyErr, siHardDriveTooSlow, siInputDeviceErr, siInvalidCompression, siInvalidSampleRate, siInvalidSampleSize, siNoBufferSpecified, siNoSoundInHardware, siUnknownInfoType, siUnknownQuality, soundSupportNotAvailableErr, sourceNotFoundErr, staleEditState, statusErr, streamingNodeNotReadyErr, synthesizerNotRespondingOSErr, synthesizerOSErr, timeNotInMedia, timeNotInTrack, timeNotInViewErr, trackIDNotFound, trackNotInMovie, tuneParseOSErr, tunePlayerFullOSErr, unitEmptyErr, unknownFormatErr, unresolvedComponentDLLErr, unsupportedAuxiliaryImportData, unsupportedOSErr, unsupportedProcessorErr, urlDataHFTPBadNameListErr, urlDataHFTPBadPasswordErr, urlDataHFTPBadUserErr, urlDataHFTPDataConnectionErr, urlDataHFTPFilenameErr, urlDataHFTPNeedPasswordErr, urlDataHFTPNoDirectoryErr, urlDataHFTPNoNetDriverErr, urlDataHFTPNoPasswordErr, urlDataHFTPPermissionsErr, urlDataHFTPProtocolErr, urlDataHFTPQuotaErr, urlDataHFTPServerDisconnectedErr, urlDataHFTPServerErr, urlDataHFTPShutdownErr, urlDataHFTPURLErr, urlDataHHTTPNoNetDriverErr, urlDataHHTTPProtocolErr, urlDataHHTTPRedirectErr, urlDataHHTTPURLErr, userCanceledErr, userDataItemNotFound, validInstancesExist, videoOutputInUseErr, vLckdErr, wackBadFileErr, wackBadMetaDataErr, wackForkNotFoundErr, wfFileNotFound, wPrErr, writErr`

Constructor Summary
`GraphicsExporter(int subType)` Opens the specified graphics export component,'grex', with the given subType.

Method Summary
`boolean` | `canTranscode()` Format-specific exporters may delegate this call; the base graphics exporter's implementation gives a reply of false .Use this call to ask a graphics exporter whether it can transcode the current input with the current settings.
`GECompressorInfo` | `canUseCompressor()` The base graphics exporter makes this call of the format-specific graphics exporter to ask whether the current export operation should be done by using an image compressor.
`int` | `doExport()` You can use the GraphicsExportDoExport function to perform an export operation.
`void` | `doStandaloneExport()` If both CanTranscode and CanUseCompressor reply false , the base graphics exporter makes this call of the format-specific exporter to perform the call.
`void` | `doTranscode()` The base graphics exporter makes this call of the format-specific graphics exporter to perform a transcoding export.
`ImageDescription` | `doUseCompressor(AtomContainer ac)` The base graphics exporter makes this call of the format-specific graphics exporter to ask whether the current export operation should be done by using an image compressor.
`void` | `drawInputImage(QDGraphics gw, QDRect srcRect, QDRect destRect)` Used by format-specific graphics exporters, especially when doing standalone export: Draws a rectangular portion of the input image.
`int` | `getCompressionMethod()` Defines the compression method to use.
`int` | `getCompressionQuality()` Defines the compression quality to use.
`java.lang.String` | `getDefaultFileCreator()` Returns file creator for the new image file format.
`java.lang.String` | `getDefaultFileNameExtension()` Returns the suggested file name extension.
`java.lang.String` | `getDefaultFileType()` Returns the default file Type for the new image file format.
`int` | `getDepth()` Defines the depth to use.
`boolean` | `getDontRecompress()` Requests that the original compressed data not be decompressed and recompressed, but be copied (possibly with modifications) through to the output file.
`int` | `getHorizontalResolution()` Gets the resolution to saved and stored.
`DataRef` | `getInputDataReference()` Gets the DataRef of the source for input images to graphics export component.
`int` | `getInputDataSize()` Used by format-specific graphics exporters when transcoding: Returns the number of bytes of original image data that can be read.
`QTFile` | `getInputFile()` Gets the file that is the source for input images to graphics export component.
`GraphicsImporter` | `getInputGraphicsImporter()` Determines the GraphicsImporter that is the source for input images to graphics export component.
`QDGraphics` | `getInputGWorld()` Determines the QDGraphics that is the source for input images to graphics export component.
`QTHandle` | `getInputHandle()` Determines the data reference that is the source for input images to graphics export component.
`int` | `getInputImageDepth()` Used by format-specific graphics exporters, especially when doing standalone export: Returns the depth of the input image.
`ImageDescription` | `getInputImageDescription()` Used by format-specific graphics exporters, especially when doing standalone export: Returns the number of bytes of original image data that can be read.
`QDRect` | `getInputImageDimensions()` Used by format-specific graphics exporters, especially when doing standalone export: Returns the dimensions of the input image.
`int` | `getInputLimit()` Only applicable when the input is a data reference, file, handle or ptr: Specifies the portion of an input data reference, file, handle or pointer that a graphics exporter is permitted to read.
`int` | `getInputOffset()` Only applicable when the input is a data reference, file, handle or ptr: Specifies the portion of an input data reference, file, handle or pointer that a graphics exporter is permitted to read.
`Pict` | `getInputPicture()` Determines the Pict that is the source for input images to graphics export component.
`PixMap` | `getInputPixmap()` Determines the QDGraphics that is the source for input images to graphics export component.
`QTPointerRef` | `getInputPtr()` Determines the data reference that is the source for input images to graphics export component.
`int` | `getInterlaceStyle()` Returns the interlace style.
`UserData` | `getMetaData()` Returns supplemental data, such as textual copyright information.
`AtomContainer` | `getMIMETypeList()` Returns MIME types and other information about the graphics format.
`DataRef` | `getOutputDataReference()` Gets the DataRef of the destination for output images.
`QTFile` | `getOutputFile()` Gets the file that is the destination for output images.
`int` | `getOutputFileCreator()` Gets the Output file Creator.
`int` | `getOutputFileType()` Gets the Output file type.
`QTHandle` | `getOutputHandle()` Determines the data reference that is the destination for output images.
`int` | `getOutputMaxSize()` Gets the output starting offset and maximum size limit.
`int` | `getOutputOffset()` Gets the output starting offset and maximum size limit.
`boolean` | `getOutputTruncateFile()` Gets the output starting offset and maximum size limit.
`AtomContainer` | `getSettingsAsAtomContainer()` These functions are used for obtaining graphics exporter settings and displaying a settings dialog box.
`QTHandle` | `getSettingsAsText()` This function is used for obtaining graphics exporter settings and displaying a settings dialog box.
`int` | `getTargetDataSize()` Specifies a desired maximum data size and asks for a quality that does not exceed that size.
`int` | `getVerticalResolution()` Defines the compression quality to use.
`byte[]` | `GraphicsExportReadOutputData(int dataOffset, int dataSize)` This function is used by format-specific graphics exporters to write output data.
`void` | `GraphicsExportWriteOutputData(byte[] data, int dataSize)` This function is used by format-specific graphics exporters to write output data.
`boolean` | `mayExporterReadInputData()` Used by format-specific graphics exporters when transcoding: Asks whether the image source is in a form that can be read.
`byte[]` | `readInputData(int dataOffset, int dataSize)` Used by format-specific graphics exporters when transcoding: Returns the number of bytes of original image data that can be read.
`void` | `requestSettings()` These functions are used for obtaining graphics exporter settings and displaying a settings dialog box.
`void` | `setCompressionMethod(int compressionMethod)` Defines the compression method to use.
`void` | `setCompressionQuality(int spatialQuality)` Defines the compression quality.
`void` | `setDepth(int depth)` Defines the depth to use.
`void` | `setDontRecompress(boolean dontRecompress)` Requests that the original compressed data not be decompressed and recompressed, but be copied (possibly with modifications) through to the output file.
`void` | `setInputDataReference(DataRef dataRef, ImageDescription desc)` Sets the specified DataRef as the source for input images to graphics export component.
`void` | `setInputFile(QTFile theFile, ImageDescription desc)` Sets the specified QTFile as the source for input images to graphics export component.
`void` | `setInputGraphicsImporter(GraphicsImporter grip)` Sets the GraphicsImporter as the source for input images to graphics export component.
`void` | `setInputGWorld(QDGraphics gworld)` Sets the QDGraphics as the source for input images to graphics export component.
`void` | `setInputHandle(QTHandle h, ImageDescription desc)` Sets the data handle as the source for input images to graphics export component.
`void` | `setInputOffsetAndLimit(int offset, int limit)` Only applicable when the input is a data reference, file, handle or ptr: Specifies the portion of an input data reference, file, handle or pointer that a graphics exporter is permitted to read.
`void` | `setInputPicture(Pict picture)` Sets the Pict as the source for input images to graphics export component.
`void` | `setInputPixmap(QDGraphics gworld)` Sets the QDGraphics as the source for input images to graphics export component.
`void` | `setInputPtr(QTPointerRef p, ImageDescription desc)` Sets the data handle reference as the source for input images to graphics export component.
`void` | `setInterlaceStyle(int interlaceStyle)` Defines the interlace style.
`void` | `setMetaData(UserData userData)` Defines supplemental data, such as textual copyright information.
`void` | `setOutputDataReference(DataRef dataRef)` Used to specify destination for output images.
`void` | `setOutputFile(QTFile theFile)` Sets the specified QTFile as the destination for output images.
`void` | `setOutputFileTypeAndCreator(int fileType, int fileCreator)` Specifies the output starting offset and maximum size limit.
`void` | `setOutputHandle(QTHandleRef h)` Sets the data handle as the destination for output images.
`void` | `setOutputOffsetAndMaxSize(int offset, int maxSize, boolean truncateFile)` Specifies the output starting offset and maximum size limit.
`void` | `setResolution(int horizontalResolution, int verticalResolution)` Defines the resolution to save and store.
`void` | `setSettingsFromAtomContainer(AtomContainer qtAtomContainer)` These functions are used for obtaining graphics exporter settings and displaying a settings dialog box.
`void` | `setTargetDataSize(int targetDataSize)` Defines a desired maximum data size and asks for a quality that does not exceed that size.

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

### GraphicsExporter

    public GraphicsExporter(int subType)
                     throws QTException

  Opens the specified graphics export component,'grex', with the given subType.
  QuickTime::OpenADefaultComponent
Parameters:
  `subType` - The graphics export component sub type

Method Detail

### doExport

    public int doExport()
                 throws StdQTException

  You can use the GraphicsExportDoExport function to perform an export operation. Before calling GraphicsExportDoExport , you must specify an input image (using a GraphicsExportSetInput call) and a destination for the output image file (using a GraphicsExportSetOutput call).
  QuickTime::GraphicsExportDoExport

  Returns:
    the actual size of the image exported

### doStandaloneExport

    public void doStandaloneExport()
                            throws QTException

  If both CanTranscode and CanUseCompressor reply false , the base graphics exporter makes this call of the format-specific exporter to perform the call.
  QuickTime::GraphicsExportDoStandaloneExport

### setInputDataReference

    public void setInputDataReference(DataRef dataRef,
                                      ImageDescription desc)
                               throws QTException

  Sets the specified DataRef as the source for input images to graphics export component.
  QuickTime::GraphicsExportSetInputDataReference

  Parameters:
    `dataRef` - The DataRef for input images to export component sub type
    `desc` - the ImageDescription handle

### getInputDataReference

    public DataRef getInputDataReference()
                                  throws QTException

  Gets the DataRef of the source for input images to graphics export component.
  QuickTime::GraphicsExportGetInputDataReference

  Returns:
    a DataRef object specifying the source of input images to the Graphics exporter.
  See Also:
    `QTHandle.fromGraphicsExporterInput(quicktime.std.image.GraphicsExporter)`

### setInputFile

    public void setInputFile(QTFile theFile,
                             ImageDescription desc)
                      throws QTException

  Sets the specified QTFile as the source for input images to graphics export component.
  QuickTime::GraphicsExportSetInputFile

  Parameters:
    `theFile` - The QTFile that points to the source of input images to export component
    `desc` - the ImageDescription handle

### getInputFile

    public QTFile getInputFile()
                        throws QTException

  Gets the file that is the source for input images to graphics export component.
  QuickTime::GraphicsExportGetInputFile

  Returns:
    a QTFile object that has the source of input images to the Graphics exporter.
  See Also:
    `quicktime.io.QTFile.fromGraphicsExporterInput`

### setInputHandle

    public void setInputHandle(QTHandle h,
                               ImageDescription desc)
                        throws QTException

  Sets the data handle as the source for input images to graphics export component.
  QuickTime::GraphicsExportSetInputHandle

  Parameters:
    `h` - The data handle that points to the source of input images to export component
    `desc` - the ImageDescription handle

### getInputHandle

    public QTHandle getInputHandle()
                            throws QTException

  Determines the data reference that is the source for input images to graphics export component.
  QuickTime::GraphicsExportGetInputHandle

  Returns:
    a QTHandle object that has the source of input images to the Graphics exporter.
  See Also:
    `quicktime.std.util.QTHandle.fromGraphicsExporter`

### setInputPtr

    public void setInputPtr(QTPointerRef p,
                            ImageDescription desc)
                     throws QTException

  Sets the data handle reference as the source for input images to graphics export component.
  QuickTime::GraphicsExportSetInputPtr

  Parameters:
    `p` - The pointer that points to the source of input images of export component
    `desc` - the ImageDescription handle

### getInputPtr

    public QTPointerRef getInputPtr()
                             throws QTException

  Determines the data reference that is the source for input images to graphics export component.
  QuickTime::GraphicsExportGetInputPtr

  Returns:
    a QTPointerRef object that has the source of input images to the Graphics exporter.

### setInputGraphicsImporter

    public void setInputGraphicsImporter(GraphicsImporter grip)
                                  throws QTException

  Sets the GraphicsImporter as the source for input images to graphics export component.
  QuickTime::GraphicsExportSetInputGraphicsImporter

  Parameters:
    `grip` - The GraphicsImporter that points to the source of input images to export component

### getInputGraphicsImporter

    public GraphicsImporter getInputGraphicsImporter()
                                              throws QTException

  Determines the GraphicsImporter that is the source for input images to graphics export component.
  QuickTime::GraphicsExportGetInputGraphicsImporter

  Returns:
    a GraphicsImporter object that has the source of input images to the Graphics exporter.

### setInputPicture

    public void setInputPicture(Pict picture)
                         throws QTException

  Sets the Pict as the source for input images to graphics export component.
  QuickTime::GraphicsExportSetInputPicture

  Parameters:
    `picture` - The Pict that points to the source of input images to export component

### getInputPicture

    public Pict getInputPicture()
                         throws QTException

  Determines the Pict that is the source for input images to graphics export component.
  QuickTime::GraphicsExportGetInputPicture

  Returns:
    a Pict object that has the source of input images to the Graphics exporter.
  See Also:
    `quicktime.std.qd.Pict.fromGraphicsExporter`

### setInputGWorld

    public void setInputGWorld(QDGraphics gworld)
                        throws QTException

  Sets the QDGraphics as the source for input images to graphics export component.
  QuickTime::GraphicsExportSetInputGWorld

  Parameters:
    `gworld` - The QDGraphics that points to the source of input images to export component

### getInputGWorld

    public QDGraphics getInputGWorld()
                              throws QTException

  Determines the QDGraphics that is the source for input images to graphics export component.
  QuickTime::GraphicsExportGetInputGWorld

  Returns:
    a QDGraphics object that has the source of input images to the Graphics exporter.
  See Also:
    `quicktime.qd.QDGraphics.fromGraphicsExporter`

### setInputPixmap

    public void setInputPixmap(QDGraphics gworld)
                        throws StdQTException

  Sets the QDGraphics as the source for input images to graphics export component.
  QuickTime::GraphicsExportSetInputPixmap

  Parameters:
    `gworld` - The QDGraphics that points to the source of input images to export component

### getInputPixmap

    public PixMap getInputPixmap()
                          throws QTException

  Determines the QDGraphics that is the source for input images to graphics export component.
  QuickTime::GraphicsExportGetInputPixmap

  Returns:
    a QDGraphics object that has the source of input images to the Graphics exporter.
  See Also:
    `quicktime.qd.QDGraphics.fromGraphicsExporter`

### setOutputDataReference

    public void setOutputDataReference(DataRef dataRef)
                                throws QTException

  Used to specify destination for output images. Sets the specified DataRef as the destination for output images.
  QuickTime::GraphicsExportSetOutputDataReference

  Parameters:
    `dataRef` - The DataRef for output images to export

### getOutputDataReference

    public DataRef getOutputDataReference()
                                   throws QTException

  Gets the DataRef of the destination for output images.
  QuickTime::GraphicsExportGetOutputDataReference

  Returns:
    a DataRef object specifying the destination for output images.
  See Also:
    `QTHandle.fromGraphicsExporterOutput(quicktime.std.image.GraphicsExporter)`

### setOutputFile

    public void setOutputFile(QTFile theFile)
                       throws QTException

  Sets the specified QTFile as the destination for output images.
  QuickTime::GraphicsExportSetOutputFile

  Parameters:
    `theFile` - The QTFile that points to destination for output images.

### getOutputFile

    public QTFile getOutputFile()
                         throws QTException

  Gets the file that is the destination for output images.
  QuickTime::GraphicsExportGetOutputFile

  Returns:
    a QTFile object that has the destination for output images.
  See Also:
    `quicktime.io.QTFile.fromGraphicsExporter`

### setOutputHandle

    public void setOutputHandle(QTHandleRef h)
                         throws QTException

  Sets the data handle as the destination for output images.
  QuickTime::GraphicsExportSetOutputHandle

  Parameters:
    `h` - The data handle that points to the destination for output images.

### getOutputHandle

    public QTHandle getOutputHandle()
                             throws QTException

  Determines the data reference that is the destination for output images.
  QuickTime::GraphicsExportGetOutputHandle

  Returns:
    a QTHandle object that has the destination for output images.
  See Also:
    `quicktime.std.util.QTHandle.fromGraphicsExporter`

### setOutputOffsetAndMaxSize

    public void setOutputOffsetAndMaxSize(int offset,
                                          int maxSize,
                                          boolean truncateFile)
                                   throws QTException

  Specifies the output starting offset and maximum size limit.
  QuickTime::GraphicsExportSetOutputOffsetAndMaxSize

  Parameters:
    `offset` - The byte offset of the image data from the beginning of the data reference.
    `maxSize` - A value describing the maximum size limit.
    `truncateFile` - A Boolean value specifying whether to truncate the file.

### getOutputOffset

    public int getOutputOffset()
                        throws StdQTException

  Gets the output starting offset and maximum size limit.
  QuickTime::GraphicsExportGetOutputOffsetAndMaxSize

  Returns:
    a starting offset.

### getOutputMaxSize

    public int getOutputMaxSize()
                         throws StdQTException

  Gets the output starting offset and maximum size limit.
  QuickTime::GraphicsExportGetOutputOffsetAndMaxSize

  Returns:
    maximum size limit.

### getOutputTruncateFile

    public boolean getOutputTruncateFile()
                                  throws StdQTException

  Gets the output starting offset and maximum size limit.
  QuickTime::GraphicsExportGetOutputOffsetAndMaxSize

  Returns:
    maximum size limit.

### setOutputFileTypeAndCreator

    public void setOutputFileTypeAndCreator(int fileType,
                                            int fileCreator)
                                     throws QTException

  Specifies the output starting offset and maximum size limit.
  QuickTime::GraphicsExportSetOutputFileTypeAndCreator

  Parameters:
    `fileType` - The file type for the new image file, such as `JPEG' .
    `fileCreator` - The file creator for the new image file. This parameter may be 0, in which case a default file creator for this file type is used.

### getOutputFileType

    public int getOutputFileType()
                          throws QTException

  Gets the Output file type.
  QuickTime::GraphicsExportGetOutputFileTypeAndCreator

  Returns:
    fileType

### getOutputFileCreator

    public int getOutputFileCreator()
                             throws QTException

  Gets the Output file Creator.
  QuickTime::GraphicsExportGetOutputFileTypeAndCreator

  Returns:
    fileCreator

### mayExporterReadInputData

    public boolean mayExporterReadInputData()
                                     throws QTException

  Used by format-specific graphics exporters when transcoding: Asks whether the image source is in a form that can be read.
  QuickTime::GraphicsExportMayExporterReadInputData
  return true if the exporter is allowed to read the input data

### getInputDataSize

    public int getInputDataSize()
                         throws QTException

  Used by format-specific graphics exporters when transcoding: Returns the number of bytes of original image data that can be read.
  QuickTime::GraphicsExportGetInputDataSize

  Returns:
    returns the size in bytes.

### readInputData

    public byte[] readInputData(int dataOffset,
                                int dataSize)
                         throws StdQTException

  Used by format-specific graphics exporters when transcoding: Returns the number of bytes of original image data that can be read.
  QuickTime::GraphicsExportReadInputData

  Parameters:
    `dataPtr` - the pointer to receive the input data.
    `dataOffset` - The offset of the image data within the source image data. The function begins reading image data from this offset.
    `dataSize` - The number of bytes of image data to read.
  Returns:
    the data of size datasize.

### getInputImageDescription

    public ImageDescription getInputImageDescription()
                                              throws QTException

  Used by format-specific graphics exporters, especially when doing standalone export: Returns the number of bytes of original image data that can be read.
  QuickTime::GraphicsExportGetInputImageDescription

  Returns:
    returns the ImageDescription

### getInputImageDimensions

    public QDRect getInputImageDimensions()
                                   throws QTException

  Used by format-specific graphics exporters, especially when doing standalone export: Returns the dimensions of the input image.
  QuickTime::GraphicsExportGetInputImageDimensions

  Returns:
    Returns the rectangle that has the dimensions of the input image.

### getInputImageDepth

    public int getInputImageDepth()
                           throws QTException

  Used by format-specific graphics exporters, especially when doing standalone export: Returns the depth of the input image.
  QuickTime::GraphicsExportGetInputImageDepth

  Returns:
    Returns the depth of the input image..

### drawInputImage

    public void drawInputImage(QDGraphics gw,
                               QDRect srcRect,
                               QDRect destRect)
                        throws QTException

  Used by format-specific graphics exporters, especially when doing standalone export: Draws a rectangular portion of the input image. srcRect and dstRect need not be the same width and height; you can use this function to scale the image portion. This would be useful, for example, if you were writing a graphics exporter for a multiple-resolution format.
  QuickTime::GraphicsExportDrawInputImage

### setInputOffsetAndLimit

    public void setInputOffsetAndLimit(int offset,
                                       int limit)
                                throws QTException

  Only applicable when the input is a data reference, file, handle or ptr: Specifies the portion of an input data reference, file, handle or pointer that a graphics exporter is permitted to read. This would be useful if, for example, the source was a JPEG image embedded within a larger file.
  QuickTime::GraphicsExportSetInputOffsetAndLimit

  Parameters:
    `offset` - The byte offset of the input image data from the beginning of the data reference.
    `limit` - The offset of the byte following the last byte of the input image data. (If you do not need to apply any limit unsigned int -1

### getInputOffset

    public int getInputOffset()
                       throws QTException

  Only applicable when the input is a data reference, file, handle or ptr: Specifies the portion of an input data reference, file, handle or pointer that a graphics exporter is permitted to read. This would be useful if, for example, the source was a JPEG image embedded within a larger file.
  QuickTime::GraphicsExportGetInputOffsetAndLimit

  Returns:
    offset of input image data

### getInputLimit

    public int getInputLimit()
                      throws QTException

  Only applicable when the input is a data reference, file, handle or ptr: Specifies the portion of an input data reference, file, handle or pointer that a graphics exporter is permitted to read. This would be useful if, for example, the source was a JPEG image embedded within a larger file.
  QuickTime::GraphicsExportGetInputOffsetAndLimit

  Returns:
    offset of the byte following the last byte of the input image data

### requestSettings

    public void requestSettings()
                         throws QTException

  These functions are used for obtaining graphics exporter settings and displaying a settings dialog box. Some graphics exporters don't support settings dialogs, and so do not implement this call. To find out whether a graphics exporter implements this call, use CallComponentCanDo ( myGraphicsExporter , kGraphicsExportRequestSettingsSelect ).
  QuickTime::GraphicsExportRequestSettings

### setSettingsFromAtomContainer

    public void setSettingsFromAtomContainer(AtomContainer qtAtomContainer)
                                      throws QTException

  These functions are used for obtaining graphics exporter settings and displaying a settings dialog box. Sets the graphics exporter component's current configuration to match the settings in the passed atom container.
  QuickTime::GraphicsExportSetSettingsFromAtomContainer

  Parameters:
    `qtAtomContainer` - A QuickTime atom container containing settings.

### getSettingsAsAtomContainer

    public AtomContainer getSettingsAsAtomContainer()
                                             throws QTException

  These functions are used for obtaining graphics exporter settings and displaying a settings dialog box. Retrieves the current settings from the graphics exporter component
  QuickTime::GraphicsExportGetSettingsAsAtomContainer

  Returns:
    AtomContainer containing settings.

### getSettingsAsText

    public QTHandle getSettingsAsText()
                               throws QTException

  This function is used for obtaining graphics exporter settings and displaying a settings dialog box. Retrieves the current settings in a user-readable format.
  QuickTime::GraphicsExportGetSettingsAsText

  Returns:
    QTHandle containing the text.

### getDefaultFileNameExtension

    public java.lang.String getDefaultFileNameExtension()
                                                 throws QTException

  Returns the suggested file name extension.
  QuickTime::GraphicsExportGetDefaultFileNameExtension

  Returns:
    Returns the suggested file name extension.

### getMIMETypeList

    public AtomContainer getMIMETypeList()
                                  throws QTException

  Returns MIME types and other information about the graphics format.
  QuickTime::GraphicsExportGetMIMETypeList
  The format's name, as a string in an atom of type kMimeInfoDescriptionTag . Optionally, the MIME type, as a string in an atom of type kMimeInfoMimeTypeTag .
  Returns:
    Returns AtomContainer containing information about the graphics format.

### getDefaultFileType

    public java.lang.String getDefaultFileType()
                                        throws QTException

  Returns the default file Type for the new image file format.
  QuickTime::GraphicsExportGetDefaultFileTypeAndCreator

  Returns:
    Returns the default file Type for the new image file format

### getDefaultFileCreator

    public java.lang.String getDefaultFileCreator()
                                           throws QTException

  Returns file creator for the new image file format.
  QuickTime::GraphicsExportGetDefaultFileTypeAndCreator

  Returns:
    Returns file creator for the new image file format

### canTranscode

    public boolean canTranscode()
                         throws QTException

  Format-specific exporters may delegate this call; the base graphics exporter's implementation gives a reply of false .Use this call to ask a graphics exporter whether it can transcode the current input with the current settings.
  QuickTime::GraphicsExportCanTranscode

  Returns:
    Returns true if current export operation can be performed by transcoding.

### doTranscode

    public void doTranscode()
                     throws QTException

  The base graphics exporter makes this call of the format-specific graphics exporter to perform a transcoding export.
  QuickTime::GraphicsExportDoTranscode

### canUseCompressor

    public GECompressorInfo canUseCompressor()
                                      throws QTException

  The base graphics exporter makes this call of the format-specific graphics exporter to ask whether the current export operation should be done by using an image compressor.
  QuickTime::GraphicsExportCanUseCompressor

  Returns:
    true if allowed to use a compressor.
  See Also:
    `AtomContainer.fromGraphicsExporterCompressor(quicktime.std.image.GraphicsExporter)`

### doUseCompressor

    public ImageDescription doUseCompressor(AtomContainer ac)
                                     throws QTException

  The base graphics exporter makes this call of the format-specific graphics exporter to ask whether the current export operation should be done by using an image compressor.
  QuickTime::GraphicsExportDoUseCompressor

  Returns:
    ImageDescription object describing the compressed image.

### setDontRecompress

    public void setDontRecompress(boolean dontRecompress)
                           throws QTException

  Requests that the original compressed data not be decompressed and recompressed, but be copied (possibly with modifications) through to the output file.
  QuickTime::GraphicsExportSetDontRecompress

  Parameters:
    `dontRecompress` - true if not allowed to recompressor.

### getDontRecompress

    public boolean getDontRecompress()
                              throws QTException

  Requests that the original compressed data not be decompressed and recompressed, but be copied (possibly with modifications) through to the output file.
  QuickTime::GraphicsExportSetDontRecompress

  Returns:
    dontRecompress true if not allowed to recompressor.

### setInterlaceStyle

    public void setInterlaceStyle(int interlaceStyle)
                           throws QTException

  Defines the interlace style.
  QuickTime::GraphicsExportSetInterlaceStyle

  Parameters:
    `interlaceStyle` - A value describing the style of the image data .

### getInterlaceStyle

    public int getInterlaceStyle()
                          throws QTException

  Returns the interlace style.
  QuickTime::GraphicsExportGetInterlaceStyle

  Returns:
    the interlace style.

### setMetaData

    public void setMetaData(UserData userData)
                     throws QTException

  Defines supplemental data, such as textual copyright information. In QuickTime 4, none of the supplied graphics exporters support setting MetaData .
  QuickTime::GraphicsExportSetMetaData

  Parameters:
    `userData` - object .

### getMetaData

    public UserData getMetaData()
                         throws QTException

  Returns supplemental data, such as textual copyright information. In QuickTime 4, none of the supplied graphics exporters support setting MetaData .
  QuickTime::GraphicsExportGetMetaData

  Returns:
    user data list
  See Also:
    `UserData.fromGraphicsExporter(quicktime.std.image.GraphicsExporter)`

### setTargetDataSize

    public void setTargetDataSize(int targetDataSize)
                           throws QTException

  Defines a desired maximum data size and asks for a quality that does not exceed that size.
  QuickTime::GraphicsExportSetTargetDataSize

  Parameters:
    `targetDataSize` - A value describing the maximum size of the image data in bytes.

### getTargetDataSize

    public int getTargetDataSize()
                          throws QTException

  Specifies a desired maximum data size and asks for a quality that does not exceed that size.
  QuickTime::GraphicsExportGetTargetDataSize

  Returns:
    A value describing the maximum size of the image data in bytes.

### setCompressionMethod

    public void setCompressionMethod(int compressionMethod)
                              throws QTException

  Defines the compression method to use.
  QuickTime::GraphicsExportSetCompressionMethod

  Parameters:
    `compressionMethod` - A value describing the compression algorithm to be used by the graphics exporter.

### getCompressionMethod

    public int getCompressionMethod()
                             throws QTException

  Defines the compression method to use.
  QuickTime::GraphicsExportGetCompressionMethod

  Returns:
    a value describing the compression algorithm used by the graphics exporter.

### setCompressionQuality

    public void setCompressionQuality(int spatialQuality)
                               throws QTException

  Defines the compression quality.
  QuickTime::GraphicsExportSetCompressionQuality

  Parameters:
    `spatialQuality` - The currently specified quality value

### getCompressionQuality

    public int getCompressionQuality()
                              throws QTException

  Defines the compression quality to use.
  QuickTime::GraphicsExportGetCompressionQuality

  Returns:
    a value describing the compression quality used by the graphics exporter.

### setResolution

    public void setResolution(int horizontalResolution,
                              int verticalResolution)
                       throws QTException

  Defines the resolution to save and store.
  QuickTime::GraphicsExportSetResolution

  Parameters:
    `spatialQuality` - The currently specified quality value

### getHorizontalResolution

    public int getHorizontalResolution()
                                throws QTException

  Gets the resolution to saved and stored.
  QuickTime::GraphicsExportGetResolution

  Returns:
    a value describing the horizontal resolution of the image.

### getVerticalResolution

    public int getVerticalResolution()
                              throws QTException

  Defines the compression quality to use.
  QuickTime::GraphicsExportGetResolution

  Returns:
    a value describing the vertical resolution of the image.

### setDepth

    public void setDepth(int depth)
                  throws QTException

  Defines the depth to use. Some image file formats support more than one pixel depth.
  QuickTime::GraphicsExportSetDepth

  Parameters:
    `A` - value describing the depth of the image data as an OSType specifying the pixel format.

### getDepth

    public int getDepth()
                 throws QTException

  Defines the depth to use. Some image file formats support more than one pixel depth.
  QuickTime::GraphicsExportGetDepth

  Returns:
    A value describing the depth of the image data as an OSType specifying the pixel format

### GraphicsExportWriteOutputData

    public void GraphicsExportWriteOutputData(byte[] data,
                                              int dataSize)
                                       throws StdQTException

  This function is used by format-specific graphics exporters to write output data. Writes output image data.
  QuickTime::GraphicsExportWriteOutputData

  Parameters:
    `data` - block containing the data.
    `dataSize` - The number of bytes of image data to write.

### GraphicsExportReadOutputData

    public byte[] GraphicsExportReadOutputData(int dataOffset,
                                               int dataSize)
                                        throws StdQTException

  This function is used by format-specific graphics exporters to write output data. Reads output image data. Not all output data types support this feature.
  QuickTime::GraphicsExportReadOutputData

  Parameters:
    `dataOffset` - The offset of the image data within the data reference. The function begins reading image data from this offset.
    `dataSize` - The number of bytes of image data to read.

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