1 /*

     2  * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3  * All rights reserved.

     4  *

     5  * This program is free software: you can redistribute it and/or modify

     6  * it under the terms of the GNU Lesser General Public License as published by

     7  * the Free Software Foundation, version 2.1 of the License.

     8  * 

     9  * This program is distributed in the hope that it will be useful,

    10  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    12  * GNU Lesser General Public License for more details.

    13  *

    14  * You should have received a copy of the GNU Lesser General Public License

    15  * along with this program.  If not, 

    16  * see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/".

    17  *

    18  * Description:

    19  *

    20  */

    21 

    22 #include "capturerequest_s60.h"

    23 #include <w32std.h>

    24 #include "txlogger.h"

    25 

    26 #ifdef _XQKEYCAPTURE_UNITTEST_

    27     #include "tsrc\mytestwindowgroup.h"

    28 #endif

    29 

    30 CaptureRequest::CaptureRequest(TUint aKey, Qt::KeyboardModifiers aModifiersMask,

    31         Qt::KeyboardModifiers aModifier, CaptureRequestType aRequestType, 

    32         XQKeyCapture::LongFlags aLongKeyFlags, 

    33 #ifndef _XQKEYCAPTURE_UNITTEST_

    34     RWindowGroup* aGroup

    35 #else

    36     MyTestWindowGroup* aGroup

    37 #endif

    38 	):

    39     mKey(aKey), 

    40     mModifiersMask(aModifiersMask), 

    41     mModifier(aModifier), 

    42     mRequestType(aRequestType),

    43     longKeyFlags(aLongKeyFlags),

    44     mRequestHandle(-1), 

    45     mAdditionalRequestHandle(-1),

    46     mGroup(aGroup)  

    47 {

    48 }

    49 

    50 CaptureRequest::~CaptureRequest()

    51 {

    52 }

    53 

    54 int CaptureRequest::request()

    55 {

    56     TX_ENTRY

    57     int res(KErrNone);

    58     if (!mGroup) {

    59         res = KErrNotReady;

    60         TX_LOG_ARGS( QString("!mGroup"));

    61     } else {

    62         switch (mRequestType) {

    63         case CaptureRequestTypeNormal:

    64             mRequestHandle = mGroup->CaptureKey(mKey, translatedModifierMask(),

    65                 translatedModifier());

    66             TX_LOG_ARGS( QString("CaptureKey done"))

    67             break;

    68         case CaptureRequestTypeLong:

    69             mRequestHandle = mGroup->CaptureLongKey(mKey, mKey,

    70                 translatedModifierMask(), translatedModifier(), 0, longKeyFlags);

    71             TX_LOG_ARGS( QString("CaptureLongKey done"))

    72             break;

    73         case CaptureRequestTypeUpAndDown:

    74             mRequestHandle = mGroup->CaptureKeyUpAndDowns(mKey,

    75                 translatedModifierMask(), translatedModifier());

    76             TX_LOG_ARGS( QString("CaptureKeyUpAndDowns done"))

    77             break;

    78         default:

    79             res = KErrNotSupported;

    80             TX_LOG_ARGS( QString("request not done"))

    81             break;

    82         }

    83         

    84         if (mRequestHandle < 0){

    85             res = mRequestHandle;

    86         } else { // following probably is not needed, it could be used to capture Modifires keys as normal keys

    87             //In Qt you might request capture CTRL key, in symbian you have to capture Left and Right CTRL keys

    88             bool additionalAction = false;

    89             TUint additionalKey = 0;

    90             switch(mKey){

    91             case EKeyLeftShift:

    92                 additionalAction = true;

    93                 additionalKey = (mRequestType == CaptureRequestTypeUpAndDown) ? EStdKeyRightShift : EKeyRightShift;

    94                 break;

    95             case EKeyLeftCtrl:

    96                 additionalAction = true;

    97                 additionalKey = (mRequestType == CaptureRequestTypeUpAndDown) ? EStdKeyRightCtrl : EKeyRightCtrl;

    98                 break;

    99             case EKeyLeftFunc:

   100                 additionalAction = true;

   101                 additionalKey = (mRequestType == CaptureRequestTypeUpAndDown) ? EStdKeyRightFunc : EKeyRightFunc;

   102                 break;

   103             }

   104 

   105             if (additionalAction && additionalKey != 0) {

   106                 TX_LOG_ARGS( QString("additionalAction needed"));

   107                 switch (mRequestType) {

   108                 case CaptureRequestTypeNormal:

   109                     mAdditionalRequestHandle = mGroup->CaptureKey(additionalKey,

   110                         translatedModifierMask(), translatedModifier());

   111                     break;

   112                 case CaptureRequestTypeLong:

   113                     mAdditionalRequestHandle = mGroup->CaptureLongKey(additionalKey,

   114                         additionalKey, translatedModifierMask(), translatedModifier(), 0, longKeyFlags);

   115                     break;

   116                 case CaptureRequestTypeUpAndDown:

   117                     mAdditionalRequestHandle = mGroup->CaptureKeyUpAndDowns(additionalKey,

   118                         translatedModifierMask(), translatedModifier());

   119                     break;

   120                 default:

   121                     res = KErrNotSupported;

   122                     break;

   123                 }

   124                 if (mAdditionalRequestHandle < 0)

   125                     res = mAdditionalRequestHandle;

   126             }

   127         }

   128     }

   129     TX_EXIT

   130     return res;

   131 }

   132 

   133 int CaptureRequest::cancel()

   134 {

   135     TX_ENTRY

   136     int res(KErrNone);

   137     if (mRequestHandle < 0 || !mGroup) {

   138     res = KErrNotReady;

   139     } else {

   140     switch (mRequestType) {

   141         case CaptureRequestTypeNormal:

   142         mGroup->CancelCaptureKey(mRequestHandle);

   143         break;

   144         case CaptureRequestTypeLong:

   145         mGroup->CancelCaptureLongKey(mRequestHandle);

   146         break;

   147         case CaptureRequestTypeUpAndDown:

   148         mGroup->CancelCaptureKeyUpAndDowns(mRequestHandle);

   149         break;

   150         default:

   151         res = KErrNotSupported;

   152         break;

   153     }

   154     if (mAdditionalRequestHandle > -1) {

   155         switch (mRequestType) {

   156         case CaptureRequestTypeNormal:

   157             mGroup->CancelCaptureKey(mAdditionalRequestHandle);

   158             break;

   159         case CaptureRequestTypeLong:

   160             mGroup->CancelCaptureLongKey(mAdditionalRequestHandle);

   161             break;

   162         case CaptureRequestTypeUpAndDown:

   163             mGroup->CancelCaptureKeyUpAndDowns(mAdditionalRequestHandle);

   164             break;

   165         default:

   166             res = KErrNotSupported;

   167             break;

   168         }

   169     }

   170     }TX_EXIT

   171     return res;

   172 }

   173 

   174 bool CaptureRequest::operator==(const CaptureRequest& other) const

   175 {

   176     bool res = mKey == other.mKey && mModifiersMask == other.mModifiersMask && mModifier

   177         == other.mModifier && mRequestType == other.mRequestType;

   178     return res;

   179 }

   180 

   181 bool CaptureRequest::matches(TUint aKey, Qt::KeyboardModifiers aModifiersMask,

   182     Qt::KeyboardModifiers aModifier, CaptureRequestType aRequestType,

   183     XQKeyCapture::LongFlags captureLongFlag) const

   184 {

   185     bool res = mKey == aKey && mModifiersMask == aModifiersMask && mModifier == aModifier

   186         && mRequestType == aRequestType && 

   187             longKeyFlags == captureLongFlag;

   188     return res;

   189 }

   190 

   191 TUint CaptureRequest::translatedModifierMask()

   192 {

   193     TUint res = translatedModifier(mModifiersMask);

   194     return res;

   195 }

   196 

   197 TUint CaptureRequest::translatedModifier()

   198 {

   199     TUint res = translatedModifier(mModifier);

   200     return res;

   201 }

   202 

   203 TUint CaptureRequest::translatedModifier(Qt::KeyboardModifiers aModifier)

   204 {

   205     TUint res = 0;

   206     if (aModifier & Qt::ShiftModifier) {

   207         res |= EModifierShift;

   208     }

   209 

   210     if (aModifier & Qt::ControlModifier) {

   211         res |= EModifierCtrl;

   212     }

   213 

   214     if (aModifier & Qt::AltModifier) {

   215         res |= EModifierAlt;

   216     }

   217 

   218     if (aModifier & Qt::KeypadModifier) {

   219         res |= EModifierKeypad;

   220     }

   221     return res;

   222 }

   223