/*

* Copyright (c) 2002-2008 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:

*

*

*/

//debug

#include "calendarui_debug.h"

// INCLUDE FILES

#include "calencontextimpl.h"       // Calendar context implementation

#include <calinstanceview.h>        // Calendar Instance view

#include <calentryview.h>           // Calendar Entry view

// Default Calendar database path

// ============================ MEMBER FUNCTIONS ===============================

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

// CCalenGlobalData::CCalenGlobalData

// C++ default constructor can NOT contain any code, that might leave.

// (other items were commented in a header).

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

//

CCalenGlobalData::CCalenGlobalData( MCalProgressCallBack& aCalCallBack )

    : iCalCallBack( aCalCallBack )

    {

    TRACE_ENTRY_POINT;

    iGlobalDataOwnsCalSession = EFalse;

    TRACE_EXIT_POINT;

    }

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

// CCalenGlobalData::NewL

// Two phased construction. This will leave if an instance of global data

// already exists.  All access to an instance of the global data should be

// through the InstanceL function, except for the initial construction

// which should be handled by the controller.

// (other items were commented in a header).

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

//

EXPORT_C CCalenGlobalData* CCalenGlobalData::NewL( MCalProgressCallBack& aCalCallBack,

    {

    TRACE_ENTRY_POINT;

    CCalenGlobalData* self = NULL;

    TAny* tlsPtr = Dll::Tls();

    // Check Thread local storage

    if (!tlsPtr)

        {

        // TLS is NULL, so no CCalenGlobalData has been created yet.

        self = new( ELeave ) CCalenGlobalData( aCalCallBack );

        CleanupStack::PushL( self );

        // Store a self pointer in TLS

        User::LeaveIfError( Dll::SetTls( static_cast<TAny*>( self ) ) );

        // Increment ref count right away. If we don't do it here, and someone

        // calls CCalenGlobalData::InstanceL in ConstructL and then ConstructL

        // leaves, we will double delete the global data.

        ++self->iRefCount;

        CleanupStack::Pop( self );

        }

    else

        {

        // An instance of the global data exists already.

        // This function should only have been called once, by CCalenAppUi

        User::Leave( KErrAlreadyExists );

        }

    TRACE_EXIT_POINT;

    return self;

    }

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

// CCalenGlobalData::InstanceL

// Two-phased constructor.

// (other items were commented in a header).

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

EXPORT_C CCalenGlobalData* CCalenGlobalData::InstanceL()

    TRACE_ENTRY_POINT;

    CCalenGlobalData* self = NULL;

    TAny* tlsPtr = Dll::Tls();

    // Check Thread local storage

    if (!tlsPtr)

        {

        // The global data has not yet been constructed.

        // FIXME - Revise comment

        User::Leave( KErrNotReady );

        }

    else

        {

        self = static_cast<CCalenGlobalData*>( tlsPtr );

        }

    ++self->iRefCount;

    TRACE_EXIT_POINT;

    return self;

    }

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

// CCalenGlobalData::InstanceL

// Two-phased constructor.  Creates the CCalenGlobalData with an existing

// CCalSession.  CCalenGlobalData does NOT take ownership of the passed session

// The caller is responsible for ensuring that the session exists until all

// open references to the CCalenGlobalData are released.

// Calls User::Invariant() if CCalenGlobalData already has a valid session.

// (other items were commented in a header).

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

EXPORT_C CCalenGlobalData* CCalenGlobalData::InstanceL(CCalSession& aSession)

    {

    TRACE_ENTRY_POINT;

    CCalenGlobalData* self = CCalenGlobalData::InstanceL();

    CleanupStack::PushL(self);

    self->SetSessionL(&aSession);

    CleanupStack::Pop(self);

    TRACE_EXIT_POINT;

    return self;

    }

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

// CCalenGlobalData::InstanceL

// Non-leaving version of constructor. Returns an instance of

// CCalenGlobalData if one exists or NULL otherwise

// (other items were commented in a header).

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

EXPORT_C CCalenGlobalData* CCalenGlobalData::Instance()

    {

    TRACE_ENTRY_POINT;

    TAny* tlsPtr = Dll::Tls();

    CCalenGlobalData* self = static_cast<CCalenGlobalData*>( tlsPtr );

    if ( self )

        {

        ++self->iRefCount;

        }

    TRACE_EXIT_POINT;

    return self;

    }

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

// CCalenGlobalData::ConstructL

// Symbian 2nd phase constructor can leave.

// (other items were commented in a header).

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

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

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

// CCalenGlobalData::SetSessionL

// Sets the CCalenGlobalData to use an externally created CCalSession.

// Leaves with KErrAlreadyExists if a session has already been created by the

// CCalenGlobalData

// (other items were commented in a header).

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

void CCalenGlobalData::SetSessionL(CCalSession* aSession)

    {

    TRACE_ENTRY_POINT;

    if (iCalSession)

        {

        __ASSERT_ALWAYS(iCalSession == aSession, User::Leave(KErrAlreadyExists));

        }

    else

        {

        iGlobalDataOwnsCalSession = EFalse;

        iCalSession = aSession;

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenGlobalData::Release

// Release handle to CCalenGlobalData.  If no other objects are referencing

// this class it will be deleted

// (other items were commented in a header).

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

EXPORT_C void CCalenGlobalData::Release()

    {

    TRACE_ENTRY_POINT;

    --iRefCount;

    if (iRefCount == 0)

        {

        delete this;

        }

    TRACE_EXIT_POINT;

    }

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

// Destructor

// This is private and should only be called from the Release() function above

// (other items were commented in a header).

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

CCalenGlobalData::~CCalenGlobalData()

    {

    TRACE_ENTRY_POINT;

        {

        delete iCalSession;

        }

        {

        }

    Dll::SetTls(NULL);

    TRACE_EXIT_POINT;

    }

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

// CCalenGlobalData::CalSessionL

// Create a Calendar session if necessary and return a reference

// (other items were commented in a header).

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

EXPORT_C CCalSession& CCalenGlobalData::CalSessionL()

    {

    TRACE_ENTRY_POINT;

    if (!iCalSession)

        {

        iGlobalDataOwnsCalSession = ETrue;

        iCalSession = CCalSession::NewL();

        TRAPD( err, iCalSession->OpenL(KCalendarDatabaseFilePath));

            {

            }

        else

            {

            User::LeaveIfError( err );

            }

        }

    TRACE_EXIT_POINT;

    return *iCalSession;

    }

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

// CCalenGlobalData::InstanceViewL

// Create an instance view if necessary and returns a reference.  Creating an

// instance view is an asynchronous operation, but this call returns

// synchronously.  When the view is created, Completed() is called, which stops

// iAs allowing this function to complete.

// Leaves with KErrInUse if this class is in the process of creating the

// instance view

// (other items were commented in a header).

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

EXPORT_C CCalInstanceView* CCalenGlobalData::InstanceViewL()

    {

    TRACE_ENTRY_POINT;

    if (!iInstanceView && !iInstanceViewCreation)

        {

        if ( iEntryViewCreation )

            {

            iQueued = &CreateInstanceViewL;

            }

        else

            {

            CreateInstanceViewL();

            }

        }

    TRACE_EXIT_POINT;

    return iInstanceView;

    }

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

// CCalenGlobalData::EntryViewL

// Create an entry view if necessary and returns a reference.  Creating an

// entry view is an asynchronous operation, but this call returns

// synchronously.  When the view is created, Completed() is called, which stops

// iAs allowing this function to complete.

// Leaves with KErrInUse if this class is in the process of creating the

// entry view

// (other items were commented in a header).

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

EXPORT_C CCalEntryView* CCalenGlobalData::EntryViewL()

    {

    TRACE_ENTRY_POINT;

        {

        if ( iInstanceViewCreation )

            {

            iQueued = &CreateEntryViewL;

            }

        else

            {

            CreateEntryViewL();

            }

        }

    return iEntryView;

    }

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    }

void CCalenGlobalData::CreateInstanceViewL()

    {

    TRACE_ENTRY_POINT;

    iInstanceViewCreation = CCalInstanceView::NewL( CalSessionL(), iCalCallBack );

    TRACE_EXIT_POINT;

    }

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

// CEntryViewObserver::ViewCreationCompleted

// FIXME -- Update description

// Get call after entryview / instance view being created

// (other items were commented in a header).

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

void CCalenGlobalData::ViewCreationCompleted( TBool aSuccess )

    {

    TRACE_ENTRY_POINT;

    if ( !aSuccess )

        {

        // Something has gone wrong

        }

    else

        {

        if ( iEntryViewCreation )

            {

            iEntryView = iEntryViewCreation;

            }

        else if ( iInstanceViewCreation )

            {

            iInstanceView = iInstanceViewCreation;

            }

        }

    iEntryViewCreation = NULL;

    iInstanceViewCreation = NULL;

    if ( iQueued )

        {

        (this->*iQueued)();

        iQueued = NULL;

        }

    TRACE_EXIT_POINT;

    }

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

// (other items were commented in a header).

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

    {

    TRACE_ENTRY_POINT;

        {

        }

    TRACE_EXIT_POINT;

    }