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

equal deleted inserted replaced

-:9ac0a0a7da70
+:71c436fe3ce0
 const TInt KPhoneScreen = 0;
 // The color that is used to clear the framebuffer when
 // mixing 3D & 2D rendering
 #define KTransparentClearColor TRgb(0x000000, 0x0)
 #define KOpaqueClearColor      TRgb(0xFFFFFF, 0xFF)
+#define KOpaqueBlackColor      TRgb(0x000000, 255)
 #ifdef _DEBUG
 #define ASSERT_GL() AssertGL()
 #else
 #define ASSERT_GL()
 // create a pbuffer surface to be used with m3g rendering
 if (iScalingOn && iFullScreen)
 {
 CreatePBufferSurfaceL();
 }
-// Draw all framebuffer content to EGL surface.
+// Draw the whole framebuffer content (as a texture) on top of
+// the EGL window surface.
 iUpperUpdateRect = TRect(Size());
 UpdateEglContent();
 }
 }
 break;
 // Unregistration is done in destructor.
 #ifdef RD_JAVA_NGA_ENABLED
 iEnv.ToLcduiObserver().RegisterControl(*this, this);
 #else
 iEnv.ToLcduiObserver().RegisterControl(*this);
-#endif
+#endif // RD_JAVA_NGA_ENABLED
+#ifdef RD_JAVA_NGA_ENABLED
+if (iFirstPaintState != EFirstPaintOccurred &&
+iDirectContents.Count() == 1)
+{
+// The first canvas paint using NGA might be interrupted
+// by addition of the direct content.
+// Invoking repaint event to restore the first paint.
+TInt posPacked  = (iViewRect.iTl.iX << 16) | (iViewRect.iTl.iY);
+TSize size = iViewRect.Size();
+TInt sizePacked = (size.iWidth << 16) | (size.iHeight);
+PostEvent(EPaint, posPacked, sizePacked);
+}
+#endif // RD_JAVA_NGA_ENABLED
 }
 // ---------------------------------------------------------------------------
 // From class MDirectContainer.
 // DrawNow need to be called, otherwise  Canvas will be unfaded
 if (iDirectContents.Count() == 0 && !iRestoreContentWhenUnfaded && IsFocused())
 {
 // In case direct content content was removed
 // from canvas, recreate pixel source here
-if (!iAlfCompositionPixelSource &&
+if (!iAlfCompositionPixelSource && !IsEglAvailable())
-!IsEglAvailable())
 {
 InitPixelSourceL();
 }
 DrawWindowNgaL(aRect);
 }
 DrawNow(iViewRect);
 }
 else
 {
 DrawNow(aRect);
+}
+#ifdef RD_JAVA_NGA_ENABLED
+iCoeEnv->WsSession().Finish();
+#endif
+if (iFirstPaintState == EFirstPaintInitiated ||
+iFirstPaintState == EFirstPaintPrepared)
+{
+// NGA is not used, StartScreen can be informed now
+if (iForeground)
+{
+// The canvas is current, therefore we can flush
+// the graphics and take the start screen snapshot.
+iFirstPaintState = EFirstPaintOccurred;
+java::ui::CoreUiAvkonLcdui::getInstance().getJavaUiAppUi()->stopStartScreen();
+}
 }
 }
 // This is needed to avoid artifacting after orientation switch.
 // It is called once after orientation change.
 if (iViewRect.Size() == iContentSize)
 {
 DEBUG("DrawWindow - Not scaled - BitBlt");
 gc.BitBlt(windowRect.iTl, iFrameBuffer, windowRect);
 }
-else
 #ifdef RD_JAVA_NGA_ENABLED
-if (IsDownScaling(iContentSize, iViewRect, iM3GContent))
+else if (IsDownScaling(iContentSize, iViewRect, iM3GContent))
 #else
-if (IsDownScaling(iContentSize, iViewRect))
+else if (IsDownScaling(iContentSize, iViewRect))
 #endif //RD_JAVA_NGA_ENABLED
 {
 DEBUG("DrawWindow - Downscaling - BitBlt");
 gc.BitBlt(windowRect.iTl, iFrameBuffer, windowRect.Size());
 }
 // Upscaling
 else if (iScaler)
 {
 iFrameBuffer->LockHeap();
 TUint32* pixelData = iFrameBuffer->DataAddress();
+// Scale the framebuffer content.
-// Scale the framebuffer content.
+CFbsBitmap* map = iScaler->Process(
-CFbsBitmap* map = iScaler->Process(
+iFrameBuffer->DisplayMode(),
-iFrameBuffer->DisplayMode(),
+pixelData,
-pixelData,
+iContentSize.iWidth,
-iContentSize.iWidth,
+iContentSize.iHeight,
-iContentSize.iHeight,
+iFrameBuffer->SizeInPixels().iWidth - iContentSize.iWidth,
-iFrameBuffer->SizeInPixels().iWidth - iContentSize.iWidth,
+iViewRect.Width(),
-iViewRect.Width(),
+iViewRect.Height());
-iViewRect.Height());
+iFrameBuffer->UnlockHeap();
-iFrameBuffer->UnlockHeap();
+if (map)
-if (map)
+{
-{
+DEBUG("DrawWindow - Upscaling - BitBlt - map ok");
-DEBUG("DrawWindow - Upscaling - BitBlt - map ok");
+gc.BitBlt(windowRect.iTl, map, windowRect.Size());
-gc.BitBlt(windowRect.iTl, map, windowRect.Size());
+}
-}
+else
-else
+{
-{
+DEBUG("DrawWindow - Upscaling - DrawBitmap - no map");
-DEBUG("DrawWindow - Upscaling - DrawBitmap - no map");
+gc.DrawBitmap(windowRect, iFrameBuffer, iContentSize);
-gc.DrawBitmap(windowRect, iFrameBuffer, iContentSize);
+}
 }
-}
-#ifdef RD_JAVA_NGA_ENABLED
-iCoeEnv->WsSession().Finish();
-#endif
 DEBUG("CMIDCanvas::DrawWindow --");
 }
 #endif // CANVAS_DOUBLE_BUFFER
 {
 iCustomComponents[iFocusedComponent]->
 CustomComponentControl(KComponentMainControl)->
 SetFocus(ETrue);
 }
-// Redraw the canvas after unfading
-DrawDeferred();
 #ifdef RD_JAVA_NGA_ENABLED
 // To avoid situation when Canvas is redrawn but black area remains
 if (iAlfCompositionPixelSource)
 {
 if (err != KErrNone)
 {
 DEBUG_INT("CMIDCanvas::FocusChanged - ActivatePixelSourceL error %d", err);
 }
 }
+else
+{
+// Redraw the canvas after unfading
+DrawDeferred();
+}
+#else // !RD_JAVA_NGA_ENABLED
+// Redraw the canvas after unfading
+DrawDeferred();
 #endif // RD_JAVA_NGA_ENABLED
 }
 else
 {
 // variable iWndUpdate is set to True. If iWndUpdate is True
 // DrawWindow() is called from method Update()
 // This is needed to avoid artifacting after orientation switch.
 TBool landscape = Layout_Meta_Data::IsLandscapeOrientation();
-if (iLandscape != landscape)
+if (iLandscape != landscape && !iAlfCompositionPixelSource)
 {
 iLandscape = landscape;
 iWndUpdate = ETrue;
 }
 else
 // already lost focus, then IsFocused is used
 if (iDirectContents.Count() > 0 || iRestoreContentWhenUnfaded || !IsFocused())
 {
 DrawWindow(aRect);
 }
-else if (iAlfCompositionPixelSource)
+else
 {
 CMIDCanvas* myself = const_cast<CMIDCanvas*>(this);
-TRAP_IGNORE(myself->ActivatePixelSourceL());
+myself->ClearUiSurface(ETrue);
+if (iAlfCompositionPixelSource)
+{
+TRAP_IGNORE(myself->ActivatePixelSourceL());
+}
 }
 iWndUpdate = EFalse;
 }
 if (!iStartUpTraceDone)
 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);
 User::Leave(err);
 }
 if (iPixelSourceSuspended)
 {
+ClearUiSurface(EFalse);
 iPixelSourceSuspended = EFalse;
 if (iFullScreen && iScalingOn)
 {
 iAlfCompositionPixelSource->SetExtent(iViewRect, KPhoneScreen);
 }
 }
 }
 // ---------------------------------------------------------------------------
+// CMIDCanvas::ClearUiSurface
+// ---------------------------------------------------------------------------
+//
+void CMIDCanvas::ClearUiSurface(TBool aDrawing)
+{
+if (!aDrawing)
+{
+Window().BeginRedraw();
+ActivateGc();
+}
+CWindowGc& gc = SystemGc();
+gc.SetBrushColor(KTransparentClearColor);
+gc.SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);
+gc.Clear();
+if (!aDrawing)
+{
+DeactivateGc();
+Window().EndRedraw();
+}
+iCoeEnv->WsSession().Finish();
+}
 // CMIDCanvas::SuspendPixelSource
 // ---------------------------------------------------------------------------
 //
 void CMIDCanvas::SuspendPixelSource()
 {
 NotifyMonitor();
-if (iAlfCompositionPixelSource)
+if (iAlfCompositionPixelSource && !iPixelSourceSuspended)
 {
 iAlfCompositionPixelSource->Suspend();
 iPixelSourceSuspended = ETrue;
 }
 }
 ELOG1(EJavaUI, "eglCopyBuffers() failed, eglError=%s",
 GetEglError(eglGetError()).Ptr());
 User::Leave(KErrUnknown);
 }
-// Make framebuffer opaque
+// Clear with opaque black so that EDrawModeOR can be used in BitBlt()
-iFrameContext->SetBrushColor(KOpaqueClearColor);
+iFrameContext->SetBrushColor(KOpaqueBlackColor);
 iFrameContext->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);
 iFrameContext->Clear();
+iFrameContext->SetDrawMode(CGraphicsContext::EDrawModeOR);
 iFrameContext->BitBlt(TPoint(), bitmap);
 CleanupStack::PopAndDestroy();
 SetCurrentEglType(current);
 // Make sure that full Canvas area

branch	RCL_3
changeset 19	71c436fe3ce0
parent 18	9ac0a0a7da70
child 21	4376525cdefb