Symbian

开发平台：

C/C++

smlparse.cpp：源码内容

{
goto exit;
}
}
// /"systemAudioDesc", "systemOperatingSystem", and "systemCPU" were
// introduced in SMIL 2.0:
// /XXXEH- TODO: We need to coordinate with TLC folks to make this a
// user-settable option:
rc = pNode->m_pValues->GetPropertyCString("systemAudioDesc", pBuf);
if(HXR_OK == rc)
{
const char* pActualValue = (const char*)pBuf->GetBuffer();
if(strcmp(pActualValue, "on") == 0)
{
if(!m_bSystemAudioDescPreference)
{
bFailed = TRUE;
}
}
else
{
if(m_bSystemAudioDescPreference)
{
bFailed = TRUE;
}
}
pBuf->Release();
if(bFailed)
{
goto exit;
}
}
rc = pNode->m_pValues->GetPropertyCString("systemOperatingSystem",
pBuf);
if(HXR_OK == rc && HX_PLATFORM_UNKNOWN!=m_versionInfo.dwPlatformId)
{
#if defined(_MACINTOSH) || defined(_MAC_UNIX) // /Sanity check on Mac platform id:
HX_ASSERT(HX_PLATFORM_MACOT == m_versionInfo.dwPlatformId ||
HX_PLATFORM_MACTCP == m_versionInfo.dwPlatformId);
#endif
const char* pOS = (const char*)pBuf->GetBuffer();
// /First, strip leading whitespace chars:
while (*pOS && isspace(*pOS))
{
*pOS++;
}
/*fixes PR 64428 (UseSystemOS version)*/
if (!m_bUseSystemOS)
{
// /Fixes PR 81522 (systemOperatingSystem version): if user
// says not to use OS info, treat it as unknown per SMIL2 spec:
bFailed = FALSE; // /Setting to FALSE instead of comparing to
// "unknown" fixes OS part of PR 64428(revisted)
goto doneSysOS;
}
// /From the SMIL 2.0 CR spec:
// "The following list contains the suggested values for this
// test attribute (additional names may be supported by an
// implementation):
// aix, beos, bsdi, dgux, freebsd, hpux, irix, linux,
// macos, ncr, nec, netbsd, nextstep, nto, openbsd, openvms,
// os2, osf, palmos, qnx, sinix, rhapsody, sco, solaris,
// sonly, sunos, unixware, win16, win32, win9x, winnt,
// wince, unknown"
// /NOTE: current Mozilla list can be found here:
// http://lxr.mozilla.org/seamonkey/search?string=_PR_SI_SYSNAME
switch (m_versionInfo.dwPlatformId)
{
case HX_PLATFORM_IRIX:
{
if (0 != strcmp("irix", pOS))
{
bFailed = TRUE;
}
}
break;
case HX_PLATFORM_LINUX:
{
if (0 != strcmp("linux", pOS))
{
bFailed = TRUE;
}
}
break;
case HX_PLATFORM_MACOT:
case HX_PLATFORM_MACTCP:
{
if (0 != strcmp("macos", pOS))
{
bFailed = TRUE;
// _DARWIN, _CARBON, and/or _MAC_UNIX implies Darwin is present on a Mac:
#if defined(_DARWIN) || defined(_CARBON) || defined(_MAC_UNIX)
// /Fixes PR 95625: Also check for darwin (UNIX on Mac):
bFailed = (0 != strcmp("darwin", pOS));
#endif // / _DARWIN || _CARBON || _MAC_UNIX.
}
}
break;
case HX_PLATFORM_QNXNTO:
{ // /We should assert! But, hey, it might come back 8-]
if (0 != strcmp("qnx", pOS))
{
bFailed = TRUE;
}
}
break;
case HX_PLATFORM_SOLARIS:
case HX_PLATFORM_SUNOS:
{
// /These are the same since RN started porting to them:
if (0 != strcmp("solaris", pOS) &&
0 != strcmp("sunos", pOS))
{
bFailed = TRUE;
}
}
break;
case HX_PLATFORM_WIN16:
{ // /We should really assert! But, it might come back 8-]
if (0 != strcmp("win16", pOS))
{
bFailed = TRUE;
}
}
break;
case HX_PLATFORM_WIN32S:// /XXXEH is Win32s always on Win16??
{
if (0 != strcmp("win16", pOS))
{
bFailed = TRUE;
}
}
break;
case HX_PLATFORM_WIN95:
case HX_PLATFORM_WIN98:
{
if (0 != strcmp("win9x", pOS) &&
0 != strcmp("win32", pOS))
{
bFailed = TRUE;
}
}
break;
case HX_PLATFORM_WINNT:
{
if (0 != strcmp("winnt", pOS) &&
0 != strcmp("win32", pOS))
{
bFailed = TRUE;
}
}
break;
case HX_PLATFORM_SYMBIAN:
{
if (0 != strcmp("symbian", pOS))
{
bFailed = TRUE;
}
}
break;
case HX_PLATFORM_UNKNOWN:
{
if (0 != strcmp("unknown", pOS))
{
bFailed = TRUE;
}
}
break;
default:
{
// /The following SMIL 2.0 systemOperatingSystem values
// are not covered in HXGetWinVer as of 12/2000:
// XXXaix, XXXbeos, bsdi, dgux, freebsd, XXXhpux, ncr,
// nec, netbsd, nextstep, nto, openbsd, openvms,
// os2, XXXosf, palmos, sinix, rhapsody, XXXsco,
// sonly, unixware, wince
#if defined(_AIX)
if (0 != strcmp("aix", pOS))
{
bFailed = TRUE;
}
#elif defined(_BEOS)
if (0 != strcmp("beos", pOS))
{
bFailed = TRUE;
}
#elif defined(_BSDI)
if (0 != strcmp("bsdi", pOS))
{
bFailed = TRUE;
}
// _DARWIN, _CARBON, and/or _MAC_UNIX implies Darwin is present on a Mac:
#elif defined(_DARWIN) || defined(_CARBON) || defined(_MAC_UNIX)
// /Fixes PR 95625 (in case HX_PLATFORM_MAC... is not
// handled, above):
if (0 != strcmp("darwin", pOS))
{
bFailed = TRUE;
}
#elif defined(_FREEBSD) || defined(_FREEBSD2)
if (0 != strcmp("freebsd", pOS))
{
bFailed = TRUE;
}
#elif defined(_HPUX)
if (0 != strcmp("hpux", pOS))
{
bFailed = TRUE;
}
#elif defined(_NETBSD) || defined(__NetBSD__)
if (0 != strcmp("netbsd", pOS))
{
bFailed = TRUE;
}
#elif defined(_OSF1)
if (0 != strcmp("osf", pOS))
{
bFailed = TRUE;
}
#elif defined(_SCO_UW)
if (0 != strcmp("sco", pOS))
{
bFailed = TRUE;
}
#elif defined(_WINCE)
if (0 != strcmp("wince", pOS))
{
bFailed = TRUE;
}
// /SGI is not in the SMIL 2.0 spec, but the spec says we can add more than
// the OSes it recommends:
#elif defined(_SGI)
if (0 != strcmp("sgi", pOS))
{
bFailed = TRUE;
}
#else // /Catch-all for any other OS; throw an error at compile time:
/* Please add to the above list with your OS's define and match it to
one of the following (or add a string if it's not in the following list and
be sure to tell RN documentation folks about it):
"dgux", "ncr", "nec", "nextstep", "nto", "openbsd", "openvms", "os2",
"palmos", "sinix", "rhapsody", "sonly", "unixware"
*/
#endif
}
break;
}
if (bFailed && 0 == strcmp("unknown", pOS))
{
bFailed = FALSE; // /"unknown should play on any OS"
}
doneSysOS:
HX_RELEASE(pBuf);
if(bFailed)
{
goto exit;
}
}
rc = pNode->m_pValues->GetPropertyCString("systemCPU", pBuf);
if(HXR_OK == rc && HX_MACHINE_UNKNOWN!=m_versionInfo.dwMachineType)
{
const char* pCPU = (const char*)pBuf->GetBuffer();
// /First, strip leading whitespace chars:
while (*pCPU && isspace(*pCPU))
{
*pCPU++;
}
/*fixes PR 64428 (UseSystemCPU version)*/
if (!m_bUseSystemCPU)
{
// /Fixes PR 81522 (systemCPU version): if user says not to
// use their CPU info, treat it as unknown per SMIL2 spec:
bFailed = FALSE; // /Setting to FALSE instead of comparing to
// "unknown" fixes CPU part of PR 64428(revisted)
goto doneSysCPU;
}
// /The SMIL 2.0 draft of 12/2000 says:
// "The following list contains the suggested values for this
// test attribute (additional names may be supported by an
// implementation): alpha, arm, arm32, hppa1.1, m68k, mips,
// ppc, rs6000, vax, x86, unknown."
switch (m_versionInfo.dwMachineType)
{
case HX_MACHINE_ALPHA:
{
if (0 != strcmp("alpha", pCPU))
{
bFailed = TRUE;
}
}
break;
case HX_MACHINE_SYMEMULATOR:
case HX_MACHINE_ARM:
{
if (0 != strcmp("arm", pCPU))
{
if (0 != strcmp("arm32", pCPU))
{
bFailed = TRUE;
}
}
}
break;
/* /XXX- these aren't supported in HXGetWinVer():
case :
{
if (0 != strcmp("hppa1.1", pCPU))
{
bFailed = TRUE;
}
}
break;
*/
case HX_MACHINE_68K:
{
if (0 != strcmp("m68k", pCPU))
{
bFailed = TRUE;
}
}
break;
case HX_MACHINE_MIPS:
{
if (0 != strcmp("mips", pCPU))
{
bFailed = TRUE;
}
}
break;
case HX_MACHINE_PPC:
{
if (0 != strcmp("ppc", pCPU))
{
bFailed = TRUE;
}
}
break;
/* /XXX- this isn't supported in HXGetWinVer():
case :
{
if (0 != strcmp("rs6000", pCPU))
{
bFailed = TRUE;
}
}
break;
*/
// /This one is not in the SMIL 2.0 spec; I added it as
// permitted by the spec:
case HX_MACHINE_SPARC:
{
if (0 != strcmp("sparc", pCPU))
{
bFailed = TRUE;
}
}
break;
/* /XXX- this isn't supported in HXGetWinVer():
case :
{
if (0 != strcmp("vax", pCPU))
{
bFailed = TRUE;
}
}
break;
*/
case HX_MACHINE_486:
case HX_MACHINE_586:
case HX_MACHINE_686:
{
if (0 != strcmp("x86", pCPU))
{
bFailed = TRUE;
}
}
break;
default:
{
// /Need to fill in others here and in HXGetWinVer().
}
break;
}
if (bFailed && 0 == strcmp("unknown", pCPU))
{
bFailed = FALSE; // /"unknown should play on any CPU"
}
doneSysCPU:
HX_RELEASE(pBuf);
if(bFailed)
{
goto exit;
}
}
if (m_pActiveNamespaceMap)
{
// look through name spaces for systemComponent name space. If it's there
// append the prefix and look for systemComponent test attribute
CHXMapStringToOb::Iterator ndxBuffer = m_pActiveNamespaceMap->Begin();
for (; ndxBuffer != m_pActiveNamespaceMap->End(); ++ndxBuffer)
{
IHXBuffer* pBuffer = (IHXBuffer*)(*ndxBuffer);
if (strcmp((const char*) SYSTEM_COMPONENT_NAMESPACE, (const char*)pBuffer->GetBuffer()) == 0)
{
const char* pPrefix = (const char*)ndxBuffer.get_key();
// +1 for the : in the namespace and 1 for the
char* pAttrName = new char[strlen(pPrefix) + strlen((const char*) SYSTEM_COMPONENT) + 2];
pAttrName[0] = '';
strcat(pAttrName, pPrefix); /* Flawfinder: ignore */
strcat(pAttrName, ":"); /* Flawfinder: ignore */
strcat(pAttrName, (const char*) SYSTEM_COMPONENT); /* Flawfinder: ignore */
rc = pNode->m_pValues->GetPropertyCString(
pAttrName, pBuf);
HX_VECTOR_DELETE(pAttrName);
if(HXR_OK == rc)
{
bFailed = systemComponentFailed(pBuf);
pBuf->Release();
// If I get in here, I found the right prefix
if (bFailed)
{
goto exit;
}
}
}
}
}
}
exit:
return bFailed;
}
BOOL
CSmilParser::customTestFailed(SMILNode* pNode)
{
BOOL bFailed = FALSE; // /If no "customTest" attribute, we don't fail.
IHXBuffer* pBuf = NULL;
if(pNode->m_pValues)
{
HX_RESULT rc = pNode->m_pValues->GetPropertyCString("customTest",
pBuf);
if(HXR_OK == rc)
{
const char* pCustTestKey = (const char*)pBuf->GetBuffer();
CSmilCustomTest* pCustTest = (CSmilCustomTest*)
((*m_pCustomTestMap)[pCustTestKey]);
if (pCustTest)
{
// /Look for uid in registry; if found and set to 1, then
// we've succeeded, else if found and set to 0, we've failed,
// else if not found and m_defaultState==TRUE, we've succeed,
// else we've failed:
if (pCustTest->m_uid.GetLength())
{
IHXPreferences* pPrefs = 0;
IHXRegistry* pRegistry = NULL;
// /If there is a uid attribute, then we fail unless
// we can find a match in the registry (that's set to
// a number that isn't 0 or a string that isn't a
// case-insensitive version of the "false"):
bFailed = TRUE;
if(HXR_OK == m_pContext->QueryInterface(
IID_IHXPreferences, (void**)&pPrefs))
{
IHXBuffer* pBuf = 0;
CHXString regKey = "customTests\";
regKey += pCustTest->m_uid;
if (HXR_OK == pPrefs->ReadPref(
(const char*)regKey, pBuf))
{
const char* pszBuf =
(const char*)pBuf->GetBuffer();
HX_ASSERT(pszBuf);
if (pszBuf)
{
UINT32 ulPrevNumericalVal =
((UINT32)atol(pszBuf));
if (ulPrevNumericalVal != 0)
{
bFailed = FALSE;
}
// /atol returns 0 if it fails, but
// 0 is a valid value:
else if (0==strcmp("0", pszBuf))
{
bFailed = TRUE;
}
else // /Might be a string like "True":
{
// /Look for any value that is not a
// case-insensitive version of "False":
bFailed = !stricmp("false", pszBuf);
}
}
HX_RELEASE(pBuf);
}
else // /not in registry, so use defaultState:
{
bFailed = !pCustTest->m_bDefaultState;
}
HX_RELEASE(pPrefs);
}
}
else
{
bFailed = !pCustTest->m_bDefaultState;
}
}
HX_RELEASE(pBuf);
}
}
return bFailed;
}
HX_RESULT
CSmilParser::selectSwitchNodes(SMILNode* pSwitchNode)
{
HX_RESULT rc = HXR_OK;
SMILNodeList* pNodeList = pSwitchNode->m_pNodeList;
if(!pNodeList)
{
return rc;
}
SMILNode* pSelectedNode = 0;
CHXSimpleList* pRejectedNodeList = new CHXSimpleList;
CHXSimpleList::Iterator i;
for(i=pNodeList->Begin();i!=pNodeList->End();++i)
{
SMILNode* pNode = (SMILNode*)(*i);
if(!pNode->m_bDelete)
{
if (testAttributeFailed(pNode) ||
customTestFailed(pNode))
{
pRejectedNodeList->AddTail(pNode);
}
else
{
pSelectedNode = pNode;
//[SMIL 1.0 Compliance] Fixes PR 26732:
//Now, update selected node's id to that of the switch so
// that anchors pointing to the switch id will reference
// the node of the switch that was selected. Note that
// we can't fix this the other way around, namely to rename
// all anchors' id strings to that of the selected node
// since not all of them have been parsed/set yet:
HX_ASSERT(pSelectedNode->m_id.GetLength() > 0 &&
pSwitchNode->m_id.GetLength() > 0);
if (pSelectedNode->m_id.GetLength() > 0 &&
pSwitchNode->m_id.GetLength() > 0)
{
pSelectedNode->m_id = pSwitchNode->m_id;
(*m_pIDMap)[(const char*)pSelectedNode->m_id] =
pSelectedNode;
pSwitchNode->m_id = assignID("switch");
(*m_pIDMap)[(const char*)pSwitchNode->m_id] =
pSwitchNode;
}
break;
}
}
}
HX_DELETE(pRejectedNodeList);
// delete non-selected nodes
for(i=pNodeList->Begin();i!=pNodeList->End();++i)
{
SMILNode* pNode = (SMILNode*)(*i);
if(pNode != pSelectedNode)
{
pNode->m_bDelete = TRUE;
}
}
return rc;
}
HX_RESULT
CSmilParser::markTestAttributeNodes(SMILNodeList* pNodeList)
{
HX_RESULT rc = HXR_OK;
if(!pNodeList)
{
return rc;
}
CHXSimpleList::Iterator i;
for(i=pNodeList->Begin();i!=pNodeList->End() && SUCCEEDED(rc);++i)
{
SMILNode* pNode = (SMILNode*)(*i);
rc = addToNamespaceScope(pNode);
if (FAILED(rc))
{
return rc;
}
if(pNode->m_tag == SMILSwitch)
{
selectSwitchNodes(pNode);
}
else
{
if(testAttributeFailed(pNode) ||
customTestFailed(pNode))
{
pNode->m_bDelete = TRUE;
}
}
//Fix for PR 21303: we need to keep drilling down
// through the tree even if we've just called
// selectSwitchNodes() to delete all but one
// child of the switch; the descendants of that
// child may have attributes as well that need
// to be checked:
//(For efficiency, only do the following code if
// the node is not already slated for deletion
// because a deletable node's children will be
// deleted anyway):
if (!pNode->m_bDelete)
{
rc = markTestAttributeNodes(pNode->m_pNodeList);
}
if (SUCCEEDED(rc))
{
rc = removeFromNamespaceScope(pNode);
}
}
return rc;
}
BOOL
CSmilParser::firstDependentChild(SMILNode* pNode)
{
if(getFirstNodeChild(pNode->m_pDependency) == pNode)
{
return TRUE;
}
return FALSE;
}
// /Walk up parent chain until we find an ancestor of the specified tag type:
SMILNode*
CSmilParser::getSpecificAncestor(SMILNodeTag ancestorTag, SMILNode* pNode)
{
SMILNode* pRet = NULL;
while(pNode)
{
pNode = pNode->m_pParent;
if(pNode && (ancestorTag == pNode->m_tag) )
{
pRet = pNode;
break;
}
}
return pRet;
}
SMILNode*
CSmilParser::findActiveChildOfAncestorExcl(SMILNode* pInterruptingNode,
LONG32 lCurTime)
{
SMILNode* pChild = NULL;
// /If we have an ancestor excl, call it X, then we need to
// find the descendant of X that is currently playing (if any):
SMILNode* pClosestExclAncestor = getSpecificAncestor(SMILExcl,
pInterruptingNode);
// /Now, we need to dig down and find an active element at lCurTime:
if (pClosestExclAncestor)
{
pChild = (findAnyActiveDescendant(pClosestExclAncestor,
lCurTime, pInterruptingNode));
}
return pChild;
}
// /This recurses down through tree under pNode to see if there is any media
// element that is playing at lCurTime; if so, returns the first one it finds
SMILNode*
CSmilParser::findAnyActiveDescendant(SMILNode* pNode, LONG32 lCurTime,
SMILNode* pButNotThisNode)
{
SMILNode* pChild = NULL;
// /Now, we need to dig down and find an active element at lCurTime:
if (pNode)
{
pChild = pNode->getFirstChild();
while (pChild)
{
if (pChild->m_bDelete || pChild == pButNotThisNode)
{
pChild = pNode->getNextChild();
continue;
}
else if (isMediaObject(pChild))
{
if (pChild->m_pElement->m_bInsertedIntoTimeline)
{
ULONG32 ulActualStartTime = 0;
ULONG32 ulActualStopTime = 0;
HX_RESULT pnrStart =
pChild->m_pElement->getCurrentScheduledStartTime(
ulActualStartTime);
LONG32 lElementCurBeginTime = (LONG32)ulActualStartTime;
// /Using this function instead of delay+dur fixes
// PR 56760 because dur already has begin-offset-from-
// syncbase in it so we were counting it twice:
HX_RESULT pnrStop =
pChild->m_pElement->getCurrentScheduledStopTime(
ulActualStopTime);
LONG32 lElementCurEndTime = (LONG32)ulActualStopTime;
if (lElementCurBeginTime <= lCurTime &&
lElementCurEndTime > lCurTime)
{
if (!pChild->m_pElement->isPausedInExcl())
{
break; // /Is currently playing; we found one.
}
}
}
}
else
{
SMILNode* pDepthChild =
findAnyActiveDescendant(pChild, lCurTime,
pButNotThisNode);
if (pDepthChild)
{
pChild = pDepthChild; // /We found one.
break;
}
}
pChild = pNode->getNextChild();
}
}
return pChild;
}
SMILNode*
CSmilParser::findLastDeferredChildOfAncestorExcl(
SMILNode* pInterruptingNode, LONG32 lCurTime)
{
SMILNode* pLastDeferred = NULL;
// /If we have an ancestor excl, call it X, then we need to
// find the descendant of X that is currently playing (if any):
SMILNode* pClosestExclAncestor = getSpecificAncestor(SMILExcl,
pInterruptingNode);
// /Now, we need to dig down and find the active or deferred
// element at lCurTime:
if (pClosestExclAncestor)
{
pLastDeferred = (findLastDeferredDescendant(pClosestExclAncestor,
lCurTime, pInterruptingNode, pLastDeferred));
}
return pLastDeferred;
}
SMILNode*
CSmilParser::findLastDeferredDescendant(SMILNode* pNode,
LONG32 lCurTime, SMILNode* pButNotThisNode, SMILNode* pLastDeferredChild)
{
SMILNode* pChild = NULL;
// /Now, we need to dig down and find an active element at lCurTime:
if (pNode)
{
pChild = pNode->getFirstChild();
while (pChild)
{
if (pChild->m_bDelete || pChild == pButNotThisNode)
{
pChild = pNode->getNextChild();
continue;
}
// /Time container, media, or animate|set|...etc. can be deferred:
else if (isTimelineObject(pChild))
{
if (pChild->m_pElement->isDeferredInExcl())
{
if (!pLastDeferredChild)
{
pLastDeferredChild = pChild;
}
else if (pChild->m_pElement->m_ulTimeDeferralOccurred <
pLastDeferredChild->
m_pElement->m_ulTimeDeferralOccurred)
{
pLastDeferredChild = pChild;
}
}
}
else
{
SMILNode* pDepthChild =
findLastDeferredDescendant(pChild, lCurTime,
pButNotThisNode, pLastDeferredChild);
if (pDepthChild)
{
if (!pLastDeferredChild)
{
pLastDeferredChild = pDepthChild;
}
else if (pDepthChild->m_pElement->m_ulTimeDeferralOccurred <
pLastDeferredChild->
m_pElement->m_ulTimeDeferralOccurred)
{
pLastDeferredChild = pDepthChild;
}
}
}
pChild = pNode->getNextChild();
}
}
return pLastDeferredChild;
}
BOOL
CSmilParser::hasAncestor(SMILNodeTag ancestor, SMILNode* pNode)
{
// walk up parent chain until we find a parent of that tag type:
BOOL rc = FALSE;
while(pNode)
{
pNode = pNode->m_pParent;
if(pNode && (ancestor == pNode->m_tag) )
{
rc = TRUE;
break;
}
}
return rc;
}
SMILNodeTag
CSmilParser::getSyncTag(SMILNode* pNode)
{
// walk up parent chain until we either find
// a PAR, a SEQ, or an EXCL
SMILNodeTag tag = SMILSeq; // assume a SEQ
BOOL bIsAnimate = FALSE;
if (pNode->m_tag == SMILAnimate ||
pNode->m_tag == SMILSet ||
pNode->m_tag == SMILAnimateColor ||
pNode->m_tag == SMILAnimateMotion)
{
bIsAnimate = TRUE;
}
while(pNode)
{
pNode = pNode->m_pParent;
if(pNode && pNode->m_tag == SMILPar)
{
// XXXMEH - TODO - we should add the ability
// for media elements to act as time containers
tag = SMILPar;
break;
}
else if(pNode && pNode->m_tag == SMILSeq)
{
tag = SMILSeq;
break;
}
else if(pNode && pNode->m_tag == SMILExcl)
{
tag = SMILExcl;
break;
}
else if (bIsAnimate &&
isMediaObject(pNode))
{
tag = SMILPar;
break;
}
}
return tag;
}
SMILNode*
CSmilParser::getSyncAncestor(SMILNode* pNode)
{
// /Walk up parent chain until we either find
// a PAR, a SEQ, or an EXCL
SMILNode* pReturnNode = NULL;
SMILNode* pAncestorNode = pNode;
while(pAncestorNode)
{
pAncestorNode = pAncestorNode->m_pParent;
if(pAncestorNode &&
(pAncestorNode->m_tag == SMILPar ||
pAncestorNode->m_tag == SMILExcl ||
pAncestorNode->m_tag == SMILSeq))
{
pReturnNode = pAncestorNode;
break;
}
// /Media elements can act as time containers for area/anchor and for
// animateXYZ and set elements:
else if (isMediaObject(pAncestorNode)
&& (SMILArea == pNode->m_tag ||
SMILAnchor == pNode->m_tag ||
SMILAnimate == pNode->m_tag ||
SMILSet == pNode->m_tag ||
SMILAnimateColor == pNode->m_tag ||
SMILAnimateMotion == pNode->m_tag)
)
{
pReturnNode = pAncestorNode;
break;
}
}
return pReturnNode;
}
// /Returns in ulSyncBaseTime the begin time of the sync base unless the
// sync base is a prior sibling in a seq, in which case it returns that
// node's element's end time. If ulSyncBaseTime can't be obtained,
// (UINT32)-1 is returned:
ULONG32
CSmilParser::getSyncBaseTimeInGroupTimeCoords(SMILNode* pNode)
{
SMILNode* pSyncBaseNode = NULL;
SMILNode* pSyncAncestorNode = NULL;
ULONG32 ulSyncBaseTime = (UINT32)-1;
if (pNode)
{
pSyncAncestorNode = getSyncAncestor(pNode);
}
if (pNode->m_pElement && pNode->m_pElement->m_pTimelineElement &&
pSyncAncestorNode && pSyncAncestorNode->m_pElement)
{
CSmilElement* pSyncBaseElement = pSyncAncestorNode->m_pElement;
if (pSyncAncestorNode && SMILSeq == pSyncAncestorNode->m_tag)
{
CHXSimpleList* pSyncAncestorChildList = NULL;
// /SyncBase of seq child is end of prior sibling, not parent's
// begin, unless no prior sibling exists:
if (pSyncBaseElement->m_pTimelineElement && NULL !=
(pSyncAncestorChildList =
pSyncBaseElement->m_pTimelineElement->getChildren()) )
{
CHXSimpleList::Iterator i = pSyncAncestorChildList->Begin();
CSmilTimelineElement* pPrevTimelineElement = NULL;
for(; i != pSyncAncestorChildList->End(); ++i)
{
CSmilTimelineElement* pTimelineElement =
(CSmilTimelineElement*)(*i);
if (pTimelineElement ==
pNode->m_pElement->m_pTimelineElement)
{
// /Found prev timed sibling (or it is NULL):
if (pPrevTimelineElement)
{
pSyncBaseElement =
pPrevTimelineElement->getSourceElement();
HX_ASSERT(pSyncBaseElement);
}
else
{
pSyncBaseElement = pSyncAncestorNode->m_pElement;
}
break;
}
pPrevTimelineElement = pTimelineElement;
}
}
// /If pNode is a timeline element, its sync ancestor should at
// least have pNode's timeline element in its child list:
HX_ASSERT(pSyncAncestorChildList);
}
if (pSyncBaseElement)
{
HX_RESULT pnrStart = HXR_OK;
// /If syncBaseElement is actually the parent seq, then use its
// begin time, not its end time, as the sync base:
if (pSyncBaseElement == pSyncAncestorNode->m_pElement)
{
pnrStart = pSyncBaseElement->getCurrentScheduledStartTime(
ulSyncBaseTime);
}
else // /Use end of prior seq sibling as sync base:
{
pnrStart = pSyncBaseElement->getCurrentScheduledStopTime(
ulSyncBaseTime);
}
}
else
{
ulSyncBaseTime = (UINT32)-1;
}
}
return(ulSyncBaseTime);
}
BOOL
CSmilParser::inSeq(SMILNode* pNode)
{
SMILNodeTag tag = getSyncTag(pNode);
return tag == SMILSeq;
}
HX_RESULT CSmilParser::createHeadElements(SMILNodeList* pNodeList)
{
HX_RESULT retVal = HXR_OK;
if (pNodeList)
{
LISTPOSITION pos = pNodeList->GetHeadPosition();
while (pos && SUCCEEDED(retVal))
{
SMILNode* pNode = (SMILNode*) pNodeList->GetAt(pos);
if (pNode && !pNode->m_bDelete)
{
retVal = addToNamespaceScope(pNode);
if (SUCCEEDED(retVal))
{
// Get the tag of the parent
SMILNodeTag eParentTag = SMILUnknown;
if (pNode->m_pParent)
{
eParentTag = pNode->m_pParent->m_tag;
}
// /XXXEH- TODO: do what makeTransition() and
// makeCustomTest() do, below, and use their actual
// failed retVals rather than just HXR_FAIL if anything
// goes wrong:
// Init the return value to failure
retVal = HXR_FAIL;
// Switch based on tag type
switch(pNode->m_tag)
{
case SMILRegion:
{
if (eParentTag == SMILBasicLayout ||
eParentTag == SMILRegion ||
eParentTag == SMILViewport)
{
CSmilRegion* pRegion = makeRegion(pNode);
if(pRegion)
{
pNode->m_pElement = pRegion;
pRegion->m_ulDelay = 0;
pRegion->m_ulTimestamp = INITIAL_STREAM0_TIMESTAMP;
insertElementByTimestamp(pRegion);
retVal = HXR_OK;
}
}
}
break;
case SMILTransition:
{
#if defined(HELIX_FEATURE_SMIL2_TRANSITIONS)
if (eParentTag == SMILHead)
{
CSmilTransition* pTrans = makeTransition(pNode, retVal);
if (pTrans && SUCCEEDED(retVal))
{
pNode->m_pElement = pTrans;
pTrans->m_ulDelay = 0;
pTrans->m_ulTimestamp = INITIAL_STREAM0_TIMESTAMP;
insertElementByTimestamp(pTrans);
}
}
#else
pNode->m_bDelete = TRUE;
retVal = HXR_OK;
#endif /* #if defined(HELIX_FEATURE_SMIL2_TRANSITIONS) */
}
break;
case SMILMeta:
{
if (eParentTag == SMILHead)
{
CSmilMeta* pMeta = makeMeta(pNode);
if(pMeta)
{
pNode->m_pElement = pMeta;
pMeta->m_ulDelay = 0;
pMeta->m_ulTimestamp = INITIAL_STREAM0_TIMESTAMP;
insertElementByTimestamp(pMeta);
retVal = HXR_OK;
}
}
}
break;
case SMILMetadata:
{
if (eParentTag == SMILHead)
{
CSmilMetadata* pMetadata=makeMetadata(pNode);
if(pMetadata)
{
pNode->m_pElement = pMetadata;
pMetadata->m_ulDelay = 0;
pMetadata->m_ulTimestamp =
INITIAL_STREAM0_TIMESTAMP;
insertElementByTimestamp(pMetadata);
retVal = HXR_OK;
}
}
}
break;
case SMILRendererPreFetch:
{
if (eParentTag == SMILRNRendererList)
{
CSmilRendererPreFetch* pRenderer =
makeRendererPreFetch(pNode);
pNode->m_pElement = pRenderer;
pRenderer->m_ulDelay = 0;
pRenderer->m_ulTimestamp = INITIAL_STREAM0_TIMESTAMP;
insertElementByTimestamp(pRenderer);
retVal = HXR_OK;
}
}
break;
case SMILRootLayout:
{
if (eParentTag == SMILBasicLayout)
{
CSmilRootLayout* pRoot = makeRootLayout(pNode);
if(pRoot)
{
pNode->m_pElement = pRoot;
pRoot->m_ulDelay = 0;
pRoot->m_ulTimestamp = INITIAL_STREAM0_TIMESTAMP;
insertElementByTimestamp(pRoot);
retVal = HXR_OK;
}
}
}
break;
case SMILRegPoint:
{
if (eParentTag == SMILBasicLayout)
{
CSmilRegPoint* pRegPt = makeRegPoint(pNode);
if(pRegPt)
{
pNode->m_pElement = pRegPt;
pRegPt->m_ulDelay = 0;
pRegPt->m_ulTimestamp = INITIAL_STREAM0_TIMESTAMP;
insertElementByTimestamp(pRegPt);
retVal = HXR_OK;
}
}
}
break;
case SMILViewport:
{
#if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT)
if (eParentTag == SMILBasicLayout)
{
CSmilViewport* pView = makeViewport(pNode);
if(pView)
{
pNode->m_pElement = pView;
pView->m_ulDelay = 0;
pView->m_ulTimestamp = INITIAL_STREAM0_TIMESTAMP;
insertElementByTimestamp(pView);
retVal = HXR_OK;
}
}
#else
// topLayout is not supported, so we
// delete the node
pNode->m_bDelete = TRUE;
// Clear the return value
retVal = HXR_OK;
#endif /* #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT) */
}
break;
case SMILBasicLayout:
{
retVal = HXR_OK;
}
break;
case SMILCustomTest:
{
if (eParentTag == SMILCustomAttributes)
{
CSmilCustomTest* pCustomTest =
makeCustomTest(pNode, retVal);
if (pCustomTest && SUCCEEDED(retVal))
{
pNode->m_pElement = pCustomTest;
pCustomTest->m_ulDelay = 0;
pCustomTest->m_ulTimestamp =
INITIAL_STREAM0_TIMESTAMP;
insertElementByTimestamp(pCustomTest);
retVal = HXR_OK;
if(!m_pCustomTestMap)
{
m_pCustomTestMap =
new CHXMapStringToOb;
}
if (m_pCustomTestMap)
{
(*m_pCustomTestMap)[pNode->m_id] =
pCustomTest;
}
else
{
retVal = HXR_OUTOFMEMORY;
}
}
}
}
break;
case SMILUnknown:
{
// If this is a </layout>, then we
// generate a close layout if we
// have had any regions
if (pNode->m_id == "CLOSE-layout")
{
CSmilEndLayout* pEndLayout = new CSmilEndLayout();
if (pEndLayout)
{
pNode->m_pElement = pEndLayout;
pEndLayout->m_ulDelay = 0;
pEndLayout->m_ulTimestamp = INITIAL_STREAM0_TIMESTAMP;
insertElementByTimestamp(pEndLayout);
retVal = HXR_OK;
}
}
else
{
// Clear the return value
retVal = HXR_OK;
}
}
break;
default:
retVal = HXR_OK;
}
// Now examine the children
if (SUCCEEDED(retVal))
{
retVal = createHeadElements(pNode->m_pNodeList);
if (SUCCEEDED(retVal))
{
retVal = removeFromNamespaceScope(pNode);
}
}
}
}
// Advance to the next node
if (SUCCEEDED(retVal))
{
pNodeList->GetNext(pos);
}
}
}
return retVal;
}
HX_RESULT
CSmilParser::setInitialDelays(SMILNodeList* pNodeList)
{
HX_RESULT rc = HXR_OK;
UINT16 nGroup = (UINT16)-1;
if(!pNodeList)
{
return rc;
}
CHXSimpleList::Iterator i = pNodeList->Begin();
for(;i!=pNodeList->End();++i)
{
if(HXR_OK != rc)
{
return rc;
}
SMILNode* pNode = (SMILNode*)(*i);
if(pNode->m_bDelete) // skip this puppy
{
continue;
}
else if(pNode->m_tag == SMILAAnchor ||
pNode->m_tag == SMILPriorityClass ||
pNode->m_tag == SMILSwitch)
{
pNode = getTimelineDescendent(pNode);
if(!pNode)
{
continue;
}
}
setInitialDelay(pNode);
switch(pNode->m_tag)
{
case SMILSeq:
{
setInitialDelayOnSeq(pNode);
}
break;
case SMILExcl:
{
HX_ASSERT(0 && "Excl can't be outer time container");
}
// /fall on through to SMILPar code:
case SMILPar:
{
SMILNode* pThisNode =
getTimelineDescendent(pNode, NULL);
while(pThisNode)
{
setInitialDelay(pThisNode);
pThisNode =
getTimelineDescendent(pNode, pThisNode);
}
}
break;
}
}
return rc;
}
void
CSmilParser::setInitialDelay(SMILNode* pNode)
{
if(pNode->m_pElement &&
pNode->m_pElement->m_pTimelineElement &&
!pNode->m_pElement->m_pTimelineElement->initialDelaySet())
{
ULONG32 ulInitialDelay = 0;
// /This fixes default begin of excl children (which is not 0 but
// rather indefinite):
if (pNode->m_pElement->m_bBeginOffsetSet ||
!hasAncestor(SMILExcl, pNode))
{
// HP m_ulPersistentComponentDelay is 0 except in nested meta
pNode->m_pElement->m_pTimelineElement->setDelay(m_ulPersistentComponentDelay, FALSE);
}
}
if(pNode->m_pNodeList)
{
if(pNode->m_tag == SMILSeq ||
pNode->m_tag == SMILExcl ||
pNode->m_tag == SMILPar)
{
if(pNode->m_pElement &&
pNode->m_pElement->m_pTimelineElement &&
pNode->m_pElement->m_ulDuration != (UINT32)-1)
{
pNode->m_pElement->m_pTimelineElement->setDuration(
pNode->m_pElement->m_ulDuration);
}
}
if(pNode->m_tag == SMILSeq)
{
setInitialDelayOnSeq(pNode);
}
//If the element doesn't exist or it does but the timelineElement
// doesn't exist, or it does but there is no delay event, or there is
// one but the delay is already set, then it's ok to set call
// setInitialDelay():
else if ((!pNode->m_pElement ||
!pNode->m_pElement->m_pTimelineElement) ||
//[SMIL 1.0 Compliance] Helps fix PR 14420:
//Don't call this if pNode has an unresolved delay event:
(!pNode->m_pElement->m_pTimelineElement->delayEvent() ||
pNode->m_pElement->m_pTimelineElement->initialDelaySet() ) )
{
SMILNode* pThisNode =
getTimelineDescendent(pNode, NULL);
while(pThisNode)
{
setInitialDelay(pThisNode);
pThisNode = getTimelineDescendent(pNode, pThisNode);
}
}
}
}
void
CSmilParser::setInitialDelayOnSeq(SMILNode* pNode)
{
UINT16 nGroup = (UINT16)-1;
SMILNode* pThisNode = getTimelineDescendent(pNode, NULL);
while(pThisNode)
{
if(pThisNode->m_nGroup != nGroup)
{
nGroup = pThisNode->m_nGroup;
setInitialDelay(pThisNode);
}
pThisNode = getTimelineDescendent(pNode, pThisNode);
}
}
HX_RESULT
CSmilParser::assignGroupIndexes(SMILNodeList* pNodeList)
{
HX_RESULT rc = HXR_OK;
if(!pNodeList)
{
return rc;
}
UINT16 nGroup = 0;
UINT16 nNum = 0;
CHXSimpleList::Iterator i = pNodeList->Begin();
for(; i != pNodeList->End(); ++i)
{
if(HXR_OK != rc)
{
return rc;
}
SMILNode* pNode = (SMILNode*)(*i);
if(pNode->m_bDelete) // skip this puppy
{
continue;
}
else if(pNode->m_tag == SMILAAnchor ||
pNode->m_tag == SMILSwitch)
{
pNode = getTimelineDescendent(pNode);
if(!pNode)
{
continue;
}
}
switch(pNode->m_tag)
{
case SMILSeq:
{
SMILNode* pThisNode =
getTimelineDescendent(pNode, NULL);
while(pThisNode)
{
rc = assignGroupIndexOnSeq(pThisNode, nGroup);
if(HXR_OK == rc)
{
pThisNode =
getTimelineDescendent(pNode, pThisNode);
nGroup++;
}
else
{
break;
}
}
}
break;
case SMILExcl:
case SMILPar:
{
// top-level par, each child has group 0
SMILNode* pThisNode =
getTimelineDescendent(pNode, NULL);
while(pThisNode)
{
rc = assignGroupIndexOnPar(pThisNode, nGroup);
if(HXR_OK == rc)
{
pThisNode =
getTimelineDescendent(pNode, pThisNode);
}
else
{
break;
}
}
}
break;
default:
break;
}
}
// Assign the number of groups
m_usNumGroups = nGroup;
return rc;
}
HX_RESULT
CSmilParser::assignGroupIndexOnPar(SMILNode* pNode,
UINT16 nGroup)
{
HX_RESULT rc = HXR_OK;
if(pNode->m_bDelete)
{
return rc;
}
pNode->m_nGroup = nGroup;
pNode->m_repeatid.AppendULONG(nGroup);
// /Added check for isNonMediaPlayableObject since animate objects, for
// instance, can exist in a group without any media siblings, and we
// want them to be able to "play" (e.g., animate a region attribute):
if ((isMediaObject(pNode) || isNonMediaPlayableObject(pNode))
&& !pNode->m_bDelete)
{
// /XXXEH- NOT SURE YET HOW TO HANDLE THIS; we should also assign
// entire tree underneath this if it has children since they will
// be in same player (except the ones that explicitly declare that
// they are independent):
// /Don't do this if sync behavior is "independent":
if (SmilSyncBehaviorIndependent != pNode->m_pElement->m_syncBehavior)
{
addGroup(pNode);
// XXXMEH - we also have to look at
// children of media objects, and assign
// their group indices as well.
SMILNode* pThisNode = getTimelineDescendent(pNode, NULL);
UINT16 nNum = 0;
while(pThisNode)
{
rc = assignGroupIndexOnPar(pThisNode, nGroup);
pThisNode->m_num = nNum++;
if(HXR_OK == rc)
{
pThisNode =
getTimelineDescendent(pNode, pThisNode);
}
else
{
break;
}
}
}
else
{
// /XXXEH- handle independent and canSlip player groups here:
HX_ASSERT(0 && "ehodge: handle addGroup for indep player");
}
}
else if (SMILSeq == pNode->m_tag ||
SMILExcl == pNode->m_tag ||
SMILPar == pNode->m_tag)
{
// top-level par, each child has group 0
SMILNode* pThisNode =
getTimelineDescendent(pNode, NULL);
UINT16 nNum = 0;
while(pThisNode)
{
rc = assignGroupIndexOnPar(pThisNode, nGroup);
pThisNode->m_num = nNum++;
if(HXR_OK == rc)
{
pThisNode =
getTimelineDescendent(pNode, pThisNode);
}
else
{
break;
}
}
}
return rc;
}
HX_RESULT
CSmilParser::assignGroupIndexOnSeq(SMILNode* pNode,
UINT16& nGroup)
{
HX_RESULT rc = HXR_OK;
if(pNode->m_bDelete)
{
return rc;
}
pNode->m_nGroup = nGroup;
pNode->m_repeatid.AppendULONG(nGroup);
// /Added check for isNonMediaPlayableObject since animate objects, for
// instance, can exist in a group without any media siblings, and we
// want them to be able to "play" (e.g., animate a region attribute):
if ((isMediaObject(pNode) || isNonMediaPlayableObject(pNode))
&& !pNode->m_bDelete)
{
addGroup(pNode);
// XXXMEH - we also need to look at
// children of media elements and assign
// their group indices as well. Treat time
// containers like <par>'s.
SMILNode* pThisNode = getTimelineDescendent(pNode, NULL);
while(pThisNode)
{
rc = assignGroupIndexOnPar(pThisNode, nGroup);
if(HXR_OK == rc)
{
pThisNode = getTimelineDescendent(pNode, pThisNode);
}
else
{
break;
}
}
}
else if (SMILSeq == pNode->m_tag)
{
SMILNode* pThisNode =
getTimelineDescendent(pNode, NULL);
while(pThisNode)
{
rc = assignGroupIndexOnSeq(pThisNode, nGroup);
if(HXR_OK == rc)
{
pThisNode = getTimelineDescendent(pNode, pThisNode);
if (pThisNode)
{
if (!pThisNode->m_bDelete &&
(isMediaObject(pThisNode) ||
isTimeContainerObject(pThisNode)) &&
// /Fixes PR 54268: if pNode isn't the outer wrapper seq
// (in a file where the body has multiple children so
// we'll play it as a clip list) then we don't want to
// put each of pNode's children into a separate group:
pNode->m_bIsOuterWrapperTimeContainer)
{
nGroup++;
}
}
}
else
{
break;
}
}
}
else if (SMILPar == pNode->m_tag || SMILExcl == pNode->m_tag)
{
SMILNode* pThisNode =
getTimelineDescendent(pNode, NULL);
while(pThisNode)
{
rc = assignGroupIndexOnPar(pThisNode, nGroup);
if(HXR_OK == rc)
{
pThisNode =
getTimelineDescendent(pNode, pThisNode);
}
else
{
break;
}
}
}
return rc;
}
BOOL
CSmilParser::isTimelineObject(SMILNode* pNode)
{
BOOL bResult = isMediaObject(pNode) ||
isTimeContainerObject(pNode);
if (!bResult)
{
switch (pNode->m_tag)
{
case SMILTransition:
case SMILAnimate:
case SMILAnimateMotion:
case SMILAnimateColor:
{
bResult = TRUE;
}
break;
default:
break;
}
}
return bResult;
}
BOOL
CSmilParser::isMediaObject(SMILNode* pNode)
{
BOOL bResult = FALSE;
if (NULL == pNode)
{
goto cleanup;
}
switch(pNode->m_tag)
{
case SMILRef:
case SMILText:
case SMILImg:
case SMILAudio:
case SMILVideo:
case SMILAnimation:
case SMILTextstream:
case SMILBrush:
case SMILPrefetch:
{
bResult = TRUE;
}
break;
default:
break;
}
cleanup:
return bResult;
}
// /This is for handling cases where only animate... element(s) are inside
// the first child of the body element and we want a group to be created so
// a timeline longer than zero will play. This is usefull if you want to
// have some regions (that get altered over time) be the entire presentation:
BOOL
CSmilParser::isNonMediaPlayableObject(SMILNode* pNode)
{
BOOL bResult = FALSE;
if (NULL == pNode)
{
goto cleanup;
}
switch(pNode->m_tag)
{
case SMILAnimate:
case SMILAnimateColor:
case SMILAnimateMotion:
{
bResult = TRUE;
}
break;
default:
break;
}
cleanup:
return bResult;
}
BOOL
CSmilParser::isTimeContainerObject(SMILNode* pNode)
{
BOOL bResult = FALSE;
if (NULL == pNode)
{
goto cleanup;
}
switch(pNode->m_tag)
{
case SMILSeq:
case SMILExcl:
case SMILPar:
{
bResult = TRUE;
}
break;
default:
break;
}
cleanup:
return bResult;
}
BOOL
CSmilParser::isEndTagObject(SMILNode* pNode)
{
BOOL bResult = FALSE;
if (NULL == pNode)
{
goto cleanup;
}
switch(pNode->m_tag)
{
case SMILEndSeq:
case SMILEndExcl:
case SMILEndPar:
case SMILEndAAnchor:
case SMILEndPriorityClass:
{
bResult = TRUE;
}
break;
default:
break;
}
cleanup:
return bResult;
}
HX_RESULT
CSmilParser::addGroup(SMILNode* pNode)
{
HX_RESULT rc = HXR_OK;
if (pNode &&
(pNode->m_tag != SMILAnimate &&
pNode->m_tag != SMILAnimateMotion &&
pNode->m_tag != SMILSet &&
pNode->m_tag != SMILAnimateColor))
{
// set group info information
CSmilAddGroup* pAddGroup = 0;
if(m_pAddGroupMap->Lookup(pNode->m_nGroup, (void*&)pAddGroup))
{
// we don't count self-replicated elements as they
// share the same track ID
if (pNode->m_repeatTag == RepeatUnknown)
{
pAddGroup->m_nTotalTracks++;
if(pNode->m_pElement &&
pNode->m_pElement->m_ulDelay == 0)
{
pAddGroup->m_nInitTracks++;
}
}
}
else
{
CSmilAddGroup* pAddGroup = new CSmilAddGroup;
pAddGroup->m_nGroup = pNode->m_nGroup;
// reference PAR or EXCL properties in group
if(pNode->m_pDependency &&
(pNode->m_pDependency->m_tag == SMILPar ||
pNode->m_pDependency->m_tag == SMILExcl) &&
// /See if it has a par and/or excl ancestor:
(hasAncestor(SMILPar, pNode) ||
hasAncestor(SMILExcl, pNode)) )
{
SMILNode* pDepNode = pNode->m_pDependency;
#if defined(DONT_ALLOW_PLAYLIST_STYLE_SEQ_IF_EXPLICIT_OUTER_TIMECONTAINER)
// /Fixes case 1 of PR 56364: clip-list file's first
// clip's explicit dur was being used for 2nd clip's dur
// (since, in that case, the m_pDependency node is not a
// parent but rather a prior sibling in a seq):
if (!m_bAllowPlaylistBehavior)
{
// /The following fixes par-in-seq version of PR 50715 and 50724:
// (fix Interop Timing #9.5 &#9.+{7,11,22,24,27,29,33,34,41,42},
// some of which are fixed for seq-in-seq, further down.)
// e.g.,
// <body>
// <seq>
// <par dur="10s">
// <ref src="...">
// </par>
// <ref dur="4s">
// </seq>
// </body>
// Used to end at 10s (second clip didn't play) but now we take
//.into account the fact that pNode's parent may not contain
// the entire group's sources:
// /Step up through ancestors until you hit body or smil, then
// back down one and use that element's explicit dur, if any:
// We need to make sure that we're not a child of a group that
// has other children:
SMILNode* pNextDepNode = (pDepNode?
pDepNode->m_pDependency : NULL);
while (pDepNode->m_pDependency &&
!(pNextDepNode->m_tag == SMILBody ||
(pNextDepNode->m_tag == SMILSeq &&
pNextDepNode->m_id == "body") ||
pNextDepNode->m_bIsOuterWrapperTimeContainer) )
{
pDepNode = pNextDepNode;
pNextDepNode = (pDepNode?
pDepNode->m_pDependency : NULL);
}
}
HX_ASSERT(pDepNode);
#endif
IHXValues* pValues = pDepNode->m_pValues;
if(pValues)
{
pAddGroup->m_pValues = pValues;
pAddGroup->m_pValues->AddRef();
}
// /Once core is fixed so that group duration can be changed on
// the fly, we'll just always set the group dur to unresolved,
// and let resolveGroupDurToOuterTimeContainerDur() take care of
// setting the overall duration. I tested this with over 200
// files and they all worked as expected:
#define PR79703_WORK_AROUND
#if defined(PR79703_WORK_AROUND)
// /"Fixes" PR 79703 (until group dur can be changed in core):
pAddGroup->m_ulDuration = 0xFFFFFFFF;
#else
pAddGroup->m_ulDuration = pDepNode->m_pElement->m_ulDuration;
#endif
// XXX HP remove the following if when XXXEH fix the same for
// body duration
if (m_ulPersistentComponentDuration)
{
pAddGroup->m_ulDuration = m_ulPersistentComponentDuration;
}
// /Fixes PR 52452: <body><par begin="5s" end="30s">...
// was playing as 25s presentation instead of 30s (even
// though video would play beyond that for 5s):
if (pDepNode->m_pElement->m_bCurBeginIsOffsetFromSyncBase &&
(UINT32)-1 != pAddGroup->m_ulDuration)
{
pAddGroup->m_ulDuration +=
pDepNode->m_pElement->m_ulBeginOffsetFromSyncBase;
}
}
// XXXJHUG -- If the group is from a Seq, we still want
// to pass along the Title, author, copyright & abstract from
// the dependant parrent sequence group.
if (pNode->m_pDependency &&
pNode->m_pDependency->m_tag == SMILSeq)
{
// the duration of a sequence is dependent on the elements
// within the sequence.
// ...Ah, but not always; if there is an explicit dur or end for the
// seq, then we want to use that dur. The rest of this code in this
// block was added to account for this, fixing many SMIL2 Timing
// interop bugs including #9.38 "fill_freeze_with_repeat.smil":
// /Step up through ancestors until you hit body element or an
// outer seq or par wrapping time container (if there is one);
// Then, back down one and use that element's explicit dur, if
// any: We need to make sure that we're not a child of a group
// that has other children:
SMILNode* pDepNode = pNode->m_pDependency;
#if defined(DONT_ALLOW_PLAYLIST_STYLE_SEQ_IF_EXPLICIT_OUTER_TIMECONTAINER)
// /The following fixes seq-in-seq version of PR 50715 and 50724:
// (fix Interop Timing #9.5 &#9.+{7,11,22,24,27,29,33,34,41,42},
// some of which are fixed for seq-in-seq, further down.)
SMILNode* pNextDepNode = pDepNode?
pDepNode->m_pDependency : NULL;
while (pDepNode->m_pDependency &&
!(pNextDepNode->m_tag == SMILBody ||
(pNextDepNode->m_tag == SMILSeq &&
pNextDepNode->m_id == "body") ||
pNextDepNode->m_bIsOuterWrapperTimeContainer) )
{
// /Fixes problem in: <body><media /><seq>...</seq></body>
// where seq was getting dur of media as dependent (which
// it's not because it's in a prior group):
if (pNode->m_nGroup != pNextDepNode->m_nGroup)
{
break;
}
pDepNode = pNextDepNode;
pNextDepNode = pDepNode?
pDepNode->m_pDependency : NULL;
}
HX_ASSERT(pDepNode);
#endif
IHXValues* pValues = pDepNode->m_pValues;
if(pValues)
{
pAddGroup->m_pValues = pValues;
pAddGroup->m_pValues->AddRef();
// XXXJH should use CCF
pAddGroup->m_pValues = new CHXHeader();
IHXBuffer* pBuf = NULL;
const char* name = NULL;
pAddGroup->m_pValues->AddRef();
if (SUCCEEDED(pValues->GetFirstPropertyCString(name, pBuf)))
{
do
{
if (strcmp("title",name)==0 ||
strcmp("author",name)==0 ||
strcmp("abstract",name)==0 ||
strcmp("copyright",name)==0)
{
pAddGroup->m_pValues->SetPropertyCString(name, pBuf);
}
HX_RELEASE(pBuf);
}
while(SUCCEEDED(pValues->GetNextPropertyCString(name, pBuf)));
}
}
pAddGroup->m_ulDuration = pDepNode->m_pElement->m_ulDuration;
// /Fixes outer-seq bug related to PR 52452:
// <body><seq begin="5s" end="30s"><vid ...
// was playing as 25s presentation instead of 30s (even
// though video would play beyond that for 5s):
if (pDepNode->m_pElement->m_bCurBeginIsOffsetFromSyncBase &&
(UINT32)-1 != pAddGroup->m_ulDuration)
{
pAddGroup->m_ulDuration +=
pDepNode->m_pElement->m_ulBeginOffsetFromSyncBase;
}
#if !defined(DONT_ALLOW_PLAYLIST_STYLE_SEQ_IF_EXPLICIT_OUTER_TIMECONTAINER)
// /And, if a virtual wrapper seq was created in
// expandRepeatElements(), then we want to use our parent's dur:
if (pNode->m_pDependency->m_bIsSeqWrapperForRepeatElement)
{
// /Get sync ancestor, not just parent in case parent is an
// <a>, <switch>, ...etc. that shouldn't impose timing
// constraints on its children:
SMILNode* pSyncAncestor =
getSyncAncestor(pNode->m_pDependency);
if (pSyncAncestor && pSyncAncestor->m_pElement)
{
pAddGroup->m_ulDuration =
pSyncAncestor->m_pElement->m_ulDuration;
}
}
#endif
}
(*m_pAddGroupMap)[pNode->m_nGroup] = pAddGroup;
pAddGroup->m_nTotalTracks = 1;
if(pNode->m_pElement &&
pNode->m_pElement->m_ulDelay == 0)
{
pAddGroup->m_nInitTracks = 1;
}
}
}
return rc;
}
HX_RESULT
CSmilParser::createBodyElements(SMILNodeList* pNodeList)
{
HX_RESULT rc = HXR_OK;
if(!pNodeList)
{
return rc;
}
if(!m_pNodeDependencies)
{
m_pNodeDependencies = new CHXStack;
}
if(!m_pAnchorStack)
{
m_pAnchorStack = new CHXStack;
}
if(!m_pTrackHintList)
{
m_pTrackHintList = new CHXSimpleList;
}
UINT32 ulTrackHint = 1;
CHXSimpleList::Iterator i;
for(i=pNodeList->Begin();i!=pNodeList->End();++i)
{
if(HXR_OK != rc)
{
return rc;
}
SMILNode* pNode = (SMILNode*)(*i);
if(pNode->m_bDelete) // skip this puppy
{
continue;
}
rc = addToNamespaceScope(pNode);
if (FAILED(rc))
{
return rc;
}
switch(pNode->m_tag)
{
case SMILSeq:
{
CSmilSeqElement* pElement = makeSeqElement(pNode);
if(!pElement)
{
return HXR_FAIL;
}
pNode->m_pElement = pElement;
CSmilTimelineSeq* pTimelineSeq =
new CSmilTimelineSeq(pElement, this);
pElement->m_pTimelineElement = pTimelineSeq;
// Check if this element depends on an external media
// marker file. If so, then add it to a list to be
// processed later
checkForXMMFDependency(pElement);
if(!m_pCurrentDependentNode) // at the top
{
//pNode->m_nGroup = (UINT16)-1; // top level
}
else
{
pNode->m_pDependency = m_pCurrentDependentNode;
if(!hasAncestor(SMILPar, pNode) &&
!hasAncestor(SMILExcl, pNode))
{
//pNode->m_nGroup =
// m_pCurrentDependentNode->m_nGroup + 1;
}
else
{
//pNode->m_nGroup =
// m_pCurrentDependentNode->m_nGroup;
}
}
m_pCurrentDependentNode = pNode;
m_pNodeDependencies->Push(m_pCurrentDependentNode);
ulTrackHint = 1;
m_pTrackHintList->AddTail((void*)ulTrackHint);
}
break;
case SMILPar:
{
CSmilParElement* pElement = makeParElement(pNode);
if(!pElement)
{
return HXR_FAIL;
}
pNode->m_pElement = pElement;
CSmilTimelinePar* pTimelinePar =
new CSmilTimelinePar(pElement, this);
pElement->m_pTimelineElement = pTimelinePar;
// Check if this element depends on an external media
// marker file. If so, then add it to a list to be
// processed later
checkForXMMFDependency(pElement);
if(!m_pCurrentDependentNode) // at the top
{
// pNode->m_nGroup = 0;
}
else
{
pNode->m_pDependency = m_pCurrentDependentNode;
if(!hasAncestor(SMILPar, pNode) &&
!hasAncestor(SMILExcl, pNode))
{
//pNode->m_nGroup =
// m_pCurrentDependentNode->m_nGroup + 1;
}
else
{
//pNode->m_nGroup = m_pCurrentDependentNode->m_nGroup;
}
}
if(firstDependentChild(pNode) || m_pCurrentDependentNode == 0)
{
ulTrackHint = 1;
m_pTrackHintList->AddTail((void*)ulTrackHint);
}
else
{
if(m_pTrackHintList->GetCount() > 0)
{
ulTrackHint = (UINT32)m_pTrackHintList->RemoveTail();
}
m_pTrackHintList->AddTail((void*)++ulTrackHint);
}
m_pCurrentDependentNode = pNode;
m_pNodeDependencies->Push(m_pCurrentDependentNode);
}
break;
case SMILExcl:
{
CSmilExclElement* pElement = makeExclElement(pNode);
if(!pElement)
{
return HXR_FAIL;
}
pNode->m_pElement = pElement;
CSmilTimelineExcl* pTimelineExcl =
new CSmilTimelineExcl(pElement, this);
pElement->m_pTimelineElement = pTimelineExcl;
// Check if this element depends on an external media
// marker file. If so, then add it to a list to be
// processed later
checkForXMMFDependency(pElement);
if(!m_pCurrentDependentNode) // at the top
{
// pNode->m_nGroup = 0;
}
else
{
pNode->m_pDependency = m_pCurrentDependentNode;
if(!hasAncestor(SMILPar, pNode) &&
!hasAncestor(SMILExcl, pNode))
{
//pNode->m_nGroup =
// m_pCurrentDependentNode->m_nGroup + 1;
}
else
{
//pNode->m_nGroup = m_pCurrentDependentNode->m_nGroup;
}
}
// /XXXEH- should we do this for SMILExcl (as for SMILPar)?:
if(firstDependentChild(pNode) || m_pCurrentDependentNode == 0)
{
ulTrackHint = 1;
m_pTrackHintList->AddTail((void*)ulTrackHint);
}
else
{
if(m_pTrackHintList->GetCount() > 0)
{
ulTrackHint = (UINT32)m_pTrackHintList->RemoveTail();
}
m_pTrackHintList->AddTail((void*)++ulTrackHint);
}
m_pCurrentDependentNode = pNode;
m_pNodeDependencies->Push(m_pCurrentDependentNode);
}
break;
case SMILPriorityClass:
{
// /Make sure parent is SMILExcl; a priorityClass element only
// is allowed an excl for a parent:
HX_ASSERT(pNode->m_pParent);
if (pNode->m_pParent)
{
if (SMILExcl !=pNode->m_pParent->m_tag)
{
#if defined(_DEBUG)
// /XXXEH- need to add informative error message for this:
BOOL NEED_ERROR__priorityClass_must_be_child_of_excl = 0;
HX_ASSERT(NEED_ERROR__priorityClass_must_be_child_of_excl);
#endif
CSmilSMILSyntaxErrorHandler errHandler(m_pContext);
errHandler.ReportError(SMILErrorUnexpectedTag,
(const char*) pNode->m_name,
pNode->m_ulTagStartLine);
rc = HXR_FAIL;
// /XXXEH- TODO: handle out-of-spec error condition.
break;
}
// /Next, make sure all of parent's other children, if any,
// are priorityClass elements as well:
CHXSimpleList* pNodeList = pNode->m_pParent->m_pNodeList;
HX_ASSERT(pNodeList);
if (pNodeList)
{
CHXSimpleList::Iterator i;
for (i=pNodeList->Begin();i!=pNodeList->End();++i)
{
SMILNode* pChildNode = (SMILNode*)(*i);
if (pChildNode->m_bDelete)
{
continue;
}
// /If an excl element has a priorityClass child,
// *ALL* children must be priorityClass elements:
if(SMILPriorityClass != pChildNode->m_tag &&
SMILEndExcl != pChildNode->m_tag)
{
CHXString errMsg =
(const char*)pChildNode->m_name;
const char* pTmp = " with ";
errMsg += pTmp;
errMsg += pNode->m_name;
CSmilSMILSyntaxErrorHandler
errHandler(m_pContext);
errHandler.ReportError(
SMILErrorUnexpectedTag,
(const char*)errMsg,
pNode->m_ulTagStartLine);
rc = HXR_FAIL;
break;
}
}
}
}
CSmilPriorityClassElement* pElement =
makePriorityClassElement(pNode);
if(pElement)
{
pNode->m_pElement = pElement;
}
else
{
rc = HXR_INVALID_PARAMETER;
}
}
break;
case SMILEndPriorityClass:
break;
case SMILEndSeq:
{
m_pCurrentDependentNode =
(SMILNode*)m_pNodeDependencies->Pop();
if(m_pTrackHintList->GetCount() > 0)
{
m_pTrackHintList->RemoveTail();
}
}
break;
case SMILEndExcl:
case SMILEndPar:
{
m_pCurrentDependentNode =
(SMILNode*)m_pNodeDependencies->Pop();
if(m_pTrackHintList->GetCount() > 0)
{
m_pTrackHintList->RemoveTail();
}
}
break;
case SMILAAnchor:
{
CSmilAAnchorElement* pElement = makeAAnchorElement(pNode);
if(pElement)
{
pNode->m_pElement = pElement;
m_pAnchorStack->Push(m_pCurrentAnchor);
m_pCurrentAnchor = pElement;
}
else
{
rc = HXR_INVALID_PARAMETER;
}
}
break;
case SMILEndAAnchor:
{
m_pCurrentAnchor = (CSmilAAnchorElement*)m_pAnchorStack->Pop();
}
break;
case SMILArea:
case SMILAnchor:
{
CSmilAnchorElement* pElement = makeAnchorElement(pNode);
if(pElement)
{
pNode->m_pElement = pElement;
//[SMIL 1.0 compliance] Helps fix PR 26471:
// In order to get a notification that we have a resolved
// event-based begin time, we need to be a
// timeline element:
CSmilTimelineAnchor* pTimelineAnchor =
new CSmilTimelineAnchor(pElement, this);
pElement->m_pTimelineElement = pTimelineAnchor;
// Check if this element depends on an external media
// marker file. If so, then add it to a list to be
// processed later
checkForXMMFDependency(pElement);
// add link to parent
SMILNode* pParent = pNode->m_pParent;
if(pParent->m_pElement)
{
pParent->m_pElement->m_pHyperlinks->AddTail(pElement);
}
if(!m_pCurrentDependentNode)
{
//anchor should NEVER be top element:
HX_ASSERT(m_pCurrentDependentNode);
}
else
{
pNode->m_pDependency = m_pCurrentDependentNode;
}
if(firstDependentChild(pNode) || m_pCurrentDependentNode == 0)
{
ulTrackHint = 1;
m_pTrackHintList->AddTail((void*)ulTrackHint);
}
else
{
if(m_pTrackHintList->GetCount() > 0)
{
ulTrackHint = (UINT32)m_pTrackHintList->RemoveTail();
}
m_pTrackHintList->AddTail((void*)++ulTrackHint);
}
m_pCurrentDependentNode = pNode;
m_pNodeDependencies->Push(m_pCurrentDependentNode);
//end of part of fix for PR 26471.
}
}
break;
case SMILBrush:
#if !defined(HELIX_FEATURE_SMIL2_BRUSH)
pNode->m_bDelete = TRUE;
break;
#endif
case SMILRef:
case SMILText:
case SMILImg:
case SMILAudio:
case SMILVideo:
case SMILAnimation:
case SMILTextstream:
case SMILPrefetch:
{
HX_ASSERT(isMediaObject(pNode));
CSmilSource* pSource = makeSource(pNode);
if(!pSource)
{
return HXR_FAIL;
}
m_bContainsSource = TRUE;
pNode->m_pElement = pSource;
CSmilTimelineElement* pTimelineElement =
new CSmilTimelineElement(pSource, this);
pNode->m_pElement->m_pTimelineElement = pTimelineElement;
// Check if this element depends on an external media
// marker file. If so, then add it to a list to be
// processed later
checkForXMMFDependency(pSource);
// attach any links
if(m_pCurrentAnchor)
{
pSource->m_pHyperlinks->AddTail(m_pCurrentAnchor);
}
if(!m_pCurrentDependentNode)
{
// make it behave like it's in a SEQ
pNode->m_pDependency = 0;
//pNode->m_nGroup = 0;
m_pCurrentDependentNode = pNode;
ulTrackHint = 1;
m_pTrackHintList->AddTail((void*)ulTrackHint);
}
else
{
pNode->m_pDependency = m_pCurrentDependentNode;
if(inSeq(pNode))
{
if(firstDependentChild(pNode))
{
ulTrackHint = 1;
m_pTrackHintList->AddTail((void*)ulTrackHint);
}
else
{
if(m_pTrackHintList->GetCount() > 0)
{
ulTrackHint =
(UINT32)m_pTrackHintList->RemoveTail();
}
m_pTrackHintList->AddTail((void*)++ulTrackHint);
}
}
else
{
if(firstDependentChild(pNode))
{
ulTrackHint = 1;
m_pTrackHintList->AddTail((void*)ulTrackHint);
}
}
if(inSeq(pNode) && (!hasAncestor(SMILPar, pNode) &&
!hasAncestor(SMILExcl, pNode)) )
{
if(firstDependentChild(pNode))
{
//pNode->m_nGroup = m_pCurrentDependentNode->m_nGroup;
}
else
{
//pNode->m_nGroup =
//m_pCurrentDependentNode->m_nGroup + 1;
}
m_pCurrentDependentNode = pNode;
}
else if(inSeq(pNode))
{
//pNode->m_nGroup = m_pCurrentDependentNode->m_nGroup;
m_pCurrentDependentNode = pNode;
}
else // in PAR or EXCL:
{
// pNode->m_nGroup = m_pCurrentDependentNode->m_nGroup;
}
}
// /Helps fix PR 58294: using this variable fixes
// <par end="30s"> version, but doesn't completely fix
// <par endsync="all"> version:
if (pNode->m_pElement->m_bHasAtLeastOneNonEventBasedBegin)
{
m_bContainsInitiallyScheduledTrack = TRUE;
}
// set track hint info
BOOL bFirstHint = TRUE;
CHXSimpleList::Iterator hintIter = m_pTrackHintList->Begin();
for(; hintIter != m_pTrackHintList->End(); ++hintIter)
{
char tmpBuf[20]; /* Flawfinder: ignore */
UINT32 ulTrackHint = (UINT32)(*hintIter);
if(bFirstHint)
{
sprintf(tmpBuf, "%d", ulTrackHint); /* Flawfinder: ignore */
bFirstHint = FALSE;
}
else
{
sprintf(tmpBuf, ".%d", ulTrackHint); /* Flawfinder: ignore */
}
pNode->m_trackHint += tmpBuf;
}
}
break;
case SMILAnimate:
case SMILSet:
case SMILAnimateMotion:
case SMILAnimateColor:
{
#if defined(HELIX_FEATURE_SMIL2_ANIMATION)
// Create the animate element object
CSmilAnimateElement* pElement = makeAnimateElement(pNode);
if(pElement)
{
// Add this to the animate element list
if (!m_pAnimateElementList)
{
m_pAnimateElementList = new CHXSimpleList();
}
if (m_pAnimateElementList)
{
m_pAnimateElementList->AddTail((void*) pElement);
}
// Link the animate element object to the node
pNode->m_pElement = pElement;
// Create an animate timeline element - we
// need this to get notification of resolved times
CSmilTimelineAnimate* pTimelineElement =
new CSmilTimelineAnimate(pElement, this);
if (pTimelineElement)
{
// Link the timeline element to the element
pElement->m_pTimelineElement = pTimelineElement;
// Check if this element depends on an external media
// marker file. If so, then add it to a list to be
// processed later
checkForXMMFDependency(pElement);
if(!m_pCurrentDependentNode)
{
// make it behave like it's in a SEQ
pNode->m_pDependency = 0;
m_pCurrentDependentNode = pNode;
}
else
{
pNode->m_pDependency = m_pCurrentDependentNode;
if(inSeq(pNode) && (!hasAncestor(SMILPar, pNode) &&
!hasAncestor(SMILExcl, pNode)) )
{
m_pCurrentDependentNode = pNode;
}
else if(inSeq(pNode))
{
m_pCurrentDependentNode = pNode;
}
}
}
else
{
rc = HXR_OUTOFMEMORY;
}
}
else
{
// XXXMEH - we would get here if the animation
// failed parsing for some reason. We won't throw
// an error (although I think we should) - we will
// just not do the animation.
// rc = HXR_OUTOFMEMORY;
// XXXMEH - what we *will* do is mark the node
// for deletion.
pNode->m_bDelete = TRUE;
}
#else
// Animation is not supported so delete element
pNode->m_bDelete = TRUE;
#endif /* #if defined(HELIX_FEATURE_SMIL2_ANIMATION) */
}
break;
case SMILParam:
{
// Create the animate element object
CSmilParamElement* pElement = makeParamElement(pNode);
if(pElement)
{
// Link the animate element object to the node
pNode->m_pElement = pElement;
}
}
break;
default:
break;
}
if (SUCCEEDED(rc))
{
// /This fixes case where there is nothing to play yet there
// is a duration on the time container; we want to play "nothing"
// for that duration:
if (isTimeContainerObject(pNode) &&
// /Note: m_bContainsSource only tells if 1 or more sources
// *might* play, but this var says that 1+ *will* play:
!m_bContainsInitiallyScheduledTrack &&
pNode->m_pElement &&
DEFAULT_DUR_IF_NO_SOURCES_SCHEDULED ==
m_ulDurIfNoInitialTracksScheduled)
{
if ((UINT32)-1 != pNode->m_pElement->m_ulDuration)
{
m_ulDurIfNoInitialTracksScheduled =
pNode->m_pElement->m_ulDuration;
}
// /Helps fix PR 58294 (original version w/endsync="all"):
// if endsync="all" and children exist, then treat duration as
// unresolved in case all children are event-begun (but
// children haven't been created yet):
else if (SMILEventSourceAll ==
pNode->m_pElement->m_nEndsyncEventSourceTag &&
pNode->m_pNodeList->GetCount() > 0 &&
pNode->m_pElement->m_pTimelineElement &&
!pNode->m_pElement->m_pTimelineElement->getNumChildren())
{
m_ulDurIfNoInitialTracksScheduled = WAY_IN_THE_FUTURE;
}
// /ELSE DO NOTHING!
}
rc = createBodyElements(pNode->m_pNodeList);
if (SUCCEEDED(rc))
{
rc = removeFromNamespaceScope(pNode);
}
}
}
return rc;
}
HX_RESULT
CSmilParser::expandRepeatElements(SMILNodeList* pNodeList)
{
// walk through tree and expand any "repeat" attributes
HX_RESULT rc = HXR_OK;
if(!pNodeList)
{
return rc;
}
LISTPOSITION lPos = pNodeList->GetHeadPosition();
while (lPos && HXR_OK == rc)
{
SMILNode* pNode = (SMILNode*)pNodeList->GetAt(lPos);
if(pNode->m_bDelete) // skip this puppy
{
pNodeList->GetNext(lPos);
continue;
}
// XXXMEH - don't handle repeats in <animate>, <set>,
// <animateMotion>, and <animateColor> here - we
// will handle them in the animation calculation
// code.
if (pNode->m_tag == SMILAnimate ||
pNode->m_tag == SMILSet ||
pNode->m_tag == SMILAnimateMotion ||
pNode->m_tag == SMILAnimateColor)
{
pNodeList->GetNext(lPos);
continue;
}
if(pNode->m_pValues)
{
// /Handle case where there are multiple repeatX attributes:
IHXBuffer* pBufSMIL1Repeat = NULL;
IHXBuffer* pBufRepeatCount = NULL;
IHXBuffer* pBufRepeatDur = NULL;
BOOL bHasSMIL1Repeat = (HXR_OK ==
pNode->m_pValues->GetPropertyCString("repeat",
pBufSMIL1Repeat));
BOOL bHasRepeatCount = (HXR_OK ==
pNode->m_pValues->GetPropertyCString("repeatCount",
pBufRepeatCount));
BOOL bHasRepeatDur = (HXR_OK ==
pNode->m_pValues->GetPropertyCString("repeatDur",
pBufRepeatDur));
// /If both repeat and repeatDur are specified, use repeatDur:
if (bHasSMIL1Repeat && bHasRepeatCount)
{
bHasSMIL1Repeat = FALSE;
}
// /XXXEH- TODO: figure out how to handle this:
// repeat="..." repeatDur="..."
// Just use repeatDur and ignore repeat?? That's what I'm doing:
if (bHasSMIL1Repeat && bHasRepeatDur)
{
bHasSMIL1Repeat = FALSE;
}
if (!pNode->m_bRepeatHandled &&
(bHasSMIL1Repeat || bHasRepeatCount || bHasRepeatDur) )
{
if (bHasRepeatDur || bHasRepeatCount)
{
// /SMIL 1.0-VS-2.0 repeat conflict should have been
// solved already above so assert if not:
HX_ASSERT(!bHasSMIL1Repeat);
}
BOOL bSMIL1RepeatIndefinite = FALSE;
BOOL bRepeatCountIndefinite = FALSE;
BOOL bRepeatDurIndefinite = FALSE;
const char* pSMIL1RepeatVal = NULL;
const char* pRepeatCountVal = NULL;
const char* pRepeatDurVal = NULL;
if (bHasSMIL1Repeat)
{
pSMIL1RepeatVal = (const char*)pBufSMIL1Repeat->GetBuffer();
if(strcmp(pSMIL1RepeatVal, "indefinite") == 0)
{
bSMIL1RepeatIndefinite = TRUE;
}
}
if (bHasRepeatCount)
{
HX_ASSERT(!bHasSMIL1Repeat);
pRepeatCountVal =
(const char*)pBufRepeatCount->GetBuffer();
if(strcmp(pRepeatCountVal, "indefinite") == 0)
{
bRepeatCountIndefinite = TRUE;
}
}
if (bHasRepeatDur)
{
HX_ASSERT(!bHasSMIL1Repeat);
pRepeatDurVal = (const char*)pBufRepeatDur->GetBuffer();
if(strcmp(pRepeatDurVal, "indefinite") == 0)
{
bRepeatDurIndefinite = TRUE;
}
}
if (bHasRepeatDur && bHasRepeatCount)
{
// /Find "MIN(p1,p2,indefinite)" per the SMIL 2.0 Timing
// spec; If exactly one is indefinite, throw it away. If
// both are, then just use repeatCount of indefinite:
if (bRepeatCountIndefinite && !bRepeatDurIndefinite)
{
bHasRepeatCount = FALSE;
}
else if (bRepeatDurIndefinite && !bRepeatCountIndefinite)
{
bHasRepeatDur = FALSE;
}
else if (bRepeatDurIndefinite && bRepeatCountIndefinite)
{
bHasRepeatDur = FALSE;
}
// /We need to know which will play for less time, but we
// can't know how long the total repeatCount duration
// will be until we resolve the dur of the element, so we
// must calc this when trackDurationSet() gets called:
else // /neither is indefinite:
{
pNode->m_bNeedToResolveRepeatDurVSRepeatCount = TRUE;
// /Just pick one for now (by removing the other one):
bHasRepeatDur = FALSE;
}
}
// /Only 1 of these three should be TRUE at this point:
HX_ASSERT(1 == (UINT32)bHasRepeatCount +
(UINT32)bHasRepeatDur + (UINT32)bHasSMIL1Repeat);
// /Now, settle on which one won:
const char* pRepeatVal = NULL;
BOOL bRepeatIndefinite = FALSE;
if (bHasRepeatCount)
{
pRepeatVal = pRepeatCountVal;
bRepeatIndefinite = bRepeatCountIndefinite;
}
else if (bHasRepeatDur)
{
pRepeatVal = pRepeatDurVal;
bRepeatIndefinite = bRepeatDurIndefinite;
}
else
{
pRepeatVal = pSMIL1RepeatVal;
bRepeatIndefinite = bSMIL1RepeatIndefinite;
}
if (pRepeatVal)
{
INT32 lRepeatCount = 0;
double fRepeatCount = 0.0;
ULONG32 ulRepeatDur = 0;
if(bRepeatIndefinite)
{
bRepeatIndefinite = TRUE;
lRepeatCount = 2;
fRepeatCount = 2.0;
}
else
{
if (bHasSMIL1Repeat)
{
lRepeatCount = atol(pRepeatVal);
fRepeatCount = double(float(lRepeatCount));
}
else if (bHasRepeatCount)
{
lRepeatCount = atol(pRepeatVal);
fRepeatCount = atof(pRepeatVal);
}
else // / bHasRepeatDur so handle dur:
{
HX_RESULT pnrslt = parseClockValue(pRepeatVal,
ulRepeatDur);
if (HXR_OK == pnrslt)
{
// /We'll wrap it in a seq with a dur of
// ulRepeatDur and then repeat it underneath
// indefinitely, ending when the seq does:
bRepeatIndefinite = TRUE;
lRepeatCount = 2;
fRepeatCount = 2.0;
}
else
{
// /Forget repeating since time was invalid:
bHasRepeatDur = FALSE;
}
}
}
double fPartialPlayFactor =
fRepeatCount - float(double(lRepeatCount));
if(fRepeatCount == 0.0)
{
pNode->m_bDelete = TRUE;
}
else if (fRepeatCount < 1.0)
{
HX_ASSERT(fPartialPlayFactor > 0.0);
pNode->m_fPartialPlayFactor = fPartialPlayFactor;
}
else if (fRepeatCount > 1.0)
{
// build a <seq>/</seq> around the repeated element...
SMILNode* pSeqNode = NULL;
SMILNode* pSeqEndNode = NULL;
createParent(pNode, SMILSeq, pSeqNode, pSeqEndNode);
// /Set this to TRUE so we can later decide whether
// or not to use explicit dur|end on parent as dur
// of this:
pSeqNode->m_bIsSeqWrapperForRepeatElement = TRUE;
// /For element that has any attributes that affect
// its "active duration" (see SMIL 2.0 spec) and not
// just its "simple duration", we put these into the
// wrapper seq's values giving us the desired result.
// These attributes are: begin, end, min, and max.
// (We also will "remove" these values from pNode by
// setting pNodes appropriate "HandledBy" flags):
IHXBuffer* pBufTemp = NULL;
BOOL bHasEndDurOrMinTimingAttribute = FALSE;
IHXValues* pValues = 0;
if (m_pClassFactory &&
(HXR_OK == m_pClassFactory->CreateInstance(
CLSID_IHXValues, (void**)&pValues)) )
{
pSeqNode->m_pValues = pValues;
}
if (HXR_OK == pNode->m_pValues->
GetPropertyCString("end", pBufTemp) )
{
bHasEndDurOrMinTimingAttribute = TRUE;
if (pSeqNode->m_pValues)
{
pSeqNode->m_pValues->SetPropertyCString(
"end", pBufTemp);
pNode->m_bEndHandledByWrapperParent =TRUE;
}
HX_RELEASE(pBufTemp);
}
if (HXR_OK == pNode->m_pValues->
GetPropertyCString("min", pBufTemp) )
{
bHasEndDurOrMinTimingAttribute = TRUE;
if (pSeqNode->m_pValues)
{
// /XXXEH- TODO: handle min="media"
pSeqNode->m_pValues->SetPropertyCString(
"min", pBufTemp);
pNode->m_bMinHandledByWrapperParent =TRUE;
}
HX_RELEASE(pBufTemp);
}
if (HXR_OK == pNode->m_pValues->
GetPropertyCString("max", pBufTemp) )
{
if (pSeqNode->m_pValues)
{
// /XXXEH- TODO: handle max="media"
pSeqNode->m_pValues->SetPropertyCString(
"max", pBufTemp);
pNode->m_bMaxHandledByWrapperParent =TRUE;
}
HX_RELEASE(pBufTemp);
}
#if defined(XXXEH_NEED_TO_HANDLE_NON_CLOCKVALUE_BEGINS)
// /XXXEH- TODO: handle begin offset in wrapping seq, but we'll need to then
// properly handle multiple begin conditions on an element as well as things
// like begin="activateEvent" (which should work whenever ANY iteration of
// the repeating media gets clicked):
if (HXR_OK == pNode->m_pValues->
GetPropertyCString("begin", pBufTemp) )
{
if (pSeqNode->m_pValues)
{
pSeqNode->m_pValues->SetPropertyCString(
"begin", pBufTemp);
pNode->m_bBeginHandledByWrapperParent =TRUE;
}
HX_RELEASE(pBufTemp);
}
#endif
// /For repeatDur="t", give the outer seq a dur of t:
if (bHasRepeatDur)
{
// /NOTE: in case of discrete media this should
// have a dur of 0, but we don't know if it's
// discrete media until
// CSmilDocumentRenderer::TrackDurationSet()
// gets called; we have to guess if it is, for
// now:
if (!bHasEndDurOrMinTimingAttribute)
{
bHasEndDurOrMinTimingAttribute =
(HXR_OK == pNode->m_pValues->
GetPropertyCString("dur", pBufTemp));
HX_RELEASE(pBufTemp);
}
// /XXXEH- TODO: find a better way to get around
// this discrete-media problem: at this point, we
// need the media's header to tell us whether it
// is discrete media, but we have to decide *now*
// whether or not to honor its repeatDur...
BOOL bIsImageOrPlainTextOrHTML = FALSE;
if (!bHasEndDurOrMinTimingAttribute)
{
if (HXR_OK == pNode->m_pValues->
GetPropertyCString("src",
pBufTemp) &&
pBufTemp->GetSize()>0 )
{
const char* pszBuf =
(const char*)pBufTemp->GetBuffer();
const char* pszExten = NULL;
UINT32 ulBufLen = strlen(pszBuf);
const char* pszWalkBuf = (ulBufLen > 1 ?
&pszBuf[ulBufLen-2] : NULL);
while (pszWalkBuf && pszWalkBuf>pszBuf)
{
if ('.' == *pszWalkBuf)
{
pszExten = pszWalkBuf+1;
break;
}
pszWalkBuf--;
}
if (pszExten)
{
if (0==stricmp("jpg",pszExten) ||
0==stricmp("png",pszExten) ||
0==stricmp("gif",pszExten) ||
0==stricmp("bmp",pszExten) ||
0==stricmp("html",pszExten) ||
0==stricmp("txt",pszExten) )
// /XXX ...etc.
{
bIsImageOrPlainTextOrHTML = TRUE;
}
}
}
}
if (!bIsImageOrPlainTextOrHTML)
{
// /Fixes SMIL 2.0 Interop Timing #4.18;
// don't add invalid ulRepeatDur (which
// it is when "indefinite"):
if (!bRepeatDurIndefinite)
{
pSeqNode->m_ulRepeatDur = ulRepeatDur;
}
else
{
HX_ASSERT(0 == ulRepeatDur);
}
}
}
SMILNode* pNodeCopy = NULL;
BOOL bOverWrite = TRUE;
INT32 lNumRepeats = fPartialPlayFactor > 0.0 ?
lRepeatCount+1 : lRepeatCount;
for (INT32 lCount = 0; lCount < lNumRepeats; ++lCount)
{
// we want to keep the original ids for the
// 1st repeat so that we don't break any links
if (0 == lCount)
{
pNodeCopy = new SMILNode(*pNode, TRUE, this);
bOverWrite = TRUE;
}
else
{
#if defined(XXXEH_REPEAT_VALUE_TIMING_SHOULD_BE_EVENT_BASED)
pNodeCopy = new SMILNode(*pNode, FALSE, this);
#else
pNodeCopy = new SMILNode(*pNode, FALSE, this,
lCount);
#endif
bOverWrite = FALSE;
}
pNodeCopy->m_pParent = pSeqNode;
pNodeCopy->m_pNodeList->m_pParentNode = pNodeCopy;
pNodeCopy->m_bRepeatHandled = TRUE;
// after the 1st repeat, mark the rest of repeats
// as replica(used in counting tracks etc.)
if (lCount > 0)
{
if (bRepeatIndefinite)
{
if (pNodeCopy->m_tag == SMILSeq ||
pNodeCopy->m_tag == SMILExcl ||
pNodeCopy->m_tag == SMILPar)
{
// set indefinite repeat tag on seq
// will be used in constructing timeline elements
pSeqNode->m_repeatTag = RepeatIndefiniteOnMe;
pNodeCopy->m_repeatTag = RepeatIndefiniteOnGroup;
markRepeatReplica(pNodeCopy->m_pNodeList, RepeatIndefiniteOnGroup);
}
else
{
pNodeCopy->m_repeatTag = RepeatIndefiniteOnMe;
}
}
else
{
if (lCount == lNumRepeats-1 &&
fPartialPlayFactor > 0.0)
{
pNodeCopy->m_fPartialPlayFactor =
fPartialPlayFactor;
}
pNodeCopy->m_repeatTag=RepeatReplica;
if (pNodeCopy->m_tag == SMILSeq ||
pNodeCopy->m_tag == SMILExcl ||
pNodeCopy->m_tag == SMILPar)
{
markRepeatReplica(
pNodeCopy->m_pNodeList,
RepeatReplica);
}
}
}
mapID(pNodeCopy, bOverWrite);
//Fix for PR 13119: internal elements (source
// elements, especially) of a repeated <seq> or
// <par> tag were not getting mapped and thus
// never played, so we need to map the IDs of
// all in the m_pNodeList of the pNodeCopy:
mapChildrenIDs(pNodeCopy->m_pNodeList, bOverWrite);
pSeqNode->m_pNodeList->AddTail(pNodeCopy);
}
pSeqNode->m_pNodeList->AddTail(pSeqEndNode);
// special case to ensure all repeated elements
// are within the same group(share the same timeline)
if (!hasAncestor(SMILPar, pSeqNode) &&
!hasAncestor(SMILExcl, pSeqNode))
{
SMILNode* pParNode = NULL;
SMILNode* pParEndNode = NULL;
createParent(pSeqNode, SMILPar, pParNode, pParEndNode);
pParNode->m_repeatTag = pSeqNode->m_repeatTag;
pParNode->m_pNodeList->AddTail(pSeqNode);
pParNode->m_pNodeList->AddTail(pParEndNode);
// now add the list to the parent...
pNodeList->InsertBefore(lPos, pParNode);
pNode->m_bDelete = TRUE; // delete original node
pNode = pParNode;
}
else
{
// now add the list to the parent...
pNodeList->InsertBefore(lPos, pSeqNode);
pNode->m_bDelete = TRUE; // delete original node
pNode = pSeqNode;
}
}
}
}
HX_RELEASE(pBufSMIL1Repeat);
HX_RELEASE(pBufRepeatCount);
HX_RELEASE(pBufRepeatDur);
}
// breadth first
rc = expandRepeatElements(pNode->m_pNodeList);
pNodeList->GetNext(lPos);
}
return rc;
}
HX_RESULT
CSmilParser::createParent (SMILNode* pChildNode,
SMILNodeTag tag,
SMILNode*& pParent,
SMILNode*& pParentEnd)
{
HX_RESULT hr = HXR_OK;
pParent = NULL;
pParentEnd = NULL;
if (!pChildNode)
{
hr = HXR_FAILED;
goto cleanup;
}
pParent = new SMILNode;
pParent->m_pParent = pChildNode->m_pParent;
pParent->m_tag = tag;
pParent->m_pNodeList = new SMILNodeList;
pParent->m_pNodeList->m_pParentNode = pParent;
pParentEnd = new SMILNode;
pParentEnd->m_pParent = pParent;
if (SMILPar == tag)
{
pParent->m_name = "par";
pParent->m_id = assignID("parCreated");
pParentEnd->m_name = "par";
pParentEnd->m_id = assignID("CLOSE-par");
pParentEnd->m_tag = SMILEndPar;
}
else if (SMILSeq == tag)
{
pParent->m_name = "seq";
pParent->m_id = assignID("seqCreated");
pParentEnd->m_name = "seq";
pParentEnd->m_id = assignID("CLOSE-seq");
pParentEnd->m_tag = SMILEndSeq;
}
else if (SMILExcl == tag)
{
pParent->m_name = "excl";
pParent->m_id = assignID("exclCreated");
pParentEnd->m_name = "excl";
pParentEnd->m_id = assignID("CLOSE-excl");
pParentEnd->m_tag = SMILEndExcl;
}
else
{
HX_ASSERT(FALSE);
hr = HXR_FAILED;
goto cleanup;
}
mapID(pParent);
mapID(pParentEnd);
cleanup:
return hr;
}
void
CSmilParser::resetTimeline()
{
m_pTimelineElementManager->resetTimeline();
}
HX_RESULT
CSmilParser::prepForSeek(UINT32 ulOldTime, UINT32 ulNewTime)
{
HX_RESULT rslt = HXR_OK;
// /Helps Fix PR 67170: reload the onLoad url list with the original list.
// findNextPendingOnLoadURL() now handles removing all but the last of
// simultaneous hurls to the same rn:sendTo+target, so a long seek back
// or a long seek forward will skip all but the last of each rn-sendTo
// link whose time is less than the seeked-to time. Otherwise we'd be
// simultaneously hurling possibly many links that would be immediately
// replaced. The end result is a better user experience, but will not
// necessarily leave the sendTo app in the state it would have been had
// normal (seek-less) playback arrived at that time in the presentation
// (especially if a "back" button exists in the app).
// If the seek-from/seek-to times are identical, leave the list as is:
if (ulOldTime != ulNewTime &&
m_pOnLoadURLList && m_pOnLoadURLListCopyForPostSeek)
{
// /TRUE for special post-seek handling in FindNextPendingOnLoadURL:
m_bHandlePostSeekOnLoadURLs = TRUE;
// /Clear the old, incomplete list:
m_pOnLoadURLList->RemoveAll();
// /Now, copy the complete original list into the active list:
LISTPOSITION lPos = m_pOnLoadURLListCopyForPostSeek->GetHeadPosition();
while (lPos)
{
CSmilAAnchorElement* pCurAnchor = (CSmilAAnchorElement*)
m_pOnLoadURLListCopyForPostSeek->GetNext(lPos);
if (!pCurAnchor)
{
HX_ASSERT(pCurAnchor); // /List shouldn't have an empty node.
continue;
}
// /Move from head to tail in each list, so add tail:
m_pOnLoadURLList->AddTail((void*) pCurAnchor);
}
}
return rslt;
}
// /Smil doc renderer needs to get at prefetch element from prefetch ID to
// adjust element's duration when the prefetching is done (if no explicit
// duration|end was put on the prefetch element). This does nothing if
// duration is already a valid amount.
// Returns HXR_FAILED if resetDuration() is not called on the element.
HX_RESULT
CSmilParser::handlePrefetchFinished(const char* pID, UINT32 ulTimeFinished)
{
HX_RESULT pnr = HXR_FAILED;
if ((UINT32)-1 != ulTimeFinished)
{
CSmilTimelineElement* pTmLnElement = m_pTimelineElementManager->getTimelineElement(pID);
if (pTmLnElement)
{
pnr = pTmLnElement->handlePrefetchFinished(ulTimeFinished);
}
}
return pnr;
}
SMILNode*
CSmilParser::getTimelineDescendent(SMILNode* pParentNode)
{
SMILNode* pDescendentNode = NULL;
CHXSimpleList* pNodeList = pParentNode->m_pNodeList;
if(!pNodeList)
{
return pDescendentNode;
}
CHXSimpleList::Iterator i;
for(i=pNodeList->Begin();i!=pNodeList->End();++i)
{
SMILNode* pNode = (SMILNode*)(*i);
if(pNode->m_bDelete)
{
continue;
}
// /<a>, <priorityClass>, and <switch> are not timeline elements:
if(pNode->m_tag == SMILAAnchor ||
pNode->m_tag == SMILPriorityClass ||
pNode->m_tag == SMILSwitch)
{
pNode = getTimelineDescendent(pNode);
if(pNode)
{
pDescendentNode = pNode;
break;
}
}
else
{
if(pNode->m_tag == SMILSeq ||
pNode->m_tag == SMILPar ||
pNode->m_tag == SMILExcl ||
pNode->m_tag == SMILRef ||
pNode->m_tag == SMILText ||
pNode->m_tag == SMILImg ||
pNode->m_tag == SMILAudio ||
pNode->m_tag == SMILVideo ||
pNode->m_tag == SMILAnimation ||
pNode->m_tag == SMILTextstream ||
pNode->m_tag == SMILBrush ||
pNode->m_tag == SMILPrefetch ||
pNode->m_tag == SMILArea ||
pNode->m_tag == SMILAnchor ||
pNode->m_tag == SMILAnimate ||
pNode->m_tag == SMILSet ||
pNode->m_tag == SMILAnimateMotion ||
pNode->m_tag == SMILAnimateColor)
{
pDescendentNode = pNode;
break;
}
}
}
return pDescendentNode;
}
SMILNode*
CSmilParser::getPrevNode(SMILNode* pCurrentNode)
{
SMILNode* pPrevNode = NULL;
CHXSimpleList* pNodeList = pCurrentNode->m_pParent->m_pNodeList;
if(!pNodeList)
{
return pPrevNode;
}
BOOL bFound = FALSE;
CHXSimpleList::Iterator i;
for(i=pNodeList->Begin();i!=pNodeList->End();++i)
{
SMILNode* pNode = (SMILNode*)(*i);
if(pNode->m_bDelete)
{
continue;
}
if (pNode->m_id == pCurrentNode->m_id)
{
bFound = TRUE;
break;
}
pPrevNode = pNode;
}
if (bFound)
{
return pPrevNode;
}
else
{
return NULL;
}
}
SMILNode*
CSmilParser::getTimelineDescendent(SMILNode* pParentNode, SMILNode* pSiblingNode)
{
SMILNode* pFirstDescendent = getTimelineDescendent(pParentNode);
if(!pSiblingNode)
{
return pFirstDescendent;
}
// first, find parent of sibling
SMILNode* pSiblingParent = pSiblingNode->m_pParent;
// /Fixes a bug where a non-timed parent has more than one timed
// child, e.g., "<par><a><ref1/><ref2/></a><ref3/></par>" in which
// case we want to find ref2, not ref3. We want to check the actual
// parent's children first, then, if actual parent is not a timeline
// element, go up to its parent, p2, and look for timeline
// sibling, else if p2 is not a timeline element then go up to its
// parent, p3, and do the same, ...etc. until a timed child is found
// or until pX is a timeline element. Has been a bug since SMIL 1:
SMILNode* pEffectiveSiblingNode = pSiblingNode;
SMILNode* pFoundSibling = NULL;
do
{
BOOL bParentIsTimedObject = isTimeContainerObject(pSiblingParent) ||
isMediaObject(pSiblingParent);
SMILNode* pNextSibling = findNextSibling(pEffectiveSiblingNode);
if (!pNextSibling)
{
// /No sibling found; if parent is a timed element, then
// we're done because there is no next sibling:
if (bParentIsTimedObject)
{
pFoundSibling = NULL;
break;
}
else
{
// /Go up and find non-timed parent's next sibling:
pEffectiveSiblingNode = pSiblingParent;
pSiblingParent = pSiblingParent->m_pParent;
}
}
else if (isTimeContainerObject(pNextSibling) ||
isMediaObject(pNextSibling))
{
pFoundSibling = pNextSibling;
break;
}
// /Sibling is not a timed element; return its first timed descendant
// if one exists, otherwise return its next sibling (and let the
// caller of this determine what to do from there):
else
{
SMILNode* pNextSiblingTimelineDescendant =
getTimelineDescendent(pNextSibling, NULL);
if (!pNextSiblingTimelineDescendant)
{
pFoundSibling = pNextSibling;
break;
}
else
{
pFoundSibling = pNextSiblingTimelineDescendant;
break;
}
}
} while (pSiblingParent);
return pFoundSibling;
}
// /Finds pNode's parent's next child, if any. DOES NOT CARE IF NODE IS
// A TIMED ELEMENT OR NOT; this is strictly a document tree thing:
SMILNode*
CSmilParser::findNextSibling(SMILNode* pNode)
{
SMILNode* pNextSibling = NULL;
CHXSimpleList::Iterator i;
if(!pNode || !pNode->m_pParent)
{
goto cleanup;
}
// /Go through parent's list until we find pNode, then return next one:
i = pNode->m_pParent->m_pNodeList->Begin();
for (; i != pNode->m_pParent->m_pNodeList->End(); ++i)
{
SMILNode* pThisNode = (SMILNode*)(*i);
// /(NOTE: even if pThisNode->m_bDelete, we still want its sibling;
// this happens when repeat of x results in: seq/x,x1,x2.../seq,x
// where the last x has m_bDelete set.)
if (pThisNode == pNode)
{
// /We found pNode so return the next one, if any:
if (++i != pNode->m_pParent->m_pNodeList->End())
{
pNextSibling = (SMILNode*)(*(i));
// /However, if the node is an end tag (SMILEndXYZ) and is
// the last child, then we want to ignore it:
if (pNode->m_pParent->m_pNodeList->End() == ++i &&
(pNextSibling && isEndTagObject(pNextSibling)))
{
pNextSibling = NULL;
}
}
break; // /We either found it or it doesn't exist.
}