/*

* 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:  

*

*/

// Orbit classes

#include <hbinstance.h>

#include <hbmainwindow.h>

#include <hbwidget.h>

#include <hbdialog.h>

#include <hbmenu.h>

#include <hbaction.h>

#include <hblabel.h>

#include <hbicon.h>

#include <hbmessagebox.h>

#include <hbprogressdialog.h>

#include <hbpushbutton.h>

#include <hbabstractbutton.h>

#include <hbaction.h>

#include <hbframedrawer.h>

#include <hbtoolbar.h>

#include <hbview.h>

#include <hbdocumentloader.h>

#include <hbtransparentwindow.h>

#include <hbgesture.h>

#include <hbgesturefilter.h>

#include <hbeffect.h>

#include <hblineedit.h>

#include <QCoreApplication>

#include <QGesture>

#include <QWidget.h>

#include <hbtapgesture.h>

// Helper Class

#include "hbstub_helper.h"

// LC UI

#include "lcuidefs.h"

// Static data that simulates HbInstance and HbMainWindow

static HbInstance* hbInstanceSingleton = 0;

// Static data for hbeffects

bool HbEffect::mRunning;

// No Gesture default state.    

Qt::GestureState testState = Qt::NoGesture;

HbTapGesture::TapStyleHint testStyleHint = HbTapGesture::Tap;

// Title Bar and Status Bar Flags

bool titlebarVisible = true;

bool statusBarVisible = true;

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

// QCoreApplication::quit

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

// 

void QCoreApplication::quit()

{

}

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

// QCoreApplication::exit

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

//

void QCoreApplication::exit(int /*retcode*/)

{

}

// HbInstance

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

// HbInstance::instance

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

//

HbInstance* HbInstance::instance()

{

	if (!hbInstanceSingleton)

		hbInstanceSingleton = new HbInstance;

	return hbInstanceSingleton;

}

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

// HbInstance::allMainWindows

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

//

QList<HbMainWindow *> HbInstance::allMainWindows() const

{

    return mAllMainWindows;

}

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

// HbInstance::HbInstance

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

//

HbInstance::HbInstance()

{

    HbMainWindow *mainWindow = new HbMainWindow;

    mAllMainWindows.append(mainWindow);

    mScene = new QGraphicsScene;

}

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

// HbInstance::~HbInstance

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

//

HbInstance::~HbInstance()

{

    mAllMainWindows.clear();

    delete mScene;

}

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

// HbInstance::HbInstance

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

//

Qt::Orientation HbInstance::orientation() const

{

    return mOrientation;

}

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

// HbInstance::HbInstance

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

//

void HbInstance::setOrientation(Qt::Orientation orientation)

{

    mOrientation = orientation;

}

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

// HbInstance::HbInstance

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

//

QGraphicsScene* HbInstance::scene() const

{

    return mScene;

}

// HbMainWindow

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

// HbMainWindow::HbMainWindow

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

//

HbMainWindow::HbMainWindow(QWidget *parent,Hb::WindowFlags windowFlags)

: QGraphicsView(parent), mCurrentView(0), mViewCount(0)

{

    Q_UNUSED(windowFlags)

}

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

// HbMainWindow::~HbMainWindow

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

//

HbMainWindow::~HbMainWindow()

{

}

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

// HbMainWindow::addView

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

//

HbView* HbMainWindow::addView(QGraphicsWidget *widget)

{

    Q_UNUSED(widget)

    mTestViews.append(static_cast<HbView*>( widget ) );

    return 0;

}

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

// HbMainWindow::removeView

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

//

QGraphicsWidget* HbMainWindow::removeView(int index)

{

    Q_UNUSED(index)

    if ( index >= 0 && index < mTestViews.count() ){

        return mTestViews.takeAt(index);

    }

    return mCurrentView;

}

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

// HbMainWindow::removeView

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

//

void HbMainWindow::removeView(QGraphicsWidget *widget)

{

    for(int i = 0; i < mTestViews.count(); i++ ){

        if ( mTestViews.at(i) == widget ){

            mTestViews.takeAt(i);

        }

    }

}

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

// HbMainWindow::currentView

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

//

HbView* HbMainWindow::currentView() const

{

    return mCurrentView;

}

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

// HbMainWindow::setCurrentView

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

//

void HbMainWindow::setCurrentView(HbView *view, bool animate)

{

	mCurrentView = view;

    Q_UNUSED(animate)

}

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

// HbMainWindow::viewCount

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

//

int HbMainWindow::viewCount() const

{

    return mTestViews.count();

}

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

// HbMainWindow::viewCount

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

//

void HbMainWindow::setOrientation(Qt::Orientation orientation, bool animate)

{

    Q_UNUSED(animate);

    mOrientation = orientation;

}

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

// HbMainWindow::viewCount

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

//

Qt::Orientation HbMainWindow::orientation() const

{

    return mOrientation;

}

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

// HbMainWindow::views

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

//

QList<HbView *> HbMainWindow::views() const

{

    return mTestViews;

}

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

// HbMainWindow::sceneRect

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

//

QRectF HbMainWindow::sceneRect() const

{

    return QRectF( 0, 0, 360, 640 );

}

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

// HbMainWindow::windowSurface

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

//

QWindowSurface* HbMainWindow::windowSurface() const

{

    return mSurface;

}

// HbWidget

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

// HbWidget::HbWidget

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

//

HbWidget::HbWidget(QGraphicsItem *parent, Qt::WindowFlags wFlags)

: QGraphicsWidget(parent,wFlags)

{

}

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

// HbWidget::~HbWidget

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

//

HbWidget::~HbWidget()

{

}

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

// HbWidget::clearActions

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

//

void HbWidget::clearActions()

{

}

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

// HbWidget::itemChange

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

//

QVariant HbWidget::itemChange(GraphicsItemChange change, const QVariant& value)

{

    Q_UNUSED(change)

    return QVariant(value);

}

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

// HbWidget::mainWindow

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

//

HbMainWindow* HbWidget::mainWindow() const

{   

}

// HbDialog

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

// HbDialog::HbDialog

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

//

HbDialog::HbDialog(QGraphicsItem *parent) : HbWidget(parent)

{

	resize(10,10); // Just some values for height and width

    mDismissPolicy = NoDismiss;

    mUnfadedItems = Hb::NoItem;

}

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

// HbDialog::~HbDialog

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

//

HbDialog::~HbDialog()

{

}

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

// HbDialog::timeout

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

//

int HbDialog::timeout() const

{

    return mTimeout;

}

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

// HbDialog::setTimeout

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

//

void HbDialog::setTimeout(int timeout)

{

    mTimeout = timeout;

}

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

// HbDialog::setTimeout

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

//

void HbDialog::setTimeout(HbDialog::DefaultTimeout timeout)

{

    // Timeout Values from the current implementation of orbit.

    switch (timeout)

        {

        case HbDialog::NoTimeout:

        mTimeout = 0;

        break;

        case HbDialog::ConfirmationNoteTimeout:

        mTimeout = 1500;

        break;

        case HbDialog::StandardTimeout:

        mTimeout = 3000;

        break;

        case HbDialog::ContextMenuTimeout:

        mTimeout = 6000;

        break;

        }

}

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

// HbDialog::setHeadingWidget

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

//

void HbDialog::setHeadingWidget(QGraphicsWidget *headingWidget)

{

    Q_UNUSED(headingWidget)    

}

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

// HbDialog::setContentWidget

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

//

void HbDialog::setContentWidget(QGraphicsWidget *contentWidget)

{

    Q_UNUSED(contentWidget)    

}

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

// HbDialog::unfadedItems

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

//

Hb::SceneItems HbDialog::unfadedItems() const

{

    return mUnfadedItems;

}

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

// HbDialog::setUnfadedItems

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

//

void HbDialog::setUnfadedItems(Hb::SceneItems unfadedItems)

{

	mUnfadedItems = unfadedItems;

}

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

// HbDialog::dismissPolicy

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

//

HbDialog::DismissPolicy HbDialog::dismissPolicy() const

{

    return mDismissPolicy;

}

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

// HbDialog::setDismissPolicy

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

//

void HbDialog::setDismissPolicy(HbDialog::DismissPolicy dismissPolicy)

{

    mDismissPolicy = dismissPolicy;

}

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

// HbDialog::itemChange

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

//

QVariant HbDialog::itemChange(GraphicsItemChange change, const QVariant& value)

{

    Q_UNUSED(change)

    return QVariant(value);

}

// HbMenu

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

// HbMenu::HbMenu

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

//

HbMenu::HbMenu(QGraphicsItem *parent) : HbDialog(parent)

{

    mIsEmpty = true;

}

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

// HbMenu::~HbMenu

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

//

HbMenu::~HbMenu()

{

}

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

// HbMenu::open

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

//

void HbMenu::open(QObject* receiver, const char* member)

{

    Q_UNUSED(receiver);

    Q_UNUSED(member);

}

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

// HbMenu::addAction

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

//

HbAction* HbMenu::addAction(const QString &text)

{

    Q_UNUSED(text)

    mIsEmpty = false;

    return 0;

}

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

// HbMenu::isEmpty

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

//

bool HbMenu::isEmpty() const

{

	return mIsEmpty;

}

// HbAction

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

// HbAction::HbAction

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