const TiXmlElement* TiXmlNode::FirstChildElement( const char * _value ) const
{
	const TiXmlNode* node;

	for (	node = FirstChild( _value );
			node;
			node = node->NextSibling( _value ) )
	{
		if ( node->ToElement() )
			return node->ToElement();
	}
	return 0;
}

TiXmlElement* TiXmlNode::FirstChildElement()
{
	TiXmlNode* node;

	for (	node = FirstChild();
			node;
			node = node->NextSibling() )
	{
		if ( node->ToElement() )
			return node->ToElement();
	}
	return 0;
}

void TiXmlDocument::StreamOut( TIXML_OSTREAM * out ) const
{
	TiXmlNode* node;
	for ( node=FirstChild(); node; node=node->NextSibling() )
	{
		node->StreamOut( out );

		// Special rule for streams: stop after the root element.
		// The stream in code will only read one element, so don't
		// write more than one.
		if ( node->ToElement() )
			break;
	}
}

	bool XMLDocument::Accept(XMLVisitor* visitor) const
	{
		if (visitor->VisitEnter(*this))
		{
			for (const XMLNode* node = FirstChild(); node; node = node->NextSibling())
			{
				if (!node->Accept(visitor))
				{
					break;
				}
			}
		}
		return visitor->VisitExit(*this);
	}

const char * XmlNode::GetText() const
{
	const TiXmlNode * childNode = FirstChild();
	if ( childNode == NULL )
	{
		return NULL;
	}
	IE_ASSERT( childNode->Type() == TEXT );

	const TiXmlText * text = childNode->ToText();
	IE_ASSERT( text );

	return text->Value();
}

void XMLParagraph::DeleteLeaf(size_t nLeaf)
{
    auto pNode   = LeafRef(nLeaf).Node();
    auto pParent = pNode->Parent();

    while(pParent && (pParent->FirstChild() == pParent->LastChild())){
        pNode   = pParent;
        pParent = pParent->Parent();
    }

    if(pParent){
        pParent->DeleteChild(pNode);
    }
}

void CookiePath::BuildCookieEditorListL(CookieDomain* domain)
{
	Cookie *ck = (Cookie*)cookie_list.First();
	if( ck )
	{
		ck->BuildCookieEditorListL(domain, this);
	}
	
	CookiePath *cp = (CookiePath*)FirstChild();
	while(cp)
	{
		cp->BuildCookieEditorListL(domain);
		cp = cp->Suc();
	}
}

	Node * Node::FindEditChildByAttrib (	std::string const & childName, 
											std::string const & attrName, 
											std::string const & attrValue)
	{
		XML::Node::ChildIter it = FirstChild ();
		XML::Node::ChildIter last = LastChild ();
		while (it != last)
		{
			XML::Node * child = *it;
			if (child->GetName () == childName && child->FindAttribValue (attrName) == attrValue)
				return child;
			++it;
		}
		return 0;
	}

void CookiePath::IterateAllCookies()
{
	Cookie* ck = static_cast<Cookie*>( cookie_list.First() );
	OpCookieIteratorListener* listener = g_cookie_API->GetCookieIteratorListener();
	while( ck )
	{
		listener->OnIterateCookies(*ck);
		ck = ck->Suc();
	}

	CookiePath* cp = static_cast<CookiePath*>( FirstChild() );
	while (cp)
	{
		cp->IterateAllCookies();
		cp = cp->Suc();
	}
}

int TiXmlDocument::Printe( char * xmlstr, int totallen, int depth, int& len ) 
{
	char tempstr[MAX_XML_SIZE] = {0};
	TiXmlNode* node = NULL;
	for ( node = FirstChild(); node; node = node->NextSibling() )
	{
		//#ifdef _PUTSTRING
		if ( node->Printe( xmlstr, totallen, depth, len ) < 0 )
		{
			return -2;
		}
		//#endif
		sprintf( tempstr, "\n" );
		SAFE_STRCAT;
	}

	return 0;
}

void CookiePath::GetMemUsed(DebugUrlMemory &debug)
{
	debug.memory_cookies += sizeof(*this) + path.Length();

	Cookie *ck = (Cookie *) cookie_list.First();
	while(ck)
	{
		ck->GetMemUsed(debug);
		ck = ck->Suc();
	}

	CookiePath *cp = (CookiePath *) FirstChild();
	while(cp)
	{
		cp->GetMemUsed(debug);
		cp = cp->Suc();
	}
}

nsFrameList::Slice
nsFrameList::InsertFrames(nsIFrame* aParent, nsIFrame* aPrevSibling,
                          nsFrameList& aFrameList)
{
  NS_PRECONDITION(aFrameList.NotEmpty(), "Unexpected empty list");

  if (aParent) {
    aFrameList.ApplySetParent(aParent);
  }

  NS_ASSERTION(IsEmpty() ||
               FirstChild()->GetParent() == aFrameList.FirstChild()->GetParent(),
               "frame to add has different parent");
  NS_ASSERTION(!aPrevSibling ||
               aPrevSibling->GetParent() == aFrameList.FirstChild()->GetParent(),
               "prev sibling has different parent");
#ifdef DEBUG_FRAME_LIST
  // ContainsFrame is O(N)
  NS_ASSERTION(!aPrevSibling || ContainsFrame(aPrevSibling),
               "prev sibling is not on this list");
#endif

  nsIFrame* firstNewFrame = aFrameList.FirstChild();
  nsIFrame* nextSibling;
  if (aPrevSibling) {
    nextSibling = aPrevSibling->GetNextSibling();
    aPrevSibling->SetNextSibling(firstNewFrame);
  }
  else {
    nextSibling = mFirstChild;
    mFirstChild = firstNewFrame;
  }

  nsIFrame* lastNewFrame = aFrameList.LastChild();
  lastNewFrame->SetNextSibling(nextSibling);
  if (!nextSibling) {
    mLastChild = lastNewFrame;
  }

  VerifyList();

  aFrameList.Clear();
  return Slice(*this, firstNewFrame, nextSibling);
}

void CookiePath::DebugWriteCookies(FILE* fp)
{
	fprintf(fp, "   ");
	DebugWritePath(fp);
	fprintf(fp, ": \n");
	Cookie* ck = (Cookie*) cookie_list.First();
	while (ck)
	{
		fprintf(fp, "      %s=%s; %lu; %d; %lu %s\n", ck->Name(), ck->Value(), ck->Expires(), ck->Secure(), ck->GetLastUsed(), (ck->DiscardAtExit() ? "; Discard on exit" : ""));
		ck = ck->Suc();
	}

	CookiePath* cp = (CookiePath*) FirstChild();
	while (cp)
	{
		cp->DebugWriteCookies(fp);
		cp = cp->Suc();
	}
}

NS_IMETHODIMP
inDeepTreeWalker::NextNode(nsIDOMNode **_retval)
{
  // First try our kids
  FirstChild(_retval);

  if (*_retval) {
    return NS_OK;
  }

  // Now keep trying next siblings up the parent chain, but if we
  // discover there's nothing else restore our state.
#ifdef DEBUG
  nsIDOMNode* origCurrentNode = mCurrentNode;
#endif
  uint32_t lastChildCallsToMake = 0;
  while (1) {
    NextSibling(_retval);

    if (*_retval) {
      return NS_OK;
    }

    nsCOMPtr<nsIDOMNode> parent;
    ParentNode(getter_AddRefs(parent));
    if (!parent) {
      // Nowhere else to go; we're done.  Restore our state.
      while (lastChildCallsToMake--) {
        nsCOMPtr<nsIDOMNode> dummy;
        LastChild(getter_AddRefs(dummy));
      }
      NS_ASSERTION(mCurrentNode == origCurrentNode,
                   "Didn't go back to the right node?");
      *_retval = nullptr;
      return NS_OK;
    }
    ++lastChildCallsToMake;
  }

  NS_NOTREACHED("how did we get here?");
  return NS_OK;
}

	void Node::Write (std::ostream & out, unsigned indent) const
	{
		WriteOpeningTag (out, indent);
		if (!_closed)
		{
			for (ConstChildIter it = FirstChild (); it != LastChild (); ++it)
			{
				XML::Node * child = *it;
				if (child->GetName ().empty ()) // text
				{
					out << Indentation (indent) << child->GetAttribValue ("Text") << std::endl;
				}
				else
				{
					child->Write (out, indent + 2);
				}
			}
		}
		WriteClosingTag (out, indent);
	}

// Return TRUE if empty
BOOL CookiePath::FreeUnusedResources()
{
	BOOL ret = cookie_list.Empty();

	CookiePath* next_cp = (CookiePath*) FirstChild();
	while (next_cp)
	{
		CookiePath* cp =next_cp;
		next_cp = cp->Suc();

		if(cp->FreeUnusedResources())
		{
			cp->Out();
			OP_DELETE(cp);
		}
		else
			ret = FALSE;
	}

	return ret;
}

OP_STATUS CookiePath::BuildCookieList(Cookie ** cookieArray, int * pos, char * pathstr, CookieDomain *domainHolder, BOOL is_export, BOOL match_subpaths/*=FALSE*/)
{
	char* pathstrcopy = pathstr;
	if(!match_subpaths && path.HasContent() && pathstr && *pathstr)
	{
		int p_len = path.Length();
		if(path.Compare(pathstr,p_len) != 0)
			return OpStatus::OK;

		pathstr += p_len; // Remove first part, if path found
		if(*pathstr == '/') pathstr++;
	}

	Cookie *ck = (Cookie*)cookie_list.First();
	if( ck )
	{
		if(match_subpaths && pathstrcopy && *pathstrcopy)	//if a path was specified
		{
			OpString8 fullpath;
			RETURN_IF_ERROR(GetFullPath(fullpath));	// get the full path
			//the internal root part does not start with /, so get rid of it
			fullpath.Delete(0,1);
			int pathlen = fullpath.Length();
			if(!pathlen || (pathlen && fullpath.Compare(pathstrcopy, pathlen) == 0))	//compare against the full path length since we want subpaths, root has null length
				ck->BuildCookieList(cookieArray, pos, domainHolder, this, is_export);
		}
		else
			ck->BuildCookieList(cookieArray, pos, domainHolder, this, is_export);
	}
	
	CookiePath *cp = (CookiePath*)FirstChild();
	while(cp)
	{
		cp->BuildCookieList(cookieArray, pos, pathstr, domainHolder, is_export, match_subpaths);
		cp = cp->Suc();
	}

    return OpStatus::OK;
}

static PNODE TreeGetLeftmost(PNODE pThisNode,
	unsigned nCurrentLevel,
	unsigned nSearchDepth)
{
	/*------------------------------------------------------
	* Determine the leftmost descendant of a node at a
	* given depth. This is implemented using a post-order
	* walk of the subtree under pThisNode, down to the
	* level of nSearchDepth. If we've searched to the
	* proper distance, return the currently leftmost node.
	* Otherwise, recursively look at the progressively
	* lower levels.
	*----------------------------------------------------*/

	PNODE pLeftmost;    /* leftmost descendant at level   */
	PNODE pRightmost;   /* rightmost offspring in search  */

	if (nCurrentLevel == nSearchDepth)
		pLeftmost = pThisNode; /*  searched far enough.    */
	else if (IsLeaf(pThisNode))
		pLeftmost = 0;  /* This node has no descendants    */
	else {  /* Do a post-order walk of the subtree.        */
		for (pLeftmost = TreeGetLeftmost(pRightmost =
			FirstChild(pThisNode),
			nCurrentLevel + 1,
			nSearchDepth)

			;
			(pLeftmost == 0) && (HasRightSibling(pRightmost))
			;
			pLeftmost = TreeGetLeftmost(pRightmost =
				RightSibling(pRightmost),
				nCurrentLevel + 1,
				nSearchDepth)
			) { /* Nothing inside this for-loop. */
		}
	}
	return (pLeftmost);
}

// pth must not start with '/'
CookiePath* CookiePath::GetCookiePathL(const char* pth, BOOL create, BOOL &is_full_path)
{
	if (pth && *pth)
	{
		is_full_path = FALSE;
		char* tmp = (char*) (*pth != '?' ? op_strpbrk(pth, "/?") : NULL);
		char save_c = 0;
		if (tmp)
		{
			save_c = *tmp;
			*tmp = '\0';
		}

		int test = 1;
		BOOL is_prefix = FALSE;
		CookiePath* cp = LastChild();

		if(create)
		{
			while (cp && test>0)
			{
				test = UriUnescape::strcmp(cp->PathPart().CStr(), pth, UriUnescape::Safe);
				if (test > 0)
					cp = cp->Pred();
			}
		}
		else
		{
			int len1 = op_strlen(pth);
			int clen;

			while(cp && test>0)
			{
				clen = cp->PathPart().Length();

				if(clen < len1 && UriUnescape::isstrprefix(cp->PathPart().CStr(), pth, UriUnescape::All))
				{
					is_prefix = TRUE;
					test = 0;
				}
				else
					test = UriUnescape::strcmp(cp->PathPart().CStr(), pth, UriUnescape::Safe);
				if (test > 0)
					cp = cp->Pred();

			}
		}

		CookiePath* next_cp = cp;
		if (test != 0 || !cp)
		{
			if (!create)
			{
				if (tmp)
					*tmp = save_c;

				return this;
			}

			next_cp = CookiePath::CreateL(pth);

			if (cp)
				next_cp->Follow(cp);
			else if (FirstChild())
				next_cp->Precede(FirstChild());
			else
				next_cp->Under(this);
		}

		BOOL local_is_full_path = FALSE;
		if (tmp)
		{
			*tmp = save_c;
			if(save_c == '/')
				local_is_full_path = TRUE;
		}

		const char* next_path = (tmp && !is_prefix) ? (save_c == '?' ? tmp : tmp+1) : 0;
		CookiePath* return_cp = next_cp->GetCookiePathL(next_path, create, is_full_path);

		if(return_cp == next_cp && tmp && local_is_full_path && !is_prefix)
			is_full_path = TRUE;

		return return_cp;
	}
	else
	{
		return this;
	}
}

GlowWidget::AutoPackError GlowQuickPanelWidget::OnAutoPack(
	int hSize,
	int vSize,
	AutoPackOptions hOption,
	AutoPackOptions vOption,
	int& leftMargin,
	int& rightMargin,
	int& topMargin,
	int& bottomMargin)
{
	GLOW_DEBUGSCOPE("GlowQuickPanelWidget::OnAutoPack");
	
	int position = (_arrangement == vertical) ? _vmargin : _hmargin;
	int size = 0;
	int minWidth = position;
	
	// Arrange widgets with default alignment
	for (GlowComponent* child = FirstChild(); child != 0; child = child->Next())
	{
		// Get next widget
		GlowWidget* widget = dynamic_cast<GlowWidget*>(child);
		if (widget == 0 || !widget->IsVisible() || widget->IsClosing())
		{
			continue;
		}
		
		// Handle the label of the panel (if any) differently.
		if (widget == _label)
		{
			if (GetStyle() == GlowPanelWidget::etchedStyle)
			{
				// Etched style: label is half in and half out of the panel
				widget->AutoPack(_hmargin, unspecifiedPos, 0, unspecifiedPos,
					leftPos | preferredSize, centerPos | preferredSize);
				topMargin = widget->Height()/2;
				if (_arrangement == vertical)
				{
					position += widget->Height()/2;
				}
			}
			else
			{
				// Other style: label is completely out of the panel
				widget->AutoPack(_hmargin, unspecifiedPos, unspecifiedPos, 0,
					leftPos | preferredSize, bottomPos | preferredSize);
				topMargin = widget->Height();
			}
			minWidth = widget->Width()+_hmargin+_hmargin;
			continue;
		}
		
		int leftMargin = 0, rightMargin = 0, topMargin = 0, bottomMargin = 0;
		if (_arrangement == horizontal)
		{
			widget->AutoPack(position, unspecifiedPos, _vmargin, unspecifiedPos,
				leftPos | preferredSize, topPos | preferredSize,
				leftMargin, rightMargin, topMargin, bottomMargin);
			size = GLOW_STD::max(size, widget->Height()+topMargin+bottomMargin);
			position += widget->Width()+leftMargin+rightMargin+_spacing;
		}
		else
		{
			widget->AutoPack(_hmargin, unspecifiedPos, position, unspecifiedPos,
				leftPos | preferredSize, topPos | preferredSize,
				leftMargin, rightMargin, topMargin, bottomMargin);
			size = GLOW_STD::max(size, widget->Width()+leftMargin+rightMargin);
			position += widget->Height()+topMargin+bottomMargin+_spacing;
		}
	}
	
	// Preferred width and height
	int pwidth = 0, pheight = 0;
	if (_arrangement == horizontal)
	{
		pwidth = GLOW_STD::max(minWidth, position-_spacing+_hmargin);
		pheight = size+_vmargin+_vmargin;
	}
	else
	{
		pwidth = GLOW_STD::max(minWidth, size+_hmargin+_hmargin);
		pheight = position-_spacing+_vmargin;
	}
	
	// Panel width
	int hnew = Width();
	if (hOption == forcedSize || hOption == expandPreferredSize)
	{
		hnew = hSize;
	}
	else if (hOption == preferredSize)
	{
		hnew = pwidth;
	}
	if (hnew < pwidth)
	{
		return hAutoPackError;
	}
	
	// Panel height
	int vnew = Height();
//.........这里部分代码省略.........