/*

* 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:  Day view control of calendar

*

*/

//System includes

#include <QGesture>

#include <QGraphicsLinearLayout>

#include <hbabstractviewitem.h>

#include <hbinstance.h>

#include <hbaction.h>

//User includes

#include "calendayitemview.h"

#include "calendayutils.h"

#include "calendaycontainer.h"

#include "calendayinfo.h"

#include "calendaymodel.h"

#include "calenservices.h"

#include "calencontext.h"

#include "CalenUid.h"

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

// CalenDayItemView()

// Constructor

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

//

CalenDayItemView::CalenDayItemView( MCalenServices &services, HbModelIterator *iterator, QGraphicsItem *parent ) 

: HbAbstractItemView(mContainer = new CalenDayContainer(), iterator, parent),

  mServices( services )

{

    mInfo = new CalenDayInfo( CalenDayInfo::ETwo );

    mContainer->setDayInfo( mInfo );

    //setup Selection Model

    QItemSelectionModel* selModel = new QItemSelectionModel(this->model());

    if ( selModel ) {

        setSelectionMode( HbAbstractItemView::SingleSelection );

        setSelectionModel( selModel );

    }

    setScrollDirections(Qt::Vertical);

    setScrollingStyle(HbScrollArea::PanWithFollowOn);

    setVerticalScrollBarPolicy(HbScrollArea::ScrollBarAlwaysOff);

    grabGesture(Qt::PanGesture);

    ungrabGesture(Qt::SwipeGesture);

    //TODO: KG: Animate item pressed?! HbAbstractItemView::TouchDown

    setEnabledAnimations( HbAbstractItemView::None );

    // Get the width of content and fix its size

    qreal contentWidth = CalenDayUtils::instance()->contentWidth();

    setMinimumWidth(contentWidth);

    setMaximumWidth(contentWidth);

    setupSlots();

    setupContextMenu();

}

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

// ~CalenDayItemView()

// Destructor

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

//

CalenDayItemView::~CalenDayItemView()

{

    delete mInfo;

}

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

// scrollTo()

// 

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

//

void CalenDayItemView::scrollTo(const QModelIndex &index, HbAbstractItemView::ScrollHint hint)

{

    HbAbstractItemView::scrollTo(index, hint);

}

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

// reset()

// 

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

//

void CalenDayItemView::reset()

{

//    CalenDayItemView::reset();

}

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

// modelAboutToBeReset()

// Handles signal that is emitted when reset() is called, before the model's

// internal state (e.g. persistent model indexes) has been invalidated.

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

//

void CalenDayItemView::modelAboutToBeReset()

{

}

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

// modelReset()

// Handles signal that is emitted when reset() is called, after the model's

// internal state (e.g. persistent model indexes) has been invalidated.

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

//

void CalenDayItemView::modelReset()

{

    if ( !mInfo ) {

        return;

    }

    //reset day info

    mInfo->Reset();

    CalenDayModel* model(0);

    model = static_cast<CalenDayModel*>(this->model());

    if ( !model ) {

        return;

    }

    int rowCount = model->rowCount( );

    SCalenApptInfo apptInfo; 

    for( int row = 0; row < rowCount; row++ ) {

        QModelIndex idx = model->index( row, 0 );

        QVariant variant = idx.data( CalenDayEntry );

        AgendaEntry entry = variant.value<AgendaEntry>();

        apptInfo.iIndex = idx;

        QDateTime start;

        QDateTime end;

        QDateTime currDate( model->modelDate() );

        CalenDayUtils::instance()->getEventValidStartEndTime( start, end, 

                                                              entry, currDate );

        apptInfo.iStartTime = start;

        apptInfo.iEndTime = end;

        TCalenInstanceId id = TCalenInstanceId::nullInstanceId();//index.row() - temporary ID

        id.mEntryLocalUid = row;

        id.mInstanceTime = apptInfo.iStartTime; 

        apptInfo.iId = id;

        apptInfo.iColor = 0xffff;

        if ( entry.isTimedEntry() )

        	{

            apptInfo.iAllDay = false;

            mInfo->InsertTimedEvent( apptInfo );

        	}

        else if( entry.type() == AgendaEntry::TypeEvent) //all-day event

        	{

        	apptInfo.iAllDay = true;

        	mInfo->InsertAlldayEvent( apptInfo );

        	}

    }

    HbAbstractItemView::reset();

}

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

// scrollVertically()

//  

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

//

void CalenDayItemView::scrollVertically( const QPointF &newPosition )

{

    QPointF currentPos = contentWidget()->pos();

    if (abs(newPosition.y()) != abs(currentPos.y())) {

        currentPos.setY(newPosition.y());

        scrollContentsTo(currentPos, 0);

    }

}

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

// itemPressed()

// This function is called when a touch down event is received within Abstract view item that is representing index. 

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

//

void CalenDayItemView::itemPressed( const QPointF &position )

{

    Q_UNUSED( position )

}

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

// itemReleased()

// This function is called when a touch release event is received within Abstract view item that is representing index.

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

//

void CalenDayItemView::itemReleased( const QPointF &position )

{

    Q_UNUSED( position )

}

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

// itemActivated()

// This function is called when the item specified by index is activated by the user.

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

//

void CalenDayItemView::itemActivated( const QPointF &position )

{

    Q_UNUSED( position )

    HbAbstractViewItem *item = qobject_cast<HbAbstractViewItem *>(sender());

    QModelIndex index = item->modelIndex();

    QItemSelectionModel* selModel( selectionModel() );

    if ( index.isValid() && selModel) {

        selModel->select( index, QItemSelectionModel::Current | QItemSelectionModel::Select );

        openSelectedItem();

    }

}

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

// itemLongPressed()

// This function is called when long press event is received within Abstract view item viewItem.

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

//

void CalenDayItemView::itemLongPressed(HbAbstractViewItem* item, QPointF coords)

{

    QModelIndex index = item->modelIndex();

    QItemSelectionModel* selModel( selectionModel() );

    if ( index.isValid() && selModel && mContextMenu) {

        selModel->select( index, QItemSelectionModel::Current | QItemSelectionModel::Select );

        mContextMenu->setPreferredPos( coords, HbPopup::BottomRightCorner );

        mContextMenu->open();

    }

}

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

// orientationChanged()

// Slot which is called whenever the orientation of the device changes.

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

//

void CalenDayItemView::orientationChanged( Qt::Orientation orientation )

{

    // Update the width of screen

    qreal contentWidth = CalenDayUtils::instance()->contentWidth();

    setMinimumWidth(contentWidth);

    setMaximumWidth(contentWidth);

    if( mContainer ) {

        mContainer->orientationChanged( orientation );

    }

}

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

// openSelectedItem()

// Opens currently selected model item.

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

//

void CalenDayItemView::openSelectedItem()

{

    issueCommandOnSelectedItem( ECalenEventView );

}

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

// editSelectedItem()

// Edits currently selected model item.

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

//

void CalenDayItemView::editSelectedItem()

{

    issueCommandOnSelectedItem( ECalenEditCurrentEntry );

}

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

// deleteSelectedIten()

// Deletes currently selected model item.

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

//

void CalenDayItemView::deleteSelectedItem()

{

    issueCommandOnSelectedItem( ECalenDeleteCurrentEntry );

}

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

// setupSlots()

// Connects item view's slots.

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

//

void CalenDayItemView::setupSlots()

{

    // Connect to main window's orientationChanged signal to handle orientation

    // switching

    QObject::connect(CalenDayUtils::instance()->mainWindow(), 

        SIGNAL(orientationChanged(Qt::Orientation)), this,

        SLOT(orientationChanged(Qt::Orientation)));

    // Connect with model signals

    if (this->model()) {

        QObject::connect(this->model(), SIGNAL(modelAboutToBeReset()), this,

            SLOT(modelAboutToBeReset()));

        QObject::connect(this->model(), SIGNAL(modelReset()), this,

            SLOT(modelReset()));

    }

    if (mContainer) {

        // Connect with base class to enable handling item press by model index

        QObject::connect(mContainer, SIGNAL(itemCreated(HbAbstractViewItem *)),

            this, SLOT(itemCreated(HbAbstractViewItem*)));

    }

    QObject::connect(this, SIGNAL(pressed(const QPointF&)), this,

        SLOT(itemPressed(const QPointF&)));

    QObject::connect(this, SIGNAL(released(const QPointF&)), this,

        SLOT(itemReleased(const QPointF&)));

    QObject::connect(this, SIGNAL(activated(const QPointF&)), this,

        SLOT(const QPointF&));

    QObject::connect(this, SIGNAL(longPressed(HbAbstractViewItem*, QPointF)),

        this, SLOT(itemLongPressed(HbAbstractViewItem*, QPointF)));

}

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

// setupSlots()

// Creates Context menu.

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

//

void CalenDayItemView::setupContextMenu()

{

    mContextMenu = new HbMenu();

    HbAction *openAction = mContextMenu->addAction(hbTrId("txt_common_menu_open"));

    if (openAction) {

        connect(openAction, SIGNAL(triggered()), this, SLOT(openSelectedItem()));

    }

    HbAction *editAction = mContextMenu->addAction(hbTrId("txt_common_menu_edit"));

    if (editAction) {

        connect(editAction, SIGNAL(triggered()), this, SLOT(editSelectedItem()));

    }

    HbAction *deleteAction = mContextMenu->addAction(hbTrId("txt_common_menu_delete"));

    if (deleteAction) {

        connect(deleteAction, SIGNAL(triggered()), this,

            SLOT(deleteSelectedItem()));

    }

}

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

// issueCommandOnSelectedItem()

// Sets context to currently selected model item and issues calendar command.

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

//

bool CalenDayItemView::issueCommandOnSelectedItem( int command )

{

    bool retVal(false);

    QItemSelectionModel* selModel(selectionModel());

    if (!selModel){

        return retVal;

    }

    QModelIndex index( selModel->currentIndex() );

    if( index.isValid() ) {

        retVal = true;

        QVariant variant = index.data( CalenDayEntry );

        AgendaEntry entry = variant.value<AgendaEntry>();

        QDateTime start;

        QDateTime end;

        CalenDayModel* model(0);

        model = static_cast<CalenDayModel*>(this->model());

        QDateTime currDate( model->modelDate() );

        CalenDayUtils::instance()->getEventValidStartEndTime( start, end, 

                                                              entry, currDate );

        TRAPD(error,

                mServices.Context().setFocusDateAndTimeAndInstance(start,

                         TCalenInstanceId::create(entry));

                mServices.IssueCommandL( command );

              );

        if( error ) {

            retVal = false;

        }

        clearSelectionInModel();

    }

    return retVal;

}

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

// clearSelectionInModel()

// Clears current selection in Selection Model.

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

//

void CalenDayItemView::clearSelectionInModel()

{

    QItemSelectionModel* selModel(selectionModel());

    if (selModel) {

        selModel->clear();

    }

}

// End of File