/*

* 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 <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 <vcxmyvideosdefs.h>

#include "videocollectionviewutils.h"

#include "videocollectionuiloader.h"

#include "videolistselectiondialog.h"

#include "videoservices.h"

#include "videothumbnaildata.h"

#include "videosortfilterproxymodel.h"

#include "videocollectioncommon.h"

#include "mpxhbvideocommondefs.h"

// 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),

mIsService(false),

mNavKeyAction(0),

mContextMenu(0),

mSelectionMode(HbAbstractItemView::NoSelection),

mScrollPositionTimer(0),

mUiLoader(uiLoader)

{

	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;

}

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

// initialize

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

//

int VideoListWidget::initialize(VideoSortFilterProxyModel &model, VideoServices* videoServices)

{

	FUNC_LOG_ADDR(this);

    mModel = &model;

	mVideoServices = videoServices;

	if(mVideoServices)

	{

		mIsService = true;

	}

    // init list view

    VideoCollectionViewUtils::initListView(this);

	mScrollPositionTimer = new QTimer();

	mScrollPositionTimer->setSingleShot(true);

	if (mIsService)

	{

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

	}

	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)

    {

        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);

    thumbnailData.startBackgroundFetching(mModel, 0);

    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);

	int retval(0);

    if (!mSignalsConnected)

    {

        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(mScrollPositionTimer, SIGNAL(timeout()), this, SLOT(scrollPositionTimerSlot())) || 

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

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

        {

            return -1;

        }

        if (!isBrowsingService())

        {

	        if(VideoCollectionCommon::EModelTypeCollectionContent == mModel->getType())

	        {

	            if (!connect(mNavKeyAction, SIGNAL(triggered()), this, SLOT(back())))

				{

					retval = -1;

				}

	        }

	        else

	        {

	            if (!connect(mNavKeyAction, SIGNAL(triggered()), qApp, SLOT(quit())))

				{

					retval = -1;

				}

	        }

        }

        mSignalsConnected = true;

    }

	return retval;

}

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

// 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()));

    }

    // check that model and navigation action exists

    if (!isBrowsingService())

    {

	    if (mModel &&

	        mModel->getType() == VideoCollectionCommon::EModelTypeCollectionContent)

	    {

	        if (mNavKeyAction)

	        {

	            disconnect(

	                mNavKeyAction, SIGNAL(triggered()),

	                this, SLOT(back()));

	        }

	    }

	    else

	    {

	        if (mNavKeyAction)

	        {

	            disconnect(

	                mNavKeyAction, SIGNAL(triggered()),

	                qApp, SLOT(quit()));

	        }

	    }

    }

	mSignalsConnected = false;

}

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

// isBrowsingService

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

//

bool VideoListWidget::isBrowsingService() const

{

    FUNC_LOG_ADDR(this);

    bool isBrowsingService = false;

    if (mIsService &&

        mVideoServices &&

        mVideoServices->currentService() == VideoServices::EBrowse)

    {

        isBrowsingService = true;

    }

    return isBrowsingService;

}

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

// setNavigationAction

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

//

void VideoListWidget::setNavigationAction()

{

    FUNC_LOG_ADDR(this);

    // Create navigation action if not already created

    if (!mNavKeyAction)

    {

        if (isBrowsingService())

        {

            mNavKeyAction = new HbAction(Hb::QuitNaviAction);

        }

        else if (mModel)

        {

            if (VideoCollectionCommon::EModelTypeCollectionContent == mModel->getType())

            {

                mNavKeyAction = new HbAction(Hb::BackNaviAction);

            }

            else

            {

                mNavKeyAction = new HbAction(Hb::QuitNaviAction);

            }

        }

    }

    // 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 = hbTrId("txt_videos_info_do_you_want_to_delete_1").arg(

                variant.toString());

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

        messageBox->setAttribute(Qt::WA_DeleteOnClose);

        messageBox->open(this, SLOT(deleteItemDialogFinished(HbAction *)));

    }

}

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

// deleteItemDialogFinished

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

//

void VideoListWidget::deleteItemDialogFinished(HbAction *action)

{

    HbMessageBox *dlg = static_cast<HbMessageBox*>(sender());

    if(action == dlg->actions().at(0)) 

    {

        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();

    {