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

equal deleted inserted replaced

-:7cee158cb8cd
+:26b2b12093af
 (iFocusedComponent < iCustomComponents.Count()) &&
 (iCustomComponents[iFocusedComponent]->
 CustomComponentControl(KComponentMainControl)->IsVisible()))
 {
 // Traversal check
-if ((aType == EEventKey) &&
+if ((aType == EEventKeyDown) &&
 (((aEvent.iCode == EKeyUpArrow) ||
 (aEvent.iCode == EKeyDownArrow)) ||
 ((aEvent.iScanCode == EStdKeyUpArrow) ||
 (aEvent.iScanCode == EStdKeyDownArrow))))
 {
 ASSERT(!iAlfMonitor);
 aRead = aEnd;
 return EFalse;
 }
-// Usually only one op code is processed by Canvas.
+switch (aRead->OpCode())
-// Exception is the video overlay case, where MIDlet
+{
-// does not draw anything inside Canvas.paint().
+case EDrwOpcM3GContentStart:
-// In this case EDrwOpcPaintStarted and EDrwOpcBitBltRect/EDrwOpcBitBlt
+{
-// are received in one ProcessL(). Also EDrwOpcPaintStarted and EDrwOpcM3GContentStart
+// EGL surface is created if canvas window is currently visible
-// may be processed in one ProcessL(), if overlays are enabled.
+// even if MIDlet would be on background.
-while (aRead < aEnd)
+if (!iM3GContent &&
-{
+i3DAccelerated &&
-switch (aRead->OpCode())
+iDirectContents.Count() == 0 &&
-{
+IsWindowVisible())
-case EDrwOpcM3GContentStart:
+{
-{
+DEBUG("CMIDCanvas::ProcessL - M3G content start");
-// EGL surface is created if canvas window is currently visible
+iM3GContent = ETrue;
-// even if MIDlet would be on background.
+iM3GStart = ETrue;
-if (!iM3GContent &&
+PostEvent(EM3GDraw, iM3GContent, 0);
-i3DAccelerated &&
+// First time when M3G content is drawn =>
-iDirectContents.Count() == 0 &&
+// switch to EGL surface drawing.
-IsWindowVisible())
+// 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)
 {
-DEBUG("CMIDCanvas::ProcessL - M3G content start");
+CreatePBufferSurfaceL();
-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
-ASSERT(aRead + aRead->Size() == aEnd);
+// the EGL window surface.
-}
+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:
+}
-{
-if (iFirstPaintState == EFirstPaintNeverOccurred)
+aRead += aRead->Size();
-{
-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::MdcAddMMAPIContentBounds(const TRect& aRect)
+void CMIDCanvas::MdcAddContentBounds(const TRect& aRect)
 {
 if (iDisplayable)
 {
 iDisplayable->AddDirectContentArea(aRect);
 }
 // From class MDirectContainer.
 // CMIDCanvas::MdcRemoveContentBounds
 // Removes a rectangle to be excluded from redrawing.
 // ---------------------------------------------------------------------------
 //
-void CMIDCanvas::MdcRemoveMMAPIContentBounds(const TRect& aRect)
+void CMIDCanvas::MdcRemoveContentBounds(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 (iCustomComponents.Find(aComponent) == KErrNotFound)
 {
 DEBUG("CMIDCanvas::RegisterComponentL, registering new");
-iCustomComponents.AppendL(aComponent);
+iCustomComponents.Append(aComponent);
 // Update custom components count in order to improve
 // the performance when counting components
 iCustomComponentsControlCount +=
 aComponent->CustomComponentControlCount();
 }
 // Remove the old index from the components array.
 iCustomComponents.Remove(index);
-iCustomComponents.InsertL(aComponent, aNewIndex);
+// Add the component to the new index. Note that the array
+// should contain memory for all the components since
+// Remove should not decrease the memory used by the array
+// Therefore, the following operation is leave-safe and
+// return value is ignored intentionally.
+iCustomComponents.Insert(aComponent, aNewIndex);
 // Redraw the whole canvas.
 DrawDeferred();
 }
 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);
 }
 {
 iPointerEventSuppressionOngoing = EFalse;
 }
 // To have the cursor on focused control
-if ((iFocusedComponent != KComponentFocusedNone) &&
+if (iFocusedComponent != KComponentFocusedNone)
-(iFocusedComponent < iCustomComponents.Count()) &&
-iCustomComponents[iFocusedComponent]->
-CustomComponentControl(KComponentMainControl)->IsVisible())
 {
 iCustomComponents[iFocusedComponent]->
 CustomComponentControl(KComponentMainControl)->
 SetFocus(ETrue);
 }
 HandleSizeChanged(landscape != iLandscape);
 iLandscape = landscape;
 PostEvent(ESizeChanged, iContentSize.iWidth, iContentSize.iHeight);
 if (IsWindowVisible() && iWndUpdate)
 {
 // Post forced paint to enable Canvas repaint behind
 // Alert or Pop-up TextBox
 PostForcedPaint();
 }
 #else
 iContentSize = contentSize;
 PostEvent(ESizeChanged, iContentSize.iWidth, iContentSize.iHeight);
 #endif // RD_JAVA_NGA_ENABLED
 }
 }
 // We cannot determine whether the control size actually did change or
 // not, so we have to do the layout no matter what.
 Layout();
-#ifdef RD_JAVA_NGA_ENABLED
-if (IsWindowVisible() && iWndUpdate)
-{
-// Post forced paint to enable Canvas repaint behind
-// Alert or Pop-up TextBox
-PostForcedPaint();
-}
-#endif // RD_JAVA_NGA_ENABLED
 }
 DEBUG("- CMIDCanvas::SizeChanged");
 }
 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);
 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
 // updated frame buffer areas by calling BlitSubRect().
 // ---------------------------------------------------------------------------
 //
 {
 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 83	26b2b12093af
parent 77	7cee158cb8cd