36 #include "hbinputmodecache_p.h" 

    36 #include "hbinputmodecache_p.h"

    37 #include "hbinputbasepaths_p.h"

   163             prData->iPredictiveInputState = 0;

   175             prData->iPredictiveInputState = HbKeyboardSettingNone;

   341     if (predictiveInputStatus()) {

   357     if (activeKeyboard() & HbQwertyKeyboardMask) {

   342         setPredictiveInputStatus(0);

   358         setPredictiveInputStatus(HbKeyboardSettingQwerty, !predictiveInputStatus(HbKeyboardSettingQwerty));

   344         setPredictiveInputStatus(1);

   360         setPredictiveInputStatus(HbKeyboardSetting12key, !predictiveInputStatus(HbKeyboardSetting12key));

   367         connect(this, SIGNAL(predictiveInputStateChanged(int)), aObserver, SLOT(predictiveInputStateChanged(int)));

   388         connect(this, SIGNAL(predictiveInputStateChanged(HbKeyboardSettingFlags, bool)), aObserver, SLOT(predictiveInputStateChanged(HbKeyboardSettingFlags, bool)));

   383         disconnect(this, SIGNAL(predictiveInputStateChanged(int)), aObserver, SLOT(predictiveInputStateChanged(int)));

   411         disconnect(this, SIGNAL(predictiveInputStateChanged(HbKeyboardSettingFlags, bool)), aObserver, SLOT(predictiveInputStateChanged(HbKeyboardSettingFlags, bool)));

   503 Sets system wide input language. Will emit signal globalInputLanguageChanged.

   538 Sets system wide input language. Will emit signal globalInputLanguageChanged if language is changed.

   512         d->lock();

   547         bool notify = false;

   513         prData->iGlobalPrimaryInputLanguage = language;

   548         d->lock();

   514         d->unlock();

   549         if (prData->iGlobalPrimaryInputLanguage != language) {

   515         emit globalInputLanguageChanged(language);

   550             prData->iGlobalPrimaryInputLanguage = language;

   516     }

   551             notify = true;

   517 }

   552         }

   518 

   553         d->unlock();

   519 /*!

   554         if (notify) {

   520 Sets system wide secondary input language. Will emit signal globalSecondaryInputLanguageChanged.

   555             emit globalInputLanguageChanged(language);

   556         }

   557     }

   558 }

   559 

   560 /*!

   561 Sets system wide secondary input language. Will emit signal globalSecondaryInputLanguageChanged if language is changed.

   529         d->lock();

   570         bool notify = false;

   530         prData->iGlobalSecondaryInputLanguage = language;

   571         d->lock();

   531         d->unlock();

   572         if (prData->iGlobalSecondaryInputLanguage != language) {

   532         emit globalSecondaryInputLanguageChanged(language);

   573             prData->iGlobalSecondaryInputLanguage = language;

   533     }

   574             notify = true;

   534 }

   575         }

   535 

   576         d->unlock();

   536 /*!

   577         if (notify) {

   537 Sets active hardware keyboard type. Will emit signal activeHwKeyboardChanged.

   578             emit globalSecondaryInputLanguageChanged(language);

   579         }

   580     }

   581 }

   582 

   583 /*!

   584 Sets active hardware keyboard type. Will emit signal activeHwKeyboardChanged if keyboard is changed.

   549         d->lock();

   596         bool notify = false;

   550         prData->iHwKeyboard = keyboard;

   597         d->lock();

   551         d->unlock();

   598         if (prData->iHwKeyboard != keyboard) {

   552         emit activeHwKeyboardChanged(keyboard);

   599             prData->iHwKeyboard = keyboard;

   553     }

   600             notify = true;

   554 }

   601         }

   555 

   602         d->unlock();

   556 /*!

   603         if (notify) {

   557 Sets active touch keyboard type. Will emit signal activeTouchKeyboardChanged.

   604             emit activeHwKeyboardChanged(keyboard);

   605         }

   606     }

   607 }

   608 

   609 /*!

   610 Sets active touch keyboard type. Will emit signal activeTouchKeyboardChanged keyboard is changed.

   569         d->lock();

   622         bool notify = false;

   570         prData->iTouchKeyboard = keyboard;

   623         d->lock();

   571         d->unlock();

   624         if (prData->iTouchKeyboard != keyboard) {

   572         emit activeTouchKeyboardChanged(keyboard);

   625             prData->iTouchKeyboard = keyboard;

   573     }

   626             notify = true;

   574 }

   627         }

   575 

   628         d->unlock();

   576 /*!

   629         if (notify) {

   577 Sets active keyboard type. Will emit signal activeKeyboardChanged.

   630             emit activeTouchKeyboardChanged(keyboard);

   631         }

   632     }

   633 }

   634 

   635 /*!

   636 Sets active keyboard type. Will emit signal activeKeyboardChanged if keyboard is changed.

   589         d->lock();

   648         bool notify = false;

   590         prData->iActiveKeyboard = keyboard;

   649         d->lock();

   591         d->unlock();

   650         if (prData->iActiveKeyboard != keyboard) {

   592         emit activeKeyboardChanged(keyboard);

   651             prData->iActiveKeyboard = keyboard;

   593     }

   652             notify = true;

   594 }

   653         }

   595 

   654         d->unlock();

   596 /*!

   655         if (notify) {

   597 Returns the status of predictive input feature. An editor instance

   656             emit activeKeyboardChanged(keyboard);

   657         }

   658     }

   659 }

   660 

   661 /*!

   662 \deprecated HbInputSettingProxy::predictiveInputStatus()

   663     is deprecated. Use predictiveInputStatusForITUT or predictiveInputStatusForQwerty instead.

   664 */

   665 int HbInputSettingProxy::predictiveInputStatus() const

   666 {

   667     return predictiveInputStatusForActiveKeyboard();

   668 }

   669 

   670 /*!

   671 \deprecated HbInputSettingProxy::setPredictiveInputStatus(int newStatus)

   672     is deprecated. Use setPredictiveInputStatusForITUT or setPredictiveInputStatusForQwerty instead.

   673 */

   674 void HbInputSettingProxy::setPredictiveInputStatus(int newStatus)

   675 {

   676     setPredictiveInputStatusForActiveKeyboard(newStatus);

   677 }

   678 

   679 /*!

   680 Returns the status of predictive input feature. Returns true if any one of given

   681 keyboard types has the prediction enabled. An editor instance may still forbid

   682 predictive input feature, even if the device wide status allows it.

   683 

   684 \sa setPredictiveInputStatus.

   685 */

   686 bool HbInputSettingProxy::predictiveInputStatus(HbKeyboardSettingFlags keyboardType) const

   687 {

   688     Q_D(const HbInputSettingProxy);

   689     bool res = false;

   690 

   691     HbSettingProxyInternalData* prData = d->proxyData();

   692     if (prData) {

   693         res = prData->iPredictiveInputState & keyboardType;

   694     }

   695 

   696     return res;

   697 }

   698 

   699 /*!

   700 Sets the status of predictive text input feature. Will emit signal predictiveInputStateChanged if status is changed.

   701 

   702 \sa predictiveInputStatus

   703 */

   704 void HbInputSettingProxy::setPredictiveInputStatus(HbKeyboardSettingFlags keyboardType, bool newStatus)

   705 {

   706     Q_D(HbInputSettingProxy);

   707     HbSettingProxyInternalData* prData = d->proxyData();

   708     if (prData) {

   709         bool notify = false;

   710         d->lock();

   711         

   712         HbKeyboardSettingFlags newValue = prData->iPredictiveInputState;

   713         if (newStatus) {

   714             newValue |= keyboardType;

   715         } else {

   716             newValue &= ~keyboardType;

   717         }

   718         if (prData->iPredictiveInputState != newValue) {

   719             prData->iPredictiveInputState = newValue;

   720             notify = true;

   721         }

   722         d->unlock();

   723         if (notify) {

   724             emit predictiveInputStateChanged(keyboardType, newStatus);

   725         }

   726     }

   727 }

   728 

   729 /*!

   730 Returns the status of predictive input feature for active keyboard. An editor instance

   600 \sa setPredictiveInputStatus.

   733 \sa setPredictiveInputStatusForActiveKeyboard.

   601 */

   734 */

   602 int HbInputSettingProxy::predictiveInputStatus() const

   735 bool HbInputSettingProxy::predictiveInputStatusForActiveKeyboard() const

   603 {

   736 {

   604     Q_D(const HbInputSettingProxy);

   737     Q_D(const HbInputSettingProxy);

   605     int res = 0;

   738     bool res = false;

   606 

   739 

   607     HbSettingProxyInternalData* prData = d->proxyData();

   740     HbSettingProxyInternalData* prData = d->proxyData();

   608     if (prData) {

   741     if (prData) {

   609         res = prData->iPredictiveInputState;

   742         if (activeKeyboard() & HbQwertyKeyboardMask) {

   743             res = prData->iPredictiveInputState & HbKeyboardSettingQwerty;

   744         } else {

   745             res = prData->iPredictiveInputState & HbKeyboardSetting12key;

   746         }

   616 Sets the status of predictive text input feature.

   753 Sets the status of predictive text input feature for active keyboard.

   617 

   754 

   618 \sa predictiveInputStatus

   755 \sa predictiveInputStatusForActiveKeyboard

   619 */

   756 */

   620 void HbInputSettingProxy::setPredictiveInputStatus(int newStatus)

   757 void HbInputSettingProxy::setPredictiveInputStatusForActiveKeyboard(bool newStatus)

   621 {

   758 {

   622     Q_D(HbInputSettingProxy);

   759     if (activeKeyboard() & HbQwertyKeyboardMask) {

   623 

   760         setPredictiveInputStatus(HbKeyboardSettingQwerty, newStatus);

   624     if (newStatus != 0) {

   761     } else {

   625         newStatus = 1;

   762         setPredictiveInputStatus(HbKeyboardSetting12key, newStatus);

   626     }

   627 

   628     HbSettingProxyInternalData* prData = d->proxyData();

   629     if (prData) {

   630         d->lock();

   631         prData->iPredictiveInputState = newStatus;

   632         d->unlock();

   633         emit predictiveInputStateChanged(newStatus);

   772     d->lock();

   901     HbSettingProxyInternalData* prData = d->proxyData();

   773     HbSettingProxyInternalData* prData = d->proxyData();

   902     if (prData) {

   774     if (prData) {

   903         d->lock();

   775         prData->iDigitType = digitType;

   904         if (prData->iDigitType != digitType) {

   776     }

   905             prData->iDigitType = digitType;

   777     d->unlock();

   906         }

   907         d->unlock();

   908     }

   799 Sets automatic text casing for qwerty keyboards.

   930 Sets automatic text casing for qwerty keyboards. Will emit signal automaticTextCasingStateForQwertyChanged if status is changed.

   806     d->lock();

   937     HbSettingProxyInternalData* prData = d->proxyData();

   807     HbSettingProxyInternalData* prData = d->proxyData();

   938     if (prData) {

   808     if (prData) {

   939         bool notify = false;

   809         prData->iQwertyTextCasing = status;

   940         d->lock();

   810     }

   941         if (prData->iQwertyTextCasing != status) {

   811     d->unlock();

   942             prData->iQwertyTextCasing = status;

   812 }

   943             notify = true;

   813 

   944         }

   814 /*!

   945         d->unlock();

   815 Enables/Disables character preview in Qwerty keypad.

   946         if (notify) {

   947             emit automaticTextCasingStateForQwertyChanged(status);

   948         }

   949     }

   950     

   951 }

   952 

   953 /*!

   954 Enables/Disables character preview in Qwerty keypad. Will emit signal characterPreviewStateForQwertyChanged if status is changed.

   822 

   961     HbSettingProxyInternalData* prData = d->proxyData();

   823     d->lock();

   962     if (prData) {

   824     HbSettingProxyInternalData* prData = d->proxyData();

   963         bool notify = false;

   825     if (prData) {

   964         d->lock();

   826         prData->iQwertyCharacterPreview = previewEnabled;

   965         if (prData->iQwertyCharacterPreview != previewEnabled) {

   827     }

   966             prData->iQwertyCharacterPreview = previewEnabled;

   828     d->unlock();

   967             notify = true;

   968         }

   969         d->unlock();

   970         if (notify) {

   971             emit characterPreviewStateForQwertyChanged(previewEnabled);

   972         }

   973     }

   974     

  1010 Sets the status of regional input correction feature. 

  1156 Sets the status of regional input correction feature. Will emit signal regionalCorretionStatusChanged if status is changed.

  1019         d->lock();

  1165         bool notify = false;

  1020         prData->iRegionalCorrectionStatus = newStatus;

  1166         d->lock();

  1021         d->unlock();

  1167         if (prData->iRegionalCorrectionStatus != newStatus) {

  1022         emit regionalCorretionStatusChanged(newStatus);

  1168             prData->iRegionalCorrectionStatus = newStatus;

  1023     }

  1169             notify = true;

  1170         }

  1171         d->unlock();

  1172         if (notify) {

  1173             emit regionalCorretionStatusChanged(newStatus);

  1174         }

  1175     }

  1176 }

  1177 

  1178 /*!

  1179 Sets the keypress timeout value. Will emit signal keypressTimeoutChanged if timeout is changed.

  1180 

  1181 \sa keypressTimeout.

  1182 */

  1183 void HbInputSettingProxy::setKeypressTimeout(int timeout)

  1184 {

  1185     Q_D(HbInputSettingProxy);

  1186     HbSettingProxyInternalData* prData = d->proxyData();

  1187     if (prData) {

  1188         bool notify = false;

  1189         d->lock();

  1190         if (prData->iKeypressTimeout != timeout) {

  1191             prData->iKeypressTimeout = timeout;

  1192             notify = true;

  1193         }

  1194         d->unlock();

  1195         if (notify) {

  1196             emit keypressTimeoutChanged(timeout);

  1197         }

  1198     }

  1199 }

  1200 

  1201 /*!

  1202 Returns the keypress timeout value. 

  1203 

  1204 \sa setKeypressTimeout.

  1205 */

  1206 int HbInputSettingProxy::keypressTimeout() const

  1207 {

  1208     Q_D(const HbInputSettingProxy);

  1209     int res = 0;

  1210     HbSettingProxyInternalData* prData = d->proxyData();

  1211     if (prData) {

  1212         res = prData->iKeypressTimeout;

  1213     }

  1214     return res;

  1215 }

  1216 

  1217 /*!

  1218 Sets the autocompletion status. Will emit signal autocompletionStateChanged if status is changed.

  1219 

  1220 \sa isAutocompletionEnabled.

  1221 */

  1222 void HbInputSettingProxy::setAutocompletionStatus(HbKeyboardSettingFlags keyboardType, bool state)

  1223 {

  1224     Q_D(HbInputSettingProxy);

  1225     HbSettingProxyInternalData* prData = d->proxyData();

  1226     if (prData) {

  1227         bool notify = false;

  1228         d->lock();

  1229         HbKeyboardSettingFlags newValue = prData->iAutocompletion;

  1230         if (state) {

  1231             newValue |= keyboardType;

  1232         } else {

  1233             newValue &= ~keyboardType;

  1234         }

  1235         if (prData->iAutocompletion != newValue) {

  1236             prData->iAutocompletion = newValue;

  1237             notify = true;

  1238         }

  1239         d->unlock();

  1240         if (notify) {

  1241             emit autocompletionStateChanged(keyboardType, state);

  1242         }

  1243     }

  1244 }

  1245 

  1246 /*!

  1247 Returns the autocompletion status for ITUT. Returns true if any of given

  1248 keyboards have autocompletion enabled.

  1249 

  1250 \sa setAutocompletionStatus.

  1251 */

  1252 bool HbInputSettingProxy::isAutocompletionEnabled(HbKeyboardSettingFlags keyboardType) const

  1253 {

  1254     Q_D(const HbInputSettingProxy);

  1255     bool res = false;

  1256     HbSettingProxyInternalData* prData = d->proxyData();

  1257     if (prData) {

  1258         res = prData->iAutocompletion & keyboardType;

  1259     }

  1260     return res;

  1261 }

  1262 

  1263 /*!

  1264 Sets the typing correction level. Will emit signal typingCorrectionLevelChanged if level is changed.

  1265 

  1266 \sa typingCorrectionLevel.

  1267 */

  1268 void HbInputSettingProxy::setTypingCorrectionLevel(HbTypingCorrectionLevel level)

  1269 {

  1270     Q_D(HbInputSettingProxy);

  1271     HbSettingProxyInternalData* prData = d->proxyData();

  1272     if (prData) {

  1273         bool notify = false;

  1274         d->lock();

  1275         if (prData->iTypingCorrectionLevel != level) {

  1276             prData->iTypingCorrectionLevel = level;

  1277             notify = true;

  1278         }

  1279         d->unlock();

  1280         if (notify) {

  1281             emit typingCorrectionLevelChanged(level);

  1282         }

  1283         enableRegionalCorrection(level == HbTypingCorrectionLevelHigh);

  1284     }

  1285 }

  1286 

  1287 /*!

  1288 Returns the typing correction level

  1289 

  1290 \sa setTypingCorrectionLevel.

  1291 */

  1292 HbTypingCorrectionLevel HbInputSettingProxy::typingCorrectionLevel() const

  1293 {

  1294     Q_D(const HbInputSettingProxy);

  1295     HbTypingCorrectionLevel res = HbTypingCorrectionLevelHigh;

  1296     HbSettingProxyInternalData* prData = d->proxyData();

  1297     if (prData) {

  1298         res = prData->iTypingCorrectionLevel;

  1299     }

  1300     return res;

  1301 }

  1302 

  1303 /*!

  1304 Sets the primary candidate mode. Will emit signal primaryCandidateModeChanged if mode is changed.

  1305 

  1306 \sa primaryCandidateMode.

  1307 */

  1308 void HbInputSettingProxy::setPrimaryCandidateMode(HbPrimaryCandidateMode mode)

  1309 {

  1310     Q_D(HbInputSettingProxy);

  1311     HbSettingProxyInternalData* prData = d->proxyData();

  1312     if (prData) {

  1313         bool notify = false;

  1314         d->lock();

  1315         if (prData->iPrimaryCandidateMode != mode) {

  1316             prData->iPrimaryCandidateMode = mode;

  1317             notify = true;

  1318         }

  1319         d->unlock();

  1320         if (notify) {

  1321             emit primaryCandidateModeChanged(mode);

  1322         }

  1323     }

  1324 }

  1325 

  1326 /*!

  1327 Returns the primary candidate mode

  1328 

  1329 \sa setPrimaryCandidateMode.

  1330 */

  1331 HbPrimaryCandidateMode HbInputSettingProxy::primaryCandidateMode() const

  1332 {

  1333     Q_D(const HbInputSettingProxy);

  1334     HbPrimaryCandidateMode res = HbPrimaryCandidateModeExactTyping;

  1335     HbSettingProxyInternalData* prData = d->proxyData();

  1336     if (prData) {

  1337         res = prData->iPrimaryCandidateMode;

  1338     }

  1339     return res;