CIccProfileXml Class Reference

#include <IccProfileXml.h>

Inheritance diagram for CIccProfileXml:

Collaboration diagram for CIccProfileXml:

Public Member Functions
	CIccProfileXml ()
	CIccProfileXml (const CIccProfileXml &profile)
virtual const char *	GetClassName () const
bool	LoadXml (const char *szFilename, const char *szRelaxNGDir, std::string *parseStr=NULL)
virtual CIccProfile *	NewCopy () const
virtual CIccProfile *	NewProfile () const
bool	ParseXml (xmlNode *pNode, std::string &parseStr)
bool	ToXml (std::string &xmlString)
bool	ToXmlWithBlanks (std::string &xmlString, std::string blanks)
virtual	~CIccProfileXml ()

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

Detailed Description

Definition at line 74 of file IccProfileXml.h.

Constructor & Destructor Documentation

CIccProfileXml() [1/2]

CIccProfileXml::CIccProfileXml ( )

inline

Definition at line 78 of file IccProfileXml.h.

: CIccProfile() {}

Referenced by NewCopy(), and NewProfile().

Here is the caller graph for this function:

CIccProfileXml() [2/2]

CIccProfileXml::CIccProfileXml ( const CIccProfileXml & profile )

inline

Definition at line 79 of file IccProfileXml.h.

: CIccProfile(profile) {}

~CIccProfileXml()

virtual CIccProfileXml::~CIccProfileXml ( )

inlinevirtual

Definition at line 82 of file IccProfileXml.h.

{}

Member Function Documentation

GetClassName()

virtual const char * CIccProfileXml::GetClassName ( ) const

inlinevirtual

Definition at line 84 of file IccProfileXml.h.

{ return "CIccProfileXml"; }

LoadXml()

bool CIccProfileXml::LoadXml	(	const char *	szFilename,
		const char *	szRelaxNGDir,
		std::string *	parseStr = NULL )

Definition at line 829 of file IccProfileXml.cpp.

{  
  xmlDoc *doc = NULL;
  xmlNode *root_element = NULL;
 
  /*parse the file and get the DOM */
  doc = xmlReadFile(szFilename, NULL, 0);
 
  if (doc == NULL) 
    return NULL;
 
  if (szRelaxNGDir && szRelaxNGDir[0]) {
    xmlRelaxNGParserCtxt* rlxParser;
    
    rlxParser = xmlRelaxNGNewParserCtxt (szRelaxNGDir);
 
    //validate the xml file
    if (rlxParser){
        xmlRelaxNG* relaxNG = xmlRelaxNGParse(rlxParser);
        if (relaxNG){
            xmlRelaxNGValidCtxt* validCtxt = xmlRelaxNGNewValidCtxt(relaxNG);
            if (validCtxt){
                int result = xmlRelaxNGValidateDoc(validCtxt, doc);
                if (result != 0){
                    printf("\nError: %d: '%s' is an invalid XML file.\n", result, szFilename);
                    return false;
                }
            }
            else
              return false;
        }
        else
          return false;       
    }
    else
        return false;  
  }
   
  std::string my_parseStr;
 
  if (!parseStr)
    parseStr = &my_parseStr;
 
  *parseStr = "";
 
  /*Get the root element node */
  root_element = xmlDocGetRootElement(doc);
 
  bool rv = ParseXml(root_element, *parseStr);
 
  xmlFreeDoc(doc);
 
  return rv;
}

References ParseXml().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

NewCopy()

virtual CIccProfile * CIccProfileXml::NewCopy ( ) const

inlinevirtual

Definition at line 80 of file IccProfileXml.h.

{ return new CIccProfileXml(*this); }

References CIccProfileXml().

Here is the call graph for this function:

NewProfile()

virtual CIccProfile * CIccProfileXml::NewProfile ( ) const

inlinevirtual

Definition at line 81 of file IccProfileXml.h.

{ return new CIccProfileXml(); }

References CIccProfileXml().

Here is the call graph for this function:

ParseBasic()

bool CIccProfileXml::ParseBasic ( xmlNode * pNode, std::string & parseStr )

protected

Name: CIccProfileXml::ParseBasic.

Purpose: Parse ICC header.

Args: pNode - pointer to xmlNode object to read data with

Return: true - valid ICC header, false - failure

Definition at line 333 of file IccProfileXml.cpp.

{     
  std::string temp;
  memset(&m_Header, 0, sizeof(m_Header));  
 
  for (pNode=pNode->children; pNode; pNode=pNode->next) {
      if (pNode->type==XML_ELEMENT_NODE) {
        if (!icXmlStrCmp((const char*)pNode->name, "ProfileVersion")) {
      const char *szVer = (const char*)pNode->children->content;
      std::string ver;
      unsigned long verMajor=0, verMinor=0, verClassMajor=0, verClassMinor=0;
 
      for (; *szVer && *szVer != '.' && *szVer != ','; szVer++) {
        ver += *szVer;
      }
      verMajor = parseVersion(ver.c_str());
      ver.clear();
      if (*szVer)
        szVer++;
 
      if (*szVer) {
        for (; *szVer && *szVer != '.' && *szVer != ','; szVer++) {
          ver += *szVer;
        }
        verMinor = parseVersion(ver.c_str());
        ver.clear();
        if (*szVer)
          szVer++;
 
        if (*szVer) {
          for (; *szVer && *szVer != '.' && *szVer != ','; szVer++) {
            ver = *szVer;
          }
          verClassMajor = parseVersion(ver.c_str());
          ver.clear();
          if (*szVer)
            szVer++;
 
          if (*szVer) {
            for (; *szVer && *szVer != '.' && *szVer != ','; szVer++) {
              ver = *szVer;
            }
            verClassMinor = parseVersion(ver.c_str());
            ver.clear();
          }
        }
      }
 
      m_Header.version = (verMajor << 24) | (verMinor << 16) | (verClassMajor << 8) | verClassMinor;
        }
    else if (!icXmlStrCmp((const char*)pNode->name, "ProfileSubClassVersion")) {
      const char *szVer = (const char*)pNode->children->content;
      std::string ver;
      unsigned long verClassMajor = 0, verClassMinor = 0;
 
      for (; *szVer && *szVer != '.' && *szVer != ','; szVer++) {
        ver = *szVer;
      }
      verClassMajor = (unsigned char)atoi(ver.c_str());
      ver.clear();
 
      if (szVer) {
        for (; *szVer && *szVer != '.' && *szVer != ','; szVer++) {
          ver = *szVer;
        }
        verClassMinor = (unsigned char)atoi(ver.c_str());
      }
 
      m_Header.version = (m_Header.version & 0xffff0000) | (((verClassMajor << 8) | verClassMinor) & 0x0000ffff);
    }
    else if (!icXmlStrCmp(pNode->name, "PreferredCMMType")) {
            m_Header.cmmId = icXmlGetChildSigVal(pNode);
        }
        else if (!icXmlStrCmp(pNode->name, "ProfileDeviceClass")) {
            m_Header.deviceClass = (icProfileClassSignature)icXmlGetChildSigVal(pNode);
        }
    else if (!icXmlStrCmp(pNode->name, "ProfileDeviceSubClass")) {
      m_Header.deviceSubClass = (icSignature)icXmlGetChildSigVal(pNode);
    }
    else if (!icXmlStrCmp(pNode->name, "DataColourSpace")) {
            m_Header.colorSpace = (icColorSpaceSignature)icXmlGetChildSigVal(pNode);
        }
        else if (!icXmlStrCmp(pNode->name, "PCS")) {
          m_Header.pcs = (icColorSpaceSignature)icXmlGetChildSigVal(pNode);
        }
        else if (!icXmlStrCmp(pNode->name, "CreationDateTime")) {
      if (pNode && pNode->children && pNode->children->content) {
        const char *datetime = (const char*)pNode->children->content;
              m_Header.date = icGetDateTimeValue(datetime);
      }
      else
        memset(&m_Header.date, 0, sizeof(m_Header.date));
        }
        else if (!icXmlStrCmp(pNode->name, "PrimaryPlatform")) {
            m_Header.platform = (icPlatformSignature)icXmlGetChildSigVal(pNode);
        }       
        else if (!icXmlStrCmp(pNode->name, "ProfileFlags")) {
            m_Header.flags = 0;         
            xmlAttr *attr = icXmlFindAttr(pNode, "EmbeddedInFile");
      if (attr && !strcmp(icXmlAttrValue(attr), "true")) {
                m_Header.flags |= icEmbeddedProfileTrue; 
            }
 
            attr = icXmlFindAttr(pNode, "UseWithEmbeddedDataOnly");
      if (attr && !strcmp(icXmlAttrValue(attr), "true")) {
                    m_Header.flags |= icUseWithEmbeddedDataOnly;
            }
 
      attr = icXmlFindAttr(pNode, "ExtendedRangePCS");
      if (attr && !strcmp(icXmlAttrValue(attr), "true")) {
        m_Header.flags |= icExtendedRangePCS;
      }
 
      attr = icXmlFindAttr(pNode, "MCSNeedsSubset");
      if (attr && !strcmp(icXmlAttrValue(attr), "true")) {
        m_Header.flags |= icMCSNeedsSubsetTrue;
      }
 
      attr = icXmlFindAttr(pNode, "VendorFlags");
      if (attr) {
        icUInt32Number vendor;
        sscanf(icXmlAttrValue(attr), "%x", &vendor);
        m_Header.flags |= vendor;
      }
        }
        else if (!icXmlStrCmp(pNode->name, "DeviceManufacturer")) {
          m_Header.manufacturer = icXmlGetChildSigVal(pNode);
        }
        else if (!icXmlStrCmp(pNode->name, "DeviceModel")) {
          m_Header.model = icXmlGetChildSigVal(pNode);
        }
        else if (!icXmlStrCmp(pNode->name, "DeviceAttributes")) {
            m_Header.attributes = icGetDeviceAttrValue(pNode);
        }
        else if (!icXmlStrCmp(pNode->name, "RenderingIntent")) {
            if (!strcmp((const char*)pNode->children->content, "Perceptual"))
                m_Header.renderingIntent = icPerceptual;
            else if (!strcmp((const char*)pNode->children->content, "Relative Colorimetric") || !strcmp((const char*)pNode->children->content, "Relative"))
                m_Header.renderingIntent = icRelativeColorimetric;
            else if (!strcmp((const char*)pNode->children->content, "Saturation"))
                m_Header.renderingIntent = icSaturation;
            else if (!strcmp((const char*)pNode->children->content, "Absolute Colorimetric") || !strcmp((const char*)pNode->children->content, "Absolute"))
                m_Header.renderingIntent = icAbsoluteColorimetric;
 
        }
        else if (!icXmlStrCmp(pNode->name, "PCSIlluminant")) { 
            xmlNode *xyzNode = icXmlFindNode(pNode->children, "XYZNumber");
 
            xmlAttr *x = icXmlFindAttr(xyzNode, "X");
            xmlAttr *y = icXmlFindAttr(xyzNode, "Y");
            xmlAttr *z = icXmlFindAttr(xyzNode, "Z");
 
            if (x && y && z) {
               m_Header.illuminant.X = icDtoF((icFloatNumber)atof(icXmlAttrValue(x)));
               m_Header.illuminant.Y = icDtoF((icFloatNumber)atof(icXmlAttrValue(y)));
               m_Header.illuminant.Z = icDtoF((icFloatNumber)atof(icXmlAttrValue(z)));
            }
        }
        else if (!icXmlStrCmp(pNode->name, "ProfileCreator")) {
          m_Header.creator = icXmlGetChildSigVal(pNode);
        }
        else if (!icXmlStrCmp(pNode->name, "ProfileID")) {
      if (pNode->children && pNode->children->content) 
            icXmlGetHexData(&m_Header.profileID.ID8, (const char*)pNode->children->content, sizeof(m_Header.profileID.ID8));
      else
        memset(&m_Header.profileID.ID8, 0, sizeof(m_Header.profileID.ID8));
        }
    else if (!icXmlStrCmp(pNode->name, "SpectralPCS")) {
      m_Header.spectralPCS = (icSpectralColorSignature)icXmlGetChildSigVal(pNode);
    }
    else if (!icXmlStrCmp(pNode->name, "SpectralRange")) {
      xmlNode *xyzNode = icXmlFindNode(pNode->children, "Wavelengths");
 
      xmlAttr *start = icXmlFindAttr(xyzNode, "start");
      xmlAttr *end = icXmlFindAttr(xyzNode, "end");
      xmlAttr *steps = icXmlFindAttr(xyzNode, "steps");
 
      if (start && end && steps) {
        m_Header.spectralRange.start = icFtoF16((icFloatNumber)atof(icXmlAttrValue(start)));
        m_Header.spectralRange.end = icFtoF16((icFloatNumber)atof(icXmlAttrValue(end)));
        m_Header.spectralRange.steps = (icUInt16Number)atoi(icXmlAttrValue(steps));
      }
    }
    else if (!icXmlStrCmp(pNode->name, "BiSpectralRange")) {
      xmlNode *xyzNode = icXmlFindNode(pNode->children, "Wavelengths");
 
      xmlAttr *start = icXmlFindAttr(xyzNode, "start");
      xmlAttr *end = icXmlFindAttr(xyzNode, "end");
      xmlAttr *steps = icXmlFindAttr(xyzNode, "steps");
 
      if (start && end && steps) {
        m_Header.biSpectralRange.start = icFtoF16((icFloatNumber)atof(icXmlAttrValue(start)));
        m_Header.biSpectralRange.end = icFtoF16((icFloatNumber)atof(icXmlAttrValue(end)));
        m_Header.biSpectralRange.steps = (icUInt16Number)atoi(icXmlAttrValue(steps));
      }
    }
    else if (!icXmlStrCmp(pNode->name, "MCS")) {
      m_Header.mcs = (icMaterialColorSignature)icXmlGetChildSigVal(pNode);
    }
    else if (!icXmlStrCmp(pNode->name, "ProfileDeviceSubClass")) {
      m_Header.deviceSubClass = (icProfileClassSignature)icXmlGetChildSigVal(pNode);
    }
        else if (!icXmlStrCmp(pNode->name, "Reserved")) {
      if (pNode->children && pNode->content)
            icXmlGetHexData(&m_Header.reserved, (const char*)pNode->children->content, sizeof(m_Header.reserved));
      else
        memset(&m_Header.reserved, 0, sizeof(m_Header.reserved));
        }
        else {
          parseStr += "Unknown Profile Header attribute: ";
          parseStr += (const char*)pNode->name;
          parseStr += "=\"";
      if (pNode->children && pNode->children->content)
            parseStr += (const char*)pNode->children->content;
          parseStr += "\"\n";
        }
      }
  }
 
  m_Header.magic = icMagicNumber;  
 
  return true;
}

References icAbsoluteColorimetric, icDtoF(), icEmbeddedProfileTrue, icExtendedRangePCS, icFtoF16(), icGetDateTimeValue(), icGetDeviceAttrValue(), icMagicNumber, icMCSNeedsSubsetTrue, icPerceptual, icRelativeColorimetric, icSaturation, icUseWithEmbeddedDataOnly, icXmlAttrValue(), icXmlFindAttr(), icXmlFindNode(), icXmlGetChildSigVal(), icXmlGetHexData(), icXmlStrCmp, and parseVersion().

Referenced by ParseXml().

Here is the call graph for this function:

Here is the caller graph for this function:

ParseTag()

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

protected

Name: CIccProfileXml::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 574 of file IccProfileXml.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; 
  icTagSignature sigTag = icGetTagNameSig(nodeName.c_str());
 
  if (sigTag != icSigUnknownTag || nodeName == "PrivateTag") { //Parsing of XML tags by name
    if (nodeName == "PrivateTag") {
      const char *tagSig = icXmlAttrValue(pNode, "TagSignature", "");
      if (tagSig[0]) {
        sigTag = (icTagSignature)icGetSigVal(tagSig);
      }
      else {
        parseStr += "Invalid TagSignature for PrivateTag\n";
        return false;
      }
    }
 
    const char *sameAs = icXmlAttrValue(pNode, "SameAs", "");
 
    if (sameAs[0]) {
      icTagSignature sigParentTag = icGetTagNameSig(sameAs);
      if (!strcmp(sameAs, "PrivateTag") || sigParentTag == icSigUnknownTag) {
        const char *sameAsSig = icXmlAttrValue(pNode, "SameAsSignature", "");
        if (sameAsSig[0]) {
          sigParentTag = (icTagSignature)icGetSigVal(sameAsSig);
        }
        else {
          parseStr += "Invalid SameAsSignature for PrivateTag\n";
          return false;
        }
      }
      pTag = this->FindTag(sigParentTag);
      if (pTag) {
        AttachTag(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);
          }
          AttachTag(sigTag, pTag);
        }
        else {
          char str[100];
          parseStr += "Unable to Parse \"";
          parseStr += (const char*)pTypeNode->name;
          parseStr += "\" (";
          parseStr += nodeName;
          sprintf(str, ") Tag on line %d\n", pTypeNode->line);
          parseStr += str;
          return false;
        }
      }
      else {
        char str[100];
        parseStr += "Invalid tag extension for \"";
        parseStr += (const char*)pTypeNode->name;
        parseStr += "\" (";
        sprintf(str, ") Tag on line %d\n", pTypeNode->line);
        parseStr += str;
        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);
            AttachTag(sigTag, pTag);
          }
        }
      }
      else {
        char str[100];
        parseStr += "Unable to Parse \"";
        parseStr += info.GetTagTypeSigName(sigType);
        parseStr += "\" (";
        parseStr += nodeName;
        sprintf(str, ") Tag on line %d\n", pNode->line);
        parseStr += str;
        return false;
      }
    }
    else {
      char str[100];
      parseStr += "Invalid tag extension for \"";
      parseStr += info.GetTagTypeSigName(sigType);
      parseStr += "\" (";
      parseStr += nodeName;
      sprintf(str, ") Tag on line %d\n", pNode->line);
      parseStr += str;
      return false;
    }
  }
 
  switch(sigTag) {
  case icSigAToB0Tag:
  case icSigAToB1Tag:
  case icSigAToB2Tag:
  case icSigAToB3Tag:
    if (pTag->IsMBBType())
      ((CIccMBB*)pTag)->SetColorSpaces(m_Header.colorSpace, m_Header.pcs);
    break;
 
  case icSigBToA0Tag:
  case icSigBToA1Tag:
  case icSigBToA2Tag:
  case icSigBToA3Tag:
    if (pTag->IsMBBType())
      ((CIccMBB*)pTag)->SetColorSpaces(m_Header.pcs, m_Header.colorSpace);
    break;
 
  case icSigHToS0Tag:
  case icSigHToS1Tag:
  case icSigHToS2Tag:
  case icSigHToS3Tag:
    if (pTag->IsMBBType())
      ((CIccMBB*)pTag)->SetColorSpaces(m_Header.pcs, m_Header.pcs);
    break;
 
  case icSigGamutTag:
    if (pTag->IsMBBType())
      ((CIccMBB*)pTag)->SetColorSpaces(m_Header.pcs, icSigGamutData);
    break;
 
  case icSigNamedColor2Tag:
    {
      if (pTag->GetType()==icSigNamedColor2Type) {
        ((CIccTagNamedColor2*)pTag)->SetColorSpaces(m_Header.pcs, m_Header.colorSpace);
      }
      else if (pTag->GetTagArrayType()==icSigNamedColorArray) {
        CIccArrayNamedColor *pAry = (CIccArrayNamedColor*)icGetTagArrayHandler(pTag);
 
        if (pAry) {
          pAry->SetColorSpaces(m_Header.pcs, m_Header.colorSpace, 
                               m_Header.spectralPCS, 
                               &m_Header.spectralRange, 
                               &m_Header.biSpectralRange);
        }
      }
    }
  default:
      break;
  }
 
  return true;
}

References CIccTag::Create(), IIccExtensionTag::GetExtClassName(), CIccTag::GetExtension(), CIccTag::GetTagArrayType(), CIccInfo::GetTagTypeSigName(), CIccTag::GetType(), icGetSigVal(), icGetTagArrayHandler(), icGetTagNameSig(), icGetTypeNameTagSig(), icSigAToB0Tag, icSigAToB1Tag, icSigAToB2Tag, icSigAToB3Tag, icSigBToA0Tag, icSigBToA1Tag, icSigBToA2Tag, icSigBToA3Tag, icSigGamutData, icSigGamutTag, icSigHToS0Tag, icSigHToS1Tag, icSigHToS2Tag, icSigHToS3Tag, icSigNamedColor2Tag, icSigNamedColor2Type, icSigNamedColorArray, icSigUnknownTag, icSigUnknownType, icXmlAttrValue(), icXmlFindAttr(), icXmlStrCmp, CIccTag::IsMBBType(), CIccTag::m_nReserved, CIccTagXml::ParseXml(), and CIccArrayNamedColor::SetColorSpaces().

Referenced by ParseXml().

Here is the call graph for this function:

Here is the caller graph for this function:

ParseXml()

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

Definition at line 801 of file IccProfileXml.cpp.

{  
  if (icXmlStrCmp(pNode->name, "IccProfile")) {
    return false;
  }
 
  xmlNode *hdrNode = icXmlFindNode(pNode->children, "Header");
 
  // parse header
  if (!hdrNode || !ParseBasic(hdrNode, parseStr))
    return false;
 
  // parse each tag
  xmlNode *tagNode = icXmlFindNode(pNode->children, "Tags");
  if (!tagNode)
    return false;
 
  for (tagNode = tagNode->children; tagNode; tagNode = tagNode->next) {
    if (tagNode->type == XML_ELEMENT_NODE) {
      if (!ParseTag(tagNode, parseStr))
        return false;
    }
  }
 
  return true;
}

References icXmlFindNode(), icXmlStrCmp, ParseBasic(), and ParseTag().

Referenced by LoadXml(), and CIccTagXmlEmbeddedProfile::ParseXml().

Here is the call graph for this function:

Here is the caller graph for this function:

ToXml()

bool CIccProfileXml::ToXml

(

std::string &

xmlString

)

Definition at line 74 of file IccProfileXml.cpp.

{
  CIccInfo info;
 
  xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
  return ToXmlWithBlanks(xml, "");
}

References ToXmlWithBlanks().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

ToXmlWithBlanks()

bool CIccProfileXml::ToXmlWithBlanks	(	std::string &	xmlString,
		std::string	blanks )

Definition at line 82 of file IccProfileXml.cpp.

{
  CIccInfo info;
  char line[256];
  char buf[256];
  char fix[256];
  int n;
  bool nonzero;
 
  xml += blanks + "<IccProfile>\n";
  xml += blanks + "  <Header>\n";
  sprintf(line, "    <PreferredCMMType>%s</PreferredCMMType>\n", icFixXml(fix, icGetColorSigStr(buf, m_Header.cmmId)));
  xml += blanks + line;
  sprintf(line, "    <ProfileVersion>%s</ProfileVersion>\n", info.GetVersionName(m_Header.version));
  xml += blanks + line;
  if (m_Header.version & 0x0000ffff) {
    sprintf(line, "    <ProfileSubClassVersion>%s</ProfileSubClassVersion>\n", info.GetSubClassVersionName(m_Header.version));
    xml += blanks + line;
  }
  sprintf(line, "    <ProfileDeviceClass>%s</ProfileDeviceClass>\n", icFixXml(fix, icGetSigStr(buf, m_Header.deviceClass)));
  xml += blanks + line;
 
  if (m_Header.deviceSubClass) {
    sprintf(line, "    <ProfileDeviceSubClass>%s</ProfileDeviceSubClass>\n", icFixXml(fix, icGetSigStr(buf, m_Header.deviceSubClass)));
    xml += blanks + line;
  }
 
  sprintf(line, "    <DataColourSpace>%s</DataColourSpace>\n", icFixXml(fix, icGetColorSigStr(buf, m_Header.colorSpace)));
  xml += blanks + line;
  sprintf(line, "    <PCS>%s</PCS>\n",  icFixXml(fix, icGetColorSigStr(buf, m_Header.pcs)));
  xml += blanks + line;
 
  sprintf(line, "    <CreationDateTime>%d-%02d-%02dT%02d:%02d:%02d</CreationDateTime>\n", 
                                        m_Header.date.year,
                                        m_Header.date.month,
                                        m_Header.date.day,
                                        m_Header.date.hours,
                                        m_Header.date.minutes,
                                        m_Header.date.seconds);
  xml += blanks + line;
 
 // if (m_Header.magic != 0){
 //   sprintf(line, "    <Signature>%s</Signature>\n", icFixXml(fix, icGetSigStr(buf, m_Header.magic)));
 //   xml += line;
 // }
 
  if (m_Header.platform != icSigUnkownPlatform){
    sprintf(line, "    <PrimaryPlatform>%s</PrimaryPlatform>\n", icFixXml(fix, icGetSigStr(buf, m_Header.platform)));
    xml += blanks + line;
  }
 
  xml+= blanks + "    ";
  xml+= icGetHeaderFlagsName(m_Header.flags, m_Header.mcs!=0);
 
  if (m_Header.manufacturer != 0){
      sprintf(line, "    <DeviceManufacturer>%s</DeviceManufacturer>\n", icFixXml(fix, icGetSigStr(buf, m_Header.manufacturer)));
      xml += blanks + line;
  }
  
  if (m_Header.model != 0){
    sprintf(line, "    <DeviceModel>%s</DeviceModel>\n", icFixXml(fix, icGetSigStr(buf, m_Header.model)));
    xml += blanks + line;
  }
 
  xml+= "    ";
  xml += blanks + icGetDeviceAttrName(m_Header.attributes);
 
  sprintf(line, "    <RenderingIntent>%s</RenderingIntent>\n", info.GetRenderingIntentName((icRenderingIntent)m_Header.renderingIntent, m_Header.version>=icVersionNumberV5));
  xml += blanks + line;
  sprintf(line, "    <PCSIlluminant>\n%s      <XYZNumber X=\"" icXmlFloatFmt "\" Y=\"" icXmlFloatFmt "\" Z=\"" icXmlFloatFmt "\"/>\n%s    </PCSIlluminant>\n", blanks.c_str(),
                                                             (float)icFtoD(m_Header.illuminant.X),
                                                             (float)icFtoD(m_Header.illuminant.Y),
                                                             (float)icFtoD(m_Header.illuminant.Z),
                                                             blanks.c_str());
 
  xml += blanks + line;
  
  sprintf(line, "    <ProfileCreator>%s</ProfileCreator>\n", icFixXml(fix, icGetSigStr(buf, m_Header.creator)));
  xml += blanks + line;
 
  if (m_Header.profileID.ID32[0] || m_Header.profileID.ID32[1] || 
      m_Header.profileID.ID32[2] || m_Header.profileID.ID32[3]) {
    xml += blanks;
    for (n=0; n<16; n++) {
      sprintf(buf + n*2, "%02X", m_Header.profileID.ID8[n]);
    }
    buf[n*2]='\0';
    xml += "    <ProfileID>";
    xml += buf;
    xml += "</ProfileID>\n";
  }
  nonzero = false;
 
  if (m_Header.spectralPCS) {
    sprintf(line, "    <SpectralPCS>%s</SpectralPCS>\n",  icFixXml(fix, icGetColorSigStr(buf, m_Header.spectralPCS)));
    xml += blanks + line;
 
    if (m_Header.spectralRange.steps) {
      xml += blanks + "    <SpectralRange>\n";
      sprintf(line, "     <Wavelengths start=\"" icXmlHalfFmt "\" end=\"" icXmlHalfFmt "\" steps=\"%d\"/>\n",
              icF16toF(m_Header.spectralRange.start), icF16toF(m_Header.spectralRange.end), m_Header.spectralRange.steps);
      xml += blanks + line;
      xml += blanks + "    </SpectralRange>\n";
    }
    if (m_Header.biSpectralRange.steps) {
      xml += blanks + "    <BiSpectralRange>\n";
      sprintf(line, "     <Wavelengths start=\"" icXmlHalfFmt "\" end=\"" icXmlHalfFmt "\" steps=\"%d\"/>\n)",
              icF16toF(m_Header.biSpectralRange.start), icF16toF(m_Header.biSpectralRange.end), m_Header.biSpectralRange.steps);
      xml += blanks + line;
      xml += blanks + "    </BiSpectralRange>\n";
    }
  }
 
  if (m_Header.mcs) {
    sprintf(line, "    <MCS>%s</MCS>\n",  icFixXml(fix, icGetColorSigStr(buf, m_Header.mcs)));
    xml += blanks + line;
  }
 
  for (n=0; n<sizeof(m_Header.reserved); n++) {
    if (m_Header.reserved[n])
      nonzero = true;
    sprintf(buf + n*2, "%02X", m_Header.reserved[n]);
  }
  buf[n*2]='\0';
  if (nonzero) {
    xml += blanks + "    <Reserved>";
    xml += buf;
      xml += "</Reserved>\n";
  }
  xml += blanks + "  </Header>\n";
  
  xml += blanks + "  <Tags>\n";
  TagEntryList::iterator i, j;
  std::set<icTagSignature> sigSet;
  CIccInfo Fmt;
  IccOffsetTagSigMap offsetTags;
 
  for (i=m_Tags->begin(); i!=m_Tags->end(); i++) {
    if (sigSet.find(i->TagInfo.sig)==sigSet.end()) {
      CIccTag *pTag = FindTag(i->TagInfo.sig);
 
      if (pTag) {
        CIccTagXml *pTagXml = (CIccTagXml*)(pTag->GetExtension());
        if (pTagXml) {
          IccOffsetTagSigMap::iterator prevTag = offsetTags.find(i->TagInfo.offset);
          const icChar *tagName = Fmt.GetTagSigName(i->TagInfo.sig);
          if (prevTag == offsetTags.end()) {
            const icChar* tagSig = icGetTagSigTypeName(pTag->GetType());
 
            if (tagName && strncmp(tagName, "Unknown ", 8)) {
              sprintf(line, "    <%s> ", icFixXml(fix, tagName));
            }
            else {
              sprintf(line, "    <PrivateTag TagSignature=\"%s\"> ", icFixXml(fix, icGetSigStr(buf, i->TagInfo.sig)));
              tagName = "PrivateTag";
            }
            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 += line;
 
            sigSet.insert(i->TagInfo.sig);
 
            // print out the rest of the tag signatures
            for (j++; j != m_Tags->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 += line;
                sigSet.insert(j->TagInfo.sig);
              }
            }
#endif
            //convert the rest of the tag to xml
            if (!pTagXml->ToXml(xml, blanks + "      ")) {
              printf("Unable to output tag with type %s\n", icGetSigStr(buf, i->TagInfo.sig));
              return false;
            }
            sprintf(line, "    </%s> </%s>\n\n", tagSig, tagName);
            xml += blanks + line;
            offsetTags[i->TagInfo.offset] = i->TagInfo.sig;
          }
          else {
            const icChar *prevTagName = Fmt.GetTagSigName(prevTag->second);
            char nameBuf[200], fix2[200];
            if (!prevTagName || !strncmp(prevTagName, "Unknown ", 8)) {
              strcpy(nameBuf, "PrivateTag");
              prevTagName = nameBuf;
            }
 
            if (tagName && strncmp(tagName, "Unknown ", 8))
              sprintf(line, "    <%s SameAs=\"%s\"", icFixXml(fix, tagName), icFixXml(fix2, prevTagName)); //parent node is the tag type
            else
              sprintf(line, "    <PrivateTag TagSignature=\"%s\" SameAs=\"%s\"", icFixXml(fix2, icGetSigStr(buf, i->TagInfo.sig)), icFixXml(fix, prevTagName));
            
            xml += blanks + line;
            if (prevTagName == nameBuf) {
              sprintf(line, " SameAsSignature=\"%s\"", icFixXml(fix2, icGetSigStr(buf, prevTag->second)));
              xml += blanks + line;
            }
 
            xml += "/>\n\n";
          }
        }
        else {
          printf("Non XML tag in list with tag %s!\n", icGetSigStr(buf, i->TagInfo.sig));
          return false;
        }
      }
      else {
        printf("Unable to find tag with tag %s!\n", icGetSigStr(buf, i->TagInfo.sig));
        return false;
      }
    }
  }
  xml += blanks + "  </Tags>\n";
  xml += blanks + "</IccProfile>\n";
 
  return true;
}

References CIccTag::GetExtension(), CIccInfo::GetRenderingIntentName(), CIccInfo::GetSubClassVersionName(), CIccInfo::GetTagSigName(), CIccTag::GetType(), CIccInfo::GetVersionName(), icF16toF(), icFixXml(), icFtoD(), icGetColorSigStr(), icGetDeviceAttrName(), icGetHeaderFlagsName(), icGetSigStr(), icGetTagSigTypeName(), icSigUnkownPlatform, icVersionNumberV5, icXmlFloatFmt, icXmlHalfFmt, and CIccTagXml::ToXml().

Referenced by ToXml(), and CIccTagXmlEmbeddedProfile::ToXml().

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

• IccXML/IccLibXML/IccProfileXml.h
• IccXML/IccLibXML/IccProfileXml.cpp