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