void GUI::YuvFileOpenDialog::hasFinished(int result) {
	if(result==QDialog::Accepted) {
		int selectedindex=-1;
		if(!listView_recentlyUsed_->selectionModel()->selectedIndexes().isEmpty()) {
			selectedindex=listView_recentlyUsed_->selectionModel()->selectedIndexes().first().row();
		}

		QString fileattributes;
		if(selectedindex!=-1&&getFilename()==getListModel()->stringList().at(selectedindex)) {
			bool res=parseAttributes(attributes_[selectedindex]);

			if(!res) {
				if((fileattributes=askAttributes()).isEmpty()) {
					setResult(QDialog::Rejected);
					return;
				}
			} else {
				fileattributes=attributes_[selectedindex];
			}
		} else {
			if(getFilename().isEmpty()||(fileattributes=askAttributes()).isEmpty()) {
				setResult(QDialog::Rejected);
				return;
			}
		}
		parseAttributes(fileattributes);
		saveListModel(getFilename(),fileattributes);
	}
}

bool ProcessingInstruction::checkStyleSheet(String& href, String& charset)
{
    if (m_target != "xml-stylesheet" || !document().frame() || parentNode() != document())
        return false;

    // see http://www.w3.org/TR/xml-stylesheet/
    // ### support stylesheet included in a fragment of this (or another) document
    // ### make sure this gets called when adding from javascript
    bool attrsOk;
    const HashMap<String, String> attrs = parseAttributes(m_data, attrsOk);
    if (!attrsOk)
        return false;
    HashMap<String, String>::const_iterator i = attrs.find("type");
    String type;
    if (i != attrs.end())
        type = i->value;

    m_isCSS = type.isEmpty() || type == "text/css";
    m_isXSL = (type == "text/xml" || type == "text/xsl" || type == "application/xml" || type == "application/xhtml+xml" || type == "application/rss+xml" || type == "application/atom+xml");
    if (!m_isCSS && !m_isXSL)
        return false;

    href = attrs.get("href");
    charset = attrs.get("charset");
    String alternate = attrs.get("alternate");
    m_alternate = alternate == "yes";
    m_title = attrs.get("title");
    m_media = attrs.get("media");

    return !m_alternate || !m_title.isEmpty();
}

inline bool TamlXmlParser::parseElement( TiXmlElement* pXmlElement, TamlVisitor& visitor )
{
    // Debug Profiling.
    PROFILE_SCOPE(TamlXmlParser_ParseElement);

    // Parse attributes (stop processing if instructed).
    if ( !parseAttributes( pXmlElement, visitor ) )
        return false;

    // Finish if only the root is needed.
    if ( visitor.wantsRootOnly() )
        return false;

    // Fetch any children.
    TiXmlNode* pChildXmlNode = pXmlElement->FirstChild();

    // Do we have any element children?
    if ( pChildXmlNode != NULL && pChildXmlNode->Type() == TiXmlNode::TINYXML_ELEMENT )
    {
        // Iterate children.
        for ( TiXmlElement* pChildXmlElement = dynamic_cast<TiXmlElement*>( pChildXmlNode ); pChildXmlElement; pChildXmlElement = pChildXmlElement->NextSiblingElement() )
        {
            // Parse element (stop processing if instructed).
            if ( !parseElement( pChildXmlElement, visitor ) )
                return false;
        }
    }

    return true;
}

      //-----------------------------------------------------------------------
      ISDPTypes::SDPPtr SDPParser::parse(const char *blob)
      {
        if (!blob) return SDPPtr();

        SDPPtr sdp(make_shared<SDP>());

        sdp->mOriginal = String(blob);
        std::unique_ptr<char[]> rawBuffer(new char[sdp->mOriginal.length()+1]);
        sdp->mRawBuffer = std::move(rawBuffer);

        memset(sdp->mRawBuffer.get(), 0, sizeof(char)*(sdp->mOriginal.length()+1));
        memcpy(sdp->mRawBuffer.get(), blob, sizeof(char)*(sdp->mOriginal.length()));

        try {
          parseLines(*sdp);
          parseAttributes(*sdp);
          validateAttributeLevels(*sdp);
          parseLinesDetails(*sdp);
          processFlagAttributes(*sdp);
          processSessionLevelValues(*sdp);
          processMediaLevelValues(*sdp);
          processSourceLevelValues(*sdp);
        } catch (const SafeIntException &e) {
          ORTC_THROW_INVALID_PARAMETERS("value found out of legal value range" + string(e.m_code));
        }

        return sdp;
      }

Lexer::Token Artlink::parse( Lexer* lexer )
{
    Lexer::Token tok( parseAttributes( lexer ) );
    while( tok != Lexer::END ) {
        if( tok == Lexer::TAG ) {
            if( lexer->tagId() == Lexer::LINK ) {
                Link* link( new Link( document, this, document->dataName(),
                            document->lexerLine(), document->lexerCol() ) );
                appendChild( link );
                link->setNoEndTag();
                link->setHypergraphic();
                tok = link->parse( lexer );
            }
            else if( lexer->tagId() == Lexer::EARTLINK || lexer->tagId() == Lexer::EUSERDOC )
                break;
            else
                parseCleanup( lexer, tok );
        }
        else {
            if( tok != Lexer::WHITESPACE )
                printError( ERR1_TAGCONTEXT );
            tok = document->getNextToken();
        }
    }
    return tok;
}

void VertexShader::compile()
{
    uncompile();

    compileToHLSL(mVertexCompiler);
    parseAttributes();
    parseVaryings();
}

    int
Tag::parseFurther ()
{
    if (m_pTagAttrString)
    {
        parseAttributes (m_pTagAttrString);
    }
    return m_attrList.size ();
}

Lexer::Token P::parse( Lexer* lexer )
{
    Lexer::Token tok( parseAttributes( lexer ) );
    while( tok != Lexer::END && !( tok == Lexer::TAG && lexer->tagId() == Lexer::EUSERDOC ) ) {
        //may contain inline, not block
        if( parseInline( lexer, tok ) )
            break;
    }
    return tok;
}

	void CModelReaderNode_Slices1507_Segment::parseXML(_In_ CXmlReader * pXMLReader) {
		// Parse name
		parseName(pXMLReader);

		// Parse attribute
		parseAttributes(pXMLReader);

		// Parse Content
		parseContent(pXMLReader);
	}

void AttributesParser::parse()
{
	const Token* pNext = next();
	if (!isEOF(pNext))
	{
		pNext = parseAttributes(pNext);
	}
	if (!isEOF(pNext))
		throw Poco::SyntaxException("extra tokens found in attribute declaration");
}

	void CModelReader_Slice1507_SliceRefModel::parseXML(_In_ CXmlReader * pXMLReader) {
		// Parse name
		parseName(pXMLReader);

		// Parse attribute
		parseAttributes(pXMLReader);

		// Parse Content
		parseContent(pXMLReader);
	}

	void CModelReaderNode093_Components::parseXML(_In_ CXmlReader * pXMLReader)
	{
		// Parse name
		parseName(pXMLReader);

		// Parse attribute
		parseAttributes(pXMLReader);

		// Parse Content
		parseContent(pXMLReader);
	}

	void COpcPackageRelationshipReader::parseRootNode(_In_ CXmlReader * pXMLReader)
	{
		if (pXMLReader == nullptr)
			throw CNMRException(NMR_ERROR_INVALIDPARAM);

		parseAttributes(pXMLReader);

		while (!pXMLReader->IsEOF()) {
			LPCWSTR pwszLocalName = nullptr;
			LPCWSTR pwszNameSpaceURI = nullptr;
			UINT nCount = 0;
			UINT nNameSpaceCount = 0;

			eXmlReaderNodeType NodeType;
			pXMLReader->Read(NodeType);

			switch (NodeType) {
			case XMLREADERNODETYPE_STARTELEMENT:
				pXMLReader->GetLocalName(&pwszLocalName, &nCount);
				if (!pwszLocalName)
					throw CNMRException(NMR_ERROR_COULDNOTGETLOCALXMLNAME);

				pXMLReader->GetNamespaceURI(&pwszNameSpaceURI, &nNameSpaceCount);
				if (!pwszNameSpaceURI)
					throw CNMRException(NMR_ERROR_COULDNOTGETNAMESPACE);

				if (nCount > 0) {
					if (wcscmp(pwszNameSpaceURI, OPCPACKAGE_SCHEMA_RELATIONSHIPS) == 0) {
						if (wcscmp(pwszLocalName, OPC_RELS_RELATIONSHIP_NODE) == 0) {
							parseChildNode(pXMLReader);
						}
					}
				}
				break;

			case XMLREADERNODETYPE_ENDELEMENT:
				pXMLReader->GetLocalName(&pwszLocalName, &nCount);
				if (!pwszLocalName)
					throw CNMRException(NMR_ERROR_COULDNOTGETLOCALXMLNAME);

				if (wcscmp(pwszLocalName, OPC_RELS_RELATIONSHIP_CONTAINER) == 0) {
					return;
				}
				pXMLReader->CloseElement();
				break;

			case XMLREADERNODETYPE_UNKNOWN:
				break;

			case XMLREADERNODETYPE_TEXT:
				break;
			}
		}
	}

	void CModelReaderNode100_Vertex::parseXML(_In_ CXmlReader * pXMLReader)
	{
		// Parse name
		parseName(pXMLReader);

		// Parse attribute
		parseAttributes(pXMLReader);

		// Parse Content
		parseContent(pXMLReader);
	}

	void CModelReaderNode_BeamLattice1702_BeamLattice::parseXML(_In_ CXmlReader * pXMLReader)
	{
		// Parse name
		parseName(pXMLReader);

		// Parse attribute
		parseAttributes(pXMLReader);

		// Parse Content
		parseContent(pXMLReader);

	}

	void CModelReaderNode_Slices1507_Vertex::parseXML(_In_ CXmlReader * pXMLReader) {
		// Parse name
		parseName(pXMLReader);

		// Parse attribute
		parseAttributes(pXMLReader);

		// Parse Content
		parseContent(pXMLReader);

		m_pSlice->addVertex(m_x, m_y);
	}

// -------------------------------------------------------------------------------
void XMLPersister::parseNode( QDomNode& node,
                                     CTreeInformationElement& informationElement )
// -------------------------------------------------------------------------------
{
   if ( node.isElement() )
   {
      QDomElement elem = node.toElement();
      //cout<<"element; tagname= "<<elem.tagName()<<endl;

      if ( elem.tagName() == "Description" )
      {
         informationElement.setDescription( elem.text() );
         parseDescriptionAttributes( elem, informationElement );
      }
      else if ( elem.tagName() == "Information" )
      {
         // QDomText textNode=node.toText();
         //std::cout<<"==="<<elem.text()<<std::endl;

         // determine whether current elemenet contains encrypted data
         if ( false != bCurrentElementIsBase64Encrypted )
         {
            // do base64 decodeing
            //std::cout<<"decoding64"<<std::endl;
            CBase64Coder b64Coder = CBase64Coder::getInstance();
            QByteArray encryptedData;
            b64Coder.decode( encryptedData, elem.text() );

            informationElement.setEncryptedData( encryptedData );
         }
         else
         {
            informationElement.setInformation( elem.text() );
         }
      }
      else if ( elem.tagName() == "InformationElement" ) {
         CTreeInformationElement* e = new CTreeInformationElement( &informationElement );
         parseAttributes( elem, *e );
         informationElement.addChild( e );
         parseChildrenOf( node, *e );
      }

//    cout<<"!!! still guessing for richtext"<<endl;
//    if ( QStyleSheet::mightBeRichText(informationElement->getInformation()) )
//      informationElement->setInformationFormat(&InformationFormat::RTF);
//    else
//      informationElement->setInformationFormat(&InformationFormat::ASCII);

   }
}

	FastXmlLine(string str) {
		this->str = str;
		bool hasSlashAtBeginning = false;
		bool hasSlashAtEnd = false;
		bool hasOpen = false;
		bool hasClosed = false;
		for(int i = 0; i < str.size(); i++) {
			if(str[i]=='<') hasOpen = true;
			else if(str[i]=='>') hasClosed = true;
			else if(str[i]=='/') {
				if(i>0 && str[i-1]=='<') hasSlashAtBeginning = true;
				else hasSlashAtEnd = true;
			}
			
		}
		if(hasOpen && hasClosed) {
			if(hasSlashAtBeginning) {
				type = closeTag;
			} else if(hasSlashAtEnd) {
				type = emptyTag;
			} else {
				type = openTag;
			}
		} else {
			type = dataTag;
		}
		
		
		// find tag name
		if(type==openTag || type==emptyTag) {
			int start = str.find('<')+1;
			int spacePos = str.find(' ');
			int brackPos = str.find('>');
			int length = 0;
			if(spacePos!=-1) length = spacePos - start;
			else length = brackPos - start;
			name = str.substr(start, length);
		} else if(type==closeTag) {
			int start = str.find('/')+1;
			int brackPos = str.find('>');
			int length = brackPos - start;
			name = str.substr(start, length);
		}
		// find attributes
		
		if(type==openTag || type==emptyTag) {
			parseAttributes();
		}
	}

        SketchElement *PathParser::parse(SketchElement *parent,
                TiXmlElement *element)
        {
            Path *path = new Path(parent);
            parseAttributes(path, element);

            string data =
                    element->Attribute("d") ? element->Attribute("d") : "";

            PathDataParser *pathDataParser = new PathDataParser(path, data);
            pathDataParser->parse();
            delete pathDataParser;

            return path;
        }

 inline bool
 AsciiXmlParser::readNextElement()
 /* this reads in the entire next XML element. false is returned if the end
  * of the text was reached before a new XML element could be found (or if
  * no end for the next element could be found).
  */
 {
   return ( discardToNextTag()
            &&
            parseTagName( elementName )
            &&
            parseAttributes()
            &&
            recordToEndOfElement() );
 }