FCL/sf/app/jrt: comparison javauis/lcdui_akn/lcdui/src/CMIDCanvas.cpp

equal deleted inserted replaced

-:d5e927d5853b
+:7cee158cb8cd
 ASSERT(!iAlfMonitor);
 aRead = aEnd;
 return EFalse;
 }
-switch (aRead->OpCode())
+// Usually only one op code is processed by Canvas.
-{
+// Exception is the video overlay case, where MIDlet
-case EDrwOpcM3GContentStart:
+// does not draw anything inside Canvas.paint().
-{
+// In this case EDrwOpcPaintStarted and EDrwOpcBitBltRect/EDrwOpcBitBlt
-// EGL surface is created if canvas window is currently visible
+// are received in one ProcessL(). Also EDrwOpcPaintStarted and EDrwOpcM3GContentStart
-// even if MIDlet would be on background.
+// may be processed in one ProcessL(), if overlays are enabled.
-if (!iM3GContent &&
+while (aRead < aEnd)
-i3DAccelerated &&
+{
-iDirectContents.Count() == 0 &&
+switch (aRead->OpCode())
-IsWindowVisible())
+{
-{
+case EDrwOpcM3GContentStart:
-DEBUG("CMIDCanvas::ProcessL - M3G content start");
+{
-iM3GContent = ETrue;
+// EGL surface is created if canvas window is currently visible
-iM3GStart = ETrue;
+// even if MIDlet would be on background.
-PostEvent(EM3GDraw, iM3GContent, 0);
+if (!iM3GContent &&
-// First time when M3G content is drawn =>
+i3DAccelerated &&
-// switch to EGL surface drawing.
+iDirectContents.Count() == 0 &&
-// Pixel source must be disposed first.
+IsWindowVisible())
-DisposePixelSource();
-OpenEglL();
-// if we are scaling with m3g and HW acceleration
-// create a pbuffer surface to be used with m3g rendering
-if (iScalingOn && iFullScreen)
 {
-CreatePBufferSurfaceL();
+DEBUG("CMIDCanvas::ProcessL - M3G content start");
+iM3GContent = ETrue;
+iM3GStart = ETrue;
+PostEvent(EM3GDraw, iM3GContent, 0);
+// First time when M3G content is drawn =>
+// switch to EGL surface drawing.
+// Pixel source must be disposed first.
+DisposePixelSource();
+OpenEglL();
+// if we are scaling with m3g and HW acceleration
+// create a pbuffer surface to be used with m3g rendering
+if (iScalingOn && iFullScreen)
+{
+CreatePBufferSurfaceL();
+}
+// Draw the whole framebuffer content (as a texture) on top of
+// the EGL window surface.
+iUpperUpdateRect = TRect(Size());
+UpdateEglContent();
 }
-// Draw the whole framebuffer content (as a texture) on top of
-// the EGL window surface.
+ASSERT(aRead + aRead->Size() == aEnd);
-iUpperUpdateRect = TRect(Size());
+}
-UpdateEglContent();
-}
-}
-break;
-case EDrwOpcBitBltRect:
-{
-if (iFirstPaintState == EFirstPaintNeverOccurred)
-{
-iFirstPaintState = EFirstPaintInitiated;
-}
-const TBitBltData& data = BitBltData(aRead);
-UpdateL(data.iRect);
-}
-break;
-case EDrwOpcBitBlt:
-{
-if (iFirstPaintState == EFirstPaintNeverOccurred)
-{
-iFirstPaintState = EFirstPaintInitiated;
-}
-UpdateL(iViewRect);
-}
-break;
-default:
-User::Leave(KErrNotSupported);
 break;
-}
+case EDrwOpcBitBltRect:
+{
-aRead += aRead->Size();
+if (iFirstPaintState == EFirstPaintNeverOccurred)
+{
+iFirstPaintState = EFirstPaintInitiated;
+}
+const TBitBltData& data = BitBltData(aRead);
+UpdateL(data.iRect);
+ASSERT(aRead + aRead->Size() == aEnd);
+}
+break;
+case EDrwOpcBitBlt:
+{
+if (iFirstPaintState == EFirstPaintNeverOccurred)
+{
+iFirstPaintState = EFirstPaintInitiated;
+}
+UpdateL(iViewRect);
+ASSERT(aRead + aRead->Size() == aEnd);
+}
+break;
+case EDrwOpcPaintStarted:
+{
+// Clear MMAPI content areas on Canvas to enable overlays.
+if (IsVideoOverlayActive())
+{
+RRegion directContents;
+iDisplayable->GetDirectContentsRegion(directContents);
+TInt count = directContents.Count();
+iFrameContext->SetBrushColor(KTransparentClearColor);
+iFrameContext->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);
+for (TInt i = 0; i < count; ++i)
+{
+const TRect rect = directContents[i];
+iFrameContext->Clear(rect);
+}
+directContents.Close();
+}
+}
+break;
+default:
+User::Leave(KErrNotSupported);
+break;
+}
+aRead += aRead->Size();
+}
 ASSERT(aRead == aEnd);
 // iFrameReady tells if this is async operation.
 // In async case CMIDBuffer waits until canvas
 // gets callback from Alf.
 // From class MDirectContainer.
 // CMIDCanvas::MdcAddContentBounds
 // Adds a rectangle to be excluded from redrawing.
 // ---------------------------------------------------------------------------
 //
-void CMIDCanvas::MdcAddContentBounds(const TRect& aRect)
+void CMIDCanvas::MdcAddMMAPIContentBounds(const TRect& aRect)
 {
 if (iDisplayable)
 {
 iDisplayable->AddDirectContentArea(aRect);
 }
 // From class MDirectContainer.
 // CMIDCanvas::MdcRemoveContentBounds
 // Removes a rectangle to be excluded from redrawing.
 // ---------------------------------------------------------------------------
 //
-void CMIDCanvas::MdcRemoveContentBounds(const TRect& aRect)
+void CMIDCanvas::MdcRemoveMMAPIContentBounds(const TRect& aRect)
 {
 if (iDisplayable)
 {
+#ifdef RD_JAVA_NGA_ENABLED
+if (iEnv.VideoOverlayEnabled())
+{
+// iMMAPIAreaUpdated may be modified in LCDUI and MMAPI threads.
+// Lock must be released before RemoveDirectContentArea().
+RCriticalSection& lock(iEnv.GetMMAPILock());
+lock.Wait();
+iMMAPIAreaUpdated = ETrue;
+lock.Signal();
+iDisplayable->RemoveDirectContentArea(aRect);
+}
+else
+{
+iDisplayable->RemoveDirectContentArea(aRect);
+}
+#else
 iDisplayable->RemoveDirectContentArea(aRect);
+#endif // RD_JAVA_NGA_ENABLED
 }
 }
 // ---------------------------------------------------------------------------
 if (iFrameBuffer->DisplayMode() == EColor16MA)
 {
 gc.SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);
 }
+#ifdef RD_JAVA_NGA_ENABLED
+// If overlay is enabled, need to clear previous content
+// from CWindowGc.
+CMIDCanvas* myself = const_cast<CMIDCanvas*>(this);
+if (myself->IsVideoOverlayActive())
+{
+gc.SetBrushColor(KTransparentClearColor);
+gc.Clear(aRect);
+}
+#endif
 TRect windowRect(aRect);
 PrepareDraw(gc, windowRect);
 // Check if Canvas scaling is used.
 if (iViewRect.Size() == iContentSize)
 if (aType == KEikInputLanguageChange)
 #endif // RD_JAVA_S60_RELEASE_9_2
 {
 // We need inform TextEditor that input language is changed.
 if ((iFocusedComponent != KComponentFocusedNone) &&
 (iFocusedComponent < iCustomComponents.Count()))
 {
 iCustomComponents[iFocusedComponent]->
 CustomComponentControl(KComponentMainControl)->
 HandleResourceChange(aType);
 }
 if (IsEglAvailable())
 {
 myself->ClearUiSurface(ETrue);
 }
-else if (iAlfCompositionPixelSource)
+// Pixel source is not activated if Canvas is not visible,
+// in order that graphics memory is not reserved while being on background
+else if (iAlfCompositionPixelSource && IsWindowVisible())
 {
 myself->ClearUiSurface(ETrue);
 TRAP_IGNORE(myself->ActivatePixelSourceL(ETrue));
 }
 else
 TBool /*aUpdateRequired*/
 #else
 TBool aUpdateRequired
 #endif // CANVAS_DIRECT_ACCESS
 ) :
 CCoeControl()
 ,iEnv(aEnv)
 #ifdef CANVAS_DOUBLE_BUFFER
 ,iFrameBuffer(NULL)
 #endif // CANVAS_DOUBLE_BUFFER
 ,iIsGameCanvas((
 aComponentType == MMIDComponent::EGameCanvas ? ETrue : EFalse))
 ,iFlags(EPostKeyEvents)
 ,iFullScreen(EFalse)
 ,iScalingOn(EFalse)
 ,iS60SelectionKeyCompatibility(EFalse)
 ,iRestoreContentWhenUnfaded(EFalse)
 ,iLastFadeMessage(0)
 #ifdef CANVAS_DIRECT_ACCESS
 ,iDcDsaToStart(EFalse)
 #endif // CANVAS_DIRECT_ACCESS
 ,iDragEventsStartedInside(EFalse)
 ,iFirstPaintState(EFirstPaintNeverOccurred)
 {
 DEBUG("+ CMIDCanvas::CMIDCanvas - EDirectEnabled");
 #ifdef CANVAS_DIRECT_ACCESS
 iFlags |= (EDirectPaused | EDirectEnabled | EUpdateRequired);
 // ---------------------------------------------------------------------------
 //
 void CMIDCanvas::HandleFullOrPartialForegroundL(
 TBool aFullOrPartialFg, TBool aCurrentDisplayable)
 {
-if (!aFullOrPartialFg && aCurrentDisplayable)
+if (!aFullOrPartialFg)
 {
 FreeGraphicsMemory(ETrue);
 }
-else if (!iPrevM3GContent && iAlfCompositionPixelSource)
-{
+// If canvas is not the current displayable but visible when MIDlet has gained
-SuspendPixelSource();
+// foreground, need to invoke forced paint to get content updated on screen
-ActivatePixelSourceL(ETrue);
+if (aFullOrPartialFg && !aCurrentDisplayable && IsVisible())
+{
+PostForcedPaint();
 }
 }
 // ---------------------------------------------------------------------------
 // CMIDCanvas::FreeGraphicsMemory
 void CMIDCanvas::MidletExiting()
 {
 iExiting = ETrue;
 TRAP_IGNORE(UpdateOffScreenBitmapL(ETrue));
 DrawToWindowGc();
+}
+// ---------------------------------------------------------------------------
+// CMIDCanvas::IsVideoOverlayActive
+// ---------------------------------------------------------------------------
+//
+TBool CMIDCanvas::IsVideoOverlayActive()
+{
+if (iEnv.VideoOverlayEnabled() && !iIsGameCanvas)
+{
+// This method is called also from CMIDGraphics.
+// Need to check here if MMAPI video area was removed by calling CheckDirectContentUpdated()
+// in order that lcdgr can use the correct alpha blending
+// (opaque or transparent target, see CMIDGraphcis.cpp and lcd16ma.cpp).
+TBool ret = iDisplayable->DirectContentsCount() > 0;
+CheckDirectContentUpdated();
+return ret;
+}
+else
+{
+return EFalse;
+}
 }
 // ---------------------------------------------------------------------------
 // CMIDCanvas::BlitFrameBufferPixels
 // Sets up OpenGL state for 2D texture rendering and renders the textures for
 {
 TInt posPacked  = 0;
 TInt sizePacked = (iContentSize.iWidth << 16) | (iContentSize.iHeight);
 PostEvent(EForcedPaint, posPacked, sizePacked);
 }
+// ---------------------------------------------------------------------------
+// CMIDCanvas::CheckDirectContentUpdated
+// Restores opaque alpha channel to direct content areas in
+// framebuffer bitmap after video is removed from canvas.
+// ---------------------------------------------------------------------------
+//
+void CMIDCanvas::CheckDirectContentUpdated()
+{
+if (iEnv.VideoOverlayEnabled() && iMMAPIAreaUpdated)
+{
+// iMMAPIAreaUpdated is modified in LCDUI and MMAPI threads.
+// Lock must be released before GetDirectContentsRegion().
+RCriticalSection& lock(iEnv.GetMMAPILock());
+lock.Wait();
+iMMAPIAreaUpdated = EFalse;
+lock.Signal();
+RRegion clearedRegion;
+RRegion directContentRegion;
+iDisplayable->GetDirectContentsRegion(directContentRegion);
+clearedRegion.AddRect(TRect(iFrameBuffer->SizeInPixels()));
+clearedRegion.SubRegion(directContentRegion);
+iFrameContext->CancelClipping();
+iFrameContext->SetClippingRegion(clearedRegion);
+iFrameContext->SetBrushColor(KOpaqueBlackColor);
+iFrameContext->SetDrawMode(CGraphicsContext::EDrawModeOR);
+iFrameContext->Clear();
+// Restore full clip area
+iFrameContext->CancelClipping();
+clearedRegion.Close();
+directContentRegion.Close();
+}
+}
 #endif // RD_JAVA_NGA_ENABLED
 // End of File.

branch	RCL_3
changeset 77	7cee158cb8cd
parent 71	d5e927d5853b
child 83	26b2b12093af