IDOMElement* DOMElement::createInstance(WebCore::Element* e) { if (!e) return nullptr; HRESULT hr; IDOMElement* domElement = 0; if (is<WebCore::HTMLFormElement>(*e)) { DOMHTMLFormElement* newElement = new DOMHTMLFormElement(e); hr = newElement->QueryInterface(IID_IDOMElement, (void**)&domElement); } else if (e->hasTagName(iframeTag)) { DOMHTMLIFrameElement* newElement = new DOMHTMLIFrameElement(e); hr = newElement->QueryInterface(IID_IDOMElement, (void**)&domElement); } else if (is<WebCore::HTMLInputElement>(*e)) { DOMHTMLInputElement* newElement = new DOMHTMLInputElement(e); hr = newElement->QueryInterface(IID_IDOMElement, (void**)&domElement); } else if (is<WebCore::HTMLOptionElement>(*e)) { DOMHTMLOptionElement* newElement = new DOMHTMLOptionElement(e); hr = newElement->QueryInterface(IID_IDOMElement, (void**)&domElement); } else if (e->hasTagName(selectTag)) { DOMHTMLSelectElement* newElement = new DOMHTMLSelectElement(e); hr = newElement->QueryInterface(IID_IDOMElement, (void**)&domElement); } else if (is<WebCore::HTMLTextAreaElement>(*e)) { DOMHTMLTextAreaElement* newElement = new DOMHTMLTextAreaElement(e); hr = newElement->QueryInterface(IID_IDOMElement, (void**)&domElement); } else if (e->isHTMLElement()) { DOMHTMLElement* newElement = new DOMHTMLElement(e); hr = newElement->QueryInterface(IID_IDOMElement, (void**)&domElement); } else { DOMElement* newElement = new DOMElement(e); hr = newElement->QueryInterface(IID_IDOMElement, (void**)&domElement); } if (FAILED(hr)) return 0; return domElement; }
musicxml::score_timewise musicxml::parse<musicxml::score_timewise>(std::istream &is, const std::string &id) { xml::auto_initializer xerces_platform { true, false }; std::unique_ptr<DOMDocument> doc { dom_document(is, id, true) }; DOMElement *root { doc->getDocumentElement() }; std::string const ns { xml::transcode<char>(root->getNamespaceURI()) }; std::string const name { xml::transcode<char>(root->getLocalName()) }; if (ns == "") { if (name == "score-partwise") { return musicxml::convert(musicxml::score_partwise{*root}); } else if (name == "score-timewise") { return musicxml::score_timewise{*root}; } } throw tree::unexpected_element<char>(name, ns, "score-partwise|score-timewise", ""); }
DOMElement* Lampara::getNodo() { DOMElement* nodoColor; char* aux; XMLCh* nombreNodo; XMLCh* valorNodo; /* Se llama a getNodo en la clase base que hace la mayor parte del trabajo, y se terminan de rellenar los campos con esta funcion*/ ElementoSimple::getNodo("lampara"); /* Obtenemos una implementación DOM Nos basta con que implemente el núcleo (CORE) del estándar DOM*/ DOMImplementation* implementacion= DOMImplementationRegistry::getDOMImplementation (XMLString::transcode ("Core")); nombreNodo=XMLString::transcode ("color"); nodoColor=doc->createElement(nombreNodo); nodoColor->setTextContent(this->getColor()); /* El puntero al documento raiz apunta al minidocumento "electroiman" creado antes. Se necesita para empezar a insertar elementos dentro del elemento*/ DOMElement* punteroDocRaiz=doc->getDocumentElement(); punteroDocRaiz->appendChild (nodoColor); punteroDocRaiz->appendChild (nodoEntradaReposo); punteroDocRaiz->appendChild (nodoSalidaReposo); punteroDocRaiz->appendChild (nodoEntradaActivacion); punteroDocRaiz->appendChild (nodoSalidaActivacion); /* Una vez enganchados los elementos, devolvemos el minidocumento*/ return (DOMElement*) doc; }
bool CustomLayerImp::fromXml(DOMNode* pDocument, unsigned int version) { if (!LayerImp::fromXml(pDocument, version)) { return false; } DOMElement* pElem = static_cast<DOMElement*>(pDocument); setAcceptsMouseEvents(StringUtilities::fromXmlString<bool>(A(pElem->getAttribute(X("mouseEventsSupported"))))); for (DOMNode* pChld = pElem->getFirstChild(); pChld != NULL; pChld = pChld->getNextSibling()) { if (XMLString::equals(pChld->getNodeName(), X("mouseCursor"))) { string cursorStr = string(A(pChld->getTextContent())); if (cursorStr.empty() == false) { QByteArray cursorArray(QByteArray::fromBase64(QByteArray::fromRawData( cursorStr.c_str(), cursorStr.size()))); QDataStream cursorStream(&cursorArray, QIODevice::ReadOnly); cursorStream >> mMouseCursor; } }
void PLMXMLParser::addInstance(char *id, osg::Group *parent) { std::map<char *, Element *, ltstr>::iterator it = instances.find(id); if (it != instances.end()) { Element *instance = it->second; osg::Group *group = instance->group; DOMElement *element = instance->element; parent->addChild(group); coVRSelectionManager::markAsHelperNode(group); osg::MatrixTransform *transformNode = getTransformNode(id, element); if (transformNode) { group->addChild(transformNode); group = transformNode; } else { if (element->hasAttribute(TAG_name)) group->setName(XMLString::transcode(element->getAttribute(TAG_name))); else group->setName(id); } const XMLCh *partRef = element->getAttribute(TAG_partRef); char *partName = XMLString::transcode(partRef); if (partName[0] == '#') addPart(partName + 1, group); else addPart(partName, group); XMLString::release(&partName); } }
void *NclImportParser::parseImportedDocumentBase( DOMElement *parentElement, void *objGrandParent) { void *parentObject; DOMNodeList *elementNodeList; DOMElement *element; DOMNode *node; string elementTagName; void *elementObject; //pre-compile attributes parentObject = createImportedDocumentBase( parentElement, objGrandParent); if (parentObject == NULL) { return NULL; } elementNodeList = parentElement->getChildNodes(); for (int i = 0; i < (int)elementNodeList->getLength(); i++) { node = elementNodeList->item(i); if(node->getNodeType()==DOMNode::ELEMENT_NODE){ element = (DOMElement*)node; elementTagName = XMLString::transcode( element->getTagName() ); if (XMLString::compareIString( elementTagName.c_str(), "importNCL") == 0) { elementObject = parseImportNCL(element, parentObject); if (elementObject != NULL) { addImportNCLToImportedDocumentBase( parentObject, elementObject); } } } } return parentObject; }
void *NclLayoutParser::parseRegion( DOMElement *parentElement, void *objGrandParent) { wclog << "parseRegion" << endl; void *parentObject; DOMNodeList *elementNodeList; DOMElement *element; DOMNode *node; string elementTagName; void *elementObject; parentObject = createRegion(parentElement, objGrandParent); if (parentObject == NULL) { return NULL; } elementNodeList = parentElement->getChildNodes(); for (int i = 0; i < (int)elementNodeList->getLength(); i++) { node = elementNodeList->item(i); if (node->getNodeType()==DOMNode::ELEMENT_NODE) { element = (DOMElement*)node; elementTagName = XMLString::transcode(element->getTagName()); wclog << ">>" << elementTagName.c_str() << ": "; wclog << XMLString::transcode(element->getAttribute(XMLString::transcode("id"))); if (XMLString::compareIString( elementTagName.c_str(), "region") == 0) { elementObject = parseRegion(element, parentObject); if (elementObject != NULL) { addRegionToRegion(parentObject, elementObject); } } } } return parentObject; }
Triggerconf::STRING_LIST Triggerconf::getConfigAttributeNames (string module, string submodule, string configname) { STRING_LIST ret; if (! existsConfigElement (module, submodule, configname)) return ret; DOMNode* node = selectConfigElement (module, submodule, configname); if (node == NULL || node->getNodeType () != DOMNode::ELEMENT_NODE) return ret; DOMElement* elem = (DOMElement*) node; DOMNamedNodeMap* attributes = elem->getAttributes (); for (unsigned int i=0; i<attributes->getLength (); i++) { DOMNode* attr = attributes->item (i); const XMLCh* xname = attr->getNodeName (); char* cname = XMLString::transcode (xname); ret.push_back (cname); XMLString::release (&cname); } return ret; }
bool CurveImp::fromXml(DOMNode* pDocument, unsigned int version) { if (pDocument == NULL || !PlotObjectImp::fromXml(pDocument, version)) { return false; } DOMElement* pElem = static_cast<DOMElement*>(pDocument); ColorType color = StringUtilities::fromXmlString<ColorType>(A(pElem->getAttribute(X("color")))); mColor = COLORTYPE_TO_QCOLOR(color); mLineWidth = StringUtilities::fromXmlString<int>(A(pElem->getAttribute(X("lineWidth")))); mLineStyle = StringUtilities::fromXmlString<LineStyle>(A(pElem->getAttribute(X("lineStyle")))); for (DOMNode* pChld = pElem->getFirstChild(); pChld != NULL; pChld = pChld->getNextSibling()) { if (XMLString::equals(pChld->getNodeName(), X("Point"))) { mPoints.push_back(StringUtilities::fromXmlString<LocationType>(A(pChld->getTextContent()))); } } return true; }
string Triggerconf::getSubmoduleAttributeValue (string module, string submodule, string attributename) { if (! existsSubmodule (module, submodule)) { setError ("invalid submodule"); return ""; } DOMNode* node = selectSubmodule (module, submodule); assert (node->getNodeType () == DOMNode::ELEMENT_NODE); DOMElement* elem = (DOMElement*) node; XMLCh* xattrname = XMLString::transcode (attributename.c_str ()); const XMLCh* xattrval = elem->getAttribute (xattrname); char* charstring = XMLString::transcode (xattrval); string ret = charstring; XMLString::release (&xattrname); XMLString::release (&charstring); resetError (); return ret; }
ret_ CXMLLoaderActions::LoadEmpty(CProgram &Program, const DOMElement *pElement, const CPDUInfo *pPDU) { #ifdef _DEBUG_ if (!pElement) return (PARAMETER_NULL | PARAMETER_2); #endif // DOMElement *pSub = (DOMElement *)pElement->getFirstChild(); if (!pSub) return XML_LOADER_ERROR; CAutoPtr<CVariable> OV; while (pSub) { ret_ Ret = LoadVariable(Program.Data(), pSub, OV.Ptr(), pPDU); if (SUCCESS != Ret && XML_INVALID_ELEMENT != Ret) return Ret; if (SUCCESS == Ret) break; pSub = (DOMElement *)pSub->getNextSibling(); } COptEmpty *pOperator = new COptEmpty(OV.Ptr()); if (false_v == Program.AddOperator(pOperator)) return XML_LOADER_ERROR; return SUCCESS; }
XMLNode *JobXML::AddElement( XMLNode *parent, std::string element, std::string content ) { // error check if ( parent == NULL ) return NULL; // create element XMLCh *elementName = XMLString::transcode( element.c_str() ); DOMElement *elementNode = mDocument->createElement( elementName ); XMLString::release( &elementName ); if ( elementNode == NULL ) { std::cout << "[Error] Creating element: " << element << "." << std::endl; return NULL; } // attach it parent->appendChild( elementNode ); // create content if ( content.length() != 0 ) { XMLCh *contentText = XMLString::transcode( content.c_str() ); DOMText *textNode = mDocument->createTextNode( contentText ); XMLString::release( &contentText ); if ( textNode == NULL ) { std::cout << "[Error] Creating content: " << content << " for element: " << element << "." << std::endl; } else { elementNode->appendChild( textNode ); } } return elementNode; }
void XercesUpdateFactory::applyInsertAttributes(const PendingUpdate &update, DynamicContext *context) { const XercesNodeImpl *nodeImpl = (const XercesNodeImpl*)update.getTarget()->getInterface(Item::gXQilla); DOMElement *element = (DOMElement*)nodeImpl->getDOMNode(); DOMDocument *doc = const_cast<DOMDocument*>(XPath2Utils::getOwnerDoc(element)); bool untyped = nodeImpl->dmNodeKind() == Node::element_string && XPath2Utils::equals(nodeImpl->getTypeName(), DocumentCache::g_szUntyped) && XPath2Utils::equals(nodeImpl->getTypeURI(), SchemaSymbols::fgURI_SCHEMAFORSCHEMA); Result children = update.getValue(); Item::Ptr item; while((item = children->next(context)).notNull()) { const XercesNodeImpl *childImpl = (const XercesNodeImpl*)item->getInterface(Item::gXQilla); DOMNode *newChild = importNodeFix(doc, const_cast<DOMNode*>(childImpl->getDOMNode()), /*deep*/true); // 1. Error checks: // a. If the QNames of any two attribute nodes in $content have implied namespace bindings that conflict with each other, // a dynamic error is raised [err:XUDY0024]. // b. If the QName of any attribute node in $content has an implied namespace binding that conflicts with a namespace // binding in the "namespaces" property of $target, a dynamic error is raised [err:XUDY0024]. // Checks performed by UpdateFactory // If the type-name property of $target is xs:untyped, then upd:setToUntyped($A) is invoked. if(!untyped) setTypes(newChild, childImpl->getDOMNode()); // The parent property of $A is set to $target. // attributes: Modified to include the nodes in $content. element->setAttributeNode((DOMAttr*)newChild); } // upd:removeType($target) is invoked. removeType(element); addToPutSet(update.getTarget(), &update, context); }
bool SpectralLibraryManager::deserialize(SessionItemDeserializer& deserializer) { if (isBatch() == true) { setInteractive(); } bool success = execute(NULL, NULL); if (success) { std::vector<Signature*> signatures; Service<SessionManager> pSessionManager; XmlReader reader(NULL, false); DOMElement* pRootElement = deserializer.deserialize(reader, "SpectralLibraryManager"); for (DOMNode* pChild = pRootElement->getFirstChild(); pChild != NULL; pChild = pChild->getNextSibling()) { DOMElement* pElement = static_cast<DOMElement*>(pChild); if (XMLString::equals(pElement->getNodeName(), X("Signature"))) { std::string signatureId = A(pElement->getAttribute(X("signatureId"))); Signature* pSignature = dynamic_cast<Signature*>(pSessionManager->getSessionItem(signatureId)); if (pSignature != NULL) { signatures.push_back(pSignature); } } } clearLibrary(); addSignatures(signatures); } return success; }
// Look at Xerces XSModel to parse XSD into tree SCMPrint void CXercesUtils::NagivateParseTree(xercesc::DOMElement* p, std::string tabs) { string name; short age; tabs+=" "; for (DOMNode* n = p->getFirstChild (); n != 0; n = n->getNextSibling ()) { if (n->getNodeType () != DOMNode::ELEMENT_NODE) continue; DOMElement* e = (DOMElement* ) n; std::string el_name = XMLString::transcode(n->getNodeName()); std::string el_value; if(e->getTextContent () && e->getChildElementCount() == (XMLSize_t) 0) el_value = XMLString::transcode(e->getTextContent ()); std::cerr << tabs.c_str() << el_name.c_str()<< "=" << el_value.c_str()<< endl; //DOMNode* node = n->getFirstChild (); NagivateParseTree((DOMElement*) n,tabs); } tabs=tabs.substr(1); }
void Triggerconf::createModule (string module) { if (rootnode == NULL) return; if (existsModule (module)) { resetError (); return; } XMLCh* xmodulename = XMLString::transcode (ELEMENT_MODULE_NAME); DOMElement* node = rootnode->getOwnerDocument ()->createElement (xmodulename); XMLString::release (&xmodulename); XMLCh* xattrname = XMLString::transcode (ATTRIBUTE_NAME); XMLCh* xmodule = XMLString::transcode (module.c_str ()); node->setAttribute (xattrname, xmodule); XMLString::release (&xattrname); XMLString::release (&xmodule); rootnode->appendChild (node); resetError (); }
bool CurveCollectionImp::fromXml(DOMNode* pDocument, unsigned int version) { if (pDocument == NULL || !PlotObjectImp::fromXml(pDocument, version)) { return false; } DOMElement* pElem = static_cast<DOMElement*>(pDocument); ColorType color = StringUtilities::fromXmlString<ColorType>(A(pElem->getAttribute(X("color")))); mColor = COLORTYPE_TO_QCOLOR(color); mLineWidth = StringUtilities::fromXmlString<int>(A(pElem->getAttribute(X("lineWidth")))); mLineStyle = StringUtilities::fromXmlString<LineStyle>(A(pElem->getAttribute(X("lineStyle")))); for (DOMNode* pChld = pElem->getFirstChild(); pChld != NULL; pChld = pChld->getNextSibling()) { if (XMLString::equals(pChld->getNodeName(), X("Curve"))) { CurveImp* pCurve = dynamic_cast<CurveImp*>(addCurve()); if (pCurve == NULL || !pCurve->fromXml(pChld, version)) { return false; } } } return true; }
string InputHandler::getAttributeValueByName(const XMLCh* elementNode, const XMLCh* attribute, const XMLCh* name) { crusde_debug("%s, line: %d, InputHandler::getAttributeValueByName(%s) name = %s ", __FILE__, __LINE__, XMLString::transcode(elementNode), XMLString::transcode(name)); assert(doc); DOMElement *root = doc->getDocumentElement(); DOMNode *child = root->getFirstChild(); DOMNamedNodeMap *attributes = NULL; while (child) { if(child != NULL) if( child->getNodeType() == DOMNode::ELEMENT_NODE ) { if(child->hasAttributes()) { attributes = child->getAttributes(); if( XMLString::compareIString( child->getNodeName(), elementNode) == 0 && XMLString::compareIString( attributes->getNamedItem(ATTR_name.xmlStr())->getNodeValue(), name) == 0 ) { char *val = XMLString::transcode(attributes->getNamedItem(attribute)->getNodeValue()); string value(val); XMLString::release(&val); return value; } } } child = child->getNextSibling(); } return string(); }
int ModelicaXML::serializeMoFileToXML(char* fileName) { // ModelicaXML filename (normal operation) DOMElement *pModelicaXMLElement = createModelicaXMLDOMElement(fileName); if (pModelicaXMLElement) pRootElementModelica->appendChild(pModelicaXMLElement); // vomit the current XML Document to file std::string xmlFile(fileName); xmlFile += ".xml"; serializeXMLDocumentToFile(xmlFile); XMLSize_t elementCount = pModelicaXMLDoc->getElementsByTagName(X("*"))->getLength(); std::cout << std::endl; std::cout << "The tree serialized contains: " << elementCount << " elements." << std::endl; return 0; }
void DeltaApplyEngine::TextNode_Update( XID_t nodeXID, DOMNode *operationNode ) { vddprintf((" update xid=%d\n",(int)nodeXID)); DOMNode* upNode = xiddoc->getXidMap().getNodeWithXID( nodeXID ); if (upNode==NULL) THROW_AWAY(("node with XID=%d not found",(int)nodeXID)); DOMNodeList *opNodes = operationNode->getChildNodes(); vddprintf(("opNodes->length() = %d\n", opNodes->getLength())); XyStrDeltaApply *xytext = new XyStrDeltaApply(xiddoc, upNode, 1); xytext->setApplyAnnotations(applyAnnotations); for (int i = opNodes->getLength() - 1; i >= 0; i--) { DOMElement *op = (DOMElement *) opNodes->item(i); char *optype = XMLString::transcode(op->getLocalName()); XMLCh pos_attr[4]; XMLCh len_attr[4]; XMLString::transcode("pos", pos_attr, 3); XMLString::transcode("len", len_attr, 3); vddprintf(("item %d = %s\n", i, optype)); // Replace operation if (strcmp(optype, "tr") == 0) { char *pos = XMLString::transcode(op->getAttribute(pos_attr)); char *len = XMLString::transcode(op->getAttribute(len_attr)); xytext->replace(atoi(pos), atoi(len), op->getTextContent()); XMLString::release(&pos); XMLString::release(&len); } // Delete operation else if (strcmp(optype, "td") == 0) { char *pos = XMLString::transcode(op->getAttribute(pos_attr)); char *len = XMLString::transcode(op->getAttribute(len_attr)); xytext->remove(atoi(pos), atoi(len)); XMLString::release(&pos); XMLString::release(&len); } // Insert operation else if (strcmp(optype, "ti") == 0) { char *pos = XMLString::transcode(op->getAttribute(pos_attr)); xytext->insert(atoi(pos), op->getTextContent()); XMLString::release(&pos); } XMLString::release(&optype); } xytext->complete(); delete xytext; }
XERCES_CPP_NAMESPACE_QUALIFIER DOMElement* readFontElement(const char* pName, XERCES_CPP_NAMESPACE_QUALIFIER DOMElement* pParent, Font& font) { DOMElement* pElement = dynamic_cast<DOMElement*>(findChildNode(pParent, pName)); if (pElement) { font.setFace(A(pElement->getAttribute(X("face")))); font.setPointSize(StringUtilities::fromXmlString<int>(A(pElement->getAttribute(X("point_size"))))); font.setBold(StringUtilities::fromXmlString<bool>(A(pElement->getAttribute(X("bold"))))); font.setItalic(StringUtilities::fromXmlString<bool>(A(pElement->getAttribute(X("italic"))))); font.setUnderline(StringUtilities::fromXmlString<bool>(A(pElement->getAttribute(X("underline"))))); } return pElement; }
xercesc::DOMElement *XCube::recursiveXML(xercesc::DOMDocument* doc) { DOMElement *cubeElem = doc->createElement(XMLString::transcode("Cube")); if(this->_name != "") cubeElem->setAttribute(XMLString::transcode("name"),XMLString::transcode(this->_name.c_str())); if(this->_fact != "") cubeElem->setAttribute(XMLString::transcode("tablename"),XMLString::transcode(this->_fact.c_str())); if(this->_dimensions.size() > 0) { Dimension *tempdimension; for(int i = 0;i < this->_dimensions.size() ;i++) { tempdimension = this->getDimension(_dimensions[i]->getName()); cubeElem->appendChild(tempdimension->recursiveXML(doc)); } } if(this->_measures.size() > 0) { Measure *tempMeasures; for(int i = 0;i < this->_measures.size() ;i++) { tempMeasures = this->getMeasure(_measures[i]->getName()); cubeElem->appendChild(tempMeasures->recursiveXML(doc)); } } if(this->_calcmembers.size() > 0) { calcMember *tempCalcmember; for(int i = 0;i < this->_calcmembers.size() ;i++) { tempCalcmember = this->getCalMember(_calcmembers[i]->getName()); cubeElem->appendChild(tempCalcmember->recursiveXML(doc)); } } return cubeElem; }
DOMElement* EppUtil::createElementNS( DOMDocument& doc, const DOMString ns, const DOMString tag, bool flag , char *_version) { DOMElement* elm; DOMString prefix(EPP_NAME_SPACE); char *use_version = version; if( NULL != _version ) /*param provided*/ use_version = _version; if( tag.isNull() ) { elm = doc.createElementNS(prefix + ns + use_version , ns); elm->setAttribute(XS("xmlns"), XS(EPP_NAME_SPACE) + ns + use_version ); if( use_version[0] == 0 ) { // old EPP-02 schema elm->setAttribute(XS("xmlns:xsi"), XS("http://www.w3.org/2000/10/XMLSchema-instance")); } else { elm->setAttribute(XS("xmlns:xsi"), XS("http://www.w3.org/2001/XMLSchema-instance")); } } else { elm = doc.createElementNS(prefix + ns + use_version, tag); elm->setPrefix(ns); if( flag ) { elm->setAttribute(XS("xmlns"), prefix + ns + use_version); } elm->setAttribute(XS("xmlns:") + ns, prefix + ns + use_version); } elm->setAttribute(XS("xsi:schemaLocation"), prefix + ns + use_version + " " + ns + use_version + ".xsd"); return elm; }
bool AxisImp::fromXml(DOMNode* pDocument, unsigned int version) { DOMElement* pElmnt = dynamic_cast<DOMElement*>(pDocument); if (pElmnt == NULL) { return false; } mTitle = A(pElmnt->getAttribute(X("title"))); for (DOMNode* pNode = pElmnt->getFirstChild(); pNode != NULL; pNode = pNode->getNextSibling()) { if (XMLString::equals(pNode->getNodeName(), X("titleFont"))) { DOMElement* pFontElement = static_cast<DOMElement*>(pNode); if (mTitleFont.fromXml(pFontElement, version) == false) { return false; } } } ColorType color = StringUtilities::fromXmlString<ColorType>(A(pElmnt->getAttribute(X("titleColor")))); mTitleColor = COLORTYPE_TO_QCOLOR(color); mScaleType = StringUtilities::fromXmlString<ScaleType>(A(pElmnt->getAttribute(X("scaleType")))); mMaxMajorTicks = StringUtilities::fromXmlString<int>(A(pElmnt->getAttribute(X("maxMajorTicks")))); mMaxMinorTicks = StringUtilities::fromXmlString<int>(A(pElmnt->getAttribute(X("maxMinorTicks")))); mScaleDraw.setLabelFormat(A(pElmnt->getAttribute(X("scaleDrawLabelFormat")))); double minValue = StringUtilities::fromXmlString<double>(A(pElmnt->getAttribute(X("minValue")))); double maxValue = StringUtilities::fromXmlString<double>(A(pElmnt->getAttribute(X("maxValue")))); setValueRange(minValue, maxValue); updateScale(); updateSize(); return true; }
int ModelicaXML::serializeAllMoFilesInDirectoryInXMLFile(char *directoryName, char *xmlFileName) { int i=0; typedef std::string mstring; mstring filename; l_list dirList; getDirectoryStructure(directoryName, dirList); std::list<char*>::const_iterator it; for(it=dirList.begin(); it!=dirList.end(); ++it) { l_list fileList; getFileList(*it, fileList, "*.mo"); // take care of pakage.mo first fileList = sortMoFiles(fileList); cout << "Found: " << fileList.size() << " *.mo files in directory: " << *it << endl; std::list<char*>::const_iterator itFileList; for(itFileList=fileList.begin(); itFileList!=fileList.end(); ++itFileList) { filename = mstring(*itFileList); cout << " [" << *itFileList << "]" << endl; DOMElement* pModelicaXML = createModelicaXMLDOMElement(filename.c_str()); // if is not NULL append it to the <modelica></modelica> element if (pModelicaXML) { pRootElementModelica->appendChild(pModelicaXML); i++; } } if (fileList.size()) cout << endl; } // vomit the current XML Document to file std::string xmlFile(xmlFileName); xmlFile = mstring(directoryName) + mstring(PATH_SEPARATOR) + xmlFile; xmlFile += ".xml"; serializeXMLDocumentToFile(xmlFile); cout << "Found: " << i << " .mo files" << endl; cout << "Serialized to: " << xmlFile << endl; return 0; }
DOMElement* EppResponseDataTransferSvcsub::toXML( DOMDocument& doc, const DOMString& tag ) { DOMElement* elm; DOMElement* body = doc.createElement(tag); DOMElement* data = EppUtil::createElementNS(doc, "svcsub", "trnData"); body->appendChild(data); if( id.isNotNull() ) { elm = doc.createElement(XS("id")); elm->appendChild(doc.createTextNode(id)); data->appendChild(elm); } if( service.isNotNull() ) { elm = doc.createElement(XS("xervice")); elm->appendChild(doc.createTextNode(service)); data->appendChild(elm); } toXMLCommon(doc, *data); return body; }
/* Add the name/value pairs to the document. */ static void AddNameValuePairs(const char *title, ParameterNameValuePairList ¶ms, DOMDocument* doc, DOMElement* parentElement) { if (params.size() == 0) return; DOMElement* element = doc->createElement(ToXMLCh(NAME_VALUE_PAIRS_ELEMENT_NAME)); element->setAttribute(ToXMLCh(NAME_ATTRIBUTE), ToXMLCh(title)); for (ParameterNameValuePairList::iterator it=params.begin(); it!=params.end(); it++) { ParameterNameValuePair &pair = *it; DOMElement* pairElement = doc->createElement(ToXMLCh(NAME_VALUE_PAIR_ELEMENT_NAME)); pairElement->setAttribute(ToXMLCh(NAME_ATTRIBUTE), ToXMLCh(pair.Name)); pairElement->setAttribute(ToXMLCh(VALUE_ATTRIBUTE), ToXMLCh(pair.Value)); element->appendChild(pairElement); } parentElement->appendChild(element); }
DOMElement* EppCredsOptions::toXML( DOMDocument& doc, const DOMString& tag ) { DOMElement* body = doc.createElement(tag); DOMElement* elm; if( version.isNotNull() ) { elm = doc.createElement(XS("version")); elm->appendChild(doc.createTextNode(version)); body->appendChild(elm); } if( lang.isNotNull() ) { elm = doc.createElement(XS("lang")); elm->appendChild(doc.createTextNode(lang)); body->appendChild(elm); } return body; }
DOMElement* EppContactData::toXML( DOMDocument& doc, const DOMString& tag ) { DOMElement* body = doc.createElement(tag); DOMElement* elm; if( name.isNotNull() ) { elm = doc.createElement(XS("name")); elm->appendChild(doc.createTextNode(name)); body->appendChild(elm); } if( (org.isNotNull()) || hasOrg ) { elm = doc.createElement(XS("org")); elm->appendChild(doc.createTextNode(org)); body->appendChild(elm); } if( !addr.isNull() ) { body->appendChild(addr.toXML(doc, "addr")); } return body; }
DOMElement* EppCommandTransferDomain::toXMLPoll( DOMDocument& doc, const DOMString& tag ) { DOMElement* elm; DOMElement* body = EppUtil::createElementNS(doc, "domain", tag); if( name.isNotNull() ) { elm = doc.createElement(XS("name")); elm->appendChild(doc.createTextNode(name)); body->appendChild(elm); } if( period != null ) { body->appendChild(period->toXML(doc, "period")); } if( authInfo != null ) { body->appendChild(authInfo->toXML(doc, "authInfo")); } return body; }