CIccTagXmlStruct Class Reference

#include <IccTagXml.h>

Inheritance diagram for CIccTagXmlStruct:

Collaboration diagram for CIccTagXmlStruct:

Public Member Functions
virtual	~CIccTagXmlStruct ()
bool	AreElemsUnique () const
bool	AttachElem (icSignature sig, CIccTag *pTag)
bool	DeleteElem (icSignature sig)
virtual void	Describe (std::string &sDescription, int nVerboseness)
virtual void	DetachIO ()
CIccTag *	FindElem (icSignature sig)
CIccTag *	FindElemOfType (icSignature sig, icTagTypeSignature sigType)
virtual const char *	GetClassName () const
TagEntryList *	GetElemList ()
icFloatNumber	GetElemNumberValue (icSignature sig, icFloatNumber defaultValue=0)
virtual const char *	GetExtClassName () const
virtual const char *	GetExtDerivedClassName () const
virtual IIccExtensionTag *	GetExtension ()
IIccStruct *	GetStructHandler ()
virtual icArraySignature	GetTagArrayType () const
virtual icStructSignature	GetTagStructType () const
virtual icTagTypeSignature	GetType () const
virtual bool	IsArrayType ()
virtual bool	IsMBBType ()
virtual bool	IsNumArrayType () const
virtual bool	IsSupported ()
virtual CIccTag *	NewCopy () const
virtual bool	ParseXml (xmlNode *pNode, std::string &parseStr)
virtual bool	Read (icUInt32Number size, CIccIO *pIO)
virtual bool	Read (icUInt32Number size, CIccIO *pIO, CIccProfile *pProfile)
virtual bool	ReadAll ()
virtual bool	SetTagStructType (icStructSignature sig)
virtual bool	ToXml (std::string &xml, std::string blanks="")
virtual icValidateStatus	Validate (std::string sigPath, std::string &sReport, const CIccProfile *pProfile=NULL) const
virtual bool	Write (CIccIO *pIO)

Static Public Member Functions
static CIccTag *	Create (icTagTypeSignature sig)
static std::string	GetElemName (icTagSignature sig, icStructSignature sigThis)
static CIccTagStruct *	ParseMem (icUInt8Number *pMem, icUInt32Number size)

Data Fields
icUInt32Number	m_nReserved

Protected Member Functions
void	Cleanup ()
bool	DetachElem (CIccTag *pTag)
IccTagEntry *	GetElem (CIccTag *pTag) const
IccTagEntry *	GetElem (icSignature sig) const
bool	LoadElem (IccTagEntry *pTagEntry, CIccIO *pIO)
bool	ParseTag (xmlNode *pNode, std::string &parseStr)

Protected Attributes
TagEntryList *	m_ElemEntries
TagPtrList *	m_ElemVals
IIccStruct *	m_pStruct
icStructSignature	m_sigStructType
icUInt32Number	m_tagSize
icUInt32Number	m_tagStart

Detailed Description

Constructor & Destructor Documentation

~CIccTagXmlStruct()

virtual CIccTagXmlStruct::~CIccTagXmlStruct ( )

inlinevirtual

{}

Member Function Documentation

AreElemsUnique()

bool CIccTagStruct::AreElemsUnique ( ) const

inherited

Name: CIccTagStruct::AreElemsUnique

Purpose: For each tag it checks to see if any other tags have the same signature.

Return: true if all tags have unique signatures, or false if there are duplicate tag signatures.

{
  TagEntryList::const_iterator i, j;
 
  for (i=m_ElemEntries->begin(); i!=m_ElemEntries->end(); i++) {
    j=i;
    for (j++; j!= m_ElemEntries->end(); j++) {
      if (i->TagInfo.sig == j->TagInfo.sig)
        return false;
    }
  }
 
  return true;
}

References CIccTagStruct::m_ElemEntries, and icTag::sig.

Referenced by CIccTagStruct::Validate().

Here is the caller graph for this function:

AttachElem()

bool CIccTagStruct::AttachElem ( icSignature  sig, CIccTag *  pTag  )

inherited

Name: CIccTagStruct::AttachTag

Purpose: Assign a tag object to a directory entry in the profile. This will assume ownership of the tag object.

Args: sig - signature of tag 'name' to use to assign tag object with, pTag - pointer to tag object to attach to profile.

Return: true = tag assigned to profile, false - tag not assigned to profile (tag already exists).

{
  IccTagEntry *pEntry = GetElem(sig);
 
  if (pEntry) {
    if (pEntry->pTag == pTag)
      return true;
 
    return false;
  }
 
  IccTagEntry Entry;
  Entry.TagInfo.sig = (icTagSignature)sig;
  Entry.TagInfo.offset = 0;
  Entry.TagInfo.size = 0;
  Entry.pTag = pTag;
 
  m_ElemEntries->push_back(Entry);
 
  TagPtrList::iterator i;
 
  for (i=m_ElemVals->begin(); i!=m_ElemVals->end(); i++)
    if (i->ptr == pTag)
      break;
 
  if (i==m_ElemVals->end()) {
    IccTagPtr TagPtr;
    TagPtr.ptr = pTag;
    m_ElemVals->push_back(TagPtr);
  }
 
  return true;
}

References CIccTagStruct::GetElem(), CIccTagStruct::m_ElemEntries, CIccTagStruct::m_ElemVals, icTag::offset, icTag::sig, and icTag::size.

Referenced by icConvertEncodingProfile(), and ParseTag().

Here is the call graph for this function:

Here is the caller graph for this function:

Cleanup()

void CIccTagStruct::Cleanup ( )

protectedinherited

Name: CIccTagStruct::Cleanup

Purpose: Detach from a pending IO object

{
  TagPtrList::iterator i;
 
  for (i=m_ElemVals->begin(); i!=m_ElemVals->end(); i++) {
    if (i->ptr)
      delete i->ptr;
  }
  m_ElemEntries->clear();
  m_ElemVals->clear();
 
  if (m_pStruct)
    delete m_pStruct;
  m_pStruct = NULL;
  m_sigStructType = icSigUndefinedStruct;
}

References icSigUndefinedStruct, CIccTagStruct::m_ElemEntries, CIccTagStruct::m_ElemVals, CIccTagStruct::m_pStruct, and CIccTagStruct::m_sigStructType.

Referenced by CIccTagStruct::~CIccTagStruct(), CIccTagStruct::operator=(), and CIccTagStruct::Read().

Here is the caller graph for this function:

Create()

CIccTag * CIccTag::Create ( icTagTypeSignature  sig )

staticinherited

Name: CIccTag::Create

Purpose: This is a static tag creator based upon tag signature type

Args: sig = tag type signature

Return: Pointer to Allocated tag

{
  return CIccTagCreator::CreateTag(sig);
}

References CIccTagCreator::CreateTag().

Referenced by CIccDefaultEncProfileConverter::ConvertFromParams(), CIccTagStruct::LoadElem(), CIccProfileXml::ParseTag(), ParseTag(), CIccMpeXmlTintArray::ParseXml(), CIccTagXmlArray::ParseXml(), CIccMpeTintArray::Read(), CIccTagLutAtoB::Read(), CIccTagLut8::Read(), CIccTagLut16::Read(), CIccTagLut8::SetColorSpaces(), CIccTagLut16::SetColorSpaces(), and CIccProfileDescText::SetType().

Here is the call graph for this function:

Here is the caller graph for this function:

DeleteElem()

bool CIccTagStruct::DeleteElem ( icSignature  sig )

inherited

Name: CIccTagStruct::DeleteSubTag

Purpose: Delete tag directory entry with given signature. If no other tag directory entries use the tag object, the tag object will also be deleted.

Args: sig - signature of tag directory entry to remove

Return: true - desired tag directory entry was found and deleted, false - desired tag directory entry was not found

{
  TagEntryList::iterator i;
 
  for (i=m_ElemEntries->begin(); i!=m_ElemEntries->end(); i++) {
    if (i->TagInfo.sig==sig)
      break;
  }
  if (i!=m_ElemEntries->end()) {
    CIccTag *pTag = i->pTag;
    m_ElemEntries->erase(i);
 
    if (!GetElem(pTag)) {
      DetachElem(pTag);
      delete pTag;
    }
    return true;
  }
 
  return false;
}

References CIccTagStruct::DetachElem(), CIccTagStruct::GetElem(), CIccTagStruct::m_ElemEntries, and icTag::sig.

Referenced by icConvertEncodingProfile().

Here is the call graph for this function:

Here is the caller graph for this function:

Describe()

void CIccTagStruct::Describe ( std::string &  sDescription, int  nVerboseness  )

virtualinherited

Name: CIccTagStruct::Describe

Purpose:

Args:

Return:

Reimplemented from CIccTag.

{
  std::string name;
  CIccStructCreator::GetStructSigName(name, m_sigStructType);
 
  sDescription += "BEGIN STRUCT \"";
  sDescription += name + "\"\n";
 
  if (m_pStruct) {
    m_pStruct->Describe(sDescription, nVerboseness);
  }
  else {
    IIccStruct *pStruct = CIccStructCreator::CreateStruct(m_sigStructType, this);
    if (pStruct) {
      pStruct->Describe(sDescription, nVerboseness);
      delete pStruct;
    }
    else {
      CIccStructUnknown structHandler(this);
 
      structHandler.Describe(sDescription, nVerboseness);
    }
  }
  sDescription += "END STRUCT \"";
  sDescription += name + "\"\n";
}

References CIccStructUnknown::CIccStructUnknown(), CIccStructCreator::CreateStruct(), CIccStructUnknown::Describe(), IIccStruct::Describe(), CIccStructCreator::GetStructSigName(), CIccTagStruct::m_pStruct, and CIccTagStruct::m_sigStructType.

Here is the call graph for this function:

DetachElem()

bool CIccTagStruct::DetachElem ( CIccTag *  pTag )

protectedinherited

Name: CIccTagStruct::DetachSubTag

Purpose: Remove association of a tag object from all tag directory entries. Associated tag directory entries will be removed from the tag directory. The tag object is NOT deleted from memory, but is considered to be no longer associated with the CIccTagStruct object. The caller assumes ownership of the tag object.

Args: pTag - pointer to tag object unassociated with the profile object

Return: true - tag object found and unassociated with profile object, false - tag object not found

{
  if (!pTag)
    return false;
  
  TagPtrList::iterator i;
 
  for (i=m_ElemVals->begin(); i!=m_ElemVals->end(); i++) {
    if (i->ptr == pTag)
      break;
  }
 
  if (i==m_ElemVals->end())
    return false;
 
  m_ElemVals->erase(i);
 
  TagEntryList::iterator j;
  for (j=m_ElemEntries->begin(); j!=m_ElemEntries->end();) {
    if (j->pTag == pTag) {
      j=m_ElemEntries->erase(j);
    }
    else
      j++;
  }
  return true;
}

References CIccTagStruct::m_ElemEntries, and CIccTagStruct::m_ElemVals.

Referenced by CIccTagStruct::DeleteElem().

Here is the caller graph for this function:

DetachIO()

virtual void CIccTag::DetachIO ( )

inlinevirtualinherited

Function: ReadAll() - Read All sub data for tag from file. Called by CIccProfile::ReadAll() to read all sub data for tag

Returns true if ReadAll is successful.

{}

FindElem()

CIccTag * CIccTagStruct::FindElem ( icSignature  sig )

inherited

Name: CIccTagStruct::FindElem

Purpose: Finds the tag object associated with the struct entry with the given signature.

Args: sig - element signature to find

Return: The desired tag object, or NULL if unable to find in the struct

{
  IccTagEntry *pEntry = GetElem(sig);
 
  if (pEntry) {
    return pEntry->pTag;
  }
 
  return NULL;
}

References CIccTagStruct::GetElem().

Referenced by CIccStructUnknown::GetElem(), CIccTagStruct::GetElemNumberValue(), CIccStructNamedColor::getName(), ParseTag(), ToXml(), CIccStructNamedColor::Validate(), CIccStructBRDF::Validate(), and CIccStructColorantInfo::Validate().

Here is the call graph for this function:

Here is the caller graph for this function:

FindElemOfType()

CIccTag * CIccTagStruct::FindElemOfType ( icSignature  sig, icTagTypeSignature  sigType  )

inherited

Name: CIccTagStruct::FindElemOfType

Purpose: Finds the tag object associated with the struct entry with the given signature that has a specific tag type.

Args: sig - element signature to find sigType - signature of desired tag type

Return: The desired tag object, or NULL if unable to find in the struct

{
  IccTagEntry *pEntry = GetElem(sig);
 
  if (pEntry && pEntry->pTag && pEntry->pTag->GetType()==sigType) {
    return pEntry->pTag;
  }
 
  return NULL;
}

References CIccTagStruct::GetElem(), and CIccTag::GetType().

Referenced by CIccDefaultEncProfileConverter::ConvertFromParams(), and icGetParamFloatNum().

Here is the call graph for this function:

Here is the caller graph for this function:

GetClassName()

virtual const char * CIccTagXmlStruct::GetClassName ( ) const

inlinevirtual

Reimplemented from CIccTagStruct.

{return "CIccTagXmlStruct"; }

GetElem() [1/2]

IccTagEntry * CIccTagStruct::GetElem ( CIccTag *  pTag ) const

protectedinherited

Name: CIccTagStruct::GetElem

Purpose: Finds the first tag entry that points to the indicated tag object

Args: pTag - pointer to tag object desired to be found

Return: pointer to first tag struct entry that points to the desired tag object, or NULL if tag object is not pointed to by any tag struct entries.

{
  TagEntryList::const_iterator i;
 
  for (i=m_ElemEntries->begin(); i!=m_ElemEntries->end(); i++) {
    if (i->pTag==pTag)
      return (IccTagEntry*)&(i->TagInfo);
  }
 
  return NULL;
}

References CIccTagStruct::m_ElemEntries.

Referenced by CIccTagStruct::DeleteElem().

Here is the caller graph for this function:

GetElem() [2/2]

IccTagEntry * CIccTagStruct::GetElem ( icSignature  sig ) const

protectedinherited

Name: CIccTagStruct::GetElem

Purpose: Get a tag entry with a given signature

Args: sig - signature id to find in tag structure

Return: Pointer to desired tag struct entry, or NULL if not found.

{
  TagEntryList::const_iterator i;
 
  for (i=m_ElemEntries->begin(); i!=m_ElemEntries->end(); i++) {
    if (i->TagInfo.sig==sig)
      return (IccTagEntry*)&(i->TagInfo);
  }
 
  return NULL;
}

References CIccTagStruct::m_ElemEntries, and icTag::sig.

Referenced by CIccTagStruct::AttachElem(), CIccTagStruct::FindElem(), and CIccTagStruct::FindElemOfType().

Here is the caller graph for this function:

GetElemList()

TagEntryList * CIccTagStruct::GetElemList ( )

inlineinherited

{ return m_ElemEntries; }

References CIccTagStruct::m_ElemEntries.

Referenced by CIccStructUnknown::Describe(), IIccStruct::Describe(), and icConvertEncodingProfile().

Here is the caller graph for this function:

GetElemName()

static std::string CIccTagStruct::GetElemName ( icTagSignature  sig, icStructSignature  sigThis  )

staticinherited

GetElemNumberValue()

icFloatNumber CIccTagStruct::GetElemNumberValue ( icSignature  sig, icFloatNumber  defaultValue = 0  )

inherited

Name: CIccTagStruct::GetElemNumberValue

Purpose: Returns the number value associated with the first entry of a CIccTagNumberArray based tag with the given signature.

Args: sig - subtag signature to find defaultValue - value to use if the tag cannot be found, or is not a number tag

Return: The tags value or defaultValue if unable to find subtag in the struct or if the subtag is not a CIccTagNumberArray based tag.

{
  CIccTag *pTag = FindElem(sig);
 
  if (!pTag || !pTag->IsNumArrayType())
    return defaultValue;
 
  CIccTagNumArray *pNumArray = (CIccTagNumArray*)pTag;
  icFloatNumber rv = defaultValue;
 
  pNumArray->GetValues(&rv, 0, 1);
 
  return rv;
}

References CIccTagStruct::FindElem(), CIccTagNumArray::GetValues(), and CIccTag::IsNumArrayType().

Referenced by CIccDefaultEncProfileConverter::ConvertFromParams().

Here is the call graph for this function:

Here is the caller graph for this function:

GetExtClassName()

virtual const char * CIccTagXml::GetExtClassName ( ) const

inlinevirtualinherited

Implements IIccExtensionTag.

{ return "CIccTagXml"; }

Referenced by icProfDescToXml(), and icXmlParseProfDesc().

Here is the caller graph for this function:

GetExtDerivedClassName()

virtual const char * CIccTagXml::GetExtDerivedClassName ( ) const

inlinevirtualinherited

Implements IIccExtensionTag.

Reimplemented in CIccCurveXml.

{ return ""; }

GetExtension()

virtual IIccExtensionTag * CIccTagXmlStruct::GetExtension ( )

inlinevirtual

Reimplemented from CIccTag.

{return this; }

GetStructHandler()

IIccStruct * CIccTagStruct::GetStructHandler ( )

inherited

Name: CIccTagStruct::GetStructHandler

Purpose: Get struct object handler

Args:

Return: Pointer to a IIccStruct object handler for the associated struct type

{
  if (!m_pStruct) {
 
    m_pStruct = CIccStructCreator::CreateStruct(m_sigStructType, this);
  }
  return m_pStruct;
}

References CIccStructCreator::CreateStruct(), CIccTagStruct::m_pStruct, and CIccTagStruct::m_sigStructType.

Referenced by icGetTagStructHandler(), ToXml(), and CIccArrayNamedColor::Validate().

Here is the call graph for this function:

Here is the caller graph for this function:

GetTagArrayType()

virtual icArraySignature CIccTag::GetTagArrayType ( ) const

inlinevirtualinherited

Reimplemented in CIccTagArray.

{ return icSigUndefinedArray; }

References icSigUndefinedArray.

Referenced by icGetTagArrayHandlerOfType(), and CIccProfileXml::ParseTag().

Here is the caller graph for this function:

GetTagStructType()

virtual icStructSignature CIccTagStruct::GetTagStructType ( ) const

inlinevirtualinherited

Reimplemented from CIccTag.

{ return m_sigStructType; }

References CIccTagStruct::m_sigStructType.

Referenced by CIccDefaultEncProfileConverter::ConvertFromParams(), IIccStruct::Describe(), and CIccStructNamedColor::Validate().

Here is the caller graph for this function:

GetType()

virtual icTagTypeSignature CIccTagStruct::GetType ( ) const

inlinevirtualinherited

Function: GetType()

Purpose: Get Tag Type. Each derived tag will implement it's own GetType() function.

Reimplemented from CIccTag.

{ return icSigTagStructType; }

References icSigTagStructType.

Referenced by CIccTagStruct::Write().

Here is the caller graph for this function:

IsArrayType()

virtual bool CIccTag::IsArrayType ( )

inlinevirtualinherited

Reimplemented in CIccTagXYZ, CIccTagChromaticity, CIccTagSparseMatrixArray, CIccTagFixedNum< T, Tsig >, CIccTagNum< T, Tsig >, CIccTagFloatNum< T, Tsig >, and CIccTagData.

{ return false; }

Referenced by MyTagDialog::MyTagDialog(), and DumpTag().

Here is the caller graph for this function:

IsMBBType()

virtual bool CIccTag::IsMBBType ( )

inlinevirtualinherited

Reimplemented in CIccMBB.

{ return false; } //If true then CIccTag can be cast as an CIccMBB 

Referenced by CIccProfileXml::ParseTag().

Here is the caller graph for this function:

IsNumArrayType()

virtual bool CIccTag::IsNumArrayType ( ) const

inlinevirtualinherited

Reimplemented in CIccTagSparseMatrixArray, CIccTagFixedNum< T, Tsig >, CIccTagNum< T, Tsig >, and CIccTagFloatNum< T, Tsig >.

{ return false;} //If true then CIccTag can be cast as a CIccTagNumArray

Referenced by CIccArrayNamedColor::FindDeviceColor(), CIccArrayNamedColor::FindPcsColor(), CIccArrayNamedColor::FindSpectralColor(), CIccTagStruct::GetElemNumberValue(), CIccStructNamedColor::GetNumArray(), CIccMpeXmlTintArray::ParseXml(), and CIccMpeTintArray::Read().

Here is the caller graph for this function:

IsSupported()

virtual bool CIccTag::IsSupported ( )

inlinevirtualinherited

Function: IsSupported(size, pIO) - Check if tag fully supported for apply purposes. By Default inherited classes are supported. Unknown tag types are not supported.

Returns true if tag type is supported.

Reimplemented in CIccTagUnknown, CIccTagEmbeddedProfile, and CIccTagMultiProcessElement.

{ return true; }

LoadElem()

bool CIccTagStruct::LoadElem ( IccTagEntry *  pTagEntry, CIccIO *  pIO  )

protectedinherited

Name: CIccTagStruct::LoadSubTag

Purpose: This will load from the indicated IO object and associate a tag object to a tag directory entry. Nothing happens if tag directory entry is associated with a tag object.

Args: pTagEntry - pointer to tag directory entry, pIO - pointer to IO object to read tag object data from

Return: true - tag directory object associated with tag directory entry, false - failure

{
  if (!pTagEntry)
    return false;
 
  if (pTagEntry->pTag)
    return true;
 
  icUInt32Number headerSize = sizeof(icTagTypeSignature) + 
    sizeof(icUInt32Number) + 
    sizeof(icUInt32Number);
 
  if (pTagEntry->TagInfo.offset<headerSize ||
      !pTagEntry->TagInfo.size ||
      pTagEntry->TagInfo.offset+pTagEntry->TagInfo.size > m_tagSize) {
    return false;
  }
 
  icTagTypeSignature sigType;
 
  icUInt32Number offset = pTagEntry->TagInfo.offset + m_tagStart;
 
  //First we need to get the tag type to create the right kind of tag
  if (pIO->Seek(offset, icSeekSet)!=offset)
    return false;
 
  if (!pIO->Read32(&sigType))
    return false;
 
  CIccTag *pTag = CIccTag::Create(sigType);
 
  if (!pTag)
    return false;
 
  //Now seek back to where the tag starts so the created tag object can read
  //in its data.
  //First we need to get the tag type to create the right kind of tag
  if (pIO->Seek(offset, icSeekSet)!=offset) {
    delete pTag;
    return false;
  }
 
  if (!pTag->Read(pTagEntry->TagInfo.size, pIO)) {
    delete pTag;
    return false;
  }
 
  pTagEntry->pTag = pTag;
 
  IccTagPtr TagPtr;
 
  TagPtr.ptr = pTag;
 
  m_ElemVals->push_back(TagPtr);
 
  TagEntryList::iterator i;
 
  for (i=m_ElemEntries->begin(); i!= m_ElemEntries->end(); i++) {
    if (i->TagInfo.offset == pTagEntry->TagInfo.offset &&
        i->pTag != pTag)
      i->pTag = pTag; 
  }
  
  return true;
}

References CIccTag::Create(), icSeekSet, CIccTagStruct::m_ElemEntries, CIccTagStruct::m_ElemVals, CIccTagStruct::m_tagSize, CIccTagStruct::m_tagStart, icTag::offset, CIccTag::Read(), CIccIO::Read32(), CIccIO::Seek(), and icTag::size.

Referenced by CIccTagStruct::Read().

Here is the call graph for this function:

Here is the caller graph for this function:

NewCopy()

virtual CIccTag * CIccTagStruct::NewCopy ( ) const

inlinevirtualinherited

Function: NewCopy(sDescription) Each derived tag will implement it's own NewCopy() function.

Parameter(s): none

Returns a new CIccTag object that is a copy of this object.

Reimplemented from CIccTag.

{ return new CIccTagStruct(*this);}

References CIccTagStruct::CIccTagStruct().

Here is the call graph for this function:

ParseMem()

CIccTagStruct * CIccTagStruct::ParseMem ( icUInt8Number *  pMem, icUInt32Number  size  )

staticinherited

Name: CIccTagStruct::ParseMem

Purpose:

Args:

Return:

{
  CIccMemIO IO;
 
  if (!IO.Attach(pMem, size))
    return NULL;
 
  CIccTagStruct *pTags = new CIccTagStruct;
 
  if (!pTags->Read(size, &IO)) {
    delete pTags;
    return NULL;
  }
 
  return pTags;
}

References CIccMemIO::Attach(), and CIccTagStruct::Read().

Here is the call graph for this function:

ParseTag()

bool CIccTagXmlStruct::ParseTag ( xmlNode *  pNode, std::string &  parseStr  )

protected

Name: CIccTagXmlStruct::ParseTag

Purpose: This will load from the indicated IO object and associate a tag object to a tag directory entry. Nothing happens if tag directory entry is associated with a tag object.

Args: pNode - pointer to xmlNode object to parse from

Return: true - tag from node successfully parsed, false - failure

{
  xmlAttr *attr;
 
  if (pNode->type != XML_ELEMENT_NODE) {// || icXmlStrCmp(pNode->name, "Tag")) {
    parseStr += "Invalid Tag Node: ";
    parseStr += (const char *)pNode->name;
    parseStr += "\n";
    return false;
  }
 
  CIccTag *pTag = NULL;
 
  std::string nodeName = (icChar*)pNode->name;
  icSignature sigTag;
  if (m_pStruct)
    sigTag = m_pStruct->GetElemSig(nodeName.c_str());
  else
    sigTag = 0;
 
  if (sigTag != 0 || nodeName == "PrivateSubTag") { //Parsing of XML tags by name
    if (nodeName == "PrivateSubTag") {
      const char *tagSig = icXmlAttrValue(pNode, "TagSignature", "");
      if (tagSig[0]) {
        sigTag = (icTagSignature)icGetSigVal(tagSig);
      }
      else {
        parseStr += "Invalid TagSignature for PrivateSubTag\n";
        return false;
      }
    }
 
    const char *sameAs = icXmlAttrValue(pNode, "SameAs", "");
 
    if (sameAs[0]) {
      icTagSignature sigParentTag = icGetTagNameSig(sameAs);
      if (!strcmp(sameAs, "PrivateSubTag") || sigParentTag == icSigUnknownTag) {
        const char *sameAsSig = icXmlAttrValue(pNode, "SameAsSignature", "");
        if (sameAsSig[0]) {
          sigParentTag = (icTagSignature)icGetSigVal(sameAsSig);
        }
        else {
          parseStr += "Invalid SameAsSignature for PrivateSubTag\n";
          return false;
        }
      }
      pTag = this->FindElem(sigParentTag);
      if (pTag) {
        AttachElem(sigTag, pTag);
      }
      else {
        parseStr += "SameAs tag ";
        parseStr += sameAs;
        parseStr += " for ";
        parseStr += nodeName + " does not exist\n";
        return false;
      }
 
      return true;
    }
    else { //Parse the type node as the first child
      xmlNode *pTypeNode;
      for (pTypeNode = pNode->children; pTypeNode; pTypeNode = pTypeNode->next) {
        if (pTypeNode->type == XML_ELEMENT_NODE) {
          break;
        }
      }
 
      if (!pTypeNode) {
        parseStr += "No tag type node defined for ";
        parseStr += nodeName;
        parseStr += "\n";
        return false;
      }
 
      // get the tag type signature
      icTagTypeSignature sigType = icGetTypeNameTagSig((const icChar*)pTypeNode->name);
 
      if (sigType == icSigUnknownType) {
        xmlAttr *attr = icXmlFindAttr(pTypeNode, "type");
        sigType = (icTagTypeSignature)icGetSigVal((icChar*)icXmlAttrValue(attr));
      }
 
      CIccInfo info;
 
      // create a tag based on the signature
      pTag = CIccTag::Create(sigType);
 
      IIccExtensionTag *pExt;
 
      if (pTag && (pExt = pTag->GetExtension()) && !strcmp(pExt->GetExtClassName(), "CIccTagXml")) {
        CIccTagXml* pXmlTag = (CIccTagXml*)pExt;
 
        if (pXmlTag->ParseXml(pTypeNode->children, parseStr)) {
          if ((attr = icXmlFindAttr(pTypeNode, "reserved"))) {
            sscanf(icXmlAttrValue(attr), "%u", &pTag->m_nReserved);
          }
          AttachElem(sigTag, pTag);
        }
        else {
          parseStr += "Unable to Parse \"";
          parseStr += (const char*)pTypeNode->name;
          parseStr += "\" (";
          parseStr += nodeName;
          parseStr += ") Tag\n";
          return false;
        }
      }
      else {
        parseStr += "Invalid tag extension for \"";
        parseStr += (const char*)pTypeNode->name;
        parseStr += "\" (";
        parseStr += nodeName;
        parseStr += ") Tag\n";
        return false;
      }
    }
  }
  else {  //Legacy parsing of XML tags by type
    sigTag = (icTagSignature)0;
    // get the tag type signature
    icTagTypeSignature sigType = icGetTypeNameTagSig(nodeName.c_str());
 
    if (sigType == icSigUnknownType) {
      xmlAttr *attr = icXmlFindAttr(pNode, "type");
      sigType = (icTagTypeSignature)icGetSigVal((icChar*)icXmlAttrValue(attr));
    }
 
    CIccInfo info;
 
    // create a tag based on the signature
    pTag = CIccTag::Create(sigType);
 
    IIccExtensionTag *pExt;
 
    if (pTag && (pExt = pTag->GetExtension()) && !strcmp(pExt->GetExtClassName(), "CIccTagXml")) {
      CIccTagXml* pXmlTag = (CIccTagXml*)pExt;
 
      if (pXmlTag->ParseXml(pNode->children, parseStr)) {
        if ((attr = icXmlFindAttr(pNode, "reserved"))) {
          sscanf(icXmlAttrValue(attr), "%u", &pTag->m_nReserved);
        }
 
        for (xmlNode *tagSigNode = pNode->children; tagSigNode; tagSigNode = tagSigNode->next) {
          if (tagSigNode->type == XML_ELEMENT_NODE && !icXmlStrCmp(tagSigNode->name, "TagSignature")) {
            sigTag = (icTagSignature)icGetSigVal((const icChar*)tagSigNode->children->content);
            AttachElem(sigTag, pTag);
          }
        }
      }
      else {
        parseStr += "Unable to Parse \"";
        parseStr += info.GetTagTypeSigName(sigType);
        parseStr += "\" (";
        parseStr += nodeName;
        parseStr += ") Tag\n";
        return false;
      }
    }
    else {
      parseStr += "Invalid tag extension for \"";
      parseStr += info.GetTagTypeSigName(sigType);
      parseStr += "\" (";
      parseStr += nodeName;
      parseStr += ") Tag\n";
      return false;
    }
  }
 
  return true;
}

References CIccTagStruct::AttachElem(), CIccTag::Create(), CIccTagStruct::FindElem(), IIccStruct::GetElemSig(), IIccExtensionTag::GetExtClassName(), CIccTag::GetExtension(), CIccInfo::GetTagTypeSigName(), icGetSigVal(), icGetTagNameSig(), icGetTypeNameTagSig(), icXmlAttrValue(), icXmlAttrValue(), icXmlFindAttr(), CIccTag::m_nReserved, CIccTagStruct::m_pStruct, and CIccTagXml::ParseXml().

Referenced by ParseXml().

Here is the call graph for this function:

Here is the caller graph for this function:

ParseXml()

bool CIccTagXmlStruct::ParseXml ( xmlNode *  pNode, std::string &  parseStr  )

virtual

Implements CIccTagXml.

{
  // parse each tag
  xmlNode *tagNode, *firstNode=pNode;
 
  for (; pNode; pNode = pNode->next) {
    if (pNode->type == XML_ELEMENT_NODE)
      break;
  }
  if (!pNode) {
    parseStr += "Invalid Tag Structure: ";
    if (firstNode)
      parseStr += (const char*)firstNode->name;
    else
      parseStr += ":";
    parseStr += "\n";
    return false;
  }
 
  std::string nodeName = (icChar*)pNode->name;
 
  icStructSignature sigStruct = CIccStructCreator::GetStructSig(nodeName.c_str());
 
  if (sigStruct) {
    SetTagStructType(sigStruct);
    pNode = pNode->children;
  }
  else {
    tagNode = icXmlFindNode(firstNode, "StructureSignature");
    if (!tagNode) {
      parseStr += "Unable to find StructureSignature\n";
      return false;
    }
 
    if (tagNode->type == XML_ELEMENT_NODE && tagNode->children && tagNode->children->content) {
 
      sigStruct = (icStructSignature)icGetSigVal(tagNode->children ? (const icChar*)tagNode->children->content : "");
      SetTagStructType(sigStruct);
    }
    else {
      parseStr += "Invalid XNode type for StructureSignature\n";
      return false;
    }
  }
 
  tagNode = icXmlFindNode(pNode, "MemberTags");
  if (!tagNode) {
    parseStr += "Unable to find structure MemberTags\n";
    return false;
  }
 
  for (tagNode = tagNode->children; tagNode; tagNode = tagNode->next) {
    if (tagNode->type == XML_ELEMENT_NODE) {
      if (!ParseTag(tagNode, parseStr)) {
        parseStr += "Failed to parse tag member (";
        parseStr += (char*)tagNode->name;
        parseStr += ")\n";
        return false;
      }
    }
  }
 
  return true;
}

References CIccStructCreator::GetStructSig(), icGetSigVal(), icXmlFindNode(), ParseTag(), and CIccTagStruct::SetTagStructType().

Here is the call graph for this function:

Read() [1/2]

bool CIccTagStruct::Read ( icUInt32Number  size, CIccIO *  pIO  )

virtualinherited

Name: CIccTagStruct::Read

Purpose:

Args:

Return:

Reimplemented from CIccTag.

{
  icTagTypeSignature sig;
 
  m_tagSize = size;
  
  icUInt32Number headerSize = sizeof(icTagTypeSignature) + 
    sizeof(icUInt32Number) + 
    sizeof(icStructSignature) +
    sizeof(icUInt32Number);
 
  if (headerSize > size)
    return false;
 
  if (!pIO) {
    return false;
  }
 
  Cleanup();
 
  m_tagStart = pIO->Tell();
 
  if (!pIO->Read32(&sig))
    return false;
 
  if (!pIO->Read32(&m_nReserved))
    return false;
 
  icStructSignature sigStructType;
 
  if (!pIO->Read32(&sigStructType))
    return false;
 
  SetTagStructType(sigStructType);
 
  icUInt32Number count, i;
  IccTagEntry TagEntry;
 
  TagEntry.pTag = NULL;
 
  if (!pIO->Read32(&count))
    return false;
 
  if (headerSize + (icUInt64Number)count*sizeof(icUInt32Number)*3 > size)
    return false;
 
  //Read TagDir
  for (i=0; i<count; i++) {
    if (!pIO->Read32(&TagEntry.TagInfo.sig) ||
        !pIO->Read32(&TagEntry.TagInfo.offset) ||
        !pIO->Read32(&TagEntry.TagInfo.size)) {
      return false;
    }
    m_ElemEntries->push_back(TagEntry);
  }
 
  TagEntryList::iterator entry;
 
  for (entry=m_ElemEntries->begin(); entry!=m_ElemEntries->end(); entry++) {
    if (!LoadElem((IccTagEntry*)&(entry->TagInfo), pIO)) {
      Cleanup();
      return false;
    }
  }
 
 
  return true;
}

References CIccTagStruct::Cleanup(), CIccTagStruct::LoadElem(), CIccTagStruct::m_ElemEntries, CIccTag::m_nReserved, CIccTagStruct::m_tagSize, CIccTagStruct::m_tagStart, icTag::offset, CIccIO::Read32(), CIccTagStruct::SetTagStructType(), icTag::sig, icTag::size, and CIccIO::Tell().

Referenced by CIccTagStruct::ParseMem().

Here is the call graph for this function:

Here is the caller graph for this function:

Read() [2/2]

virtual bool CIccTag::Read ( icUInt32Number  size, CIccIO *  pIO, CIccProfile *  pProfile  )

inlinevirtualinherited

Function: Read(size, pIO) - Read tag from file. Each derived tag will implement it's own Read() function.

Parameter(s): size - number of bytes in tag including the type signature. pIO - IO object used to read in tag. The IO object should already be initialized to point to the begining of the tag.

Returns true if Read is successful.

Reimplemented in CIccTagEmbeddedProfile.

{ return Read(size, pIO); }

References CIccTag::Read().

Here is the call graph for this function:

ReadAll()

virtual bool CIccTag::ReadAll ( )

inlinevirtualinherited

Function: ReadAll() - Read All sub data for tag from file. Called by CIccProfile::ReadAll() to read all sub data for tag

Returns true if ReadAll is successful.

Reimplemented in CIccTagEmbeddedProfile.

{ return true; }

SetTagStructType()

bool CIccTagStruct::SetTagStructType ( icStructSignature  sig )

virtualinherited

Name: CIccTagStruct::SetTagStructType

Purpose:

Args:

Return:

{
  if (m_pStruct)
    delete m_pStruct;
 
  m_sigStructType = sig;
  m_pStruct = CIccStructCreator::CreateStruct(m_sigStructType, this);
 
  return m_pStruct != NULL;
}

References CIccStructCreator::CreateStruct(), CIccTagStruct::m_pStruct, and CIccTagStruct::m_sigStructType.

Referenced by ParseXml(), and CIccTagStruct::Read().

Here is the call graph for this function:

Here is the caller graph for this function:

ToXml()

bool CIccTagXmlStruct::ToXml ( std::string &  xml, std::string  blanks = ""  )

virtual

Implements CIccTagXml.

{
  std::string info;
  char buf[256], fix[256], line[256];
  IIccStruct *pStruct = GetStructHandler();
 
  const icChar *structName = ((pStruct != NULL) ? pStruct->GetDisplayName() : NULL);
  blanks += "  ";
 
   if (structName && strcmp(structName, "privateStruct")) {
     sprintf(line, "<%s> <MemberTags>\n", structName);
   }
   else {
     // print out the struct signature
     sprintf(line, "<privateStruct StructSignature=\"%s\"/> <MemberTags>\n", icFixXml(fix, icGetSigStr(buf, m_sigStructType)));
     structName = "privateStruct";
   }
 
  xml += blanks + line;
  TagEntryList::iterator i, j;
  std::set<icTagSignature> sigSet;
  CIccInfo Fmt;
  IccOffsetTagSigMap offsetTags;
 
  for (i=m_ElemEntries->begin(); i!=m_ElemEntries->end(); i++) {
    if (sigSet.find(i->TagInfo.sig)==sigSet.end()) {
      CIccTag *pTag = FindElem(i->TagInfo.sig);
 
      if (pTag) {
        CIccTagXml *pTagXml = (CIccTagXml*)(pTag->GetExtension());
        if (pTagXml) {
          IccOffsetTagSigMap::iterator prevTag = offsetTags.find(i->TagInfo.offset);
          std::string tagName = ((pStruct!=NULL) ? pStruct->GetElemName((icSignature)i->TagInfo.sig) : "");
          if (prevTag == offsetTags.end()) {
            const icChar* tagSig = icGetTagSigTypeName(pTag->GetType());
 
            if (tagName.size() && strncmp(tagName.c_str(), "PrivateSubTag", 13)) {
              sprintf(line, "  <%s>", icFixXml(fix, tagName.c_str()));
            }
            else {
              sprintf(line, "  <PrivateSubTag TagSignature=\"%s\">", icFixXml(fix, icGetSigStr(buf, i->TagInfo.sig)));
              tagName = "PrivateSubTag";
            }
            xml += blanks + line;
 
            // PrivateType - a type that does not belong to the list in the icc specs - custom for vendor.
            if (!strcmp("PrivateType", tagSig))
              sprintf(line, " <PrivateType type=\"%s\">\n", icFixXml(fix, icGetSigStr(buf, pTag->GetType())));
            else
              sprintf(line, " <%s>\n", tagSig); //parent node is the tag type
 
            xml += line;
            j = i;
#if 0
            // print out the tag signature (there is at least one)
            sprintf(line, "  <TagSignature>%s</TagSignature>\n", icFixXml(fix, icGetSigStr(buf, i->TagInfo.sig)));
            xml += blanks + line;
 
            sigSet.insert(i->TagInfo.sig);
 
            // print out the rest of the tag signatures
            for (j++; j != m_ElemEntries->end(); j++) {
              if (j->pTag == i->pTag || j->TagInfo.offset == i->TagInfo.offset) {
                sprintf(line, "  <TagSignature>%s</TagSignature>\n", icFixXml(fix, icGetSigStr(buf, j->TagInfo.sig)));
                xml += blanks + line;
                sigSet.insert(j->TagInfo.sig);
              }
            }
            // if (pTag->m_nReserved) {
            //   sprintf(line, " Reserved=\"%08x\"", pTag->m_nReserved);
            //   xml += line;
            // }
            // xml += ">\n";
#endif
            //convert the rest of the tag to xml
            if (!pTagXml->ToXml(xml, blanks + "    ")) {
              printf("Unable to output sub-tag with type %s\n", icGetSigStr(buf, i->TagInfo.sig));
              return false;
            }
            sprintf(line, "  </%s> </%s>\n", tagSig, tagName.c_str());
            xml += blanks + line;
            offsetTags[i->TagInfo.offset] = i->TagInfo.sig;
          }
          else {
            std::string prevTagName = ((pStruct != NULL) ? pStruct->GetElemName(prevTag->second) : "");
            char fix2[200];
 
            if (tagName.size() && strncmp(tagName.c_str(), "PrivateSubTag", 13))
              sprintf(line, "    <%s SameAs=\"%s\"", icFixXml(fix, tagName.c_str()), icFixXml(fix2, prevTagName.c_str())); //parent node is the tag type
            else
              sprintf(line, "    <PrivateSubTag TagSignature=\"%s\" SameAs=\"%s\"", icFixXml(fix2, icGetSigStr(buf, i->TagInfo.sig)), icFixXml(fix, prevTagName.c_str()));
 
            xml += line;
            if (prevTagName.size() || !strncmp(prevTagName.c_str(), "PrivateSubTag", 13)) {
              sprintf(line, " SameAsSignature=\"%s\"", icFixXml(fix2, icGetSigStr(buf, prevTag->second)));
              xml += line;
            }
 
            xml += "/>\n";
          }
        }
        else {
          printf("Non XML tag in list with type %s!\n", icGetSigStr(buf, i->TagInfo.sig));
          return false;
        }
      }
      else {
        printf("Unable to find tag with type %s!\n", icGetSigStr(buf, i->TagInfo.sig));
        return false;
      }
    }
  }
 
  xml += blanks + "</MemberTags> </" + structName + ">\n";
  return true;
}

References CIccTagStruct::FindElem(), IIccStruct::GetDisplayName(), IIccStruct::GetElemName(), CIccTag::GetExtension(), CIccTagStruct::GetStructHandler(), CIccTag::GetType(), icFixXml(), icGetSigStr(), icGetTagSigTypeName(), CIccTagStruct::m_ElemEntries, CIccTagStruct::m_sigStructType, icTag::offset, icTag::sig, and CIccTagXml::ToXml().

Here is the call graph for this function:

Validate()

icValidateStatus CIccTagStruct::Validate ( std::string  sigPath, std::string &  sReport, const CIccProfile *  pProfile = NULL  ) const

virtualinherited

Name: CIccTagStruct::Validate

Purpose:

Args:

Return:

Reimplemented from CIccTag.

{ 
  icValidateStatus rv = CIccTag::Validate(sigPath, sReport, pProfile);
 
  CIccInfo Info;
  std::string sSigPathName = Info.GetSigPathName(sigPath);
 
  // Check for duplicate tags
  if (!AreElemsUnique()) {
    sReport += icMsgValidateWarning;
    sReport += sSigPathName;
    sReport += " - There are duplicate elements.\n";
    rv =icMaxStatus(rv, icValidateWarning);
  }
 
  if (m_pStruct) {  //Should call GetStructHandler before validate to get 
    rv = icMaxStatus(rv, m_pStruct->Validate(sigPath, sReport, pProfile));
  }
  else {
    sReport += "Unknown tag struct type - Validating struct sub-tags\n";
    rv = icMaxStatus(rv, icValidateWarning);
 
    // Per Tag tests
    TagEntryList::iterator i;
    for (i = m_ElemEntries->begin(); i != m_ElemEntries->end(); i++) {
      rv = icMaxStatus(rv, i->pTag->Validate(sigPath + icGetSigPath(i->TagInfo.sig), sReport, pProfile));
    }
  }
 
  return rv;
}

References CIccTagStruct::AreElemsUnique(), CIccInfo::GetSigPathName(), icGetSigPath(), icMaxStatus(), icMsgValidateWarning, icValidateWarning, CIccTagStruct::m_ElemEntries, CIccTagStruct::m_pStruct, icTag::sig, CIccTag::Validate(), and IIccStruct::Validate().

Here is the call graph for this function:

Write()

bool CIccTagStruct::Write ( CIccIO *  pIO )

virtualinherited

Name: CIccTagStruct::Write

Purpose:

Args:

Return:

Reimplemented from CIccTag.

{
  icTagTypeSignature sig = GetType();
 
  if (!pIO)
    return false;
 
  m_tagStart = pIO->Tell();
 
  if (!pIO->Write32(&sig))
    return false;
 
  if (!pIO->Write32(&m_nReserved))
    return false;
 
  if (!pIO->Write32(&m_sigStructType))
    return false;
 
  TagEntryList::iterator i, j;
  icUInt32Number count;
 
  for (count=0, i=m_ElemEntries->begin(); i!= m_ElemEntries->end(); i++) {
    if (i->pTag)
      count++;
  }
 
  pIO->Write32(&count);
 
  icUInt32Number dirpos = pIO->Tell();
 
  //Write Unintialized TagDir
  for (i=m_ElemEntries->begin(); i!= m_ElemEntries->end(); i++) {
    if (i->pTag) {
      i->TagInfo.offset = 0;
      i->TagInfo.size = 0;
 
      pIO->Write32(&i->TagInfo.sig);
      pIO->Write32(&i->TagInfo.offset);
      pIO->Write32(&i->TagInfo.size);
    }
  }
 
  //Write Tags
  for (i=m_ElemEntries->begin(); i!= m_ElemEntries->end(); i++) {
    if (i->pTag) {
      for (j=m_ElemEntries->begin(); j!=i; j++) {
        if (i->pTag == j->pTag)
          break;
      }
 
      if (i==j) {
        i->TagInfo.offset = pIO->GetLength();
        i->pTag->Write(pIO);
        i->TagInfo.size = pIO->GetLength() - i->TagInfo.offset;
        i->TagInfo.offset -= m_tagStart;
 
        pIO->Align32();
      }
      else {
        i->TagInfo.offset = j->TagInfo.offset;
        i->TagInfo.size = j->TagInfo.size;
      }
    }
  }
  icUInt32Number epos = pIO->Tell();
 
  pIO->Seek(dirpos, icSeekSet);
 
  //Write TagDir with offsets and sizes
  for (i=m_ElemEntries->begin(); i!= m_ElemEntries->end(); i++) {
    if (i->pTag) {
      pIO->Write32(&i->TagInfo.sig);
      pIO->Write32(&i->TagInfo.offset);
      pIO->Write32(&i->TagInfo.size);
    }
  }
 
  pIO->Seek(epos, icSeekSet);
 
 
  return true;
}

References CIccIO::Align32(), CIccIO::GetLength(), CIccTagStruct::GetType(), icSeekSet, CIccTagStruct::m_ElemEntries, CIccTag::m_nReserved, CIccTagStruct::m_sigStructType, CIccTagStruct::m_tagStart, icTag::offset, CIccIO::Seek(), icTag::sig, icTag::size, CIccIO::Tell(), CIccTag::Write(), and CIccIO::Write32().

Here is the call graph for this function:

Field Documentation

m_ElemEntries

TagEntryList* CIccTagStruct::m_ElemEntries

protectedinherited

Referenced by CIccTagStruct::CIccTagStruct(), CIccTagStruct::CIccTagStruct(), CIccTagStruct::~CIccTagStruct(), CIccTagStruct::AreElemsUnique(), CIccTagStruct::AttachElem(), CIccTagStruct::Cleanup(), CIccTagStruct::DeleteElem(), CIccTagStruct::DetachElem(), CIccTagStruct::GetElem(), CIccTagStruct::GetElem(), CIccTagStruct::GetElemList(), IIccStruct::getTagEntries(), CIccTagStruct::LoadElem(), CIccTagStruct::operator=(), CIccTagStruct::Read(), ToXml(), CIccTagStruct::Validate(), and CIccTagStruct::Write().

m_ElemVals

TagPtrList* CIccTagStruct::m_ElemVals

protectedinherited

Referenced by CIccTagStruct::CIccTagStruct(), CIccTagStruct::CIccTagStruct(), CIccTagStruct::~CIccTagStruct(), CIccTagStruct::AttachElem(), CIccTagStruct::Cleanup(), CIccTagStruct::DetachElem(), CIccTagStruct::LoadElem(), and CIccTagStruct::operator=().

m_nReserved

icUInt32Number CIccTag::m_nReserved

inherited

Referenced by CIccTag::CIccTag(), CIccTagMultiProcessElement::CIccTagMultiProcessElement(), CIccTagMultiProcessElement::CIccTagMultiProcessElement(), CIccTagMultiProcessElement::operator=(), CIccProfileXml::ParseTag(), ParseTag(), CIccMpeXmlTintArray::ParseXml(), CIccTagXmlArray::ParseXml(), CIccTagText::Read(), CIccTagUtf8Text::Read(), CIccTagZipUtf8Text::Read(), CIccTagUtf16Text::Read(), CIccTagTextDescription::Read(), CIccTagSignature::Read(), CIccTagNamedColor2::Read(), CIccTagXYZ::Read(), CIccTagChromaticity::Read(), CIccTagCicp::Read(), CIccTagSparseMatrixArray::Read(), CIccTagFixedNum< T, Tsig >::Read(), CIccTagNum< T, Tsig >::Read(), CIccTagFloatNum< T, Tsig >::Read(), CIccTagMeasurement::Read(), CIccTagMultiLocalizedUnicode::Read(), CIccTagData::Read(), CIccTagDateTime::Read(), CIccTagColorantOrder::Read(), CIccTagColorantTable::Read(), CIccTagViewingConditions::Read(), CIccTagProfileSeqDesc::Read(), CIccTagResponseCurveSet16::Read(), CIccTagSpectralDataInfo::Read(), CIccTagSpectralViewingConditions::Read(), CIccTagEmbeddedHeightImage::Read(), CIccTagEmbeddedNormalImage::Read(), CIccTagStruct::Read(), CIccTagArray::Read(), CIccTagDict::Read(), CIccTagCurve::Read(), CIccTagParametricCurve::Read(), CIccTagLutAtoB::Read(), CIccTagLut8::Read(), CIccTagLut16::Read(), CIccTagGamutBoundaryDesc::Read(), CIccTagMultiProcessElement::Read(), CIccTagProfileSequenceId::Read(), CIccTagEmbeddedProfile::Read(), CIccTag::Validate(), CIccTagText::Write(), CIccTagUtf8Text::Write(), CIccTagZipUtf8Text::Write(), CIccTagUtf16Text::Write(), CIccTagTextDescription::Write(), CIccTagSignature::Write(), CIccTagNamedColor2::Write(), CIccTagXYZ::Write(), CIccTagChromaticity::Write(), CIccTagCicp::Write(), CIccTagSparseMatrixArray::Write(), CIccTagFixedNum< T, Tsig >::Write(), CIccTagNum< T, Tsig >::Write(), CIccTagFloatNum< T, Tsig >::Write(), CIccTagMeasurement::Write(), CIccTagMultiLocalizedUnicode::Write(), CIccTagData::Write(), CIccTagDateTime::Write(), CIccTagColorantOrder::Write(), CIccTagColorantTable::Write(), CIccTagViewingConditions::Write(), CIccTagProfileSeqDesc::Write(), CIccTagResponseCurveSet16::Write(), CIccTagSpectralDataInfo::Write(), CIccTagSpectralViewingConditions::Write(), CIccTagEmbeddedHeightImage::Write(), CIccTagEmbeddedNormalImage::Write(), CIccTagStruct::Write(), CIccTagArray::Write(), CIccTagDict::Write(), CIccTagEmbeddedProfile::Write(), CIccTagCurve::Write(), CIccTagParametricCurve::Write(), CIccTagLutAtoB::Write(), CIccTagLut8::Write(), CIccTagLut16::Write(), CIccTagGamutBoundaryDesc::Write(), CIccTagMultiProcessElement::Write(), and CIccTagProfileSequenceId::Write().

m_pStruct

IIccStruct* CIccTagStruct::m_pStruct

protectedinherited

Referenced by CIccTagStruct::CIccTagStruct(), CIccTagStruct::CIccTagStruct(), CIccTagStruct::~CIccTagStruct(), CIccTagStruct::Cleanup(), CIccTagStruct::Describe(), CIccTagStruct::GetStructHandler(), CIccTagStruct::operator=(), ParseTag(), CIccTagStruct::SetTagStructType(), and CIccTagStruct::Validate().

m_sigStructType

icStructSignature CIccTagStruct::m_sigStructType

protectedinherited

Referenced by CIccTagStruct::CIccTagStruct(), CIccTagStruct::Cleanup(), CIccTagStruct::Describe(), CIccTagStruct::GetStructHandler(), CIccTagStruct::GetTagStructType(), CIccTagStruct::operator=(), CIccTagStruct::SetTagStructType(), ToXml(), and CIccTagStruct::Write().

m_tagSize

icUInt32Number CIccTagStruct::m_tagSize

protectedinherited

Referenced by CIccTagStruct::LoadElem(), and CIccTagStruct::Read().

m_tagStart

icUInt32Number CIccTagStruct::m_tagStart

protectedinherited

Referenced by CIccTagStruct::LoadElem(), CIccTagStruct::Read(), and CIccTagStruct::Write().

---

The documentation for this class was generated from the following files:

• IccXML/IccLibXML/IccTagXml.h
• IccXML/IccLibXML/IccTagXml.cpp