Ativando o Suporte do Teclado

Os usuários freqüentemente interagem com aplicativos host utilizando teclas especiais no teclado físico, como F1, Attn, Reset e Clear. Há maneiras diferentes pelas quais os usuários dos aplicativos do HATS podem enviar pressionamentos de tecla para o host:

Este capítulo explica como definir o suporte ao teclado no seu projeto HATS e contém sugestões para documentar o suporte ao teclado para seus usuários.

Para utilizar o suporte ao teclado nos projetos HATS da Web, você deve ter um navegador da Web suportado. Para obter uma lista de navegadores da Web suportados e limitações, consulte a seção de pré-requisitos do HATS do Centro de Informações do HATS no endereço http://publib.boulder.ibm.com/infocenter/hatshelp/v75/index.jsp.

Definindo o Suporte ao Teclado

Para configurar o suporte ao teclado em um projeto do HATS, você precisa ativar o suporte ao teclado em seu projeto. O suporte ao teclado pode ser ativado na guia Outro de suas Configurações de Projeto e selecionando as opções disponíveis. Para obter informações adicionais, consulte Suporte ao Teclado

Você também pode definir um teclado numérico do host e um teclado numérico do aplicativo. Consulte Teclado Numérico do Host e Teclado Numérico do Aplicativo para obter informações adicionais.

Alterando a Aparência dos Teclados Numéricos

Para projetos da Web do HATS, utilize as configurações Teclado Numérico do Host e Teclado Numérico do Aplicativo na guia Renderização das Configurações do Projeto para definir quais teclas exibir e se irá exibi-las como botões ou links. Consulte Teclado Numérico do Host e Teclado Numérico do Aplicativo para obter informações adicionais.

Para alterar o estilo de um teclado numérico para um projeto da Web do HATS específico, altere o cascading style sheet (arquivo .css) que corresponde ao teclado numérico. Esta será a folha de estilo que você utilizará quando construir seu projeto. No ambiente de trabalho do Rational SDP, vá para a visualização Projetos HATS do HATS Toolkit e expanda o nome do projeto. Expanda o Conteúdo da Web/Comum/Páginas de Estilo. Para obter informações adicionais, consulte Utilizando Folhas de Estilo.

Para modificar a folha de estilo, clique duas vezes no arquivo .css para abrir o editor. Lembre-se de que os modelos podem substituir as alterações nas folhas de estilo. Para obter informações adicionais sobre folhas de estilo em cascata, vá para http://www.w3.org/Style/CSS/.

A cascading style sheet define sete estilos:

table.HostKeypad
Segundo plano do teclado numérico do host
table.ApplicationKeypad
Segundo plano do teclado numérico do aplicativo
input.HostPFKey
Botões PF do teclado numérico do host
input.HostButton
Botões do teclado numérico do host
input.ApplicationButton
Botões do teclado numérico do aplicativo
a.HostKeyLink
Links do teclado numérico do host
a.ApplicationKeyLink
Links do teclado numérico do aplicativo

Para projetos rich client do HATS, utilize as configurações Teclado Numérico do Host na guia Renderização das Configurações do Projeto para definir quais teclas exibir e se irá exibi-las como botões ou links. Consulte Teclado Numérico do Host para obter informações adicionais. Utilize as configurações Teclado Numérico do Aplicativo na guia Renderização das Configurações do Projeto para definir quais botões no nível do aplicativo irá exibir. Utilize as configurações da Barra de Ferramentas na guia Renderização para definir se os botões no nível do aplicativo exibirão texto, uma imagem ou ambos. Consulte Teclado Numérico do Aplicativo e Barra de Ferramentas Apenas RCP  para obter informações adicionais.

Fornecendo Documentação para Usuários

Para facilitar o uso do seu aplicativo HATS, você pode desejar documentar as configurações de teclado para seus usuários -- seja na interface gráfica com o usuário do aplicativo ou em alguma outra forma facilmente exibida (talvez um link em seu modelo). Sua documentação deve descrever:

Tabela 5. Mapeamento de Teclas no HATS
Botão na Barra de Botões Mapeamento de Tecla Física Padrão
F1 - F12 F1 - F12
F13 - F24 Shift + F1 - F12
ENTER Inserir
LIMPAR Esc
RESET Ctrl + R
SYSREQ Shift + Esc
ATTN Pausa/Interrupção
PAGEUP Page Up
PAGEDN Page Down
PA1 Alt + Delete
PA2 Alt + End
PA3 Alt + Page Down
IMPRIMIR
Ctrl + P  Apenas Web 
Ctrl + Shift + P  Apenas RCP 
HELP Ctrl + H
Ativar/Desativar Teclado Ctrl + K
Padrão Alt + Insert
Atualizar Alt + Page Up
Reconfigurar Formulário HTML Ctrl + S
Desconectar Ctrl + D
Visualizar Tarefas de Impressão Ctrl + J
Reverso Alt + Enter
Saída do Campo
Shift + Enter  Apenas Web  Enter do Teclado Numérico
 Apenas RCP 
Nota:
Para obter informações adicionais, consulte Suporte à Tecla de Campo 5250 Especial.
Campo+
Ctrl + Mais do Teclado Numérico  Apenas Web  Mais do
Teclado Numérico  Apenas RCP 
Campo-
Ctrl + Menos do Teclado Numérico  Apenas Web  Menos do
Teclado Numérico  Apenas RCP 
Nota:
Para obter informações adicionais, consulte Suporte à Tecla de Campo 5250 Especial.
Nota:
Ctrl+R é mapeado para um RESET do host para sessões bidirecionais e não-bidirecionais e Alt+Enter é mapeado para reversão para sessões bidirecionais.

Suporte à Tecla de Campo 5250 Especial

Combinações de Pressionamento de Tecla de Campo Padrão

As combinações de pressionamento de tecla de campo padrão para os aplicativos da Web do HATS estão listadas abaixo. Para obter informações sobre como remapear o teclado, consulte Remapeando o Teclado em um Aplicativo HATS.

Saída de campo Rápido

O pressionamento de tecla Saída de Campo Rápido pode ser usado com aplicativos da Web do HATS para acelerar a entrada de dados numéricos para telas 5250. Esse pressionamento de tecla limpa o campo atual da posição dos sinais de intercalação atuais para o final do campo; e avança a posição do cursor para o próximo campo. Embora esse pressionamento de tecla possa ser usado em qualquer campo, é especialmente útil quando os usuários devem, de outro modo, usar uma Saída de Campo. Um verdadeiro pressionamento de tecla Saída de Campo envia a tela de dados para o host e faz com que a transformação do HATS seja reapresentada. Portanto, telas que exigem muitos auxílios de Saída de Campo antes de serem enviadas podem causar problemas de utilização. O pressionamento de tecla Saída de Campo Rápido, combinada com o recurso Emulação de Saída de Campo, aumenta consideravelmente a velocidade desses aplicativos.

Como os aplicativos rich client apresentam uma arquitetura diferente dos aplicativos da Web, um pressionamento de tecla Saída de Campo Rápido não é necessária. Não há atraso de roundtrip para uma Saída de Campo Verdadeira nos aplicativos rich client.

Menos de Campo Rápido

O pressionamento de tecla Menos de Campo Rápido pode ser usado com aplicativos da Web do HATS para acelerar a entrada de dados numéricos negativos para telas 5250. Esse pressionamento de tecla limpa o campo atual da posição dos sinais de intercalação atuais para o final do campo, incluí um caractere de sinal de menos (-) no início do valor do campo e avança a posição do cursor para o próximo campo. Embora esse pressionamento de tecla possa ser usado em qualquer campo, é útil apenas em campos numéricos atribuídos assinados 5250, quando usuários podem, de outro modo, usar um Menos Campo. Um verdadeiro pressionamento de tecla Menos de Campo envia a tela de dados para o host e faz com que a transformação seja reapresentada. Portanto, telas que exigem muitos auxílios de Menos de Campo antes de serem enviadas podem causar problemas de utilização. O pressionamento de tecla Menos de Campo Rápido, combinada com o forma alternativa para recursos para inserção de números negativos, aumenta consideravelmente a velocidade desses aplicativos. O uso do pressionamento de tecla Menos de Campo Rápido em campos que não os campos numéricos assinados 5250 pode causar a entrada de dados inadequados.

Como os aplicativos rich client apresentam uma arquitetura diferente dos aplicativos da Web, um pressionamento de tecla Menos de Campo Rápido não é necessária. Não há atraso de roundtrip para um Menos de Campo Verdadeira nos aplicativos rich client.

Forma Alternativa de Inserir Números Negativos

Para inserir um número negativo em um campo numérico assinado 5250, os usuários podem inserir um caractere de sina l de menos (-) na primeira posição do campo, ao invés de usar um Menos Campo e incorrer em uma roundtrip para o servidor. Isso permite uma entrada mais rápida de grandes quantidades de números negativos nos campos numéricos com sinal do 5250. O servidor do HATS emula um pressionamento de tecla Menos de Campo para cada campo numérico assinado 5250 inserido com um caractere de sinal de menos no início. É necessário limpar quaisquer dados previamente preenchidos indesejados no campo antes de tabular para um outro campo. Os usuários não devem inserir um sinal de menos na primeira posição e também pressionar Menos de Campo, Mais de Campo ou Saída de Campo.

Emulação de Saída do Campo

Este recurso fornece automaticamente uma tecla de auxílio Saída do Campo para o usuário, quando necessário. Uma tecla de auxílio Saída do Campo é necessária quando determinados tipos de campos 5250 são modificados.

Por exemplo, se um usuário estiver usando o pressionamento de tecla Saída de Campo Rápido para avançar de campo para campo e enviar a tela com uma tecla Enter ou alguma outra tecla de auxílio não pertencente ao campo, uma Saída de Campo pode ser necessária para o campo que contém o cursor quando a tela é enviada.

Nesse caso, se uma Saída de Campo necessária não é fornecida, o host pode responder com a mensagem de erro, Tecla Enter não permitida no campo. Com esse recurso do HATS, o servidor do HATS envia uma Saída de Campo para o host antes de enviar o Enter, evitando a mensagem de erro.

Se você deseja desativar esse recurso, inclua as seguintes instruções no arquivo application.hap:

<class name="com.ibm.hats.common.RuntimeSettings">
        <setting name="emulateFieldExit" value="false"/>
</class>

Se já houver uma seção <class> com esse nome, apenas inclua a linha <setting> dentro da seção.

Remapeando o Teclado em um Aplicativo HATS

Conceitos a Serem Entendidos Antes de Remapear as Teclas do HATS

Cada aplicativo do HATS integra o código do produto Host On Demand para manipular a conexão com o servidor Telnet em nome do cliente. Portanto, esse guia utiliza a terminologia do Host On-Demand para palavras-chave mnemônicas que podem ser enviadas ao computador host para representar o usuário que pressiona as teclas na sessão do host.

Palavras-chave Mnemônicas

Tabela de palavras-chave mnemônicas 3270 suportadas pelo HATS
Tabela 6. Palavras-chave Mnemônicas para SendKeys
Função Palavra-chave Mnemônica
Atenção [attn]
Alternar Visualização [altview]
Limpar [clear]
Inserir [enter]
F1 [pf1]
F2 [pf2]
F3 [pf3]
F4 [pf4]
F5 [pf5]
F6 [pf6]
F7 [pf7]
F8 [pf8]
F9 [pf9]
F10 [pf10]
F11 [pf11]
F12 [pf12]
F13 [pf13]
F14 [pf14]
F15 [pf15]
F16 [pf16]
F17 [pf17]
F18 [pf18]
F19 [pf19]
F20 [pf20]
F21 [pf21]
F22 [pf22]
F23 [pf23]
F24 [pf24]
Home [home]
PA1 [pa1]
PA2 [pa2]
PA3 [pa3]
Redefinir [reset]
Pedido do Sistema [sysreq]
Tabela de palavras-chave mnemônicas 5250 suportadas pelo HATS
Tabela 7. Palavras-chave Mnemônicas para SendKeys
Função Palavra-chave Mnemônica
Atenção [attn]
Alternar Visualização [altview]
Limpar [clear]
Inserir [enter]
F1 [pf1]
F2 [pf2]
F3 [pf3]
F4 [pf4]
F5 [pf5]
F6 [pf6]
F7 [pf7]
F8 [pf8]
F9 [pf9]
F10 [pf10]
F11 [pf11]
F12 [pf12]
F13 [pf13]
F14 [pf14]
F15 [pf15]
F16 [pf16]
F17 [pf17]
F18 [pf18]
F19 [pf19]
F20 [pf20]
F21 [pf21]
F22 [pf22]
F23 [pf23]
F24 [pf24]
Saída do Campo [fldext]
Campo+ [field+]
Campo- [field-]
Ajuda [help]
PA1 [pa1]
PA2 [pa2]
PA3 [pa3]
Pedido do Sistema [sysreq]
Page Up [pageup]
Page Down [pagedn]
Saída de campo Rápido [qfldext]
Menos de Campo Rápido [qfld-]
Redefinir [reset]
Pedido do Sistema [sysreq]
Pedido de Teste [test]

Determinando Valores do Código-Chave

Para determinar o valor do código-chave para uma determinada tecla no teclado, salve o seguinte código HTML em um arquivo e abra-o em uma janela do navegador Internet Explorer. O valor do código-chave é exibido para qualquer tecla pressionada nesse navegador.

<html>
<head>
<script>
document.onkeydown = keydownhandler;
function keydownhandler()
{
	document.testform.displayField.value = "Keycode: " + window.event.keyCode;
}
</script>
</head>
<body>
	<center>
		<form name="testform">
			<input type="text" name="displayField" value="Hit any key">
		</form>
	</center>
</body>
</html>

Remapeando Teclas para Aplicativos da Web do HATS

Em cada aplicativo da Web do HATS existe um arquivo chamado KBS.js que determina como os valores do código chave gerados pelo teclado dos usuários são mapeados para os sinais de tecla enviados à sessão do host. Para remapear o teclado do HATS, você deve editar o arquivo KBS.js. Para localizar o KBS.js, vá para a exibição Navigator, em seguida, veja no diretório nome_do_projeto/Web Content/Common. Existem três valores no KBS.js que determinam o relacionamento entre qualquer tecla no teclado sendo pressionada e qual sinal é então enviado ao host. Esses três valores são:

  1. O valor do código-chave para a tecla pressionada, representado como uma variável de número inteiro no arquivo KBS.js. Por exemplo,
    var CODE_F2        = 113; 
    para a tecla F2,
  2. A combinação do valor do código-chave e os estados de Alt, Ctrl e Shift do teclado e
  3. A palavra-chave mnemônica do Host On-Demand enviada para o valor de combinação do código-chave e os estados de Alt, Ctrl e Shift. Por exemplo,
    [CODE_F2, 0, 0, 0, '[pf2]']
    envia o sinal de tecla pf2 ao host quando a tecla F2 é pressionada no teclado do usuário.

Para alterar os mapeamentos de teclas em seu aplicativo da Web do HATS, é possível alterar ou incluir combinações permitindo que teclas novas ou existentes enviem a palavra-chave mnemônica.

Saiba que você não pode remapear as teclas modificadoras Ctrl, Alt e Shift. O HATS utiliza JavaScript™ e o JavaScript não considera essas teclas como pressionamentos de teclas, mas como modificadores.

Para remapear teclas nos aplicativos da Web do HATS, basta modificar as variáveis keycode e defaultKeyMappings na parte superior do arquivo KBS.js.

Nota:
Existem dependências entre as teclas listadas no arquivo KBS.js, o estado do Suporte ao Teclado das Configurações do Projeto e a presença ou ausência de quaisquer botões de tecla listados na tela. As regras que regem essas dependências estão listadas abaixo.

  1. O suporte ao teclado pode ser configurado utilizando as definições de nível do projeto para especificar se ele deve seguir regras do HATS V5 ou anterior ou se deve suportar todas as teclas mapeadas, independentemente de quais botões ou links são exibidos. Para modificar estas configurações, vá para a visualização Projetos HATS e dê um clique duplo em Configurações de Projeto de seu projeto do HATS, selecione a guia Outro e clique em Suporte ao Teclado. Para obter informações adicionais, consulte Suporte ao Teclado.
  2. Por padrão, o HATS mostra o teclado numérico do aplicativo, mas não exibe o teclado numérico do host. Para que o HATS exiba o teclado numérico do host, você precisa ir para a visualização Projetos HATS e dar um clique duplo nas Configurações do Projeto do seu projeto HATS, selecionar a guia Renderização e clicar em Teclado Numérico do Host. Em seguida você terá a opção de ativar a caixa de opções para exibir o teclado numérico do host bem como selecionar quais teclas devem ser exibidas.

Exemplo

O seguinte exemplo mostra como mapear a combinação de teclas Ctrl+Home no teclado. Para enviar a tecla Home para a sessão do host e também colocar um botão para essa função em sua transformação, duas etapas são necessárias: Editar KBS.js e depois modificar sua transformação conforme descrito em Incluindo Botões de Teclado Numérico Adicionais em uma Transformação.

Para especificar a combinação de teclas que envia a tecla do host, modifique o arquivo KBS.js incluindo as linhas especificadas em itálico negrito a seguir:

var CODE_BACKSPACE = 8;
 var CODE_TAB       = 9;
 var CODE_ENTER     = 13;
 var CODE_PAUSE     = 19;
 var CODE_ESC       = 27;
 var CODE_PAGEUP    = 33;
 var CODE_PAGEDOWN  = 34;
 var CODE_END       = 35;
 var CODE_HOME      = 36;
 var CODE_INSERT    = 45;
 var CODE_DELETE    = 46;
 var CODE_A         = 65;
 var CODE_B         = 66;
 var CODE_C         = 67;
 var CODE_D         = 68;
 var CODE_E         = 69;
 var CODE_F         = 70;
 var CODE_G         = 71;
 var CODE_H         = 72;
 var CODE_I         = 73;
 var CODE_J         = 74;
 var CODE_K         = 75;
 var CODE_L         = 76;
 var CODE_M         = 77;
 var CODE_N         = 78;
 var CODE_O         = 79;
 var CODE_P         = 80;
 var CODE_Q         = 81;
 var CODE_R         = 82;
 var CODE_S         = 83;
 var CODE_T         = 84;
 var CODE_U         = 85;
 var CODE_V         = 86;
 var CODE_W         = 87;
 var CODE_X         = 88;
 var CODE_Y         = 89;
 var CODE_Z         = 90;
 var CODE_HOSTHOME = 36;
 var CODE_F1        = 112;
 var CODE_F2        = 113;
 var CODE_F3        = 114;
 var CODE_F4        = 115;
 var CODE_F5        = 116;
 var CODE_F6        = 117;
 var CODE_F7        = 118;
 var CODE_F8        = 119;
 var CODE_F9        = 120;
 var CODE_F10       = 121;
 var CODE_F11       = 122;
 var CODE_F12       = 123;
 var HostKey        =1;
 var ApplicationKey =2;
/***********************************************************
 * NOTICE: DO NOT MODIFY THE ABOVE VARIABLES!!
 ***********************************************************/

 var defaultKeyMappings = [
 // KEYCODE,       ALT, CTRL, SHIFT, MNEMONIC
 //============ command key mappings ================
   [CODE_ENTER,      0,    0,     0, '[enter]'     ],
   [CODE_PAUSE,      0,    0,     0, '[attn]'      ],
   [CODE_ESC,        0,    0,     0, '[clear]'     ],
   [CODE_ESC,        0,    0,     1, '[sysreq]'    ],
   [CODE_PAGEUP,     0,    0,     0, '[pageup]'    ],
   [CODE_PAGEUP,     1,    0,     0, 'refresh'     ],
   [CODE_PAGEDOWN,   0,    0,     0, '[pagedn]'    ],
   [CODE_HOSTHOME, 0,    1,     0, '[home]'
], 
   [CODE_PAGEDOWN,   1,    0,     0, '[pa3]'       ],
   [CODE_END,        1,    0,     0, '[pa2]'       ],
   [CODE_INSERT,     1,    0,     0, 'default'     ],
   [CODE_DELETE,     1,    0,     0, '[pa1]'       ],
   [CODE_D,          0,    1,     0, 'disconnect'  ],
   [CODE_H,          0,    1,     0, '[help]'      ],
   [CODE_P,          0,    1,     0, '[printhost]' ],   
   [CODE_J,          0,    1,     0, 'printjobs'   ],
   [CODE_ENTER,      1,    0,     0, 'reverse'     ],   
   [CODE_K,          0,    1,     0, 'toggle'      ],
   [CODE_S,          0,    1,     0, 'ResetButton' ],   
 //============ function key mappings ===============
   [CODE_F1,         0,    0,     0, '[pf1]'       ],
   [CODE_F1,         0,    0,     1, '[pf13]'      ],
   [CODE_F2,         0,    0,     0, '[pf2]'       ],
   [CODE_F2,         0,    0,     1, '[pf14]'      ],
   [CODE_F3,         0,    0,     0, '[pf3]'       ],
   [CODE_F3,         0,    0,     1, '[pf15]'      ],
   [CODE_F4,         0,    0,     0, '[pf4]'       ],
   [CODE_F4,         0,    0,     1, '[pf16]'      ],
   [CODE_F5,         0,    0,     0, '[pf5]'       ],
   [CODE_F5,         0,    0,     1, '[pf17]'      ],
   [CODE_F6,         0,    0,     0, '[pf6]'       ],
   [CODE_F6,         0,    0,     1, '[pf18]'      ],
   [CODE_F7,         0,    0,     0, '[pf7]'       ],
   [CODE_F7,         0,    0,     1, '[pf19]'      ],
   [CODE_F8,         0,    0,     0, '[pf8]'       ],
   [CODE_F8,         0,    0,     1, '[pf20]'      ],
   [CODE_F9,         0,    0,     0, '[pf9]'       ],
   [CODE_F9,         0,    0,     1, '[pf21]'      ],
   [CODE_F10,        0,    0,     0, '[pf10]'      ],
   [CODE_F10,        0,    0,     1, '[pf22]'      ],
   [CODE_F11,        0,    0,     0, '[pf11]'      ],
   [CODE_F11,        0,    0,     1, '[pf23]'      ],
   [CODE_F12,        0,    0,     0, '[pf12]'      ],
   [CODE_F12,        0,    0,     1, '[pf24]'      ]
 ];
Nota:
O nome atribuído a qualquer nova variável do código-chave (CODE_HOSTHOME nesse exemplo) não é importante, exceto se for exclusivo e for equivalente à entrada correspondente na lista de variáveis defaultKeyMappings. Além disso observe nesse exemplo que incluir uma nova variável de código-chave para a tecla Home não é realmente necessário uma vez que a entrada
var CODE_HOME = 36;
já existe para o código-chave da tecla Home. No entanto, se você está mapeando uma tecla do teclado que não esteja associada a uma variável do código-chave já definida em KBS.js, essa entrada seria necessária.

Remapeando Teclas para Aplicativos Rich Client do HATS

No ambiente rich client, os mapeamentos de teclado padrão são definidos no arquivo plugin.xml do plug-in Extensão de Tempo de Execução RCP do HATS e são aplicáveis a todos os aplicativos rich client do HATS em execução no mesmo ambiente.

Um contexto de teclado do Eclipse é utilizado para influenciar quais comandos estão disponíveis para o usuário em um determinado momento. Quando um usuário está utilizando uma visualização de transformação do HATS, o contexto de teclado do HATS é utilizado. Esse contexto é registrado no arquivo plugin.xml do plug-in Extensão de Tempo de Execução RCP do HATS. O seguinte exemplo mostra como isso aparece:

<extension 
      point="org.eclipse.ui.contexts">
   <context
         name="%KEYBOARD_CONTEXT_NAME"
         description="%KEYBOARD_CONTEXT_NAME"
         id="com.ibm.hats.rcp.transformationContext"
         parentId="org.eclipse.ui.contexts.window">
   </context>
</extension>

Os mapeamentos do teclado padrão também são definidos no arquivo plugin.xml. O exemplo a seguir mostra como um mapeamento de teclas para um aplicativo HATS em execução no Eclipse RCP ou Lotus Expeditor aparece neste arquivo:

<extension
      point="org.eclipse.ui.commands">
   <category
         name="%COMMAND_CATEGORY_NAME"
         description"%COMMAND_CATEGORY_NAME"
         id="com.ibm.hats.rcp.transformationCategory"
   </category>
   <command
         name="[pf1]"
         category="com.ibm.hats.rcp.transformationCategory"
         id="com.ibm.hats.rcp.send_[pf1]">
   </command>
     ...
 </extension>

<extension
      point="org.eclipse.ui.bindings">
   <key
         commandId="com.ibm.hats.rcp.send_[pf1]"
         contextId="com.ibm.hats.rcp.transformationContext"
         configuration="org.eclipse.ui.defaultAcceleratorConfiguration"
         sequence="F1"
   </key>
     ...
 </extension>

As ligações de teclas para execução no Lotus Notes são separadas das outras ligações de teclas. A ligação de teclas equivalente para o exemplo anterior seria:

   <key
         commandId="com.ibm.hats.rcp.send_[pf1]"
         contextId="com.ibm.hats.rcp.transformationContext"
         schemeId="com.ibm.workplace.notes.hannoverConfiguration"
         sequence="F1"
   </key>

Exemplo

O exemplo a seguir mostra como mapear a combinação de teclas Ctrl+Home no teclado para um aplicativo rich client em execução no Eclipse RCP ou Lotus Expeditor. Primeiro, inclua a tag de comando para [home] e a tag de tecla para Ctrl+Home no arquivo plugin.xml no plug-in Extensão de Tempo de Execução RCP do HATS, conforme mostrado a seguir:

<extension
      point="org.eclipse.ui.commands">
     ...
   <command
         name="[home]"
         category="com.ibm.hats.rcp.transformationCategory"
         id="com.ibm.hats.rcp.send_[home]">
   </command>
     ...
 </extension>
<extension
      point="org.eclipse.ui.bindings">
     ...
   <key
         commandId="com.ibm.hats.rcp.send_[home]"
         contextId="com.ibm.hats.rcp.transformationContext"
         configuration="org.eclipse.ui.defaultAcceleratorConfiguration"
         sequence="Ctrl+Home"
   </key>
     ...
 </extension>

Em seguida, atualize o código de visualização de transformação para que a visualização saiba que um novo mapeamento de teclas está registrado no arquivo plugin.xml. Para fazer isso, edite o arquivo MainView.java em seu projeto. Esse arquivo está localizado na pasta \Source\<nome do projeto>\views sob seu projeto na visualização Projetos HATS. Dê um clique duplo no arquivo MainView.java para abri-lo no editor. Inclua o método createKeyboardActions seguindo o método MainView conforme mostrado abaixo:

protected void createKeyboardActions() {
    super.createKeyboardActions();
    addKeyboardAction("[home]", "com.ibm.hats.rcp.send_[home]");
}
Como ocorre nos aplicativos da Web do HATS, saiba que você não pode remapear as teclas modificadoras Ctrl, Alt e Shift para aplicativos rich client do HATS.

Você pode fornecer uma maneira para seus usuários configurarem as preferências padrão do teclado Eclipse. Ele é normalmente configurado a partir da barra de menus utilizando Janela > Preferências > Ambiente de Trabalho > Teclas. Se você fornecer isso para seus usuários, eles poderão substituir os mapeamentos de teclas definidos no plug-in Extensão de Tempo de Execução RCP do HATS.

Incluindo Botões de Teclado Numérico Adicionais em uma Transformação

É possível incluir um novo botão ou link no Teclado Numérico do Host padrão. O controle para isso está em Configurações do Projeto na guia Renderização, configurações do Teclado Numérico do Host. O novo botão ou link aparecerá sempre que o padrão do Teclado Numérico do Host for utilizado. É possível incluir um novo botão ou link em uma única transformação, utilizando a função Inserir Teclado Numérico do Host > Tecla Individual ao editar a transformação. Consulte Tecla Individual para obter informações adicionais. A GUI para incluir seu próprio botão ou link requer uma Legenda e um Mnemônico. Nesse exemplo, a Legenda é Home e o Mnemônico é [home]. Se você desejar o suporte de teclado para este novo botão, será necessário incluí-lo na tabela KBS.js defaultKeyMappings (para aplicativos da Web) ou no arquivo plugin.xml do plug-in de extensão de tempo de execução do RCP do HATS (para aplicativos rich client).