diff --git a/web/source/keymanweb.ts b/web/source/keymanweb.ts index 318bde58f1..cf064c8235 100644 --- a/web/source/keymanweb.ts +++ b/web/source/keymanweb.ts @@ -1695,7 +1695,7 @@ if(!window['keyman']['initialized']) { if(keymanweb.isAttached(Pelem)) { // Only operate on attached elements! if(keymanweb._LastActiveElement == Pelem || keymanweb._LastActiveElement == Pelem['kmw_ip']) { keymanweb._LastActiveElement = null; - keymanweb.setActiveKeyboard(keymanweb.globalKeyboard, keymanweb.globalLanguageCode); + keymanweb.keyboardManager.setActiveKeyboard(keymanweb.globalKeyboard, keymanweb.globalLanguageCode); keymanweb['osk']._Hide(); } @@ -1786,7 +1786,7 @@ if(!window['keyman']['initialized']) { && keymanweb._LastActiveElement) { if(Pkbd != null && Plc != null) { // Second part necessary for Closure. - keymanweb.setActiveKeyboard(Pkbd, Plc); + keymanweb.keyboardManager.setActiveKeyboard(Pkbd, Plc); } } } @@ -2002,10 +2002,10 @@ if(!window['keyman']['initialized']) { */ keymanweb._FocusKeyboardSettings = function(blockGlobalChange) { if(keymanweb._LastActiveElement._kmwAttachment.keyboard != null) { - keymanweb.setActiveKeyboard(keymanweb._LastActiveElement._kmwAttachment.keyboard, + keymanweb.keyboardManager.setActiveKeyboard(keymanweb._LastActiveElement._kmwAttachment.keyboard, keymanweb._LastActiveElement._kmwAttachment.languageCode); } else if(!blockGlobalChange) { - keymanweb.setActiveKeyboard(keymanweb.globalKeyboard, keymanweb.globalLanguageCode); + keymanweb.keyboardManager.setActiveKeyboard(keymanweb.globalKeyboard, keymanweb.globalLanguageCode); } } @@ -2170,85 +2170,6 @@ if(!window['keyman']['initialized']) { var p={}; p['target']=_target; p['activeControl']=_activeControl; return util.callEvent('kmw.controlfocused',p); } - - /** - * Execute external (UI) code needed on registering keyboard, used - * to update each UIs language menu - * - * Note that the argument object is not at present used by any UI, - * since the menu is always fully recreated when needed, but the arguments - * remain defined to allow for possible use in future (Aug 2014) - * - * @param {string} _internalName - * @param {string} _language - * @param {string} _keyboardName - * @param {string} _languageCode - * @param {string=} _packageID Used by KMEA/KMEI to track .kmp related info. - * @return {boolean} - */ - keymanweb.doKeyboardRegistered = function(_internalName,_language,_keyboardName,_languageCode, _packageID) - { - var p={'internalName':_internalName,'language':_language,'keyboardName':_keyboardName,'languageCode':_languageCode}; - - // Utilized only by our embedded codepaths. - if(_packageID) { - p['package'] = _packageID; - } - return util.callEvent('kmw.keyboardregistered',p); - } - - /** - * Execute external (UI) code to rebuild menu when deregistering keyboard - * - * @return {boolean} - */ - - keymanweb.doKeyboardUnregistered = function() - { - var p={}; - return util.callEvent('kmw.keyboardregistered',p); - } - - /** - * Execute external (UI) code needed on loading keyboard - * - * @param {string} _internalName - * @return {boolean} - */ - keymanweb.doKeyboardLoaded = function(_internalName) - { - var p={}; p['keyboardName']=_internalName; - return util.callEvent('kmw.keyboardloaded',p); - } - - /** - * Function doBeforeKeyboardChange - * Scope Private - * @param {string} _internalName - * @param {string} _languageCode - * @return {boolean} - * Description Execute external (UI) code needed before changing keyboard - */ - keymanweb.doBeforeKeyboardChange = function(_internalName,_languageCode) - { - var p={}; p['internalName']=_internalName; p['languageCode']=_languageCode; - return util.callEvent('kmw.beforekeyboardchange',p); - } - - /** - * Execute external (UI) code needed *after* changing keyboard - * - * @param {string} _internalName - * @param {string} _languageCode - * @param {boolean=} _indirect - * @return {boolean} - */ - keymanweb.doKeyboardChange = function(_internalName,_languageCode,_indirect) - { - var p={}; p['internalName']=_internalName; p['languageCode']=_languageCode; - p['indirect']=(arguments.length > 2 ? _indirect : false); - return util.callEvent('kmw.keyboardchange',p); - } /** * Function doUnloadOSK @@ -2933,19 +2854,8 @@ if(!window['keyman']['initialized']) { * @param {string} PInternalName Internal name * @param {string} PLgCode Language code */ - keymanweb['setActiveKeyboard'] = keymanweb.setActiveKeyboard = function(PInternalName,PLgCode) { - //TODO: This does not make sense: the callbacks should be in _SetActiveKeyboard, not here, - // since this is always called FROM the UI, which should not need notification. - // If UI callbacks are needed at all, they should be within _SetActiveKeyboard - keymanweb.doBeforeKeyboardChange(PInternalName,PLgCode); - keymanweb.keyboardManager._SetActiveKeyboard(PInternalName,PLgCode,true); - if(keymanweb._LastActiveElement != null) keymanweb._FocusLastActiveElement(); - // If we ever allow PLgCode to be set by default, we can auto-detect the language code - // after the _SetActiveKeyboard call. - // if(!PLgCode && (keymanweb).keyboardManager.activeStub) { - // PLgCode = (keymanweb).keyboardManager.activeStub['KLC']; - // } - keymanweb.doKeyboardChange(PInternalName,PLgCode); + keymanweb['setActiveKeyboard'] = function(PInternalName,PLgCode) { + keymanweb.keyboardManager.setActiveKeyboard(PInternalName,PLgCode); } /** diff --git a/web/source/kmwkeyboards.ts b/web/source/kmwkeyboards.ts index 712774ae9e..619db478c5 100644 --- a/web/source/kmwkeyboards.ts +++ b/web/source/kmwkeyboards.ts @@ -267,7 +267,7 @@ class KeyboardManager { } // Update the UI - (this.keymanweb).doKeyboardRegistered(sp['KI'],sp['KL'],sp['KN'],sp['KLC'],sp['KP']); + this.doKeyboardRegistered(sp['KI'],sp['KL'],sp['KN'],sp['KLC'],sp['KP']); } /** @@ -299,6 +299,29 @@ class KeyboardManager { } } + /** + * Allow to change active keyboard by (internal) keyboard name + * + * @param {string} PInternalName Internal name + * @param {string} PLgCode Language code + */ + setActiveKeyboard(PInternalName: string, PLgCode: string) { + //TODO: This does not make sense: the callbacks should be in _SetActiveKeyboard, not here, + // since this is always called FROM the UI, which should not need notification. + // If UI callbacks are needed at all, they should be within _SetActiveKeyboard + this.doBeforeKeyboardChange(PInternalName,PLgCode); + this._SetActiveKeyboard(PInternalName,PLgCode,true); + if(this.keymanweb._LastActiveElement != null) { + (this.keymanweb)._FocusLastActiveElement(); + } + // If we ever allow PLgCode to be set by default, we can auto-detect the language code + // after the _SetActiveKeyboard call. + // if(!PLgCode && (keymanweb).keyboardManager.activeStub) { + // PLgCode = (keymanweb).keyboardManager.activeStub['KLC']; + // } + this.doKeyboardChange(PInternalName, PLgCode); + } + /** * Change active keyboard to keyboard selected by (internal) name and language code * @@ -532,7 +555,7 @@ class KeyboardManager { //Activate keyboard, if it's still the active stub. if(kbdStub == manager.activeStub) { - (manager.keymanweb).doBeforeKeyboardChange(kbd['KI'],kbdStub['KLC']); + manager.doBeforeKeyboardChange(kbd['KI'],kbdStub['KLC']); manager.activeKeyboard=kbd; if((manager.keymanweb)._LastActiveElement != null) { @@ -615,7 +638,7 @@ class KeyboardManager { this.keymanweb.globalKeyboard = t[0]; this.keymanweb.globalLanguageCode = t[1]; - (this.keymanweb).doKeyboardChange(t[0],t[1]); // And update the UI if necessary + this.doKeyboardChange(t[0],t[1]); // And update the UI if necessary } } @@ -1121,7 +1144,7 @@ class KeyboardManager { if(anyRemoved) { // Update the UI keyboard menu - (this.keymanweb).doKeyboardUnregistered(); + this.doKeyboardUnregistered(); } return success; @@ -1177,7 +1200,7 @@ class KeyboardManager { this.keyboards=(this.keymanweb)._push(this.keyboards, Pk); // Execute any external (UI) code needed after loading keyboard - (this.keymanweb).doKeyboardLoaded(Pk['KI']); + this.doKeyboardLoaded(Pk['KI']); // Restore the originally-active stub to its prior state. No need to change it permanently. this.activeStub = savedActiveStub; @@ -1235,9 +1258,92 @@ class KeyboardManager { // Reload this keyboard if it was the last active keyboard and // make any changes needed by UI for new keyboard stub // (Uncommented for Build 360) - (this.keymanweb).doKeyboardRegistered(Pstub['KI'],Pstub['KL'],Pstub['KN'],Pstub['KLC'],Pstub['KP']); + this.doKeyboardRegistered(Pstub['KI'],Pstub['KL'],Pstub['KN'],Pstub['KLC'],Pstub['KP']); return null; } + /* + * Last part - the events. + */ + + /** + * Execute external (UI) code needed on registering keyboard, used + * to update each UIs language menu + * + * Note that the argument object is not at present used by any UI, + * since the menu is always fully recreated when needed, but the arguments + * remain defined to allow for possible use in future (Aug 2014) + * + * @param {string} _internalName + * @param {string} _language + * @param {string} _keyboardName + * @param {string} _languageCode + * @param {string=} _packageID Used by KMEA/KMEI to track .kmp related info. + * @return {boolean} + */ + doKeyboardRegistered(_internalName: string, _language: string, _keyboardName: string, + _languageCode: string, _packageID?: string): boolean { + var p={'internalName':_internalName,'language':_language,'keyboardName':_keyboardName,'languageCode':_languageCode}; + + // Utilized only by our embedded codepaths. + if(_packageID) { + p['package'] = _packageID; + } + return this.keymanweb.util.callEvent('kmw.keyboardregistered',p); + } + + /** + * Execute external (UI) code to rebuild menu when deregistering keyboard + * + * @return {boolean} + */ + + doKeyboardUnregistered(): boolean { + var p={}; + return this.keymanweb.util.callEvent('kmw.keyboardregistered',p); + } + + /** + * Execute external (UI) code needed on loading keyboard + * + * @param {string} _internalName + * @return {boolean} + */ + doKeyboardLoaded(_internalName: string): boolean { + var p={}; + p['keyboardName']=_internalName; + return this.keymanweb.util.callEvent('kmw.keyboardloaded', p); + } + + /** + * Function doBeforeKeyboardChange + * Scope Private + * @param {string} _internalName + * @param {string} _languageCode + * @return {boolean} + * Description Execute external (UI) code needed before changing keyboard + */ + doBeforeKeyboardChange(_internalName: string, _languageCode: string): boolean { + var p={}; + p['internalName']=_internalName; + p['languageCode']=_languageCode; + return this.keymanweb.util.callEvent('kmw.beforekeyboardchange',p); + } + + /** + * Execute external (UI) code needed *after* changing keyboard + * + * @param {string} _internalName + * @param {string} _languageCode + * @param {boolean=} _indirect + * @return {boolean} + */ + doKeyboardChange(_internalName: string, _languageCode: string, _indirect?:boolean): boolean { + var p={}; + p['internalName']=_internalName; + p['languageCode']=_languageCode; + p['indirect']=(arguments.length > 2 ? _indirect : false); + return this.keymanweb.util.callEvent('kmw.keyboardchange', p); + } } \ No newline at end of file diff --git a/web/source/kmwutils.ts b/web/source/kmwutils.ts index d4d4c0ad2d..a6160f1795 100644 --- a/web/source/kmwutils.ts +++ b/web/source/kmwutils.ts @@ -219,7 +219,7 @@ class Util { * @return {boolean} * Description Invoke an event using any function with up to four arguments */ - callEvent(event: string, params: Object[]): boolean { + callEvent(event: string, params: Object|Object[]): boolean { if(typeof this.events[event] == 'undefined') { return true; }