// 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 "eglwindow.h"
#include <e32base.h>
#include <w32std.h>


//REglWindowBase-----------------------------------------------------

REglWindowBase::REglWindowBase() :
	iIsRWindow(0xFFFFFFFF)
	{
	//Check that BC is not broken between RWindow and REglWindowBase.
	__ASSERT_COMPILE(sizeof(MWsClientClass) == sizeof(REglWindowBase));
	}


TBool REglWindowBase::IsRWindow() const
    {
    //REglWindowBase works out whether it is really an RWindow or a class
    //derived from REglWindowBase by checking the location where iWsBuffer 
    //would be in an RWindow (iIsRWindow in this class). If this is 
    //0xFFFFFFFF, it is not an RWindow.
    return (iIsRWindow != 0xFFFFFFFF);
    }

//-------------------------------------------------------------------


//Static function used to copy one configuration to another.
static void CopySurfaceConfiguration(const TSurfaceConfiguration& aSrc, TSurfaceConfiguration& aDest)
    {
    TRect extent;
    TRect viewport;
    TSurfaceId surface;
    aSrc.GetExtent(extent);
    aDest.SetExtent(extent);
    aSrc.GetSurfaceId(surface);
    aDest.SetSurfaceId(surface);
    aSrc.GetViewport(viewport);
    aDest.SetViewport(viewport);
    aDest.SetFlip(aSrc.Flip());
    aDest.SetOrientation(aSrc.Orientation());
    }


//REglStandAloneWindow-----------------------------------------------

//Class used to hold surface window data to prevent the 
//possibility of binary break if TSurfaceConfiguration grows.
NONSHARABLE_CLASS(REglStandAloneWindow::TEglStandAloneWindowData)
    {
public:
    TEglStandAloneWindowData(const TSize& aSizeInPixels, const TSize& aSizeInTwips, TInt aScreenNumber, MEglStandAloneWindowObserver& aObserver);
    MEglStandAloneWindowObserver& iObserver;
    TSize iSizeInPixels;
    TSize iSizeInTwips;
    TInt iScreenNumber;
    TRgb iBackgroundColor;
    TSurfaceConfiguration iSurfaceConfig;
    };


REglStandAloneWindow::TEglStandAloneWindowData::TEglStandAloneWindowData(const TSize& aSizeInPixels, const TSize& aSizeInTwips, TInt aScreenNumber, MEglStandAloneWindowObserver& aObserver) :
    iObserver(aObserver),
    iSizeInPixels(aSizeInPixels),
    iSizeInTwips(aSizeInTwips),
    iScreenNumber(aScreenNumber),
    iBackgroundColor(0,0,0,0) //Transparent Black.
    {
    CopySurfaceConfiguration(TSurfaceConfiguration(), iSurfaceConfig);
    }


EXPORT_C REglStandAloneWindow::REglStandAloneWindow() :
    iData(NULL)
	{
	}

	
EXPORT_C TInt REglStandAloneWindow::Create(const TSize& aSizeInPixels, const TSize& aSizeInTwips, TInt aScreenNumber, MEglStandAloneWindowObserver& aObserver)
	{
	if(iData)
	    {
	    return KErrAlreadyExists;
	    }
	
	EGL_WINDOW_ASSERT_DEBUG(aSizeInPixels.iWidth >= 0, EEglWindowPanicSizeInPixelsIsNegative);
	EGL_WINDOW_ASSERT_DEBUG(aSizeInPixels.iHeight >= 0, EEglWindowPanicSizeInPixelsIsNegative);
	EGL_WINDOW_ASSERT_DEBUG(aSizeInTwips.iWidth >= 0, EEglWindowPanicSizeInTwipsIsNegative);
	EGL_WINDOW_ASSERT_DEBUG(aSizeInTwips.iHeight >= 0, EEglWindowPanicSizeInTwipsIsNegative);
	EGL_WINDOW_ASSERT_DEBUG(aScreenNumber >= 0 || aScreenNumber == KAllScreens, EEglWindowPanicInvalidScreenNumber);
	
	//Allocate and initialize data.
    iData = new TEglStandAloneWindowData(aSizeInPixels, aSizeInTwips, aScreenNumber, aObserver);
    if(!iData)
        {
        return KErrNoMemory;
        }
    
	return KErrNone;
	}


EXPORT_C void REglStandAloneWindow::Close()
    {
    if(!iData)
        {
        return;
        }
    
    //Remove background surface with a forced redraw so that 
    //the contents immediately disappear from the screen.
    RemoveBackgroundSurface(ETrue);
    delete iData;
    iData = NULL;
    }


EXPORT_C void REglStandAloneWindow::SetSizeInPixels(const TSize& aSize)
    {
    EGL_WINDOW_ASSERT_ALWAYS(iData, EEglWindowPanicREglStandAloneWindowNotCreated);
    EGL_WINDOW_ASSERT_DEBUG(aSize.iWidth >= 0, EEglWindowPanicSizeInPixelsIsNegative);
    EGL_WINDOW_ASSERT_DEBUG(aSize.iHeight >= 0, EEglWindowPanicSizeInPixelsIsNegative);
    iData->iSizeInPixels = aSize;
    }


EXPORT_C void REglStandAloneWindow::SetSizeInTwips(const TSize& aSize)
    {
    EGL_WINDOW_ASSERT_ALWAYS(iData, EEglWindowPanicREglStandAloneWindowNotCreated);
    EGL_WINDOW_ASSERT_DEBUG(aSize.iWidth >= 0, EEglWindowPanicSizeInTwipsIsNegative);
    EGL_WINDOW_ASSERT_DEBUG(aSize.iHeight >= 0, EEglWindowPanicSizeInTwipsIsNegative);
    iData->iSizeInTwips = aSize;
    }


EXPORT_C TRgb REglStandAloneWindow::BackgroundColor() const
    {
    EGL_WINDOW_ASSERT_ALWAYS(iData, EEglWindowPanicREglStandAloneWindowNotCreated);
    return iData->iBackgroundColor;
    }


EXPORT_C TBool REglStandAloneWindow::GetBackgroundSurface(TSurfaceConfiguration& aConfiguration) const
    {
    EGL_WINDOW_ASSERT_ALWAYS(iData, EEglWindowPanicREglStandAloneWindowNotCreated);
    
    TSurfaceId surface;
    iData->iSurfaceConfig.GetSurfaceId(surface);
    if(surface.IsNull())
        {
        return EFalse;
        }
    
    CopySurfaceConfiguration(iData->iSurfaceConfig, aConfiguration);
    return ETrue;
    }


EXPORT_C TBool REglStandAloneWindow::IsValid() const
    {
    return iData != NULL;
    }


EXPORT_C TSize REglStandAloneWindow::SizeInPixels() const
    {
    EGL_WINDOW_ASSERT_ALWAYS(iData, EEglWindowPanicREglStandAloneWindowNotCreated);
    return iData->iSizeInPixels;
    }


EXPORT_C TSize REglStandAloneWindow::SizeInTwips() const
    {
    EGL_WINDOW_ASSERT_ALWAYS(iData, EEglWindowPanicREglStandAloneWindowNotCreated);
    return iData->iSizeInTwips;
    }


EXPORT_C TInt REglStandAloneWindow::ScreenNumber() const
    {
    EGL_WINDOW_ASSERT_ALWAYS(iData, EEglWindowPanicREglStandAloneWindowNotCreated);
    return iData->iScreenNumber;
    }


EXPORT_C void REglStandAloneWindow::SetBackgroundColor(TRgb aColor, TBool aTriggerRedraw)
    {
    EGL_WINDOW_ASSERT_ALWAYS(iData, EEglWindowPanicREglStandAloneWindowNotCreated);
    iData->iBackgroundColor = aColor;
    iData->iObserver.ColorWasSetForWindow(*this, aTriggerRedraw);
    }


EXPORT_C TInt REglStandAloneWindow::SetBackgroundSurface(const TSurfaceConfiguration& aConfiguration, TBool aTriggerRedraw)
    {
    EGL_WINDOW_ASSERT_ALWAYS(iData, EEglWindowPanicREglStandAloneWindowNotCreated);
    
#ifdef _DEBUG
    //Assert that the surface is not null.
    TSurfaceId surface;
    aConfiguration.GetSurfaceId(surface);
    EGL_WINDOW_ASSERT_DEBUG(!surface.IsNull(), EEglWindowPanicInvalidSurface);
#endif
    
    //Remove the old surface if one exists.
    RemoveBackgroundSurface(EFalse);
    
    //Save the new configuration and alert the observer that a new surface was set.
    TInt err = KErrNone;
    CopySurfaceConfiguration(aConfiguration, iData->iSurfaceConfig);
    err = iData->iObserver.SurfaceWasSetForWindow(*this, aTriggerRedraw);
    
    return err;
    }


EXPORT_C void REglStandAloneWindow::RemoveBackgroundSurface(TBool aTriggerRedraw)
    {
    EGL_WINDOW_ASSERT_ALWAYS(iData, EEglWindowPanicREglStandAloneWindowNotCreated);
    
    //If there is a valid config, alert the observer that it will be removed.
    TSurfaceId surface;
    iData->iSurfaceConfig.GetSurfaceId(surface);
    if(!surface.IsNull())
        {
        iData->iObserver.SurfaceWillBeRemovedForWindow(*this, aTriggerRedraw);
        }
    
    //Zero the configuration.
    CopySurfaceConfiguration(TSurfaceConfiguration(), iData->iSurfaceConfig);
    }

//-------------------------------------------------------------------