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

equal deleted inserted replaced

-:0fd27995241b
+:9ac0a0a7da70
 sizeof(TBitBltData) / sizeof(TMIDBufferOp))));
 return *static_cast< const TBitBltData* >(aOp->Data());
 }
+#ifdef RD_JAVA_NGA_ENABLED
 // ---------------------------------------------------------------------------
 // IsDownScaling
 // Check if downscaling in use.
 // @param aSourceSize Source rect size.
 // @param aDestRect Destination rect.
 // ---------------------------------------------------------------------------
 //
-inline TBool IsDownScaling(const TSize& aSourceSize, const TRect& aDestRect)
+inline TBool IsDownScaling(const TSize& aSourceSize, const TRect& aDestRect, TBool aM3GContent)
 {
+// if m3G is drawing then downscaling is turn off
+if (aM3GContent)
+{
+return EFalse;
+}
 return (aSourceSize.iWidth > aDestRect.Width() ||
 aSourceSize.iHeight > aDestRect.Height());
 }
+#else
+// ---------------------------------------------------------------------------
+// IsDownScaling
+// Check if downscaling in use.
+// @param aSourceSize Source rect size.
+// @param aDestRect Destination rect.
+// ---------------------------------------------------------------------------
+inline TBool IsDownScaling(const TSize& aSourceSize, const TRect& aDestRect)
+{
+return (aSourceSize.iWidth > aDestRect.Width() ||
+aSourceSize.iHeight > aDestRect.Height());
+}
+#endif //RD_JAVA_NGA_ENABLED
 // ======== MEMBER FUNCTIONS ========
 // ---------------------------------------------------------------------------
 // CMIDCanvas::NewL
 // Two-phased constructor. Use this method to create a CMIDCanvas instance.
 // (other items are commented in the header file)
 // ---------------------------------------------------------------------------
 //
 void CMIDCanvas::SetFocusedComponent(MMIDCustomComponent* aComponent)
 {
-if (aComponent == NULL)
+if (!aComponent)
 {
 iFocusedComponent = KComponentFocusedNone;
 iPressedComponent = NULL;
 }
 else
 iDirectContents.Count() == 0)
 {
 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 (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);
 }
 aRead += aRead->Size();
 }
 #endif // CANVAS_DOUBLE_BUFFER
 if (iFirstPaintState == EFirstPaintNeverOccurred)
 {
 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();
 }
 else
 // The window is not visible, the start screen snapshot
 // will be taken when the canvas will be set current.
 iFirstPaintState = EFirstPaintInitiated;
 }
 }
 DEBUG("- CMIDCanvas::ProcessL");
 return EFalse;
 }
 #endif // RD_JAVA_NGA_ENABLED
 DrawWindowNgaL(aRect);
 }
 else
 {
 // Must draw via CCoeControl framework
-DrawNow(aRect);
+if (iFullScreen && iScalingOn)
+{
+DrawNow(iViewRect);
+}
+else
+{
+DrawNow(aRect);
+}
 }
 // This is needed to avoid artifacting after orientation switch.
 // It is called once after orientation change.
 if (iWndUpdate)
 if (eglSwapBuffers(iEglDisplay, iEglWindowSurface) == EGL_FALSE)
 {
 ELOG1(EJavaUI, "eglSwapBuffers() failed, eglError=%d", eglGetError());
 ASSERT(EFalse);
 }
 SetCurrentEglType(EEglNone);
 if (iFirstPaintState != EFirstPaintOccurred)
 {
 iFirstPaintState = EFirstPaintOccurred;
 java::ui::CoreUiAvkonLcdui::getInstance().getJavaUiAppUi()->stopStartScreen();
 }
 if (iViewRect.Size() == iContentSize)
 {
 DEBUG("DrawWindow - Not scaled - BitBlt");
 gc.BitBlt(windowRect.iTl, iFrameBuffer, windowRect);
 }
-else if (IsDownScaling(iContentSize, iViewRect))
+else
-{
+#ifdef RD_JAVA_NGA_ENABLED
-DEBUG("DrawWindow - Downscaling - BitBlt");
+if (IsDownScaling(iContentSize, iViewRect, iM3GContent))
-gc.BitBlt(windowRect.iTl, iFrameBuffer, windowRect.Size());
+#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.
 CFbsBitmap* map = iScaler->Process(
 iFrameBuffer->DisplayMode(),
 pixelData,
 iContentSize.iWidth,
 iContentSize.iHeight,
 iFrameBuffer->SizeInPixels().iWidth - iContentSize.iWidth,
 iViewRect.Width(),
 iViewRect.Height());
 iFrameBuffer->UnlockHeap();
 if (map)
 {
 DEBUG("DrawWindow - Upscaling - BitBlt - map ok");
 gc.BitBlt(windowRect.iTl, map, windowRect.Size());
 }
 else
 {
 DEBUG("DrawWindow - Upscaling - DrawBitmap - no map");
 gc.DrawBitmap(windowRect, iFrameBuffer, iContentSize);
 }
 }
 #ifdef RD_JAVA_NGA_ENABLED
 iCoeEnv->WsSession().Finish();
 #endif
 }
 if (aType == KEikDynamicLayoutVariantSwitch)
 {
 // If orientation change is done,
 // then we have to inform all components about it.
-if (iFocusedComponent != KComponentFocusedNone &&
+if (iFullScreen && iScalingOn)
-iFullScreen)
 {
 for (int i = 0; i < iCustomComponents.Count(); i++)
 {
 iCustomComponents[i]->HandleResolutionChange();
 }
 {
 iCustomComponents[iFocusedComponent]->
 CustomComponentControl(KComponentMainControl)->
 SetFocus(EFalse);
 }
 #ifdef RD_JAVA_NGA_ENABLED
 // Avoid the situation when the content is drawn over the menu
 SuspendPixelSource();
 #endif // RD_JAVA_NGA_ENABLED
 // Repaint to ensure that fading will be displayed correctly for Alert
 // or PopupTextBox when DSA is paused.
 DrawDeferred();
 }
 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)
 {
 DEBUG("+ CMIDCanvas::CMIDCanvas - EDirectEnabled");
 #ifdef CANVAS_DIRECT_ACCESS
 iFlags |= (EDirectPaused | EDirectEnabled | EUpdateRequired);
 // ---------------------------------------------------------------------------
 //
 void CMIDCanvas::HandleForeground(TBool aForeground)
 {
 DEBUG_INT("CMIDCanvas::HandleForeground(%d) ++", aForeground);
 iForeground = aForeground;
 #ifdef RD_JAVA_NGA_ENABLED
 if (!iForeground)
 {
 }
 SuspendPixelSource();
 }
 #endif // RD_JAVA_NGA_ENABLED
 DEBUG("CMIDCanvas::HandleForeground --");
 }
 #ifdef RD_JAVA_NGA_ENABLED
 if (iDirectContents.Count() > 0)
 {
 return;
 }
 // ProduceNewFrameL() is called in some cases
 // directly from ActivateSyncL(), need to set iFrameReady
 // before ActivateSyncL()
 iFrameReady = ETrue;
 TRAPD(err, iAlfCompositionPixelSource->ActivateSyncL());
 if (err != KErrNone)
 res = EFalse;
 }
 else
 {
 NotifyMonitor();
 TUint8* from = (TUint8*)iFrameBuffer->DataAddress();
-TBool downScaling = IsDownScaling(iContentSize, iViewRect);
+TBool downScaling = IsDownScaling(iContentSize, iViewRect, iM3GContent);
 TInt width =  downScaling ? iViewRect.Width()  : iContentSize.iWidth;
 TInt height = downScaling ? iViewRect.Height() : iContentSize.iHeight;
 TUint bytes = width * KBytesPerPixel;
 TInt scanLength = CFbsBitmap::ScanLineLength(
 iFrameBuffer->SizeInPixels().iWidth, iFrameBuffer->DisplayMode());
 for (TInt y = 0; y < height; ++y)
 {
 Mem::Copy(aBuffer, from, bytes);
 aBuffer += iAlfBufferAttributes.iStride;
 from += scanLength;
 }
 res = ETrue;
 }
 if (iFirstPaintState == EFirstPaintInitiated || iFirstPaintState == EFirstPaintPrepared)
 {
 if (iFirstPaintState == EFirstPaintInitiated)
 {
 iFirstPaintState = EFirstPaintPrepared;
 {
 iFirstPaintState = EFirstPaintOccurred;
 java::ui::CoreUiAvkonLcdui::getInstance().getJavaUiAppUi()->stopStartScreen();
 }
 }
 DEBUG("CMIDCanvas::ProduceNewFrameL --");
 return res;
 }
 // ---------------------------------------------------------------------------
 // From MAlfBufferProvider
 MAlfBufferProvider::TBufferCreationAttributes& CMIDCanvas::BufferAttributes()
 {
 DEBUG_INT2("CMIDCanvas::BufferAttributes - iContentSize(w=%d, h=%d) ++",
 iContentSize.iWidth, iContentSize.iHeight);
-TBool downScaling = IsDownScaling(iContentSize, iViewRect);
+TBool downScaling = IsDownScaling(iContentSize, iViewRect, iM3GContent);
 iAlfBufferAttributes.iWidth  = downScaling ? iViewRect.Width() : iContentSize.iWidth;
 iAlfBufferAttributes.iHeight = downScaling ? iViewRect.Height() : iContentSize.iHeight;
 iAlfBufferAttributes.iStride = iAlfBufferAttributes.iWidth * KBytesPerPixel;
 return iAlfBufferAttributes;
 iM3GContent = EFalse;
 iM3GStart = EFalse;
 iEglPendingResize = EFalse;
 iEglPendingDispose = EFalse;
+PostEvent(EM3GDraw, iM3GContent, 0);
 if (iEglDisplay == EGL_NO_DISPLAY)
 {
 return;
 }
 if (!IsEglAvailable())
 {
 return EFalse;
 }
 TEglType current = GetCurrentEglType();
-if (aSurfaceType == EEglNone || aRgba == NULL)
+if (aSurfaceType == EEglNone || !aRgba)
 {
 if (iScalingOn && iFullScreen)
 {
 if (aSurfaceType == EEglNone)
 {
 aSurfaceType = EEglPbuffer;
 }
-if (aRgba == NULL)
+if (!aRgba)
 {
 glClearColor(0.f, 0.f, 0.f, 1.f);
 }
 }
 else
 {
 if (aSurfaceType == EEglNone)
 {
 aSurfaceType = EEglWindow;
 }
-if (aRgba == NULL)
+if (!aRgba)
 {
 glClearColor(1.f, 1.f, 1.f, 1.f);
 }
 }
 }
 SetCurrentEglType(aSurfaceType);
-if (aRgba != NULL)
+if (aRgba)
 {
 glClearColor(
 aRgba->Red() / 255.f, aRgba->Green() / 255.0f,
 aRgba->Blue() / 255.0f, aRgba->Alpha() / 255.0f);
 }
 {
 return;
 }
 TRect rect(aRect);
-TRect canvasRect = IsDownScaling(iContentSize, iViewRect) ?
+TRect canvasRect = IsDownScaling(iContentSize, iViewRect, iM3GContent) ?
 TRect(iViewRect.Size()) : TRect(iContentSize);
 rect.Intersection(canvasRect);
 // Update the member rects
 if (iUpperUpdateRect.Intersects(rect))
 return KEglBadNativeWindow;
 }
 return KEglSuccess;
 }
 #endif // RD_JAVA_NGA_ENABLED
 // End of File.

branch	RCL_3
changeset 25	9ac0a0a7da70
parent 24	0fd27995241b
child 34	71c436fe3ce0