Mercurial Mercurial > oss > FCL > sf > app > phone / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
phonesettings/cpphonesettingsplugins/tsrc/mocks/mock_hbview.cpp
changeset 78 baacf668fe89
parent 45 6b911d05207e
equal deleted inserted replaced
76:cfea66083b62 78:baacf668fe89 
    16 */
 
    16 */
 
    17 #include <QDebug>
 
    17 #include <QDebug>
 
    18 #include <smcmockclassincludes.h>
 
    18 #include <smcmockclassincludes.h>
 
    19 #include <hbview.h>
 
    19 #include <hbview.h>
 
    20 
    20 
       
    21 #include <HbIcon>
 
       
    22 #include <HbMenu>
 
       
    23 #include <HbToolBar>
 
       
    24 #include <HbDockWidget>
 
       
    25 #include <HbAction>
 
       
    26 
       
    27 
    21 // ============================ MEMBER FUNCTIONS ===============================
 
    28 // ============================ MEMBER FUNCTIONS ===============================
 
    22 
    29 
    23 // -----------------------------------------------------------------------------
 
    30 // -----------------------------------------------------------------------------
 
    24 // HbView::HbView
 
    31 // HbView::HbView
 
    25 // -----------------------------------------------------------------------------
 
    32 // -----------------------------------------------------------------------------
 
    57 // HbView::icon
 
    64 // HbView::icon
 
    58 // -----------------------------------------------------------------------------
 
    65 // -----------------------------------------------------------------------------
 
    59 //
 
    66 //
 
    60 HbIcon HbView::icon(  ) const
 
    67 HbIcon HbView::icon(  ) const
 
    61     {
 
    68     {
 
       
    69     SMC_MOCK_METHOD0( HbIcon )
 
    62     }
 
    70     }
 
    63 
    71 
    64 
    72 
    65 // -----------------------------------------------------------------------------
 
    73 // -----------------------------------------------------------------------------
 
    66 // HbView::setIcon
 
    74 // HbView::setIcon
 
    67 // -----------------------------------------------------------------------------
 
    75 // -----------------------------------------------------------------------------
 
    68 //
 
    76 //
 
    69 void HbView::setIcon( 
    77 void HbView::setIcon( 
    70         const HbIcon & )
 
    78         const HbIcon & icon )
 
    71     {
 
    79     {
 
       
    80     SMC_MOCK_METHOD1( void, const HbIcon &, icon )
 
    72     }
 
    81     }
 
    73 
    82 
    74 
    83 
    75 // -----------------------------------------------------------------------------
 
    84 // -----------------------------------------------------------------------------
 
    76 // HbView::menu
 
    85 // HbView::menu
 
    77 // -----------------------------------------------------------------------------
 
    86 // -----------------------------------------------------------------------------
 
    78 //
 
    87 //
 
    79 HbMenu * HbView::menu(  ) const
 
    88 HbMenu * HbView::menu(  ) const
 
    80     {
 
    89     {
 
       
    90     SMC_MOCK_METHOD0( HbMenu * )
 
    81     }
 
    91     }
 
    82 
    92 
    83 
    93 
    84 // -----------------------------------------------------------------------------
 
    94 // -----------------------------------------------------------------------------
 
    85 // HbView::setMenu
 
    95 // HbView::setMenu
 
    86 // -----------------------------------------------------------------------------
 
    96 // -----------------------------------------------------------------------------
 
    87 //
 
    97 //
 
    88 void HbView::setMenu( 
    98 void HbView::setMenu( 
    89         HbMenu * )
 
    99         HbMenu * menu )
 
    90     {
 
   100     {
 
       
   101     SMC_MOCK_METHOD1( void, HbMenu *, menu )
 
    91     }
 
   102     }
 
    92 
   103 
    93 
   104 
    94 // -----------------------------------------------------------------------------
 
   105 // -----------------------------------------------------------------------------
 
    95 // HbView::takeMenu
 
   106 // HbView::takeMenu
 
    96 // -----------------------------------------------------------------------------
 
   107 // -----------------------------------------------------------------------------
 
    97 //
 
   108 //
 
    98 HbMenu * HbView::takeMenu(  )
 
   109 HbMenu * HbView::takeMenu(  )
 
    99     {
 
   110     {
 
       
   111     SMC_MOCK_METHOD0( HbMenu * )
 
   100     }
 
   112     }
 
   101 
   113 
   102 
   114 
   103 // -----------------------------------------------------------------------------
 
   115 // -----------------------------------------------------------------------------
 
   104 // HbView::toolBar
 
   116 // HbView::toolBar
 
   105 // -----------------------------------------------------------------------------
 
   117 // -----------------------------------------------------------------------------
 
   106 //
 
   118 //
 
   107 HbToolBar * HbView::toolBar(  ) const
 
   119 HbToolBar * HbView::toolBar(  ) const
 
   108     {
 
   120     {
 
       
   121     SMC_MOCK_METHOD0( HbToolBar * )
 
   109     }
 
   122     }
 
   110 
   123 
   111 
   124 
   112 // -----------------------------------------------------------------------------
 
   125 // -----------------------------------------------------------------------------
 
   113 // HbView::setToolBar
 
   126 // HbView::setToolBar
 
   114 // -----------------------------------------------------------------------------
 
   127 // -----------------------------------------------------------------------------
 
   115 //
 
   128 //
 
   116 void HbView::setToolBar( 
   129 void HbView::setToolBar( 
   117         HbToolBar *  )
 
   130         HbToolBar * toolBar )
 
   118     {
 
   131     {
 
       
   132     SMC_MOCK_METHOD1( void, HbToolBar *, toolBar )
 
   119     }
 
   133     }
 
   120 
   134 
   121 
   135 
   122 // -----------------------------------------------------------------------------
 
   136 // -----------------------------------------------------------------------------
 
   123 // HbView::takeToolBar
 
   137 // HbView::takeToolBar
 
   124 // -----------------------------------------------------------------------------
 
   138 // -----------------------------------------------------------------------------
 
   125 //
 
   139 //
 
   126 HbToolBar * HbView::takeToolBar(  )
 
   140 HbToolBar * HbView::takeToolBar(  )
 
   127     {
 
   141     {
 
       
   142     SMC_MOCK_METHOD0( HbToolBar * )
 
   128     }
 
   143     }
 
   129 
   144 
   130 
   145 
   131 // -----------------------------------------------------------------------------
 
   146 // -----------------------------------------------------------------------------
 
   132 // HbView::dockWidget
 
   147 // HbView::dockWidget
 
   133 // -----------------------------------------------------------------------------
 
   148 // -----------------------------------------------------------------------------
 
   134 //
 
   149 //
 
   135 HbDockWidget * HbView::dockWidget(  ) const
 
   150 HbDockWidget * HbView::dockWidget(  ) const
 
   136     {
 
   151     {
 
       
   152     SMC_MOCK_METHOD0( HbDockWidget * )
 
   137     }
 
   153     }
 
   138 
   154 
   139 
   155 
   140 // -----------------------------------------------------------------------------
 
   156 // -----------------------------------------------------------------------------
 
   141 // HbView::setDockWidget
 
   157 // HbView::setDockWidget
 
   142 // -----------------------------------------------------------------------------
 
   158 // -----------------------------------------------------------------------------
 
   143 //
 
   159 //
 
   144 void HbView::setDockWidget( 
   160 void HbView::setDockWidget( 
   145         HbDockWidget *  )
 
   161         HbDockWidget * dockWidget )
 
   146     {
 
   162     {
 
       
   163     SMC_MOCK_METHOD1( void, HbDockWidget *, dockWidget )
 
   147     }
 
   164     }
 
   148 
   165 
   149 
   166 
   150 // -----------------------------------------------------------------------------
 
   167 // -----------------------------------------------------------------------------
 
   151 // HbView::widget
 
   168 // HbView::widget
 
   152 // -----------------------------------------------------------------------------
 
   169 // -----------------------------------------------------------------------------
 
   153 //
 
   170 //
 
   154 QGraphicsWidget * HbView::widget(  ) const
 
   171 QGraphicsWidget * HbView::widget(  ) const
 
   155     {
 
   172     {
 
       
   173     SMC_MOCK_METHOD0( QGraphicsWidget * )
 
   156     }
 
   174     }
 
   157 
   175 
   158 
   176 
   159 // -----------------------------------------------------------------------------
 
   177 // -----------------------------------------------------------------------------
 
   160 // HbView::setWidget
 
   178 // HbView::setWidget
 
   161 // -----------------------------------------------------------------------------
 
   179 // -----------------------------------------------------------------------------
 
   162 //
 
   180 //
 
   163 void HbView::setWidget( 
   181 void HbView::setWidget( 
   164         QGraphicsWidget *  )
 
   182         QGraphicsWidget * widget )
 
   165     {
 
   183     {
 
       
   184     SMC_MOCK_METHOD1( void, QGraphicsWidget *, widget )
 
   166     }
 
   185     }
 
   167 
   186 
   168 
   187 
   169 // -----------------------------------------------------------------------------
 
   188 // -----------------------------------------------------------------------------
 
   170 // HbView::takeWidget
 
   189 // HbView::takeWidget
 
   171 // -----------------------------------------------------------------------------
 
   190 // -----------------------------------------------------------------------------
 
   172 //
 
   191 //
 
   173 QGraphicsWidget * HbView::takeWidget(  )
 
   192 QGraphicsWidget * HbView::takeWidget(  )
 
   174     {
 
   193     {
 
       
   194     SMC_MOCK_METHOD0( QGraphicsWidget * )
 
   175     }
 
   195     }
 
   176 
   196 
   177 
   197 
   178 // -----------------------------------------------------------------------------
 
   198 // -----------------------------------------------------------------------------
 
   179 // HbView::showItems
 
   199 // HbView::showItems
 
   180 // -----------------------------------------------------------------------------
 
   200 // -----------------------------------------------------------------------------
 
   181 //
 
   201 //
 
   182 void HbView::showItems( 
   202 void HbView::showItems( 
   183         Hb::SceneItems  )
 
   203         Hb::SceneItems /*items*/ )
 
   184     {
 
   204     {
 
       
   205     //SMC_MOCK_METHOD1( void, Hb::SceneItems, items )
 
   185     }
 
   206     }
 
   186 
   207 
   187 
   208 
   188 // -----------------------------------------------------------------------------
 
   209 // -----------------------------------------------------------------------------
 
   189 // HbView::hideItems
 
   210 // HbView::hideItems
 
   190 // -----------------------------------------------------------------------------
 
   211 // -----------------------------------------------------------------------------
 
   191 //
 
   212 //
 
   192 void HbView::hideItems( 
   213 void HbView::hideItems( 
   193         Hb::SceneItems  )
 
   214         Hb::SceneItems /*items*/ )
 
   194     {
 
   215     {
 
       
   216     //SMC_MOCK_METHOD1( void, Hb::SceneItems, items )
 
   195     }
 
   217     }
 
   196 
   218 
   197 
   219 
   198 // -----------------------------------------------------------------------------
 
   220 // -----------------------------------------------------------------------------
 
   199 // HbView::visibleItems
 
   221 // HbView::visibleItems
 
   200 // -----------------------------------------------------------------------------
 
   222 // -----------------------------------------------------------------------------
 
   201 //
 
   223 //
 
   202 Hb::SceneItems HbView::visibleItems(  ) const
 
   224 Hb::SceneItems HbView::visibleItems(  ) const
 
   203     {
 
   225     {
 
       
   226     SMC_MOCK_METHOD0( Hb::SceneItems )
 
   204     }
 
   227     }
 
   205 
   228 
   206 
   229 
   207 // -----------------------------------------------------------------------------
 
   230 // -----------------------------------------------------------------------------
 
   208 // HbView::isItemVisible
 
   231 // HbView::isItemVisible
 
   209 // -----------------------------------------------------------------------------
 
   232 // -----------------------------------------------------------------------------
 
   210 //
 
   233 //
 
   211 bool HbView::isItemVisible( 
   234 bool HbView::isItemVisible( 
   212         Hb::SceneItem  ) const
 
   235         Hb::SceneItem /*item*/ ) const
 
   213     {
 
   236     {
 
       
   237     //SMC_MOCK_METHOD1( bool, Hb::SceneItem, item )
 
   214     }
 
   238     }
 
   215 
   239 
   216 
   240 
   217 // -----------------------------------------------------------------------------
 
   241 // -----------------------------------------------------------------------------
 
   218 // HbView::setItemVisible
 
   242 // HbView::setItemVisible
 
   219 // -----------------------------------------------------------------------------
 
   243 // -----------------------------------------------------------------------------
 
   220 //
 
   244 //
 
   221 void HbView::setItemVisible( 
   245 void HbView::setItemVisible( 
   222         Hb::SceneItem item,
 
   246         Hb::SceneItem /*item*/,
 
   223         bool visible )
 
   247         bool /*visible*/ )
 
   224     {
 
   248     {
 
   225     SMC_MOCK_METHOD2( void, Hb::SceneItem, item, 
   249     /*SMC_MOCK_METHOD2( void, Hb::SceneItem, item, 
   226         bool, visible )
 
   250         bool, visible )*/
 
   227     }
 
   251     }
 
   228 
   252 
   229 
   253 
   230 // -----------------------------------------------------------------------------
 
   254 // -----------------------------------------------------------------------------
 
   231 // HbView::isContentFullScreen
 
   255 // HbView::isContentFullScreen
 
   241 // HbView::viewFlags
 
   265 // HbView::viewFlags
 
   242 // -----------------------------------------------------------------------------
 
   266 // -----------------------------------------------------------------------------
 
   243 //
 
   267 //
 
   244 HbView::HbViewFlags HbView::viewFlags(  ) const
 
   268 HbView::HbViewFlags HbView::viewFlags(  ) const
 
   245     {
 
   269     {
 
   246     // SMC_MOCK_METHOD0( HbViewFlags )
 
   270     SMC_MOCK_METHOD0( HbView::HbViewFlags )
 
   247     }
 
   271     }
 
   248 
   272 
   249 
   273 
   250 // -----------------------------------------------------------------------------
 
   274 // -----------------------------------------------------------------------------
 
   251 // HbView::setTitleBarVisible
 
   275 // HbView::setTitleBarVisible
 
   273 // -----------------------------------------------------------------------------
 
   297 // -----------------------------------------------------------------------------
 
   274 // HbView::addAction
 
   298 // HbView::addAction
 
   275 // -----------------------------------------------------------------------------
 
   299 // -----------------------------------------------------------------------------
 
   276 //
 
   300 //
 
   277 void HbView::addAction( 
   301 void HbView::addAction( 
   278         HbAction * action,
 
   302         HbAction * actione,
 
   279         ActionContainer preferredActionContainer )
 
   303         ActionContainer preferredActionContainer )
 
   280     {
 
   304     {
 
   281    // SMC_MOCK_METHOD2( void, HbAction *, action, 
   305     SMC_MOCK_METHOD2( void, HbAction *, actione, 
   282      //   ActionContainer, preferredActionContainer )
 
   306         ActionContainer, preferredActionContainer )
 
   283     }
 
   307     }
 
   284 
   308 
   285 
   309 
   286 // -----------------------------------------------------------------------------
 
   310 // -----------------------------------------------------------------------------
 
   287 // HbView::navigationAction
 
   311 // HbView::navigationAction
 
   296 // -----------------------------------------------------------------------------
 
   320 // -----------------------------------------------------------------------------
 
   297 // HbView::setNavigationAction
 
   321 // HbView::setNavigationAction
 
   298 // -----------------------------------------------------------------------------
 
   322 // -----------------------------------------------------------------------------
 
   299 //
 
   323 //
 
   300 void HbView::setNavigationAction( 
   324 void HbView::setNavigationAction( 
   301         HbAction * action )
 
   325         HbAction * actione )
 
   302     {
 
   326     {
 
   303  //   SMC_MOCK_METHOD1( void, HbAction *, action )
 
   327     SMC_MOCK_METHOD1( void, HbAction *, actione )
 
   304     }
 
   328     }
 
   305 
   329 
   306 
   330 
   307 // -----------------------------------------------------------------------------
 
   331 // -----------------------------------------------------------------------------
 
   308 // HbView::setTitle
 
   332 // HbView::setTitle
 
   329 // -----------------------------------------------------------------------------
 
   353 // -----------------------------------------------------------------------------
 
   330 // HbView::setViewFlags
 
   354 // HbView::setViewFlags
 
   331 // -----------------------------------------------------------------------------
 
   355 // -----------------------------------------------------------------------------
 
   332 //
 
   356 //
 
   333 void HbView::setViewFlags( 
   357 void HbView::setViewFlags( 
   334         HbViewFlags flags )
 
   358         HbViewFlags /*flags*/ )
 
   335     {
 
   359     {
 
   336   //  SMC_MOCK_METHOD1( void, HbViewFlags, flags )
 
   360     //SMC_MOCK_METHOD1( void, HbViewFlags, flags )
 
   337     }
 
   361     }
 
   338 
   362 
   339 
   363 
   340 // -----------------------------------------------------------------------------
 
   364 // -----------------------------------------------------------------------------
 
   341 // HbView::titleChanged
 
   365 // HbView::titleChanged
 
   353 // -----------------------------------------------------------------------------
 
   377 // -----------------------------------------------------------------------------
 
   354 //
 
   378 //
 
   355 void HbView::iconChanged( 
   379 void HbView::iconChanged( 
   356         const HbIcon & icon )
 
   380         const HbIcon & icon )
 
   357     {
 
   381     {
 
   358   //  SMC_MOCK_METHOD1( void, const HbIcon &, icon )
 
   382     SMC_MOCK_METHOD1( void, const HbIcon &, icon )
 
   359     }
 
   383     }
 
   360 
   384 
   361 
   385 
   362 // -----------------------------------------------------------------------------
 
   386 // -----------------------------------------------------------------------------
 
   363 // HbView::toolBarChanged
 
   387 // HbView::toolBarChanged
 
   418 // -----------------------------------------------------------------------------
 
   442 // -----------------------------------------------------------------------------
 
   419 //
 
   443 //
 
   420 bool HbView::event( 
   444 bool HbView::event( 
   421         QEvent * event )
 
   445         QEvent * event )
 
   422     {
 
   446     {
 
   423   //  SMC_MOCK_METHOD1( bool, QEvent *, event )
 
   447     SMC_MOCK_METHOD1( bool, QEvent *, event )
 
   424     }
 
   448     }
 
   425 
   449 
   426 
   450 
       
   451 // -----------------------------------------------------------------------------
 
       
   452 // HbView::changeEvent
 
       
   453 // -----------------------------------------------------------------------------
 
       
   454 //
 
       
   455 void HbView::changeEvent( 
       
   456         QEvent * event )
 
       
   457     {
 
       
   458     SMC_MOCK_METHOD1( void, QEvent *, event )
 
       
   459     }
 
       
   460 
       
   461
FCL/sf/app/phone