CIccProfileXml Class Reference

#include <IccProfileXml.h>

Inheritance diagram for CIccProfileXml:

Collaboration diagram for CIccProfileXml:

Public Member Functions
	CIccProfileXml ()
	CIccProfileXml (const CIccProfileXml &profile)
virtual	~CIccProfileXml ()
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)

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

Detailed Description

Constructor & Destructor Documentation

CIccProfileXml() [1/2]

CIccProfileXml::CIccProfileXml ( )

inline

: CIccProfile() {}

References CIccProfile.

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

Here is the caller graph for this function:

CIccProfileXml() [2/2]

CIccProfileXml::CIccProfileXml ( const CIccProfileXml &  profile )

inline

: CIccProfile(profile) {}

References CIccProfile.

Referenced by NewCopy().

Here is the caller graph for this function:

~CIccProfileXml()

virtual CIccProfileXml::~CIccProfileXml ( )

inlinevirtual

{}

Member Function Documentation

GetClassName()

virtual const char * CIccProfileXml::GetClassName ( ) const

inlinevirtual

{ return "CIccProfileXml"; }

LoadXml()

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

{  
  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

{ return new CIccProfileXml(*this); }

References CIccProfileXml().

Here is the call graph for this function:

NewProfile()

virtual CIccProfile * CIccProfileXml::NewProfile ( ) const

inlinevirtual

{ 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

{     
  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 icHeader::attributes, icHeader::biSpectralRange, icHeader::cmmId, icHeader::colorSpace, icHeader::creator, icHeader::date, icHeader::deviceClass, icHeader::deviceSubClass, icSpectralRange::end, icHeader::flags, icAbsoluteColorimetric, icDtoF(), icFtoF16(), icGetDateTimeValue(), icGetDeviceAttrValue(), icPerceptual, icRelativeColorimetric, icSaturation, icXmlAttrValue(), icXmlFindAttr(), icXmlFindNode(), icXmlGetChildSigVal(), icXmlGetHexData(), icProfileID::ID8, icHeader::illuminant, icHeader::magic, icHeader::manufacturer, icHeader::mcs, icHeader::model, parseVersion(), icHeader::pcs, icHeader::platform, icHeader::profileID, icHeader::renderingIntent, icHeader::reserved, icHeader::spectralPCS, icHeader::spectralRange, icSpectralRange::start, icSpectralRange::steps, icHeader::version, icXYZNumber::X, icXYZNumber::Y, and icXYZNumber::Z.

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

{
  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 icHeader::biSpectralRange, icHeader::colorSpace, CIccTag::Create(), IIccExtensionTag::GetExtClassName(), CIccTag::GetExtension(), CIccTag::GetTagArrayType(), CIccInfo::GetTagTypeSigName(), CIccTag::GetType(), icGetSigVal(), icGetTagArrayHandler(), icGetTagNameSig(), icGetTypeNameTagSig(), icSigAToB0Tag, icSigAToB1Tag, icSigAToB2Tag, icSigAToB3Tag, icSigBToA0Tag, icSigBToA1Tag, icSigBToA2Tag, icSigBToA3Tag, icSigGamutTag, icSigHToS0Tag, icSigHToS1Tag, icSigHToS2Tag, icSigHToS3Tag, icSigNamedColor2Tag, icSigNamedColor2Type, icSigNamedColorArray, icXmlAttrValue(), icXmlAttrValue(), icXmlFindAttr(), CIccTag::IsMBBType(), CIccTag::m_nReserved, CIccTagXml::ParseXml(), icHeader::pcs, CIccMBB::SetColorSpaces(), CIccTagNamedColor2::SetColorSpaces(), CIccArrayNamedColor::SetColorSpaces(), icHeader::spectralPCS, and icHeader::spectralRange.

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
	)

{  
  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(), 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

)

{
  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
	)

{
  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 != icSigUnknownPlatform){
    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 icHeader::attributes, icHeader::biSpectralRange, icHeader::cmmId, icHeader::colorSpace, icHeader::creator, icHeader::date, icDateTimeNumber::day, icHeader::deviceClass, icHeader::deviceSubClass, icSpectralRange::end, icHeader::flags, CIccTag::GetExtension(), CIccInfo::GetRenderingIntentName(), CIccInfo::GetSubClassVersionName(), CIccInfo::GetTagSigName(), CIccTag::GetType(), CIccInfo::GetVersionName(), icDateTimeNumber::hours, icF16toF(), icFixXml(), icFtoD(), icGetColorSigStr(), icGetDeviceAttrName(), icGetHeaderFlagsName(), icGetSigStr(), icGetTagSigTypeName(), icSigUnknownPlatform, icProfileID::ID32, icProfileID::ID8, icHeader::illuminant, icHeader::manufacturer, icHeader::mcs, icDateTimeNumber::minutes, icHeader::model, icDateTimeNumber::month, icTag::offset, icHeader::pcs, icHeader::platform, icHeader::profileID, icHeader::renderingIntent, icHeader::reserved, icDateTimeNumber::seconds, icTag::sig, icHeader::spectralPCS, icHeader::spectralRange, icSpectralRange::start, icSpectralRange::steps, CIccTagXml::ToXml(), icHeader::version, icXYZNumber::X, icXYZNumber::Y, icDateTimeNumber::year, and icXYZNumber::Z.

Referenced by CIccTagXmlEmbeddedProfile::ToXml(), and 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