phoneplugins/infowidgetplugin/infowidgetprovider/tsrc/mocks/mock_hbwidget.cpp
changeset 22 6bb1b21d2484
equal deleted inserted replaced
21:92ab7f8d0eab 22:6bb1b21d2484
       
     1 /* 
       
     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description:
       
    15 *
       
    16 */
       
    17 #include <QDebug>
       
    18 #include <smcmockclassincludes.h>
       
    19 #include <hbwidget.h>
       
    20 
       
    21 // ============================ MEMBER FUNCTIONS ===============================
       
    22 
       
    23 // -----------------------------------------------------------------------------
       
    24 // HbWidget::HbWidget
       
    25 // -----------------------------------------------------------------------------
       
    26 //
       
    27 HbWidget::HbWidget( 
       
    28         QGraphicsItem * ,
       
    29         Qt::WindowFlags  )
       
    30     //:
       
    31     //HbWidgetBase( /*parent, wFlags*/ )
       
    32     {
       
    33     
       
    34     }
       
    35 
       
    36 
       
    37 // -----------------------------------------------------------------------------
       
    38 // HbWidget::~HbWidget
       
    39 // -----------------------------------------------------------------------------
       
    40 //
       
    41 HbWidget::~HbWidget(  )
       
    42     {
       
    43     
       
    44     }
       
    45 
       
    46 
       
    47 // -----------------------------------------------------------------------------
       
    48 // HbWidget::event
       
    49 // -----------------------------------------------------------------------------
       
    50 //
       
    51 bool HbWidget::event( 
       
    52         QEvent *  )
       
    53     {
       
    54     }
       
    55 
       
    56 
       
    57 // -----------------------------------------------------------------------------
       
    58 // HbWidget::setStyle
       
    59 // -----------------------------------------------------------------------------
       
    60 //
       
    61 void HbWidget::setStyle( 
       
    62         HbStyle *  )
       
    63     {
       
    64     }
       
    65 
       
    66 
       
    67 // -----------------------------------------------------------------------------
       
    68 // HbWidget::style
       
    69 // -----------------------------------------------------------------------------
       
    70 //
       
    71 HbStyle * HbWidget::style(  ) const
       
    72     {
       
    73     }
       
    74 
       
    75 
       
    76 // -----------------------------------------------------------------------------
       
    77 // HbWidget::clearActions
       
    78 // -----------------------------------------------------------------------------
       
    79 //
       
    80 void HbWidget::clearActions(  )
       
    81     {
       
    82     SMC_MOCK_METHOD0( void )
       
    83     }
       
    84 
       
    85 
       
    86 
       
    87 // -----------------------------------------------------------------------------
       
    88 // HbWidget::pluginBaseId
       
    89 // -----------------------------------------------------------------------------
       
    90 //
       
    91 int HbWidget::pluginBaseId(  ) const
       
    92     {
       
    93     SMC_MOCK_METHOD0( int )
       
    94     }
       
    95 
       
    96 
       
    97 // -----------------------------------------------------------------------------
       
    98 // HbWidget::mainWindow
       
    99 // -----------------------------------------------------------------------------
       
   100 //
       
   101 HbMainWindow * HbWidget::mainWindow(  ) const
       
   102     {
       
   103    // SMC_MOCK_METHOD0( HbMainWindow * )
       
   104     }
       
   105 
       
   106 
       
   107 // -----------------------------------------------------------------------------
       
   108 // HbWidget::primitive
       
   109 // -----------------------------------------------------------------------------
       
   110 //
       
   111 QGraphicsItem * HbWidget::primitive( 
       
   112         HbStyle::Primitive  ) const
       
   113     {
       
   114   //  SMC_MOCK_METHOD1( QGraphicsItem *, HbStyle::Primitive, primitive )
       
   115     }
       
   116 
       
   117 
       
   118 // -----------------------------------------------------------------------------
       
   119 // HbWidget::setFocusOrientation
       
   120 // -----------------------------------------------------------------------------
       
   121 //
       
   122 void HbWidget::setFocusOrientation( 
       
   123         Qt::Orientations ,
       
   124         Qt::Orientations  )
       
   125     {
       
   126    // SMC_MOCK_METHOD2( void, Qt::Orientations, previous, 
       
   127      //   Qt::Orientations, next )
       
   128     }
       
   129 
       
   130 
       
   131 // -----------------------------------------------------------------------------
       
   132 // HbWidget::keyForFocusNextChild
       
   133 // -----------------------------------------------------------------------------
       
   134 //
       
   135 QKeySequence HbWidget::keyForFocusNextChild(  ) const
       
   136     {
       
   137    // SMC_MOCK_METHOD0( QKeySequence )
       
   138     }
       
   139 
       
   140 
       
   141 // -----------------------------------------------------------------------------
       
   142 // HbWidget::keyForFocusPreviousChild
       
   143 // -----------------------------------------------------------------------------
       
   144 //
       
   145 QKeySequence HbWidget::keyForFocusPreviousChild(  ) const
       
   146     {
       
   147   //  SMC_MOCK_METHOD0( QKeySequence )
       
   148     }
       
   149 
       
   150 
       
   151 // -----------------------------------------------------------------------------
       
   152 // HbWidget::setKeyFocusMode
       
   153 // -----------------------------------------------------------------------------
       
   154 //
       
   155 void HbWidget::setKeyFocusMode( 
       
   156         const QKeySequence &  )
       
   157     {
       
   158 //    SMC_MOCK_METHOD1( void, const QKeySequence &, key )
       
   159     }
       
   160 
       
   161 
       
   162 // -----------------------------------------------------------------------------
       
   163 // HbWidget::keyFocusMode
       
   164 // -----------------------------------------------------------------------------
       
   165 //
       
   166 QKeySequence HbWidget::keyFocusMode(  ) const
       
   167     {
       
   168 //    SMC_MOCK_METHOD0( QKeySequence )
       
   169     }
       
   170 
       
   171 
       
   172 // -----------------------------------------------------------------------------
       
   173 // HbWidget::lastFocusedChild
       
   174 // -----------------------------------------------------------------------------
       
   175 //
       
   176 QGraphicsItem * HbWidget::lastFocusedChild(  ) const
       
   177     {
       
   178  //   SMC_MOCK_METHOD0( QGraphicsItem * )
       
   179     }
       
   180 
       
   181 
       
   182 // -----------------------------------------------------------------------------
       
   183 // HbWidget::setFocusOrder
       
   184 // -----------------------------------------------------------------------------
       
   185 //
       
   186 void HbWidget::setFocusOrder( 
       
   187         QGraphicsItem * ,
       
   188         QGraphicsItem *  )
       
   189     {
       
   190    // SMC_MOCK_METHOD2( void, QGraphicsItem *, first, 
       
   191      //   QGraphicsItem *, second )
       
   192     }
       
   193 
       
   194 
       
   195 // -----------------------------------------------------------------------------
       
   196 // HbWidget::setFocusDelegation
       
   197 // -----------------------------------------------------------------------------
       
   198 //
       
   199 void HbWidget::setFocusDelegation( 
       
   200         HbWidget::FocusDelegation  )
       
   201     {
       
   202  //   SMC_MOCK_METHOD1( void, HbWidget::FocusDelegation, focusDelegation )
       
   203     }
       
   204 
       
   205 
       
   206 // -----------------------------------------------------------------------------
       
   207 // HbWidget::focusDelegation
       
   208 // -----------------------------------------------------------------------------
       
   209 //
       
   210 HbWidget::FocusDelegation HbWidget::focusDelegation(  ) const
       
   211     {
       
   212   //  SMC_MOCK_METHOD0( HbWidget::FocusDelegation )
       
   213     }
       
   214 
       
   215 
       
   216 // -----------------------------------------------------------------------------
       
   217 // HbWidget::setFocusLooping
       
   218 // -----------------------------------------------------------------------------
       
   219 //
       
   220 void HbWidget::setFocusLooping( 
       
   221         bool enable )
       
   222     {
       
   223     SMC_MOCK_METHOD1( void, bool, enable )
       
   224     }
       
   225 
       
   226 
       
   227 // -----------------------------------------------------------------------------
       
   228 // HbWidget::hasFocusLooping
       
   229 // -----------------------------------------------------------------------------
       
   230 //
       
   231 bool HbWidget::hasFocusLooping(  ) const
       
   232     {
       
   233     SMC_MOCK_METHOD0( bool )
       
   234     }
       
   235 
       
   236 
       
   237 // -----------------------------------------------------------------------------
       
   238 // HbWidget::setFocusMode
       
   239 // -----------------------------------------------------------------------------
       
   240 //
       
   241 void HbWidget::setFocusMode( 
       
   242         HbWidget::FocusMode )
       
   243     {
       
   244    // SMC_MOCK_METHOD1( void, HbWidget::, FocusMode )
       
   245     }
       
   246 
       
   247 
       
   248 // -----------------------------------------------------------------------------
       
   249 // HbWidget::focusMode
       
   250 // -----------------------------------------------------------------------------
       
   251 //
       
   252 HbWidget::FocusMode HbWidget::focusMode(  ) const
       
   253     {
       
   254   //  SMC_MOCK_METHOD0( HbWidget::FocusMode )
       
   255     }
       
   256 
       
   257 
       
   258 // -----------------------------------------------------------------------------
       
   259 // HbWidget::setFocusHighlight
       
   260 // -----------------------------------------------------------------------------
       
   261 //
       
   262 void HbWidget::setFocusHighlight( 
       
   263         HbStyle::Primitive ,
       
   264         HbWidget::FocusHighlight  )
       
   265     {
       
   266   //  SMC_MOCK_METHOD2( void, HbStyle::Primitive, type, 
       
   267     //    HbWidget::FocusHighlight, focusHighlight )
       
   268     }
       
   269 
       
   270 
       
   271 // -----------------------------------------------------------------------------
       
   272 // HbWidget::focusHighlight
       
   273 // -----------------------------------------------------------------------------
       
   274 //
       
   275 HbStyle::Primitive HbWidget::focusHighlight( 
       
   276         HbWidget::FocusHighlight  )
       
   277     {
       
   278  //   SMC_MOCK_METHOD1( HbStyle::Primitive, HbWidget::FocusHighlight, focusHighlight )
       
   279     }
       
   280 
       
   281 
       
   282 // -----------------------------------------------------------------------------
       
   283 // HbWidget::setBackgroundItem
       
   284 // -----------------------------------------------------------------------------
       
   285 //
       
   286 void HbWidget::setBackgroundItem( 
       
   287         HbStyle::Primitive ,
       
   288         int  )
       
   289     {
       
   290   //  SMC_MOCK_METHOD2( void, HbStyle::Primitive, type, 
       
   291     //    int, zValue )
       
   292     }
       
   293 
       
   294 
       
   295 // -----------------------------------------------------------------------------
       
   296 // HbWidget::setBackgroundItem
       
   297 // -----------------------------------------------------------------------------
       
   298 //
       
   299 void HbWidget::setBackgroundItem( 
       
   300         QGraphicsItem * ,
       
   301         int  )
       
   302     {
       
   303    // SMC_MOCK_METHOD2( void, QGraphicsItem *, item, 
       
   304      //   int, zValue )
       
   305     }
       
   306 
       
   307 
       
   308 // -----------------------------------------------------------------------------
       
   309 // HbWidget::backgroundItem
       
   310 // -----------------------------------------------------------------------------
       
   311 //
       
   312 QGraphicsItem * HbWidget::backgroundItem(  ) const
       
   313     {
       
   314    // SMC_MOCK_METHOD0( QGraphicsItem * )
       
   315     }
       
   316 
       
   317 
       
   318 // -----------------------------------------------------------------------------
       
   319 // HbWidget::overrideFeedback
       
   320 // -----------------------------------------------------------------------------
       
   321 //
       
   322 HbFeedback::InstantEffect HbWidget::overrideFeedback( 
       
   323         Hb::InstantInteraction  ) const
       
   324     {
       
   325   //  SMC_MOCK_METHOD1( HbFeedback::InstantEffect, Hb::InstantInteraction, interaction )
       
   326     }
       
   327 
       
   328 
       
   329 // -----------------------------------------------------------------------------
       
   330 // HbWidget::overrideContinuousFeedback
       
   331 // -----------------------------------------------------------------------------
       
   332 //
       
   333 HbFeedback::ContinuousEffect HbWidget::overrideContinuousFeedback( 
       
   334         Hb::ContinuousInteraction ,
       
   335         int *  ) const
       
   336     {
       
   337   //  SMC_MOCK_METHOD2( HbFeedback::ContinuousEffect, Hb::ContinuousInteraction, interaction, 
       
   338     //    int *, intensity )
       
   339     }
       
   340 
       
   341 
       
   342 // -----------------------------------------------------------------------------
       
   343 // HbWidget::recreatePrimitives
       
   344 // -----------------------------------------------------------------------------
       
   345 //
       
   346 void HbWidget::recreatePrimitives(  )
       
   347     {
       
   348     SMC_MOCK_METHOD0( void )
       
   349     }
       
   350 
       
   351 
       
   352 // -----------------------------------------------------------------------------
       
   353 // HbWidget::updatePrimitives
       
   354 // -----------------------------------------------------------------------------
       
   355 //
       
   356 void HbWidget::updatePrimitives(  )
       
   357     {
       
   358     SMC_MOCK_METHOD0( void )
       
   359     }
       
   360 
       
   361 
       
   362 // -----------------------------------------------------------------------------
       
   363 // HbWidget::focusInEvent
       
   364 // -----------------------------------------------------------------------------
       
   365 //
       
   366 void HbWidget::focusInEvent( 
       
   367         QFocusEvent *  )
       
   368     {
       
   369  //   SMC_MOCK_METHOD1( void, QFocusEvent *, event )
       
   370     }
       
   371 
       
   372 
       
   373 // -----------------------------------------------------------------------------
       
   374 // HbWidget::focusOutEvent
       
   375 // -----------------------------------------------------------------------------
       
   376 //
       
   377 void HbWidget::focusOutEvent( 
       
   378         QFocusEvent *  )
       
   379     {
       
   380   //  SMC_MOCK_METHOD1( void, QFocusEvent *, event )
       
   381     }
       
   382 
       
   383 
       
   384 // -----------------------------------------------------------------------------
       
   385 // HbWidget::resizeEvent
       
   386 // -----------------------------------------------------------------------------
       
   387 //
       
   388 void HbWidget::resizeEvent( 
       
   389         QGraphicsSceneResizeEvent *  )
       
   390     {
       
   391   //  SMC_MOCK_METHOD1( void, QGraphicsSceneResizeEvent *, event )
       
   392     }
       
   393 
       
   394 // -----------------------------------------------------------------------------
       
   395 // HbWidget::changeEvent
       
   396 // -----------------------------------------------------------------------------
       
   397 //
       
   398 void HbWidget::changeEvent( 
       
   399         QEvent * event )
       
   400     {
       
   401     SMC_MOCK_METHOD1( void, QEvent *, event )
       
   402     }
       
   403 
       
   404 
       
   405 // -----------------------------------------------------------------------------
       
   406 // HbWidget::itemChange
       
   407 // -----------------------------------------------------------------------------
       
   408 //
       
   409 QVariant HbWidget::itemChange( 
       
   410         GraphicsItemChange ,
       
   411         const QVariant &  )
       
   412     {
       
   413  //   SMC_MOCK_METHOD2( QVariant, GraphicsItemChange, change, 
       
   414    //     const QVariant &, value )
       
   415     }
       
   416 
       
   417 
       
   418 // -----------------------------------------------------------------------------
       
   419 // HbWidget::polishEvent
       
   420 // -----------------------------------------------------------------------------
       
   421 //
       
   422 void HbWidget::polishEvent(  )
       
   423     {
       
   424     SMC_MOCK_METHOD0( void )
       
   425     }
       
   426 
       
   427 
       
   428 // -----------------------------------------------------------------------------
       
   429 // HbWidget::polish
       
   430 // -----------------------------------------------------------------------------
       
   431 //
       
   432 void HbWidget::polish( 
       
   433         HbStyleParameters &  )
       
   434     {
       
   435  //   SMC_MOCK_METHOD1( void, HbStyleParameters &, params )
       
   436     }
       
   437 
       
   438 
       
   439 // -----------------------------------------------------------------------------
       
   440 // HbWidget::repolish
       
   441 // -----------------------------------------------------------------------------
       
   442 //
       
   443 void HbWidget::repolish(  )
       
   444     {
       
   445     SMC_MOCK_METHOD0( void )
       
   446     }
       
   447 
       
   448 
       
   449 // -----------------------------------------------------------------------------
       
   450 // HbWidget::setPluginBaseId
       
   451 // -----------------------------------------------------------------------------
       
   452 //
       
   453 void HbWidget::setPluginBaseId( 
       
   454         int baseId )
       
   455     {
       
   456     SMC_MOCK_METHOD1( void, int, baseId )
       
   457     }
       
   458 
       
   459 
       
   460 // -----------------------------------------------------------------------------
       
   461 // HbWidget::gestureEvent
       
   462 // -----------------------------------------------------------------------------
       
   463 //
       
   464 void HbWidget::gestureEvent( 
       
   465         QGestureEvent *  )
       
   466     {
       
   467   //  SMC_MOCK_METHOD1( void, QGestureEvent *, event )
       
   468     }
       
   469 
       
   470 
       
   471 // -----------------------------------------------------------------------------
       
   472 // HbWidget::HbWidget
       
   473 // -----------------------------------------------------------------------------
       
   474 //
       
   475 HbWidget::HbWidget( 
       
   476         HbWidgetPrivate & ,
       
   477         QGraphicsItem * ,
       
   478         Qt::WindowFlags  )
       
   479     //:
       
   480     //HbWidgetBase( /*dd, parent, wFlags*/ )
       
   481     {
       
   482     
       
   483     }
       
   484 
       
   485