third_party/exiv2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Removed not used XMP-SDK files.

Browse Source
This commit is contained in:
Andreas Huggel 2008-05-20 15:10:07 +00:00
parent 9fb2fe85ba
commit 505add251c
4 changed files with 0 additions and 779 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

418
xmpsdk/include/TXMPFiles.hpp
View File

@ -1,418 +0,0 @@
#ifndef __TXMPFiles_hpp__
#define __TXMPFiles_hpp__ 1
#if ( ! __XMP_hpp__ )
#error "Do not directly include, use XMP.hpp"
#endif
// =================================================================================================
// ADOBE SYSTEMS INCORPORATED
// Copyright 2002-2007 Adobe Systems Incorporated
// All Rights Reserved
//
// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance with the terms
// of the Adobe license agreement accompanying it.
// =================================================================================================
// ================================================================================================
/// \file TXMPFiles.hpp
/// \brief API for access to the "main" metadata in a file.
///
/// \c TXMPFiles provides the API for the Adobe XMP Toolkit's File Handler component. This provides
/// convenient access to the main, or document level, XMP for a file. The File Handler supports file
/// I/O, the XMP Toolkit Core supports manipulation of the XMP properties. The File Handler is
/// intended to eventually have smart, efficient support for all file formats for which the means to
/// embed XMP is defined in the XMP Specification. Where possible this support will allow injection
/// of XMP where none currently exists, expansion of XMP without regard to existing padding, and
/// reconciliation of the XMP and other legacy forms of metadata.
///
///\c TXMPFiles is designed for use by clients interested in the metadata and not in the primary file
/// content. The Adobe Bridge application is a typical example. \c TXMPFiles is not intended to be
/// particulary appropriate for files authored by an application. I.e. those files for which the
/// application has explicit knowledge of the file format.
// ================================================================================================
// ================================================================================================
/// \class TXMPFiles TXMPFiles.hpp
/// \brief API for access to the "main" metadata in a file.
///
/// \c TXMPFiles provides the API for the Adobe XMP Toolkit's File Handler component. This provides
/// convenient access to the main, or document level, XMP for a file. The general model is to open
/// a file, read and write the metadata, then close the file. While open, portions of the file
/// might be maintained in RAM data structures. Memory usage can vary considerably depending on
/// file format and access options. The file may be opened for read-only or read-write access, with
/// typical exclusion for both modes.
///
/// Errors result in the throw of an \c XMPError exception.
///
/// The template is instantiated with a string object class. This allows a clean implementation
/// that provides two major benefits: output string storage is fully owned by the client and access
/// is fully thread safe. The template parameter, class \c tStringObj, is described in the XMP.hpp
/// umbrella header.
///
/// To use TXMPFiles define TXMP_STRING_TYPE and XMP_INCLUDE_XMPFILES, then include the XMP.hpp
/// umbrella header:
/// \code
/// #define TXMP_STRING_TYPE std::string
/// #define XMP_INCLUDE_XMPFILES 1
/// #include "XMP.hpp"
/// \endcode
// ================================================================================================
template <class tStringObj>
class TXMPFiles {
public:
// ============================================================================================
/// \name Initialization and termination
/// @{
/// \c SXMPFiles must be initialized before use and may be terminated when done.
static void GetVersionInfo ( XMP_VersionInfo * versionInfo );
/// \brief \c Initialize must be called before using \c SXMPFiles. It returns a Boolean
/// success/failure value.
static bool Initialize();
static bool Initialize ( XMP_OptionBits options );
/// \brief \c Terminate may be called when done using \c SXMPFiles. It deallocates global data
/// structures created by \c Initialize.
static void Terminate();
/// @}
// ============================================================================================
/// \name Constructors and destructor
/// @{
/// The default constructor initializes an object that is associated with no file. The alternate
/// constructors call OpenFile. The destructor automatically calls CloseFile if necessary.
/// \brief The default constructor initializes an object that is associated with no file.
TXMPFiles();
virtual ~TXMPFiles() throw();
/// \brief These alternate constructors call \c OpenFile. The second form is a trivial overload
/// that calls the first form passing \c filePath.c_str().
TXMPFiles ( XMP_StringPtr filePath,
XMP_FileFormat format = kXMP_UnknownFile,
XMP_OptionBits openFlags = 0 );
TXMPFiles ( const tStringObj & filePath,
XMP_FileFormat format = kXMP_UnknownFile,
XMP_OptionBits openFlags = 0 );
/// \brief The copy constructor and assignment operator increment an internal reference count,
/// they do not perform a deep copy.
TXMPFiles ( const TXMPFiles<tStringObj> & original );
void operator= ( const TXMPFiles<tStringObj> & rhs );
/// \brief The "ref" constructor and \c GetInternalRef serve the same purpose as their analogs
/// in SXMPMeta, safely passing \c SXMPFiles references across DLL boundaries where the clients
/// might have used different string types when instantiating \c TXMPFiles.
TXMPFiles ( XMPFilesRef xmpFilesObj );
XMPFilesRef GetInternalRef();
/// @}
// ============================================================================================
/// \name Static Functions
/// @{
// --------------------------------------------------------------------------------------------
/// \brief Determine the supported features for a given file format.
///
/// The supported features can vary quite a bit among file formats, depending on both the
/// general capabilities of the format and the implementation of the handler for that format.
///
/// \param format The format whose support flags are desired.
///
/// \param handlerFlags A set of option bits showing the support for this format:
///
/// \li kXMPFiles_CanInjectXMP - Can inject first-time XMP into an existing file.
/// \li kXMPFiles_CanExpand - Can expand XMP or other metadata in an existing file.
/// \li kXMPFiles_CanRewrite - Can copy one file to another, writing new metadata.
/// \li kXMPFiles_CanReconcile - Supports reconciliation between XMP and other forms.
/// \li kXMPFiles_AllowsOnlyXMP - Allows access to just the XMP, ignoring other forms.
/// \li kXMPFiles_ReturnsRawPacket - File handler returns raw XMP packet information and string.
/// \li kXMPFiles_ReturnsTNail - File handler returns native thumbnail information.
///
/// The kXMPFiles_AllowsOnlyXMP flag is only meaningful if kXMPFiles_CanReconcile is set.
///
/// If kXMPFiles_ReturnsRawPacket is set, the returned packet information might have an offset
/// of -1 to indicate an unknown offset. While all file handlers should be able to return the
/// raw packet, some might not know the offset of the packet within the file. This is typical
/// in cases where external libraries are used. These cases might not even allow return of the
/// raw packet.
///
/// \result Returns true if the format has explicit "smart" support. Returns false if the format
/// is handled by the default packet scanning plus heuristics.
static bool GetFormatInfo ( XMP_FileFormat format,
XMP_OptionBits * handlerFlags = 0 );
/// @}
// ============================================================================================
/// \name OpenFile, CloseFile, and related file-oriented operations
/// @{
// --------------------------------------------------------------------------------------------
/// \brief Open a file for metadata access.
///
/// Opens a file for the requested forms of metadata access. Opening the file at a minimum
/// causes the raw XMP packet to be read from the file. If the file handler supports legacy
/// metadata reconciliation then legacy metadata will also be read, unless kXMPFiles_OpenOnlyXMP
/// is passed. If the file handler supports native thumbnails and kXMPFiles_OpenCacheTNail is
/// passed then the native thumbnail will also be cached.
///
/// If the file is opened for read-only access (passing kXMPFiles_OpenForRead), then the disk
/// file itself will be closed after reading the data from it. The XMPFiles object will not be
/// "closed" though, it is still necessary to call CloseFile when finished using it. Other
/// methods (GetXMP, etc.) can only be used between the OpenFile and CloseFile calls. The XMPFiles
/// destructor will not call CloseFile, any pending updates will be lost.
///
/// If the file is opened for update (passing kXMPFiles_OpenForUpdate), then the disk file remains
/// open until CloseFile is called. The disk file is only updated once, when Close file is called,
/// no matter how many calls are made to PutXMP.
///
/// Ideally the XMP is not parsed and legacy reconciliation is not performed until GetXMP is
/// called. This is not guaranteed though, specific file handlers might do earlier parsing of
/// the XMP. This delayed parsing and the early disk file close for read-only access are
/// optimizations to help clients implementing file browsers. They can access the file briefly
/// and possibly display a thumbnail, then postpone more expensive XMP processing until later.
///
/// \param filePath The UTF-8 path for the file, appropriate for the local OS. Overloads are
/// declared to pass the path as either a "const char *" or a string object.
///
/// \param format The format of the file. If the format is unknown pass \c kXMP_UnknownFile and
/// the format will be determined from the file content. The first handler to check will be
/// guessed from the file's extension. Passing any other format value is generally just a hint
/// about what file handler to try first (instead of the one based on the extension). If the
/// kXMPFiles_OpenStrictly is set, then any format other than kXMP_UnknownFile requires that the
/// file actually be that format, an exception is thrown if not.
///
/// \param openFlags A set of option bits describing the desired access. By default (zero) the
/// file is opened for read-only access and the format handler decides on the level of
/// reconciliation that will be performed. By default a best effort will be made to locate the
/// correct XMP and to reconcile XMP with other forms (if reconciliation is done). The option
/// \c kXMPFiles_OpenStrictly may be used to force more strict rules, resulting is exceptions for
/// errors. The definition of strictness is specific to each handler, there may be no difference.
///
/// The defined openFlag bits are:
///
/// \li kXMPFiles_OpenForRead - Open for read-only access.
/// \li kXMPFiles_OpenForUpdate - Open for reading and writing.
/// \li kXMPFiles_OpenOnlyXMP - Only the XMP is wanted, no reconciliation.
/// \li kXMPFiles_OpenCacheTNail - Cache thumbnail if possible, GetThumbnail will be called.
/// \li kXMPFiles_OpenStrictly - Be strict about locating XMP and reconciling with other forms.
/// \li kXMPFiles_OpenUseSmartHandler - Require the use of a smart handler.
/// \li kXMPFiles_OpenUsePacketScanning - Force packet scanning, don't use a smart handler.
///
/// \result Returns true if the file is succesfully opened and attached to a file handler.
/// Returns false for "anticipated" problems, e.g. passing kXMPFiles_OpenUseSmartHandler but not
/// having an appropriate smart handler. Throws an exception for serious problems.
bool OpenFile ( XMP_StringPtr filePath,
XMP_FileFormat format = kXMP_UnknownFile,
XMP_OptionBits openFlags = 0 );
bool OpenFile ( const tStringObj & filePath,
XMP_FileFormat format = kXMP_UnknownFile,
XMP_OptionBits openFlags = 0 );
// --------------------------------------------------------------------------------------------
/// \brief Close an opened file.
///
/// Performs any necessary output to the file and closes it. Files that are opened for update
/// are written to only when closing.
///
/// \param closeFlags A set of bit flags for optional closing actions.
///
/// The defined closeFlags bits are:
///
/// \li kXMPFiles_UpdateSafely - Write into a temporary file then swap for crash safety.
void CloseFile ( XMP_OptionBits closeFlags = 0 );
// --------------------------------------------------------------------------------------------
/// \brief Get basic information about an opened file.
///
/// \param filePath If not null, returns the path passed to OpenFile.
///
/// \param openFlags If not null, returns the flags passed to OpenFile.
///
/// \param format If not null, returns the format of the file.
///
/// \param handlerFlags If not null, returns the handler's capability flags.
///
/// \result Returns true if a file is opened, false otherwise. This notion of "open" really means
/// that OpenFile has been called but CloseFile has not. The actual disk file might be closed in
/// the host file system sense, as explained for OpenFile.
bool GetFileInfo ( tStringObj * filePath = 0,
XMP_OptionBits * openFlags = 0,
XMP_FileFormat * format = 0,
XMP_OptionBits * handlerFlags = 0 );
// --------------------------------------------------------------------------------------------
/// \brief Set the callback function used to check for a user signaled abort.
///
/// \param abortProc The callback function used to check for a user signaled abort. It will be
/// called periodically to allow an abort of time consuming operations. The abort results in an
/// exception being thrown. The callback function should return true to signal an abort.
///
/// \param abortArg An argument passed to the callback function.
void SetAbortProc ( XMP_AbortProc abortProc,
void * abortArg );
/// @}
// ============================================================================================
/// \name Metadata Access Functions
/// @{
// --------------------------------------------------------------------------------------------
/// \brief Obtain the XMP.
///
/// \c GetXMP is used to obtain the parsed XMP, and/or the raw XMP packet, and/or information
/// about the raw XMP packet. If all parameters are null it simply tells if XMP is present or
/// not. The options provided when the file was opened determine if reconciliation is done with
/// other forms of metadata.
///
/// \param xmpObj If not null, returns the parsed XMP.
///
/// \param xmpPacket If not null, returns the raw XMP packet as stored in the file. The encoding
/// of the packet is given in the packetInfo. The string will be empty if the low level file
/// handler does not provide the raw packet.
///
/// \param packetInfo If not null, returns the location and form of the raw XMP in the file. The
/// charForm and writeable flag reflect the raw XMP in the file. The parsed XMP property values
/// are always UTF-8. The writeable flag is taken from the packet trailer, it is only relevant
/// for "format ignorant" writing.
///
/// \note The packetInfo struct always reflects the state of the XMP in the file. The offset,
/// length, and character form will not change as a result of calling \c PutXMP unless the file
/// is also written.
///
/// \note Some file handlers might not return location or contents of the raw packet string.
/// Check the \c kXMPFiles_ReturnsRawPacket bit returned by GetFormatInfo if you depend on this.
/// If the low level file handler does not provide the raw packet location then the offset and
/// length will both be 0, the charForm will be UTF-8, and the writeable flag will be false.
///
/// \result Returns true if the file has XMP, false otherwise.
bool GetXMP ( SXMPMeta * xmpObj = 0,
tStringObj * xmpPacket = 0,
XMP_PacketInfo * packetInfo = 0 );
// --------------------------------------------------------------------------------------------
/// \brief Obtain the native thumbnail.
///
/// \c GetThumbnail is used to obtain native thumbnail information, if the associated file
/// handler supports that and the thumbnail was cached by OpenFile. This requires that
/// kXMPFiles_OpenCacheTNail be passed to OpenFile. The tnailInfo output pointer can be null,
/// in which case GetThumbnail will simply tell if a recognized native thumbnail is present.
///
/// \param tnailInfo If not null, returns information about a recognized native thumbnail, and
/// some related information about the primary image if appropriate.
///
/// \note The returned thumbnail information can be incomplete. What gets returned can depend on
/// the file format, the file handler's capabilities, and the specific file content.
///
/// \li The fullHeight, fullWIdth, and fullOrientation fields are only meaningful for image files.
/// They are not meaningful for multi-page files such as PDF or InDesign, for dynamic audio or
/// video files, etc. The fields will be zero if not meaningful or not determined.
///
/// \li The tnailImage and tnailSize fields might be zero even if a "recognized" thumbnail is
/// present. Being recognized means only that the handler has determined that the file does
/// contain a native thumbnail. The thumbnail data might be of a format that the file handler
/// cannot (or does not) return a single contiguous block of thumbnail data. A possible case of
/// this is a TIFF uncompressed thumbnail, the handler might not have logic to gather the various
/// disjoint pieces of the thumbnail from the overall TIFF stream.
///
/// \result Returns true if a recognized native thumbnail is presentand the thumbnail was
/// cached by OpenFile. This requires that kXMPFiles_OpenCacheTNail be passed to OpenFile. Note
/// that GetThumbnail can return true but still not return an actual thumbnail image, see the
/// above note.
bool GetThumbnail ( XMP_ThumbnailInfo * tnailInfo );
// --------------------------------------------------------------------------------------------
/// \brief Update the XMP.
///
/// \c PutXMP supplies new XMP for the file. However, the file is not actully written until
/// closed. The options provided when the file was opened determine if reconciliation is done
/// with other forms of metadata. Overloads are provided to pass the XMP as an XMP
/// object, a string object, or a "const char *" plus length.
void PutXMP ( const SXMPMeta & xmpObj );
void PutXMP ( const tStringObj & xmpPacket );
void PutXMP ( XMP_StringPtr xmpPacket,
XMP_StringLen xmpLength = kXMP_UseNullTermination );
// --------------------------------------------------------------------------------------------
/// \brief Determine if the XMP can be updated.
///
/// \c CanPutXMP determines if the XMP can (probably) be updated. The provided XMP is only used
/// to obtain the length of the serialized packet. The new XMP is not kept, calling this will
/// not cause the file to be written when closed. Overloads are provided to pass the XMP as an
/// XMP object, a string object, or a "const char *" plus length. This is implemented roughly
/// as:
///
/// \code
/// bool CanPutXMP ( XMP_StringPtr xmpPacket )
/// {
/// XMP_FileFormat format;
/// this->GetFileInfo ( 0, &format, 0 );
///
/// XMP_OptionBits formatFlags;
/// GetFormatInfo ( format, &formatFlags );
///
/// if ( (formatFlags & kXMPFiles_CanInjectXMP) && (formatFlags & kXMPFiles_CanExpand) ) return true;
///
/// XMP_PacketInfo packetInfo;
/// bool hasXMP = this->GetXMP ( 0, 0, &packetInfo );
///
/// if ( ! hasXMP ) {
/// if ( formatFlags & kXMPFiles_CanInjectXMP ) return true;
/// } else {
/// if ( (formatFlags & kXMPFiles_CanExpand) ||
/// (packetInfo.length >= strlen(xmpPacket)) ) return true;
/// }
///
/// return false;
///
/// }
/// \endcode
bool CanPutXMP ( const SXMPMeta & xmpObj );
bool CanPutXMP ( const tStringObj & xmpPacket );
bool CanPutXMP ( XMP_StringPtr xmpPacket,
XMP_StringLen xmpLength = kXMP_UseNullTermination );
/// @}
// =============================================================================================
private:
XMPFilesRef xmpFilesRef;
}; // class TXMPFiles
// =================================================================================================
#endif // __TXMPFiles_hpp__

9
xmpsdk/include/XMP.hpp
View File

@ -75,17 +75,8 @@
#include "client-glue/TXMPMeta.incl_cpp"
#include "client-glue/TXMPIterator.incl_cpp"
#include "client-glue/TXMPUtils.incl_cpp"
#include "client-glue/TXMPFiles.incl_cpp"
#endif
#if XMP_INCLUDE_XMPFILES
#include "TXMPFiles.hpp" // ! Needs typedef for SXMPMeta.
typedef class TXMPFiles <TXMP_STRING_TYPE> SXMPFiles;
#if TXMP_EXPAND_INLINE
#include "client-glue/TXMPFiles.incl_cpp"
#endif
#endif
#endif // TXMP_STRING_TYPE
#if XMP_WinBuild

5
xmpsdk/include/XMP.incl_cpp
View File

@ -55,11 +55,6 @@
template class TXMPIterator <TXMP_STRING_TYPE>;
template class TXMPUtils <TXMP_STRING_TYPE>;
#if XMP_INCLUDE_XMPFILES
#include "client-glue/TXMPFiles.incl_cpp"
template class TXMPFiles <TXMP_STRING_TYPE>;
#endif
#endif
#if XMP_WinBuild

347
xmpsdk/include/client-glue/TXMPFiles.incl_cpp
View File

@ -1,347 +0,0 @@
// =================================================================================================
// ADOBE SYSTEMS INCORPORATED
// Copyright 2002-2007 Adobe Systems Incorporated
// All Rights Reserved
//
// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance with the terms
// of the Adobe license agreement accompanying it.
// =================================================================================================
// ================================================================================================
/// \file TXMPFiles.incl_cpp
/// \brief The implementation of the TXMPFiles template class.
#if WIN_ENV
#pragma warning ( disable : 4003 ) // not enough actual parameters for macro
#pragma warning ( disable : 4800 ) // forcing value to bool 'true' or 'false' (performance warning)
#endif
#include "client-glue/WXMP_Common.hpp"
#include "client-glue/WXMPFiles.hpp"
// =================================================================================================
// Implementation Guidelines
// =========================
//
// The implementations of the template functions are very stylized. The jobs done in this code are:
//
// 1. ...
//
// =================================================================================================
#ifndef XMPFiles_TraceCTorDTor
#define XMPFiles_TraceCTorDTor 0
#endif
#if XMPFiles_TraceCTorDTor
class XFPeek { // Hack to peek at the client ref count in the internal object.
public:
XFPeek();
virtual ~XFPeek();
XMP_Int32 clientRefs;
};
#endif
// =================================================================================================
XMP_MethodIntro(TXMPFiles,void)::
GetVersionInfo ( XMP_VersionInfo * versionInfo )
{
WrapNoCheckVoid ( zXMPFiles_GetVersionInfo_1 ( versionInfo ) );
}
// -------------------------------------------------------------------------------------------------
XMP_MethodIntro(TXMPFiles,bool)::
Initialize()
{
WrapCheckBool ( ok, zXMPFiles_Initialize_2 ( 0 ) );
return ok;
}
// -------------------------------------------------------------------------------------------------
XMP_MethodIntro(TXMPFiles,bool)::
Initialize ( XMP_OptionBits options )
{
WrapCheckBool ( ok, zXMPFiles_Initialize_2 ( options ) );
return ok;
}
// -------------------------------------------------------------------------------------------------
XMP_MethodIntro(TXMPFiles,void)::
Terminate()
{
WrapNoCheckVoid ( zXMPFiles_Terminate_1() );
}
// =================================================================================================
static XMPFilesRef Default_CTor()
{
WrapCheckXMPFilesRef ( newRef, zXMPFiles_CTor_1() );
return newRef;
}
// -------------------------------------------------------------------------------------------------
XMP_CTorDTorIntro(TXMPFiles)::
TXMPFiles() : xmpFilesRef(Default_CTor())
{
#if XMPFiles_TraceCTorDTor
XFPeek* xfPtr = (XFPeek*)this->xmpFilesRef;
printf ( "Default construct TXMPFiles @ %.8X, ref = %.8X, count = %d\n", this, xfPtr, xfPtr->clientRefs );
#endif
}
// -------------------------------------------------------------------------------------------------
XMP_CTorDTorIntro(TXMPFiles)::
TXMPFiles ( const TXMPFiles<tStringObj> & original ) : xmpFilesRef(original.xmpFilesRef)
{
WXMPFiles_IncrementRefCount_1 ( this->xmpFilesRef );
#if XMPFiles_TraceCTorDTor
XFPeek* xfPtr = (XFPeek*)this->xmpFilesRef;
printf ( "Copy construct TXMPFiles @ %.8X, ref = %.8X, count = %d\n", this, xfPtr, xfPtr->clientRefs );
#endif
}
// -------------------------------------------------------------------------------------------------
XMP_MethodIntro(TXMPFiles,void)::
operator= ( const TXMPFiles<tStringObj> & rhs )
{
#if XMPFiles_TraceCTorDTor
XFPeek* xfLHS = (XFPeek*)this->xmpFilesRef;
XFPeek* xfRHS = (XFPeek*)rhs.xmpFilesRef;
printf ( "Assign TXMPFiles, lhs @ %.8X, rhs @ %.8X\n", this, &rhs );
printf ( " original lhs ref = %.8X, count = %d\n", xfLHS, xfLHS->clientRefs );
printf ( " original rhs ref = %.8X, count = %d\n", xfRHS, xfRHS->clientRefs );
#endif
XMPFilesRef oldRef = this->xmpFilesRef; // ! Decrement last so errors leave client object OK.
this->xmpFilesRef = rhs.xmpFilesRef;
WXMPFiles_IncrementRefCount_1 ( this->xmpFilesRef ); // Increment the count on the new ref.
WXMPFiles_DecrementRefCount_1 ( oldRef ); // Decrement the count on the old ref.
#if XMPFiles_TraceCTorDTor
printf ( " result lhs ref = %.8X, count = %d\n", xfLHS, xfLHS->clientRefs );
#endif
}
// -------------------------------------------------------------------------------------------------
XMP_CTorDTorIntro(TXMPFiles)::
TXMPFiles ( XMPFilesRef _xmpFilesRef ) : xmpFilesRef(_xmpFilesRef)
{
WXMPFiles_IncrementRefCount_1 ( this->xmpFilesRef );
#if XMPFiles_TraceCTorDTor
XFPeek* xfPtr = (XFPeek*)this->xmpFilesRef;
printf ( "Ref construct TXMPFiles @ %.8X, ref = %.8X, count = %d\n", this, xfPtr, xfPtr->clientRefs );
#endif
}
// -------------------------------------------------------------------------------------------------
XMP_CTorDTorIntro(TXMPFiles)::
TXMPFiles ( XMP_StringPtr filePath,
XMP_FileFormat format /* = kXMP_UnknownFile */,
XMP_OptionBits openFlags /* = 0 */ ) : xmpFilesRef(Default_CTor())
{
#if XMPFiles_TraceCTorDTor
XFPeek* xfPtr = (XFPeek*)this->xmpFilesRef;
printf ( "File construct TXMPFiles @ %.8X, ref = %.8X, count = %d\n", this, xfPtr, xfPtr->clientRefs );
#endif
bool ok = this->OpenFile ( filePath, format, openFlags );
if ( ! ok ) throw XMP_Error ( kXMPErr_NoFileHandler, "OpenFile returned false" );
}
// -------------------------------------------------------------------------------------------------
XMP_CTorDTorIntro(TXMPFiles)::
TXMPFiles ( const tStringObj & filePath,
XMP_FileFormat format /* = kXMP_UnknownFile */,
XMP_OptionBits openFlags /* = 0 */ ) : xmpFilesRef(Default_CTor())
{
#if XMPFiles_TraceCTorDTor
XFPeek* xfPtr = (XFPeek*)this->xmpFilesRef;
printf ( "File construct TXMPFiles @ %.8X, ref = %.8X, count = %d\n", this, xfPtr, xfPtr->clientRefs );
#endif
bool ok = this->OpenFile ( filePath.c_str(), format, openFlags );
if ( ! ok ) throw XMP_Error ( kXMPErr_NoFileHandler, "OpenFile returned false" );
}
// -------------------------------------------------------------------------------------------------
XMP_CTorDTorIntro(TXMPFiles)::
~TXMPFiles () throw()
{
#if XMPFiles_TraceCTorDTor
XFPeek* xfPtr = (XFPeek*)this->xmpFilesRef;
printf ( "Destruct TXMPFiles @ %.8X, ref= %.8X, count = %d\n", this, xfPtr, xfPtr->clientRefs );
#endif
WXMPFiles_DecrementRefCount_1 ( this->xmpFilesRef );
this->xmpFilesRef = 0;
}
// =================================================================================================
XMP_MethodIntro(TXMPFiles,bool)::
GetFormatInfo ( XMP_FileFormat format,
XMP_OptionBits * flags )
{
WrapCheckBool ( found, zXMPFiles_GetFormatInfo_1 ( format, flags ) );
return found;
}
// =================================================================================================
XMP_MethodIntro(TXMPFiles,XMPFilesRef)::
GetInternalRef()
{
return this->xmpFilesRef;
}
// -------------------------------------------------------------------------------------------------
XMP_MethodIntro(TXMPFiles,bool)::
OpenFile ( XMP_StringPtr filePath,
XMP_FileFormat format /* = kXMP_UnknownFile */,
XMP_OptionBits openFlags /* =0 */ )
{
WrapCheckBool ( ok, zXMPFiles_OpenFile_1 ( filePath, format, openFlags ) );
return ok;
}
// -------------------------------------------------------------------------------------------------
XMP_MethodIntro(TXMPFiles,bool)::
OpenFile ( const tStringObj & filePath,
XMP_FileFormat format /* = kXMP_UnknownFile */,
XMP_OptionBits openFlags /* =0 */ )
{
return this->OpenFile ( filePath.c_str(), format, openFlags );
}
// -------------------------------------------------------------------------------------------------
XMP_MethodIntro(TXMPFiles,void)::
CloseFile ( XMP_OptionBits closeFlags /* =0 */ )
{
WrapCheckVoid ( zXMPFiles_CloseFile_1 ( closeFlags ) );
}
// -------------------------------------------------------------------------------------------------
XMP_MethodIntro(TXMPFiles,bool)::
GetFileInfo ( tStringObj * filePath /* = 0 */,
XMP_OptionBits * openFlags /* =0 */,
XMP_FileFormat * format /* = 0 */,
XMP_OptionBits * handlerFlags /* =0 */ )
{
XMP_StringPtr pathStr;
XMP_StringLen pathLen;
WrapCheckBool ( isOpen, zXMPFiles_GetFileInfo_1 ( &pathStr, &pathLen, openFlags, format, handlerFlags ) );
if ( isOpen ) {
if ( filePath != 0 ) filePath->assign ( pathStr, pathLen );
WXMPFiles_UnlockObj_1 ( this->xmpFilesRef );
}
return isOpen;
}
// -------------------------------------------------------------------------------------------------
XMP_MethodIntro(TXMPFiles,void)::
SetAbortProc ( XMP_AbortProc abortProc,
void * abortArg )
{
WrapCheckVoid ( zXMPFiles_SetAbortProc_1 ( abortProc, abortArg ) );
}
// -------------------------------------------------------------------------------------------------
XMP_MethodIntro(TXMPFiles,bool)::
GetXMP ( SXMPMeta * xmpObj /* = 0 */,
tStringObj * xmpPacket /* = 0 */,
XMP_PacketInfo * packetInfo /* =0 */ )
{
XMP_StringPtr xmpStr;
XMP_StringLen xmpLen;
XMPMetaRef xmpRef = 0;
if ( xmpObj != 0 ) {
SXMPUtils::RemoveProperties ( xmpObj, 0, 0, kXMPUtil_DoAllProperties );
// *** Need an SXMPMeta::Clear method:
xmpRef = xmpObj->GetInternalRef();
}
WrapCheckBool ( hasXMP, zXMPFiles_GetXMP_1 ( xmpRef, &xmpStr, &xmpLen, packetInfo ) );
if ( hasXMP ) {
if ( xmpPacket != 0 ) xmpPacket->assign ( xmpStr, xmpLen );
WXMPFiles_UnlockObj_1 ( this->xmpFilesRef );
}
return hasXMP;
}
// -------------------------------------------------------------------------------------------------
XMP_MethodIntro(TXMPFiles,bool)::
GetThumbnail ( XMP_ThumbnailInfo * tnailInfo )
{
WrapCheckBool ( hasTNail, zXMPFiles_GetThumbnail_1 ( tnailInfo ) );
return hasTNail;
}
// -------------------------------------------------------------------------------------------------
XMP_MethodIntro(TXMPFiles,void)::
PutXMP ( const SXMPMeta & xmpObj )
{
WrapCheckVoid ( zXMPFiles_PutXMP_1 ( xmpObj.GetInternalRef(), 0, 0 ) );
}
// -------------------------------------------------------------------------------------------------
XMP_MethodIntro(TXMPFiles,void)::
PutXMP ( XMP_StringPtr xmpPacket,
XMP_StringLen xmpLength /* = kXMP_UseNullTermination */ )
{
WrapCheckVoid ( zXMPFiles_PutXMP_1 ( 0, xmpPacket, xmpLength ) );
}
// -------------------------------------------------------------------------------------------------
XMP_MethodIntro(TXMPFiles,void)::
PutXMP ( const tStringObj & xmpPacket )
{
this->PutXMP ( xmpPacket.c_str(), xmpPacket.size() );
}
// -------------------------------------------------------------------------------------------------
XMP_MethodIntro(TXMPFiles,bool)::
CanPutXMP ( const SXMPMeta & xmpObj )
{
WrapCheckBool ( canPut, zXMPFiles_CanPutXMP_1 ( xmpObj.GetInternalRef(), 0, 0 ) );
return canPut;
}
// -------------------------------------------------------------------------------------------------
XMP_MethodIntro(TXMPFiles,bool)::
CanPutXMP ( XMP_StringPtr xmpPacket,
XMP_StringLen xmpLength /* = kXMP_UseNullTermination */ )
{
WrapCheckBool ( canPut, zXMPFiles_CanPutXMP_1 ( 0, xmpPacket, xmpLength ) );
return canPut;
}
// -------------------------------------------------------------------------------------------------
XMP_MethodIntro(TXMPFiles,bool)::
CanPutXMP ( const tStringObj & xmpPacket )
{
return this->CanPutXMP ( xmpPacket.c_str(), xmpPacket.size() );
}
// =================================================================================================