phoneplugins/infowidgetplugin/tsrc/mocks/mock_qevent.cpp
changeset 76 cfea66083b62
equal deleted inserted replaced
74:d1c62c765e48 76:cfea66083b62
       
     1 /** Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
       
     2 * All rights reserved.
       
     3 * This component and the accompanying materials are made available
       
     4 * under the terms of the License "Eclipse Public License v1.0"
       
     5 * which accompanies this distribution, and is available
       
     6 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     7 *
       
     8 * Initial Contributors:
       
     9 * Nokia Corporation - initial contribution.
       
    10 *
       
    11 * Contributors:
       
    12 *
       
    13 * Description:
       
    14 *
       
    15 */
       
    16 #include <QDebug>
       
    17 #include <smcmockclassincludes.h>
       
    18 #include <qevent.h>
       
    19 
       
    20 #include <QUrl>
       
    21 #include <QWidget>
       
    22 #include <QGesture>
       
    23 
       
    24 // ============================ MEMBER FUNCTIONS ===============================
       
    25 
       
    26 // -----------------------------------------------------------------------------
       
    27 // QWheelEvent::QWheelEvent
       
    28 // -----------------------------------------------------------------------------
       
    29 //
       
    30 QWheelEvent::QWheelEvent( 
       
    31         const QPoint & pos,
       
    32         int delta,
       
    33         Qt::MouseButtons buttons,
       
    34         Qt::KeyboardModifiers modifiers,
       
    35         Qt::Orientation orient )
       
    36     :QInputEvent(Wheel, modifiers)
       
    37     //QInputEvent( /*pos, delta, buttons, modifiers, orient*/ )
       
    38     {
       
    39     
       
    40     }
       
    41 
       
    42 
       
    43 // -----------------------------------------------------------------------------
       
    44 // QWheelEvent::QWheelEvent
       
    45 // -----------------------------------------------------------------------------
       
    46 //
       
    47 QWheelEvent::QWheelEvent( 
       
    48         const QPoint & pos,
       
    49         const QPoint & globalPos,
       
    50         int delta,
       
    51         Qt::MouseButtons buttons,
       
    52         Qt::KeyboardModifiers modifiers,
       
    53         Qt::Orientation orient )
       
    54     : QInputEvent(Wheel)
       
    55     //QInputEvent( /*pos, globalPos, delta, buttons, modifiers, orient*/ )
       
    56     {
       
    57     
       
    58     }
       
    59 
       
    60 
       
    61 // -----------------------------------------------------------------------------
       
    62 // QWheelEvent::~QWheelEvent
       
    63 // -----------------------------------------------------------------------------
       
    64 //
       
    65 QWheelEvent::~QWheelEvent(  )
       
    66     {
       
    67     
       
    68     }
       
    69 
       
    70 // -----------------------------------------------------------------------------
       
    71 // QUpdateLaterEvent::QUpdateLaterEvent
       
    72 // -----------------------------------------------------------------------------
       
    73 //
       
    74 QUpdateLaterEvent::QUpdateLaterEvent( 
       
    75         const QRegion & paintRegion )
       
    76     :QEvent(UpdateLater)
       
    77     //QEvent( /*paintRegion*/ )
       
    78     {
       
    79     
       
    80     }
       
    81 
       
    82 
       
    83 // -----------------------------------------------------------------------------
       
    84 // QUpdateLaterEvent::~QUpdateLaterEvent
       
    85 // -----------------------------------------------------------------------------
       
    86 //
       
    87 QUpdateLaterEvent::~QUpdateLaterEvent(  )
       
    88     {
       
    89     
       
    90     }
       
    91 
       
    92 
       
    93 // -----------------------------------------------------------------------------
       
    94 // QGestureEvent::QGestureEvent
       
    95 // -----------------------------------------------------------------------------
       
    96 //
       
    97 QGestureEvent::QGestureEvent( 
       
    98         const QList<QGesture *> & gestures )
       
    99     :QEvent(QEvent::Gesture)
       
   100     //QEvent( /*gestures*/ )
       
   101     {
       
   102     
       
   103     }
       
   104 
       
   105 
       
   106 // -----------------------------------------------------------------------------
       
   107 // QGestureEvent::~QGestureEvent
       
   108 // -----------------------------------------------------------------------------
       
   109 //
       
   110 QGestureEvent::~QGestureEvent(  )
       
   111     {
       
   112     
       
   113     }
       
   114 
       
   115 
       
   116 // -----------------------------------------------------------------------------
       
   117 // QGestureEvent::gestures
       
   118 // -----------------------------------------------------------------------------
       
   119 //
       
   120 QList <QGesture * > QGestureEvent::gestures(  ) const
       
   121     {
       
   122     SMC_MOCK_METHOD0( QList <QGesture * > )
       
   123     }
       
   124 
       
   125 
       
   126 // -----------------------------------------------------------------------------
       
   127 // QGestureEvent::gesture
       
   128 // -----------------------------------------------------------------------------
       
   129 //
       
   130 QGesture * QGestureEvent::gesture( 
       
   131         Qt::GestureType type ) const
       
   132     {
       
   133     SMC_MOCK_METHOD1( QGesture *, Qt::GestureType, type )
       
   134     }
       
   135 
       
   136 
       
   137 // -----------------------------------------------------------------------------
       
   138 // QGestureEvent::activeGestures
       
   139 // -----------------------------------------------------------------------------
       
   140 //
       
   141 QList <QGesture * > QGestureEvent::activeGestures(  ) const
       
   142     {
       
   143     SMC_MOCK_METHOD0( QList <QGesture * > )
       
   144     }
       
   145 
       
   146 
       
   147 // -----------------------------------------------------------------------------
       
   148 // QGestureEvent::canceledGestures
       
   149 // -----------------------------------------------------------------------------
       
   150 //
       
   151 QList <QGesture * > QGestureEvent::canceledGestures(  ) const
       
   152     {
       
   153     SMC_MOCK_METHOD0( QList <QGesture * > )
       
   154     }
       
   155 
       
   156 
       
   157 // -----------------------------------------------------------------------------
       
   158 // QGestureEvent::setAccepted
       
   159 // -----------------------------------------------------------------------------
       
   160 //
       
   161 void QGestureEvent::setAccepted( 
       
   162         QGesture *gesture, bool value)
       
   163     {
       
   164     SMC_MOCK_METHOD2( void, QGesture *, gesture, bool, value )
       
   165     }
       
   166 
       
   167 
       
   168 // -----------------------------------------------------------------------------
       
   169 // QGestureEvent::accept
       
   170 // -----------------------------------------------------------------------------
       
   171 //
       
   172 void QGestureEvent::accept( 
       
   173         QGesture *gesture)
       
   174     {
       
   175     SMC_MOCK_METHOD1( void, QGesture *, gesture )
       
   176     }
       
   177 
       
   178 
       
   179 // -----------------------------------------------------------------------------
       
   180 // QGestureEvent::ignore
       
   181 // -----------------------------------------------------------------------------
       
   182 //
       
   183 void QGestureEvent::ignore( 
       
   184         QGesture *gesture )
       
   185     {
       
   186     SMC_MOCK_METHOD1( void, QGesture *, gesture )
       
   187     }
       
   188 
       
   189 
       
   190 // -----------------------------------------------------------------------------
       
   191 // QGestureEvent::isAccepted
       
   192 // -----------------------------------------------------------------------------
       
   193 //
       
   194 bool QGestureEvent::isAccepted( 
       
   195         QGesture *gesture ) const
       
   196     {
       
   197     SMC_MOCK_METHOD1( bool, QGesture *, gesture )
       
   198     }
       
   199 
       
   200 
       
   201 // -----------------------------------------------------------------------------
       
   202 // QGestureEvent::setAccepted
       
   203 // -----------------------------------------------------------------------------
       
   204 //
       
   205 void QGestureEvent::setAccepted( 
       
   206         Qt::GestureType type, bool value)
       
   207     {
       
   208     SMC_MOCK_METHOD2( void, Qt::GestureType, type, bool, value )
       
   209     }
       
   210 
       
   211 
       
   212 // -----------------------------------------------------------------------------
       
   213 // QGestureEvent::accept
       
   214 // -----------------------------------------------------------------------------
       
   215 //
       
   216 void QGestureEvent::accept( 
       
   217         Qt::GestureType type )
       
   218     {
       
   219     SMC_MOCK_METHOD1( void, Qt::GestureType, type )
       
   220     }
       
   221 
       
   222 
       
   223 // -----------------------------------------------------------------------------
       
   224 // QGestureEvent::ignore
       
   225 // -----------------------------------------------------------------------------
       
   226 //
       
   227 void QGestureEvent::ignore( 
       
   228         Qt::GestureType type )
       
   229     {
       
   230     SMC_MOCK_METHOD1( void, Qt::GestureType, type )
       
   231     }
       
   232 
       
   233 
       
   234 // -----------------------------------------------------------------------------
       
   235 // QGestureEvent::isAccepted
       
   236 // -----------------------------------------------------------------------------
       
   237 //
       
   238 bool QGestureEvent::isAccepted( 
       
   239         Qt::GestureType type ) const
       
   240     {
       
   241     SMC_MOCK_METHOD1( bool, Qt::GestureType, type )
       
   242     }
       
   243 
       
   244 
       
   245 // -----------------------------------------------------------------------------
       
   246 // QGestureEvent::setWidget
       
   247 // -----------------------------------------------------------------------------
       
   248 //
       
   249 void QGestureEvent::setWidget( 
       
   250         QWidget * widget )
       
   251     {
       
   252     SMC_MOCK_METHOD1( void, QWidget *, widget )
       
   253     }
       
   254 
       
   255 
       
   256 // -----------------------------------------------------------------------------
       
   257 // QGestureEvent::widget
       
   258 // -----------------------------------------------------------------------------
       
   259 //
       
   260 QWidget * QGestureEvent::widget(  ) const
       
   261     {
       
   262     SMC_MOCK_METHOD0( QWidget * )
       
   263     }
       
   264 
       
   265 
       
   266 // -----------------------------------------------------------------------------
       
   267 // QGestureEvent::mapToGraphicsScene
       
   268 // -----------------------------------------------------------------------------
       
   269 //
       
   270 QPointF QGestureEvent::mapToGraphicsScene( 
       
   271         const QPointF & gesturePoint ) const
       
   272     {
       
   273     SMC_MOCK_METHOD1( QPointF, const QPointF &, gesturePoint )
       
   274     }
       
   275 
       
   276 
       
   277 // -----------------------------------------------------------------------------
       
   278 // QContextMenuEvent::QContextMenuEvent
       
   279 // -----------------------------------------------------------------------------
       
   280 //
       
   281 QContextMenuEvent::QContextMenuEvent( 
       
   282         Reason reason,
       
   283         const QPoint & pos,
       
   284         const QPoint & globalPos,
       
   285         Qt::KeyboardModifiers modifiers )
       
   286     :QInputEvent(ContextMenu, modifiers)
       
   287     //QInputEvent( /*reason, pos, globalPos, modifiers*/ )
       
   288     {
       
   289     
       
   290     }
       
   291 
       
   292 
       
   293 // -----------------------------------------------------------------------------
       
   294 // QContextMenuEvent::QContextMenuEvent
       
   295 // -----------------------------------------------------------------------------
       
   296 //
       
   297 QContextMenuEvent::QContextMenuEvent( 
       
   298         Reason reason,
       
   299         const QPoint & pos,
       
   300         const QPoint & globalPos )
       
   301     :QInputEvent(ContextMenu)
       
   302     //QInputEvent( /*reason, pos, globalPos*/ )
       
   303     {
       
   304     
       
   305     }
       
   306 
       
   307 
       
   308 // -----------------------------------------------------------------------------
       
   309 // QContextMenuEvent::QContextMenuEvent
       
   310 // -----------------------------------------------------------------------------
       
   311 //
       
   312 QContextMenuEvent::QContextMenuEvent( 
       
   313         Reason reason,
       
   314         const QPoint & pos )
       
   315     :QInputEvent(ContextMenu)
       
   316     //QInputEvent( /*reason, pos*/ )
       
   317     {
       
   318     
       
   319     }
       
   320 
       
   321 
       
   322 // -----------------------------------------------------------------------------
       
   323 // QContextMenuEvent::~QContextMenuEvent
       
   324 // -----------------------------------------------------------------------------
       
   325 //
       
   326 QContextMenuEvent::~QContextMenuEvent(  )
       
   327     {
       
   328     
       
   329     }
       
   330 
       
   331 
       
   332 // -----------------------------------------------------------------------------
       
   333 // QStatusTipEvent::QStatusTipEvent
       
   334 // -----------------------------------------------------------------------------
       
   335 //
       
   336 QStatusTipEvent::QStatusTipEvent( 
       
   337         const QString & tip )
       
   338     :QEvent(StatusTip)
       
   339     //QEvent( /*tip*/ )
       
   340     {
       
   341     
       
   342     }
       
   343 
       
   344 
       
   345 // -----------------------------------------------------------------------------
       
   346 // QStatusTipEvent::~QStatusTipEvent
       
   347 // -----------------------------------------------------------------------------
       
   348 //
       
   349 QStatusTipEvent::~QStatusTipEvent(  )
       
   350     {
       
   351     
       
   352     }
       
   353 
       
   354 
       
   355 // -----------------------------------------------------------------------------
       
   356 // QMoveEvent::QMoveEvent
       
   357 // -----------------------------------------------------------------------------
       
   358 //
       
   359 QMoveEvent::QMoveEvent( 
       
   360         const QPoint & pos,
       
   361         const QPoint & oldPos )
       
   362     :QEvent(Move)
       
   363     //QEvent( /*pos, oldPos*/ )
       
   364     {
       
   365     
       
   366     }
       
   367 
       
   368 
       
   369 // -----------------------------------------------------------------------------
       
   370 // QMoveEvent::~QMoveEvent
       
   371 // -----------------------------------------------------------------------------
       
   372 //
       
   373 QMoveEvent::~QMoveEvent(  )
       
   374     {
       
   375     
       
   376     }
       
   377 
       
   378 
       
   379 // -----------------------------------------------------------------------------
       
   380 // QDragEnterEvent::QDragEnterEvent
       
   381 // -----------------------------------------------------------------------------
       
   382 //
       
   383 QDragEnterEvent::QDragEnterEvent( 
       
   384         const QPoint & pos,
       
   385         Qt::DropActions actions,
       
   386         const QMimeData * data,
       
   387         Qt::MouseButtons buttons,
       
   388         Qt::KeyboardModifiers modifiers )
       
   389     :QDragMoveEvent(pos, actions, data, buttons, modifiers, DragEnter)
       
   390     //QDragMoveEvent( /*pos, actions, data, buttons, modifiers*/ )
       
   391     {
       
   392     
       
   393     }
       
   394 
       
   395 
       
   396 // -----------------------------------------------------------------------------
       
   397 // QDragEnterEvent::~QDragEnterEvent
       
   398 // -----------------------------------------------------------------------------
       
   399 //
       
   400 QDragEnterEvent::~QDragEnterEvent(  )
       
   401     {
       
   402     
       
   403     }
       
   404 
       
   405 
       
   406 // -----------------------------------------------------------------------------
       
   407 // QIconDragEvent::QIconDragEvent
       
   408 // -----------------------------------------------------------------------------
       
   409 //
       
   410 QIconDragEvent::QIconDragEvent(  )
       
   411     :QEvent(IconDrag)
       
   412     {
       
   413     
       
   414     }
       
   415 
       
   416 
       
   417 // -----------------------------------------------------------------------------
       
   418 // QIconDragEvent::~QIconDragEvent
       
   419 // -----------------------------------------------------------------------------
       
   420 //
       
   421 QIconDragEvent::~QIconDragEvent(  )
       
   422     {
       
   423     
       
   424     }
       
   425 
       
   426 
       
   427 // -----------------------------------------------------------------------------
       
   428 // QFileOpenEvent::QFileOpenEvent
       
   429 // -----------------------------------------------------------------------------
       
   430 //
       
   431 QFileOpenEvent::QFileOpenEvent( 
       
   432         const QString & file )
       
   433     :QEvent(FileOpen)
       
   434     //QEvent( /*file*/ )
       
   435     {
       
   436     
       
   437     }
       
   438 
       
   439 
       
   440 // -----------------------------------------------------------------------------
       
   441 // QFileOpenEvent::QFileOpenEvent
       
   442 // -----------------------------------------------------------------------------
       
   443 //
       
   444 QFileOpenEvent::QFileOpenEvent( 
       
   445         const QUrl & url )
       
   446     :QEvent(FileOpen)
       
   447     //QEvent( /*url*/ )
       
   448     {
       
   449     
       
   450     }
       
   451 
       
   452 
       
   453 // -----------------------------------------------------------------------------
       
   454 // QFileOpenEvent::~QFileOpenEvent
       
   455 // -----------------------------------------------------------------------------
       
   456 //
       
   457 QFileOpenEvent::~QFileOpenEvent(  )
       
   458     {
       
   459     
       
   460     }
       
   461 
       
   462 
       
   463 // -----------------------------------------------------------------------------
       
   464 // QFileOpenEvent::url
       
   465 // -----------------------------------------------------------------------------
       
   466 //
       
   467 QUrl QFileOpenEvent::url(  ) const
       
   468     {
       
   469     SMC_MOCK_METHOD0( QUrl )
       
   470     }
       
   471 
       
   472 
       
   473 // -----------------------------------------------------------------------------
       
   474 // QHelpEvent::QHelpEvent
       
   475 // -----------------------------------------------------------------------------
       
   476 //
       
   477 QHelpEvent::QHelpEvent( 
       
   478         Type type,
       
   479         const QPoint & pos,
       
   480         const QPoint & globalPos )
       
   481     :QEvent(type)
       
   482     //QEvent( /*type, pos, globalPos*/ )
       
   483     {
       
   484     
       
   485     }
       
   486 
       
   487 
       
   488 // -----------------------------------------------------------------------------
       
   489 // QHelpEvent::~QHelpEvent
       
   490 // -----------------------------------------------------------------------------
       
   491 //
       
   492 QHelpEvent::~QHelpEvent(  )
       
   493     {
       
   494     
       
   495     }
       
   496 
       
   497 
       
   498 // -----------------------------------------------------------------------------
       
   499 // QToolBarChangeEvent::QToolBarChangeEvent
       
   500 // -----------------------------------------------------------------------------
       
   501 //
       
   502 QToolBarChangeEvent::QToolBarChangeEvent( 
       
   503         bool t )
       
   504     :QEvent(ToolBarChange)
       
   505     //QEvent( /*t*/ )
       
   506     {
       
   507     
       
   508     }
       
   509 
       
   510 
       
   511 // -----------------------------------------------------------------------------
       
   512 // QToolBarChangeEvent::~QToolBarChangeEvent
       
   513 // -----------------------------------------------------------------------------
       
   514 //
       
   515 QToolBarChangeEvent::~QToolBarChangeEvent(  )
       
   516     {
       
   517     
       
   518     }
       
   519 
       
   520 
       
   521 // -----------------------------------------------------------------------------
       
   522 // QDragMoveEvent::QDragMoveEvent
       
   523 // -----------------------------------------------------------------------------
       
   524 //
       
   525 QDragMoveEvent::QDragMoveEvent( 
       
   526         const QPoint & pos,
       
   527         Qt::DropActions actions,
       
   528         const QMimeData * data,
       
   529         Qt::MouseButtons buttons,
       
   530         Qt::KeyboardModifiers modifiers,
       
   531         Type type )
       
   532     :QDropEvent(pos, actions, data, buttons, modifiers, type)
       
   533     //QDropEvent( /*pos, actions, data, buttons, modifiers, type*/ )
       
   534     {
       
   535     
       
   536     }
       
   537 
       
   538 
       
   539 // -----------------------------------------------------------------------------
       
   540 // QDragMoveEvent::~QDragMoveEvent
       
   541 // -----------------------------------------------------------------------------
       
   542 //
       
   543 QDragMoveEvent::~QDragMoveEvent(  )
       
   544     {
       
   545     
       
   546     }
       
   547 
       
   548 
       
   549 // -----------------------------------------------------------------------------
       
   550 // QPaintEvent::QPaintEvent
       
   551 // -----------------------------------------------------------------------------
       
   552 //
       
   553 QPaintEvent::QPaintEvent( 
       
   554         const QRegion & paintRegion )
       
   555     :QEvent(Paint)
       
   556     //QEvent( /*paintRegion*/ )
       
   557     {
       
   558     
       
   559     }
       
   560 
       
   561 
       
   562 // -----------------------------------------------------------------------------
       
   563 // QPaintEvent::QPaintEvent
       
   564 // -----------------------------------------------------------------------------
       
   565 //
       
   566 QPaintEvent::QPaintEvent( 
       
   567         const QRect & paintRect )
       
   568     :QEvent(Paint)
       
   569     //QEvent( /*paintRect*/ )
       
   570     {
       
   571     
       
   572     }
       
   573 
       
   574 
       
   575 // -----------------------------------------------------------------------------
       
   576 // QPaintEvent::~QPaintEvent
       
   577 // -----------------------------------------------------------------------------
       
   578 //
       
   579 QPaintEvent::~QPaintEvent(  )
       
   580     {
       
   581     
       
   582     }
       
   583 
       
   584 
       
   585 // -----------------------------------------------------------------------------
       
   586 // QKeyEvent::QKeyEvent
       
   587 // -----------------------------------------------------------------------------
       
   588 //
       
   589 QKeyEvent::QKeyEvent( 
       
   590         Type type,
       
   591         int key,
       
   592         Qt::KeyboardModifiers modifiers,
       
   593         const QString & text,
       
   594         bool autorep,
       
   595         ushort count )
       
   596     :QInputEvent(type, modifiers)
       
   597     //QInputEvent( /*type, key, modifiers, text, autorep, count*/ )
       
   598     {
       
   599     
       
   600     }
       
   601 
       
   602 
       
   603 // -----------------------------------------------------------------------------
       
   604 // QKeyEvent::~QKeyEvent
       
   605 // -----------------------------------------------------------------------------
       
   606 //
       
   607 QKeyEvent::~QKeyEvent(  )
       
   608     {
       
   609     
       
   610     }
       
   611 
       
   612 // -----------------------------------------------------------------------------
       
   613 // QKeyEvent::matches
       
   614 // -----------------------------------------------------------------------------
       
   615 //
       
   616 bool QKeyEvent::matches( 
       
   617         QKeySequence::StandardKey key ) const
       
   618     {
       
   619     SMC_MOCK_METHOD1( bool, QKeySequence::StandardKey, key )
       
   620     }
       
   621 
       
   622 
       
   623 // -----------------------------------------------------------------------------
       
   624 // QKeyEvent::modifiers
       
   625 // -----------------------------------------------------------------------------
       
   626 //
       
   627 Qt::KeyboardModifiers QKeyEvent::modifiers(  ) const
       
   628     {
       
   629     SMC_MOCK_METHOD0( Qt::KeyboardModifiers )
       
   630     }
       
   631 
       
   632 
       
   633 // -----------------------------------------------------------------------------
       
   634 // QKeyEvent::createExtendedKeyEvent
       
   635 // -----------------------------------------------------------------------------
       
   636 //
       
   637 QKeyEvent * QKeyEvent::createExtendedKeyEvent( 
       
   638         Type type,
       
   639         int key,
       
   640         Qt::KeyboardModifiers modifiers,
       
   641         quint32 nativeScanCode,
       
   642         quint32 nativeVirtualKey,
       
   643         quint32 nativeModifiers,
       
   644         const QString & text,
       
   645         bool autorep,
       
   646         ushort count )
       
   647     {
       
   648     /*SMC_MOCK_METHOD9( QKeyEvent *, Type, type, 
       
   649         int, key, 
       
   650         Qt::KeyboardModifiers, modifiers, 
       
   651         quint32, nativeScanCode, 
       
   652         quint32, nativeVirtualKey, 
       
   653         quint32, nativeModifiers, 
       
   654         const QString &, text, 
       
   655         bool, autorep, 
       
   656         ushort, count )*/
       
   657     }
       
   658 
       
   659 
       
   660 // -----------------------------------------------------------------------------
       
   661 // QKeyEvent::nativeScanCode
       
   662 // -----------------------------------------------------------------------------
       
   663 //
       
   664 quint32 QKeyEvent::nativeScanCode(  ) const
       
   665     {
       
   666     SMC_MOCK_METHOD0( quint32 )
       
   667     }
       
   668 
       
   669 
       
   670 // -----------------------------------------------------------------------------
       
   671 // QKeyEvent::nativeVirtualKey
       
   672 // -----------------------------------------------------------------------------
       
   673 //
       
   674 quint32 QKeyEvent::nativeVirtualKey(  ) const
       
   675     {
       
   676     SMC_MOCK_METHOD0( quint32 )
       
   677     }
       
   678 
       
   679 
       
   680 // -----------------------------------------------------------------------------
       
   681 // QKeyEvent::nativeModifiers
       
   682 // -----------------------------------------------------------------------------
       
   683 //
       
   684 quint32 QKeyEvent::nativeModifiers(  ) const
       
   685     {
       
   686     SMC_MOCK_METHOD0( quint32 )
       
   687     }
       
   688 
       
   689 
       
   690 // -----------------------------------------------------------------------------
       
   691 // QClipboardEvent::QClipboardEvent
       
   692 // -----------------------------------------------------------------------------
       
   693 //
       
   694 QClipboardEvent::QClipboardEvent( 
       
   695         QEventPrivate * data )
       
   696     :QEvent(QEvent::Clipboard)
       
   697     //QEvent( /*data*/ )
       
   698     {
       
   699     
       
   700     }
       
   701 
       
   702 
       
   703 // -----------------------------------------------------------------------------
       
   704 // QClipboardEvent::~QClipboardEvent
       
   705 // -----------------------------------------------------------------------------
       
   706 //
       
   707 QClipboardEvent::~QClipboardEvent(  )
       
   708     {
       
   709     
       
   710     }
       
   711 
       
   712 
       
   713 // -----------------------------------------------------------------------------
       
   714 // QHideEvent::QHideEvent
       
   715 // -----------------------------------------------------------------------------
       
   716 //
       
   717 QHideEvent::QHideEvent(  )
       
   718     :QEvent(Hide)
       
   719     //QEvent( /**/ )
       
   720     {
       
   721     
       
   722     }
       
   723 
       
   724 
       
   725 // -----------------------------------------------------------------------------
       
   726 // QHideEvent::~QHideEvent
       
   727 // -----------------------------------------------------------------------------
       
   728 //
       
   729 QHideEvent::~QHideEvent(  )
       
   730     {
       
   731     
       
   732     }
       
   733 
       
   734 
       
   735 // -----------------------------------------------------------------------------
       
   736 // QInputMethodEvent::QInputMethodEvent
       
   737 // -----------------------------------------------------------------------------
       
   738 //
       
   739 QInputMethodEvent::QInputMethodEvent(  )
       
   740     :QEvent(QEvent::InputMethod)
       
   741     //QEvent( /**/ )
       
   742     {
       
   743     
       
   744     }
       
   745 
       
   746 
       
   747 // -----------------------------------------------------------------------------
       
   748 // QInputMethodEvent::QInputMethodEvent
       
   749 // -----------------------------------------------------------------------------
       
   750 //
       
   751 QInputMethodEvent::QInputMethodEvent( 
       
   752         const QString & preeditText,
       
   753         const QList<Attribute> & attributes )
       
   754     :QEvent(QEvent::InputMethod)
       
   755     //QEvent( /*preeditText, attributes*/ )
       
   756     {
       
   757     
       
   758     }
       
   759 
       
   760 
       
   761 // -----------------------------------------------------------------------------
       
   762 // QInputMethodEvent::setCommitString
       
   763 // -----------------------------------------------------------------------------
       
   764 //
       
   765 void QInputMethodEvent::setCommitString( 
       
   766         const QString & commitString,
       
   767         int replaceFrom,
       
   768         int replaceLength )
       
   769     {
       
   770     SMC_MOCK_METHOD3( void, const QString &, commitString, 
       
   771         int, replaceFrom, 
       
   772         int, replaceLength )
       
   773     }
       
   774 
       
   775 
       
   776 // -----------------------------------------------------------------------------
       
   777 // QInputMethodEvent::QInputMethodEvent
       
   778 // -----------------------------------------------------------------------------
       
   779 //
       
   780 QInputMethodEvent::QInputMethodEvent( 
       
   781         const QInputMethodEvent & other )
       
   782     :QEvent(QEvent::InputMethod)
       
   783     //QEvent( /*other*/ )
       
   784     {
       
   785     
       
   786     }
       
   787 
       
   788 
       
   789 // -----------------------------------------------------------------------------
       
   790 // QTabletEvent::QTabletEvent
       
   791 // -----------------------------------------------------------------------------
       
   792 //
       
   793 QTabletEvent::QTabletEvent( 
       
   794         Type t,
       
   795         const QPoint & pos,
       
   796         const QPoint & globalPos,
       
   797         const QPointF & hiResGlobalPos,
       
   798         int device,
       
   799         int pointerType,
       
   800         qreal pressure,
       
   801         int xTilt,
       
   802         int yTilt,
       
   803         qreal tangentialPressure,
       
   804         qreal rotation,
       
   805         int z,
       
   806         Qt::KeyboardModifiers keyState,
       
   807         qint64 uniqueID )
       
   808     :QInputEvent(t, keyState)
       
   809     //QInputEvent( /*t, pos, globalPos, hiResGlobalPos, device, pointerType, pressure, xTilt, yTilt, tangentialPressure, rotation, z, keyState, uniqueID*/ )
       
   810     {
       
   811     
       
   812     }
       
   813 
       
   814 
       
   815 // -----------------------------------------------------------------------------
       
   816 // QTabletEvent::~QTabletEvent
       
   817 // -----------------------------------------------------------------------------
       
   818 //
       
   819 QTabletEvent::~QTabletEvent(  )
       
   820     {
       
   821     
       
   822     }
       
   823 
       
   824 
       
   825 // -----------------------------------------------------------------------------
       
   826 // QDropEvent::QDropEvent
       
   827 // -----------------------------------------------------------------------------
       
   828 //
       
   829 QDropEvent::QDropEvent( 
       
   830         const QPoint & pos,
       
   831         Qt::DropActions actions,
       
   832         const QMimeData * data,
       
   833         Qt::MouseButtons buttons,
       
   834         Qt::KeyboardModifiers modifiers,
       
   835         Type type )
       
   836     :QEvent(type)
       
   837     //QEvent( /*pos, actions, data, buttons, modifiers, type*/ )
       
   838     {
       
   839     
       
   840     }
       
   841 
       
   842 
       
   843 // -----------------------------------------------------------------------------
       
   844 // QDropEvent::~QDropEvent
       
   845 // -----------------------------------------------------------------------------
       
   846 //
       
   847 QDropEvent::~QDropEvent(  )
       
   848     {
       
   849     
       
   850     }
       
   851 
       
   852 
       
   853 // -----------------------------------------------------------------------------
       
   854 // QDropEvent::setDropAction
       
   855 // -----------------------------------------------------------------------------
       
   856 //
       
   857 void QDropEvent::setDropAction( 
       
   858         Qt::DropAction act )
       
   859     {
       
   860     SMC_MOCK_METHOD1( void, Qt::DropAction, act )
       
   861     }
       
   862 
       
   863 
       
   864 // -----------------------------------------------------------------------------
       
   865 // QDropEvent::source
       
   866 // -----------------------------------------------------------------------------
       
   867 //
       
   868 QWidget * QDropEvent::source(  ) const
       
   869     {
       
   870     SMC_MOCK_METHOD0( QWidget * )
       
   871     }
       
   872 
       
   873 
       
   874 // -----------------------------------------------------------------------------
       
   875 // QDropEvent::format
       
   876 // -----------------------------------------------------------------------------
       
   877 //
       
   878 const char * QDropEvent::format( 
       
   879         int n ) const
       
   880     {
       
   881     SMC_MOCK_METHOD1( const char *, int, n )
       
   882     }
       
   883 
       
   884 
       
   885 // -----------------------------------------------------------------------------
       
   886 // QDropEvent::encodedData
       
   887 // -----------------------------------------------------------------------------
       
   888 //
       
   889 QByteArray QDropEvent::encodedData( 
       
   890         const char * ch) const
       
   891     {
       
   892     SMC_MOCK_METHOD1( QByteArray, const char *, ch )
       
   893     }
       
   894 
       
   895 
       
   896 // -----------------------------------------------------------------------------
       
   897 // QDropEvent::provides
       
   898 // -----------------------------------------------------------------------------
       
   899 //
       
   900 bool QDropEvent::provides( 
       
   901         const char * ch) const
       
   902     {
       
   903     SMC_MOCK_METHOD1( bool, const char *, ch )
       
   904     }
       
   905 
       
   906 
       
   907 // -----------------------------------------------------------------------------
       
   908 // QHoverEvent::QHoverEvent
       
   909 // -----------------------------------------------------------------------------
       
   910 //
       
   911 QHoverEvent::QHoverEvent( 
       
   912         Type type,
       
   913         const QPoint & pos,
       
   914         const QPoint & oldPos )
       
   915     :QEvent(type)
       
   916     //QEvent( /*type, pos, oldPos*/ )
       
   917     {
       
   918     
       
   919     }
       
   920 
       
   921 
       
   922 // -----------------------------------------------------------------------------
       
   923 // QHoverEvent::~QHoverEvent
       
   924 // -----------------------------------------------------------------------------
       
   925 //
       
   926 QHoverEvent::~QHoverEvent(  )
       
   927     {
       
   928     
       
   929     }
       
   930 
       
   931 
       
   932 // -----------------------------------------------------------------------------
       
   933 // QActionEvent::QActionEvent
       
   934 // -----------------------------------------------------------------------------
       
   935 //
       
   936 QActionEvent::QActionEvent( 
       
   937         int type,
       
   938         QAction * action,
       
   939         QAction * before )
       
   940     :QEvent(static_cast<QEvent::Type>(type))
       
   941     //QEvent( /*type, action, before*/ )
       
   942     {
       
   943     
       
   944     }
       
   945 
       
   946 
       
   947 // -----------------------------------------------------------------------------
       
   948 // QActionEvent::~QActionEvent
       
   949 // -----------------------------------------------------------------------------
       
   950 //
       
   951 QActionEvent::~QActionEvent(  )
       
   952     {
       
   953     
       
   954     }
       
   955 
       
   956 
       
   957 // -----------------------------------------------------------------------------
       
   958 // QDragLeaveEvent::QDragLeaveEvent
       
   959 // -----------------------------------------------------------------------------
       
   960 //
       
   961 QDragLeaveEvent::QDragLeaveEvent(  )
       
   962     :QEvent(DragLeave)
       
   963     //QEvent( /**/ )
       
   964     {
       
   965     
       
   966     }
       
   967 
       
   968 
       
   969 // -----------------------------------------------------------------------------
       
   970 // QDragLeaveEvent::~QDragLeaveEvent
       
   971 // -----------------------------------------------------------------------------
       
   972 //
       
   973 QDragLeaveEvent::~QDragLeaveEvent(  )
       
   974     {
       
   975     
       
   976     }
       
   977 
       
   978 
       
   979 // -----------------------------------------------------------------------------
       
   980 // QResizeEvent::QResizeEvent
       
   981 // -----------------------------------------------------------------------------
       
   982 //
       
   983 QResizeEvent::QResizeEvent( 
       
   984         const QSize & size,
       
   985         const QSize & oldSize )
       
   986     :QEvent(Resize)
       
   987     //QEvent( /*size, oldSize*/ )
       
   988     {
       
   989     
       
   990     }
       
   991 
       
   992 
       
   993 // -----------------------------------------------------------------------------
       
   994 // QResizeEvent::~QResizeEvent
       
   995 // -----------------------------------------------------------------------------
       
   996 //
       
   997 QResizeEvent::~QResizeEvent(  )
       
   998     {
       
   999     
       
  1000     }
       
  1001 
       
  1002 
       
  1003 // -----------------------------------------------------------------------------
       
  1004 // QDragResponseEvent::QDragResponseEvent
       
  1005 // -----------------------------------------------------------------------------
       
  1006 //
       
  1007 QDragResponseEvent::QDragResponseEvent( 
       
  1008         bool accepted )
       
  1009     :QEvent(DragResponse)
       
  1010     //QEvent( /*accepted*/ )
       
  1011     {
       
  1012     
       
  1013     }
       
  1014 
       
  1015 
       
  1016 // -----------------------------------------------------------------------------
       
  1017 // QDragResponseEvent::~QDragResponseEvent
       
  1018 // -----------------------------------------------------------------------------
       
  1019 //
       
  1020 QDragResponseEvent::~QDragResponseEvent(  )
       
  1021     {
       
  1022     
       
  1023     }
       
  1024 
       
  1025 
       
  1026 // -----------------------------------------------------------------------------
       
  1027 // QInputEvent::QInputEvent
       
  1028 // -----------------------------------------------------------------------------
       
  1029 //
       
  1030 QInputEvent::QInputEvent( 
       
  1031         Type type,
       
  1032         Qt::KeyboardModifiers modifiers )
       
  1033     :QEvent(type)
       
  1034     //QEvent( /*type, modifiers*/ )
       
  1035     {
       
  1036     
       
  1037     }
       
  1038 
       
  1039 
       
  1040 // -----------------------------------------------------------------------------
       
  1041 // QInputEvent::~QInputEvent
       
  1042 // -----------------------------------------------------------------------------
       
  1043 //
       
  1044 QInputEvent::~QInputEvent(  )
       
  1045     {
       
  1046     
       
  1047     }
       
  1048 
       
  1049 
       
  1050 // -----------------------------------------------------------------------------
       
  1051 // QWhatsThisClickedEvent::QWhatsThisClickedEvent
       
  1052 // -----------------------------------------------------------------------------
       
  1053 //
       
  1054 QWhatsThisClickedEvent::QWhatsThisClickedEvent( 
       
  1055         const QString & href )
       
  1056     :QEvent(WhatsThisClicked)
       
  1057     //QEvent( /*href*/ )
       
  1058     {
       
  1059     
       
  1060     }
       
  1061 
       
  1062 
       
  1063 // -----------------------------------------------------------------------------
       
  1064 // QWhatsThisClickedEvent::~QWhatsThisClickedEvent
       
  1065 // -----------------------------------------------------------------------------
       
  1066 //
       
  1067 QWhatsThisClickedEvent::~QWhatsThisClickedEvent(  )
       
  1068     {
       
  1069     
       
  1070     }
       
  1071 
       
  1072 
       
  1073 // -----------------------------------------------------------------------------
       
  1074 // QShortcutEvent::QShortcutEvent
       
  1075 // -----------------------------------------------------------------------------
       
  1076 //
       
  1077 QShortcutEvent::QShortcutEvent( 
       
  1078         const QKeySequence & key,
       
  1079         int id,
       
  1080         bool ambiguous )
       
  1081     :QEvent(Shortcut)
       
  1082     //QEvent( /*key, id, ambiguous*/ )
       
  1083     {
       
  1084     
       
  1085     }
       
  1086 
       
  1087 
       
  1088 // -----------------------------------------------------------------------------
       
  1089 // QShortcutEvent::~QShortcutEvent
       
  1090 // -----------------------------------------------------------------------------
       
  1091 //
       
  1092 QShortcutEvent::~QShortcutEvent(  )
       
  1093     {
       
  1094     
       
  1095     }
       
  1096 
       
  1097 
       
  1098 // -----------------------------------------------------------------------------
       
  1099 // QMouseEvent::QMouseEvent
       
  1100 // -----------------------------------------------------------------------------
       
  1101 //
       
  1102 QMouseEvent::QMouseEvent( 
       
  1103         Type type,
       
  1104         const QPoint & pos,
       
  1105         Qt::MouseButton button,
       
  1106         Qt::MouseButtons buttons,
       
  1107         Qt::KeyboardModifiers modifiers )
       
  1108     :QInputEvent(type, modifiers)
       
  1109     //QInputEvent( /*type, pos, button, buttons, modifiers*/ )
       
  1110     {
       
  1111     
       
  1112     }
       
  1113 
       
  1114 
       
  1115 // -----------------------------------------------------------------------------
       
  1116 // QMouseEvent::QMouseEvent
       
  1117 // -----------------------------------------------------------------------------
       
  1118 //
       
  1119 QMouseEvent::QMouseEvent( 
       
  1120         Type type,
       
  1121         const QPoint & pos,
       
  1122         const QPoint & globalPos,
       
  1123         Qt::MouseButton button,
       
  1124         Qt::MouseButtons buttons,
       
  1125         Qt::KeyboardModifiers modifiers )
       
  1126     :QInputEvent(type, modifiers)
       
  1127     //QInputEvent( /*type, pos, globalPos, button, buttons, modifiers*/ )
       
  1128     {
       
  1129     
       
  1130     }
       
  1131 
       
  1132 
       
  1133 // -----------------------------------------------------------------------------
       
  1134 // QMouseEvent::~QMouseEvent
       
  1135 // -----------------------------------------------------------------------------
       
  1136 //
       
  1137 QMouseEvent::~QMouseEvent(  )
       
  1138     {
       
  1139     
       
  1140     }
       
  1141 
       
  1142 
       
  1143 // -----------------------------------------------------------------------------
       
  1144 // QMouseEvent::createExtendedMouseEvent
       
  1145 // -----------------------------------------------------------------------------
       
  1146 //
       
  1147 QMouseEvent * QMouseEvent::createExtendedMouseEvent( 
       
  1148         Type type,
       
  1149         const QPointF & pos,
       
  1150         const QPoint & globalPos,
       
  1151         Qt::MouseButton button,
       
  1152         Qt::MouseButtons buttons,
       
  1153         Qt::KeyboardModifiers modifiers )
       
  1154     {
       
  1155     /*SMC_MOCK_METHOD6( QMouseEvent *, Type, type, 
       
  1156         const QPointF &, pos, 
       
  1157         const QPoint &, globalPos, 
       
  1158         Qt::MouseButton, button, 
       
  1159         Qt::MouseButtons, buttons, 
       
  1160         Qt::KeyboardModifiers, modifiers )*/
       
  1161     }
       
  1162 
       
  1163 
       
  1164 // -----------------------------------------------------------------------------
       
  1165 // QMouseEvent::posF
       
  1166 // -----------------------------------------------------------------------------
       
  1167 //
       
  1168 QPointF QMouseEvent::posF(  ) const
       
  1169     {
       
  1170     SMC_MOCK_METHOD0( QPointF )
       
  1171     }
       
  1172 
       
  1173 
       
  1174 // -----------------------------------------------------------------------------
       
  1175 // QFocusEvent::QFocusEvent
       
  1176 // -----------------------------------------------------------------------------
       
  1177 //
       
  1178 QFocusEvent::QFocusEvent( 
       
  1179         Type type,
       
  1180         Qt::FocusReason reason )
       
  1181     :QEvent(type)
       
  1182     //QEvent( /*type, reason*/ )
       
  1183     {
       
  1184     
       
  1185     }
       
  1186 
       
  1187 
       
  1188 // -----------------------------------------------------------------------------
       
  1189 // QFocusEvent::~QFocusEvent
       
  1190 // -----------------------------------------------------------------------------
       
  1191 //
       
  1192 QFocusEvent::~QFocusEvent(  )
       
  1193     {
       
  1194     
       
  1195     }
       
  1196 
       
  1197 
       
  1198 // -----------------------------------------------------------------------------
       
  1199 // QFocusEvent::reason
       
  1200 // -----------------------------------------------------------------------------
       
  1201 //
       
  1202 Qt::FocusReason QFocusEvent::reason(  )
       
  1203     {
       
  1204     SMC_MOCK_METHOD0( Qt::FocusReason )
       
  1205     }
       
  1206 
       
  1207 
       
  1208 // -----------------------------------------------------------------------------
       
  1209 // QFocusEvent::reason
       
  1210 // -----------------------------------------------------------------------------
       
  1211 //
       
  1212 Qt::FocusReason QFocusEvent::reason(  ) const
       
  1213     {
       
  1214     SMC_MOCK_METHOD0( Qt::FocusReason )
       
  1215     }
       
  1216 
       
  1217 
       
  1218 // -----------------------------------------------------------------------------
       
  1219 // QTouchEvent::QTouchEvent
       
  1220 // -----------------------------------------------------------------------------
       
  1221 //
       
  1222 QTouchEvent::QTouchEvent( 
       
  1223         QEvent::Type eventType,
       
  1224         QTouchEvent::DeviceType deviceType,
       
  1225         Qt::KeyboardModifiers modifiers,
       
  1226         Qt::TouchPointStates touchPointStates,
       
  1227         const QList<QTouchEvent::TouchPoint> & touchPoints )
       
  1228     :QInputEvent(eventType, modifiers)
       
  1229     //QInputEvent( /*eventType, deviceType, modifiers, touchPointStates, touchPoints*/ )
       
  1230     {
       
  1231     
       
  1232     }
       
  1233 
       
  1234 
       
  1235 // -----------------------------------------------------------------------------
       
  1236 // QTouchEvent::~QTouchEvent
       
  1237 // -----------------------------------------------------------------------------
       
  1238 //
       
  1239 QTouchEvent::~QTouchEvent(  )
       
  1240     {
       
  1241     
       
  1242     }
       
  1243 
       
  1244 
       
  1245 // -----------------------------------------------------------------------------
       
  1246 // QCloseEvent::QCloseEvent
       
  1247 // -----------------------------------------------------------------------------
       
  1248 //
       
  1249 QCloseEvent::QCloseEvent(  )
       
  1250     :QEvent(Close)
       
  1251     //QEvent( /**/ )
       
  1252     {
       
  1253     
       
  1254     }
       
  1255 
       
  1256 
       
  1257 // -----------------------------------------------------------------------------
       
  1258 // QCloseEvent::~QCloseEvent
       
  1259 // -----------------------------------------------------------------------------
       
  1260 //
       
  1261 QCloseEvent::~QCloseEvent(  )
       
  1262     {
       
  1263     
       
  1264     }
       
  1265 
       
  1266 
       
  1267 // -----------------------------------------------------------------------------
       
  1268 // QWindowStateChangeEvent::QWindowStateChangeEvent
       
  1269 // -----------------------------------------------------------------------------
       
  1270 //
       
  1271 QWindowStateChangeEvent::QWindowStateChangeEvent( 
       
  1272         Qt::WindowStates aOldState )
       
  1273     :QEvent(WindowStateChange)
       
  1274     //QEvent( /*aOldState*/ )
       
  1275     {
       
  1276     
       
  1277     }
       
  1278 
       
  1279 
       
  1280 // -----------------------------------------------------------------------------
       
  1281 // QWindowStateChangeEvent::QWindowStateChangeEvent
       
  1282 // -----------------------------------------------------------------------------
       
  1283 //
       
  1284 QWindowStateChangeEvent::QWindowStateChangeEvent( 
       
  1285         Qt::WindowStates aOldState,
       
  1286         bool isOverride )
       
  1287     :QEvent(WindowStateChange)
       
  1288     //QEvent( /*aOldState, isOverride*/ )
       
  1289     {
       
  1290     
       
  1291     }
       
  1292 
       
  1293 
       
  1294 // -----------------------------------------------------------------------------
       
  1295 // QWindowStateChangeEvent::~QWindowStateChangeEvent
       
  1296 // -----------------------------------------------------------------------------
       
  1297 //
       
  1298 QWindowStateChangeEvent::~QWindowStateChangeEvent(  )
       
  1299     {
       
  1300     
       
  1301     }
       
  1302 
       
  1303 
       
  1304 // -----------------------------------------------------------------------------
       
  1305 // QWindowStateChangeEvent::isOverride
       
  1306 // -----------------------------------------------------------------------------
       
  1307 //
       
  1308 bool QWindowStateChangeEvent::isOverride(  ) const
       
  1309     {
       
  1310     SMC_MOCK_METHOD0( bool )
       
  1311     }
       
  1312 
       
  1313 
       
  1314 // -----------------------------------------------------------------------------
       
  1315 // QShowEvent::QShowEvent
       
  1316 // -----------------------------------------------------------------------------
       
  1317 //
       
  1318 QShowEvent::QShowEvent(  )
       
  1319     :QEvent(Show)
       
  1320     //QEvent( /**/ )
       
  1321     {
       
  1322     
       
  1323     }
       
  1324 
       
  1325 
       
  1326 // -----------------------------------------------------------------------------
       
  1327 // QShowEvent::~QShowEvent
       
  1328 // -----------------------------------------------------------------------------
       
  1329 //
       
  1330 QShowEvent::~QShowEvent(  )
       
  1331     {
       
  1332     
       
  1333     }
       
  1334 
       
  1335