/** 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 the License "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:
*
*/
#include <smcmockclassincludes.h>
#include <QShowEvent>
#include <QGraphicsWidget>
#include <HbView>
#include "hbmainwindow.h"

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// HbMainWindow::HbMainWindow
// -----------------------------------------------------------------------------
//
HbMainWindow::HbMainWindow( 
        QWidget * parent,
        Hb::WindowFlags windowFlags ) : QGraphicsView(parent),  d_ptr(0)
    {
    
    }


// -----------------------------------------------------------------------------
// HbMainWindow::~HbMainWindow
// -----------------------------------------------------------------------------
//
HbMainWindow::~HbMainWindow(  )
    {
    
    }


// -----------------------------------------------------------------------------
// HbMainWindow::addView
// -----------------------------------------------------------------------------
//
HbView * HbMainWindow::addView( 
        QGraphicsWidget * widget )
    {
    SMC_MOCK_METHOD1( HbView *, QGraphicsWidget *, widget )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::insertView
// -----------------------------------------------------------------------------
//
HbView * HbMainWindow::insertView( 
        int index,
        QGraphicsWidget * widget )
    {
    SMC_MOCK_METHOD2( HbView *, int, index, 
        QGraphicsWidget *, widget )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::removeView
// -----------------------------------------------------------------------------
//
void HbMainWindow::removeView( 
        QGraphicsWidget * widget )
    {
    SMC_MOCK_METHOD1( void, QGraphicsWidget *, widget )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::views
// -----------------------------------------------------------------------------
//
QList <HbView * > HbMainWindow::views(  ) const
    {
    SMC_MOCK_METHOD0( QList <HbView * > )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::currentView
// -----------------------------------------------------------------------------
//
HbView * HbMainWindow::currentView(  ) const
    {
    SMC_MOCK_METHOD0( HbView * )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::setCurrentView
// -----------------------------------------------------------------------------
//
void HbMainWindow::setCurrentView( 
        HbView * view,
        bool animate,
        Hb::ViewSwitchFlags flags )
    {
    SMC_MOCK_METHOD3( void, HbView *, view, 
        bool, animate, 
        /*Hb::ViewSwitchFlags*/int, flags )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::orientation
// -----------------------------------------------------------------------------
//
Qt::Orientation HbMainWindow::orientation(  ) const
    {
    SMC_MOCK_METHOD0( Qt::Orientation )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::setOrientation
// -----------------------------------------------------------------------------
//
void HbMainWindow::setOrientation( 
        Qt::Orientation orientation,
        bool animate )
    {
    SMC_MOCK_METHOD2( void, Qt::Orientation, orientation, 
        bool, animate )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::unsetOrientation
// -----------------------------------------------------------------------------
//
void HbMainWindow::unsetOrientation( 
        bool animate )
    {
    SMC_MOCK_METHOD1( void, bool, animate )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::nativeBackgroundWindow
// -----------------------------------------------------------------------------
//
WId HbMainWindow::nativeBackgroundWindow(  )
    {
    SMC_MOCK_METHOD0( WId )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::resetNativeBackgroundWindow
// -----------------------------------------------------------------------------
//
void HbMainWindow::resetNativeBackgroundWindow(  )
    {
    SMC_MOCK_METHOD0( void )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::layoutRect
// -----------------------------------------------------------------------------
//
QRectF HbMainWindow::layoutRect(  ) const
    {
    SMC_MOCK_METHOD0( QRectF )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::setBackgroundImageName
// -----------------------------------------------------------------------------
//
void HbMainWindow::setBackgroundImageName( 
        Qt::Orientation orientation,
        const QString & name )
    {
    SMC_MOCK_METHOD2( void, Qt::Orientation, orientation, 
        const QString &, name )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::backgroundImageName
// -----------------------------------------------------------------------------
//
QString HbMainWindow::backgroundImageName( 
        Qt::Orientation orientation ) const
    {
    SMC_MOCK_METHOD1( QString, Qt::Orientation, orientation )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::setBackgroundImageMode
// -----------------------------------------------------------------------------
//
void HbMainWindow::setBackgroundImageMode( 
        Hb::BackgroundImageMode mode )
    {
    SMC_MOCK_METHOD1( void, Hb::BackgroundImageMode, mode )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::backgroundImageMode
// -----------------------------------------------------------------------------
//
Hb::BackgroundImageMode HbMainWindow::backgroundImageMode(  ) const
    {
    SMC_MOCK_METHOD0( Hb::BackgroundImageMode )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::setAutomaticOrientationEffectEnabled
// -----------------------------------------------------------------------------
//
void HbMainWindow::setAutomaticOrientationEffectEnabled( 
        bool enabled )
    {
    SMC_MOCK_METHOD1( void, bool, enabled )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::automaticOrientationEffectEnabled
// -----------------------------------------------------------------------------
//
bool HbMainWindow::automaticOrientationEffectEnabled(  ) const
    {
    SMC_MOCK_METHOD0( bool )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::isObscured
// -----------------------------------------------------------------------------
//
bool HbMainWindow::isObscured(  ) const
    {
    SMC_MOCK_METHOD0( bool )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::broadcastEvent
// -----------------------------------------------------------------------------
//
void HbMainWindow::broadcastEvent( 
        int eventType )
    {
    SMC_MOCK_METHOD1( void, int, eventType )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::viewReady
// -----------------------------------------------------------------------------
//
void HbMainWindow::viewReady(  )
    {
    SMC_MOCK_METHOD0( void )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::aboutToChangeView
// -----------------------------------------------------------------------------
//
void HbMainWindow::aboutToChangeView( 
        HbView * oldView,
        HbView * newView )
    {
    SMC_MOCK_METHOD2( void, HbView *, oldView, 
        HbView *, newView )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::currentViewChanged
// -----------------------------------------------------------------------------
//
void HbMainWindow::currentViewChanged( 
        HbView * view )
    {
    SMC_MOCK_METHOD1( void, HbView *, view )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::aboutToChangeOrientation
// -----------------------------------------------------------------------------
//
void HbMainWindow::aboutToChangeOrientation(  )
    {
    SMC_MOCK_METHOD0( void )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::aboutToChangeOrientation
// -----------------------------------------------------------------------------
//
void HbMainWindow::aboutToChangeOrientation( 
        Qt::Orientation newOrientation,
        bool animated )
    {
    SMC_MOCK_METHOD2( void, Qt::Orientation, newOrientation, 
        bool, animated )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::orientationChanged
// -----------------------------------------------------------------------------
//
void HbMainWindow::orientationChanged( 
        Qt::Orientation orientation )
    {
    SMC_MOCK_METHOD1( void, Qt::Orientation, orientation )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::obscured
// -----------------------------------------------------------------------------
//
void HbMainWindow::obscured(  )
    {
    SMC_MOCK_METHOD0( void )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::revealed
// -----------------------------------------------------------------------------
//
void HbMainWindow::revealed(  )
    {
    SMC_MOCK_METHOD0( void )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::changeEvent
// -----------------------------------------------------------------------------
//
void HbMainWindow::changeEvent( 
        QEvent * event )
    {
    SMC_MOCK_METHOD1( void, QEvent *, event )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::closeEvent
// -----------------------------------------------------------------------------
//
void HbMainWindow::closeEvent( 
        QCloseEvent * event )
    {
    SMC_MOCK_METHOD1( void, QCloseEvent *, event )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::drawBackground
// -----------------------------------------------------------------------------
//
void HbMainWindow::drawBackground( 
        QPainter * painter,
        const QRectF & rect )
    {
    SMC_MOCK_METHOD2( void, QPainter *, painter, 
        const QRectF &, rect )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::keyPressEvent
// -----------------------------------------------------------------------------
//
void HbMainWindow::keyPressEvent( 
        QKeyEvent * event )
    {
    SMC_MOCK_METHOD1( void, QKeyEvent *, event )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::keyReleaseEvent
// -----------------------------------------------------------------------------
//
void HbMainWindow::keyReleaseEvent( 
        QKeyEvent * event )
    {
    SMC_MOCK_METHOD1( void, QKeyEvent *, event )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::resizeEvent
// -----------------------------------------------------------------------------
//
void HbMainWindow::resizeEvent( 
        QResizeEvent * event )
    {
    SMC_MOCK_METHOD1( void, QResizeEvent *, event )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::customEvent
// -----------------------------------------------------------------------------
//
void HbMainWindow::customEvent( 
        QEvent * event )
    {
    SMC_MOCK_METHOD1( void, QEvent *, event )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::scrollContentsBy
// -----------------------------------------------------------------------------
//
void HbMainWindow::scrollContentsBy( 
        int dx,
        int dy )
    {
    SMC_MOCK_METHOD2( void, int, dx, 
        int, dy )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::paintEvent
// -----------------------------------------------------------------------------
//
void HbMainWindow::paintEvent( 
        QPaintEvent * event )
    {
    SMC_MOCK_METHOD1( void, QPaintEvent *, event )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::showEvent
// -----------------------------------------------------------------------------
//
void HbMainWindow::showEvent( 
        QShowEvent * event )
    {
    SMC_MOCK_METHOD1( void, QShowEvent *, event )
    }


// -----------------------------------------------------------------------------
// HbMainWindow::event
// -----------------------------------------------------------------------------
//
bool HbMainWindow::event( 
        QEvent * event )
    {
    SMC_MOCK_METHOD1( bool, QEvent *, event )
    }