layout.cpp
上传用户:dangjiwu
上传日期:2013-07-19
资源大小:42019k
文件大小:29k
源码类别:

Symbian

开发平台:

Visual C++

  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: layout.cpp,v 1.2.16.1 2004/07/09 01:58:01 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  49. // system
  50. #include <time.h>
  51. // include
  52. #include "hxtypes.h"
  53. #include "hxwintyp.h"
  54. #include "hxcom.h"
  55. #include "hxwin.h"
  56. #include "hxsite2.h"
  57. #include "smiltype.h"
  58. #include "hxxml.h"
  59. #include "ihxpckts.h"
  60. // pncont
  61. #include "hxslist.h"
  62. #include "hxstring.h"
  63. // pnmisc
  64. #include "hxwinver.h"
  65. // rnxmllib
  66. #include "hxxmlprs.h"
  67. // rmasmil
  68. #include "smlelem.h"
  69. #include "smlparse.h"
  70. // smlrendr
  71. #include "passivsw.h"
  72. #include "siteuser.h"
  73. #include "layout.h"
  74. CSmilBasicBox::CSmilBasicBox()
  75. {
  76.     m_pParent                = NULL;
  77.     m_pChildList             = NULL;
  78.     m_bWidthResolved         = FALSE;
  79.     m_bDefaultWidthAssigned  = FALSE;
  80.     m_bHeightResolved        = FALSE;
  81.     m_bDefaultHeightAssigned = FALSE;
  82.     m_Rect.left              = 0;
  83.     m_Rect.top               = 0;
  84.     m_Rect.right             = 0;
  85.     m_Rect.bottom            = 0;
  86.     m_RectNoZoom.left        = 0;
  87.     m_RectNoZoom.top         = 0;
  88.     m_RectNoZoom.right       = 0;
  89.     m_RectNoZoom.bottom      = 0;
  90.     m_pSite                  = NULL;
  91.     m_pPassiveSiteWatcher    = NULL;
  92.     m_pSiteUser              = NULL;
  93.     m_bSiteChangingSize      = FALSE;
  94.     m_bNested      = FALSE;
  95.     m_eResizeBehavior        = ResizeZoom;
  96.     m_dZoomScaleFactorX      = 1.0;
  97.     m_dZoomScaleFactorY      = 1.0;
  98.     m_pChildRendererSiteList = NULL;
  99. }
  100. CSmilBasicBox::~CSmilBasicBox()
  101. {
  102.     HX_DELETE(m_pChildList);
  103.     HX_RELEASE(m_pSite);
  104.     HX_RELEASE(m_pPassiveSiteWatcher);
  105.     HX_RELEASE(m_pSiteUser);
  106.     HX_DELETE(m_pChildRendererSiteList);
  107. }
  108. HX_RESULT CSmilBasicBox::addChild(CSmilBasicBox* pBox)
  109. {
  110.     HX_RESULT retVal = HXR_OK;
  111.     if (!m_pChildList)
  112.     {
  113.         m_pChildList = new CHXSimpleList();
  114.     }
  115.     if (m_pChildList)
  116.     {
  117.         m_pChildList->AddTail((void*) pBox);
  118.         // Make sure our child inherits our resizeBehavior
  119.         pBox->m_eResizeBehavior = m_eResizeBehavior;
  120.     }
  121.     else
  122.     {
  123.         retVal = HXR_OUTOFMEMORY;
  124.     }
  125.     return retVal;
  126. }
  127. HX_RESULT CSmilBasicBox::addRendererSiteChild(IHXSite* pSite)
  128. {
  129.     HX_RESULT retVal = HXR_FAIL;
  130.     if (pSite)
  131.     {
  132.         if (!m_pChildRendererSiteList)
  133.         {
  134.             m_pChildRendererSiteList = new CHXSimpleList();
  135.         }
  136.         if (m_pChildRendererSiteList)
  137.         {
  138.             m_pChildRendererSiteList->AddTail((void*) pSite);
  139.             retVal = HXR_OK;
  140.         }
  141.     }
  142.     return retVal;
  143. }
  144. HX_RESULT CSmilBasicBox::removeRendererSiteChild(IHXSite* pSite )
  145. {
  146.     if(m_pChildRendererSiteList)
  147.     {
  148.         LISTPOSITION pos = m_pChildRendererSiteList->Find(pSite);
  149.         if(pos)
  150.         {
  151.             m_pChildRendererSiteList->RemoveAt(pos);
  152.         }
  153.     }
  154.     return HXR_OK;
  155. }
  156. BOOL CSmilBasicBox::isResolved(BoxDimension eDim)
  157. {
  158.     BOOL bRet = FALSE;
  159.     if (eDim == BoxDimensionWidth)
  160.     {
  161.         bRet = m_bWidthResolved;
  162.     }
  163.     else
  164.     {
  165.         bRet = m_bHeightResolved;
  166.     }
  167.     return bRet;
  168. }
  169. HX_RESULT CSmilBasicBox::computeChildrenMax(BoxDimension eDim,
  170.                                             BOOL         bAllMustBeValid,
  171.                                             REF(INT32)   rlMax)
  172. {
  173.     HX_RESULT retVal = HXR_FAIL;
  174.     // Do we have any children to resolve from? If
  175.     // not, then we can't resolve, so this is failure
  176.     if (m_pChildList &&
  177.         m_pChildList->GetCount() > 0)
  178.     {
  179.         // Now if we are having to compute our dimensions from
  180.         // our children, then we need to loop through our immediate
  181.         // children and compute their maximum value. NOTE: this 
  182.         // assumes that the values of m_cRect.left and m_cRect.top
  183.         // have already been set in this box.
  184.         UINT32       ulNumValid = 0;
  185.         INT32        lMax       = 0;
  186.         LISTPOSITION pos        = m_pChildList->GetHeadPosition();
  187.         while (pos)
  188.         {
  189.             CSmilBasicBox* pListBox = (CSmilBasicBox*) m_pChildList->GetNext(pos);
  190.             if (pListBox)
  191.             {
  192.                 INT32 lDim = 0;
  193.                 if (eDim == BoxDimensionWidth)
  194.                 {
  195.                     if (pListBox->m_bWidthResolved)
  196.                     {
  197.                         lDim = pListBox->m_Rect.right;
  198.                         ulNumValid++;
  199.                     }
  200.                 }
  201.                 else
  202.                 {
  203.                     if (pListBox->m_bHeightResolved)
  204.                     {
  205.                         lDim = pListBox->m_Rect.bottom;
  206.                         ulNumValid++;
  207.                     }
  208.                 }
  209.                 if (lDim > lMax)
  210.                 {
  211.                     lMax = lDim;
  212.                 }
  213.             }
  214.         }
  215.         // If we required all to be valid, then we
  216.         // need ulNumValid == num children. If not,
  217.         // then we just need at least 1 valid.
  218.         if ((bAllMustBeValid  && ulNumValid == (UINT32) m_pChildList->GetCount()) ||
  219.             (!bAllMustBeValid && ulNumValid > 0))
  220.         {
  221.             // Assign the out parameter
  222.             rlMax = lMax;
  223.             // Clear the return value
  224.             retVal = HXR_OK;
  225.         }
  226.     }
  227.     return retVal;
  228. }
  229. /*
  230.  * CSmilBasicRegion methods
  231.  */
  232. CSmilBasicRegion::CSmilBasicRegion(CSmilRegion* pSmilRegion) :
  233.     CSmilBasicBox()
  234. {
  235.     m_pSmilRegion              = pSmilRegion;
  236.     m_rect.left                = 0;
  237.     m_rect.top                 = 0;
  238.     m_rect.right               = 0;
  239.     m_rect.bottom              = 0;
  240.     m_originalRect.left        = 0;
  241.     m_originalRect.top         = 0;
  242.     m_originalRect.right       = 0;
  243.     m_originalRect.bottom      = 0;
  244.     m_mediaSize.cx             = 0;
  245.     m_mediaSize.cy             = 0;
  246.     m_originalMediaSize.cx     = 0;
  247.     m_originalMediaSize.cy     = 0;
  248.     m_bMediaSizeSet            = FALSE;
  249.     m_LayoutRect.m_dLeft       = 0.0;
  250.     m_LayoutRect.m_eLeftType   = CSS2TypeAuto;
  251.     m_LayoutRect.m_dTop        = 0.0;
  252.     m_LayoutRect.m_eTopType    = CSS2TypeAuto;
  253.     m_LayoutRect.m_dRight      = 0.0;
  254.     m_LayoutRect.m_eRightType  = CSS2TypeAuto;
  255.     m_LayoutRect.m_dBottom     = 0.0;
  256.     m_LayoutRect.m_eBottomType = CSS2TypeAuto;
  257.     m_LayoutRect.m_dWidth      = 0.0;
  258.     m_LayoutRect.m_eWidthType  = CSS2TypeAuto;
  259.     m_LayoutRect.m_dHeight     = 0.0;
  260.     m_LayoutRect.m_eHeightType = CSS2TypeAuto;
  261.     m_lZIndex                  = 0;
  262.     m_eFit                     = FitHidden;
  263.     m_ulBackgroundColor        = 0xFF000000;
  264.     m_eBackgroundColorType     = CSS2TypeTransparent;
  265.     m_bImplicitRegion          = FALSE;
  266.     m_bWidthUnspecified        = FALSE;
  267.     m_bHeightUnspecified       = FALSE;
  268.     m_dSoundLevel              = 100.0;
  269.     m_eShowBackground          = ShowBackgroundAlways;
  270.     m_bUnderRootLayout         = TRUE;
  271.     if (pSmilRegion)
  272.     {
  273.         // Copy the layout rect
  274.         m_LayoutRect = pSmilRegion->m_Rect;
  275.         // Set the z-index attribute
  276.         m_lZIndex = pSmilRegion->m_lZIndex;
  277.         // Set the fit attribute
  278.         m_eFit = pSmilRegion->m_eFit;
  279.         // Set the sound level
  280.         m_dSoundLevel = pSmilRegion->m_dSoundLevel;
  281.         // Set the region name
  282.         if (pSmilRegion->m_pNode)
  283.         {
  284.             m_region = pSmilRegion->m_pNode->m_id;
  285.         }
  286.         // Set the background color
  287.         m_ulBackgroundColor    = pSmilRegion->m_ulBackgroundColor;
  288.         m_eBackgroundColorType = pSmilRegion->m_eBackgroundColorType;
  289.         // Set the showBackground attribute
  290.         m_eShowBackground = pSmilRegion->m_eShowBackground;
  291.     }
  292. }
  293. CSmilBasicRegion::~CSmilBasicRegion()
  294. {
  295. }
  296. HX_RESULT CSmilBasicRegion::computeDimension(BoxDimension eDim)
  297. {
  298.     HX_RESULT retVal = HXR_OK;
  299.     if (eDim == BoxDimensionWidth)
  300.     {
  301.         if (!m_bWidthResolved)
  302.         {
  303.             // Is our parent width available?
  304.             BOOL   bParentAvailable = FALSE;
  305.             double dParentWidth     = 0.0;
  306.             if (m_pParent && m_pParent->m_bWidthResolved)
  307.             {
  308.                 bParentAvailable = TRUE;
  309.                 if (m_dZoomScaleFactorX != 1.0 ||
  310.                     m_dZoomScaleFactorY != 1.0)
  311.                 {
  312.                     dParentWidth = (double) HXxRECT_WIDTH(m_pParent->m_RectNoZoom);
  313.                 }
  314.                 else
  315.                 {
  316.                     dParentWidth = (double) HXxRECT_WIDTH(m_pParent->m_Rect);
  317.                 }
  318.             }
  319.             // Now resolve left/right/width
  320.             retVal = resolveDimension(m_LayoutRect.m_dLeft,
  321.                                       m_LayoutRect.m_eLeftType,
  322.                                       m_LayoutRect.m_dRight,
  323.                                       m_LayoutRect.m_eRightType,
  324.                                       m_LayoutRect.m_dWidth,
  325.                                       m_LayoutRect.m_eWidthType,
  326.                                       bParentAvailable,
  327.                                       dParentWidth,
  328.                                       m_Rect.left,
  329.                                       m_Rect.right);
  330.             if (SUCCEEDED(retVal))
  331.             {
  332.                 m_bWidthResolved = TRUE;
  333.                 // XXXMEH - these are holdover members which currently
  334.                 // need to be set, but should be taken out soon
  335.                 m_rect.left          = m_Rect.left;
  336.                 m_rect.right         = m_Rect.right;
  337.                 m_originalRect.left  = m_Rect.left;
  338.                 m_originalRect.right = m_Rect.right;
  339.                 m_bWidthUnspecified  = (m_LayoutRect.m_eWidthType  == CSS2TypeAuto ? TRUE : FALSE);
  340.             }
  341.         }
  342.     }
  343.     else
  344.     {
  345.         if (!m_bHeightResolved)
  346.         {
  347.             // Is our parent width available?
  348.             BOOL   bParentAvailable = FALSE;
  349.             double dParentHeight    = 0.0;
  350.             if (m_pParent && m_pParent->m_bHeightResolved)
  351.             {
  352.                 bParentAvailable = TRUE;
  353.                 if (m_dZoomScaleFactorX != 1.0 ||
  354.                     m_dZoomScaleFactorY != 1.0)
  355.                 {
  356.                     dParentHeight = (double) HXxRECT_HEIGHT(m_pParent->m_RectNoZoom);
  357.                 }
  358.                 else
  359.                 {
  360.                     dParentHeight = (double) HXxRECT_HEIGHT(m_pParent->m_Rect);
  361.                 }
  362.             }
  363.             // Now resolve top/bottom/height
  364.             retVal = resolveDimension(m_LayoutRect.m_dTop,
  365.                                       m_LayoutRect.m_eTopType,
  366.                                       m_LayoutRect.m_dBottom,
  367.                                       m_LayoutRect.m_eBottomType,
  368.                                       m_LayoutRect.m_dHeight,
  369.                                       m_LayoutRect.m_eHeightType,
  370.                                       bParentAvailable,
  371.                                       dParentHeight,
  372.                                       m_Rect.top,
  373.                                       m_Rect.bottom);
  374.             if (SUCCEEDED(retVal))
  375.             {
  376.                 m_bHeightResolved = TRUE;
  377.                 // XXXMEH - these are holdover members which currently
  378.                 // need to be set, but should be taken out soon
  379.                 m_rect.top            = m_Rect.top;
  380.                 m_rect.bottom         = m_Rect.bottom;
  381.                 m_originalRect.top    = m_Rect.top;
  382.                 m_originalRect.bottom = m_Rect.bottom;
  383.                 m_bHeightUnspecified  = (m_LayoutRect.m_eHeightType == CSS2TypeAuto ? TRUE : FALSE);
  384.             }
  385.         }
  386.     }
  387.     return retVal;
  388. }
  389. HX_RESULT CSmilBasicRegion::resolveFromChildren(BoxDimension eDim)
  390. {
  391.     HX_RESULT retVal = HXR_OK;
  392.     INT32 lMax = 0;
  393.     retVal     = computeChildrenMax(eDim, TRUE, lMax);
  394.     if (SUCCEEDED(retVal))
  395.     {
  396.         if (eDim == BoxDimensionWidth)
  397.         {
  398.             m_bWidthResolved = TRUE;
  399.             if (m_LayoutRect.m_eLeftType == CSS2TypeLength)
  400.             {
  401.                 m_Rect.left = (INT32) (m_LayoutRect.m_dLeft + 0.5);
  402.             }
  403.             m_Rect.right = m_Rect.left + lMax;
  404.             // XXXMEH - these are holdover members which currently
  405.             // need to be set, but should be taken out soon
  406.             m_rect.left          = m_Rect.left;
  407.             m_rect.right         = m_Rect.right;
  408.             m_originalRect.left  = m_Rect.left;
  409.             m_originalRect.right = m_Rect.right;
  410.             m_bWidthUnspecified  = (m_LayoutRect.m_eWidthType  == CSS2TypeAuto ? TRUE : FALSE);
  411.         }
  412.         else
  413.         {
  414.             m_bHeightResolved = TRUE;
  415.             if (m_LayoutRect.m_eTopType == CSS2TypeLength)
  416.             {
  417.                 m_Rect.top = (INT32) (m_LayoutRect.m_dTop + 0.5);
  418.             }
  419.             m_Rect.bottom = m_Rect.top + lMax;
  420.             // XXXMEH - these are holdover members which currently
  421.             // need to be set, but should be taken out soon
  422.             m_rect.top            = m_Rect.top;
  423.             m_rect.bottom         = m_Rect.bottom;
  424.             m_originalRect.top    = m_Rect.top;
  425.             m_originalRect.bottom = m_Rect.bottom;
  426.             m_bHeightUnspecified  = (m_LayoutRect.m_eHeightType == CSS2TypeAuto ? TRUE : FALSE);
  427.         }
  428.     }
  429.     return retVal;
  430. }
  431. HX_RESULT CSmilBasicRegion::resolveDimension(double dLeft,  CSS2Type eLeftType,
  432.                                              double dRight, CSS2Type eRightType,
  433.                                              double dWidth, CSS2Type eWidthType,
  434.                                              BOOL bHaveParentWidth, double dParentWidth,
  435.                                              REF(INT32) rlRectMin,
  436.                                              REF(INT32) rlRectMax)
  437. {
  438.     HX_RESULT retVal = HXR_OK;
  439.     // Convert any percentage values
  440.     if (eLeftType  == CSS2TypePercentage ||
  441.         eRightType == CSS2TypePercentage ||
  442.         eWidthType == CSS2TypePercentage)
  443.     {
  444.         if (bHaveParentWidth)
  445.         {
  446.             if (eLeftType == CSS2TypePercentage)
  447.             {
  448.                 eLeftType = CSS2TypeLength;
  449.                 dLeft     = dLeft * dParentWidth / 100.0;
  450.             }
  451.             if (eRightType == CSS2TypePercentage)
  452.             {
  453.                 eRightType = CSS2TypeLength;
  454.                 dRight     = dRight * dParentWidth / 100.0;
  455.             }
  456.             if (eWidthType == CSS2TypePercentage)
  457.             {
  458.                 eWidthType = CSS2TypeLength;
  459.                 dWidth     = dWidth * dParentWidth / 100.0;
  460.             }
  461.         }
  462.         else
  463.         {
  464.             retVal = HXR_FAIL;
  465.         }
  466.     }
  467.     if (SUCCEEDED(retVal))
  468.     {
  469.         // Apply the following algorithm, where bbw
  470.         // is the "bounding box width" or in this
  471.         // case, the parent dimension (pw). See the SMIL 2.0 Layout
  472.         // module for full detail.
  473.         //
  474.         //        Attribute values       Resulting value             RECT values
  475.         // Case left   width  right   left     width    right    min(=left) max(=pw-right)
  476.         // =============================================================================
  477.         //  0   auto   auto   auto      0       pw        0         0         pw
  478.         //  1   auto   auto     R       0      pw-R       R         0        pw-R
  479.         //  2   auto     W    auto      0        W       pw-W       0          W
  480.         //  3   auto     W      R    pw-R-W      W        R      pw-R-W      pw-R
  481.         //  4     L    auto   auto      L      pw-L       0         L         pw
  482.         //  5     L    auto     R       L     pw-R-L      R         L        pw-R
  483.         //  6     L      W    auto      L        W     pw-L-W       L         L+W
  484.         //  7     L      W      R       L        W     pw-L-W       L         L+W
  485.         //
  486.         // The algorithm is the same for top/height/bottom.
  487.         //
  488.         double dMin = 0.0;
  489.         double dMax = 0.0;
  490.         // Which case do we have?
  491.         if (eLeftType == CSS2TypeAuto)
  492.         {
  493.             if (eWidthType == CSS2TypeAuto)
  494.             {
  495.                 if (eRightType == CSS2TypeAuto)
  496.                 {
  497.                     // Case 0
  498.                     if (bHaveParentWidth)
  499.                     {
  500.                         dMin = 0.0;
  501.                         dMax = dParentWidth;
  502.                     }
  503.                     else
  504.                     {
  505.                         retVal = HXR_FAIL;
  506.                     }
  507.                 }
  508.                 else
  509.                 {
  510.                     // Case 1
  511.                     if (bHaveParentWidth)
  512.                     {
  513.                         dMin = 0.0;
  514.                         dMax = dParentWidth - dRight;
  515.                     }
  516.                     else
  517.                     {
  518.                         retVal = HXR_FAIL;
  519.                     }
  520.                 }
  521.             }
  522.             else
  523.             {
  524.                 if (eRightType == CSS2TypeAuto)
  525.                 {
  526.                     // Case 2
  527.                     dMin = 0.0;
  528.                     dMax = dWidth;
  529.                 }
  530.                 else
  531.                 {
  532.                     // Case 3
  533.                     if (bHaveParentWidth)
  534.                     {
  535.                         dMin = dParentWidth - dRight - dWidth;
  536.                         dMax = dParentWidth - dRight;
  537.                     }
  538.                     else
  539.                     {
  540.                         retVal = HXR_FAIL;
  541.                     }
  542.                 }
  543.             }
  544.         }
  545.         else
  546.         {
  547.             if (eWidthType == CSS2TypeAuto)
  548.             {
  549.                 if (eRightType == CSS2TypeAuto)
  550.                 {
  551.                     // Case 4
  552.                     if (bHaveParentWidth)
  553.                     {
  554.                         dMin = dLeft;
  555.                         dMax = dParentWidth;
  556.                     }
  557.                     else
  558.                     {
  559.                         retVal = HXR_FAIL;
  560.                     }
  561.                 }
  562.                 else
  563.                 {
  564.                     // Case 5
  565.                     if (bHaveParentWidth)
  566.                     {
  567.                         dMin = dLeft;
  568.                         dMax = dParentWidth - dRight;
  569.                     }
  570.                     else
  571.                     {
  572.                         retVal = HXR_FAIL;
  573.                     }
  574.                 }
  575.             }
  576.             else
  577.             {
  578.                 if (eRightType == CSS2TypeAuto)
  579.                 {
  580.                     // Case 6
  581.                     dMin = dLeft;
  582.                     dMax = dLeft + dWidth;
  583.                 }
  584.                 else
  585.                 {
  586.                     // Case 7
  587.                     dMin = dLeft;
  588.                     dMax = dLeft + dWidth;
  589.                 }
  590.             }
  591.         }
  592.         // Now assign the out parameters
  593.         if (SUCCEEDED(retVal))
  594.         {
  595.             rlRectMin = (INT32) (dMin + 0.5);
  596.             rlRectMax = (INT32) (dMax + 0.5);
  597.         }
  598.     }
  599.     return retVal;
  600. }
  601. CSmilBasicRootLayout::CSmilBasicRootLayout() :
  602.     CSmilBasicBox()
  603. {
  604.     m_pRoot              = NULL;
  605.     m_OriginalSize.cx    = 0;
  606.     m_OriginalSize.cy    = 0;
  607.     m_bOriginalWidthSet  = FALSE;
  608.     m_bOriginalHeightSet = FALSE;
  609. }
  610. CSmilBasicRootLayout::~CSmilBasicRootLayout()
  611. {
  612. }
  613. HX_RESULT CSmilBasicRootLayout::computeDimension(BoxDimension eDim)
  614. {
  615.     HX_RESULT retVal = HXR_OK;
  616.     // There's nothing to do here really. For <root-layout>
  617.     // and <viewport>, the width and height will get resolved
  618.     // either from the values of "width" and "height" themselves,
  619.     // or they will get resolved from their children's width
  620.     // and height. So if we are already resolved, we will stay
  621.     // resolved and return HXR_OK. If not, we will stay not resolved
  622.     // and return HXR_FAIL.
  623.     if ((eDim == BoxDimensionWidth  && !m_bWidthResolved) ||
  624.         (eDim == BoxDimensionHeight && !m_bHeightResolved))
  625.     {
  626.         retVal = HXR_FAIL;
  627.     }
  628.     return retVal;
  629. }
  630. HX_RESULT CSmilBasicRootLayout::resolveFromChildren(BoxDimension eDim)
  631. {
  632.     HX_RESULT retVal = HXR_OK;
  633.     INT32 lMax = 0;
  634.     retVal     = computeChildrenMax(eDim, TRUE, lMax);
  635.     if (SUCCEEDED(retVal))
  636.     {
  637.         if (eDim == BoxDimensionWidth)
  638.         {
  639.             m_bWidthResolved    = TRUE;
  640.             m_Rect.left         = 0;
  641.             m_Rect.right        = lMax;
  642.             if (!m_bOriginalWidthSet)
  643.             {
  644.                 m_OriginalSize.cx   = m_Rect.right;
  645.                 m_bOriginalWidthSet = TRUE;
  646.             }
  647.         }
  648.         else
  649.         {
  650.             m_bHeightResolved = TRUE;
  651.             m_Rect.top        = 0;
  652.             m_Rect.bottom     = lMax;
  653.             if (!m_bOriginalHeightSet)
  654.             {
  655.                 m_OriginalSize.cy    = m_Rect.bottom;
  656.                 m_bOriginalHeightSet = TRUE;
  657.             }
  658.         }
  659.     }
  660.     return retVal;
  661. }
  662. void CSmilBasicRootLayout::SetParserRootLayout(CSmilRootLayout* pRoot)
  663. {
  664.     // Assign the member variable
  665.     m_pRoot = pRoot;
  666.     // Set up the box parameters
  667.     if (pRoot)
  668.     {
  669.         // Get the resizeBehavior from our CSmilRootLayout element
  670.         m_eResizeBehavior = pRoot->m_eResizeBehavior;
  671.         // Check if the width is resolved on its own.
  672.         // Based on its values along, the width of the
  673.         // root-layout is only resolved if the width
  674.         // is specified as an absolute length
  675.         if (pRoot->m_eWidthType == CSS2TypeLength)
  676.         {
  677.             // Assign the rect values
  678.             m_Rect.left  = 0;
  679.             m_Rect.right = (INT32) (pRoot->m_dWidth + 0.5);
  680.             // Set the resolved flag
  681.             m_bWidthResolved = TRUE;
  682.             // Set the original width and the flag
  683.             if (!m_bOriginalWidthSet)
  684.             {
  685.                 m_OriginalSize.cx   = m_Rect.right;
  686.                 m_bOriginalWidthSet = TRUE;
  687.             }
  688.         }
  689.         // Check if the height is resolved on its own.
  690.         // Based on its values along, the height of the
  691.         // root-layout is only resolved if the height
  692.         // is specified as an absolute length
  693.         if (pRoot->m_eHeightType == CSS2TypeLength)
  694.         {
  695.             // Assign the rect values
  696.             m_Rect.top    = 0;
  697.             m_Rect.bottom = (INT32) (pRoot->m_dHeight + 0.5);
  698.             // Set the resolved flag
  699.             m_bHeightResolved = TRUE;
  700.             // Set the original height and the flag
  701.             if (!m_bOriginalHeightSet)
  702.             {
  703.                 m_OriginalSize.cy    = m_Rect.bottom;
  704.                 m_bOriginalHeightSet = TRUE;
  705.             }
  706.         }
  707.     }
  708. }
  709. BOOL CSmilBasicRootLayout::IsWidthSet() const
  710. {
  711.     return m_bWidthResolved;
  712. }
  713. BOOL CSmilBasicRootLayout::IsHeightSet() const
  714. {
  715.     return m_bHeightResolved;
  716. }
  717. UINT32 CSmilBasicRootLayout::GetWidth() const
  718. {
  719.     return (UINT32) HXxRECT_WIDTH(m_Rect);
  720. }
  721. UINT32 CSmilBasicRootLayout::GetHeight() const
  722. {
  723.     return (UINT32) HXxRECT_HEIGHT(m_Rect);
  724. }
  725. UINT32 CSmilBasicRootLayout::GetBackgroundColor() const
  726. {
  727.     UINT32 ulRet = 0;
  728.     if (m_pRoot)
  729.     {
  730.         ulRet = m_pRoot->m_ulBackgroundColor;
  731.     }
  732.     return ulRet;
  733. }
  734. #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT)
  735. CSmilBasicViewport::CSmilBasicViewport(CSmilViewport* pPort) :
  736.     CSmilBasicBox()
  737. {
  738.     // Assign member variables
  739.     m_pPort              = pPort;
  740.     m_ulNumActiveMedia   = 0;
  741.     m_bOpen              = FALSE;
  742.     m_OriginalSize.cx    = 0;
  743.     m_OriginalSize.cy    = 0;
  744.     m_bOriginalWidthSet  = FALSE;
  745.     m_bOriginalHeightSet = FALSE;
  746.     m_bViewportIsSetup   = FALSE;
  747.     // Determine if the width and height are resolved
  748.     if (pPort)
  749.     {
  750.         // Get the resize behavior from our CSmilViewport element
  751.         m_eResizeBehavior = pPort->m_eResizeBehavior;
  752.         // Copy the id for convenience
  753.         m_id = pPort->m_pNode->m_id;
  754.         // Check if the width is resolved on its own.
  755.         // Based on its values along, the width of the
  756.         // viewport is only resolved if the width
  757.         // is specified as an absolute length
  758.         if (pPort->m_eWidthType == CSS2TypeLength)
  759.         {
  760.             // Assign the rect values
  761.             m_Rect.left  = 0;
  762.             m_Rect.right = (INT32) (pPort->m_dWidth + 0.5);
  763.             // Set the resolved flag
  764.             m_bWidthResolved = TRUE;
  765.             // Set the original width and flag
  766.             if (!m_bOriginalWidthSet)
  767.             {
  768.                 m_OriginalSize.cx   = m_Rect.right;
  769.                 m_bOriginalWidthSet = TRUE;
  770.             }
  771.         }
  772.         // Check if the height is resolved on its own.
  773.         // Based on its values along, the height of the
  774.         // viewport is only resolved if the height
  775.         // is specified as an absolute length
  776.         if (pPort->m_eHeightType == CSS2TypeLength)
  777.         {
  778.             // Assign the rect values
  779.             m_Rect.top    = 0;
  780.             m_Rect.bottom = (INT32) (pPort->m_dHeight + 0.5);
  781.             // Set the resolved flag
  782.             m_bHeightResolved = TRUE;
  783.             // Set the original height and flag
  784.             if (!m_bOriginalHeightSet)
  785.             {
  786.                 m_OriginalSize.cy    = m_Rect.bottom;
  787.                 m_bOriginalHeightSet = TRUE;
  788.             }
  789.         }
  790.     }
  791. }
  792. CSmilBasicViewport::~CSmilBasicViewport()
  793. {
  794. }
  795. HX_RESULT CSmilBasicViewport::computeDimension(BoxDimension eDim)
  796. {
  797.     HX_RESULT retVal = HXR_OK;
  798.     // There's nothing to do here really. For <root-layout>
  799.     // and <viewport>, the width and height will get resolved
  800.     // either from the values of "width" and "height" themselves,
  801.     // or they will get resolved from their children's width
  802.     // and height. So if we are already resolved, we will stay
  803.     // resolved and return HXR_OK. If not, we will stay not resolved
  804.     // and return HXR_FAIL.
  805.     if ((eDim == BoxDimensionWidth  && !m_bWidthResolved) ||
  806.         (eDim == BoxDimensionHeight && !m_bHeightResolved))
  807.     {
  808.         retVal = HXR_FAIL;
  809.     }
  810.     return retVal;
  811. }
  812. HX_RESULT CSmilBasicViewport::resolveFromChildren(BoxDimension eDim)
  813. {
  814.     HX_RESULT retVal = HXR_OK;
  815.     INT32 lMax = 0;
  816.     retVal     = computeChildrenMax(eDim, TRUE, lMax);
  817.     if (SUCCEEDED(retVal))
  818.     {
  819.         if (eDim == BoxDimensionWidth)
  820.         {
  821.             m_bWidthResolved = TRUE;
  822.             m_Rect.left      = 0;
  823.             m_Rect.right     = lMax;
  824.             if (!m_bOriginalWidthSet)
  825.             {
  826.                 m_OriginalSize.cx   = m_Rect.right;
  827.                 m_bOriginalWidthSet = TRUE;
  828.             }
  829.         }
  830.         else
  831.         {
  832.             m_bHeightResolved = TRUE;
  833.             m_Rect.top        = 0;
  834.             m_Rect.bottom     = lMax;
  835.             if (!m_bOriginalHeightSet)
  836.             {
  837.                 m_OriginalSize.cy    = m_Rect.bottom;
  838.                 m_bOriginalHeightSet = TRUE;
  839.             }
  840.         }
  841.     }
  842.     return retVal;
  843. }
  844. #endif /* #if defined(HELIX_FEATURE_SMIL2_MULTIWINDOWLAYOUT) */