/*
* Copyright (c) 2005 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:
*
*/


#include <coemain.h>
#include <coecntrl.h>
#include <reflcdui.h>
#include <hal.h>

#include "LcdWindowSurface.h"

/**
 * Utility function to query the frame buffer attributes for screen aScreenNo
 * when set to displayMode aMode.
 */
LOCAL_C TInt GetScreenInfo(TAcceleratedBitmapInfo& aScreen, TInt aScreenNo, TDisplayMode aMode);

CLcdWindowSurface* CLcdWindowSurface::NewL(CCoeControl& aWindow, MDirectContainer& aContainer, TBool aUpdate)
{
    CLcdWindowSurface* surface = new(ELeave) CLcdWindowSurface(aContainer, aUpdate);
    CleanupStack::PushL(surface);
    surface->ConstructL(aWindow);
    CleanupStack::Pop(surface);
    return surface;
}

CLcdWindowSurface::CLcdWindowSurface(MDirectContainer& aContainer, TBool aUpdate)
        : iContainer(&aContainer)
        , iWsSession(CCoeEnv::Static()->WsSession())
        , iWsDevice(*CCoeEnv::Static()->ScreenDevice())
        , iUpdate(aUpdate)
{
    ASSERT(iContainer);
    //
    // Risk of configuration problem if screen mode does not match the configured
    // primary mode. In that case it would not be possible to use any of the
    // transforming blitters and a frame buffer bitmap would have to be used.
    //
    // Solution is to provide opaque converter blitters from/to all target modes,
    // or generic blitter (as BITGDI) via XRGB8888.
    //
    iImageType.iColorMode = iWsDevice.DisplayMode();
    iImageType.iAlphaMode = ENone;
    iImageType.iTransparency = ETransparencyNone;
}

CLcdWindowSurface::~CLcdWindowSurface()
{
    if (iContainer)
    {
        iContainer->MdcRemoveContent(this);
    }
    Deactivate();
    delete iWsContext;
    iEmptyRegion.Close();
    iUpdateRegion.Close();
}

void CLcdWindowSurface::ConstructL(CCoeControl& aWindow)
{
    iContainer->MdcAddContent(this);
    User::LeaveIfError(iWsDevice.CreateContext(iWsContext));
    if (aWindow.IsBackedUp())
    {
        User::Leave(KErrArgument);
    }
    else
    {
        ActivateL((RWindow*)aWindow.DrawableWindow());
    }
    TRect bounds(aWindow.PositionRelativeToScreen(), aWindow.Size());
    iBounds = bounds;
    iVisible = aWindow.IsVisible();
}

CLcdSurface::TSurfaceType CLcdWindowSurface::Type() const
{
    return CLcdSurface::EWindowSurface;
}

void CLcdWindowSurface::Update(const TRect& aRect)
{
    if (iStarted && iUpdate && iVisible)
    {
        ASSERT(iWsAccess);

        iUpdateRegion.AddRect(aRect);

        (void) DoUpdate();
    }
}

TInt CLcdWindowSurface::DoUpdate()
{
    CFbsScreenDevice* device = iWsAccess->ScreenDevice();
    RRegion& visibleRegion = *iWsAccess->DrawingRegion();

    const TInt updateCount  = iUpdateRegion.Count();
    const TInt visibleCount = visibleRegion.Count();
    if (updateCount && visibleCount)
    {
        iUpdateRegion.Intersect(visibleRegion);
        device->Update(iUpdateRegion);
    }
    iUpdateRegion.Clear();

    return updateCount;
}

void CLcdWindowSurface::Begin(TAcceleratedBitmapInfo& aBitmap, TBitmapLockCount& /*aCount*/)
{
    if (!iStarted && iEnabled)
    {
        iStarted = Start();
    }

#ifdef _DEBUG
    if (iStarted)
    {
        ASSERT(NULL != iScreen.iAddress);
    }
    else
    {
        ASSERT(NULL == iScreen.iAddress);
    }
#endif

    aBitmap = iScreen;
}

void CLcdWindowSurface::End(TBitmapLockCount& /*aCount*/)
{
}

TRect CLcdWindowSurface::Bounds() const
{
    return iBounds;
}

RRegion* CLcdWindowSurface::VisibleRegion() const
{
    if (iStarted)
    {
        ASSERT(iWsAccess);
        return iWsAccess->DrawingRegion();
    }
    return const_cast<RRegion*>(&iEmptyRegion);
}

CBitmapContext* CLcdWindowSurface::Context() const
{
    CBitmapContext* context = iWsAccess->Gc();
    if (context)
    {
        return context;
    }
    return iWsContext;
}

TImageType CLcdWindowSurface::ImageType() const
{
    return iImageType;
}

TBool CLcdWindowSurface::Start()
{
    ASSERT(iWsAccess);
    TRAPD(err, iWsAccess->StartL());
    if (KErrNone == err)
    {
        const TInt screenNo = iWsDevice.GetScreenNumber();

        //
        // DisplayMode may change dynamically on some devices.
        //
        const TDisplayMode displayMode = iWsDevice.DisplayMode();

        if (displayMode != iImageType.iColorMode)
        {
            // this surface doesn't match the current screen mode.
            // Any lcdgd device created for this surface will fail.
            err = KErrNotSupported;
        }
        else
        {
            //
            // Hardware bitmaps handles that reference screen framebuffers
            // start at -1 decending with the correspondance:
            //
            // handle = -(1 + screenNo) == ~screenNo
            //
            RHardwareBitmap screenHwb(~screenNo);

            TAcceleratedBitmapSpec screenSpec(screenHwb);

            err = screenSpec.GetInfo(iScreen);
            if (err)
            {
                // hardware bitmaps screen references may not be supported on
                // all ports. In that case we fall back to querying the HAL
                // in GetScreenInfo().
                //
                err = GetScreenInfo(iScreen, screenNo, displayMode);
            }
        }

        if (err)
        {
            Mem::FillZ(&iScreen, sizeof(iScreen));
            iWsAccess->Cancel();
        }

        //
        // Record current scale, size and rotation settings
        //
        TPixelsAndRotation sizeAndRotation;
        iWsDevice.GetDefaultScreenSizeAndRotation(sizeAndRotation);

        // screen size and orientation determine coordinate transform
        // we should be using during rendering.
        iScreenCoords.iSize        = sizeAndRotation.iPixelSize;
        iScreenCoords.iOrientation = sizeAndRotation.iRotation;
        iScreenCoords.iScale  = iWsDevice.GetCurrentScreenModeScale();
        iScreenCoords.iOrigin = iWsDevice.GetDefaultScreenModeOrigin();
    }

    return (KErrNone == err);
}

void CLcdWindowSurface::ActivateL(RWindow* aWindow)
{
    if (iWsWindow)
    {
        Deactivate();
    }
    iWsWindow = aWindow;
    if (iWsWindow)
    {
        iWsContext->Activate(*iWsWindow);
        iWsAccess = CDirectScreenAccess::NewL(iWsSession, iWsDevice, *iWsWindow, *this);
        iEnabled  = ETrue;
    }
}

void CLcdWindowSurface::Deactivate()
{
    if (iWsWindow && iWsContext)
    {
        iWsContext->Deactivate();
    }
    delete iWsAccess;
    iWsAccess = NULL;
    iStarted  = EFalse;
    iEnabled  = EFalse;
    iWsWindow = NULL;
}

/* CONTENT INTERFACE */

/**
Notify content that container visiblity has changed. The content must not
be displayed when it's container is invisible.
@param "aVisible" ETrue if the container is visible, EFalse if it is invisible.
*/
void CLcdWindowSurface::MdcContainerVisibilityChanged(TBool aVisible)
{
    iVisible = aVisible;
}

/**
Notify content that the container bounds have changed.
@param "aRect" Maximum area the content can occupy in screen co-ordinates.
The content should be clipped to this area.
*/
void CLcdWindowSurface::MdcContentBoundsChanged(const TRect& aRect)
{
    iBounds = aRect;
}

/**
Notify content that its display area has changed.
This should only be called when the content is displayed on an Item.
@param "aDisplayRect" Display area in Item co-ordinates.
@param "aScreenRect" Display area in screen co-ordinates.
*/
void CLcdWindowSurface::MdcItemContentRectChanged(const TRect& /*aContentRect*/,const TRect& /*aScreenRect*/)
{
    ASSERT(EFalse);
}

void CLcdWindowSurface::MdcContainerDestroyed()
{
    Deactivate();
    iContainer = NULL;
}


void CLcdWindowSurface::MdcAbortDSA()
{
    // Empty implementation.
    // This DSA event is delivered via AbortNow.
}


void CLcdWindowSurface::MdcResumeDSA()
{
    // Empty implementation.
    // This DSA event is delivered via Restart.
}


/**
 * MDirectScreenAccess
 */
void CLcdWindowSurface::AbortNow(RDirectScreenAccess::TTerminationReasons /*aReasons*/)
{
    iWsAccess->Cancel();
    iStarted=EFalse;
    iEnabled=EFalse;
}

void CLcdWindowSurface::Restart(RDirectScreenAccess::TTerminationReasons /*aReasons*/)
{
    //
    // Don't bother restarting until next Begin comes through.
    //
    iEnabled=ETrue;
}

RWindow* CLcdWindowSurface::Window() const
{
    return iWsWindow;
}

void CLcdWindowSurface::GetCoordinateSystem(TCoordinateSystem& aCoords) const
{
    aCoords = iScreenCoords;
}

LOCAL_C TUint Log2(TInt aVal)
{
    ASSERT(aVal > 0);
    TUint v = 1;
    TInt  x = 0;
    while (v < aVal)
    {
        v <<= 1;
        ++x;
    }
    return x;
}

LOCAL_C TInt GetScreenInfo(TAcceleratedBitmapInfo& aScreen, TInt aScreenNo, TDisplayMode aMode)
{
    // 'current mode' attributes. These should not need the
    // displayMode but this could depend on video driver.
    //
    TInt err     = 0;
    TInt mode    = 0;
    TInt address = 0;
    TInt width   = 0;
    TInt height  = 0;

    // 'request mode' attributes. These need the displayMode
    // passed in the attribute value argument.
    TInt offset     = aMode;
    TInt linePitch  = aMode;
    TInt bpp        = aMode;

    err = HAL::Get(aScreenNo, HALData::EDisplayMode, mode);
    ASSERT(mode == (TInt)aMode);

    if (KErrNone == err)
    {
        err = HAL::Get(aScreenNo, HALData::EDisplayMemoryAddress, address);
    }

    if (KErrNone == err)
    {
        err = HAL::Get(aScreenNo, HALData::EDisplayXPixels, width);
    }

    if (KErrNone == err)
    {
        err = HAL::Get(aScreenNo, HALData::EDisplayYPixels, height);
    }

    if (KErrNone == err)
    {
        offset = mode;  // Parameter must be set to mode on input.
        err = HAL::Get(aScreenNo, HALData::EDisplayOffsetToFirstPixel, offset);
    }

    if (KErrNone == err)
    {
        linePitch = mode;   // Parameter must be set to mode on input.
        err = HAL::Get(aScreenNo, HALData::EDisplayOffsetBetweenLines, linePitch);
    }

    if (KErrNone == err)
    {
        bpp = mode; // Parameter must be set to mode on input.
        err = HAL::Get(aScreenNo, HALData::EDisplayBitsPerPixel, bpp);
    }

    aScreen.iPhysicalAddress = NULL;
    aScreen.iDisplayMode  = aMode;
    aScreen.iAddress      = reinterpret_cast<TUint8*>(address + offset);
    aScreen.iLinePitch    = linePitch;
    aScreen.iSize.iWidth  = width;
    aScreen.iSize.iHeight = height;
    aScreen.iPixelShift   = Log2(bpp);

    return err;
}