/*

* Copyright (c) 2007-2009 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:  Calendar view manager

 *

*/

//system includes

#include <hbmainwindow.h>

#include <hbinstance.h>

#include <hbapplication.h> // hbapplication

#include <xqserviceutil.h> // service utils

//user includes

#include "calenviewmanager.h"

#include "calencontroller.h"

#include "hb_calencommands.hrh"

#include "calenservicesimpl.h"

#include "calenmonthview.h"

#include "calenagendaview.h"

#include "calenmonthview.h"

#include "agendaeventviewer.h"

#include "calennotificationhandler.h"

#include "CalenUid.h"

#include "calenactionuiutils.h"

#include "calensettingsview.h"

#include "calendocloader.h"

#include "calendarui_debug.h"

#include "calencommon.h"

#include "calendayview.h"

#include <agendautil.h>

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "calenviewmanagerTraces.h"

#endif

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

// CalenViewManager::CalenViewManager

// 2nd phase of construction.

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

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

//

CalenViewManager::CalenViewManager( CCalenController& aController)

: mController(aController)

{

	OstTraceFunctionEntry0( CALENVIEWMANAGER_CALENVIEWMANAGER_ENTRY );

	// Following block intializes member variables

	mCalenEventViewer = NULL;

	mMonthViewDocLoader = NULL;

	mAgendaViewDocLoader = NULL;	

	mAgendaViewAltDocLoader = NULL;

	mCalenAgendaView = NULL;

	mCalenMonthView = NULL;

	mCalenAgendaViewAlt = NULL;

	mSettingsView = NULL;

	mCalenDayView = NULL;

	mInstanceViewCreated = false;

	// Connect to instance view and entry view creation signals from agenda

	// interface

	connect(mController.agendaInterface(), SIGNAL(instanceViewCreationCompleted(int)),

	        this, SLOT(handleInstanceViewCreation(int)));

	connect(mController.agendaInterface(), SIGNAL(entryViewCreationCompleted(int)),

		        this, SLOT(handleEntryViewCreation(int)));

	connect(mController.agendaInterface(), SIGNAL(entriesChanged(QList<ulong>)),

								this, SLOT(handleEntriesChanged(QList<ulong>)));

    connect(mController.agendaInterface(), SIGNAL(entryUpdated(ulong)),

                                this, SLOT(handleEntryUpdation(ulong)));

    connect(mController.agendaInterface(), SIGNAL(entryAdded(ulong)),

                                this, SLOT(handleEntryUpdation(ulong)));

	OstTraceFunctionExit0( CALENVIEWMANAGER_CALENVIEWMANAGER_EXIT );

}

void CalenViewManager::SecondPhaseConstruction()

{

    OstTraceFunctionEntry0( CALENVIEWMANAGER_SECONDPHASECONSTRUCTION_ENTRY );

    // Check the Application Startup reason from Activity Manager

    int activityReason = qobject_cast<HbApplication*>(qApp)->activateReason();

    // Check if calendar is launched thru XQService framework

    bool isFromServiceFrmWrk = XQServiceUtil::isService(); // Since activateReason 

    //of hbapplication is not returning right value if the activity is started 

    //as services so using the above line temporarily untill a fix is available in 

    // hbappliacation. Need to remove this line after the fix is available for hbapplcation

    if (Hb::ActivationReasonActivity == activityReason) // Check if application is started 

    // as an activity

        {

        // Application is started from an activity

        // Extract activity data

        QVariant data = qobject_cast<HbApplication*>(qApp)->activateData();

        // Restore state from activity data

        QByteArray serializedModel = data.toByteArray();

        QDataStream stream(&serializedModel, QIODevice::ReadOnly);

        int viewId; // int declared for debugging purpose

        stream >> viewId; // read stream into an int

        mFirstView = viewId;

        if (ECalenMonthView == viewId) // Check if Activity was stored for month view

            {

            loadMonthView(); // Load month view

            }

        else if (ECalenAgendaView == viewId) // Check if Activity was stored for agenda view

            {

        	loadAgendaView(); // Load agenda view

            }

        ActivateDefaultViewL(viewId);

        // Connect to the view ready signal so that we can construct other views 

        // once this view is ready

        connect(&mController.MainWindow(), SIGNAL(viewReady()), 

                this, SLOT(handleMainViewReady()));

        if (ECalenMonthView == viewId) // Check if Activity was stored for month view

            {

            mController.MainWindow().addView(mCalenMonthView); // Add month view to main window

            mController.MainWindow().setCurrentView(mCalenMonthView); // Set month view as current view

            } 

        else if (ECalenAgendaView == viewId) // Check if Activity was stored for agenda view

            {

            mController.MainWindow().addView(mCalenAgendaView); // Add agenda view to main window

            mController.MainWindow().setCurrentView(mCalenAgendaView); // Set agenda view as current view

            }

        } else if (isFromServiceFrmWrk/*Hb::ActivationReasonService == activityReason*/) {

        // Dont load any views until our remote slot gets called in

        // calenserviceprovider.cpp

        // Just have an empty mainwindow

    } else {

        // Do the normal startup

        // Load the month view and active it and add it to main window

        mFirstView = ECalenMonthView;

        loadMonthView();

        ActivateDefaultViewL(ECalenMonthView);

        // Connect to the view ready signal so that we construct other view 

        // once this view is shown

        connect(&mController.MainWindow(), SIGNAL(viewReady()), 

                        this, SLOT(handleMainViewReady()));

        mController.MainWindow().addView(mCalenMonthView);

        mController.MainWindow().setCurrentView(mCalenMonthView);

    }

    OstTraceFunctionExit0( CALENVIEWMANAGER_SECONDPHASECONSTRUCTION_EXIT );

}

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

// CalenViewManager::~CalenViewManager

// Destructor.

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

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

//

CalenViewManager::~CalenViewManager()

{

    OstTraceFunctionEntry0( DUP1_CALENVIEWMANAGER_CALENVIEWMANAGER_ENTRY );

	if (mSettingsView) {

		delete mSettingsView;

		mSettingsView = 0;

	}

	if (mAgendaViewDocLoader) {

		delete mAgendaViewDocLoader;

		mAgendaViewDocLoader = 0;

	}

	if (mAgendaViewAltDocLoader) {

		delete mAgendaViewAltDocLoader;

		mAgendaViewAltDocLoader = 0;

	}

	if (mMonthViewDocLoader) {

		delete mMonthViewDocLoader;

		mMonthViewDocLoader = 0;

	}

	OstTraceFunctionExit0( DUP1_CALENVIEWMANAGER_CALENVIEWMANAGER_EXIT );

}

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

// CalenViewManager::constructAndActivateView

// Constructs and activates the requested view

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

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

//

void CalenViewManager::constructAndActivateView(int view)

{

	OstTraceFunctionEntry0( CALENVIEWMANAGER_CONSTRUCTANDACTIVATEVIEW_ENTRY );

    // We are here because, some other application is launching calendar with 

	// the view, hence connect to viewReady() signal to do any lazy loading

	// in the slot

	// Connect to the view ready signal so that we construct other view 

	// once this view is shown

	connect(&mController.MainWindow(), SIGNAL(viewReady()), 

					this, SLOT(handleMainViewReady()));

	if (view == ECalenMonthView) {

		mFirstView = ECalenMonthView;

		loadMonthView();

		ActivateDefaultViewL(ECalenMonthView);

		// Add month view to mainwindow.

		mController.MainWindow().addView(mCalenMonthView);

		mController.MainWindow().setCurrentView(mCalenMonthView);

	} else if (view == ECalenAgendaView) {

		mFirstView = ECalenAgendaView;

		loadAgendaView();

		ActivateDefaultViewL(ECalenAgendaView);

		// Add agenda view to mainwindow.

		mController.MainWindow().addView(mCalenAgendaView);

		mController.MainWindow().setCurrentView(mCalenAgendaView);

		mController.MainWindow().addView(mCalenAgendaViewAlt);

	}

	OstTraceFunctionExit0( CALENVIEWMANAGER_CONSTRUCTANDACTIVATEVIEW_EXIT );

}

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

// CalenViewManager::loadMonthView

// Loads month view frm the docml

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

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

//

void CalenViewManager::loadMonthView()

{

    OstTraceFunctionEntry0( CALENVIEWMANAGER_LOADMONTHVIEW_ENTRY );

	bool loadSuccess = false;

	Qt::Orientation currentOrienation = mController.MainWindow().orientation();

	// Create the month view docloader object.

	mMonthViewDocLoader = new CalenDocLoader(mController);

	mMonthViewDocLoader->load(CALEN_MONTHVIEW_XML_FILE, &loadSuccess);

	Q_ASSERT_X(loadSuccess, "calenviewmanager.cpp", 

											"Unable to load month view XML");

	// Based on the current orientation, load the appropriate section

	if (Qt::Vertical == currentOrienation) {

		mMonthViewDocLoader->load(CALEN_MONTHVIEW_XML_FILE, 

											CALEN_PORTRAIT, &loadSuccess);

		} else {

			mMonthViewDocLoader->load(CALEN_MONTHVIEW_XML_FILE, 

											CALEN_LANDSCAPE, &loadSuccess);

		}

	Q_ASSERT_X(loadSuccess, "calenviewmanager.cpp", "Unable to load XML");

	// Get the calenmonth view from the loader.

	mCalenMonthView = static_cast<CalenMonthView *> 

							(mMonthViewDocLoader->findWidget(CALEN_MONTHVIEW));

	Q_ASSERT_X(mCalenMonthView, "calenviewmanager.cpp", 

											"Unable to load calenMonth view");

	// Set the parent to delete the view once will exit the application

	mCalenMonthView->setParent(this);

	// Setup the month view.

	mCalenMonthView->setupView(mMonthViewDocLoader);

	OstTraceFunctionExit0( CALENVIEWMANAGER_LOADMONTHVIEW_EXIT );

}

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

// CalenViewManager::loadAgendaView

// Loads the agenda view frm the docml

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

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

//

void CalenViewManager::loadAgendaView()

{

    OstTraceFunctionEntry0( CALENVIEWMANAGER_LOADAGENDAVIEW_ENTRY );

	bool loadSuccess = false;

	// Create the agenda view docloader object.

	mAgendaViewDocLoader = new CalenDocLoader(mController);

	// Load default section

	mAgendaViewDocLoader->load(CALEN_AGENDAVIEW_XML_FILE, &loadSuccess);

	if (!loadSuccess) {

		qFatal("calenviewmanager.cpp : Unable to load XML");

	}

	// Get the calenagenda view from the loader

	mCalenAgendaView = static_cast<CalenAgendaView *> (mAgendaViewDocLoader->findWidget(CALEN_AGENDAVIEW));

	if (!mCalenAgendaView) {

		qFatal("calenviewmanager.cpp : Unable to find agenda view");

	}

	// Set the parent to delete the view once will exit the application

	mCalenAgendaView->setParent(this);

	// Setup the agenda view

	mCalenAgendaView->setupView(mAgendaViewDocLoader);

	// The following code is done to provide swipe support

	// in agenda view. Idea is to create two views and keep

	// switiching between these two using view switch effects

	// to provide an illusion of flow to the user

	loadAlternateAgendaView();

	OstTraceFunctionExit0( CALENVIEWMANAGER_LOADAGENDAVIEW_EXIT );

}

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

// CalenViewManager::loadDayView

// Loads day view from the docml

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

void CalenViewManager::loadDayView()

{

    bool loadSuccess = false;

    // Create the docloader object

    CalenDocLoader *docLoader = new CalenDocLoader(mController);

    if (docLoader) {

        docLoader->load(CALEN_DAYVIEW_DOCML, &loadSuccess);

        if (!loadSuccess) {

            qFatal("calenviewmanager.cpp : Unable to load day view XML");

        }

        // Get the CalenDayView object from the loader

        mCalenDayView = static_cast<CalenDayView *>

            (docLoader->findWidget(CALEN_DAYVIEW));

        if (!mCalenDayView) {

            qFatal("calenviewmanager.cpp : Unable to find day view");

        }

        // Set the parent to delete the view once will exit the application

        mCalenDayView->setParent(this);

        // Set up the day view - day view takes the ownership

        mCalenDayView->setupView(docLoader);

    }

}

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

// CalenViewManager::handleMainViewReady

// Slot to handle viewReady() signal from mainwindow

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

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

//

void CalenViewManager::handleMainViewReady()

{

    OstTraceFunctionEntry0( CALENVIEWMANAGER_HANDLEMAINVIEWREADY_ENTRY );

	// Construct the month view part that is kept for lazy loading

    if (mCalenMonthView) {

		mCalenMonthView->doLazyLoading();

		if (mInstanceViewCreated) {

			// populate entries for the month view if the month view is launched 

			// from the service APIs. Otherwise the month view is not populated with 

			// the entries as CalenViewManager::handleInstanceViewCreation is called 

			// before the month view creation so the model array is not populated.

			mCalenMonthView->fetchEntriesAndUpdateModel();

		}

	}

	// Construct other views

	constructOtherViews();

    // Install the event filter for the controller once the view is ready

    // so that system language/locale changes can be handled

	//hbInstance->allMainWindows().first()->installEventFilter(&mController);

	// disconnect the view ready signal as we dont need it anymore

	disconnect(&mController.MainWindow(), SIGNAL(viewReady()), 

			   this, SLOT(handleMainViewReady()));

	OstTraceFunctionExit0( CALENVIEWMANAGER_HANDLEMAINVIEWREADY_EXIT );

}

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

// CalenViewManager::constructOtherViews

// Constructs the other views apart frm firstview and adds them to main window

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

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

//

void CalenViewManager::constructOtherViews()

{

    OstTraceFunctionEntry0( CALENVIEWMANAGER_CONSTRUCTOTHERVIEWS_ENTRY );

	// Load all other views except mFirstView

	// NOTE: Right now, since Calendar has only two views, month view 

	// and agenda view, when client launches agenda view, then there is no need

	// to construct the month view as per UI REQ., but tomorrow if new views

	// come after agenda view, then we need to construct those views if they are

	// native views. Right now, there is a event viewer but its not a native

	// view. Hence, if agenda view is launched, dont construct month view

	if (mFirstView != ECalenAgendaView) // check if agenda view is not already loaded

		{

		// Load all other views 

		loadAgendaView();

		if (!mCalenDayView) {

		    loadDayView();

		}

	}

	else //agenda view was launched as first view

	    {

		// No implementation yet. UI specs not clear

		// to be commented in with some more code once UI specs is frozen

		// for agenda view launching as first view after it was saved as activity

		// when it was launched from month view

        // loadMonthView();

        // mCalenMonthView->doLazyLoading();

	    }

	// Setup the settings view

	mSettingsView = new CalenSettingsView(mController.Services());

	OstTraceFunctionExit0( CALENVIEWMANAGER_CONSTRUCTOTHERVIEWS_EXIT );

}

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

// CalenViewManager::getFirstView

// Returns the first view

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

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

//

int CalenViewManager::getFirstView()

{

    OstTraceFunctionEntry0( CALENVIEWMANAGER_GETFIRSTVIEW_ENTRY );

	OstTraceFunctionExit0( CALENVIEWMANAGER_GETFIRSTVIEW_EXIT );

	return mFirstView;

}

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

// CalenViewManager::showNextDay

// other items were commented in a header

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

//

void CalenViewManager::showNextDay()

{

    OstTraceFunctionEntry0( CALENVIEWMANAGER_SHOWNEXTDAY_ENTRY );

    // Set the context for the next day

    QDateTime currentDay = mController.Services().Context().focusDateAndTime();

    currentDay = currentDay.addDays(1);

    mController.Services().Context().setFocusDate(currentDay);

    mCurrentViewId = ECalenAgendaView;

    // Check which is the currently activated view

    if (mController.MainWindow().currentView() == mCalenAgendaView) {

        mCalenAgendaView->disconnectAboutToQuitEvent(); // disconnect mCalenAgendaView to get aboutToQuit Events

        HbEffect::add(mCalenAgendaView,

                      ":/fxml/view_hide",

                      "hide");

        HbEffect::add(mCalenAgendaViewAlt,

                      ":/fxml/view_show",

                      "show");

        // Set the other agenda view as the current view

        // and animate to provide illusion of swipe

		// It would also connect for aboutToQuit events

        mCalenAgendaViewAlt->doPopulation();

        mController.MainWindow().setCurrentView(mCalenAgendaViewAlt, true, Hb::ViewSwitchUseNormalAnim);

    } else {

    mCalenAgendaViewAlt->disconnectAboutToQuitEvent(); // disconnect mCalenAgendaViewAlt to get aboutToQuit Events

        HbEffect::add(mCalenAgendaViewAlt,

                      ":/fxml/view_hide",

                      "hide");

        HbEffect::add(mCalenAgendaView,

                      ":/fxml/view_show",

                      "show");

		// It would also connect for aboutToQuit events

        mCalenAgendaView->doPopulation();

        mController.MainWindow().setCurrentView(mCalenAgendaView, true, Hb::ViewSwitchUseNormalAnim);

    }

    OstTraceFunctionExit0( CALENVIEWMANAGER_SHOWNEXTDAY_EXIT );

}

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

// CalenViewManager::showPrevDay

// other items were commented in a header

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

//

void CalenViewManager::showPrevDay()

{

    OstTraceFunctionEntry0( CALENVIEWMANAGER_SHOWPREVDAY_ENTRY );