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

*

*/

// INCLUDES

#include <calenconstants.h>

#include <calenagendautils.h>

#include <calendateutils.h>

#include <calentoolbar.h>

#include <Calendar.rsg>

#include <CalenStatusPaneUtils.h>

#include <calencontext.h>

#include <caltime.h>

#include <calinstance.h>

#include <calinstanceview.h>

#include <calentry.h>

#include <aknlists.h>

#include <aknnavide.h>

#include <aknnotewrappers.h>

#include <AknWaitDialog.h>

#include <eikbtgpc.h>

#include <centralrepository.h>

#include <StringLoader.h>

#include <sysutil.h>

#include <hlplch.h>

#include <akntoolbar.h>

#include <calencommands.hrh>

#include <calenservices.h>

#include <calsession.h>

#include <calenviewutils.h>

#include <calcalendarinfo.h>

#include <caleninstanceid.h>            // TCalenInstanceId

#include "calendarui_debug.h"           // Debug.

#include "CalendarVariant.hrh"

#include "calennativeview.h"

#include "calencontainer.h"

#include "CalenInterimUtils2.h"

#include "calensend.h"

#include "calentitlepane.h"

#include "CleanupResetAndDestroy.h"

#include "CalenPaths.h"

#include "calendar.hrh"

#include "CalenUid.h"

#include "CalendarPrivateCRKeys.h"

#include "multicaluidialog.h"

const TInt KAbbreviatedWeekNames[] =

    {

    R_QTN_WEEK_TWO_CHARS_MO,

    R_QTN_WEEK_TWO_CHARS_TU,

    R_QTN_WEEK_TWO_CHARS_WE,

    R_QTN_WEEK_TWO_CHARS_TH,

    R_QTN_WEEK_TWO_CHARS_FR,

    R_QTN_WEEK_TWO_CHARS_SA,

    R_QTN_WEEK_TWO_CHARS_SU

    };

#ifdef RD_CALEN_EXTERNAL_CAL

#include  <aiwservicehandler.h>

// MIME types

_LIT8(KContentTypeCalendar, "text/calendar");

#endif //RD_CALEN_EXTERNAL_CAL

#include <aknnavilabel.h>

#include <calennavilabel.h>

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

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

// CCalenNativeView::~CCalenNativeView

// Destructor

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

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

//

CCalenNativeView::~CCalenNativeView()

    {

    TRACE_ENTRY_POINT;

    CCoeAppUi* appui = CEikonEnv::Static()->AppUi();

    appui->RemoveFromStack( iContainer );

    delete iContainer;

    iServices.CancelNotifications( this );

    delete iAbbreviatedDayArray;

#ifdef RD_CALEN_EXTERNAL_CAL

    //delete AIW iServiceHandler;

    ReleaseServiceHandler();

#endif //RD_CALEN_EXTERNAL_CAL

    delete iMenuName;

    delete iSettingsName;

    delete iSPUtils;

    if( iAsyncCallback )

        {

        iAsyncCallback->Cancel();

        delete iAsyncCallback;

        iAsyncCallback = NULL;

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenNativeView::SetStatusPaneFromActiveContextL(

// This function sets the status pane based upon the context

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

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

//

void CCalenNativeView::SetStatusPaneFromActiveContextL()

    {

    TRACE_ENTRY_POINT;

    iSPUtils->RefreshStatusPane();

    TRACE_EXIT_POINT;

    }

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

// CCalenNativeView::Container

// Return container control pointer.

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

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

//

CCalenContainer* CCalenNativeView::Container()

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return iContainer;

    }

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

// CCalenNativeView::OnCmdGotoDateL

// Handling command "Go to day"

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

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

//

void CCalenNativeView::OnCmdGotoDateL()

    {

    TRACE_ENTRY_POINT;

    TTime date = CalenDateUtils::Today();

    TInt buttonId = CalenViewUtils::DateQueryL( date, 0 );

		//test

	TDateTime dateTime = date.DateTime();

    if (buttonId == EAknSoftkeyOk || buttonId == EEikBidOk)

        {

        MCalenContext& context = iServices.Context();

        TCalTime dateCalTime;

        dateCalTime.SetTimeLocalL( date );

        context.SetFocusDateAndTimeL( dateCalTime, context.ViewId() );

        iContainer->NotifyChangeDateL();

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenNativeView::OnCmdGotoTodayL

// Handling command "Today". # key is pressed.

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

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

//

void CCalenNativeView::OnCmdGotoTodayL()

    {

    TRACE_ENTRY_POINT;

    TTime today = CalenDateUtils::Today();

    MCalenContext& context = iServices.Context();

    TCalTime todayCalTime;

    todayCalTime.SetTimeLocalL( today );

    context.SetFocusDateAndTimeL( todayCalTime, context.ViewId() );

    iContainer->NotifyChangeDateL();

    TRACE_EXIT_POINT;

    }

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

// CCalenNativeView::NotifyFocusChanged

// Notified that the focus of Container changes.

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

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

//

void CCalenNativeView::NotifyFocusChanged()

    {

    TRACE_ENTRY_POINT;

    // FIXME: iLocChangeReason doesn't seem to serve any purpose.

    // Debug how it is used.

    if (iContainer && iNeedsRefresh)

        {

        if (IsForeground() && IsContainerFocused())

            {

            //The database was changed while calendar was running as a

            //background task or the editor was open.  We need to refresh.

            TRAP_IGNORE(BeginRepopulationL());

            iNeedsRefresh = EFalse;

            }

        }

    if (iLocChangeReason && IsContainerFocused())

        {

        PIM_TRAPD_HANDLE( OnLocaleChangedL( iLocChangeReason ) );

        }

    iLocChangeReason = 0;

    TRACE_EXIT_POINT;

    }

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

// CCalenNativeView::IsContainerFocused

// Is container focused?

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

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

//

TBool CCalenNativeView::IsContainerFocused()

    {

    TRACE_ENTRY_POINT;

    TRACE_EXIT_POINT;

    return (iContainer && iContainer->IsVisible());

    }

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

// CCalenNativeView::ShowValidScrollButtons

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

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

//

void CCalenNativeView::ShowValidScrollButtons(CAknNavigationDecorator& aNaviLabel,

                                        const TTime& aBeforeRange,

                                        const TTime& aAfterRange)

    {

    TRACE_ENTRY_POINT;

    aNaviLabel.MakeScrollButtonVisible(ETrue);

    // FIXME can be written more simply.

    TBool mirrored(AknLayoutUtils::LayoutMirrored());

    if (mirrored)

        {

        TBool validDay(CalenDateUtils::IsValidDay(aBeforeRange));

        aNaviLabel.SetScrollButtonDimmed(

            CAknNavigationDecorator::ERightButton, !validDay);

        validDay = CalenDateUtils::IsValidDay(TTime(aAfterRange));

        aNaviLabel.SetScrollButtonDimmed(

            CAknNavigationDecorator::ELeftButton, !validDay);

        }

    else

        {

        TBool validDay(CalenDateUtils::IsValidDay(aBeforeRange));

        aNaviLabel.SetScrollButtonDimmed(

            CAknNavigationDecorator::ELeftButton, !validDay);

        validDay = CalenDateUtils::IsValidDay(aAfterRange);

        aNaviLabel.SetScrollButtonDimmed(

            CAknNavigationDecorator::ERightButton, !validDay);

        }

    if(iContainer && AknLayoutUtils::PenEnabled())

        {

        aNaviLabel.SetNaviDecoratorObserver(static_cast<MAknNaviDecoratorObserver*>(iContainer));

        CCoeControl* coeRes = aNaviLabel.DecoratedControl();

        CCalenNaviLabel *actualLabel = static_cast<CCalenNaviLabel*>(coeRes);

        actualLabel->SetLabelObserver(static_cast<MCCalenNaviLabelObserver*>(iContainer));

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenNativeView::DynInitMenuPaneL

// Initialization of Options menu

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

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

//

void CCalenNativeView::DynInitMenuPaneL(TInt aResourceId, CEikMenuPane* aMenuPane)

    {

    TRACE_ENTRY_POINT;

    switch (aResourceId)

        {

        case R_CALENDAR_NOTETYPE_MENUPANE:

            {

            if( !iServices.InterimUtilsL().MRViewersEnabledL( ETrue ) )

                {

                aMenuPane->DeleteMenuItem( ECalenNewMeetingRequest );

                }

            break;

            }

        case R_CALENDAR_CHANGE_VIEW_MENUPANE:

            {

            // If we get the cascading view switch menu pane, 

            // need to offer it to the services, to remove

            // the current view.

            iServices.OfferMenuPaneL( aResourceId, aMenuPane );

            }

            break;

        default:

            {

#ifdef RD_CALEN_EXTERNAL_CAL

            // do we have a service handler, if not create one

            if (!iServiceHandler)

                {

                CreateServiceHandlerL(ETrue);

                }

            if (iServiceHandler->HandleSubmenuL(*aMenuPane))

                {

                return;

                }

            // is the menu item AIW menu item if so, we will initialize our menu item

            if (iServiceHandler->IsAiwMenu(aResourceId))

                {

                CAiwGenericParamList& inParamList = iServiceHandler->InParamListL();

                TInt extrainfo=0;

                TAiwVariant variant(extrainfo);

                // No generic param for integer, therefore use EGenericParamError.

                TAiwGenericParam param(EGenericParamError, variant);

                inParamList.AppendL(param);

                iServiceHandler->InitializeMenuPaneL(

                    *aMenuPane,

                    aResourceId,

                    ECalenExtAiwCommandId,

                    inParamList);

                }

#endif

            break;

            }

        }

    TRACE_EXIT_POINT;

    }

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

// CCalenNativeView::HandleCommandL

// Command handling for each view

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

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

//

void CCalenNativeView::HandleCommandL(TInt aCommand)

    {

    TRACE_ENTRY_POINT;

     switch (aCommand)

        {

        case EAknCmdHelp:

            HlpLauncher::LaunchHelpApplicationL( iCoeEnv->WsSession(), iAvkonAppUi->AppHelpContextL() );

            break;

        // Context should be 8am on current focused day for these actions.

        case ECalenNewMeeting:

        case ECalenNewMeetingRequest:

        case ECalenNewAnniv:

        case ECalenNewDayNote:

        case ECalenNewTodo:

            {

            iIsEditorActive = ETrue;

            MCalenContext& context = iServices.Context();

            // Set the date on the context. It will set it to be the

            // default of view (8am) on that day as we don't set the time.

            TCalTime time;

            time.SetTimeLocalL( CCalenContainer::DateFromContextL( context ) );

            context.SetFocusDateL( time,

                                   TVwsViewId( KUidCalendar, Id() ) );

            iServices.IssueCommandL( aCommand );

            }

            break;

        case ECalenShowSettings:

            {

            iIsEditorActive = ETrue;

            iServices.IssueCommandL( aCommand );

            }

            break;

        case ECalenMonthView:

        case ECalenWeekView:

        case ECalenDayView:

        case ECalenTodoView:

            {

            MCalenContext& context = iServices.Context();

            // Set the date on the context. It will set it to be the

            // default of view (8am) on that day as we don't set the time.

            TCalTime time;

            time.SetTimeLocalL( CCalenContainer::DateFromContextL( context ) );

            context.SetFocusDateL( time,

                                   TVwsViewId( KUidCalendar, Id() ) );

            iServices.IssueCommandL( aCommand );

            }

            break;

        // The context should remain the same for these actions.

        case ECalenForwardsToDayView:

        case ECalenNextView:

        case ECalenPrevView:

        case ECalenViewCurrentEntry:

        case ECalenEditCurrentEntry: 

        case ECalenCompleteTodo:

        case ECalenRestoreTodo:

        case ECalenDeleteAllEntries:

        case ECalenDeleteCurrentEntry:

        case ECalenDeleteEntriesBeforeDate:

        //case ECalenGlobalSendAsCmdId:

                SetCommandHandlingInProgress( ETrue );

                iServices.IssueCommandL( aCommand );

            break;

        case ECalenEventView:

        case ECalenSwitchView:  

		case ECalenSend:

            iServices.IssueCommandL( aCommand );

            break;

        case ECalenGotoDate:

            OnCmdGotoDateL();

            break;

        case ECalenGotoToday:

            OnCmdGotoTodayL();

            break;

        default:

            {

#ifdef RD_CALEN_EXTERNAL_CAL

            // by default we will check also AIW commands

            if (!iServiceHandler)

                {

                CreateServiceHandlerL(ETrue);

                }

            TInt aiwCmd = iServiceHandler->ServiceCmdByMenuCmd(aCommand);

            // if we have right one, handle it

            if(aiwCmd)

                {

                // add current focused date to param list

                MCalenContext& context = iServices.Context();

                TTime time = context.FocusTime().TimeLocalL();

                CAiwGenericParamList& inparams=iServiceHandler->InParamListL();

                TAiwGenericParam date(EGenericParamDateTime);

                date.Value().Set(time);

                inparams.AppendL(date);

                // Execute AIW menu service command.

                PIM_TRAPD_HANDLE(

                iServiceHandler->ExecuteMenuCmdL(

                    aCommand,                           // The service command

                    inparams,    // pass our date

                    iServiceHandler->OutParamListL(),   // No output parameters needed

                    KAiwOptASyncronous,                  // we are using async version

                    this ));                             // and we want to call us back

                }

            // if not then let ui framwork handle it

            else

                {

#endif

                iServices.IssueCommandL( aCommand );

#ifdef RD_CALEN_EXTERNAL_CAL

                }

#endif // RD_CALEN_EXTERNAL_CAL