/*

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

*

* Description:   Videolist content widget implementation

*

*/

#include "videocollectiontrace.h"

#include "videolistwidget.h"

#include <xqserviceutil.h>

#include <qcoreapplication.h>

#include <qtimer.h>

#include <hbscrollbar.h>

#include <xqserviceutil.h>

#include <hbmenu.h>

#include <hbaction.h>

#include <hbinstance.h>

#include <hbmainwindow.h>

#include <hblistviewitem.h>

#include <hbmessagebox.h>

#include <hbinputdialog.h>

#include <hbparameterlengthlimiter.h>

#include <vcxmyvideosdefs.h>

#include "videocollectionviewutils.h"

#include "videocollectionuiloader.h"

#include "videolistselectiondialog.h"

#include "videothumbnaildata.h"

#include "videosortfilterproxymodel.h"

#include "videocollectioncommon.h"

#include "mpxhbvideocommondefs.h"

// Object names.

const char* const LIST_WIDGET_OBJECT_NAME_CONTEXT_MENU             = "vc:ListWidgetContextMenu";

const char* const LIST_WIDGET_OBJECT_NAME_DELETE_VIDEO             = "vc:ListWidgetMessageBoxDeleteVideo";

const char* const LIST_WIDGET_OBJECT_NAME_RENAME_VIDEO             = "vc:ListWidgetInputDialogRenameVideo";

const char* const LIST_WIDGET_OBJECT_NAME_REMOVE_COLLECTION        = "vc:ListWidgetMessageBoxRemoveCollection";

const char* const LIST_WIDGET_OBJECT_NAME_NAV_KEY_BACK             = "vc:ListWidgetNavKeyBack";

const char* const LIST_WIDGET_OBJECT_NAME_NAV_KEY_QUIT             = "vc:ListWidgetNavKeyQuit";

const char* const LIST_WIDGET_OBJECT_NAME_ACTION_ATTACH            = "vc:ListWidgetActionAttach";

const char* const LIST_WIDGET_OBJECT_NAME_ACTION_PLAY              = "vc:ListWidgetActionPlay";

const char* const LIST_WIDGET_OBJECT_NAME_ACTION_DETAILS           = "vc:ListWidgetActionDetails";

const char* const LIST_WIDGET_OBJECT_NAME_ACTION_DELETE            = "vc:ListWidgetActionDelete";

const char* const LIST_WIDGET_OBJECT_NAME_ACTION_OPEN              = "vc:ListWidgetActionOpen";

const char* const LIST_WIDGET_OBJECT_NAME_ACTION_ADD_TO            = "vc:ListWidgetActionAddToCollection";

const char* const LIST_WIDGET_OBJECT_NAME_ACTION_REMOVE_FROM       = "vc:ListWidgetActionRemoveFromCollection";

const char* const LIST_WIDGET_OBJECT_NAME_ACTION_RENAME            = "vc:ListWidgetActionRename";

const char* const LIST_WIDGET_OBJECT_NAME_ACTION_REMOVE_COLLECTION = "vc:ListWidgetActionRemoveCollection";

// Interval in ms to report the scroll position.

const int SCROLL_POSITION_TIMER_TIMEOUT = 100;

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

// Constructor

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

//

VideoListWidget::VideoListWidget(VideoCollectionUiLoader *uiLoader, HbView *parent) :

HbListView(parent),

mModel(0),

mVideoServices(0),

mCurrentLevel(VideoCollectionCommon::ELevelInvalid),

mSignalsConnected(false),

mNavKeyAction(0),

mContextMenu(0),

mSelectionMode(HbAbstractItemView::NoSelection),

mScrollPositionTimer(0),

mUiLoader(uiLoader),

mService(VideoServices::ENoService)

{

	FUNC_LOG_ADDR(this);

}

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

// Destructor

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

//

VideoListWidget::~VideoListWidget()

{

	FUNC_LOG_ADDR(this);

    delete mScrollPositionTimer;

    mScrollPositionTimer = 0;

	mContextMenuActions.clear();

	disconnect();

    delete mContextMenu;

    mContextMenu = 0;

    delete mNavKeyAction;

    mNavKeyAction = 0;

    if(mVideoServices)

    {

        mVideoServices->decreaseReferenceCount();

        mVideoServices = 0;

    }

}

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

// initialize

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

//

int VideoListWidget::initialize(VideoSortFilterProxyModel &model, 

                                bool isService,

                                VideoCollectionCommon::TCollectionLevels level)

{

	FUNC_LOG_ADDR(this);

    mModel = &model;    

	mCurrentLevel = level;

	if(isService)

	{

		if(!mVideoServices)

		{

		    mVideoServices = VideoServices::instance();

		}

    	if(XQServiceUtil::interfaceName().contains("IVideoFetch"))

    	{

    		mService = VideoServices::EUriFetcher;

    	}

    	else if (XQServiceUtil::interfaceName().contains("IVideoBrowse"))

    	{

    		mService = VideoServices::EBrowse;

    	}

	}

    else

    {

        if(mVideoServices)

        {

		    mVideoServices->decreaseReferenceCount();

            mVideoServices = 0;    

        }

    }

    // init list view

    VideoCollectionViewUtils::initListView(this);

	mScrollPositionTimer = new QTimer();

	mScrollPositionTimer->setSingleShot(true);

	if (mVideoServices)

	{

		connect(this, SIGNAL(fileUri(const QString&)), mVideoServices, SLOT(itemSelected(const QString&)));

	}

	setItemPixmapCacheEnabled(true);

	setModel(mModel);

    return 0;

}

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

// activate

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

//

int VideoListWidget::activate()

{

	FUNC_LOG_ADDR(this);

    return activate(mCurrentLevel);

}

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

// activate

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

//

int VideoListWidget::activate(VideoCollectionCommon::TCollectionLevels level)

{

	FUNC_LOG_ADDR(this);

	INFO_2("VideoListWidget::activate() [0x%x]: level: %d", this, level);

    if(!mModel || level == VideoCollectionCommon::ELevelInvalid)

    {

        return -1;

    }

	mCurrentLevel = level;

    setVisible(true);

    setNavigationAction();

    if (connectSignals() < 0)

    {

        ERROR_1(-1, "VideoListWidget::activate() [0x%x]: connecting signals failed.", this);

        return -1;

    }

    // open model to the current level in case not in album or category

    if (level != VideoCollectionCommon::ELevelAlbum &&

        level != VideoCollectionCommon::ELevelDefaultColl)

    {

         mModel->open(level);

    }

    // Enable thumbnail background fetching.

    VideoThumbnailData &thumbnailData = VideoThumbnailData::instance();

    thumbnailData.enableBackgroundFetching(true);

    fetchThumbnailsForVisibleItems();

    return 0;

}

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

// deactivate

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

//

void VideoListWidget::deactivate()

{

	FUNC_LOG_ADDR(this);

    if(mContextMenu) 

    {

        mContextMenu->hide();

    }

    setVisible(false);

    disConnectSignals();

    // Free allocated memory for list thumbnails and disable background fetching.

    VideoThumbnailData &thumbnailData = VideoThumbnailData::instance();

    thumbnailData.enableBackgroundFetching(false);

    thumbnailData.freeThumbnailData();

}

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

// getLevel

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

//

VideoCollectionCommon::TCollectionLevels VideoListWidget::getLevel()

{

	FUNC_LOG_ADDR(this);

    return mCurrentLevel;

}

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

// connectSignals

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

//

int VideoListWidget::connectSignals()

{

	FUNC_LOG_ADDR(this);

    if (mSignalsConnected)

    {

        return 0;

    }

    if(!connect(this, SIGNAL(scrollingStarted()), this, SLOT(scrollingStartedSlot())) ||

       !connect(this, SIGNAL(scrollingEnded()), this, SLOT(scrollingEndedSlot())) ||

       !connect(this, SIGNAL(scrollPositionChanged(const QPointF &)), 

               this, SLOT(scrollPositionChangedSlot(const QPointF &))) ||

       !connect(this, SIGNAL(longPressed(HbAbstractViewItem *, const QPointF &)), 

    {

        return -1;

    }

    // handle navi key trigger -signal connection

    const char *slot = SLOT(quit()); 

    QObject *receiver = qApp;

    if(mVideoServices && mService == VideoServices::EBrowse)

    {

        receiver = mVideoServices;

        slot = SLOT(browsingEnded());

    }

    else 

    {        

        if(mCurrentLevel == VideoCollectionCommon::ELevelAlbum || 

           mCurrentLevel == VideoCollectionCommon::ELevelDefaultColl)

        {

            receiver = this;

            slot = SLOT(back());

        }

        else if(mVideoServices && mService == VideoServices::EUriFetcher)

        {

            receiver = this;

            slot = SLOT(endVideoFecthingSlot());            

        }

    }

    if(!connect(mNavKeyAction, SIGNAL(triggered()), receiver, slot))

    {

        return -1;

    }

    mSignalsConnected = true;

	return 0;

}

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

// disConnectSignals

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

//

void VideoListWidget::disConnectSignals()

{

    FUNC_LOG_ADDR(this);

    // safe to disconnect these always

    disconnect(

        this, SIGNAL(scrollingStarted()),

        this, SLOT(scrollingStartedSlot()));

    disconnect(

        this, SIGNAL(scrollingEnded()),

        this, SLOT(scrollingEndedSlot()));

    disconnect(

        this, SIGNAL(scrollPositionChanged(const QPointF&)), 

        this, SLOT(scrollPositionChangedSlot(const QPointF&)));

    disconnect(this, SIGNAL(longPressed(HbAbstractViewItem *, const QPointF &)), 

             this, SLOT(longPressedSlot(HbAbstractViewItem *, const QPointF &)));

    // check that scroll position timer is created

    if (mScrollPositionTimer)

    {

        disconnect(

            mScrollPositionTimer, SIGNAL(timeout()),

            this, SLOT(scrollPositionTimerSlot()));

    }

    if(mNavKeyAction)

    {

        mNavKeyAction->disconnect(SIGNAL(triggered()));

    }

	mSignalsConnected = false;

}

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

// setNavigationAction

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

//

void VideoListWidget::setNavigationAction()

{

    FUNC_LOG_ADDR(this);

    // Create navigation action if not already created

    if (!mNavKeyAction)

    {

        Hb::NavigationAction navAction = Hb::QuitNaviAction;

        QString objectName = LIST_WIDGET_OBJECT_NAME_NAV_KEY_QUIT;

        if(mCurrentLevel == VideoCollectionCommon::ELevelAlbum || 

           mCurrentLevel == VideoCollectionCommon::ELevelDefaultColl)

        {

            navAction = Hb::BackNaviAction; 

            objectName = LIST_WIDGET_OBJECT_NAME_NAV_KEY_BACK;

        }

        mNavKeyAction = new HbAction(navAction);

        mNavKeyAction->setObjectName(LIST_WIDGET_OBJECT_NAME_NAV_KEY_BACK);       

    }

    // Set navigation action only when widget is not in selection mode

    if (mSelectionMode == HbAbstractItemView::NoSelection)

    {

        HbView *currentView = hbInstance->allMainWindows().value(0)->currentView();

        if (currentView)

        {

            currentView->setNavigationAction(mNavKeyAction);

        }

    }

}

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

// deleteItemSlot

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

//

void VideoListWidget::deleteItemSlot()

{

	FUNC_LOG_ADDR(this);

    if(!mModel)

    {

        return;

    }

    QVariant variant;

    QModelIndex index = currentIndex();

    variant = mModel->data(index, VideoCollectionCommon::KeyTitle);

    if (variant.isValid())

    {

        QString text = HbParameterLengthLimiter(

                hbTrId("txt_videos_info_do_you_want_to_delete_1")).arg(variant.toString()); 

        HbMessageBox *messageBox = new HbMessageBox(text, HbMessageBox::MessageTypeQuestion);

        messageBox->setStandardButtons(HbMessageBox::Yes | HbMessageBox::No);

        messageBox->setAttribute(Qt::WA_DeleteOnClose);

        messageBox->setObjectName(LIST_WIDGET_OBJECT_NAME_DELETE_VIDEO);

        messageBox->open(this, SLOT(deleteItemDialogFinished(int)));

    }

}

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

// deleteItemDialogFinished

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

//

void VideoListWidget::deleteItemDialogFinished(int action)

{

    if(action == HbMessageBox::Yes)

    {

        QModelIndex index = currentIndex();

        if(index.isValid())

        {

            QModelIndexList list;

            list.append(index);

            mModel->deleteItems(list);

        }

    }

}

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

// createContextMenu

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

//

void VideoListWidget::createContextMenu()

{

	FUNC_LOG_ADDR(this);

    if(mContextMenu)

    {

        return;

    }

    mContextMenu = new HbMenu();

    mContextMenu->setDismissPolicy(HbPopup::TapAnywhere);

    mContextMenu->setObjectName(LIST_WIDGET_OBJECT_NAME_CONTEXT_MENU);

    if (mService == VideoServices::EUriFetcher)

    {

        mContextMenuActions[EActionAttach] = 

        mContextMenuActions[EActionAttach]->setObjectName(LIST_WIDGET_OBJECT_NAME_ACTION_ATTACH);

        mContextMenuActions[EActionOpen]   = 

                                    mContextMenu->addAction(hbTrId("txt_common_menu_open"), this, SLOT(openItemSlot()));

        mContextMenuActions[EActionOpen]->setObjectName(LIST_WIDGET_OBJECT_NAME_ACTION_OPEN);

        mContextMenuActions[EActionPlay]    = 

                mContextMenu->addAction(hbTrId("txt_videos_menu_play"), this, SLOT(playItemSlot()));

        mContextMenuActions[EActionPlay]->setObjectName(LIST_WIDGET_OBJECT_NAME_ACTION_PLAY);

        mContextMenuActions[EActionDetails] = 

                mContextMenu->addAction(hbTrId("txt_common_menu_details"), this, SLOT(openDetailsSlot()));

        mContextMenuActions[EActionDetails]->setObjectName(LIST_WIDGET_OBJECT_NAME_ACTION_DETAILS);

    }

    else if (mService == VideoServices::EBrowse)

    {

        mContextMenuActions[EActionPlay]    = 

                mContextMenu->addAction(hbTrId("txt_videos_menu_play"), this, SLOT(playItemSlot()));

        mContextMenuActions[EActionPlay]->setObjectName(LIST_WIDGET_OBJECT_NAME_ACTION_PLAY);

        mContextMenuActions[EActionDelete]           = 

                mContextMenu->addAction(hbTrId("txt_common_menu_delete"), this, SLOT(deleteItemSlot()));

        mContextMenuActions[EActionDelete]->setObjectName(LIST_WIDGET_OBJECT_NAME_ACTION_DELETE);

        mContextMenuActions[EActionDetails] = 

                mContextMenu->addAction(hbTrId("txt_common_menu_details"), this, SLOT(openDetailsSlot()));

        mContextMenuActions[EActionDetails]->setObjectName(LIST_WIDGET_OBJECT_NAME_ACTION_DETAILS);

    }

    else

    {

        mContextMenuActions[EActionPlay]    = 

                mContextMenu->addAction(hbTrId("txt_videos_menu_play"), this, SLOT(playItemSlot()));

        mContextMenuActions[EActionPlay]->setObjectName(LIST_WIDGET_OBJECT_NAME_ACTION_PLAY);

        mContextMenuActions[EActionOpen]    = 

                            mContextMenu->addAction(hbTrId("txt_common_menu_open"), this, SLOT(openItemSlot()));

        mContextMenuActions[EActionOpen]->setObjectName(LIST_WIDGET_OBJECT_NAME_ACTION_OPEN);

        mContextMenuActions[EActionAddToCollection] = 

                mContextMenu->addAction(hbTrId("txt_videos_menu_add_to_collection"), this, SLOT(addToCollectionSlot()));

        mContextMenuActions[EActionAddToCollection]->setObjectName(LIST_WIDGET_OBJECT_NAME_ACTION_ADD_TO);

        mContextMenuActions[EActionRemove]           = 

                mContextMenu->addAction(hbTrId("txt_videos_menu_remove_from_collection"), this, SLOT(removeFromCollectionSlot()));

        mContextMenuActions[EActionRemove]->setObjectName(LIST_WIDGET_OBJECT_NAME_ACTION_REMOVE_FROM);

        mContextMenuActions[EActionRename]           = 

                mContextMenu->addAction(hbTrId("txt_common_menu_rename_item"), this, SLOT(renameSlot()));

        mContextMenuActions[EActionRename]->setObjectName(LIST_WIDGET_OBJECT_NAME_ACTION_RENAME);

        mContextMenuActions[EActionRemoveCollection] = 

                mContextMenu->addAction(hbTrId("txt_videos_menu_remove_collection"), this, SLOT(removeCollectionSlot()));

        mContextMenuActions[EActionRemoveCollection]->setObjectName(LIST_WIDGET_OBJECT_NAME_ACTION_REMOVE_COLLECTION);

        mContextMenuActions[EActionDelete]           = 

                mContextMenu->addAction(hbTrId("txt_common_menu_delete"), this, SLOT(deleteItemSlot()));

        mContextMenuActions[EActionDelete]->setObjectName(LIST_WIDGET_OBJECT_NAME_ACTION_DELETE);

        mContextMenuActions[EActionDetails]          = 

                mContextMenu->addAction(hbTrId("txt_common_menu_details"), this, SLOT(openDetailsSlot()));

        mContextMenuActions[EActionDetails]->setObjectName(LIST_WIDGET_OBJECT_NAME_ACTION_DETAILS);

    }

}