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


/**
 @file
 @publishedPartner
 @prototype
*/


#include "eglwindowinterface.h"
#include "eglwindow.h"
#include <e32base.h>
#include <w32std.h>
#include <hal.h>


EXPORT_C TEglWindowInterface::TEglWindowInterface(EGLNativeWindowType aNativeWindow) :
    iEglWindow(reinterpret_cast<REglWindowBase*>(aNativeWindow))
    {
    }


EXPORT_C TBool TEglWindowInterface::IsValid() const
    {
    if(iEglWindow->IsRWindow())
        {
        TInt wsHandle = reinterpret_cast<const RWindow*>(iEglWindow)->WsHandle();
        return (wsHandle != 0);
        }
    else
        {
        return iEglWindow->IsValid();
        }
    }


EXPORT_C TSize TEglWindowInterface::SizeInPixels() const
    {
    if(iEglWindow->IsRWindow())
        {
        return reinterpret_cast<const RWindow*>(iEglWindow)->Size();
        }
    else
        {
        return iEglWindow->SizeInPixels();
        }
    }


EXPORT_C TSize TEglWindowInterface::SizeInTwips() const
    {
    if(iEglWindow->IsRWindow())
        {
        //This is a simple solution to get the twip size of an RWindow.
        //A temporary CWsScreenDevice is constructed for the screen that
        //the RWindow exists on and is used to convert the size in pixels
        //to a size in twips. The temporary CWsScreenDevice is then destructed.
        //If this is found to be non-performant, we could use a TLS thread 
        //singleton that lazily creates screen devices and maintains a list
        //thoughout its lifetime. The singleton could be destroyed though a
        //static function on TEglWindowInterface as part of eglReleaseThread().
        //This represents more complexity and should only be considered as an
        //optimisation if it is found to be neccessary. Note that use of the HAL
        //interface is not really an option, since we need to find the pixel 
        //size of the screen and this could be virtualised by the screen.
    
        const RWindow* window = reinterpret_cast<const RWindow*>(iEglWindow);
        RWsSession* winSession = window->Session();
        EGL_WINDOW_ASSERT_DEBUG(winSession, EEglWindowPanicRWindowHasNoSession);
        
        //Do a placement new to avoid the possible KErrNoMemory error.
        TUint8 screenDevMem[sizeof(CWsScreenDevice)];
        CWsScreenDevice* screenDev = new (screenDevMem) CWsScreenDevice(*winSession);

        //Nothing we can do about this error.
        TInt err = screenDev->Construct(window->ScreenNumber());
        if(err != KErrNone)
            {
            screenDev->~CWsScreenDevice();
            return TSize(0,0);
            }
        
        TSize pixelSize = window->Size();
        TInt twipWidth = screenDev->HorizontalPixelsToTwips(pixelSize.iWidth);
        TInt twipHeight = screenDev->VerticalPixelsToTwips(pixelSize.iHeight);
        TSize twipSize(twipWidth, twipHeight);
        
        screenDev->~CWsScreenDevice();
        return twipSize;
        }
    else
        {
        return iEglWindow->SizeInTwips();
        }
    }


EXPORT_C TInt TEglWindowInterface::ScreenNumber() const
    {
    if(iEglWindow->IsRWindow())
        {
        return reinterpret_cast<const RWindow*>(iEglWindow)->ScreenNumber();
        }
    else
        {
        return iEglWindow->ScreenNumber();
        }
    }


EXPORT_C void TEglWindowInterface::SetBackgroundColor(TRgb aColor, TBool aTriggerRedraw)
    {
    if(iEglWindow->IsRWindow())
        {
        RWindow* window = reinterpret_cast<RWindow*>(iEglWindow);
        window->SetBackgroundColor(aColor);
        if(aTriggerRedraw)
            {
            window->Invalidate();
            }
        }
    else
        {
        iEglWindow->SetBackgroundColor(aColor, aTriggerRedraw);
        }
    }


EXPORT_C TInt TEglWindowInterface::SetBackgroundSurface(const TSurfaceConfiguration &aConfiguration, TBool aTriggerRedraw)
    {
    if(iEglWindow->IsRWindow())
        {
#ifdef _DEBUG
        TSurfaceId surface;
        aConfiguration.GetSurfaceId(surface);
        EGL_WINDOW_ASSERT_DEBUG(!surface.IsNull(), EEglWindowPanicInvalidSurface);
#endif
        return reinterpret_cast<RWindow*>(iEglWindow)->SetBackgroundSurface(aConfiguration, aTriggerRedraw);
        }
    else
        {
        return iEglWindow->SetBackgroundSurface(aConfiguration, aTriggerRedraw);
        }
    }


EXPORT_C void TEglWindowInterface::RemoveBackgroundSurface(TBool aTriggerRedraw)
    {
    if(iEglWindow->IsRWindow())
        {
        RWindow* window = reinterpret_cast<RWindow*>(iEglWindow);
        RWsSession* winSession = window->Session();
        EGL_WINDOW_ASSERT_DEBUG(winSession, EEglWindowPanicRWindowHasNoSession);    
        window->RemoveBackgroundSurface(aTriggerRedraw);
        }
    else
        {
        iEglWindow->RemoveBackgroundSurface(aTriggerRedraw);
        }
    }