开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
3gppttstructs.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：44k
源码类别：

Symbian

开发平台：

Visual C++

3gppttstructs.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2003 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 ***** */ 
  36. /****************************************************************************
  37.  *  Includes
  38.  */
  39. #include <string.h> // /for memset, strncmp, stricmp
  40. #include "hlxclib/memory.h" // /for memset, memcpy
  42. #include "chxpckts.h" // /For IHXPacket
  43. #include "hxwintyp.h" // /For HXxRect
  45. #if defined(_SYMBIAN) // /                                                     -----vvvvvvvvvvvvvvvvvvvvvvvvvv-----
  46. #include <utf.h>  // /For CnvUtfConverter::ConvertToUnicodeFromUtf8();
  47. #endif // /_SYMBIAN                                                            _____^^^^^^^^^^^^^^^^^^^^^^^^^^_____
  49. #include "3gppttstructs.h"
  50. #include "3gppttutils.h"
  52. #include "hxheap.h"
  53. #ifdef _DEBUG
  54. #undef HX_THIS_FILE
  55. static const char HX_THIS_FILE[] = __FILE__;
  56. #endif
  58. // for DPRINTF
  59. //#define INCLUDE_DPRINTF
  60. #if(INCLUDE_DPRINTF)
  61. #   include "debug.h"
  62. #   define D_TIMEDTEXT D_INFO
  63. #else
  64. #   define DPRINTF(a,b)
  65. #endif
  67. HX_RESULT C3GPPTextboxBox::Build(const UINT8*& pData)
  68. {
  69.     DPRINTF(D_TIMEDTEXT, ("C3GPPTextboxBox::Build()n"));
  70.     m_top = ReadUI16(pData);
  71.     m_left = ReadUI16(pData);
  72.     m_bottom = ReadUI16(pData);
  73.     m_right = ReadUI16(pData);
  74.     return HXR_OK;
  75. }
  78. HX_RESULT C3GPPStyleRecord::Build(const UINT8*& pData)
  79. {
  80.     DPRINTF(D_TIMEDTEXT, ("C3GPPStyleRecord::Build()n"));
  81.     m_uiStartCharOffset = ReadUI16(pData);
  82.     m_uiEndCharOffset = ReadUI16(pData);
  83.     m_uiFontID = ReadUI16(pData);
  84.     m_uFaceStyleFlags = *pData++;
  85.     m_uFontSize = *pData++;
  86.     m_textColor = ReadARGB(pData);
  87.     return HXR_OK;
  88. }
  90. HX_RESULT C3GPPFontRecord::Build(const UINT8*& pData)
  91. {
  92.     DPRINTF(D_TIMEDTEXT, ("C3GPPFontRecord::Build()n"));
  93.     m_uiFontID = ReadUI16(pData);
  94.     UINT8 cchFontName = *pData++;
  95.     HX_RESULT hr = m_strFont.Set((const char*)pData, cchFontName);
  96.     if(SUCCEEDED(hr))
  97.     {
  98.         pData += cchFontName;
  99.     }
  101.     return hr;
  102. }
  104. HX_RESULT C3GPPTextHyperTextBox::Build(const UINT8*& pData) 
  105. { 
  106.     DPRINTF(D_TIMEDTEXT, ("C3GPPTextHyperTextBox::Build()n"));
  107.     m_uiStartCharOffset = ReadUI16(pData);
  108.     m_uiEndCharOffset = ReadUI16(pData);
  109.     UINT8 cchURL = *pData++;
  110.  
  111.     HX_RESULT hr = m_strURL.Set((const char*)pData, cchURL);
  112.     if(SUCCEEDED(hr))
  113.     {
  114.         pData += cchURL;
  115.         cchURL = *pData++;
  117.         hr = m_strAltURL.Set((const char*)pData, cchURL);
  118.         if(SUCCEEDED(hr))
  119.         {
  120.             pData += cchURL;
  121.         }
  122.     }
  124.     return hr;
  125. }
  128. HX_RESULT C3GPPTextSampleEntry::Build(const UINT8*& pData)
  129. {
  130.     DPRINTF(D_TIMEDTEXT, ("C3GPPTextSampleEntry::Build()n"));
  131.     HX_RESULT hr = C3GPPArrayEntry::Build(pData);
  132.     if(SUCCEEDED(hr))
  133.     {
  134.         m_ulDisplayFlags = ReadUL32(pData);
  135.         m_horizontalJustification   = *pData++;
  136.         m_verticalJustification     = *pData++;
  137.         m_bgColor = ReadARGB(pData);
  139.         hr = m_defaultTextBox.Build(pData);
  140.         if(SUCCEEDED(hr))
  141.         {
  142.             hr = m_defaultStyle.Build(pData);
  143.             if(SUCCEEDED(hr))
  144.             {
  145.                 hr = m_fontTable.Build(pData);
  146.             }
  147.         }
  148.     }
  150.     return hr;
  151. }
  153. C3GPPTextSampleEntry::C3GPPTextSampleEntry()
  154. : m_ulDisplayFlags(0)
  155. , m_horizontalJustification(0)
  156. , m_verticalJustification(0)
  157. , m_bgColor(0)
  158. {  
  159. }
  163. TextSampleScrollDirection
  164. C3GPPTextSampleEntry::getScrollDirection() const
  165. {
  166.     TextSampleScrollDirection retval = scrollDirNone;
  168.     if (hasScrollIn()  ||  hasScrollOut())
  169.     {
  170.         switch (m_ulDisplayFlags & HX_3GPPTT_DISPLAYFLAGS_SCROLL_DIR_MASK)
  171.         {
  172.             case HX_3GPPTT_DISPLAYFLAGS_SCROLL_DIR_UP:
  173.                 retval = scrollDirUp;
  174.                 break;
  175.             case HX_3GPPTT_DISPLAYFLAGS_SCROLL_DIR_RTOL:
  176.                 retval = scrollDirRightToLeft;
  177.                 break;
  178.             case HX_3GPPTT_DISPLAYFLAGS_SCROLL_DIR_DOWN:
  179.                 retval = scrollDirDown;
  180.                 break;
  181.             case HX_3GPPTT_DISPLAYFLAGS_SCROLL_DIR_LTOR:
  182.                 retval = scrollDirLeftToRight;
  183.                 break;
  184.             default:
  185.                 // /Should be one of the above:
  186.                 HX_ASSERT(m_ulDisplayFlags & HX_3GPPTT_DISPLAYFLAGS_SCROLL_DIR_MASK);
  187.                 retval = scrollDirNone;
  188.                 break;
  189.         }
  190.     }
  192.     return retval;
  193. }
  197. C3GPPTextSampleModifierBox::ModifierType C3GPPTextSampleModifierBox::ReadType(const UINT8*& pData)
  198. {
  199.     const char* pchType = (const char*)pData;
  200.     pData += 4;
  202.     ModifierType type = UNKNOWN;
  204.     if      (!strncmp(pchType, "styl", 4) )
  205.     {
  206.         type = STYL;
  207.     }
  208.     else if (!strncmp(pchType, "hlit", 4) )
  209.     {
  210.         type = HLIT;
  211.     }
  212.     else if (!strncmp(pchType, "hclr", 4) )
  213.     {
  214.         type = HCLR;
  215.     }
  216.     else if (!strncmp(pchType, "krok", 4) )
  217.     {
  218.         type = KROK;
  219.     }
  220.     else if (!strncmp(pchType, "dlay", 4) )
  221.     {
  222.         type = DLAY;
  223.     }
  224.     else if (!strncmp(pchType, "href", 4) )
  225.     {
  226.         type = HREF;
  227.     }
  228.     else if (!strncmp(pchType, "tbox", 4) )
  229.     {
  230.         type = TBOX;
  231.     }
  232.     else if (!strncmp(pchType, "blnk", 4) )
  233.     {
  234.         type = BLNK;
  235.     }
  237.     return type;
  238. }
  240. HX_RESULT C3GPPTextSample::Init(IHXBuffer* pIHXBuff)
  241. {
  242.     HX_ASSERT(pIHXBuff);
  243.     m_pIHXBuff->AddRef();
  245.     const UINT8* pPackedBuff  = m_pIHXBuff->GetBuffer();
  246.     HX_ASSERT(pPackedBuff);
  248.     UINT32 cbSampleTotal = m_pIHXBuff->GetSize();
  249.     m_uiTextLengthInBytes = ReadUI16(pPackedBuff);
  251.     UINT32 cbSampleTextBox = 2 + m_uiTextLengthInBytes; //size field + text
  253.     HX_ASSERT(cbSampleTotal >= cbSampleTextBox);
  254.     if (m_uiTextLengthInBytes && (cbSampleTotal > 2) )
  255.     {
  256.         // /NOTE: The spec says:
  257.         //   "Authors should limit the string in each text sample to not more
  258.         //    than 2048 bytes, for maximum terminal interoperability."
  259.         // and it also says:
  260.         //   "Any unrecognised box found in the text sample should be skipped
  261.         //    and ignored, and processing continue as if it were not there."
  262.         m_pText = (const char*) pPackedBuff;
  264.         
  266.         m_uiTextModifiersTotalSize = UINT16(cbSampleTotal - cbSampleTextBox);
  268.         DPRINTF(D_TIMEDTEXT, ("C3GPPTextSample::Init(): %.*s;n", 200, m_pText));
  270.         if (m_uiTextModifiersTotalSize)
  271.         {
  272.             // text modifiers follow
  273.             m_pTextModifierData = pPackedBuff +  m_uiTextLengthInBytes;
  274.             
  275.         }
  276.     }    
  277.     return HXR_OK;
  278. }
  280. C3GPPTextSample::C3GPPTextSample(IHXBuffer* pIHXBuff) 
  281. : m_pText(NULL)
  282. , m_uiTextLengthInBytes(0)
  283. , m_pTextModifierData(NULL)
  284. , m_uiTextModifiersTotalSize(0)
  285. , m_pIHXBuff(pIHXBuff)
  286. {
  287.     Init(pIHXBuff);
  288. }
  290. HX_RESULT C3GPPTextStyleBox::Build(const UINT8*& pData)
  291. {
  292.     DPRINTF(D_TIMEDTEXT, ("C3GPPTextStyleBox::Build()n"));
  293.     HX_RESULT hr = HXR_OK;
  295.     UINT16 entryCount = ReadUI16(pData);
  296.     HX_ASSERT(m_entries.GetCount() == 0);
  298.     DPRINTF(D_TIMEDTEXT, ("C3GPPTextStyleBox::Build(): %u entriesn", entryCount));
  299.     hr = m_entries.Reset(entryCount);
  300.     if(SUCCEEDED(hr))
  301.     {
  302.         for(UINT16 idx = 0; idx < entryCount; ++idx)
  303.         {
  304.             C3GPPStyleRecord* pEntry = new C3GPPStyleRecord();
  305.             if(!pEntry)
  306.             {
  307.                 return HXR_OUTOFMEMORY;
  308.             }
  310.             hr = pEntry->Build(pData);
  311.             if(FAILED(hr))
  312.             {
  313.                 HX_DELETE(pEntry);
  314.                 break;
  315.             }
  316.             m_entries[idx] = pEntry;
  317.         }
  318.     }
  320.     return hr;
  321. }
  323. C3GPPFontTableBox::~C3GPPFontTableBox()
  324. {
  325.     CleanUp();
  326. }
  328. void C3GPPFontTableBox::CleanUp()
  329. {
  330.     for ( UINT32 idx = 0; idx != m_entries.GetCount(); ++idx )
  331.     {
  332. C3GPPFontRecord*& pEntry = (C3GPPFontRecord*&)(m_entries[idx]);
  333. delete pEntry;
  334.     }
  336.     m_entries.Reset(0);
  337. }
  340. HX_RESULT C3GPPFontTableBox::Build(const UINT8*& pData)
  341. {
  342.     DPRINTF(D_TIMEDTEXT, ("C3GPPFontTableBox::Build()n"));
  343.     HX_RESULT hr = HXR_OK;
  345.     m_ulFontTableSizeInBytes = ReadUL32(pData);
  347.     // skip ftab
  348.     HX_ASSERT(!strncmp((const char*)pData, "ftab", 4));
  349.     pData += 4;
  351.     UINT16 entryCount = ReadUI16(pData);
  352.     HX_ASSERT(m_entries.GetCount() == 0);
  354.     DPRINTF(D_TIMEDTEXT, ("C3GPPFontTableBox::Build(): %u entriesn", entryCount));
  356.     hr = m_entries.Reset(entryCount);
  357.     if(SUCCEEDED(hr))
  358.     {
  359.         for(UINT16 idx = 0; idx < entryCount; ++idx)
  360.         {
  361.             C3GPPFontRecord* pEntry = new C3GPPFontRecord();
  362.             if(!pEntry)
  363.             {
  364.                 return HXR_OUTOFMEMORY;
  365.             }
  367.             hr = pEntry->Build(pData);
  368.             if(FAILED(hr))
  369.             {
  370.                 HX_ASSERT(false);
  371.                 HX_DELETE(pEntry);
  372.                 break;
  373.             }
  374.             HX_ASSERT(0 == m_entries[idx]);
  375.             m_entries[idx] = pEntry;
  376.         }
  377.     }
  379.     return hr;
  380. }
  382. C3GPPTextStyleBox::~C3GPPTextStyleBox()
  383. {
  384.     CleanUp();
  385. }
  387. void C3GPPTextStyleBox::CleanUp()
  388. {
  389.     for ( INT32 idx = 0; idx != m_entries.GetCount(); ++idx )
  390.     {
  391. C3GPPStyleRecord*& pEntry = (C3GPPStyleRecord*&)(m_entries[idx]);
  392. delete pEntry;
  393.     }
  394.     m_entries.Reset(0);
  395. }
  398. HX_RESULT C3GPPTextKaraokeBox::Build(const UINT8*& pData)
  399. {
  400.     DPRINTF(D_TIMEDTEXT, ("C3GPPTextKaraokeBox::Build()n"));
  402.     HX_RESULT hr = HXR_OK;
  404.     m_ul1stHighlightStartTime = ReadUL32(pData);
  405.     UINT16 entryCount = ReadUI16(pData);
  406.     HX_ASSERT(m_entries.GetCount() == 0);
  408.     DPRINTF(D_TIMEDTEXT, ("C3GPPTextKaraokeBox::Build(): %u entriesn", entryCount));
  409.     hr = m_entries.Reset(entryCount);
  410.     if(SUCCEEDED(hr))
  411.     {
  412.         for(UINT16 idx = 0; idx < entryCount; ++idx)
  413.         {
  414.             C3GPPTextKaraokeControlEntry* pEntry = new C3GPPTextKaraokeControlEntry();
  415.             if(!pEntry)
  416.             {
  417.                 return HXR_OUTOFMEMORY;
  418.             }
  420.             hr = pEntry->Build(pData);
  421.             if(FAILED(hr))
  422.             {
  423.                 HX_ASSERT(false);
  424.                 HX_DELETE(pEntry);
  425.                 break;
  426.             }
  427.             m_entries[idx] = pEntry;
  428.         }
  429.     }
  431.     return hr;
  432. }
  434. C3GPPTextKaraokeBox::~C3GPPTextKaraokeBox()
  435. {
  436.     CleanUp();
  437. }
  439. void C3GPPTextKaraokeBox::CleanUp()
  440. {
  441.     for ( INT32 idx = 0; idx != m_entries.GetCount(); ++idx )
  442.     {
  443. C3GPPTextKaraokeControlEntry*& pEntry = (C3GPPTextKaraokeControlEntry*&)(m_entries[idx]);
  444. delete pEntry;
  445.     }
  446.     m_entries.Reset(0);
  447. }
  449. HX_RESULT C3GPPTextKaraokeBox::C3GPPTextKaraokeControlEntry::Build(const UINT8*& pData)
  450. {
  451.     m_ulHighlightEndTime = ReadUL32(pData);
  452.     m_uiStartCharOffset = ReadUI16(pData); 
  453.     m_uiEndCharOffset = ReadUI16(pData);
  454.     return HXR_OK;
  455. }
  457. HX_RESULT C3GPPTextContainer::BuildKROK(const UINT8*& pData, 
  458.                                         UINT16& uiLowestPotentialNextTCStartOffsetFound,
  459.                                         BOOL& bNeedToBreakTCsUpAtNewlines,
  460.                                         UINT16& curEndCharOffset)
  461. {
  462.     DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildKROK()n"));
  463.     HX_ASSERT(!m_pTextKaraokeBox);
  464.  
  465.     m_pTextKaraokeBox = new C3GPPTextKaraokeBox();
  466.     if(!m_pTextKaraokeBox)
  467.     {
  468.         return HXR_OUTOFMEMORY;
  469.     }
  471.     HX_RESULT hr = m_pTextKaraokeBox->Build(pData);
  472.     if(SUCCEEDED(hr))
  473.     {
  474.         BOOL bAssignBoxToCurrent = FALSE;
  475.         m_uiTextKaraokeBoxIndex = HX_3GPPTT_INVALID_INDEX;
  476.         // /Go through the array of C3GPPTextKaraokeControlEntry(s)
  477.         // & look at their m_uiStartCharOffset & m_uiEndCharOffset.
  478.         // If all are fully before or fully after, ignore the
  479.         // whole enchilada:
  481.         UINT16 uiEntryCount = m_pTextKaraokeBox->GetEntryCount();
  482.         DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildKROK(): %u entriesn", uiEntryCount));
  483.         for (UINT16 uiCurEntry = 0; uiCurEntry < uiEntryCount; uiCurEntry++)
  484.         {
  485.             const C3GPPTextKaraokeBox::C3GPPTextKaraokeControlEntry*
  486.                     pCurKaraokeCtrlEntry =
  487.                     m_pTextKaraokeBox->GetKaraokeControlEntry(uiCurEntry);
  488.             HX_ASSERT(pCurKaraokeCtrlEntry);
  489.             if (pCurKaraokeCtrlEntry)
  490.             {
  491.                 UINT16 uiCurStartCharOffset =
  492.                         pCurKaraokeCtrlEntry->GetStartOffset();
  493.                 curEndCharOffset =
  494.                         pCurKaraokeCtrlEntry->GetEndOffset();
  495.                 DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildKROK(): range %u, %un", uiCurStartCharOffset, curEndCharOffset));
  496.                 if (HXR_OK != UpdateLowestPotentialNextTCStartOffset(
  497.                         uiCurStartCharOffset, curEndCharOffset,
  498.                         /*REF IN/OUT */ uiLowestPotentialNextTCStartOffsetFound,
  499.                         /*REF OUT*/ bAssignBoxToCurrent) )
  500.                 {
  501.                     DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildKROK(): discarding entry %u n", uiCurEntry));
  502.                     continue; // /Ignore this entry; bad data.
  503.                 }
  504.                 if (bAssignBoxToCurrent)
  505.                 {
  506.                     m_uiTextKaraokeBoxIndex = uiCurEntry;
  507.                     break;
  508.                 }
  509.             }
  510.         }
  511.         if (HX_3GPPTT_INVALID_INDEX == m_uiTextKaraokeBoxIndex)
  512.         {
  513.             // /All Karaoke control entries are before or after,
  514.             // so ignore this entire karaoke modifier:
  515.             HX_DELETE(m_pTextKaraokeBox);
  516.         }
  517.         bNeedToBreakTCsUpAtNewlines = TRUE;
  519.     }
  520.     else
  521.     {
  522.         HX_ASSERT(false);
  523.         HX_DELETE(m_pTextKaraokeBox);
  524.     }
  527.     return hr;
  528. }
  531. HX_RESULT C3GPPTextContainer::BuildDLAY(const UINT8*& pData)
  532. {        
  533.     DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildDLAY()n"));
  534.     HX_ASSERT(!m_pTextScrollDelayBox);
  536.     m_pTextScrollDelayBox = new C3GPPTextScrollDelayBox();
  537.     if(!m_pTextScrollDelayBox)
  538.     {
  539.         return HXR_OUTOFMEMORY;
  540.     }
  542.     HX_RESULT hr = m_pTextScrollDelayBox->Build(pData);
  543.     if(FAILED(hr))
  544.     {
  545.         HX_ASSERT(false);
  546.         HX_DELETE(m_pTextScrollDelayBox);
  547.     }
  548.     return hr;
  549.     
  550. }
  552. HX_RESULT C3GPPTextContainer::BuildHCLR(const UINT8*& pData)
  553. {        
  554.     DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildHCLR()n"));
  555.     HX_ASSERT(!m_pTextHilightColorBox);
  557.     m_pTextHilightColorBox = new C3GPPTextHilightColorBox();
  558.     if(!m_pTextHilightColorBox)
  559.     {
  560.         return HXR_OUTOFMEMORY;
  561.     }
  563.     HX_RESULT hr = m_pTextHilightColorBox->Build(pData);
  564.     if(FAILED(hr))
  565.     {
  566.         HX_ASSERT(false);
  567.         HX_DELETE(m_pTextHilightColorBox);
  568.     }
  569.     return hr;
  570. }
  572. HX_RESULT C3GPPTextContainer::BuildTBOX(const UINT8*& pData)
  573. {        
  574.     DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildTBOX(): text boxn"));
  575.     HX_ASSERT(!m_pTextboxBox);
  577.     m_pTextboxBox = new C3GPPTextboxBox();
  578.     if(!m_pTextboxBox)
  579.     {
  580.         return HXR_OUTOFMEMORY;
  581.     }
  583.     HX_RESULT hr = m_pTextboxBox->Build(pData);
  584.     if(FAILED(hr))
  585.     {
  586.         HX_ASSERT(false);
  587.         HX_DELETE(m_pTextboxBox);
  588.     }
  589.     return hr;
  590. }
  591.   
  592. HX_RESULT C3GPPTextContainer::BuildHLIT(const UINT8*& pData, 
  593.                                         UINT16& uiLowestPotentialNextTCStartOffsetFound,
  594.                                         BOOL& bNeedToBreakTCsUpAtNewlines,
  595.                                         UINT16& curEndCharOffset)
  596. {
  597.     DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildHLIT()n"));
  598.     HX_ASSERT(!m_pTextHighlightBox);
  599.  
  600.     m_pTextHighlightBox = new C3GPPTextHighlightBox();
  601.     if(!m_pTextHighlightBox)
  602.     {
  603.         return HXR_OUTOFMEMORY;
  604.     }
  606.     HX_RESULT hr = m_pTextHighlightBox->Build(pData);
  607.     if(SUCCEEDED(hr))
  608.     {
  609.         BOOL bAssignBoxToCurrent = FALSE;
  610.         UINT16 uiCurStartCharOffset = m_pTextHighlightBox->GetStartOffset();
  611.         curEndCharOffset = m_pTextHighlightBox->GetEndOffset();
  613.         DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildHLIT(): range %u, %un", uiCurStartCharOffset, curEndCharOffset));
  615.         // /If data is bad or if this is out of range, then
  616.         // this hlit box is not this's modifier:
  617.         if (HXR_OK != UpdateLowestPotentialNextTCStartOffset(
  618.                 uiCurStartCharOffset, curEndCharOffset,
  619.                 /*REF IN/OUT */ uiLowestPotentialNextTCStartOffsetFound,
  620.                 /*REF OUT*/ bAssignBoxToCurrent)
  621.                 // /FALSE means this is out of box's range:
  622.                 || !bAssignBoxToCurrent)
  623.         {
  624.             DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildHLIT(): discardingn"));
  625.             HX_DELETE(m_pTextHighlightBox);
  626.         }
  627.         
  628.         bNeedToBreakTCsUpAtNewlines = TRUE;
  629.     }
  630.     else
  631.     {
  632.         HX_ASSERT(false);
  633.         HX_DELETE(m_pTextBlinkBox);
  634.     }
  636.     return hr;
  637. }
  641. HX_RESULT C3GPPTextContainer::BuildHREF(const UINT8*& pData, 
  642.                                         UINT16& uiLowestPotentialNextTCStartOffsetFound,
  643.                                         BOOL& bNeedToBreakTCsUpAtNewlines,
  644.                                         UINT16& curEndCharOffset)
  645. {
  646.     DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildHREF()n"));
  647.     HX_ASSERT(!m_pTextHyperTextBox);
  649.     m_pTextHyperTextBox = new C3GPPTextHyperTextBox();
  650.     if(!m_pTextHyperTextBox)
  651.     {
  652.         return HXR_OUTOFMEMORY;
  653.     }
  655.     HX_RESULT hr = m_pTextHyperTextBox->Build(pData);
  656.     if(SUCCEEDED(hr))
  657.     {
  658.         BOOL bAssignBoxToCurrent = FALSE;
  659.         UINT16 uiCurStartCharOffset = m_pTextHyperTextBox->GetStartOffset();
  660.         curEndCharOffset = m_pTextHyperTextBox->GetEndOffset();
  661.             
  662.         DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildHREF(): range %u, %un", uiCurStartCharOffset, curEndCharOffset));
  664.         // /If data is bad or if this is out of range, then
  665.         // this hlit box is not this's modifier:
  666.         if (HXR_OK != UpdateLowestPotentialNextTCStartOffset(
  667.                 uiCurStartCharOffset, curEndCharOffset,
  668.                 /*REF IN/OUT */ uiLowestPotentialNextTCStartOffsetFound,
  669.                 /*REF OUT */ bAssignBoxToCurrent)
  670.                 // /FALSE means this is out of box's range:
  671.                 || !bAssignBoxToCurrent)
  672.         {
  673.             DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildHREF(): discardingn"));
  674.             HX_DELETE(m_pTextHyperTextBox);
  675.         }
  676.         
  677.         bNeedToBreakTCsUpAtNewlines = TRUE;
  678.     }
  679.     else
  680.     {
  681.         HX_ASSERT(false);
  682.         HX_DELETE(m_pTextHyperTextBox);
  683.     }
  685.     return hr;
  686. }
  689. HX_RESULT C3GPPTextContainer::BuildBLNK(const UINT8*& pData, 
  690.                                         UINT16& uiLowestPotentialNextTCStartOffsetFound,
  691.                                         BOOL& bNeedToBreakTCsUpAtNewlines,
  692.                                         UINT16& curEndCharOffset)
  694. {
  695.     DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildBLNK()n"));
  696.     HX_ASSERT(!m_pTextBlinkBox);
  698.     m_pTextBlinkBox = new C3GPPTextBlinkBox();
  699.     if(!m_pTextBlinkBox)
  700.     {
  701.         return HXR_OUTOFMEMORY;
  702.     }
  704.     HX_RESULT hr = m_pTextBlinkBox->Build(pData);
  705.     if(SUCCEEDED(hr))
  706.     {
  707.         BOOL bAssignBoxToCurrent = FALSE;
  708.         UINT16 uiCurStartCharOffset = m_pTextBlinkBox->GetStartOffset();
  709.         curEndCharOffset = m_pTextBlinkBox->GetEndOffset();
  711.         DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildBLNK(): range %u, %un", uiCurStartCharOffset, curEndCharOffset));
  713.         // /If data is bad or if this is out of range, then
  714.         // this hlit box is not this's modifier:
  715.         if (HXR_OK != UpdateLowestPotentialNextTCStartOffset(
  716.                 uiCurStartCharOffset, curEndCharOffset,
  717.                 /*REF IN/OUT */ uiLowestPotentialNextTCStartOffsetFound,
  718.                 /*REF OUT */ bAssignBoxToCurrent)
  719.                 // /FALSE means this is out of box's range:
  720.                 || !bAssignBoxToCurrent)
  721.         {
  722.             DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildBLNK(): discardingn"));
  723.             HX_DELETE(m_pTextBlinkBox);
  724.         }
  725.         
  726.         bNeedToBreakTCsUpAtNewlines = TRUE;
  727.     }
  728.     else
  729.     {
  730.         HX_ASSERT(false);
  731.         HX_DELETE(m_pTextBlinkBox);
  732.     }
  734.     return hr;
  735. }
  737. HX_RESULT C3GPPTextContainer::BuildSTYL(const UINT8*& pData, 
  738.                                         UINT16& uiLowestPotentialNextTCStartOffsetFound,
  739.                                         BOOL& bNeedToBreakTCsUpAtNewlines,
  740.                                         UINT16& curEndCharOffset)
  741. {
  742.     DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildSTYL()n"));
  743.     HX_ASSERT(!m_pTextStyleBox);
  745.     m_pTextStyleBox = new C3GPPTextStyleBox();
  746.     if(!m_pTextStyleBox)
  747.     {
  748.         return HXR_OUTOFMEMORY;
  749.     }
  751.     HX_RESULT hr = m_pTextStyleBox->Build(pData);
  752.     if(SUCCEEDED(hr))
  753.     {
  754.         BOOL bAssignBoxToCurrent = FALSE;
  755.         m_uiTextStyleBoxIndex = HX_3GPPTT_INVALID_INDEX;
  757.         // /Go through the array of C3GPPStyleRecords and look
  758.         // at their m_uiStartCharOffset and m_uiEndCharOffset.
  759.         // If all are fully before or fully after, ignore the
  760.         // whole shebang:
  761.         UINT16 uiEntryCount = m_pTextStyleBox->GetEntryCount();
  762.         DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildSTYL(): %u entriesn", uiEntryCount));
  764.         for (UINT16 uiCurEntry = 0; uiCurEntry < uiEntryCount; uiCurEntry++)
  765.         {
  766.             const C3GPPStyleRecord* pCurStyleRecord =
  767.                     m_pTextStyleBox->GetStyleRecord(uiCurEntry);
  768.             HX_ASSERT(pCurStyleRecord);
  769.             if (pCurStyleRecord)
  770.             {
  771.                 UINT16 uiCurStartCharOffset = pCurStyleRecord->GetStartOffset();
  772.                 curEndCharOffset = pCurStyleRecord->GetEndOffset();
  774.                 DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildSTYL(): [entry %u] range %u, %un", uiCurEntry, uiCurStartCharOffset, curEndCharOffset));
  777.                 if (HXR_OK != UpdateLowestPotentialNextTCStartOffset(
  778.                         uiCurStartCharOffset, curEndCharOffset,
  779.                         /*REF IN/OUT */ uiLowestPotentialNextTCStartOffsetFound,
  780.                         /*REF OUT*/ bAssignBoxToCurrent) )
  781.                 {
  782.                     // ignore, bad data
  783.                     DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildSTYL(): discardingn"));
  784.                     continue;
  785.                 }
  786.                 if (bAssignBoxToCurrent)
  787.                 {
  788.                     m_uiTextStyleBoxIndex = uiCurEntry;
  789.                     break;
  790.                 }
  791.             }
  792.         }
  793.      
  794.     
  795.         if (HX_3GPPTT_INVALID_INDEX == m_uiTextStyleBoxIndex)
  796.         {
  797.             // /All style records are before or after, so
  798.             // ignore entire style modifier:
  799.             HX_DELETE(m_pTextStyleBox);
  800.         }
  801.         bNeedToBreakTCsUpAtNewlines = TRUE;
  802.     }
  803.     else
  804.     {
  805.         HX_ASSERT(false);
  806.         HX_DELETE(m_pTextStyleBox);
  807.     }
  810.     return hr;
  811. }
  813. HX_RESULT C3GPPTextContainer::BuildSampleModifiers(BOOL& bNeedToBreakTCsUpAtNewlines)
  814. {
  815.     DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildSampleModifiers()n"));
  817.     bNeedToBreakTCsUpAtNewlines = FALSE;
  819.     HX_ASSERT(m_pTextSample);
  820.     if (!m_pTextSample->GetModifierData())
  821.     {
  822.         // no modifiers; no work to do
  823.         DPRINTF(D_TIMEDTEXT, ("C3GPPTextContainer::BuildSampleModifiers(): no sample modifiersn"));
  825.         return HXR_OK;
  826.     }
  827.             
  828.     HX_RESULT hr = HXR_OK;
  830.     // /Walk the sampleModifier array and find the next start-
  831.     // index boundary that is greater than m_uiStartCharOffset;
  832.     // What we find, if any, is 1 + our end index:
  833.     UINT16 uiLowestPotentialNextTCStartOffsetFound =
  834.             HX_3GPPTT_MAX_CHAR_OFFSET;
  836.     UINT16 curEndCharOffset = HX_3GPPTT_INVALID_INDEX;
  837.     
  838.     const UINT8* pData = m_pTextSample->GetModifierData();
  839.     HX_ASSERT(m_pTextSample->GetModifierDataSize() > 0);
  840.     const UINT8* pDataEnd = pData + m_pTextSample->GetModifierDataSize();
  842.     while (pData < pDataEnd)
  843.     {
  844.         // get sample modifier type and size
  845.         C3GPPTextSampleModifierBox box;
  846.         
  847.         hr = box.Build(pData);
  848.         HX_ASSERT(HXR_OK == hr);
  850.         if(pData + box.GetDataSize() > pDataEnd)
  851.         {
  852.             HX_ASSERT(false);
  853.             hr = HXR_FAIL;
  854.             break;
  855.         }
  857.         // create sample modifier object for this modifier type
  858.         switch(box.GetType())
  859.         {
  860.         case C3GPPTextSampleModifierBox::STYL:
  861.             hr = BuildSTYL(pData, 
  862.                 uiLowestPotentialNextTCStartOffsetFound, 
  863.                 bNeedToBreakTCsUpAtNewlines, curEndCharOffset);
  864.             break;
  865.         case C3GPPTextSampleModifierBox::HLIT:
  866.              hr = BuildHLIT(pData, 
  867.                 uiLowestPotentialNextTCStartOffsetFound, 
  868.                 bNeedToBreakTCsUpAtNewlines, curEndCharOffset);
  869.             break;
  870.         case C3GPPTextSampleModifierBox::HCLR:
  871.             hr = BuildHCLR(pData);
  872.             break;
  873.         case C3GPPTextSampleModifierBox::KROK:
  874.             hr = BuildKROK(pData, 
  875.                 uiLowestPotentialNextTCStartOffsetFound, 
  876.                 bNeedToBreakTCsUpAtNewlines, curEndCharOffset);
  877.             break;
  878.         case C3GPPTextSampleModifierBox::DLAY:
  879.             hr = BuildDLAY(pData);
  880.             break;
  881.         case C3GPPTextSampleModifierBox::HREF:
  882.             hr = BuildHREF(pData, 
  883.                 uiLowestPotentialNextTCStartOffsetFound,
  884.                 bNeedToBreakTCsUpAtNewlines, curEndCharOffset);
  885.             break;
  886.         case C3GPPTextSampleModifierBox::TBOX:
  887.             hr = BuildTBOX(pData);
  888.             break;
  889.         case C3GPPTextSampleModifierBox::BLNK:
  890.             hr = BuildBLNK(pData, 
  891.                 uiLowestPotentialNextTCStartOffsetFound, 
  892.                 bNeedToBreakTCsUpAtNewlines, curEndCharOffset);
  893.             break;
  894.         default:
  895.             HX_ASSERT(false); //XXXLCM skip unknown types?
  896.             hr = HXR_FAIL;
  897.             break;
  898.         }
  900.         if(FAILED(hr))
  901.         {
  902.             HX_ASSERT(false);
  903.             break;
  904.         }
  906.        
  907.         // we should consume the box data size exactly
  908.         HX_ASSERT( UINT32(pData - box.GetData()) == box.GetDataSize());
  910.         // /If we found one, then use it if it's lowest so far:
  911.         if (curEndCharOffset <
  912.                 uiLowestPotentialNextTCStartOffsetFound  &&
  913.                 // /Ignore if end is prior to our start:
  914.                 // /(Changed '>=' to '>' to prevent infinite loop)
  915.                 curEndCharOffset > m_uiUnpackedStartCharOffset)
  916.         {
  917.             uiLowestPotentialNextTCStartOffsetFound =
  918.                     curEndCharOffset;
  919.         }
  920.     }
  922.     if(SUCCEEDED(hr))
  923.     {
  924.         // we should always end up exactly at end of data
  925.         HX_ASSERT(pData == pDataEnd);
  927.         // /OK, our end char offset is one less than the lowest start
  928.         // of the next T.C. found, above, (& not less than our start):
  929.         HX_ASSERT(uiLowestPotentialNextTCStartOffsetFound > 0);
  930.         if (HX_3GPPTT_MAX_CHAR_OFFSET !=
  931.                 uiLowestPotentialNextTCStartOffsetFound)
  932.         {
  933.             // /Don't add 1 here; it's end-point exclusive:
  934.             m_uiUnpackedEndCharOffset = uiLowestPotentialNextTCStartOffsetFound;
  935.         }
  936.         else
  937.         {
  938.             m_uiUnpackedEndCharOffset = HX_3GPPTT_MAX_CHAR_OFFSET;
  939.         }
  940.     }
  942.     return hr;
  943.             
  944. }
  946. HX_RESULT C3GPPTextContainer::Init
  947. (
  948.     IHXPacket* pPacket,
  949.     UINT32 ulPacketContentsBeginTime,
  950.     UINT32 ulMaxEndTime,
  951.     UINT16 uiStartCharOffset, 
  952.     /*OUT*/ UINT16& uiREFIndexOfLastChar)
  953. {
  954.     HX_RESULT hxr = HXR_OK;
  956.     HX_ASSERT(pPacket);
  957.     m_pPacket = pPacket;
  958.     m_pPacket->AddRef();
  959.     m_ulEndTime = ulMaxEndTime; // /Initialize for now to this
  960.     m_ulBeginTime = ulPacketContentsBeginTime;
  961.     m_uiUnpackedStartCharOffset = uiStartCharOffset;
  963.     uiREFIndexOfLastChar = HX_3GPPTT_INVALID_INDEX;
  965.     BOOL bNeedToBreakTCsUpAtNewlines = FALSE;
  967.     
  969.     // /Go through the textModifiers of the packet and figure out what our
  970.     // end index is in the text buffer based on where the end of same-
  971.     // attributed continguous text ends.  Return the end index in
  972.     // uiREFIndexOfLastChar so, if there's any text remaining, another
  973.     // C3GPPTextContainer can be created knowing where to start:
  974. //-----------------------------------------------------------------------------
  975.     IHXBuffer* pBuff = m_pPacket->GetBuffer();
  976.     if (pBuff)
  977.     {
  978.         BOOL bTextIsUTF16ReverseEncoded = FALSE;
  979.         BOOL bTextIsUTF16Encoded = FALSE;
  981.         m_pTextSample = new C3GPPTextSample(pBuff);
  982.         HX_ASSERT(m_pTextSample);
  983.         if (!m_pTextSample)
  984.         {
  985.             hxr = HXR_OUTOFMEMORY;
  986.             goto cleanup;
  987.         }
  989.         bTextIsUTF16Encoded = IsUTF16Encoded(
  990.                 (UCHAR*)(m_pTextSample->GetText()),
  991.                 m_pTextSample->GetTextLenInBytes(),
  992.                 bTextIsUTF16ReverseEncoded);
  994.         hxr = BuildSampleModifiers(bNeedToBreakTCsUpAtNewlines);
  995.         if(FAILED(hxr))
  996.         {
  997.             goto cleanup;
  998.         }
  1001.         // /XXXEH- TODO: this is not UTF-8 friendly code (when 2-byte
  1002.         // 00r or 00n chars are present)!  Also, r or n may be 2nd
  1003.         // byte of a 2-byte value and not meant as a newline (CR or LF,
  1004.         // respectively) char!
  1005.         // /Before patting ourselves on the back for finding the start &
  1006.         // end offsets of this text container, we need to look for
  1007.         // newline characters and break up TC's at each new-line
  1008.         // character, but only if m_pTextSample->m_pTextModifiers exists
  1009.         // and modified individual parts of the text and not just the
  1010.         // entire thing, e.g., as 'tbox' does.  Otherwise it's OK to
  1011.         // leave entire packet's text as one TextContainer even if it
  1012.         // has newline chars:
  1014.         // /Note: these are the supported UNICODE text wrap controls:
  1015.         //  u000a (LF)
  1016.         //  u000d (CR)
  1017.         //  u000du000a (CRLF)
  1018.         //  u0085 (NEXT LINE)
  1019.         //  u2028 (LINE SEP)
  1020.         //  u2029 (PARA SEP)
  1022. #if defined(_SYMBIAN) // /                                                     -----vvvvvvvvvvvvvvvvvvvvvvvvvv-----
  1023.         // /Convert to UTF-16 then go through and start a new
  1024.         // TextContainer wherever a newline char is found that
  1025.         // does not immediately follow another newline:
  1026.         HX_RESULT hxrsltCnvrtChars = HXR_OK;
  1027.         HBufC16* pHBufUTF16Text = NULL;
  1028.         HBufC8*  pHBufUTF8Text = NULL;
  1029.         const char* pUnconvertedText = m_pTextSample->GetText() + m_uiUnpackedStartCharOffset;
  1030.         INT32 lUnconvertedTextLen = (INT32)
  1031.                 ((UINT32)GetTextByteLength());
  1032.         HX_ASSERT(m_uiUnpackedEndCharOffset >= (UINT32)lUnconvertedTextLen);
  1034.         BOOL bDummyVar = FALSE;
  1035.         BOOL bTextContainerTextStartsWithUTF16EncodeFlag =
  1036.                 IsUTF16Encoded((UCHAR*)pUnconvertedText,
  1037.                 lUnconvertedTextLen,
  1038.                 bDummyVar);
  1039.         INT32 lTextLenInChars = lUnconvertedTextLen;
  1040.         if (bTextIsUTF16Encoded)
  1041.         {
  1042.             HX_ASSERT(!(lTextLenInChars & 0x1)); // /Shouldn't be odd
  1043.             lTextLenInChars >>= 1; // /Divide by 2: 2 bytes/char
  1044.             if (bTextContainerTextStartsWithUTF16EncodeFlag)
  1045.             {
  1046.                 // /Skip past 0xfffe UTF-16 flag at start:
  1047.                 pUnconvertedText += 2;
  1048.                 lTextLenInChars--;
  1049.             }
  1050.         }
  1051.         if (hxrsltCnvrtChars==HXR_OK  &&  pUnconvertedText  &&
  1052.                 lUnconvertedTextLen > 0)
  1053.         {
  1054.             pHBufUTF16Text = HBufC16::NewMax((TInt)lTextLenInChars);
  1055.             if (pHBufUTF16Text)
  1056.             {
  1057.                 TInt tiNumLinesOfText = 1;
  1058.                 // /UTF-8 to UTF-16 translation:
  1059.                 if (bTextIsUTF16Encoded)
  1060.                 {
  1061.                     TInt leadByteOffset = 0;
  1062.                     TInt trailingByteOffset = 1;
  1063.                     if (bTextIsUTF16ReverseEncoded)
  1064.                     {
  1065.                         leadByteOffset = 1;
  1066.                         trailingByteOffset = 0;
  1067.                     }
  1068.                     for (TInt i = 0; i < (TInt)lTextLenInChars ; i++)
  1069.                     {
  1070.                         pHBufUTF16Text->Des()[i] =
  1071.                                 ((UINT16)(pUnconvertedText[
  1072.                                     (i*2)+leadByteOffset])) <<8 |
  1073.                                 pUnconvertedText[
  1074.                                     (i*2)+trailingByteOffset];
  1075.                     }
  1076.                 }
  1077.                 else
  1078.                 {
  1079.                     pHBufUTF8Text = HBufC8::NewMax((TInt)lTextLenInChars);
  1080.                     for (TInt i = 0; i < (TInt)lTextLenInChars ; i++) 
  1081.                     {
  1082.                         pHBufUTF8Text->Des()[i] =
  1083.                                 (UINT8)(pUnconvertedText[i]);
  1084.                     }
  1085.                     TInt kErr =
  1086.                             CnvUtfConverter::ConvertToUnicodeFromUtf8(
  1087.                             pHBufUTF16Text->Des(),
  1088.                             pHBufUTF8Text->Des() );
  1090.                     delete pHBufUTF8Text;
  1091.                 }
  1093.                 // /Now step through UTF-16 chars in pHBufUTF16Text:
  1094.                 const TInt iStrLen16 = pHBufUTF16Text->Length();
  1095.                 HX_ASSERT(iStrLen16);
  1096.                 if (iStrLen16)
  1097.                 {
  1098.                     TInt tiChars = 0;
  1099.                     TInt tiNewlines = 0;
  1100.                     UINT16 ch16 =
  1101.                             pHBufUTF16Text->Des()[tiChars];
  1102.                     BOOL bPriorCharWasCarriageReturn = FALSE;
  1103.                     BOOL bCurCharIsCarriageReturn = FALSE;
  1104.                     BOOL bCurCharIsAtomicNewline = FALSE;
  1105.                     // /First, skip newline chars at the start:
  1106.                     while (tiChars < iStrLen16  &&
  1107.                             isUTF16NewlineChar(ch16,
  1108.                             bPriorCharWasCarriageReturn,
  1109.                             /*REF*/ bCurCharIsCarriageReturn,
  1110.                             /*REF*/ bCurCharIsAtomicNewline) )
  1111.                     {
  1112.                         tiChars++;
  1113.                         // /If it's not LF of CRLF, then ++ newlines:
  1114.                         if (bCurCharIsAtomicNewline)
  1115.                         {
  1116.                             tiNewlines++;
  1117.                         }
  1118.                         if (tiChars >= iStrLen16)
  1119.                         {
  1120.                             break;
  1121.                         }
  1122.                         ch16 = pHBufUTF16Text->Des()[tiChars];
  1123.                         bPriorCharWasCarriageReturn =
  1124.                                 bCurCharIsCarriageReturn;
  1125.                     }
  1127.                     m_lNumUTF16NewlinesAtStart = (INT16)tiNewlines;
  1128.                     m_lNumUTF16NewlineCharsAtStart = (INT16)tiChars;
  1130.                     // /Next, find any newline chars in the middle:
  1131.                     bPriorCharWasCarriageReturn = FALSE;
  1132.                     while (tiChars < iStrLen16)
  1133.                     {
  1134.                         ch16 = pHBufUTF16Text->Des()[tiChars];
  1135.                         if (isUTF16NewlineChar(ch16,
  1136.                                 bPriorCharWasCarriageReturn,
  1137.                                 /*REF*/ bCurCharIsCarriageReturn,
  1138.                                 /*REF*/ bCurCharIsAtomicNewline))
  1139.                         {
  1140.                             // /Start a new TextContainer at this
  1141.                             // newline char:
  1142.                             m_uiUnpackedEndCharOffset = tiChars +
  1143.                                     // /Add offset to get it back into
  1144.                                     // proper coords:
  1145.                                     m_uiUnpackedStartCharOffset;
  1146.                             break;
  1147.                         }
  1148.                         bPriorCharWasCarriageReturn =
  1149.                                 bCurCharIsCarriageReturn;
  1150.                         tiChars++;
  1151.                     }
  1153.                 }
  1154.             }
  1155.         }
  1156. #else  // / else not _SYMBIAN                                                  ------------------------------------
  1157.         if (bNeedToBreakTCsUpAtNewlines)
  1158.         {
  1159.             const char* pTextOfThis = m_pTextSample->GetText() + m_uiUnpackedStartCharOffset;
  1160.             HX_ASSERT(pTextOfThis); // /Asserted? notify ehodge@real.com w/.3gp content
  1161.             if (pTextOfThis)
  1162.             {
  1163.                 UINT16 uiLen = GetTextByteLength();
  1164. #pragma message("&&&& XXXEH- 20031027- check for UTF8 or UTF16; if 16, step by 2's. If 8... &&&&")
  1165.                 BOOL bIsReverseUTF16 = FALSE;
  1166.                 BOOL bIsUTF16 = IsUTF16Encoded(pTextOfThis,
  1167.                         (INT32)uiLen, bIsReverseUTF16);
  1168.                 const UCHAR* pStepper = pTextOfThis;
  1169.                 // /First, skip newline chars at the start:
  1170.                 while (('r' == *pStepper  ||  'n' == *pStepper)  &&
  1171.                         pStepper < pTextOfThis + uiLen)
  1172.                 {
  1173.                     pStepper++;
  1174.                 }
  1175.                 // /Next, find any newline chars in the middle:
  1176.                 do
  1177.                 {
  1178.                     if ('r' == *pStepper  ||  'n' == *pStepper)
  1179.                     {
  1180.                         // /Start a new TextContainer at this newline char:
  1181.                         m_uiUnpackedEndCharOffset = pStepper - pTextOfThis +
  1182.                                 // /Need offset to get back into proper coords:
  1183.                                 m_uiUnpackedStartCharOffset;
  1184.                         break;
  1185.                     }
  1186.                 } while (++pStepper < pTextOfThis + uiLen);
  1187.             }
  1188.         }
  1189. #endif // /if _SYMBIAN else...                                                 _____^^^^^^^^^^^^^^^^^^^^^^^^^^_____
  1190.     }
  1191. //-----------------------------------------------------------------------------
  1192.     
  1194. cleanup:
  1196.     uiREFIndexOfLastChar = m_uiUnpackedEndCharOffset;
  1198.     return hxr;
  1199. }
  1202. C3GPPTextContainer::C3GPPTextContainer() 
  1203. : m_pPacket(NULL)
  1204. , m_pTextSample(NULL)
  1205. , m_uiUnpackedStartCharOffset(HX_3GPPTT_INVALID_INDEX)
  1206. , m_uiUnpackedEndCharOffset(HX_3GPPTT_INVALID_INDEX)
  1207. , m_uiTextStyleBoxIndex(HX_3GPPTT_INVALID_INDEX)
  1208. , m_uiTextKaraokeBoxIndex(HX_3GPPTT_INVALID_INDEX)
  1209. , m_pTextStyleBox(NULL)
  1210. , m_pTextHighlightBox(NULL)
  1211. , m_pTextHilightColorBox(NULL)
  1212. , m_pTextKaraokeBox(NULL)
  1213. , m_pTextScrollDelayBox(NULL)
  1214. , m_pTextHyperTextBox(NULL)
  1215. , m_pTextboxBox(NULL)
  1216. , m_pTextBlinkBox(NULL)
  1217. , m_ulBeginTime(HX_3GPPTT_INVALID_TIME)
  1218. , m_ulEndTime(HX_3GPPTT_INVALID_TIME) 
  1219. , m_ulNextDrawUpdateTimeOffset(0)
  1220. , m_ulPrevDrawUpdateTimeOffset(HX_3GPPTT_INVALID_TIME)
  1221. , m_lNumUTF16NewlineCharsAtStart(HX_3GPPTT_INVALID_INT16)
  1222. , m_lNumUTF16NewlinesAtStart(HX_3GPPTT_INVALID_INT16)
  1223. {
  1224.     m_BoundingRectOfInitialDraw.left = m_BoundingRectOfInitialDraw.right = 0;
  1225.     m_BoundingRectOfInitialDraw.top = m_BoundingRectOfInitialDraw.bottom = 0;
  1227.     
  1228. }
  1230. C3GPPTextContainer::~C3GPPTextContainer()
  1231. {
  1232.     HX_RELEASE(m_pPacket);
  1233.     HX_DELETE(m_pTextSample);
  1234.     HX_DELETE(m_pTextStyleBox);
  1235.     HX_DELETE(m_pTextHighlightBox);
  1236.     HX_DELETE(m_pTextHilightColorBox);
  1237.     HX_DELETE(m_pTextKaraokeBox);
  1238.     HX_DELETE(m_pTextScrollDelayBox);
  1239.     HX_DELETE(m_pTextHyperTextBox);
  1240.     HX_DELETE(m_pTextboxBox);
  1241.     HX_DELETE(m_pTextBlinkBox);
  1242. }
  1245. BOOL
  1246. C3GPPTextContainer::ContainsPoint(INT16 iX, INT16 iY) const
  1247. {
  1248.     return (   iX >= m_BoundingRectOfInitialDraw.left   &&
  1249.            iX <= m_BoundingRectOfInitialDraw.right  &&
  1250.            iY >= m_BoundingRectOfInitialDraw.top    &&
  1251.            iY <= m_BoundingRectOfInitialDraw.bottom);
  1252. }
  1255. HX_RESULT
  1256. C3GPPTextContainer::UpdateLowestPotentialNextTCStartOffset(
  1257.         UINT16 uiCurStartCharOffset, UINT16 uiCurEndCharOffset,
  1258.         UINT16& /*REF IN-&-OUT*/ uiLowestPotentialNextTCStartOffsetFound,
  1259.         BOOL&   /*REF OUT*/ bAssignBoxToCurrent)
  1260. {
  1261.     bAssignBoxToCurrent = FALSE; // /Initialize.
  1263.     // /Error if start is after end or even if they are equal since indices
  1264.     // are end-point exclusive:
  1265.     if (uiCurStartCharOffset >= uiCurEndCharOffset)
  1266.     {
  1267.         // /Don't bother asserting; it's a bad test file (3GPPtext-e-06-00.3gp)
  1268.         return HXR_UNEXPECTED; // /BAD DATA!
  1269.     }
  1271.     // /To avoid crash @ draw time w/corrupt data, make sure these don't
  1272.     // exceed the complete buffer's size:
  1273.     if (uiCurStartCharOffset > m_pTextSample->GetTextLenInBytes()  ||
  1274.             uiCurEndCharOffset > m_pTextSample->GetTextLenInBytes())
  1275.     {
  1276.         HX_ASSERT(uiCurStartCharOffset > m_pTextSample->GetTextLenInBytes());
  1277.         HX_ASSERT(uiCurEndCharOffset > m_pTextSample->GetTextLenInBytes());
  1278.         return HXR_UNEXPECTED; // /Ignore this entry.
  1279.     }
  1280.     if (m_uiUnpackedStartCharOffset >= uiCurStartCharOffset  &&
  1281.             uiCurEndCharOffset > // /(end-pt exclusive)
  1282.             m_uiUnpackedStartCharOffset)
  1283.     {
  1284.         bAssignBoxToCurrent = TRUE; // /this's begin is within current range
  1286.         HX_ASSERT(uiLowestPotentialNextTCStartOffsetFound >= uiCurEndCharOffset);
  1287.         if (uiLowestPotentialNextTCStartOffsetFound > uiCurEndCharOffset)
  1288.         {
  1289.             // /Don't add 1 here; it's end-point exclusive:
  1290.             uiLowestPotentialNextTCStartOffsetFound = uiCurEndCharOffset;
  1291.         }
  1292.     }
  1293.     // /Use start as potential end if lowest so far:
  1294.     else if (uiCurStartCharOffset < uiLowestPotentialNextTCStartOffsetFound  &&
  1295.             // /Ignore if prior to our start:
  1296.             uiCurStartCharOffset >= m_uiUnpackedStartCharOffset)
  1297.     {
  1298.         uiLowestPotentialNextTCStartOffsetFound = uiCurStartCharOffset;
  1299.         // /I think the logic of the if(), above,
  1300.         // handles this but I'm too lazy to check:
  1301.         HX_ASSERT(0 != uiLowestPotentialNextTCStartOffsetFound);
  1302.     }
  1304.     return HXR_OK;
  1305. }
  1308. UINT32
  1309. C3GPPTextContainer::GetNextActivityTime() const
  1310. {
  1311.     UINT32 ulBegin = GetBeginTime();
  1312.     if (HX_3GPPTT_INVALID_TIME == ulBegin)
  1313.     {
  1314.         return ulBegin;
  1315.     }
  1316.     return (m_ulNextDrawUpdateTimeOffset + ulBegin);
  1317. }
  1320. UINT32
  1321. C3GPPTextContainer::GetPrevActivityTime() const
  1322. {
  1323.     UINT32 ulBegin = GetBeginTime();
  1324.     if (HX_3GPPTT_INVALID_TIME == ulBegin  ||
  1325.             HX_3GPPTT_INVALID_TIME == m_ulPrevDrawUpdateTimeOffset)
  1326.     {
  1327.         return HX_3GPPTT_INVALID_TIME;
  1328.     }
  1329.     return (m_ulPrevDrawUpdateTimeOffset + ulBegin);
  1330. }
  1332. void
  1333. C3GPPTextContainer::SetPrevActivityTime(UINT32 ulAbsoluteTime)
  1334. {
  1335.     UINT32 ulBegin = GetBeginTime();
  1336.     if (HX_3GPPTT_INVALID_TIME == ulBegin  ||  ulBegin > ulAbsoluteTime)
  1337.     {
  1338.         m_ulPrevDrawUpdateTimeOffset = HX_3GPPTT_INVALID_TIME;
  1339.     }
  1340.     else
  1341.     {
  1342.         m_ulPrevDrawUpdateTimeOffset = ulAbsoluteTime - ulBegin;
  1343.     }
  1344. }