#include <IccTagXml.h>

Inheritance diagram for CIccTagXmlStruct:

Collaboration diagram for CIccTagXmlStruct:

Public Member Functions
virtual const char *	GetClassName () const

virtual IIccExtensionTag *	GetExtension ()

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

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

virtual	~CIccTagXmlStruct ()

Public Member Functions inherited from CIccTagStruct
bool	AreElemsUnique () const
	Name: CIccTagStruct::AreElemsUnique.

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

	CIccTagStruct ()
	Name: CIccTagStruct::CIccTagStruct.

	CIccTagStruct (const CIccTagStruct &lut)
	Name: CIccTagStruct::CIccTagStruct.

bool	DeleteElem (icSignature sig)
	Name: CIccTagStruct::DeleteSubTag.

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

CIccTag *	FindElem (icSignature sig)
	Name: CIccTagStruct::FindElem.

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

TagEntryList *	GetElemList ()

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

IIccStruct *	GetStructHandler ()
	Name: CIccTagStruct::GetStructHandler.

virtual icStructSignature	GetTagStructType () const

virtual icTagTypeSignature	GetType () const
	Function: GetType()

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

CIccTagStruct &	operator= (const CIccTagStruct &lut)
	Name: &operator=.

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

virtual bool	SetTagStructType (icStructSignature sig)
	Name: CIccTagStruct::SetTagStructType.

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

virtual bool	Write (CIccIO *pIO)
	Name: CIccTagStruct::Write.

virtual	~CIccTagStruct ()
	Name: CIccTagStruct::~CIccTagStruct.

Public Member Functions inherited from CIccTag
	CIccTag ()
	Name: CIccTag::CIccTag.

virtual void	DetachIO ()
	Function: ReadAll() - Read All sub data for tag from file.

virtual icArraySignature	GetTagArrayType () const

virtual bool	IsArrayType ()

virtual bool	IsMBBType ()

virtual bool	IsNumArrayType () const

virtual bool	IsSupported ()
	Function: IsSupported(size, pIO) - Check if tag fully supported for apply purposes.

virtual bool	Read (icUInt32Number size, CIccIO pIO, CIccProfile pProfile)
	Function: Read(size, pIO) - Read tag from file.

virtual bool	ReadAll ()
	Function: ReadAll() - Read All sub data for tag from file.

virtual	~CIccTag ()
	Name: CIccTag::CIccTag.

Public Member Functions inherited from CIccTagXml
virtual const char *	GetExtClassName () const

virtual const char *	GetExtDerivedClassName () const

virtual	~CIccTagXml (void)

Protected Member Functions
bool	ParseTag (xmlNode *pNode, std::string &parseStr)
	Name: CIccTagXmlStruct::ParseTag.

Protected Member Functions inherited from CIccTagStruct
void	Cleanup ()
	Name: CIccTagStruct::Cleanup.

bool	DetachElem (CIccTag *pTag)
	Name: CIccTagStruct::DetachSubTag.

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

IccTagEntry *	GetElem (icSignature sig) const
	Name: CIccTagStruct::GetElem.

bool	LoadElem (IccTagEntry pTagEntry, CIccIO pIO)
	Name: CIccTagStruct::LoadSubTag.

Additional Inherited Members
Static Public Member Functions inherited from CIccTagStruct
static std::string	GetElemName (icTagSignature sig, icStructSignature sigThis)

static CIccTagStruct *	ParseMem (icUInt8Number *pMem, icUInt32Number size)
	Name: CIccTagStruct::ParseMem.

Static Public Member Functions inherited from CIccTag
static CIccTag *	Create (icTagTypeSignature sig)
	Name: CIccTag::Create.

Public Attributes inherited from CIccTag
icUInt32Number	m_nReserved

Protected Attributes inherited from CIccTagStruct
TagEntryList *	m_ElemEntries

TagPtrList *	m_ElemVals

IIccStruct *	m_pStruct

icStructSignature	m_sigStructType

icUInt32Number	m_tagSize

icUInt32Number	m_tagStart

Detailed Description

Definition at line 641 of file IccTagXml.h.

Constructor & Destructor Documentation

◆ ~CIccTagXmlStruct()

virtual CIccTagXmlStruct::~CIccTagXmlStruct ( )

inlinevirtual

Definition at line 644 of file IccTagXml.h.

644{}

Member Function Documentation

◆ GetClassName()

virtual const char * CIccTagXmlStruct::GetClassName ( ) const

inlinevirtual

Reimplemented from CIccTagStruct.

Definition at line 646 of file IccTagXml.h.

646{return "CIccTagXmlStruct"; }

◆ GetExtension()

virtual IIccExtensionTag * CIccTagXmlStruct::GetExtension ( )

inlinevirtual

Reimplemented from CIccTag.

Definition at line 648 of file IccTagXml.h.

648{return this; }

◆ 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

Definition at line 4483 of file IccTagXml.cpp.

{
  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 CIccTag::Create(), IIccExtensionTag::GetExtClassName(), CIccTag::GetExtension(), CIccInfo::GetTagTypeSigName(), icGetSigVal(), icGetTagNameSig(), icGetTypeNameTagSig(), icSigUnknownTag, icSigUnknownType, icXmlAttrValue(), icXmlFindAttr(), icXmlStrCmp, CIccTag::m_nReserved, and CIccTagXml::ParseXml().

Here is the call graph for this function:

◆ ParseXml()

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

virtual

Implements CIccTagXml.

Definition at line 4656 of file IccTagXml.cpp.

{
  // 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: ";
    parseStr += (const char *)firstNode->name;
    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(), and icXmlFindNode().

Here is the call graph for this function:

◆ ToXml()

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

virtual

Implements CIccTagXml.

Definition at line 4350 of file IccTagXml.cpp.

{
  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 IIccStruct::GetDisplayName(), IIccStruct::GetElemName(), CIccTag::GetExtension(), CIccTag::GetType(), icFixXml(), icGetSigStr(), icGetTagSigTypeName(), and CIccTagXml::ToXml().

Here is the call graph for this function:

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

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

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ~CIccTagXmlStruct()

Member Function Documentation

◆ GetClassName()

◆ GetExtension()

◆ ParseTag()

◆ ParseXml()

◆ ToXml()