escsmil.cpp
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:10k
源码类别:

Symbian

开发平台:

C/C++

  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  35. #include "hxcom.h"     /* IUnknown */
  36. #include "hxtypes.h" 
  37. #include "hxbuffer.h"
  38. #include "hxiids.h"
  39. #include "hxstrutl.h"
  40. #include "hxstring.h"
  41. #include "growingq.h"
  42. #include "xmlesc.h"
  43. #include "escsmil.h"
  44. #include "vsrcinfo.h"
  45. /*___________________________________________________________________________
  46.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  47.  * Static variable declarations
  48.  *___________________________________________________________________________
  49.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
  50. const char* const CEscapeSMIL::m_pHotSMILTags[] = 
  51.       "ref"
  52.     , "animation"
  53.     , "audio"
  54.     , "img"
  55.     , "video"
  56.     , "text"
  57.     , "textstream"
  58.     , "meta"
  59.     , 0};
  60. /*___________________________________________________________________________
  61.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  62.  *  CEscapeXMLtoHTML::PushHeader(queue)
  63.  *
  64.  *  PARAMETERS:
  65.  * queue The queue to push the output to.
  66.  *
  67.  *  DESCRIPTION:
  68.  * This function pushes the header information for the smil file.
  69.  *
  70.  *  RETURNS
  71.  * void
  72.  *___________________________________________________________________________
  73.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
  74. void
  75. CEscapeSMIL::PushHeader(CBigByteGrowingQueue* queue)
  76. {
  77.     queue->EnQueue(z_pOpen);
  78.     
  79.     char buf[sizeof(z_pImage_ss) + sizeof(z_pSMILImageLoc) /* Flawfinder: ignore */
  80.      + sizeof(z_pSMILAltText)];
  81.     //sprintf(buf, z_pImage_ss, z_pSMILImageLoc, z_pSMILAltText);
  82.     queue->EnQueue(z_pSMILHeader);
  83.     
  84.     //queue->EnQueue(z_pSMILHREF);
  85.     //queue->EnQueue(buf);
  86.     //queue->EnQueue("</a>");
  87.     queue->EnQueue(z_pStream);
  88.     queue->EnQueue(z_pSMILName);
  89.     queue->EnQueue(z_pEndLine);
  90.     
  91.     PushCommonHeader(queue);
  92.     sprintf(buf, z_pXMLSource_s, z_pSMILName); /* Flawfinder: ignore */
  93.     queue->EnQueue(buf);
  94.     queue->EnQueue(z_pClose);
  95.     
  96.     queue->EnQueue(z_pSMILTrailer);
  97. }
  98. /*___________________________________________________________________________
  99.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  100.  *  CEscapeXMLtoHTML::OnTag(cp, pObj, queue)
  101.  *
  102.  *  PARAMETERS:
  103.  *
  104.  * cp It points to the first whitespace after a tag name we are
  105.  * looking for
  106.  * ulLen Length to end of cp so we don't overrun the buffer
  107.  * pObj The current state of the Parse Function, this can be used
  108.  * to continue parsing.  its tag member contains the name
  109.  * of the tag
  110.  * queue The queue to push the output to.
  111.  *
  112.  *  DESCRIPTION:
  113.  * This function is used to wrap any key attributes in the any tags in
  114.  * m_pHotRTTags. It calls CEscapeXMLtoHTML to do most the work
  115.  *
  116.  *  RETURNS
  117.  * UINT32
  118.  *     number of characters used off cp
  119.  *___________________________________________________________________________
  120.  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
  121. UINT32
  122. CEscapeSMIL::OnTag(const UCHAR* cp, UINT32 ulLen, DataObject* pObj,
  123.    CBigByteGrowingQueue* pQueue)
  124. {
  125.     if ( strcasecmp(pObj->tag, "meta") == 0 )
  126.     {
  127. // special case - we need to find the base -
  128. const UCHAR* pBeginName = NULL;
  129. const UCHAR* pBeginContent = NULL;
  130. const UCHAR* pEndTag = NULL;
  131. const char* walker = (const char*)cp;
  132. BOOL bInComment = FALSE;
  133. UINT32 ulEscLen = 0;
  134. while ( (!pEndTag) && ulEscLen < ulLen)
  135. {
  136.     if ( !bInComment )
  137.     {
  138. if ( *walker == '>')
  139. {
  140.     pEndTag = (const UCHAR*)walker;
  141.     ++pEndTag;
  142. }
  143. else if ( ulEscLen + 6 < ulLen && 
  144.     isspace(*(walker-1)) && 
  145.     !strncmp(walker, "name", 4) &&
  146.     (*(walker+4) == '=' || isspace(*(walker+4))) )
  147. {
  148.     walker += 4;
  149.     ulEscLen += 4;
  150.     while ( isspace(*walker) && ulEscLen < ulLen )
  151.     {
  152. ++walker;
  153. ++ulEscLen;
  154.     }
  155.     HX_ASSERT(*walker == '=');
  156.     if ( *walker == '=' )
  157.     {
  158. ++walker;
  159. ++ulEscLen;
  160. while ( isspace(*walker) && ulEscLen < ulLen )
  161. {
  162.     ++walker;
  163.     ++ulEscLen;
  164. }
  165. HX_ASSERT(*walker == '"' || *walker == ''');
  166. if ( *walker == '"' || *walker == ''' )
  167. {
  168.     ++walker;
  169.     ++ulEscLen;
  170.     pBeginName = (const UCHAR*)walker;
  171. }
  172.     }
  173. }
  174. else if ( ulEscLen + 7 < ulLen &&  
  175.     isspace(*(walker-1)) && 
  176.     !strncmp(walker, "content", 7) &&
  177.     (*(walker+7) == '='|| isspace(*(walker+7))) )
  178. {
  179.     walker += 7;
  180.     ulEscLen += 7;
  181.     while ( isspace(*walker) && ulEscLen < ulLen )
  182.     {
  183. ++walker;
  184. ++ulEscLen;
  185.     }
  186.     HX_ASSERT(*walker == '=');
  187.     if ( *walker == '=' )
  188.     {
  189. ++walker;
  190. ++ulEscLen;
  191. while ( isspace(*walker) && ulEscLen < ulLen )
  192. {
  193.     ++walker;
  194.     ++ulEscLen;
  195. }
  196. HX_ASSERT(*walker == '"' || *walker == ''');
  197. if ( *walker == '"' || *walker == ''' )
  198. {
  199.     ++walker;
  200.     ++ulEscLen;
  201.     pBeginContent = (const UCHAR*)walker;
  202. }
  203.     }
  204. }
  205. else if ( ulEscLen + 4 < ulLen && 
  206.     !strncmp(walker, "<!--", 4) )
  207. {
  208.     bInComment = TRUE;
  209.     walker += 3;
  210.     ulEscLen += 3;
  211. }
  212.     }
  213.     else
  214.     {
  215. if ( ulEscLen + 3 < ulLen && !strncmp(walker, "-->", 3) )
  216. {
  217.     bInComment = FALSE;
  218.     walker += 2;
  219.     ulEscLen += 2;
  220. }
  221.     }
  222.     ++walker;
  223.     ++ulEscLen;
  224. }
  225. if ( pEndTag == NULL || pBeginName == NULL || pBeginContent == NULL )
  226. {
  227.     return 0;
  228. }
  229. else if ( strncmp((const char*)pBeginName, "base", 4) == 0 )
  230. {
  231.     char* pOldPath = m_pOurPath;
  232.     char* pEndContent = (char*)strchr((const char*)pBeginContent, '"');
  233.     if ( pEndContent == NULL )
  234.     {
  235. pEndContent = (char*)strchr((const char*)pBeginContent, ''');
  236.     }
  237.     HX_ASSERT(pEndContent);
  238.     UINT32 ulConLen = 0;
  239.     if ( pEndContent )
  240.     {
  241. ulConLen = (const UCHAR*)pEndContent - pBeginContent;
  242.     }
  243.     m_pOurPath = new char[strlen(pOldPath) + ulConLen + 2];
  244.     strcpy(m_pOurPath, pOldPath);
  245.     HX_VECTOR_DELETE(pOldPath);
  246.     if ( *pBeginContent == '/' )
  247.     {
  248. strncpy(m_pOurPath, (const char*)pBeginContent, ulConLen);
  249. m_pOurPath[ulConLen] = '';
  250.     }
  251.     // if it is alpha it is a relative directory name
  252.     else if ( isalnum(*pBeginContent) )
  253.     {
  254. // 1 for "/"
  255. UINT32 len = strlen(m_pOurPath) + ulConLen + 1;
  256. strcat(m_pOurPath, "/");
  257. strncat(m_pOurPath, (const char*)pBeginContent, ulConLen);
  258. m_pOurPath[len] = '';
  259.     }
  260.     else if ( !strncmp((const char*)pBeginContent, "./", 2) )
  261.     {
  262. // -1 for .
  263. UINT32 len = strlen(m_pOurPath) + ulConLen - 1;
  264. strncat(m_pOurPath, (const char*)pBeginContent + 1, ulConLen - 1);
  265. m_pOurPath[len] = '';
  266.     }
  267.     else if ( !strncmp((const char*)pBeginContent, "../", 3 ) )
  268.     {
  269. int count = 0;
  270. const char* pRelativePath = (const char*)pBeginContent;
  271. char* pCurrentEndOfPath = m_pOurPath;
  272. pCurrentEndOfPath += strlen(m_pOurPath);
  273. // back up a directory off of the file path for
  274. // every ../ we find
  275. while (!strncmp((const char*)pRelativePath, "../", 3 ))
  276. {
  277.     // we found a ../ so back up a directory on the path,
  278.     // walk backwards to the previous / and set it to null
  279.     while (*pCurrentEndOfPath != '/' && 
  280. pCurrentEndOfPath >= m_pOurPath)
  281.     {
  282. pCurrentEndOfPath--;
  283.     }
  284.     // watch to make sure we don't have more ../ than directories
  285.     if ( pCurrentEndOfPath < m_pOurPath )
  286.     {
  287. ++pCurrentEndOfPath;
  288.     }
  289.     *pCurrentEndOfPath = '';
  290.     pRelativePath +=3;
  291. }
  292. UINT32 len = (pCurrentEndOfPath - m_pOurPath) + 
  293.     ulConLen - (pRelativePath - (const char*)pBeginContent) + 1;
  294. // back 1 off of pRelativePath so we get the / that's there.
  295. strncat(m_pOurPath, (const char*)pRelativePath - 1,
  296.     ulConLen - (pRelativePath - (const char*)pBeginContent) + 1);
  297. m_pOurPath[len] = '';
  298.     }
  299.     else
  300.     {
  301. HX_ASSERT(FALSE);
  302. return 0;
  303.     }
  304.     // get rid of the trailing '/' if there is one.
  305.     ulConLen = strlen(m_pOurPath);
  306.     if ( m_pOurPath[ulConLen-1] == '/' )
  307.     {
  308. m_pOurPath[ulConLen-1] = '';
  309.     }
  310. }
  311. return 0;
  312.     }
  313.     else
  314.     {
  315. // src=" attribute is the only one we are looking for.
  316. return WrapAttributeWithHREF(cp, ulLen, pObj, pQueue, "src");
  317.     }
  318. }