/*

* Copyright (c) 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: Interface to HbDocumentLoader (DocML files).

*

*/

#include <QtCore>

#include <hbstyle.h>

#include <hbdocumentloader.h>

#include <hbframeitem.h>

#include "bubblewidgetmanager.h"

#include "bubblecontainerwidget.h"

#include "bubbleimagewidget.h"

#include "bubbleheadingwidget.h"

#include "bubbleexpandedhandler.h"

#include "bubblecollapsedhandler.h"

#include "bubbleconferencehandler.h"

#include "bubbleparticipantlistitem.h"

#include "bubblebutton.h"

#include "hbtextitem.h"

const char *BUBBLE_DOCUMENT_CONTENT = "content";

// document loader

class BubbleDocumentLoader : public HbDocumentLoader

{

public:

    BubbleDocumentLoader(BubbleImageManager& imageManager);

    virtual QObject *createObject(const QString& type,

                                  const QString &name);

private:

    BubbleImageManager& mImageManager;

};

BubbleWidgetManager::BubbleWidgetManager(

    BubbleImageManager& imageManager, QObject* parent)

    : QObject(parent), mImageManager(imageManager),

      mOrientation(Qt::Vertical)

{

    // .docml mappings

    mFileNames.insert(SingleCallView,

                      QLatin1String(":/xml/bubble_layout_1.docml"));

    mFileNames.insert(TwoCallsView,

                      QLatin1String(":/xml/bubble_layout_2.docml"));

    mFileNames.insert(ThreeCallsView,

                      QLatin1String(":/xml/bubble_layout_3.docml"));

    mFileNames.insert(ConferenceView,

                      QLatin1String(":/xml/bubble_layout_4.docml"));

    mFileNames.insert(MutedOverlay,

                      QLatin1String(":/xml/bubble_layout_5.docml"));

    mOrientationName.insert(Qt::Vertical, QLatin1String("portrait"));

    mOrientationName.insert(Qt::Horizontal, QLatin1String("landscape"));

    mWidgetPrefix.insert(ExpandedBubble, QLatin1String("eb:"));

    mWidgetPrefix.insert(CollapsedBubble, QLatin1String("cb:"));

    mWidgetPrefix.insert(CollapsedBubble2, QLatin1String("cb2:"));

    mContainerName.insert(ExpandedBubble, QLatin1String("expandedBubble"));

    mContainerName.insert(CollapsedBubble, QLatin1String("collapsedBubble"));

    mContainerName.insert(CollapsedBubble2, QLatin1String("collapsedBubble2"));

    mWidgetName.insert(Heading, QLatin1String("bubbleHeading"));

    mWidgetName.insert(Image, QLatin1String("callImage"));

    mWidgetName.insert(LeftButton, QLatin1String("leftButton"));

    mWidgetName.insert(CenterButton, QLatin1String("centerButton"));

    mWidgetName.insert(RightButton, QLatin1String("rightButton"));

    mWidgetName.insert(ParticipantList, QLatin1String("participantList"));

    mWidgetName.insert(MutedIcon, QLatin1String("mutedIcon"));

}

BubbleWidgetManager::~BubbleWidgetManager()

{

    qDeleteAll(mDocumentLoaders);

    mDocumentLoaders.clear();

    QList<int> keys = mDocumentHandlers.keys();

    foreach (int key, keys) {

        qDeleteAll(*mDocumentHandlers[key]);

    }

    qDeleteAll(mDocumentHandlers);

    mDocumentHandlers.clear();

}

QGraphicsWidget* BubbleWidgetManager::view(View view)

{

    if (mDocumentContent.contains(view)) {

        // already loaded

        return mDocumentContent[view];

    } else {

        // load from .docml

        return loadDocument(view,mOrientation);

    }

}

bool BubbleWidgetManager::isLoaded(View view)

{

    if (mDocumentContent.contains(view)) {

        return true;

    } else {

        return false;

    }

}

void BubbleWidgetManager::releaseView(View view)

{

    Q_UNUSED(view)

    // release loaders

    BubbleDocumentLoader* loader = mDocumentLoaders.value(view,0);

    delete loader;

    mDocumentLoaders.remove(view);

    // release handler

    QList<BubbleHandler*>* handlers = mDocumentHandlers.value(view,0);

    if (handlers) {

        qDeleteAll(*handlers);

        delete handlers;

        mDocumentHandlers.remove(view);

    }

    // release document objects

    QObjectList objectList = mDocumentObjects.value(view);

    foreach(QObject* object, objectList) {

        QMetaObject::invokeMethod(object, "deleteLater", Qt::QueuedConnection);

    }

    mDocumentObjects.remove(view);

    mDocumentContent.remove(view);

}

QGraphicsWidget* BubbleWidgetManager::loadDocument(

    View view,

    Qt::Orientation orientation)

{

    BubbleDocumentLoader* loader =

        new BubbleDocumentLoader(mImageManager);

    bool ok;

    QObjectList objectList = loader->load(mFileNames[view],&ok);

    Q_ASSERT(ok);

    loader->load(mFileNames[view],mOrientationName[orientation],&ok);

    Q_ASSERT(ok);

    mDocumentLoaders.insert(view,loader);

    mDocumentObjects.insert(view,objectList);

    QGraphicsWidget* widget =

        mDocumentLoaders[view]->findWidget(BUBBLE_DOCUMENT_CONTENT);

    Q_ASSERT(widget);

    widget->setVisible(false);

    mDocumentContent.insert(view,widget);

    if (view!=MutedOverlay) {

        createDocumentHandlers(view);

    }

    applyCustomStyles(view);

    return widget;

}

void BubbleWidgetManager::applyCustomStyles(View view)

{

    setBackground(widget(view,None,MutedIcon));

}

void BubbleWidgetManager::setBackground(QGraphicsWidget* widget)

{

    HbWidget* w;

    w = qobject_cast<HbWidget*>(widget);

    if (w) {

        HbFrameItem* item =

            new HbFrameItem(QLatin1String("qtg_fr_popup_trans"),

                            HbFrameDrawer::NinePieces);

        w->setBackgroundItem(item); // takes ownership

    }

}

void BubbleWidgetManager::createDocumentHandlers(View view)

{

    Q_ASSERT(mDocumentLoaders.contains(view));

    QList<BubbleHandler*>* handlers = new QList<BubbleHandler*>;

    if (mDocumentLoaders[view]->findWidget(mContainerName[ExpandedBubble]) ) {

        if (view==ConferenceView) {

            BubbleConferenceHandler* handler =

                new BubbleConferenceHandler(*this,view,ExpandedBubble);

            handlers->append(handler);

        } else {

            BubbleExpandedHandler* handler =

                new BubbleExpandedHandler(*this,view,ExpandedBubble);

            handlers->append(handler);

        }

    }

    if (mDocumentLoaders[view]->findWidget(mContainerName[CollapsedBubble]) ) {

        BubbleCollapsedHandler* handler =

            new BubbleCollapsedHandler(*this,view,CollapsedBubble);

        handlers->append(handler);

    }

    if (mDocumentLoaders[view]->findWidget(mContainerName[CollapsedBubble2]) ) {

        BubbleCollapsedHandler* handler =

            new BubbleCollapsedHandler(*this,view,CollapsedBubble2);

        handlers->append(handler);

    }

    mDocumentHandlers.insert(view,handlers);

}

QGraphicsWidget* BubbleWidgetManager::container(

    View view,

    Container container) const

{

    QGraphicsWidget* w=0;

    if (mDocumentLoaders.contains(view)) {

        w = mDocumentLoaders.value(view)->findWidget(

            mContainerName[container]);

    }

    return w;

}

QGraphicsWidget* BubbleWidgetManager::widget(

    View view,

    Container container,

    Widget widget ) const

{

    QGraphicsWidget* w=0;

    if (mDocumentLoaders.contains(view)) {

        QString name;

        name.append(mWidgetPrefix.value(container));

        name.append(mWidgetName.value(widget));

        w = mDocumentLoaders.value(view)->findWidget(name);

    }

    return w;

}

QList<BubbleHandler*>* BubbleWidgetManager::handlers(

    QGraphicsWidget* widget) const

{

    int doc = mDocumentContent.key(widget);

    return mDocumentHandlers[doc];

}

void BubbleWidgetManager::handleOrientationChange(

    Qt::Orientation orientation)

{

    if (mOrientation!=orientation) {

        bool ok;

        QList<int> docs = mDocumentLoaders.keys();

        foreach (int doc, docs) {

            mDocumentLoaders[doc]->load(

                mFileNames[doc],mOrientationName.value(orientation),&ok);

            Q_ASSERT(ok);

        }

        mOrientation = orientation;

    }

}

QGraphicsWidget* BubbleWidgetManager::createParticipantListItem()

{

    return new BubbleParticipantListItem();

}

// custom widget loading

BubbleDocumentLoader::BubbleDocumentLoader(BubbleImageManager& imageManager)

    : mImageManager(imageManager)

{

}

QObject *BubbleDocumentLoader::createObject(

    const QString& type,

    const QString &name)

{

    if ( type == BubbleContainerWidget::staticMetaObject.className() ) {

        QObject *object = new BubbleContainerWidget();

        object->setObjectName(name);

        return object;

    }

    if ( type == BubbleImageWidget::staticMetaObject.className() ) {

        QObject *object = new BubbleImageWidget(mImageManager);

        object->setObjectName(name);

        return object;

    }

    if ( type == BubbleHeadingWidget::staticMetaObject.className() ) {

        QObject *object = new BubbleHeadingWidget();

        object->setObjectName(name);

        return object;

    }

    if ( type == BubbleButton::staticMetaObject.className() ) {

        QObject *object = new BubbleButton;

        object->setObjectName(name);

        return object;

    }

    return HbDocumentLoader::createObject(type, name);

}