--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/javauis/lcdui_akn/lcdui/inc/CMIDCanvas.h Tue Apr 27 16:30:29 2010 +0300
@@ -0,0 +1,1704 @@
+/*
+* Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: CMIDCanvas - Implements the native part of the Canvas class.
+*
+*/
+
+
+
+#ifndef CMIDCANVAS_H
+#define CMIDCANVAS_H
+
+/**
+ * Enables platform support for accelerated GDI operations.
+ *
+ * Used for creating of hardware bitmap (e.g. in LcdFbsImage.cpp) which can be
+ * used in hardware graphics accelerator if available.
+ *
+ * FIX for BITGDI failing to transparently support drawing to hardware
+ * bitmaps. Certain accelerator operations fail silently rather than falling
+ * back to software routines. If the licencee can be sure that their hardware
+ * accelerator supports all BITGDI operations then it may be worth
+ * uncommenting the following line.
+ */
+#define ACCELERATED_BITGDI 1
+
+/**
+ * Enables deffered BitBlting. With this flag on, CMIDCanvas counts BitBlt
+ * cycles and tries to optimize BitBlt process.
+ */
+#define DEFER_BITBLT 1
+
+/**
+ * Enables update invalidate method of drawing. Use RWindow::BeginRedraw and
+ * RWindow::EndRedraw to tell the window server when the window is about to
+ * respond to the last redraw event by redrawing.
+ */
+#define CANVAS_UPDATE_INVALIDATE 1
+
+/**
+ * Used double buffer for Canvas. Enabled by MIDP 2.1 specification.
+ *
+ * Define to switch on native double buffering in canvas. Canvas may still be
+ * double buffered in java even if this is switched off, however this has not
+ * been tested without JSR_135_SUPPORT.
+ */
+#define CANVAS_DOUBLE_BUFFER 1
+
+/**
+ * Enable direct screen access for Canvas when not using double buffering.
+ * Define to switch on direct access in canvas. Cannot be used without
+ * CANVAS_DOUBLE_BUFFER.
+ */
+#ifndef RD_JAVA_NGA_ENABLED
+#define CANVAS_DIRECT_ACCESS 1
+#endif // !RD_JAVA_NGA_ENABLED
+
+
+/**
+ * If canvas is using direct access itself, it must provide a native
+ * framebuffer.
+ */
+#ifdef CANVAS_DIRECT_ACCESS
+#ifndef CANVAS_DOUBLE_BUFFER
+#define CANVAS_DOUBLE_BUFFER
+#endif
+#endif
+
+/**
+ * Without a native framebuffer we cannot handle redraw events natively, but
+ * will have to generate a java repaint.
+ */
+#ifndef CANVAS_DOUBLE_BUFFER
+#define CANVAS_ASYNC_REPAINT
+#endif
+
+
+#include <w32std.h>
+#include <gulgcmap.h>
+#include <coemain.h>
+#include <coecntrl.h>
+
+#ifdef RD_JAVA_NGA_ENABLED
+#include <EGL/egl.h>
+#include <GLES/gl.h>
+#include <platform/mw/alf/alfcompositionclient.h>
+#include "monitor.h"
+#endif // RD_JAVA_NGA_ENABLED
+
+
+#include <lcdui.h>
+#include <reflcdui.h>
+#include <aknpointereventsuppressor.h>
+#include <MMIDCustomComponentContainer.h>
+
+
+/** MMIDMediaKeysListener in declaration. */
+#include "MMIDMediaKeysListener.h"
+
+/** Used CMIDDisplayable as member iDisplayable. */
+#include "CMIDDisplayable.h"
+
+
+class CMIDKeyDecoder;
+class CMIDScaler;
+class CMIDCallIndicator;
+class CMIDNetworkIndicator;
+class CMIDRemConObserver;
+class CMIDTactileFeedbackExtension;
+
+
+/**
+ * Drawable canvas control.
+ * Can be used as drawing surface of MIDP Canvas.
+ * Key events, game actions, pointer events and size change events are
+ * generated in the CMIDCanvas class. Whenever a key is pressed, that key is
+ * translated and an event is posted to the Java side.
+ *
+ * @lib lcdui.dll
+ * @since S60 v3.0
+ */
+NONSHARABLE_CLASS(CMIDCanvas) :
+ public CCoeControl,
+ public MMIDCanvas,
+ public MMIDBufferProcessor,
+ public MDirectContainer,
+#ifdef CANVAS_DIRECT_ACCESS
+ public MDirectScreenAccess,
+#endif
+ public MMIDMediaKeysListener,
+#ifdef RD_TACTILE_FEEDBACK
+ public MMIDTactileFeedbackComponent,
+#endif
+#ifdef RD_JAVA_NGA_ENABLED
+ public MAlfBufferProvider,
+#endif // RD_JAVA_NGA_ENABLED
+ public MMIDCustomComponentContainer
+{
+ /** CMIDNetworkIndicator is using protected function PostEvent. */
+ friend class CMIDNetworkIndicator;
+
+public:
+
+ /**
+ * Two-phased constructor.
+ *
+ * @param aEnv Environment object.
+ * @param aComponentType The component type, can be ECanvas
+ * or EGameCanvas.
+ * @param aUpdateRequired Update is requied.
+ */
+ static CMIDCanvas* NewL(
+ MMIDEnv& aEnv,
+ CCoeControl& aWindow,
+ MMIDComponent::TType aComponentType = MMIDComponent::ECanvas,
+ TBool aUpdateRequired = EFalse);
+
+ /**
+ * Destructor.
+ */
+ virtual ~CMIDCanvas();
+
+ /**
+ * Set fullscreen mode on/off.
+ *
+ * @since S60 v3.0
+ * @param aFullScreen The fullscreen mode state to be set.
+ */
+ void FullScreen(TBool aFullScreen);
+
+ /**
+ * Tells whether scaling is on or off.
+ *
+ * @since S60 v3.0
+ * @return ETrue if scaling is on, otherwise returns EFalse.
+ */
+ TBool IsScalingOn();
+
+ /**
+ * Tells whether application attribute
+ * Nokia-MIDlet-S60-Selection-Key-Compatibility is set true or not.
+ *
+ * @since S60 v5.0
+ * @return ETrue if the attribute value is true, otherwise returns EFalse.
+ */
+ TBool SelectionKeyCompatibility();
+
+
+// from base class CCoeControl
+
+ /**
+ * Counts the number of compound controls in this CCoeControl.
+ *
+ * @return The number of compound controls in this CCoeControl
+ * @since S60 5.0
+ */
+ TInt CountComponentControls() const;
+
+ /**
+ * Returns the compound control in the specified index.
+ *
+ * @param aIndex The index of the control to be retrieved.
+ * @return The control in the specified index or NULL if there
+ * is no control in that index.
+ * @since S60 5.0
+ */
+ CCoeControl* ComponentControl(TInt aIndex) const;
+
+ /**
+ * From CCoeControl.
+ * Process a key event.
+ *
+ * @since S60 v3.0
+ * @param aKeyEvent Key event.
+ * @param aType Event code.
+ * @return Key response.
+ */
+ TKeyResponse OfferKeyEventL(
+ const TKeyEvent& aKeyEvent,
+ TEventCode aType);
+
+
+// from base class MMIDCanvas
+
+ /**
+ * From MMIDComponent.
+ * Invoked by the framework to clean up any resources used by the
+ * implementation. Deletes this.
+ *
+ * @since S60 v3.0
+ */
+ void Dispose();
+
+ /**
+ * From MMIDComponent.
+ * Returns the component type as a MMIDComponent::TType enum.
+ *
+ * @since S60 v3.0
+ * @return Always returns MMIDComponent::ECanvas.
+ */
+ MMIDComponent::TType Type() const;
+
+ /**
+ * From MMIDComponent.
+ * Returns buffer processor associated with this component.
+ *
+ * @since S60 v3.0
+ * @return Always returns this.
+ */
+ MMIDBufferProcessor* Processor();
+
+ /**
+ * From MMIDCancas.
+ * Returns a reference to the CCoeControl corresponding to this canvas.
+ *
+ * @since S60 v3.0
+ * @return Reference to the CCoeControl corresponding to this canvas.
+ */
+ CCoeControl& Control();
+
+ /**
+ * From MMIDCancas.
+ * Double buffering support.
+ *
+ * Returns the frame buffer.
+ *
+ * @since S60 v3.0
+ * @return A pointer to the frame buffer.
+ */
+ CFbsBitmap* FrameBuffer() const;
+
+ /**
+ * From MMIDCancas.
+ * Returns the size of the canvas content.
+ *
+ * @since S60 v3.0
+ * @return The size of the displayable content.
+ */
+ TSize ContentSize() const;
+
+ /**
+ * From MMIDCancas.
+ * Direct screen access support.
+ *
+ * Disables temporarily direct screen access.
+ *
+ * @since S60 v3.0
+ */
+ void PauseDirectAccess();
+
+ /**
+ * From MMIDCancas.
+ * Re-enables direct screen access.
+ *
+ * @since S60 v3.0
+ */
+ void ResumeDirectAccess();
+
+ /**
+ * From MMIDCancas.
+ * Switch off key event posting. Game keys will still be tracked, but
+ * keyPressed()/keyReleased() callbacks will not be called.
+ *
+ * @since S60 v3.0
+ */
+ void SuppressKeys();
+
+ /**
+ * From MMIDCancas.
+ * Returns the latched state of the game action keys.
+ *
+ * @since S60 v3.0
+ * @return The latched state of the game action keys.
+ */
+ TUint32 GameActions();
+
+ /**
+ * From MMIDCancas.
+ * Returns a direct container on which video can be rendered.
+ *
+ * @since S60 v3.0
+ * @return A container on which video can be rendered
+ */
+ MDirectContainer& DirectContainer();
+
+ /**
+ * From MMIDCancas.
+ * Draw a background image.
+ *
+ * @since S60 v3.2
+ * @param aGc Target graphical context
+ * @param aPosition Position
+ * @param aSize Size
+ */
+ void DrawBackground(
+ CBitmapContext& aGc,
+ const TPoint& aPosition,
+ const TSize& aSize);
+
+ /**
+ * From MMIDCancas.
+ * Returns the type of Canvas object.
+ *
+ * @since S60 v3.2
+ * @return ETrue if the type is
+ * MMIDComponent::EGameCanvas and EFalse
+ * when the type is MMIDComponent::ECanvas.
+ */
+ TBool IsGameCanvas() const;
+
+ /**
+ * From MMIDCancas.
+ * Gets a network indicator location and size on fullscreen Canvas.
+ *
+ * @since S60 v5.0
+ * @param aPosition Returned top left position of network indicator
+ * @param aSize Returned size of nw indicator
+ * @return EFalse if Canvas is not able to display nw indicator (not
+ * fullscreen), otherwise ETrue.
+ */
+ TBool NetworkIndicatorLocation(TPoint& aPosition, TSize& aSize) const;
+
+
+#ifdef RD_TACTILE_FEEDBACK
+ /**
+ * From MMIDCancas.
+ * Get tactile feedback component.
+ *
+ * @since S60 v5.0
+ * @return this as tactile feedback component.
+ */
+ MMIDTactileFeedbackComponent* TactileFeedbackComponent();
+#endif // RD_TACTILE_FEEDBACK
+
+
+// from base class MMIDBufferProcessor
+
+ /**
+ * From MMIDBufferProcessor.
+ * Process a block of commands, updating read pointer as you go.
+ *
+ * @since S60 v3.0
+ * @param aRead The address of the first command in the buffer for this
+ * processor.
+ * @param aEnd The address of the command *after* the last command in the
+ * buffer for this processor.
+ * @param aCycles The amount of 'compute effort' remaining in the current
+ * AO RunL.
+ * @param aStatus The request status.
+ * @return Returns ETrue if processing will be async.
+ */
+ TBool ProcessL(
+ const TMIDBufferOp*& aRead,
+ const TMIDBufferOp* aEnd,
+ TInt& aCycles,
+#ifdef RD_JAVA_NGA_ENABLED
+ java::util::Monitor* aMonitor);
+#else
+ TRequestStatus* aStatus = NULL);
+#endif
+
+ /**
+ * From MMIDBufferProcessor.
+ * Called by framework if the processor is doing some async operation
+ * when the MIDlet is closed down. Processor should cancel the async
+ * operation and clean up any resources.
+ *
+ * @since S60 v3.0
+ */
+ void AbortAsync();
+
+
+#ifdef CANVAS_DIRECT_ACCESS
+// from base class MDirectScreenAccess
+
+ /**
+ * From MAbortDirectScreenAccess.
+ * This function is called by the window server when direct screen access
+ * must stop (for example because a dialogue is moved in front of the area
+ * where direct screen access is taking place).
+ *
+ * @since S60 v3.0
+ * @param aReason The reason why direct screen access was terminated.
+ */
+ void AbortNow(RDirectScreenAccess::TTerminationReasons aReasons);
+
+ /**
+ * From MDirectScreenAccess.
+ * This function is called by the window server as soon as direct screen
+ * access can resume.
+ *
+ * @since S60 v3.0
+ * @param aReason Provides the reason why direct screen access was
+ * terminated.
+ */
+ void Restart(RDirectScreenAccess::TTerminationReasons aReasons);
+#endif // CANVAS_DIRECT_ACCESS
+
+
+// from base class MDirectContainer
+
+ /**
+ * From MDirectContainer.
+ * Set the content of this direct container.
+ *
+ * @since S60 v3.0
+ * @param aContent Content which is displayed on this container.
+ */
+ void MdcAddContent(MDirectContent* aContent);
+
+ /**
+ * From MDirectContainer.
+ * Remove the content from this direct container. This will called when
+ * the Player is closed.
+ *
+ * @since S60 v3.0
+ * @param aContent Content which is displayed on this container.
+ */
+ void MdcRemoveContent(MDirectContent* aContent);
+
+ /**
+ * From MDirectContainer.
+ * Add content bound to this direct container.
+ * Container will not allow painting in this region.
+ *
+ * @since S60 v3.0
+ * @param aRect Content bounds.
+ */
+ void MdcAddContentBounds(const TRect& aRect);
+
+ /**
+ * From MDirectContainer.
+ * Removes one content bound from this direct container.
+ *
+ * @since S60 v3.2
+ * @param aRect Content bound to be removed.
+ */
+ void MdcRemoveContentBounds(const TRect& aRect);
+
+ /**
+ * From MDirectContainer.
+ * Get rect of a window on which content of this direct container can be
+ * displayed.
+ *
+ * @since S60 v3.2
+ * @return Rect of a window.
+ */
+ TRect MdcContainerWindowRect() const;
+
+ /**
+ * From MDirectContainer.
+ * Get the visiblity of this direct container.
+ *
+ * @since S60 v3.0
+ * @return ETrue if the container is visible, EFalse if it is
+ * invisible.
+ */
+ TBool MdcContainerVisibility() const;
+
+ /**
+ * From MDirectContainer.
+ * Get the bounds of the area that the content of this direct container
+ * can occupy.
+ *
+ * @since S60 v3.0
+ * @return Maximum area that the content can occupy in screen
+ * co-ordinates.
+ */
+ TRect MdcContentBounds() const;
+
+ /**
+ * From MDirectContainer.
+ * Get the area on the Item on which content can be displayed.
+ *
+ * @since S60 v3.0
+ * @param aContentRect Return parameter for content area in Item
+ * co-ordinates.
+ * @param aScreenRect Return parameter for content area in screen
+ * co-ordinates.
+ */
+ void MdcItemContentRect(TRect& aContentRect, TRect& aScreenRect) const;
+
+ /**
+ * From MDirectContainer.
+ * Allows a control created for direct container content display to pass
+ * on pointer events.
+ *
+ * @since S60 v3.0
+ * @param aPointerEvent The pointer event. iPosition will be reset to the
+ * parent window position. iParentPosition will be invalid for the
+ * container.
+ */
+ void MdcHandlePointerEventL(TPointerEvent& aPointerEvent);
+
+ /**
+ * From MDirectContainer.
+ * Flush the direct container content.
+ *
+ * @since S60 v3.2
+ * @param aContentRect The content area to be proceeded.
+ */
+ void MdcFlushContainer(const TRect& aRect);
+
+ /**
+ * From MDirectContainer.
+ * Invokes callback aConsumer->MdcDSAResourcesCallback in LCDUI thread.
+ * Used in case when MMAPI needs to start DSA within LCDUI thread.
+ *
+ * @since S60 v5.0
+ * @param "aConsumer" A consumer of callback
+ */
+ void MdcGetDSAResources(MUiEventConsumer& aConsumer);
+
+ /**
+ * From MDirectContainer.
+ * Invokes callback aConsumer->MdcUICallback in LCDUI thread.
+ * Used in case when MMAPI needs to run some operation
+ * within LCDUI thread.
+ *
+ * @since S60 v5.0
+ * @param "aConsumer" A consumer of callback
+ * @param "aCallbackId" A number identifying the callback
+ */
+ void MdcGetUICallback(MUiEventConsumer& aConsumer, TInt aCallbackId);
+
+#ifdef RD_JAVA_NGA_ENABLED
+ /**
+ * From MDirectContainer.
+ * Notification about added content in LCDUI thread.
+ * @since S60 v9.2
+ */
+ void MdcNotifyContentAdded();
+#endif
+
+
+// from base class MMIDMediaKeysListener
+
+ /**
+ * From MMIDMediaKeysListener.
+ * This method is called when a media key has been pressed.
+ *
+ * @since S60 3.2
+ * @param TMIDKeyEvent The media key event that has occured.
+ */
+ void HandleMediaKeyEvent(TMIDKeyEvent& aKeyEvent);
+
+
+#ifdef RD_TACTILE_FEEDBACK
+// from base class MMIDTactileFeedbackComponent
+
+ /**
+ * From MMIDTactileFeedbackComponent.
+ * Update tactile feedback areas.
+ *
+ * @since S60 v5.0
+ */
+ void UpdateTactileFeedback();
+
+ /**
+ * From MMIDTactileFeedbackComponent.
+ * Register feedback area.
+ *
+ * @since S60 v5.0
+ * @param aId The area Id.
+ * @param aRect The area rectangle.
+ * @param aStyle The area style.
+ */
+ void RegisterFeedbackArea(TInt aId, TRect aRect, TInt aStyle);
+
+ /**
+ * From MMIDTactileFeedbackComponent.
+ * Unregister feedback area.
+ *
+ * @since S60 v5.0
+ * @param aId The area Id.
+ */
+ void UnregisterFeedbackArea(TInt aId);
+
+ /**
+ * From MMIDTactileFeedbackComponent.
+ * Unregister feedback for the control.
+ *
+ * @since S60 v5.0
+ */
+ void UnregisterFeedbackForControl();
+
+ /**
+ * From MMIDTactileFeedbackComponent.
+ * Move area to first priority.
+ *
+ * @since S60 v5.0
+ * @param aId The area Id.
+ */
+ void MoveAreaToFirstPriority(TInt aId);
+#endif // RD_TACTILE_FEEDBACK
+
+ // From MMIDCustomComponentContainer
+
+ /**
+ * Registers a new custom component to this container.
+ *
+ * The ownership of the component is NOT transfferred. Nothing happens
+ * if the component has already been registered. The component is added
+ * on top of the stack in this container. Index can be changed later.
+ *
+ * @param aComponent The component to be registered.
+ * @since S60 5.0
+ */
+ void RegisterComponentL(MMIDCustomComponent* aComponent);
+
+ /**
+ * Unregisters an existing custom component from this container.
+ *
+ * Nothing happens if the component is not found from this container.
+ *
+ * @param aComponent The component to be unregistered.
+ * @since S60 5.0
+ */
+ void UnregisterComponent(MMIDCustomComponent* aComponent);
+
+ /**
+ * Changes the index of the specified custom component.
+ *
+ * @param aComponent The component which index will be changed
+ * @param aNewIndex The new index of the component.
+ * @since S60 5.0
+ */
+ void SetComponentIndexL(
+ MMIDCustomComponent* aComponent,
+ TInt aNewIndex);
+
+ /**
+ * Stores the index of focused component in parent.
+ *
+ * @param aComponent The component which gained focus
+ * @since S60 5.0
+ */
+ void SetFocusedComponent(MMIDCustomComponent* aComponent);
+
+ /**
+ * Returns the index of the given component in this container.
+ *
+ * @return The index of the given component in this container. KErrNotFound
+ * is returned if this container does not have the specified component.
+ * @since S60 5.0
+ */
+ TInt ComponentIndex(MMIDCustomComponent* aComponent) const;
+
+ /**
+ * Gets the full screen status of this component container.
+ *
+ * Typically the container is the same object which is returned when
+ * calling <code>Control()</code>.
+ *
+ * @return <code>ETrue</code> if this component container is set to full screen
+ * and <code>EFalse</code> if not.
+ * @since S60 5.0
+ */
+ TBool IsFullScreen() const;
+
+protected:
+
+ /**
+ * Post an event to Java side.
+ *
+ * @since S60 v3.0
+ * @param aType Event type.
+ * @param aData0 Event data.
+ * @param aData1 Event data.
+ * @return ETrue on success, otherwise returns EFalse .
+ */
+ TBool PostEvent(TEventType aType, TInt aData0, TInt aData1) const;
+
+ /**
+ * Update screen from frame buffer.
+ *
+ * @since S60 v3.0
+ * @param aRect Source rectangle in frame buffer co-ordinates.
+ */
+#ifdef RD_JAVA_NGA_ENABLED
+ void UpdateL(const TRect& aRect);
+#else
+ void Update(const TRect& aRect);
+#endif
+
+ /**
+ * Prepare draw operation.
+ *
+ * @since S60 v5.0
+ * @param aGc Graphics context for drawing.
+ * @param aWinRect Source rectangle in frame buffer co-ordinates.
+ */
+ inline void PrepareDraw(CGraphicsContext& aGc, TRect& aWinRect) const;
+
+#ifdef RD_JAVA_NGA_ENABLED
+ /**
+ * Draws canvas content using
+ * - pixel source when canvas has plain 2D content.
+ * - EGL surface when M3G content has been drawn.
+ * This method is not used if canvas has direct content.
+ * In this case drawing is done via CCoeControl framework.
+ *
+ * @since S60 v9.2
+ * @param aRect Rectangle to be drawn in frame buffer co-ordinates.
+ */
+ void DrawWindowNgaL(const TRect& aRect);
+#endif
+
+#ifdef CANVAS_DOUBLE_BUFFER
+ /**
+ * Draw through Window server using native frame buffer.
+ *
+ * @since S60 v3.0
+ * @param aRect Source rectangle in frame buffer co-ordinates.
+ */
+ void DrawWindow(const TRect& aRect) const;
+#endif // CANVAS_DOUBLE_BUFFER
+
+#ifdef CANVAS_DIRECT_ACCESS
+ /**
+ * Start Direct Screen Access.
+ *
+ * @since S60 v3.0
+ */
+ void StartDirectAccess();
+
+ /**
+ * Stop Direct Screen Access.
+ *
+ * @since S60 v3.0
+ */
+ void StopDirectAccess();
+
+ /**
+ * Restart Direct Screen Access.
+ *
+ * @since S60 v3.0
+ */
+ void RestartL();
+
+ /**
+ * Draw using Direct Screen Access.
+ *
+ * @since S60 v3.0
+ * @param aRect Source rectangle in frame buffer co-ordinates.
+ */
+ void DrawDirect(const TRect& aRect) const;
+#endif // CANVAS_DIRECT_ACCESS
+
+// from base class CCoeControl
+
+ /**
+ * From CCoeControl.
+ * Resource change handling.
+ *
+ * @since S60 v5.0
+ * @param aType The message type code.
+ */
+ void HandleResourceChange(TInt aType);
+
+ /**
+ * Scale II (Pen and Touch) support to S60 release 5.0 builds.
+ * Conditional compilation required by the implementation.
+ */
+#ifdef RD_SCALABLE_UI_V2
+ /**
+ * From CCoeControl.
+ * Pointer events handling.
+ *
+ * @since S60 v5.0
+ * @param aEvent The received pointer event.
+ */
+ virtual void HandlePointerEventL(const TPointerEvent& aEvent);
+#endif // RD_SCALABLE_UI_V2
+
+ /**
+ * From CCoeControl.
+ * Change of focus.
+ *
+ * @since S60 v3.0
+ * @param aDrawNow The redraw of the control is or is not required
+ * immediatelly.
+ */
+ virtual void FocusChanged(TDrawNow aDrawNow);
+
+ /**
+ * From CCoeControl.
+ * Change of size.
+ *
+ * @since S60 v3.0
+ */
+ virtual void SizeChanged();
+
+ /**
+ * From CCoeControl.
+ * Change of position.
+ *
+ * @since S60 v3.0
+ */
+ virtual void PositionChanged();
+
+ /**
+ * From CCoeControl.
+ * Drawing.
+ *
+ * @since S60 v3.0
+ * @param aRect The clipping rectangle.
+ */
+ virtual void Draw(const TRect& aRect) const;
+
+
+private:
+
+#ifdef RD_SCALABLE_UI_V2
+ /**
+ * Pointer events handling in controls.
+ *
+ * @param aPointerEvent The received pointer event on canvas.
+ *
+ * @return ETrue if event was consumed by any control, Efalse otherwise.
+ * @since S60 v5.0
+ */
+ TBool HandlePointerEventInControlsL(const TPointerEvent& aPointerEvent);
+
+ /**
+ * Pointer event pressed in the control.
+ *
+ * @param aControl The control to be checked.
+ * @param apoint The received pointer event transformed position.
+ *
+ * @return ETrue if event is in the control, Efalse otherwise.
+ * @since S60 v5.0
+ */
+ TBool PointerEventInControl(MMIDCustomComponent* aControl,
+ TPoint aPoint);
+
+#endif // RD_SCALABLE_UI_V2
+
+ /**
+ * Constructor.
+ * @see CMIDCanvas::NewL()
+ */
+ CMIDCanvas(
+ MMIDEnv& aEnv,
+ MMIDComponent::TType aCanvasType,
+ TBool aUpdateRequired);
+
+ /**
+ * Second phase construction.
+ *
+ * @since S60 v3.0
+ * @param aWindow Container window.
+ */
+ void ConstructL(CCoeControl& aWindow);
+
+ /**
+ * Set the container window.
+ *
+ * @since S60 v3.0
+ * @param aWindow Container window.
+ */
+ void SetContainerWindowL(const CCoeControl& aWindow);
+
+ /**
+ * Send key event to Java side.
+ *
+ * @since S60 v3.2
+ * @param aEvent Key event.
+ * @param aType Event code.
+ */
+ void SendKeyEventToJavaSideL(const TKeyEvent& aEvent, TEventCode aType);
+
+
+#ifdef CANVAS_DOUBLE_BUFFER
+ /**
+ * Create frame buffer.
+ *
+ * @since S60 v3.0
+ * @param aSize The size of a frame buffer.
+ */
+ void CreateFrameBufferL(const TSize& aSize);
+#endif // CANVAS_DOUBLE_BUFFER
+
+#ifdef DEFER_BITBLT
+ /**
+ * Get BitBlt cycles count.
+ *
+ * @since S60 v3.0
+ * @param aSize The size of a pixel region.
+ * @return Cycles count.
+ */
+ TInt BitBltCycles(const TSize& aSize) const;
+#endif // DEFER_BITBLT
+
+ /**
+ * Layout Canvas control.
+ *
+ * @since S60 v3.0
+ */
+ void Layout();
+
+#ifdef CANVAS_DIRECT_ACCESS
+ /**
+ * Tells whether Direct Screen Access is enabled or disabled.
+ *
+ * @since S60 v3.0
+ * @return ETrue if DSA is enabled, otherwise returns EFalse.
+ */
+ inline TBool DirectEnabled() const;
+
+ /**
+ * Tells whether Direct Screen Access is paused or not.
+ *
+ * @since S60 v3.0
+ * @return ETrue if DSA is paused, otherwise returns EFalse.
+ */
+ inline TBool DirectPaused() const;
+
+ /**
+ * Tells whether screen device update is required or not.
+ *
+ * @since S60 v3.0
+ * @return ETrue if update is required, otherwise returns EFalse.
+ */
+ inline TBool UpdateRequired() const;
+#endif // CANVAS_DIRECT_ACCESS
+
+ /**
+ * Tells whether posting of key events is enabled or disabled.
+ *
+ * @since S60 v3.0
+ * @return ETrue if posting of key events is enabled, otherwise returns
+ * EFalse.
+ */
+ inline TBool PostKeyEvents() const;
+
+ /**
+ * Process game press action.
+ *
+ * @since S60 v3.0
+ * @param aAction Game action.
+ */
+ void GamePress(TInt aAction);
+
+ /**
+ * Process game release action.
+ *
+ * @since S60 v3.0
+ * @param aAction Game action.
+ */
+ void GameRelease(TInt aAction);
+
+ /**
+ * Sets MIDlet's original size and target size resolutions if those are
+ * defined in JAD or manifest. If attribute is missing or it's not
+ * defined correctly, the value will be 0,0. This value is later used as
+ * an "error value".
+ *
+ * @since S60 v3.0
+ */
+ void SetScalingFactors();
+
+ /**
+ * Returns original MIDlet screen size with regards to display
+ * orientation.
+ *
+ * When "MIDlet scaling on orientation switch" is allowed and Canvas
+ * scaling is enabled then this function reflects display orientation
+ * when accessing original MIDlet screen size. This means that it
+ * eventually swaps original MIDlet size orientation if it does not
+ * correspond to actual display orientation.
+ *
+ * @since S60 v3.2
+ * @return Original MIDlet screen size with regards to display
+ * orientation.
+ */
+ TSize OrientedOrgMIDletScrSize() const;
+
+ /**
+ * Check if the network indicator should be shown in Canvas depending on
+ * the midlet's domain:
+ * - in manufacturer domain the indicator is not shown
+ * - in operator domain a central reposotory key defines whether the
+ * indicator is shown
+ * - in trusted/untrusted 3rd patry domain the indicator is shown
+ *
+ * @since S60 3.2
+ * @return ETrue, if network indicator is shown in Canvas, otherwise
+ * returns EFalse.
+ */
+ TBool IsNetworkIndicatorEnabledL() const;
+
+#ifdef RD_JAVA_NGA_ENABLED
+
+ /** EGL surface types */
+ typedef enum
+ {
+ EEglNone = 0,
+ EEglWindow,
+ EEglPbuffer
+ } TEglType;
+
+
+// from MAlfBufferProvider
+public:
+ /**
+ * Called by framework when the next buffer is ready and available for the client to draw.
+ *
+ * @since S60 v9.2
+ * @param aVisibleRegion is currently visible surface region
+ * @return ETrue to continue drawing of frames. EFalse to pause drawing.
+ * After pausing drawing client needs to call CAlfCompositionPixelSource::ActivateL to
+ * continue drawing of frames
+ */
+ TBool ProduceNewFrameL(const TRegion& aVisibleRegion, TUint8*& aBuffer);
+
+ /**
+ * Called by framework when new buffer is been created.
+ * Client should provide desired creation attributes.
+ *
+ * @since S60 v9.2
+ */
+ TBufferCreationAttributes& BufferAttributes();
+
+ /**
+ * Notifications from Alf composition FW
+ *
+ * @since S60 v9.2
+ */
+ void ContextAboutToSuspend();
+ void OnActivation();
+
+public:
+ /**
+ * Handles switching from foreground to
+ * background and vice versa. Mainly rendering
+ * context and surfaces need to be relased.
+ */
+ void HandleForeground(TBool aForeground);
+
+// From MMIDComponentNgaExtension
+public:
+ /**
+ * @see MMIDComponentNgaExtension#UpdateEglContent()
+ * @since S60 9.2
+ */
+ void UpdateEglContent();
+
+ /**
+ * @see MMIDComponentNgaExtension#IsEglAvailable()
+ * @since S60 9.2
+ */
+ TBool IsEglAvailable();
+
+ /**
+ * @see MMIDComponentNgaExtension#BindEglSurface()
+ * @since S60 9.2
+ */
+ EGLSurface BindEglSurface();
+
+ /**
+ * @see MMIDComponentNgaExtension#ReleaseEglSurface()
+ * @since S60 9.2
+ */
+ void ReleaseEglSurface();
+
+ /**
+ * @see MMIDComponentNgaExtension#UpdateOffScreenBitmapL()
+ * @since S60 9.2
+ */
+ virtual void UpdateOffScreenBitmapL(TBool aForced);
+
+ /**
+ * @see MMIDComponentNgaExtension#FillEglSurface()
+ * @since S60 9.2
+ */
+ virtual TBool FillEglSurface(const TRect& aRect, const TRgb& aColor);
+
+ /**
+ * Clear whole OpenGL ES surface (color buffer).
+ * @param aSurfaceType A surface to be cleared. If the value is
+ * <code>EEglNone</code> then the defualt surface is used
+ * (e.g. Pbuffer in case of scaling).
+ * @param aRgba A clear color. If null then a default color will be used:
+ * black in case of scaling and otherwise the clear color is white.
+ * @return <code>ETrue</code> if succeeded.
+ * @since S60 9.2
+ */
+ virtual TBool ClearEglSurface(
+ TEglType aSurfaceType = EEglWindow, const TRgb* aRgba = NULL);
+
+// From MMIDCanvas
+public:
+ /**
+ * @see MMIDCanvas::UpdateRect(const TRect&)
+ */
+ void UpdateRect(const TRect& aRect);
+
+private:
+ /**
+ * Blits pbuffer surface scaled to window surface
+ * @since S60 9.2
+ */
+ void BlitPBufferScaledToWindowSurface();
+
+ /**
+ * Initializes pixel source
+ * @since S60 9.2
+ */
+ void InitPixelSourceL();
+
+ /**
+ * Releases resources occupied by the pixel source
+ * @since S60 9.2
+ */
+ void DisposePixelSource();
+
+ /**
+ * Creates an EGL pbuffer surface and context
+ * for openGL based scaling
+ * @since S60 9.2
+ */
+ void CreatePBufferSurfaceL();
+
+ /**
+ * Disposes pbuffer surface and context
+ * created with CreatePBufferSurface()
+ * @since S60 9.2
+ */
+ void DisposePBufferSurface();
+
+ /*
+ * Initializes EGL resources
+ * @since S60 9.2
+ */
+ void OpenEglL();
+
+ /**
+ * Releases EGL resources
+ * @since S60 9.2
+ */
+ void CloseEgl();
+
+ /**
+ * Creates EGL context
+ * @since S60 9.2
+ */
+ void CreateEglContext();
+
+ /**
+ * Sets current EGL
+ * @param aType The EGL type that is set active: Window, PBuffer or NULL.
+ * @return ETrue if succeeded.
+ * @since S60 9.2
+ */
+ TBool SetCurrentEglType(TEglType aType = EEglNone);
+
+ /**
+ * Gets current EGL
+ * @since S60 9.2
+ */
+ TEglType GetCurrentEglType();
+
+ /**
+ * Reads EGL surface size
+ * @param aSurface Egl surface. If the value is <code>EGL_NO_SURFACE</code>
+ * then the defualt surface is used (e.g. Pbuffer in case of scaling).
+ * @return Surface size. Returns TSize(0, 0) if failed.
+ * @since S60 9.2
+ */
+ TSize GetEglSurfaceSize(EGLSurface aSurface = EGL_NO_SURFACE);
+
+ /**
+ * Handles size changed. EGL window surface needs to be recreated
+ * if window size increases.
+ * @since S60 9.2
+ */
+ void HandleSizeChanged();
+
+ /**
+ * Draws frame buffer 2D content as OpenGL texture in case of
+ * M3G + 2D mixing.
+ * @since S60 9.2
+ */
+ void BlitFrameBufferPixels();
+
+ /**
+ * Initializes the OpenGL ES content before 2d rendering
+ * @param aTopLeftOrigo If false then the origo is viewport's
+ * bottom left corner.
+ * @param aRect Scissor rectangle. If NULL then the scissor
+ * will be the same as the viewport rectangle.
+ * @since S60 9.2
+ */
+ TSize InitOpenGl(TBool aTopLeftOrigo = EFalse, const TRect* aRect = NULL);
+
+ /**
+ * Draws a rectangular area of frame buffer as OpenGL texture.
+ * aRect Part of frame buffer that is drawn.
+ * @since S60 9.2
+ */
+ void BlitSubRect(const TRect& aRect);
+
+ /**
+ * Creates OpenGL texture out of aPixels and draws it to
+ * EGL surface. Parameters define the texture location on EGL surface.
+ * @since S60 9.2
+ */
+ void BlitSubRectTexture(
+ TInt aXOffset, TInt aYOffset, TInt aWidth, TInt aHeight,
+ TInt aStride, const TUint8* aPixels);
+ /**
+ * Clears the frame buffer with transparent color.
+ * Clearing is needed in M3G + 2D mixing case in order
+ * 2D content can be rendered as an OpenGL texture.
+ * @since S60 9.2
+ */
+ void ClearFrameBuffer();
+
+ /**
+ * Pixel source is activated when canvas has a frame ready to be passed
+ * to Alf composition.
+ * @since S60 9.2
+ */
+ void ActivatePixelSourceL();
+
+ /**
+ * Suspending pixel source releases its resources on graphics HW.
+ * @since S60 9.2
+ */
+ void SuspendPixelSource();
+
+ /**
+ * Notifies monitor omwned by CMIDBuffer after async ProcessL()
+ * is completed (i.e. in normal case when ProduceNewFrameL() is called).
+ * @since S60 9.2
+ */
+ void NotifyMonitor();
+
+ /**
+ * Check for OpenGL errors.
+ * @since S60 9.2
+ */
+ void AssertGL();
+
+ /**
+ * @since S60 9.2
+ * Converts pixels from ARGB to RGBA.
+ */
+ inline void ConvertPixels(
+ const TUint32* aSrc, TUint8* aDst, TInt aPixelCount);
+
+ /**
+ * EGL error
+ * @since S60 9.2
+ */
+ const TDesC8& GetEglError(EGLint aErr);
+
+#endif // RD_JAVA_NGA_ENABLED
+
+private: // data
+
+ /** CMIDCanvas flags datatype */
+ enum TFlags
+ {
+ EDirectEnabled = 1,
+ EDirectPaused = 2,
+ EPostKeyEvents = 4,
+ EUpdateRequired = 8
+ };
+
+ /**
+ * A MIDlet environment.
+ */
+ MMIDEnv& iEnv;
+
+#ifdef CANVAS_DOUBLE_BUFFER
+ /**
+ * Frame buffer.
+ * Not own.
+ */
+ CFbsBitmap* iFrameBuffer;
+
+ /**
+ * Frame bitmapped graphics context.
+ * Own.
+ */
+ CFbsBitGc* iFrameContext;
+
+ /**
+ * Frame bitmap graphics device.
+ * Own.
+ */
+ CFbsBitmapDevice* iFrameDevice;
+#endif // CANVAS_DOUBLE_BUFFER
+
+ /**
+ * Stores information whether this control is the game canvas or not.
+ */
+ TBool iIsGameCanvas;
+
+ /**
+ * View rectangle.
+ */
+ TRect iViewRect;
+
+ /**
+ * Content size.
+ */
+ TSize iContentSize;
+
+#ifdef CANVAS_DIRECT_ACCESS
+ /**
+ * An active object used to start direct screen access.
+ * Own.
+ */
+ CDirectScreenAccess* iDirectAccess;
+
+ /**
+ * Direct screen access bitmapped graphics context.
+ * Not own.
+ */
+ CFbsBitGc* iDirectGc;
+
+ /**
+ * Update region.
+ */
+ mutable RRegion iUpdateRegion;
+#endif // CANVAS_DIRECT_ACCESS
+
+ /**
+ * Status flags.
+ */
+ TUint32 iFlags;
+
+ /**
+ * Game key state.
+ */
+ TUint32 iGameKeyState;
+
+ /**
+ * Game key latch.
+ */
+ TUint32 iGameKeyLatch;
+
+ /**
+ * Displayable.
+ * Not own.
+ */
+ CMIDDisplayable* iDisplayable;
+
+ /**
+ * Fullscreen - status flag.
+ */
+ TBool iFullScreen;
+
+ /**
+ * Scaling on - status flag.
+ */
+ TBool iScalingOn;
+
+ /**
+ * Nokia-MIDlet-Original-Display-Size JAD attribute value.
+ */
+ TSize iOrgMIDletScrSize;
+
+ /**
+ * Nokia-MIDlet-Target-Display-Size JAD attribute value.
+ */
+ TSize iTargetMIDletScrSize;
+
+ /**
+ * Nokia-MIDlet-allow-scaling-on-orientation-switch JAD attribute value.
+ */
+ TBool iScaleMIDletOnOrientSwitch;
+
+ /**
+ * Nokia-MIDlet-S60-Selection-Key-Compatibility JAD attribute value.
+ */
+ TBool iS60SelectionKeyCompatibility;
+
+ /**
+ * Network indicator.
+ * Own.
+ */
+ CMIDNetworkIndicator* iNetworkIndicator;
+
+ /**
+ * Call indicator.
+ * Own.
+ */
+ CMIDCallIndicator* iCallIndicator;
+
+ /**
+ * Scaler.
+ * Not own.
+ */
+ CMIDScaler* iScaler;
+
+ /**
+ * PointerEventSuppressor.
+ * Own.
+ */
+ CAknPointerEventSuppressor* iPointerEventSuppressor;
+ TPoint iPointerPressedCoordinates;
+ TBool iPointerEventSuppressionOngoing;
+ TInt iPESPointerMovementInTwips;
+ TInt iPESTimeInMilliseconds;
+
+ /**
+ * For drag event filtering.
+ */
+ TTime iPreviousDragTimeStamp;
+
+ /**
+ * Direct content listeners.
+ * Not own.
+ */
+ RPointerArray< MDirectContent > iDirectContents;
+
+ /**
+ * Restore content when unfaded - status flag.
+ */
+ TBool iRestoreContentWhenUnfaded;
+
+ /**
+ * Position in screen co-ordinates.
+ * Stored in member variable because CCoeControl::PositionRelativeToScreen
+ * cannot be called from another thread. Value is set in
+ * SetContainerWindowL and in SizeChanged methods. Used in
+ * MdcContentBounds method.
+ */
+ TPoint iPositionRelativeToScreen;
+
+ /**
+ * Key decoder.
+ * Not own.
+ */
+ CMIDKeyDecoder* iKeyDecoder;
+
+ /**
+ * Remote connection observer.
+ * Not own.
+ */
+ CMIDRemConObserver* iRemConObserver;
+
+ /**
+ * The last fade message.
+ */
+ TInt iLastFadeMessage;
+
+#ifdef RD_TACTILE_FEEDBACK
+ /**
+ * To handle tactile feedback areas.
+ * Own.
+ */
+ CMIDTactileFeedbackExtension* iTactileFeedback;
+#endif // RD_TACTILE_FEEDBACK
+
+ /**
+ * Stores information about screen orientation, if screen
+ * in landscape mode, variable iLandscape is True
+ */
+ mutable TBool iLandscape;
+
+ /**
+ * Stores information about screen need of screen refresh
+ * after orientation change to avoid artifacting
+ */
+ mutable TBool iWndUpdate;
+
+#ifdef CANVAS_DIRECT_ACCESS
+ /**
+ * Stores information that DirectContent
+ * needs to be informed about DSA restart
+ */
+ TBool iDcDsaToStart;
+#endif // CANVAS_DIRECT_ACCESS
+
+
+ /**
+ * Stores old bounds of the direct content
+ * used before SizeChanged is called
+ */
+ TRect iOldContentBounds;
+
+ /**
+ * The startup trace should be done only once.
+ */
+ mutable TBool iStartUpTraceDone;
+
+ // The list of registered custom components.
+ RPointerArray< MMIDCustomComponent > iCustomComponents;
+
+ // The count of custom components.
+ TInt iCustomComponentsControlCount;
+
+ // The index of focused custom component
+ TInt iFocusedComponent;
+
+ // Stores the control on which was press event generated
+ MMIDCustomComponent* iPressedComponent;
+
+#ifdef RD_JAVA_NGA_ENABLED
+
+ /**
+ * Flag incdicating the foreground status of canvas.
+ * Set to EFalse when some other displayable is made current
+ * or when MIDlet goes to background.
+ */
+ TBool iForeground;
+
+ /**
+ * CAlfCompositionPixelSource is used for drawing canvas
+ * content when only basic content is drawn
+ * (no M3G or direct content).
+ * Own.
+ */
+ CAlfCompositionPixelSource* iAlfCompositionPixelSource;
+
+ /**
+ * Flag indicating if pixel source is in suspended state.
+ * When pixel source is suspended, it releases its surface
+ * on Graphics HW.
+ */
+ TBool iPixelSourceSuspended;
+
+ /**
+ * Buffer attributes define the size of ARGB data that is
+ * passed to CAlfCompositionPixelSource.
+ * Read by CAlfCompositionPixelSource in BufferAttributes().
+ */
+ TBufferCreationAttributes iAlfBufferAttributes;
+
+ /**
+ * Indicates if frame buffer contains a complete frame that
+ * should be passed to Alf compostion.
+ */
+ mutable TBool iFrameReady;
+
+ /**
+ * Monitor that needs to be signalled after
+ * ProduceNewFrameL callback is received.
+ * Not own.
+ */
+ java::util::Monitor* iAlfMonitor;
+
+ /**
+ * Flag indicating whether device has 3D HW accelerator.
+ */
+ TBool i3DAccelerated;
+
+ /**
+ * Flag indicating whether midlet is drawing M3G content.
+ * Reset to EFalse in CloseEgl().
+ */
+ TBool iM3GContent;
+
+ /**
+ * ETrue, while M3G has bound to canvas EGL surface.
+ */
+ TBool iEglOccupied;
+
+ /**
+ * ETrue, when canvas is drawing the first frame
+ * that has M3G content. Reset to EFalse in CloseEgl().
+ */
+ TBool iM3GStart;
+
+ /**
+ * Set to ETrue, if canvas is resized while M3G was bound to
+ * EGL surface.
+ */
+ TBool iEglPendingResize;
+
+ /**
+ * Set to ETrue, if canvas canvas goes to background
+ * (i.e. canvas needs to release resources on graphics HW)
+ * while M3G was bound to EGL surface.
+ */
+ TBool iEglPendingDispose;
+
+ /**
+ * Handles to the EGL display, surface, context and config.
+ */
+ EGLDisplay iEglDisplay;
+ EGLSurface iEglWindowSurface;
+ EGLContext iEglWindowSurfaceContext;
+ EGLConfig iEglConfig;
+
+ /**
+ * Handles to the EGL pbuffer surface, context and texture in case of
+ * OpenGL based scaling
+ */
+ EGLSurface iEglPbufferSurface;
+ EGLContext iEglPbufferSurfaceContext;
+ GLuint iPbufferTexture;
+
+ /**
+ * These rects define the framebuffer areas that
+ * need to be blitted to EGL surface as OpenGL texture.
+ * Canvas is devided vertically into 2 parts, but it is
+ * a common case that iUpperUpdateRect covers the full canvas
+ * (E.g. if fillRect() is used in MIDlet for full canvas area).
+ * Updated by UpdateRects().
+ */
+ TRect iUpperUpdateRect;
+ TRect iLowerUpdateRect;
+
+ /**
+ * Pointer to converted pixel data that is given to
+ * OpenGL when creating the frame buffer texture.
+ * Added the member variable because this is needed continuosly.
+ * Own.
+ */
+ TUint8* iTexturePixels;
+
+ /**
+ * OpenGL coordinate arrays used fo r rendering filled rectangles
+ */
+ GLshort* iVertexArray;
+ GLubyte* iTriangleStrip;
+
+#endif // RD_JAVA_NGA_ENABLED
+
+ /**
+ * If dragging was started (by pointer down) inside the canvas,
+ * all drag events and release event should go to canvas
+ * even if it is outside of canvas.
+ * All events, which started outside the canvas have to be ignored.
+ */
+ TBool iDragEventsStartedInside;
+};
+
+#ifdef RD_JAVA_NGA_ENABLED
+// ------------------------------------
+// Converts pixels from ARGB to RGBA
+// ------------------------------------
+//
+inline void CMIDCanvas::ConvertPixels(
+ const TUint32* aSrc, TUint8* aDst, TInt aPixelCount)
+{
+ while (aPixelCount--)
+ {
+ TUint argb = *aSrc++;
+ *aDst++ = (argb >> 16) & 0xFFu;
+ *aDst++ = (argb >> 8) & 0xFFu;
+ *aDst++ = argb & 0xFFu;
+ *aDst++ = (argb >> 24) & 0xFFu;
+ }
+}
+#endif // RD_JAVA_NGA_ENABLED
+
+#endif // CMIDCANVAS_H