layout/generic/nsVideoFrame.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim:set ts=2 sw=2 sts=2 et cindent: */
   3 /* ***** BEGIN LICENSE BLOCK *****
   4  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version
   7  * 1.1 (the "License"); you may not use this file except in compliance with
   8  * the License. You may obtain a copy of the License at
   9  * http://www.mozilla.org/MPL/
  10  *
  11  * Software distributed under the License is distributed on an "AS IS" basis,
  12  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13  * for the specific language governing rights and limitations under the
  14  * License.
  15  *
  16  * The Original Code is Mozilla code.
  17  *
  18  * The Initial Developer of the Original Code is the Mozilla Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 2007
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *  Chris Double <chris.double@double.co.nz>
  24  *
  25  * Alternatively, the contents of this file may be used under the terms of
  26  * either the GNU General Public License Version 2 or later (the "GPL"), or
  27  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28  * in which case the provisions of the GPL or the LGPL are applicable instead
  29  * of those above. If you wish to allow use of your version of this file only
  30  * under the terms of either the GPL or the LGPL, and not to allow others to
  31  * use your version of this file under the terms of the MPL, indicate your
  32  * decision by deleting the provisions above and replace them with the notice
  33  * and other provisions required by the GPL or the LGPL. If you do not delete
  34  * the provisions above, a recipient may use your version of this file under
  35  * the terms of any one of the MPL, the GPL or the LGPL.
  36  *
  37  * ***** END LICENSE BLOCK ***** */
  38
  39 /* rendering object for the HTML <video> element */
  40
  41 #include "nsHTMLParts.h"
  42 #include "nsCOMPtr.h"
  43 #include "nsIServiceManager.h"
  44 #include "nsGkAtoms.h"
  45
  46 #include "nsVideoFrame.h"
  47 #include "nsHTMLVideoElement.h"
  48 #include "nsIDOMHTMLVideoElement.h"
  49 #include "nsDisplayList.h"
  50 #include "nsIRenderingContext.h"
  51 #include "gfxContext.h"
  52 #include "gfxImageSurface.h"
  53 #include "nsPresContext.h"
  54 #include "nsTransform2D.h"
  55 #include "nsContentCreatorFunctions.h"
  56 #include "nsBoxLayoutState.h"
  57 #include "nsBoxFrame.h"
  58
  59 nsIFrame*
  60 NS_NewHTMLVideoFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
  61 {
  62   return new (aPresShell) nsVideoFrame(aContext);
  63 }
  64
  65 nsVideoFrame::nsVideoFrame(nsStyleContext* aContext) :
  66   nsContainerFrame(aContext)
  67 {
  68 }
  69
  70 nsVideoFrame::~nsVideoFrame()
  71 {
  72 }
  73
  74 NS_INTERFACE_MAP_BEGIN(nsVideoFrame)
  75   NS_INTERFACE_MAP_ENTRY(nsIAnonymousContentCreator)
  76 #ifdef NS_DEBUG
  77   NS_INTERFACE_MAP_ENTRY(nsIFrameDebug)
  78 #endif
  79 NS_INTERFACE_MAP_END_INHERITING(nsContainerFrame)
  80
  81 NS_IMETHODIMP_(nsrefcnt)
  82 nsVideoFrame::AddRef(void)
  83 {
  84   return NS_OK;
  85 }
  86
  87 NS_IMETHODIMP_(nsrefcnt)
  88 nsVideoFrame::Release(void)
  89 {
  90     return NS_OK;
  91 }
  92
  93 nsresult
  94 nsVideoFrame::CreateAnonymousContent(nsTArray<nsIContent*>& aElements)
  95 {
  96   // Set up "videocontrols" XUL element which will be XBL-bound to the
  97   // actual controls.
  98   nsPresContext* presContext = PresContext();
  99   nsNodeInfoManager *nodeInfoManager =
 100     presContext->Document()->NodeInfoManager();
 101   nsCOMPtr<nsINodeInfo> nodeInfo;
 102   nsresult rv = nodeInfoManager->GetNodeInfo(nsGkAtoms::videocontrols, nsnull,
 103                                              kNameSpaceID_XUL, getter_AddRefs(nodeInfo));
 104   NS_ENSURE_SUCCESS(rv, rv);
 105
 106   rv = NS_NewElement(getter_AddRefs(mVideoControls), kNameSpaceID_XUL, nodeInfo, PR_FALSE);
 107   NS_ENSURE_SUCCESS(rv, rv);
 108   if (!aElements.AppendElement(mVideoControls))
 109     return NS_ERROR_OUT_OF_MEMORY;
 110   return NS_OK;
 111 }
 112
 113 void
 114 nsVideoFrame::Destroy()
 115 {
 116   nsContentUtils::DestroyAnonymousContent(&mVideoControls);
 117   nsContainerFrame::Destroy();
 118 }
 119
 120 PRBool
 121 nsVideoFrame::IsLeaf() const
 122 {
 123   return PR_TRUE;
 124 }
 125
 126 void
 127 nsVideoFrame::PaintVideo(nsIRenderingContext& aRenderingContext,
 128                          const nsRect& aDirtyRect, nsPoint aPt)
 129 {
 130   gfxContext* ctx = static_cast<gfxContext*>(aRenderingContext.GetNativeGraphicData(nsIRenderingContext::NATIVE_THEBES_CONTEXT));
 131   // TODO: handle the situation where the frame size is not the same as the
 132   // video size, by drawing to the largest rectangle that fits in the frame
 133   // whose aspect ratio equals the video's aspect ratio
 134   nsRect area = GetContentRect() - GetPosition() + aPt;
 135   nsPresContext* presContext = PresContext();
 136   gfxRect r = gfxRect(presContext->AppUnitsToGfxUnits(area.x),
 137                       presContext->AppUnitsToGfxUnits(area.y),
 138                       presContext->AppUnitsToGfxUnits(area.width),
 139                       presContext->AppUnitsToGfxUnits(area.height));
 140
 141   nsHTMLVideoElement* element = static_cast<nsHTMLVideoElement*>(GetContent());
 142   element->Paint(ctx, r);
 143 }
 144
 145 NS_IMETHODIMP
 146 nsVideoFrame::Reflow(nsPresContext*           aPresContext,
 147                      nsHTMLReflowMetrics&     aMetrics,
 148                      const nsHTMLReflowState& aReflowState,
 149                      nsReflowStatus&          aStatus)
 150 {
 151   DO_GLOBAL_REFLOW_COUNT("nsVideoFrame");
 152   DISPLAY_REFLOW(aPresContext, this, aReflowState, aMetrics, aStatus);
 153   NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS,
 154                   ("enter nsVideoFrame::Reflow: availSize=%d,%d",
 155                   aReflowState.availableWidth, aReflowState.availableHeight));
 156
 157   NS_PRECONDITION(mState & NS_FRAME_IN_REFLOW, "frame is not in reflow");
 158
 159   aStatus = NS_FRAME_COMPLETE;
 160
 161   aMetrics.width = aReflowState.ComputedWidth();
 162   aMetrics.height = aReflowState.ComputedHeight();
 163
 164   // stash this away so we can compute our inner area later
 165   mBorderPadding   = aReflowState.mComputedBorderPadding;
 166
 167   aMetrics.width += mBorderPadding.left + mBorderPadding.right;
 168   aMetrics.height += mBorderPadding.top + mBorderPadding.bottom;
 169
 170   nsIFrame* child = mFrames.FirstChild();
 171   if (child) {
 172     NS_ASSERTION(child->GetContent() == mVideoControls,
 173                  "What is this child doing here?");
 174     nsBoxLayoutState boxState(PresContext(), aReflowState.rendContext);
 175     nsBoxFrame::LayoutChildAt(boxState, child,
 176                               nsRect(mBorderPadding.left, mBorderPadding.right,
 177                                      aReflowState.ComputedWidth(), aReflowState.ComputedHeight()));
 178   }
 179
 180   aMetrics.mOverflowArea.SetRect(0, 0, aMetrics.width, aMetrics.height);
 181
 182   FinishAndStoreOverflow(&aMetrics);
 183
 184   if (mRect.width != aMetrics.width || mRect.height != aMetrics.height) {
 185     Invalidate(nsRect(0, 0, mRect.width, mRect.height), PR_FALSE);
 186   }
 187
 188   NS_FRAME_TRACE(NS_FRAME_TRACE_CALLS,
 189                   ("exit nsVideoFrame::Reflow: size=%d,%d",
 190                   aMetrics.width, aMetrics.height));
 191   NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aMetrics);
 192
 193   return NS_OK;
 194 }
 195
 196 static void PaintVideo(nsIFrame* aFrame, nsIRenderingContext* aCtx,
 197                         const nsRect& aDirtyRect, nsPoint aPt)
 198 {
 199 #if 0
 200   double start = double(PR_IntervalToMilliseconds(PR_IntervalNow()))/1000.0;
 201 #endif
 202
 203   static_cast<nsVideoFrame*>(aFrame)->PaintVideo(*aCtx, aDirtyRect, aPt);
 204 #if 0
 205   double end = double(PR_IntervalToMilliseconds(PR_IntervalNow()))/1000.0;
 206   printf("PaintVideo: %f\n", (float)end - (float)start);
 207
 208 #endif
 209 }
 210
 211 NS_IMETHODIMP
 212 nsVideoFrame::BuildDisplayList(nsDisplayListBuilder*   aBuilder,
 213                                const nsRect&           aDirtyRect,
 214                                const nsDisplayListSet& aLists)
 215 {
 216   if (!IsVisibleForPainting(aBuilder))
 217     return NS_OK;
 218
 219   DO_GLOBAL_REFLOW_COUNT_DSP("nsVideoFrame");
 220
 221   nsresult rv = DisplayBorderBackgroundOutline(aBuilder, aLists);
 222   NS_ENSURE_SUCCESS(rv, rv);
 223
 224   rv = aLists.Content()->AppendNewToTop(new (aBuilder) nsDisplayGeneric(this, ::PaintVideo, "Video"));
 225   NS_ENSURE_SUCCESS(rv, rv);
 226
 227   if (mFrames.FirstChild()) {
 228     rv = mFrames.FirstChild()->BuildDisplayListForStackingContext(aBuilder, aDirtyRect, aLists.Content());
 229   }
 230   return rv;
 231 }
 232
 233 nsIAtom*
 234 nsVideoFrame::GetType() const
 235 {
 236   return nsGkAtoms::HTMLVideoFrame;
 237 }
 238
 239 #ifdef ACCESSIBILITY
 240 NS_IMETHODIMP
 241 nsVideoFrame::GetAccessible(nsIAccessible** aAccessible)
 242 {
 243   return NS_ERROR_FAILURE;
 244 }
 245 #endif
 246
 247 #ifdef DEBUG
 248 NS_IMETHODIMP
 249 nsVideoFrame::GetFrameName(nsAString& aResult) const
 250 {
 251   return MakeFrameName(NS_LITERAL_STRING("HTMLVideo"), aResult);
 252 }
 253 #endif
 254
 255 nsSize nsVideoFrame::ComputeSize(nsIRenderingContext *aRenderingContext,
 256                                      nsSize aCBSize,
 257                                      nscoord aAvailableWidth,
 258                                      nsSize aMargin,
 259                                      nsSize aBorder,
 260                                      nsSize aPadding,
 261                                      PRBool aShrinkWrap)
 262 {
 263   nsSize size = GetVideoSize();
 264
 265   IntrinsicSize intrinsicSize;
 266   intrinsicSize.width.SetCoordValue(size.width);
 267   intrinsicSize.height.SetCoordValue(size.height);
 268
 269   nsSize& intrinsicRatio = size; // won't actually be used
 270
 271   return nsLayoutUtils::ComputeSizeWithIntrinsicDimensions(aRenderingContext,
 272                                                            this,
 273                                                            intrinsicSize,
 274                                                            intrinsicRatio,
 275                                                            aCBSize,
 276                                                            aMargin,
 277                                                            aBorder,
 278                                                            aPadding);
 279 }
 280
 281 nscoord nsVideoFrame::GetMinWidth(nsIRenderingContext *aRenderingContext)
 282 {
 283   // XXX The caller doesn't account for constraints of the height,
 284   // min-height, and max-height properties.
 285   nscoord result = GetVideoSize().width;
 286   DISPLAY_MIN_WIDTH(this, result);
 287   return result;
 288 }
 289
 290 nscoord nsVideoFrame::GetPrefWidth(nsIRenderingContext *aRenderingContext)
 291 {
 292   // XXX The caller doesn't account for constraints of the height,
 293   // min-height, and max-height properties.
 294   nscoord result = GetVideoSize().width;
 295   DISPLAY_PREF_WIDTH(this, result);
 296   return result;
 297 }
 298
 299 nsSize nsVideoFrame::GetIntrinsicRatio()
 300 {
 301   return GetVideoSize();
 302 }
 303
 304 nsSize nsVideoFrame::GetVideoSize()
 305 {
 306   // Defaulting size to 300x150 if no size given.
 307   nsIntSize size(300,150);
 308
 309   nsHTMLVideoElement* element = static_cast<nsHTMLVideoElement*>(GetContent());
 310   if (element) {
 311     nsresult rv;
 312
 313     size = element->GetVideoSize(size);
 314     if (element->HasAttr(kNameSpaceID_None, nsGkAtoms::width)) {
 315       PRInt32 width = -1;
 316       rv = element->GetWidth(&width);
 317       if (NS_SUCCEEDED(rv)) {
 318         size.width = width;
 319       }
 320     }
 321     if (element->HasAttr(kNameSpaceID_None, nsGkAtoms::height)) {
 322       PRInt32 height = -1;
 323       rv = element->GetHeight(&height);
 324       if (NS_SUCCEEDED(rv)) {
 325         size.height = height;
 326       }
 327     }
 328   }
 329
 330   return nsSize(nsPresContext::CSSPixelsToAppUnits(size.width),
 331                 nsPresContext::CSSPixelsToAppUnits(size.height));
 332 }
 333
 334 NS_IMETHODIMP nsVideoFrame::Freeze()
 335 {
 336   nsHTMLVideoElement* element = static_cast<nsHTMLVideoElement*>(GetContent());
 337   element->Pause();
 338   return NS_OK;
 339 }
 340
 341 NS_IMETHODIMP nsVideoFrame::Thaw()
 342 {
 343   nsHTMLVideoElement* element = static_cast<nsHTMLVideoElement*>(GetContent());
 344   element->Play();
 345   return NS_OK;
 346 }
 347