/* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and /or associated documentation files

 * (the "Materials "), to deal in the Materials without restriction,

 * including without limitation the rights to use, copy, modify, merge,

 * publish, distribute, sublicense, and/or sell copies of the Materials,

 * and to permit persons to whom the Materials are furnished to do so,

 * subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included

 * in all copies or substantial portions of the Materials.

 *

 * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR

 * THE USE OR OTHER DEALINGS IN THE MATERIALS.

 *

 * Initial Contributors:

 * Nokia Corporation - initial contribution.

 *

 * Contributors:

 *

 * Description:

 *

 */

#include "EGLProcess.h"

#include "EGLThread.h"

#include "eglInternal.h"

CEGLProcess::CEGLProcess( EGLint processId ) :

    m_id( processId ),

    m_currentThread( NULL )

    {

    }

CEGLProcess::~CEGLProcess(void)

    {

    DestroyPointerVector<CEGLThread>(m_threads);

    }

CEGLThread* CEGLProcess::AddThread( EGLI_THREAD_ID threadId, bool setCurrent, EGLint supportedApis )

    {

    CEGLThread* thread = HasThread( threadId );

    if( !thread )

        {

        thread = EGLI_NEW CEGLThread( threadId, supportedApis );

        if( thread )

            {

            AddObject<CEGLThread>( m_threads, thread );

            }

        }    

    if( setCurrent && thread )

        {

        m_currentThread = thread;

        }

    return thread;

    }

void CEGLProcess::RemoveThread( EGLI_THREAD_ID threadId )

    {

    if( m_currentThread && m_currentThread->Id() == threadId )

        {

        m_currentThread = NULL;

        }

    DeleteObjectById<CEGLThread>( m_threads, threadId );

    }

CEGLThread* CEGLProcess::HasThread( EGLI_THREAD_ID threadId ) const

    {

    return FindObjectById<CEGLThread>( m_threads, threadId, NULL );

    }

void CEGLProcess::SetCurrentThread( EGLI_THREAD_ID threadId )

    {

    EGLI_ASSERT(m_currentThread != NULL);

    if( m_currentThread->Id() != threadId )

        {

        m_currentThread = FindObjectById<CEGLThread>( m_threads, threadId, NULL );

        EGLI_ASSERT( m_currentThread != NULL );

        }

#else

    EGLI_ASSERT( false );

#endif

    }

CEGLThread* CEGLProcess::CurrentThread() const

    { 

    EGLI_ASSERT( m_currentThread != NULL );

    return m_currentThread;

#elif defined(_WIN32)

    EGLI_THREAD_ID threadId = GetCurrentThreadId();

    CEGLThread* thread = FindObjectById( m_threads, threadId, NULL );

    //EGLI_ASSERT( thread != NULL );

    return thread;

#else // Linux

    // \todo

#endif

    }

CEGLSurface* CEGLProcess::FindBoundSurface( CEGLContext* context, bool readSurface ) const

     {

     EGLI_ASSERT( context != NULL );

     CEGLSurface* ret = NULL;         

     std::vector<CEGLThread*>::const_iterator iter = m_threads.begin();

     while( iter != m_threads.end() )

         {

         if( (*iter)->CurrentVGContext() == context )

             {

             ret = (*iter)->CurrentVGSurface();

             break;

             }

         else if( (*iter)->CurrentGLESContext() == context )

             {

             //TODO

             EGLI_ASSERT( false );

             }

         }

     return ret;

     }