From c14fddfb595fd837e2fc790e6cc19b47dc4c1fbb Mon Sep 17 00:00:00 2001 From: Benjamin Aigner Date: Thu, 16 Nov 2017 13:05:08 +0100 Subject: [PATCH] First commit Working Keyboard and Mouse Untested: mouse via external serial interface TBD: Joystick --- .gitignore | 2 + Makefile | 11 + main/ble_hidd_demo_main.c | 680 +++++ main/component.mk | 10 + main/config.h | 166 ++ main/esp_hidd_prf_api.c | 146 + main/esp_hidd_prf_api.h | 156 + main/hid_dev.c | 143 + main/hid_dev.h | 257 ++ main/hid_device_le_prf.c | 738 +++++ main/hidd_le_prf_int.h | 339 +++ main/keyboard.c | 2092 ++++++++++++++ main/keyboard.h | 118 + main/keylayouts.h | 5782 +++++++++++++++++++++++++++++++++++++ main/undefkeylayouts.h | 434 +++ sdkconfig | 509 ++++ 16 files changed, 11583 insertions(+) create mode 100644 .gitignore create mode 100644 Makefile create mode 100644 main/ble_hidd_demo_main.c create mode 100644 main/component.mk create mode 100644 main/config.h create mode 100644 main/esp_hidd_prf_api.c create mode 100644 main/esp_hidd_prf_api.h create mode 100644 main/hid_dev.c create mode 100644 main/hid_dev.h create mode 100644 main/hid_device_le_prf.c create mode 100644 main/hidd_le_prf_int.h create mode 100644 main/keyboard.c create mode 100644 main/keyboard.h create mode 100644 main/keylayouts.h create mode 100644 main/undefkeylayouts.h create mode 100644 sdkconfig diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..84b3bb3 --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ + +./build \ No newline at end of file diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..8604de3 --- /dev/null +++ b/Makefile @@ -0,0 +1,11 @@ +# +# This is a project Makefile. It is assumed the directory this Makefile resides in is a +# project subdirectory. +# + +PROJECT_NAME := hidd_demos + +COMPONENT_ADD_INCLUDEDIRS := components/include \ + + +include $(IDF_PATH)/make/project.mk diff --git a/main/ble_hidd_demo_main.c b/main/ble_hidd_demo_main.c new file mode 100644 index 0000000..cde1d65 --- /dev/null +++ b/main/ble_hidd_demo_main.c @@ -0,0 +1,680 @@ +// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at + +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Adaptions done: +// Copyright 2017 Benjamin Aigner + +#include +#include +#include +#include "freertos/FreeRTOS.h" +#include "freertos/task.h" +#include "freertos/event_groups.h" +#include "esp_system.h" +#include "esp_wifi.h" +#include "esp_event_loop.h" +#include "esp_log.h" +#include "nvs_flash.h" +#include "bt.h" + +#include "config.h" + +#include "esp_hidd_prf_api.h" +#include "esp_bt_defs.h" +#include "esp_gap_ble_api.h" +#include "esp_gatts_api.h" +#include "esp_gatt_defs.h" +#include "esp_bt_main.h" +#include "esp_bt_device.h" +#include "bt_trace.h" +#include "driver/gpio.h" +#include "driver/uart.h" +#include "hid_dev.h" +#include "keyboard.h" + +#define GATTS_TAG "FABI/FLIPMOUSE" + +static uint16_t hid_conn_id = 0; +static bool sec_conn = false; +static uint8_t keycode_modifier; +static uint8_t keycode_deadkey_first; +static uint8_t keycode_arr[6]; +//static joystick_data_t joystick;//currently unused, no joystick implemented +static config_data_t config; + + +#define CHAR_DECLARATION_SIZE (sizeof(uint8_t)) + +static void hidd_event_callback(esp_hidd_cb_event_t event, esp_hidd_cb_param_t *param); + +const char hid_device_name_fabi[] = "FABI"; +const char hid_device_name_flipmouse[] = "FLipMouse"; +static uint8_t hidd_service_uuid128[] = { + /* LSB <--------------------------------------------------------------------------------> MSB */ + //first uuid, 16bit, [12],[13] is the value + 0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80, 0x00, 0x10, 0x00, 0x00, 0x12, 0x18, 0x00, 0x00, +}; + +static esp_ble_adv_data_t hidd_adv_data = { + .set_scan_rsp = false, + .include_name = true, + .include_txpower = true, + .min_interval = 0x20, + .max_interval = 0x30, + .appearance = 0x03c0, //HID Generic, + .manufacturer_len = 0, + .p_manufacturer_data = NULL, + .service_data_len = 0, + .p_service_data = NULL, + .service_uuid_len = sizeof(hidd_service_uuid128), + .p_service_uuid = hidd_service_uuid128, + .flag = 0x6, +}; + +static esp_ble_adv_params_t hidd_adv_params = { + .adv_int_min = 0x20, + .adv_int_max = 0x30, + .adv_type = ADV_TYPE_IND, + .own_addr_type = BLE_ADDR_TYPE_PUBLIC, + //.peer_addr = + //.peer_addr_type = + .channel_map = ADV_CHNL_ALL, + .adv_filter_policy = ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY, +}; + +/* +void IRAM_ATTR gpio_isr_handler(void* arg) +{ + uint32_t gpio_num = (uint32_t) arg; + xQueueSendFromISR(gpio_evt_queue, &gpio_num, NULL); +} + +void gpio_task_example(void* arg) +{ + static uint8_t i = 0; + uint32_t io_num; + for(;;) { + if(xQueueReceive(gpio_evt_queue, &io_num, portMAX_DELAY)) { + printf("GPIO[%d] intr, val: %d\n", io_num, gpio_get_level(io_num)); + if(i == 0) { + ++i; + } + } + } +} + +static void gpio_demo_init(void) +{ + gpio_config_t io_conf; + //disable interrupt + io_conf.intr_type = GPIO_PIN_INTR_DISABLE; + //set as output mode + io_conf.mode = GPIO_MODE_OUTPUT; + //bit mask of the pins that you want to set,e.g.GPIO18/19 + io_conf.pin_bit_mask = GPIO_OUTPUT_PIN_SEL; + //disable pull-down mode + io_conf.pull_down_en = 0; + //disable pull-up mode + io_conf.pull_up_en = 0; + //configure GPIO with the given settings + gpio_config(&io_conf); + + //interrupt of rising edge + io_conf.intr_type = GPIO_PIN_INTR_POSEDGE; + //bit mask of the pins, use GPIO4/5 here + io_conf.pin_bit_mask = GPIO_INPUT_PIN_SEL; + //set as input mode + io_conf.mode = GPIO_MODE_INPUT; + //enable pull-up mode + io_conf.pull_up_en = 1; + gpio_config(&io_conf); + + //change gpio intrrupt type for one pin + gpio_set_intr_type(GPIO_INPUT_IO_0, GPIO_INTR_ANYEDGE); + + //create a queue to handle gpio event from isr + gpio_evt_queue = xQueueCreate(10, sizeof(uint32_t)); + //start gpio task + xTaskCreate(gpio_task_example, "gpio_task_example", 2048, NULL, 10, NULL); + + //install gpio isr service + gpio_install_isr_service(ESP_INTR_FLAG_DEFAULT); + //hook isr handler for specific gpio pin + gpio_isr_handler_add(GPIO_INPUT_IO_0, gpio_isr_handler, (void*) GPIO_INPUT_IO_0); + //hook isr handler for specific gpio pin + gpio_isr_handler_add(GPIO_INPUT_IO_1, gpio_isr_handler, (void*) GPIO_INPUT_IO_1); + + //remove isr handler for gpio number. + gpio_isr_handler_remove(GPIO_INPUT_IO_0); + //hook isr handler for specific gpio pin again + gpio_isr_handler_add(GPIO_INPUT_IO_0, gpio_isr_handler, (void*) GPIO_INPUT_IO_0); + +}*/ + + + +static void hidd_event_callback(esp_hidd_cb_event_t event, esp_hidd_cb_param_t *param) +{ + switch(event) { + case ESP_HIDD_EVENT_REG_FINISH: { + if (param->init_finish.state == ESP_HIDD_INIT_OK) { + //esp_bd_addr_t rand_addr = {0x04,0x11,0x11,0x11,0x11,0x05}; + if(config.bt_device_name_index == 1) + { + esp_ble_gap_set_device_name(hid_device_name_flipmouse); + } else { + esp_ble_gap_set_device_name(hid_device_name_fabi); + } + esp_ble_gap_config_adv_data(&hidd_adv_data); + + } + break; + } + case ESP_BAT_EVENT_REG: { + break; + } + case ESP_HIDD_EVENT_DEINIT_FINISH: + break; + case ESP_HIDD_EVENT_BLE_CONNECT: { + hid_conn_id = param->connect.conn_id; + sec_conn = true; //TODO: right here?!? + LOG_ERROR("%s(), ESP_HIDD_EVENT_BLE_CONNECT", __func__); + break; + } + case ESP_HIDD_EVENT_BLE_DISCONNECT: { + sec_conn = false; + hid_conn_id = 0; + LOG_ERROR("%s(), ESP_HIDD_EVENT_BLE_DISCONNECT", __func__); + esp_ble_gap_start_advertising(&hidd_adv_params); + break; + } + default: + break; + } + return; +} + +static void gap_event_handler(esp_gap_ble_cb_event_t event, esp_ble_gap_cb_param_t *param) +{ + switch (event) { + case ESP_GAP_BLE_ADV_DATA_SET_COMPLETE_EVT: + esp_ble_gap_start_advertising(&hidd_adv_params); + break; + case ESP_GAP_BLE_SEC_REQ_EVT: + for(int i = 0; i < ESP_BD_ADDR_LEN; i++) { + LOG_DEBUG("%x:",param->ble_security.ble_req.bd_addr[i]); + } + esp_ble_gap_security_rsp(param->ble_security.ble_req.bd_addr, true); + break; + case ESP_GAP_BLE_AUTH_CMPL_EVT: + sec_conn = true; + LOG_ERROR("status = %s, ESP_GAP_BLE_AUTH_CMPL_EVT",param->ble_security.auth_cmpl.success ? "success" : "fail"); + break; + default: + break; + } +} + + +void update_config() +{ + nvs_handle my_handle; + esp_err_t err = nvs_open("fabi_c", NVS_READWRITE, &my_handle); + if(err != ESP_OK) ESP_LOGE("MAIN","error opening NVS"); + err = nvs_set_u8(my_handle, "btname_i", config.bt_device_name_index); + if(err != ESP_OK) ESP_LOGE("MAIN","error saving NVS - bt name"); + err = nvs_set_u8(my_handle, "locale", config.locale); + if(err != ESP_OK) ESP_LOGE("MAIN","error saving NVS - locale"); + printf("Committing updates in NVS ... "); + err = nvs_commit(my_handle); + printf((err != ESP_OK) ? "Failed!\n" : "Done\n"); + nvs_close(my_handle); +} + +void process_uart(uint8_t *input, uint16_t len) +{ + //tested commands: + //ID_FABI + //ID_FLIPMOUSE + //ID + //PMx (PM0 PM1) + //GP + //DPx (number of paired device, 1-x) + //KW (+layouts) + //KD/KU + //KR + //KL + + //untested commands: + //KC + //M + + //TBD: joystick (everything) + // KK (if necessary) + + if(len < 2) return; + //easier this way than typecast in each str* function + const char *input2 = (const char *) input; + int counter; + char nl = '\n'; + uint8_t keycode = 0; + esp_ble_bond_dev_t *btdevlist = NULL; + #define DEBUG_TAG "UART_PARSER" + + /**++++ commands without parameters ++++*/ + //get module ID + if(strcmp(input2,"ID") == 0) + { + uart_write_bytes(EX_UART_NUM, MODULE_ID, sizeof(MODULE_ID)); + ESP_LOGD(DEBUG_TAG,"sending module id (ID)"); + return; + } + + //get all BT pairings + if(strcmp(input2,"GP") == 0) + { + counter = esp_ble_get_bond_device_num(); + if(counter > 0) + { + btdevlist = (esp_ble_bond_dev_t *) malloc(sizeof(esp_ble_bond_dev_t)*counter); + if(btdevlist != NULL) + { + if(esp_ble_get_bond_device_list(&counter,btdevlist) == ESP_OK) + { + ESP_LOGI(DEBUG_TAG,"bonded devices (starting with index 0):"); + ESP_LOGI(DEBUG_TAG,"---------------------------------------"); + for(uint8_t i = 0; i + if(input[0] == 'M' && len == 5) + { + esp_hidd_send_mouse_value(hid_conn_id,input[1],input[2],input[3],input[4]); + ESP_LOGD(DEBUG_TAG,"mouse movement"); + return; + } + //BT: delete one pairing + if(input[0] == 'D' && input[1] == 'P' && len == 3) + { + counter = esp_ble_get_bond_device_num(); + if(counter == 0) + { + ESP_LOGE(DEBUG_TAG,"error deleting device, no paired devices"); + return; + } + + if(input[2] >= '0' && input[2] <= '9') input[2] -= '0'; + if(input[2] >= counter) + { + ESP_LOGE(DEBUG_TAG,"error deleting device, number out of range"); + return; + } + if(counter >= 0) + { + btdevlist = (esp_ble_bond_dev_t *) malloc(sizeof(esp_ble_bond_dev_t)*counter); + if(btdevlist != NULL) + { + if(esp_ble_get_bond_device_list(&counter,btdevlist) == ESP_OK) + { + esp_ble_remove_bond_device(btdevlist[input[2]].bd_addr); + } else ESP_LOGE(DEBUG_TAG,"error getting device list"); + } else ESP_LOGE(DEBUG_TAG,"error allocating memory for device list"); + } else ESP_LOGE(DEBUG_TAG,"error getting bonded devices count"); + return; + } + //BT: enable/disable discoverable/pairing + if(input[0] == 'P' && input[1] == 'M' && len == 3) + { + if(input[2] == 0 || input[2] == '0') + { + if(esp_ble_gap_stop_advertising() != ESP_OK) + { + ESP_LOGE(DEBUG_TAG,"error stopping advertising"); + } + } else if(input[2] == 1 || input[2] == '1') { + if(esp_ble_gap_start_advertising(&hidd_adv_params) != ESP_OK) + { + ESP_LOGE(DEBUG_TAG,"error starting advertising"); + } else { + //TODO: terminate any connection to be pairable? + } + } else ESP_LOGE(DEBUG_TAG,"parameter error, either 0/1 or '0'/'1'"); + ESP_LOGD(DEBUG_TAG,"management: pairing %d (PM)",input[2]); + return; + } + + //set BT names (either FABI or FLipMouse) + if(strcmp(input2,"ID_FABI") == 0) + { + config.bt_device_name_index = 0; + update_config(); + ESP_LOGD(DEBUG_TAG,"management: set device name to FABI (ID_FABI)"); + return; + } + if(strcmp(input2,"ID_FLIPMOUSE") == 0) + { + config.bt_device_name_index = 1; + update_config(); + ESP_LOGD(DEBUG_TAG,"management: set device name to FLipMouse (ID_FLIPMOUSE)"); + return; + } + + + ESP_LOGE(DEBUG_TAG,"No command executed with: %s ; len= %d\n",input,len); +} + + +void uart_stdin(void *pvParameters) +{ + static uint8_t command[50]; + static uint8_t cpointer = 0; + static uint8_t keycode = 0; + char character; + /** demo mouse speed */ + #define MOUSE_SPEED 30 + + //Install UART driver, and get the queue. + uart_driver_install(CONFIG_CONSOLE_UART_NUM, UART_FIFO_LEN * 2, UART_FIFO_LEN * 2, 0, NULL, 0); + + + while(1) + { + // read single byte + uart_read_bytes(CONFIG_CONSOLE_UART_NUM, (uint8_t*) &character, 1, portMAX_DELAY); + + //sum up characters to one \n terminated command and send it to + //UART parser + if(character == '\n' || character == '\r') + { + printf("received enter, forward command to UART parser\n"); + command[cpointer] = 0x00; + process_uart(command, cpointer); + cpointer = 0; + } else { + if(cpointer < 50) + { + command[cpointer] = character; + cpointer++; + } + } + + if (!sec_conn) { + printf("Not connected, ignoring '%c'\n", character); + } else { + switch (character){ + case 'a': + esp_hidd_send_mouse_value(hid_conn_id,0,-MOUSE_SPEED,0,0); + break; + case 's': + esp_hidd_send_mouse_value(hid_conn_id,0,0,MOUSE_SPEED,0); + break; + case 'd': + esp_hidd_send_mouse_value(hid_conn_id,0,MOUSE_SPEED,0,0); + break; + case 'w': + esp_hidd_send_mouse_value(hid_conn_id,0,0,-MOUSE_SPEED,0); + break; + case 'l': + esp_hidd_send_mouse_value(hid_conn_id,0x01,0,0,0); + esp_hidd_send_mouse_value(hid_conn_id,0x00,0,0,0); + break; + case 'r': + esp_hidd_send_mouse_value(hid_conn_id,0x02,0,0,0); + esp_hidd_send_mouse_value(hid_conn_id,0x00,0,0,0); + break; + case 'y': + case 'z': + printf("Received: %d\n",character); + break; + case 'Q': + //send only lower characters + keycode = 28; + esp_hidd_send_keyboard_value(hid_conn_id,0,&keycode,1); + keycode = 0; + esp_hidd_send_keyboard_value(hid_conn_id,0,&keycode,1); + vTaskDelay(1000 / portTICK_PERIOD_MS); + + break; + } + } + + vTaskDelay(50 / portTICK_PERIOD_MS); + } +} + + +void app_main() +{ + esp_err_t ret; + + // Initialize NVS. + ret = nvs_flash_init(); + if (ret == ESP_ERR_NVS_NO_FREE_PAGES) { + ESP_ERROR_CHECK(nvs_flash_erase()); + ret = nvs_flash_init(); + } + ESP_ERROR_CHECK( ret ); + + // Read config + nvs_handle my_handle; + ret = nvs_open("fabi_c", NVS_READWRITE, &my_handle); + if(ret != ESP_OK) ESP_LOGE("MAIN","error opening NVS"); + ret = nvs_get_u8(my_handle, "btname_i", &config.bt_device_name_index); + if(ret != ESP_OK) + { + ESP_LOGE("MAIN","error reading NVS - bt name, setting to FABI"); + config.bt_device_name_index = 0; + } + ret = nvs_get_u8(my_handle, "locale", &config.locale); + if(ret != ESP_OK || config.locale >= LAYOUT_MAX) + { + ESP_LOGE("MAIN","error reading NVS - locale, setting to US_INTERNATIONAL"); + config.locale = LAYOUT_US_INTERNATIONAL; + } + nvs_close(my_handle); + + + esp_bt_controller_config_t bt_cfg = BT_CONTROLLER_INIT_CONFIG_DEFAULT(); + ret = esp_bt_controller_init(&bt_cfg); + if (ret) { + ESP_LOGE(GATTS_TAG, "%s initialize controller failed\n", __func__); + return; + } + + ret = esp_bt_controller_enable(ESP_BT_MODE_BTDM); + if (ret) { + ESP_LOGE(GATTS_TAG, "%s enable controller failed\n", __func__); + return; + } + + ret = esp_bluedroid_init(); + if (ret) { + LOG_ERROR("%s init bluedroid failed\n", __func__); + return; + } + + ret = esp_bluedroid_enable(); + if (ret) { + LOG_ERROR("%s init bluedroid failed\n", __func__); + return; + } + + //load HID country code for locale before initialising HID + hidd_set_countrycode(get_hid_country_code(config.locale)); + + if((ret = esp_hidd_profile_init()) != ESP_OK) { + LOG_ERROR("%s init bluedroid failed\n", __func__); + } + + ///register the callback function to the gap module + esp_ble_gap_register_callback(gap_event_handler); + esp_hidd_register_callbacks(hidd_event_callback); + + /* set the security iocap & auth_req & key size & init key response key parameters to the stack*/ + esp_ble_auth_req_t auth_req = ESP_LE_AUTH_BOND; //bonding with peer device after authentication + esp_ble_io_cap_t iocap = ESP_IO_CAP_NONE; //set the IO capability to No output No input + uint8_t key_size = 16; //the key size should be 7~16 bytes + uint8_t init_key = ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK; + uint8_t rsp_key = ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK; + esp_ble_gap_set_security_param(ESP_BLE_SM_AUTHEN_REQ_MODE, &auth_req, sizeof(uint8_t)); + esp_ble_gap_set_security_param(ESP_BLE_SM_IOCAP_MODE, &iocap, sizeof(uint8_t)); + esp_ble_gap_set_security_param(ESP_BLE_SM_MAX_KEY_SIZE, &key_size, sizeof(uint8_t)); + /* If your BLE device act as a Slave, the init_key means you hope which types of key of the master should distribut to you, + and the response key means which key you can distribut to the Master; + If your BLE device act as a master, the response key means you hope which types of key of the slave should distribut to you, + and the init key means which key you can distribut to the slave. */ + esp_ble_gap_set_security_param(ESP_BLE_SM_SET_INIT_KEY, &init_key, sizeof(uint8_t)); + esp_ble_gap_set_security_param(ESP_BLE_SM_SET_RSP_KEY, &rsp_key, sizeof(uint8_t)); + + //init the gpio pin (not needing GPIOs by now...) + //gpio_demo_init(); + + xTaskCreate(&uart_stdin, "stdin", 2048, NULL, 5, NULL); + +} + diff --git a/main/component.mk b/main/component.mk new file mode 100644 index 0000000..48adb59 --- /dev/null +++ b/main/component.mk @@ -0,0 +1,10 @@ +# +# Main Makefile. This is basically the same as a component makefile. +# +# This Makefile should, at the very least, just include $(SDK_PATH)/make/component_common.mk. By default, +# this will take the sources in the src/ directory, compile them and link them into +# lib(subdirectory_name).a in the build directory. This behaviour is entirely configurable, +# please read the ESP-IDF documents if you need to do this. +# + +# include $(IDF_PATH)/make/component_common.mk diff --git a/main/config.h b/main/config.h new file mode 100644 index 0000000..3e2f840 --- /dev/null +++ b/main/config.h @@ -0,0 +1,166 @@ + +#ifndef _CONFIG_H_ +#define _CONFIG_H_ + +#define MODULE_ID "ESP32BT_v0.1" + +//TODO: change to external UART; currently set to serial port of monitor for debugging +#define EX_UART_NUM UART_NUM_0 + +// from USB HID Specification 1.1, Appendix B.2 +const uint8_t hid_descriptor[] = { + /**++++ KEYBOARD ++++**/ + + 0x05, 0x01, // Usage Page (Generic Desktop) + 0x09, 0x06, // Usage (Keyboard) + 0xa1, 0x01, // Collection (Application) + //TODO: is this right here?!? + 0x85, 0x01, // REPORT_ID (1) + // Modifier byte + + 0x75, 0x01, // Report Size (1) + 0x95, 0x08, // Report Count (8) + 0x05, 0x07, // Usage Page (Key codes) + 0x19, 0xe0, // Usage Minimum (Keyboard LeftControl) + 0x29, 0xe7, // Usage Maxium (Keyboard Right GUI) + 0x15, 0x00, // Logical Minimum (0) + 0x25, 0x01, // Logical Maximum (1) + 0x81, 0x02, // Input (Data, Variable, Absolute) + + // Reserved byte + + 0x75, 0x01, // Report Size (1) + 0x95, 0x08, // Report Count (8) + 0x81, 0x03, // Input (Constant, Variable, Absolute) + + // LED report + padding + + 0x95, 0x05, // Report Count (5) + 0x75, 0x01, // Report Size (1) + 0x05, 0x08, // Usage Page (LEDs) + 0x19, 0x01, // Usage Minimum (Num Lock) + 0x29, 0x05, // Usage Maxium (Kana) + 0x91, 0x02, // Output (Data, Variable, Absolute) + + 0x95, 0x01, // Report Count (1) + 0x75, 0x03, // Report Size (3) + 0x91, 0x03, // Output (Constant, Variable, Absolute) + + // Keycodes + + 0x95, 0x06, // Report Count (6) + 0x75, 0x08, // Report Size (8) + 0x15, 0x00, // Logical Minimum (0) + 0x25, 0xff, // Logical Maximum (1) + 0x05, 0x07, // Usage Page (Key codes) + 0x19, 0x00, // Usage Minimum (Reserved (no event indicated)) + 0x29, 0xff, // Usage Maxium (Reserved) + 0x81, 0x00, // Input (Data, Array) + + 0xc0, // End collection + + /**++++ MOUSE ++++**/ + + 0x05, 0x01, // USAGE_PAGE (Generic Desktop) + 0x09, 0x02, // USAGE (Mouse) + 0xa1, 0x01, // COLLECTION (Application) + + 0x09, 0x01, // USAGE (Pointer) + 0xa1, 0x00, // COLLECTION (Physical) + //TODO: is this right here?!? + 0x85, 0x02, // REPORT_ID (2) + 0x05, 0x09, // USAGE_PAGE (Button) + 0x19, 0x01, // USAGE_MINIMUM (Button 1) + 0x29, 0x03, // USAGE_MAXIMUM (Button 3) + 0x15, 0x00, // LOGICAL_MINIMUM (0) + 0x25, 0x01, // LOGICAL_MAXIMUM (1) + 0x95, 0x03, // REPORT_COUNT (3) + 0x75, 0x01, // REPORT_SIZE (1) + 0x81, 0x02, // INPUT (Data,Var,Abs) + 0x95, 0x01, // REPORT_COUNT (1) + 0x75, 0x05, // REPORT_SIZE (5) + 0x81, 0x03, // INPUT (Cnst,Var,Abs) + + 0x05, 0x01, // USAGE_PAGE (Generic Desktop) + 0x09, 0x30, // USAGE (X) + 0x09, 0x31, // USAGE (Y) + 0x15, 0x81, // LOGICAL_MINIMUM (-127) + 0x25, 0x7f, // LOGICAL_MAXIMUM (127) + 0x75, 0x08, // REPORT_SIZE (8) + 0x95, 0x02, // REPORT_COUNT (2) + 0x81, 0x06, // INPUT (Data,Var,Rel) + + 0xc0, // END_COLLECTION + 0xc0, // END_COLLECTION + + /**++++ JOYSTICK ++++*/ + //TODO: add joystick to GATT table, otherwise it does not work + + 0x05, 0x01, // Usage Page (Generic Desktop) + 0x09, 0x04, // Usage (Joystick) + 0xA1, 0x01, // Collection (Application) + //TODO: is this right here?!? + 0x85, 0x03, // REPORT_ID (3) + + 0x15, 0x00, // Logical Minimum (0) + 0x25, 0x01, // Logical Maximum (1) + 0x75, 0x01, // Report Size (1) + 0x95, 0x20, // Report Count (32) + 0x05, 0x09, // Usage Page (Button) + 0x19, 0x01, // Usage Minimum (Button #1) + 0x29, 0x20, // Usage Maximum (Button #32) + 0x81, 0x02, // Input (variable,absolute) + 0x15, 0x00, // Logical Minimum (0) + 0x25, 0x07, // Logical Maximum (7) + 0x35, 0x00, // Physical Minimum (0) + 0x46, 0x3B, 0x01, // Physical Maximum (315) + 0x75, 0x04, // Report Size (4) + 0x95, 0x01, // Report Count (1) + 0x65, 0x14, // Unit (20) + 0x05, 0x01, // Usage Page (Generic Desktop) + 0x09, 0x39, // Usage (Hat switch) + 0x81, 0x42, // Input (variable,absolute,null_state) + 0x05, 0x01, // Usage Page (Generic Desktop) + 0x09, 0x01, // Usage (Pointer) + 0xA1, 0x00, // Collection () + 0x15, 0x00, // Logical Minimum (0) + 0x26, 0xFF, 0x03, // Logical Maximum (1023) + 0x75, 0x0A, // Report Size (10) + 0x95, 0x04, // Report Count (4) + 0x09, 0x30, // Usage (X) + 0x09, 0x31, // Usage (Y) + 0x09, 0x32, // Usage (Z) + 0x09, 0x35, // Usage (Rz) + 0x81, 0x02, // Input (variable,absolute) + 0xC0, // End Collection + 0x15, 0x00, // Logical Minimum (0) + 0x26, 0xFF, 0x03, // Logical Maximum (1023) + 0x75, 0x0A, // Report Size (10) + 0x95, 0x02, // Report Count (2) + 0x09, 0x36, // Usage (Slider) + 0x09, 0x36, // Usage (Slider) + 0x81, 0x02, // Input (variable,absolute) + 0xC0 // End Collection +}; + + + +typedef struct joystick_data { + uint16_t X; + uint16_t Y; + uint16_t Z; + uint16_t Z_rotate; + uint16_t slider_left; + uint16_t slider_right; + uint16_t buttons1; + uint16_t buttons2; + int16_t hat; +} joystick_data_t; + +typedef struct config_data { + uint8_t bt_device_name_index; + uint8_t locale; +} config_data_t; + + +#endif diff --git a/main/esp_hidd_prf_api.c b/main/esp_hidd_prf_api.c new file mode 100644 index 0000000..98bbb39 --- /dev/null +++ b/main/esp_hidd_prf_api.c @@ -0,0 +1,146 @@ +// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at + +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "esp_hidd_prf_api.h" +#include "hidd_le_prf_int.h" +#include "hid_dev.h" +#include +#include +#include "bt_trace.h" + +// HID keyboard input report length +#define HID_KEYBOARD_IN_RPT_LEN 8 + +// HID LED output report length +#define HID_LED_OUT_RPT_LEN 1 + +// HID mouse input report length +#define HID_MOUSE_IN_RPT_LEN 5 + +// HID consumer control input report length +#define HID_CC_IN_RPT_LEN 2 + + +esp_err_t esp_hidd_register_callbacks(esp_hidd_event_cb_t callbacks) +{ + esp_err_t hidd_status; + + if(callbacks != NULL) { + hidd_le_env.hidd_cb = callbacks; + } else { + return ESP_FAIL; + } + + if((hidd_status = hidd_register_cb()) != ESP_OK) { + return hidd_status; + } + + esp_ble_gatts_app_register(BATTRAY_APP_ID); + + if((hidd_status = esp_ble_gatts_app_register(HIDD_APP_ID)) != ESP_OK) { + return hidd_status; + } + + return hidd_status; +} + +esp_err_t esp_hidd_profile_init(void) +{ + if (hidd_le_env.enabled) { + LOG_ERROR("HID device profile already initialized"); + return ESP_FAIL; + } + // Reset the hid device target environment + memset(&hidd_le_env, 0, sizeof(hidd_le_env_t)); + hidd_le_env.enabled = true; + return ESP_OK; +} + +esp_err_t esp_hidd_profile_deinit(void) +{ + uint16_t hidd_svc_hdl = hidd_le_env.hidd_inst.att_tbl[HIDD_LE_IDX_SVC]; + if (!hidd_le_env.enabled) { + LOG_ERROR("HID device profile already initialized"); + return ESP_OK; + } + + if(hidd_svc_hdl != 0) { + esp_ble_gatts_stop_service(hidd_svc_hdl); + esp_ble_gatts_delete_service(hidd_svc_hdl); + } else { + return ESP_FAIL; + } + + /* register the HID device profile to the BTA_GATTS module*/ + esp_ble_gatts_app_unregister(hidd_le_env.gatt_if); + + return ESP_OK; +} + +uint16_t esp_hidd_get_version(void) +{ + return HIDD_VERSION; +} + +void esp_hidd_send_consumer_value(uint16_t conn_id, uint8_t key_cmd, bool key_pressed) +{ + uint8_t buffer[HID_CC_IN_RPT_LEN] = {0, 0}; + if (key_pressed) { + LOG_DEBUG("hid_consumer_build_report"); + hid_consumer_build_report(buffer, key_cmd); + } + LOG_DEBUG("buffer[0] = %x, buffer[1] = %x", buffer[0], buffer[1]); + hid_dev_send_report(hidd_le_env.gatt_if, conn_id, + HID_RPT_ID_CC_IN, HID_REPORT_TYPE_INPUT, HID_CC_IN_RPT_LEN, buffer); + return; +} + +void esp_hidd_send_keyboard_value(uint16_t conn_id, key_mask_t special_key_mask, uint8_t *keyboard_cmd, uint8_t num_key) +{ + if (num_key > HID_KEYBOARD_IN_RPT_LEN - 2) { + LOG_ERROR("%s(), the number key should not be more than %d", __func__, HID_KEYBOARD_IN_RPT_LEN); + return; + } + + uint8_t buffer[HID_KEYBOARD_IN_RPT_LEN] = {0}; + + buffer[0] = special_key_mask; + + for (int i = 0; i < num_key; i++) { + buffer[i+2] = keyboard_cmd[i]; + } + + LOG_DEBUG("the key vaule = %d,%d,%d, %d, %d, %d,%d, %d", buffer[0], buffer[1], buffer[2], buffer[3], buffer[4], buffer[5], buffer[6], buffer[7]); + hid_dev_send_report(hidd_le_env.gatt_if, conn_id, + HID_RPT_ID_KEY_IN, HID_REPORT_TYPE_INPUT, HID_KEYBOARD_IN_RPT_LEN, buffer); + return; +} + +void esp_hidd_send_mouse_value(uint16_t conn_id, uint8_t mouse_button, int8_t mickeys_x, int8_t mickeys_y, int8_t wheel) +{ + uint8_t buffer[HID_MOUSE_IN_RPT_LEN]; + + buffer[0] = mouse_button; // Buttons + buffer[1] = mickeys_x; // X + buffer[2] = mickeys_y; // Y + buffer[3] = wheel; // Wheel + buffer[4] = 0; // AC Pan + + hid_dev_send_report(hidd_le_env.gatt_if, conn_id, + HID_RPT_ID_MOUSE_IN, HID_REPORT_TYPE_INPUT, HID_MOUSE_IN_RPT_LEN, buffer); + return; +} + + + diff --git a/main/esp_hidd_prf_api.h b/main/esp_hidd_prf_api.h new file mode 100644 index 0000000..9340293 --- /dev/null +++ b/main/esp_hidd_prf_api.h @@ -0,0 +1,156 @@ +// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at + +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef __ESP_HIDD_API_H__ +#define __ESP_HIDD_API_H__ + +#include "esp_bt_defs.h" +#include "esp_gatt_defs.h" +#include "esp_err.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + ESP_HIDD_EVENT_REG_FINISH = 0, + ESP_BAT_EVENT_REG, + ESP_HIDD_EVENT_DEINIT_FINISH, + ESP_HIDD_EVENT_BLE_CONNECT, + ESP_HIDD_EVENT_BLE_DISCONNECT, +} esp_hidd_cb_event_t; + +/// HID config status +typedef enum { + ESP_HIDD_STA_CONN_SUCCESS = 0x00, + ESP_HIDD_STA_CONN_FAIL = 0x01, +} esp_hidd_sta_conn_state_t; + +/// HID init status +typedef enum { + ESP_HIDD_INIT_OK = 0, + ESP_HIDD_INIT_FAILED = 1, +} esp_hidd_init_state_t; + +/// HID deinit status +typedef enum { + ESP_HIDD_DEINIT_OK = 0, + ESP_HIDD_DEINIT_FAILED = 0, +} esp_hidd_deinit_state_t; + +#define LEFT_CONTROL_KEY_MASK (1 >> 0) +#define LEFT_SHIFT_KEY_MASK (1 >> 1) +#define LEFT_ALT_KEY_MASK (1 >> 2) +#define LEFT_GUI_KEY_MASK (1 >> 3) +#define RIGHT_CONTROL_KEY_MASK (1 >> 4) +#define RIGHT_SHIFT_KEY_MASK (1 >> 5) +#define RIGHT_ALT_KEY_MASK (1 >> 6) +#define RIGHT_GUI_KEY_MASK (1 >> 7) +typedef uint8_t key_mask_t; +/** + * @brief HIDD callback parameters union + */ +typedef union { + /** + * @brief ESP_HIDD_EVENT_INIT_FINISH + */ + struct hidd_init_finish_evt_param { + esp_hidd_init_state_t state; /*!< Initial status */ + esp_gatt_if_t gatts_if; + } init_finish; /*!< HID callback param of ESP_HIDD_EVENT_INIT_FINISH */ + + /** + * @brief ESP_HIDD_EVENT_DEINIT_FINISH + */ + struct hidd_deinit_finish_evt_param { + esp_hidd_deinit_state_t state; /*!< De-initial status */ + } deinit_finish; /*!< HID callback param of ESP_HIDD_EVENT_DEINIT_FINISH */ + + /** + * @brief ESP_HIDD_EVENT_CONNECT + */ + struct hidd_connect_evt_param { + uint16_t conn_id; + esp_bd_addr_t remote_bda; /*!< HID Remote bluetooth device address */ + } connect; /*!< HID callback param of ESP_HIDD_EVENT_CONNECT */ + + /** + * @brief ESP_HIDD_EVENT_DISCONNECT + */ + struct hidd_disconnect_evt_param { + esp_bd_addr_t remote_bda; /*!< HID Remote bluetooth device address */ + } disconnect; /*!< HID callback param of ESP_HIDD_EVENT_DISCONNECT */ + +} esp_hidd_cb_param_t; + + +/** + * @brief HID device event callback function type + * @param event : Event type + * @param param : Point to callback parameter, currently is union type + */ +typedef void (*esp_hidd_event_cb_t) (esp_hidd_cb_event_t event, esp_hidd_cb_param_t *param); + + + +/** + * + * @brief This function is called to receive hid device callback event + * + * @param[in] callbacks: callback functions + * + * @return ESP_OK - success, other - failed + * + */ +esp_err_t esp_hidd_register_callbacks(esp_hidd_event_cb_t callbacks); + +/** + * + * @brief This function is called to initialize hid device profile + * + * @return ESP_OK - success, other - failed + * + */ +esp_err_t esp_hidd_profile_init(void); + +/** + * + * @brief This function is called to de-initialize hid device profile + * + * @return ESP_OK - success, other - failed + * + */ +esp_err_t esp_hidd_profile_deinit(void); + +/** + * + * @brief Get hidd profile version + * + * @return Most 8bit significant is Great version, Least 8bit is Sub version + * + */ +uint16_t esp_hidd_get_version(void); + +void esp_hidd_send_consumer_value(uint16_t conn_id, uint8_t key_cmd, bool key_pressed); + +void esp_hidd_send_keyboard_value(uint16_t conn_id, key_mask_t special_key_mask, uint8_t *keyboard_cmd, uint8_t num_key); + +void esp_hidd_send_mouse_value(uint16_t conn_id, uint8_t mouse_button, int8_t mickeys_x, int8_t mickeys_y, int8_t wheel); + +#ifdef __cplusplus +} +#endif + +#endif /* __ESP_HIDD_API_H__ */ + diff --git a/main/hid_dev.c b/main/hid_dev.c new file mode 100644 index 0000000..25f877d --- /dev/null +++ b/main/hid_dev.c @@ -0,0 +1,143 @@ +// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at + +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "hid_dev.h" +#include "bt_trace.h" +#include +#include +#include +#include + + +#ifdef __cplusplus +extern "C" { +#endif + +static hid_report_map_t *hid_dev_rpt_tbl; +static uint8_t hid_dev_rpt_tbl_Len; + +static hid_report_map_t *hid_dev_rpt_by_id(uint8_t id, uint8_t type) +{ + hid_report_map_t *rpt = hid_dev_rpt_tbl; + + for (uint8_t i = hid_dev_rpt_tbl_Len; i > 0; i--, rpt++) { + if (rpt->id == id && rpt->type == type && rpt->mode == hidProtocolMode) { + return rpt; + } + } + + return NULL; +} + +void hid_dev_register_reports(uint8_t num_reports, hid_report_map_t *p_report) +{ + hid_dev_rpt_tbl = p_report; + hid_dev_rpt_tbl_Len = num_reports; + return; +} + +void hid_dev_send_report(esp_gatt_if_t gatts_if, uint16_t conn_id, + uint8_t id, uint8_t type, uint8_t length, uint8_t *data) +{ + hid_report_map_t *p_rpt; + + // get att handle for report + if ((p_rpt = hid_dev_rpt_by_id(id, type)) != NULL) { + // if notifications are enabled + LOG_ERROR("%s(), send the report, handle = %d", __func__, p_rpt->handle); + esp_ble_gatts_send_indicate(gatts_if, conn_id, p_rpt->handle, length, data, false); + } + + return; +} + +void hid_consumer_build_report(uint8_t *buffer, consumer_cmd_t cmd) +{ + if (!buffer) { + LOG_ERROR("%s(), the buffer is NULL, hid build report failed.", __func__); + return; + } + + switch (cmd) { + case HID_CONSUMER_CHANNEL_UP: + HID_CC_RPT_SET_CHANNEL(buffer, HID_CC_RPT_CHANNEL_UP); + break; + + case HID_CONSUMER_CHANNEL_DOWN: + HID_CC_RPT_SET_CHANNEL(buffer, HID_CC_RPT_CHANNEL_DOWN); + break; + + case HID_CONSUMER_VOLUME_UP: + HID_CC_RPT_SET_VOLUME_UP(buffer); + break; + + case HID_CONSUMER_VOLUME_DOWN: + HID_CC_RPT_SET_VOLUME_DOWN(buffer); + break; + + case HID_CONSUMER_MUTE: + HID_CC_RPT_SET_BUTTON(buffer, HID_CC_RPT_MUTE); + break; + + case HID_CONSUMER_POWER: + HID_CC_RPT_SET_BUTTON(buffer, HID_CC_RPT_POWER); + break; + + case HID_CONSUMER_RECALL_LAST: + HID_CC_RPT_SET_BUTTON(buffer, HID_CC_RPT_LAST); + break; + + case HID_CONSUMER_ASSIGN_SEL: + HID_CC_RPT_SET_BUTTON(buffer, HID_CC_RPT_ASSIGN_SEL); + break; + + case HID_CONSUMER_PLAY: + HID_CC_RPT_SET_BUTTON(buffer, HID_CC_RPT_PLAY); + break; + + case HID_CONSUMER_PAUSE: + HID_CC_RPT_SET_BUTTON(buffer, HID_CC_RPT_PAUSE); + break; + + case HID_CONSUMER_RECORD: + HID_CC_RPT_SET_BUTTON(buffer, HID_CC_RPT_RECORD); + break; + + case HID_CONSUMER_FAST_FORWARD: + HID_CC_RPT_SET_BUTTON(buffer, HID_CC_RPT_FAST_FWD); + break; + + case HID_CONSUMER_REWIND: + HID_CC_RPT_SET_BUTTON(buffer, HID_CC_RPT_REWIND); + break; + + case HID_CONSUMER_SCAN_NEXT_TRK: + HID_CC_RPT_SET_BUTTON(buffer, HID_CC_RPT_SCAN_NEXT_TRK); + break; + + case HID_CONSUMER_SCAN_PREV_TRK: + HID_CC_RPT_SET_BUTTON(buffer, HID_CC_RPT_SCAN_PREV_TRK); + break; + + case HID_CONSUMER_STOP: + HID_CC_RPT_SET_BUTTON(buffer, HID_CC_RPT_STOP); + break; + + default: + break; + } + + return; +} + diff --git a/main/hid_dev.h b/main/hid_dev.h new file mode 100644 index 0000000..2e6d0b2 --- /dev/null +++ b/main/hid_dev.h @@ -0,0 +1,257 @@ +// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at + +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef HID_DEV_H__ +#define HID_DEV_H__ + +#include "hidd_le_prf_int.h" + + +#ifdef __cplusplus +extern "C" { +#endif + + +/* HID Report type */ +#define HID_TYPE_INPUT 1 +#define HID_TYPE_OUTPUT 2 +#define HID_TYPE_FEATURE 3 + +// HID Keyboard/Keypad Usage IDs (subset of the codes available in the USB HID Usage Tables spec) +#define HID_KEY_RESERVED 0 // No event inidicated +#define HID_KEY_A 4 // Keyboard a and A +#define HID_KEY_B 5 // Keyboard b and B +#define HID_KEY_C 6 // Keyboard c and C +#define HID_KEY_D 7 // Keyboard d and D +#define HID_KEY_E 8 // Keyboard e and E +#define HID_KEY_F 9 // Keyboard f and F +#define HID_KEY_G 10 // Keyboard g and G +#define HID_KEY_H 11 // Keyboard h and H +#define HID_KEY_I 12 // Keyboard i and I +#define HID_KEY_J 13 // Keyboard j and J +#define HID_KEY_K 14 // Keyboard k and K +#define HID_KEY_L 15 // Keyboard l and L +#define HID_KEY_M 16 // Keyboard m and M +#define HID_KEY_N 17 // Keyboard n and N +#define HID_KEY_O 18 // Keyboard o and O +#define HID_KEY_P 19 // Keyboard p and p +#define HID_KEY_Q 20 // Keyboard q and Q +#define HID_KEY_R 21 // Keyboard r and R +#define HID_KEY_S 22 // Keyboard s and S +#define HID_KEY_T 23 // Keyboard t and T +#define HID_KEY_U 24 // Keyboard u and U +#define HID_KEY_V 25 // Keyboard v and V +#define HID_KEY_W 26 // Keyboard w and W +#define HID_KEY_X 27 // Keyboard x and X +#define HID_KEY_Y 28 // Keyboard y and Y +#define HID_KEY_Z 29 // Keyboard z and Z +#define HID_KEY_1 30 // Keyboard 1 and ! +#define HID_KEY_2 31 // Keyboard 2 and @ +#define HID_KEY_3 32 // Keyboard 3 and # +#define HID_KEY_4 33 // Keyboard 4 and % +#define HID_KEY_5 34 // Keyboard 5 and % +#define HID_KEY_6 35 // Keyboard 6 and ^ +#define HID_KEY_7 36 // Keyboard 7 and & +#define HID_KEY_8 37 // Keyboard 8 and * +#define HID_KEY_9 38 // Keyboard 9 and ( +#define HID_KEY_0 39 // Keyboard 0 and ) +#define HID_KEY_RETURN 40 // Keyboard Return (ENTER) +#define HID_KEY_ESCAPE 41 // Keyboard ESCAPE +#define HID_KEY_DELETE 42 // Keyboard DELETE (Backspace) +#define HID_KEY_TAB 43 // Keyboard Tab +#define HID_KEY_SPACEBAR 44 // Keyboard Spacebar +#define HID_KEY_MINUS 45 // Keyboard - and (underscore) +#define HID_KEY_EQUAL 46 // Keyboard = and + +#define HID_KEY_LEFT_BRKT 47 // Keyboard [ and { +#define HID_KEY_RIGHT_BRKT 48 // Keyboard ] and } +#define HID_KEY_BACK_SLASH 49 // Keyboard \ and | +#define HID_KEY_SEMI_COLON 51 // Keyboard ; and : +#define HID_KEY_SGL_QUOTE 52 // Keyboard ' and " +#define HID_KEY_GRV_ACCENT 53 // Keyboard Grave Accent and Tilde +#define HID_KEY_COMMA 54 // Keyboard , and < +#define HID_KEY_DOT 55 // Keyboard . and > +#define HID_KEY_FWD_SLASH 56 // Keyboard / and ? +#define HID_KEY_CAPS_LOCK 57 // Keyboard Caps Lock +#define HID_KEY_F1 58 // Keyboard F1 +#define HID_KEY_F2 59 // Keyboard F2 +#define HID_KEY_F3 60 // Keyboard F3 +#define HID_KEY_F4 61 // Keyboard F4 +#define HID_KEY_F5 62 // Keyboard F5 +#define HID_KEY_F6 63 // Keyboard F6 +#define HID_KEY_F7 64 // Keyboard F7 +#define HID_KEY_F8 65 // Keyboard F8 +#define HID_KEY_F9 66 // Keyboard F9 +#define HID_KEY_F10 67 // Keyboard F10 +#define HID_KEY_F11 68 // Keyboard F11 +#define HID_KEY_F12 69 // Keyboard F12 +#define HID_KEY_PRNT_SCREEN 70 // Keyboard Print Screen +#define HID_KEY_SCROLL_LOCK 71 // Keyboard Scroll Lock +#define HID_KEY_PAUSE 72 // Keyboard Pause +#define HID_KEY_INSERT 73 // Keyboard Insert +#define HID_KEY_HOME 74 // Keyboard Home +#define HID_KEY_PAGE_UP 75 // Keyboard PageUp +#define HID_KEY_DELETE_FWD 76 // Keyboard Delete Forward +#define HID_KEY_END 77 // Keyboard End +#define HID_KEY_PAGE_DOWN 78 // Keyboard PageDown +#define HID_KEY_RIGHT_ARROW 79 // Keyboard RightArrow +#define HID_KEY_LEFT_ARROW 80 // Keyboard LeftArrow +#define HID_KEY_DOWN_ARROW 81 // Keyboard DownArrow +#define HID_KEY_UP_ARROW 82 // Keyboard UpArrow +#define HID_KEY_NUM_LOCK 83 // Keypad Num Lock and Clear +#define HID_KEY_DIVIDE 84 // Keypad / +#define HID_KEY_MULTIPLY 85 // Keypad * +#define HID_KEY_SUBTRACT 86 // Keypad - +#define HID_KEY_ADD 87 // Keypad + +#define HID_KEY_ENTER 88 // Keypad ENTER +#define HID_KEYPAD_1 89 // Keypad 1 and End +#define HID_KEYPAD_2 90 // Keypad 2 and Down Arrow +#define HID_KEYPAD_3 91 // Keypad 3 and PageDn +#define HID_KEYPAD_4 92 // Keypad 4 and Lfet Arrow +#define HID_KEYPAD_5 93 // Keypad 5 +#define HID_KEYPAD_6 94 // Keypad 6 and Right Arrow +#define HID_KEYPAD_7 95 // Keypad 7 and Home +#define HID_KEYPAD_8 96 // Keypad 8 and Up Arrow +#define HID_KEYPAD_9 97 // Keypad 9 and PageUp +#define HID_KEYPAD_0 98 // Keypad 0 and Insert +#define HID_KEYPAD_DOT 99 // Keypad . and Delete +#define HID_KEY_MUTE 127 // Keyboard Mute +#define HID_KEY_VOLUME_UP 128 // Keyboard Volume up +#define HID_KEY_VOLUME_DOWN 129 // Keyboard Volume down +#define HID_KEY_LEFT_CTRL 224 // Keyboard LeftContorl +#define HID_KEY_LEFT_SHIFT 225 // Keyboard LeftShift +#define HID_KEY_LEFT_ALT 226 // Keyboard LeftAlt +#define HID_KEY_LEFT_GUI 227 // Keyboard LeftGUI +#define HID_KEY_RIGHT_CTRL 228 // Keyboard LeftContorl +#define HID_KEY_RIGHT_SHIFT 229 // Keyboard LeftShift +#define HID_KEY_RIGHT_ALT 230 // Keyboard LeftAlt +#define HID_KEY_RIGHT_GUI 231 // Keyboard RightGUI +typedef uint8_t keyboard_cmd_t; + +#define HID_MOUSE_LEFT 253 +#define HID_MOUSE_MIDDLE 254 +#define HID_MOUSE_RIGHT 255 +typedef uint8_t mouse_cmd_t; + +// HID Consumer Usage IDs (subset of the codes available in the USB HID Usage Tables spec) +#define HID_CONSUMER_POWER 48 // Power +#define HID_CONSUMER_RESET 49 // Reset +#define HID_CONSUMER_SLEEP 50 // Sleep + +#define HID_CONSUMER_MENU 64 // Menu +#define HID_CONSUMER_SELECTION 128 // Selection +#define HID_CONSUMER_ASSIGN_SEL 129 // Assign Selection +#define HID_CONSUMER_MODE_STEP 130 // Mode Step +#define HID_CONSUMER_RECALL_LAST 131 // Recall Last +#define HID_CONSUMER_QUIT 148 // Quit +#define HID_CONSUMER_HELP 149 // Help +#define HID_CONSUMER_CHANNEL_UP 156 // Channel Increment +#define HID_CONSUMER_CHANNEL_DOWN 157 // Channel Decrement + +#define HID_CONSUMER_PLAY 176 // Play +#define HID_CONSUMER_PAUSE 177 // Pause +#define HID_CONSUMER_RECORD 178 // Record +#define HID_CONSUMER_FAST_FORWARD 179 // Fast Forward +#define HID_CONSUMER_REWIND 180 // Rewind +#define HID_CONSUMER_SCAN_NEXT_TRK 181 // Scan Next Track +#define HID_CONSUMER_SCAN_PREV_TRK 182 // Scan Previous Track +#define HID_CONSUMER_STOP 183 // Stop +#define HID_CONSUMER_EJECT 184 // Eject +#define HID_CONSUMER_RANDOM_PLAY 185 // Random Play +#define HID_CONSUMER_SELECT_DISC 186 // Select Disk +#define HID_CONSUMER_ENTER_DISC 187 // Enter Disc +#define HID_CONSUMER_REPEAT 188 // Repeat +#define HID_CONSUMER_STOP_EJECT 204 // Stop/Eject +#define HID_CONSUMER_PLAY_PAUSE 205 // Play/Pause +#define HID_CONSUMER_PLAY_SKIP 206 // Play/Skip + +#define HID_CONSUMER_VOLUME 224 // Volume +#define HID_CONSUMER_BALANCE 225 // Balance +#define HID_CONSUMER_MUTE 226 // Mute +#define HID_CONSUMER_BASS 227 // Bass +#define HID_CONSUMER_VOLUME_UP 233 // Volume Increment +#define HID_CONSUMER_VOLUME_DOWN 234 // Volume Decrement +typedef uint8_t consumer_cmd_t; + +#define HID_CC_RPT_MUTE 1 +#define HID_CC_RPT_POWER 2 +#define HID_CC_RPT_LAST 3 +#define HID_CC_RPT_ASSIGN_SEL 4 +#define HID_CC_RPT_PLAY 5 +#define HID_CC_RPT_PAUSE 6 +#define HID_CC_RPT_RECORD 7 +#define HID_CC_RPT_FAST_FWD 8 +#define HID_CC_RPT_REWIND 9 +#define HID_CC_RPT_SCAN_NEXT_TRK 10 +#define HID_CC_RPT_SCAN_PREV_TRK 11 +#define HID_CC_RPT_STOP 12 + +#define HID_CC_RPT_CHANNEL_UP 0x01 +#define HID_CC_RPT_CHANNEL_DOWN 0x03 +#define HID_CC_RPT_VOLUME_UP 0x40 +#define HID_CC_RPT_VOLUME_DOWN 0x80 + +// HID Consumer Control report bitmasks +#define HID_CC_RPT_NUMERIC_BITS 0xF0 +#define HID_CC_RPT_CHANNEL_BITS 0xCF +#define HID_CC_RPT_VOLUME_BITS 0x3F +#define HID_CC_RPT_BUTTON_BITS 0xF0 +#define HID_CC_RPT_SELECTION_BITS 0xCF + + +// Macros for the HID Consumer Control 2-byte report +#define HID_CC_RPT_SET_NUMERIC(s, x) (s)[0] &= HID_CC_RPT_NUMERIC_BITS; \ + (s)[0] = (x) +#define HID_CC_RPT_SET_CHANNEL(s, x) (s)[0] &= HID_CC_RPT_CHANNEL_BITS; \ + (s)[0] |= ((x) & 0x03) << 4 +#define HID_CC_RPT_SET_VOLUME_UP(s) (s)[0] &= HID_CC_RPT_VOLUME_BITS; \ + (s)[0] |= 0x40 +#define HID_CC_RPT_SET_VOLUME_DOWN(s) (s)[0] &= HID_CC_RPT_VOLUME_BITS; \ + (s)[0] |= 0x80 +#define HID_CC_RPT_SET_BUTTON(s, x) (s)[1] &= HID_CC_RPT_BUTTON_BITS; \ + (s)[1] |= (x) +#define HID_CC_RPT_SET_SELECTION(s, x) (s)[1] &= HID_CC_RPT_SELECTION_BITS; \ + (s)[1] |= ((x) & 0x03) << 4 + + +// HID report mapping table +typedef struct +{ + uint16_t handle; // Handle of report characteristic + uint16_t cccdHandle; // Handle of CCCD for report characteristic + uint8_t id; // Report ID + uint8_t type; // Report type + uint8_t mode; // Protocol mode (report or boot) +} hid_report_map_t; + +// HID dev configuration structure +typedef struct +{ + uint32_t idleTimeout; // Idle timeout in milliseconds + uint8_t hidFlags; // HID feature flags + +} hid_dev_cfg_t; + +void hid_dev_register_reports(uint8_t num_reports, hid_report_map_t *p_report); + +void hid_dev_send_report(esp_gatt_if_t gatts_if, uint16_t conn_id, + uint8_t id, uint8_t type, uint8_t length, uint8_t *data); + +void hid_consumer_build_report(uint8_t *buffer, consumer_cmd_t cmd); + +void hid_keyboard_build_report(uint8_t *buffer, keyboard_cmd_t cmd); + +void hid_mouse_build_report(uint8_t *buffer, mouse_cmd_t cmd); + +#endif /* HID_DEV_H__ */ + diff --git a/main/hid_device_le_prf.c b/main/hid_device_le_prf.c new file mode 100644 index 0000000..fef66aa --- /dev/null +++ b/main/hid_device_le_prf.c @@ -0,0 +1,738 @@ +// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at + +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "hidd_le_prf_int.h" +#include +#include "bt_types.h" +#include "bt_trace.h" +//#include "esp_gap_ble_api.h" + + +/// characteristic presentation information +struct prf_char_pres_fmt +{ + /// Unit (The Unit is a UUID) + uint16_t unit; + /// Description + uint16_t description; + /// Format + uint8_t format; + /// Exponent + uint8_t exponent; + /// Name space + uint8_t name_space; +}; + +// HID report mapping table +static hid_report_map_t hid_rpt_map[HID_NUM_REPORTS]; + + +// HID Report Map characteristic value +// Keyboard report descriptor (using format for Boot interface descriptor) +static const uint8_t hidReportMap[] = { + 0x05, 0x01, // Usage Page (Generic Desktop) + 0x09, 0x02, // Usage (Mouse) + 0xA1, 0x01, // Collection (Application) + 0x85, 0x01, // Report Id (1) + 0x09, 0x01, // Usage (Pointer) + 0xA1, 0x00, // Collection (Physical) + 0x05, 0x09, // Usage Page (Buttons) + 0x19, 0x01, // Usage Minimum (01) - Button 1 + 0x29, 0x03, // Usage Maximum (03) - Button 3 + 0x15, 0x00, // Logical Minimum (0) + 0x25, 0x01, // Logical Maximum (1) + 0x75, 0x01, // Report Size (1) + 0x95, 0x03, // Report Count (3) + 0x81, 0x02, // Input (Data, Variable, Absolute) - Button states + 0x75, 0x05, // Report Size (5) + 0x95, 0x01, // Report Count (1) + 0x81, 0x01, // Input (Constant) - Padding or Reserved bits + 0x05, 0x01, // Usage Page (Generic Desktop) + 0x09, 0x30, // Usage (X) + 0x09, 0x31, // Usage (Y) + 0x09, 0x38, // Usage (Wheel) + 0x15, 0x81, // Logical Minimum (-127) + 0x25, 0x7F, // Logical Maximum (127) + 0x75, 0x08, // Report Size (8) + 0x95, 0x03, // Report Count (3) + 0x81, 0x06, // Input (Data, Variable, Relative) - X & Y coordinate + 0xC0, // End Collection + 0xC0, // End Collection + + 0x05, 0x01, // Usage Pg (Generic Desktop) + 0x09, 0x06, // Usage (Keyboard) + 0xA1, 0x01, // Collection: (Application) + 0x85, 0x02, // Report Id (2) + // + 0x05, 0x07, // Usage Pg (Key Codes) + 0x19, 0xE0, // Usage Min (224) + 0x29, 0xE7, // Usage Max (231) + 0x15, 0x00, // Log Min (0) + 0x25, 0x01, // Log Max (1) + // + // Modifier byte + 0x75, 0x01, // Report Size (1) + 0x95, 0x08, // Report Count (8) + 0x81, 0x02, // Input: (Data, Variable, Absolute) + // + // Reserved byte + 0x95, 0x01, // Report Count (1) + 0x75, 0x08, // Report Size (8) + 0x81, 0x01, // Input: (Constant) + // + // LED report + 0x95, 0x05, // Report Count (5) + 0x75, 0x01, // Report Size (1) + 0x05, 0x08, // Usage Pg (LEDs) + 0x19, 0x01, // Usage Min (1) + 0x29, 0x05, // Usage Max (5) + 0x91, 0x02, // Output: (Data, Variable, Absolute) + // + // LED report padding + 0x95, 0x01, // Report Count (1) + 0x75, 0x03, // Report Size (3) + 0x91, 0x01, // Output: (Constant) + // + // Key arrays (6 bytes) + 0x95, 0x06, // Report Count (6) + 0x75, 0x08, // Report Size (8) + 0x15, 0x00, // Log Min (0) + 0x25, 0x65, // Log Max (101) + 0x05, 0x07, // Usage Pg (Key Codes) + 0x19, 0x00, // Usage Min (0) + 0x29, 0x65, // Usage Max (101) + 0x81, 0x00, // Input: (Data, Array) + // + 0xC0, // End Collection + // + 0x05, 0x0C, // Usage Pg (Consumer Devices) + 0x09, 0x01, // Usage (Consumer Control) + 0xA1, 0x01, // Collection (Application) + 0x85, 0x03, // Report Id (3) + 0x09, 0x02, // Usage (Numeric Key Pad) + 0xA1, 0x02, // Collection (Logical) + 0x05, 0x09, // Usage Pg (Button) + 0x19, 0x01, // Usage Min (Button 1) + 0x29, 0x0A, // Usage Max (Button 10) + 0x15, 0x01, // Logical Min (1) + 0x25, 0x0A, // Logical Max (10) + 0x75, 0x04, // Report Size (4) + 0x95, 0x01, // Report Count (1) + 0x81, 0x00, // Input (Data, Ary, Abs) + 0xC0, // End Collection + 0x05, 0x0C, // Usage Pg (Consumer Devices) + 0x09, 0x86, // Usage (Channel) + 0x15, 0xFF, // Logical Min (-1) + 0x25, 0x01, // Logical Max (1) + 0x75, 0x02, // Report Size (2) + 0x95, 0x01, // Report Count (1) + 0x81, 0x46, // Input (Data, Var, Rel, Null) + 0x09, 0xE9, // Usage (Volume Up) + 0x09, 0xEA, // Usage (Volume Down) + 0x15, 0x00, // Logical Min (0) + 0x75, 0x01, // Report Size (1) + 0x95, 0x02, // Report Count (2) + 0x81, 0x02, // Input (Data, Var, Abs) + 0x09, 0xE2, // Usage (Mute) + 0x09, 0x30, // Usage (Power) + 0x09, 0x83, // Usage (Recall Last) + 0x09, 0x81, // Usage (Assign Selection) + 0x09, 0xB0, // Usage (Play) + 0x09, 0xB1, // Usage (Pause) + 0x09, 0xB2, // Usage (Record) + 0x09, 0xB3, // Usage (Fast Forward) + 0x09, 0xB4, // Usage (Rewind) + 0x09, 0xB5, // Usage (Scan Next) + 0x09, 0xB6, // Usage (Scan Prev) + 0x09, 0xB7, // Usage (Stop) + 0x15, 0x01, // Logical Min (1) + 0x25, 0x0C, // Logical Max (12) + 0x75, 0x04, // Report Size (4) + 0x95, 0x01, // Report Count (1) + 0x81, 0x00, // Input (Data, Ary, Abs) + 0x09, 0x80, // Usage (Selection) + 0xA1, 0x02, // Collection (Logical) + 0x05, 0x09, // Usage Pg (Button) + 0x19, 0x01, // Usage Min (Button 1) + 0x29, 0x03, // Usage Max (Button 3) + 0x15, 0x01, // Logical Min (1) + 0x25, 0x03, // Logical Max (3) + 0x75, 0x02, // Report Size (2) + 0x81, 0x00, // Input (Data, Ary, Abs) + 0xC0, // End Collection + 0x81, 0x03, // Input (Const, Var, Abs) + 0xC0 // End Collection +}; + +/// Battery Service Attributes Indexes +enum +{ + BAS_IDX_SVC, + + BAS_IDX_BATT_LVL_CHAR, + BAS_IDX_BATT_LVL_VAL, + BAS_IDX_BATT_LVL_NTF_CFG, + BAS_IDX_BATT_LVL_PRES_FMT, + + BAS_IDX_NB, +}; + +#define HI_UINT16(a) (((a) >> 8) & 0xFF) +#define LO_UINT16(a) ((a) & 0xFF) + +hidd_le_env_t hidd_le_env; + +// HID report map length +uint8_t hidReportMapLen = sizeof(hidReportMap); +uint8_t hidProtocolMode = HID_PROTOCOL_MODE_REPORT; + +// HID report mapping table +//static hidRptMap_t hidRptMap[HID_NUM_REPORTS]; + +// HID Information characteristic value +static uint8_t hidInfo[HID_INFORMATION_LEN] = { + LO_UINT16(0x0111), HI_UINT16(0x0111), // bcdHID (USB HID version) + //TODO: setter for this country code field?!? + 0x00, // bCountryCode + HID_KBD_FLAGS // Flags +}; + + +// HID External Report Reference Descriptor +static uint16_t hidExtReportRefDesc = ESP_GATT_UUID_BATTERY_LEVEL; + +// HID Report Reference characteristic descriptor, mouse input +static uint8_t hidReportRefMouseIn[HID_REPORT_REF_LEN] = + { HID_RPT_ID_MOUSE_IN, HID_REPORT_TYPE_INPUT }; + + +// HID Report Reference characteristic descriptor, key input +static uint8_t hidReportRefKeyIn[HID_REPORT_REF_LEN] = + { HID_RPT_ID_KEY_IN, HID_REPORT_TYPE_INPUT }; + +// HID Report Reference characteristic descriptor, LED output +static uint8_t hidReportRefLedOut[HID_REPORT_REF_LEN] = + { HID_RPT_ID_LED_OUT, HID_REPORT_TYPE_OUTPUT }; + +// HID Report Reference characteristic descriptor, Feature +static uint8_t hidReportRefFeature[HID_REPORT_REF_LEN] = + { HID_RPT_ID_FEATURE, HID_REPORT_TYPE_FEATURE }; + +// HID Report Reference characteristic descriptor, consumer control input +static uint8_t hidReportRefCCIn[HID_REPORT_REF_LEN] = + { HID_RPT_ID_CC_IN, HID_REPORT_TYPE_INPUT }; + + +/* + * Heart Rate PROFILE ATTRIBUTES + **************************************************************************************** + */ + +/// hid Service uuid +static uint16_t hid_le_svc = ATT_SVC_HID; +uint16_t hid_count = 0; +esp_gatts_incl_svc_desc_t incl_svc = {0}; + +#define CHAR_DECLARATION_SIZE (sizeof(uint8_t)) +///the uuid definition +static const uint16_t primary_service_uuid = ESP_GATT_UUID_PRI_SERVICE; +static const uint16_t include_service_uuid = ESP_GATT_UUID_INCLUDE_SERVICE; +static const uint16_t character_declaration_uuid = ESP_GATT_UUID_CHAR_DECLARE; +static const uint16_t character_client_config_uuid = ESP_GATT_UUID_CHAR_CLIENT_CONFIG; +static const uint16_t hid_info_char_uuid = ESP_GATT_UUID_HID_INFORMATION; +static const uint16_t hid_report_map_uuid = ESP_GATT_UUID_HID_REPORT_MAP; +static const uint16_t hid_control_point_uuid = ESP_GATT_UUID_HID_CONTROL_POINT; +static const uint16_t hid_report_uuid = ESP_GATT_UUID_HID_REPORT; +static const uint16_t hid_proto_mode_uuid = ESP_GATT_UUID_HID_PROTO_MODE; +static const uint16_t hid_kb_input_uuid = ESP_GATT_UUID_HID_BT_KB_INPUT; +static const uint16_t hid_kb_output_uuid = ESP_GATT_UUID_HID_BT_KB_OUTPUT; +static const uint16_t hid_mouse_input_uuid = ESP_GATT_UUID_HID_BT_MOUSE_INPUT; +static const uint16_t hid_repot_map_ext_desc_uuid = ESP_GATT_UUID_EXT_RPT_REF_DESCR; +static const uint16_t hid_report_ref_descr_uuid = ESP_GATT_UUID_RPT_REF_DESCR; +///the propoty definition +static const uint8_t char_prop_notify = ESP_GATT_CHAR_PROP_BIT_NOTIFY; +static const uint8_t char_prop_read = ESP_GATT_CHAR_PROP_BIT_READ; +static const uint8_t char_prop_write = ESP_GATT_CHAR_PROP_BIT_WRITE; +static const uint8_t char_prop_read_write = ESP_GATT_CHAR_PROP_BIT_WRITE|ESP_GATT_CHAR_PROP_BIT_READ; +static const uint8_t char_prop_read_notify = ESP_GATT_CHAR_PROP_BIT_READ|ESP_GATT_CHAR_PROP_BIT_NOTIFY; + +/// battary Service +static const uint16_t battary_svc = ESP_GATT_UUID_BATTERY_SERVICE_SVC; + +static const uint16_t bat_lev_uuid = ESP_GATT_UUID_BATTERY_LEVEL; +static const uint8_t bat_lev_ccc[2] ={ 0x00, 0x00}; +static const uint16_t char_format_uuid = ESP_GATT_UUID_CHAR_PRESENT_FORMAT; + +static uint8_t battary_lev = 50; +/// Full HRS Database Description - Used to add attributes into the database +static const esp_gatts_attr_db_t bas_att_db[BAS_IDX_NB] = +{ + // Heart Rate Service Declaration + [BAS_IDX_SVC] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&primary_service_uuid, ESP_GATT_PERM_READ, + sizeof(uint16_t), sizeof(battary_svc), (uint8_t *)&battary_svc}}, + + // Heart Rate Measurement Characteristic Declaration + [BAS_IDX_BATT_LVL_CHAR] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, ESP_GATT_PERM_READ, + CHAR_DECLARATION_SIZE,CHAR_DECLARATION_SIZE, (uint8_t *)&char_prop_read_notify}}, + + // Heart Rate Measurement Characteristic Value + [BAS_IDX_BATT_LVL_VAL] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&bat_lev_uuid, ESP_GATT_PERM_READ, + sizeof(uint8_t),sizeof(uint8_t), &battary_lev}}, + + // Heart Rate Measurement Characteristic - Client Characteristic Configuration Descriptor + [BAS_IDX_BATT_LVL_NTF_CFG] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, ESP_GATT_PERM_READ|ESP_GATT_PERM_WRITE, + sizeof(uint16_t),sizeof(bat_lev_ccc), (uint8_t *)bat_lev_ccc}}, + + // Body Sensor Location Characteristic Declaration + [BAS_IDX_BATT_LVL_PRES_FMT] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&char_format_uuid, ESP_GATT_PERM_READ, + sizeof(struct prf_char_pres_fmt), 0, NULL}}, +}; + + +/// Full Hid device Database Description - Used to add attributes into the database +static esp_gatts_attr_db_t hidd_le_gatt_db[HIDD_LE_IDX_NB] = +{ + // HID Service Declaration + [HIDD_LE_IDX_SVC] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&primary_service_uuid, + ESP_GATT_PERM_READ_ENCRYPTED, sizeof(uint16_t), sizeof(hid_le_svc), + (uint8_t *)&hid_le_svc}}, + + // HID Service Declaration + [HIDD_LE_IDX_INCL_SVC] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&include_service_uuid, + ESP_GATT_PERM_READ, + sizeof(esp_gatts_incl_svc_desc_t), sizeof(esp_gatts_incl_svc_desc_t), + (uint8_t *)&incl_svc}}, + + // HID Information Characteristic Declaration + [HIDD_LE_IDX_HID_INFO_CHAR] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, + ESP_GATT_PERM_READ, + CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, + (uint8_t *)&char_prop_read_write}}, + // HID Information Characteristic Value + [HIDD_LE_IDX_HID_INFO_VAL] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&hid_info_char_uuid, + ESP_GATT_PERM_READ, + sizeof(hids_hid_info_t), sizeof(hidInfo), + (uint8_t *)&hidInfo}}, + + // HID Control Point Characteristic Declaration + [HIDD_LE_IDX_HID_CTNL_PT_CHAR] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, + ESP_GATT_PERM_READ, + CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, + (uint8_t *)&char_prop_write}}, + // HID Control Point Characteristic Value + [HIDD_LE_IDX_HID_CTNL_PT_VAL] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&hid_control_point_uuid, + ESP_GATT_PERM_WRITE, + sizeof(uint8_t), 0, + NULL}}, + + // Report Map Characteristic Declaration + [HIDD_LE_IDX_REPORT_MAP_CHAR] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, + ESP_GATT_PERM_READ, + CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, + (uint8_t *)&char_prop_read}}, + // Report Map Characteristic Value + [HIDD_LE_IDX_REPORT_MAP_VAL] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&hid_report_map_uuid, + ESP_GATT_PERM_READ, + HIDD_LE_REPORT_MAP_MAX_LEN, sizeof(hidReportMap), + (uint8_t *)&hidReportMap}}, + + // Report Map Characteristic - External Report Reference Descriptor + [HIDD_LE_IDX_REPORT_MAP_EXT_REP_REF] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&hid_repot_map_ext_desc_uuid, + ESP_GATT_PERM_READ, + sizeof(uint16_t), sizeof(uint16_t), + (uint8_t *)&hidExtReportRefDesc}}, + + // Protocol Mode Characteristic Declaration + [HIDD_LE_IDX_PROTO_MODE_CHAR] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, + ESP_GATT_PERM_READ, + CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, + (uint8_t *)&char_prop_read_write}}, + // Protocol Mode Characteristic Value + [HIDD_LE_IDX_PROTO_MODE_VAL] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&hid_proto_mode_uuid, + (ESP_GATT_PERM_READ|ESP_GATT_PERM_WRITE), + sizeof(uint8_t), sizeof(hidProtocolMode), + (uint8_t *)&hidProtocolMode}}, + + [HIDD_LE_IDX_REPORT_MOUSE_IN_CHAR] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, + ESP_GATT_PERM_READ, + CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, + (uint8_t *)&char_prop_read_notify}}, + + [HIDD_LE_IDX_REPORT_MOUSE_IN_VAL] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&hid_report_uuid, + ESP_GATT_PERM_READ, + HIDD_LE_REPORT_MAX_LEN, 0, + NULL}}, + + [HIDD_LE_IDX_REPORT_MOUSE_IN_CCC] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, + (ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE), + sizeof(uint16_t), 0, + NULL}}, + + [HIDD_LE_IDX_REPORT_MOUSE_REP_REF] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&hid_report_ref_descr_uuid, + ESP_GATT_PERM_READ, + sizeof(hidReportRefMouseIn), sizeof(hidReportRefMouseIn), + hidReportRefMouseIn}}, + // Report Characteristic Declaration + [HIDD_LE_IDX_REPORT_KEY_IN_CHAR] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, + ESP_GATT_PERM_READ, + CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, + (uint8_t *)&char_prop_read_notify}}, + // Report Characteristic Value + [HIDD_LE_IDX_REPORT_KEY_IN_VAL] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&hid_report_uuid, + ESP_GATT_PERM_READ, + HIDD_LE_REPORT_MAX_LEN, 0, + NULL}}, + // Report KEY INPUT Characteristic - Client Characteristic Configuration Descriptor + [HIDD_LE_IDX_REPORT_KEY_IN_CCC] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, + (ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE), + sizeof(uint16_t), 0, + NULL}}, + // Report Characteristic - Report Reference Descriptor + [HIDD_LE_IDX_REPORT_KEY_IN_REP_REF] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&hid_report_ref_descr_uuid, + ESP_GATT_PERM_READ, + sizeof(hidReportRefKeyIn), sizeof(hidReportRefKeyIn), + hidReportRefKeyIn}}, + + // Report Characteristic Declaration + [HIDD_LE_IDX_REPORT_LED_OUT_CHAR] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, + ESP_GATT_PERM_READ, + CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, + (uint8_t *)&char_prop_read_write}}, + + [HIDD_LE_IDX_REPORT_LED_OUT_VAL] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&hid_report_uuid, + ESP_GATT_PERM_READ|ESP_GATT_PERM_WRITE, + HIDD_LE_REPORT_MAX_LEN, 0, + NULL}}, + [HIDD_LE_IDX_REPORT_LED_OUT_REP_REF] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&hid_report_ref_descr_uuid, + ESP_GATT_PERM_READ, + sizeof(hidReportRefLedOut), sizeof(hidReportRefLedOut), + hidReportRefLedOut}}, + + // Report Characteristic Declaration + [HIDD_LE_IDX_REPORT_CC_IN_CHAR] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, + ESP_GATT_PERM_READ, + CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, + (uint8_t *)&char_prop_read_notify}}, + // Report Characteristic Value + [HIDD_LE_IDX_REPORT_CC_IN_VAL] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&hid_report_uuid, + ESP_GATT_PERM_READ, + HIDD_LE_REPORT_MAX_LEN, 0, + NULL}}, + // Report KEY INPUT Characteristic - Client Characteristic Configuration Descriptor + [HIDD_LE_IDX_REPORT_CC_IN_CCC] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, + (ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE), + sizeof(uint16_t), 0, + NULL}}, + // Report Characteristic - Report Reference Descriptor + [HIDD_LE_IDX_REPORT_CC_IN_REP_REF] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&hid_report_ref_descr_uuid, + ESP_GATT_PERM_READ, + sizeof(hidReportRefCCIn), sizeof(hidReportRefCCIn), + hidReportRefCCIn}}, + + // Boot Keyboard Input Report Characteristic Declaration + [HIDD_LE_IDX_BOOT_KB_IN_REPORT_CHAR] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, + ESP_GATT_PERM_READ, + CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, + (uint8_t *)&char_prop_read_notify}}, + // Boot Keyboard Input Report Characteristic Value + [HIDD_LE_IDX_BOOT_KB_IN_REPORT_VAL] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&hid_kb_input_uuid, + ESP_GATT_PERM_READ, + HIDD_LE_BOOT_REPORT_MAX_LEN, 0, + NULL}}, + // Boot Keyboard Input Report Characteristic - Client Characteristic Configuration Descriptor + [HIDD_LE_IDX_BOOT_KB_IN_REPORT_NTF_CFG] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, + (ESP_GATT_PERM_READ|ESP_GATT_PERM_WRITE), + sizeof(uint16_t), 0, + NULL}}, + + // Boot Keyboard Output Report Characteristic Declaration + [HIDD_LE_IDX_BOOT_KB_OUT_REPORT_CHAR] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, + ESP_GATT_PERM_READ, + CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, + (uint8_t *)&char_prop_read_write}}, + // Boot Keyboard Output Report Characteristic Value + [HIDD_LE_IDX_BOOT_KB_OUT_REPORT_VAL] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&hid_kb_output_uuid, + (ESP_GATT_PERM_READ|ESP_GATT_PERM_WRITE), + HIDD_LE_BOOT_REPORT_MAX_LEN, 0, + NULL}}, + + // Boot Mouse Input Report Characteristic Declaration + [HIDD_LE_IDX_BOOT_MOUSE_IN_REPORT_CHAR] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, + ESP_GATT_PERM_READ, + CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, + (uint8_t *)&char_prop_read_notify}}, + // Boot Mouse Input Report Characteristic Value + [HIDD_LE_IDX_BOOT_MOUSE_IN_REPORT_VAL] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&hid_mouse_input_uuid, + ESP_GATT_PERM_READ, + HIDD_LE_BOOT_REPORT_MAX_LEN, 0, + NULL}}, + // Boot Mouse Input Report Characteristic - Client Characteristic Configuration Descriptor + [HIDD_LE_IDX_BOOT_MOUSE_IN_REPORT_NTF_CFG] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_client_config_uuid, + (ESP_GATT_PERM_READ | ESP_GATT_PERM_WRITE), + sizeof(uint16_t), 0, + NULL}}, + + // Report Characteristic Declaration + [HIDD_LE_IDX_REPORT_CHAR] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&character_declaration_uuid, + ESP_GATT_PERM_READ, + CHAR_DECLARATION_SIZE, CHAR_DECLARATION_SIZE, + (uint8_t *)&char_prop_read_write}}, + // Report Characteristic Value + [HIDD_LE_IDX_REPORT_VAL] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&hid_report_uuid, + ESP_GATT_PERM_READ, + HIDD_LE_REPORT_MAX_LEN, 0, + NULL}}, + // Report Characteristic - Report Reference Descriptor + [HIDD_LE_IDX_REPORT_REP_REF] = {{ESP_GATT_AUTO_RSP}, {ESP_UUID_LEN_16, (uint8_t *)&hid_report_ref_descr_uuid, + ESP_GATT_PERM_READ, + sizeof(hidReportRefFeature), sizeof(hidReportRefFeature), + hidReportRefFeature}}, +}; + +static void hid_add_id_tbl(void); + +void esp_hidd_prf_cb_hdl(esp_gatts_cb_event_t event, esp_gatt_if_t gatts_if, + esp_ble_gatts_cb_param_t *param) +{ + switch(event) { + case ESP_GATTS_REG_EVT: { + esp_hidd_cb_param_t hidd_param; + hidd_param.init_finish.state = param->reg.status; + if(param->reg.app_id == HIDD_APP_ID) { + hidd_le_env.gatt_if = gatts_if; + if(hidd_le_env.hidd_cb != NULL) { + (hidd_le_env.hidd_cb)(ESP_HIDD_EVENT_REG_FINISH, &hidd_param); + hidd_le_create_service(hidd_le_env.gatt_if); + } + } + if(param->reg.app_id == BATTRAY_APP_ID) { + hidd_param.init_finish.gatts_if = gatts_if; + if(hidd_le_env.hidd_cb != NULL) { + (hidd_le_env.hidd_cb)(ESP_BAT_EVENT_REG, &hidd_param); + } + + } + + break; + } + case ESP_GATTS_CONF_EVT: { + break; + } + case ESP_GATTS_CREATE_EVT: + break; + case ESP_GATTS_CONNECT_EVT: + //if(param->connect.is_connected) { + if(param->connect.conn_id != 0) { + esp_hidd_cb_param_t cb_param = {0}; + LOG_ERROR("the connection establish, conn_id = %x",param->connect.conn_id); + memcpy(cb_param.connect.remote_bda, param->connect.remote_bda, sizeof(esp_bd_addr_t)); + cb_param.connect.conn_id = param->connect.conn_id; + hidd_clcb_alloc(param->connect.conn_id, param->connect.remote_bda); + //esp_ble_set_encryption(param->connect.remote_bda, ESP_BLE_SEC_ENCRYPT_NO_MITM); + if(hidd_le_env.hidd_cb != NULL) { + (hidd_le_env.hidd_cb)(ESP_HIDD_EVENT_BLE_CONNECT, &cb_param); + } + } + break; + case ESP_GATTS_DISCONNECT_EVT: { + if(hidd_le_env.hidd_cb != NULL) { + (hidd_le_env.hidd_cb)(ESP_HIDD_EVENT_BLE_DISCONNECT, NULL); + } + hidd_clcb_dealloc(param->disconnect.conn_id); + break; + } + case ESP_GATTS_CLOSE_EVT: + break; + case ESP_GATTS_WRITE_EVT: { + break; + } + case ESP_GATTS_CREAT_ATTR_TAB_EVT: { + if (param->add_attr_tab.num_handle == BAS_IDX_NB && + param->add_attr_tab.svc_uuid.uuid.uuid16 == ESP_GATT_UUID_BATTERY_SERVICE_SVC && + param->add_attr_tab.status == ESP_GATT_OK) { + incl_svc.start_hdl = param->add_attr_tab.handles[BAS_IDX_SVC]; + incl_svc.end_hdl = incl_svc.start_hdl + BAS_IDX_NB -1; + LOG_ERROR("%s(), start added the hid service to the stack database. incl_handle = %d", + __func__, incl_svc.start_hdl); + esp_ble_gatts_create_attr_tab(hidd_le_gatt_db, gatts_if, HIDD_LE_IDX_NB, 0); + } + if (param->add_attr_tab.num_handle == HIDD_LE_IDX_NB && + param->add_attr_tab.status == ESP_GATT_OK) { + memcpy(hidd_le_env.hidd_inst.att_tbl, param->add_attr_tab.handles, + HIDD_LE_IDX_NB*sizeof(uint16_t)); + LOG_ERROR("hid svc handle = %x",hidd_le_env.hidd_inst.att_tbl[HIDD_LE_IDX_SVC]); + hid_add_id_tbl(); + esp_ble_gatts_start_service(hidd_le_env.hidd_inst.att_tbl[HIDD_LE_IDX_SVC]); + } else { + esp_ble_gatts_start_service(param->add_attr_tab.handles[0]); + } + break; + } + + default: + break; + } +} + +void hidd_le_create_service(esp_gatt_if_t gatts_if) +{ + /* Here should added the battery service first, because the hid service should include the battery service. + After finish to added the battery service then can added the hid service. */ + esp_ble_gatts_create_attr_tab(bas_att_db, gatts_if, BAS_IDX_NB, 0); + +} + +/** set the bCountryCode field of the HID info. + * @warning Set this before initializing anything else! + * */ +void hidd_set_countrycode(uint8_t countrycode) +{ + hidInfo[2] = countrycode; +} + +void hidd_le_init(void) +{ + + // Reset the hid device target environment + memset(&hidd_le_env, 0, sizeof(hidd_le_env_t)); +} + +void hidd_clcb_alloc (uint16_t conn_id, esp_bd_addr_t bda) +{ + uint8_t i_clcb = 0; + hidd_clcb_t *p_clcb = NULL; + + for (i_clcb = 0, p_clcb= hidd_le_env.hidd_clcb; i_clcb < HID_MAX_APPS; i_clcb++, p_clcb++) { + if (!p_clcb->in_use) { + p_clcb->in_use = TRUE; + p_clcb->conn_id = conn_id; + p_clcb->connected = TRUE; + memcpy (p_clcb->remote_bda, bda, ESP_BD_ADDR_LEN); + break; + } + } + return; +} + +bool hidd_clcb_dealloc (uint16_t conn_id) +{ + uint8_t i_clcb = 0; + hidd_clcb_t *p_clcb = NULL; + + for (i_clcb = 0, p_clcb= hidd_le_env.hidd_clcb; i_clcb < HID_MAX_APPS; i_clcb++, p_clcb++) { + memset(p_clcb, 0, sizeof(hidd_clcb_t)); + return TRUE; + } + + return FALSE; +} + +esp_err_t hidd_register_cb(void) +{ + esp_err_t status; + status = esp_ble_gatts_register_callback(esp_hidd_prf_cb_hdl); + return status; +} + +void hidd_set_attr_value(uint16_t handle, uint16_t val_len, const uint8_t *value) +{ + hidd_inst_t *hidd_inst = &hidd_le_env.hidd_inst; + if(hidd_inst->att_tbl[HIDD_LE_IDX_HID_INFO_VAL] <= handle && + hidd_inst->att_tbl[HIDD_LE_IDX_REPORT_REP_REF] >= handle) { + esp_ble_gatts_set_attr_value(handle, val_len, value); + } else { + LOG_ERROR("%s error:Invalid handle value.",__func__); + } + return; +} + +void hidd_get_attr_value(uint16_t handle, uint16_t *length, uint8_t **value) +{ + hidd_inst_t *hidd_inst = &hidd_le_env.hidd_inst; + if(hidd_inst->att_tbl[HIDD_LE_IDX_HID_INFO_VAL] <= handle && + hidd_inst->att_tbl[HIDD_LE_IDX_REPORT_REP_REF] >= handle){ + esp_ble_gatts_get_attr_value(handle, length, (const uint8_t **)value); + } else { + LOG_ERROR("%s error:Invalid handle value.", __func__); + } + + return; +} + +static void hid_add_id_tbl(void) +{ + // Mouse input report + hid_rpt_map[0].id = hidReportRefMouseIn[0]; + hid_rpt_map[0].type = hidReportRefMouseIn[1]; + hid_rpt_map[0].handle = hidd_le_env.hidd_inst.att_tbl[HIDD_LE_IDX_REPORT_MOUSE_IN_VAL]; + hid_rpt_map[0].cccdHandle = hidd_le_env.hidd_inst.att_tbl[HIDD_LE_IDX_REPORT_MOUSE_IN_VAL]; + hid_rpt_map[0].mode = HID_PROTOCOL_MODE_REPORT; + + // Key input report + hid_rpt_map[1].id = hidReportRefKeyIn[0]; + hid_rpt_map[1].type = hidReportRefKeyIn[1]; + hid_rpt_map[1].handle = hidd_le_env.hidd_inst.att_tbl[HIDD_LE_IDX_REPORT_KEY_IN_VAL]; + hid_rpt_map[1].cccdHandle = hidd_le_env.hidd_inst.att_tbl[HIDD_LE_IDX_REPORT_KEY_IN_CCC]; + hid_rpt_map[1].mode = HID_PROTOCOL_MODE_REPORT; + + // Consumer Control input report + hid_rpt_map[2].id = hidReportRefCCIn[0]; + hid_rpt_map[2].type = hidReportRefCCIn[1]; + hid_rpt_map[2].handle = hidd_le_env.hidd_inst.att_tbl[HIDD_LE_IDX_REPORT_CC_IN_VAL]; + hid_rpt_map[2].cccdHandle = hidd_le_env.hidd_inst.att_tbl[HIDD_LE_IDX_REPORT_CC_IN_CCC]; + hid_rpt_map[2].mode = HID_PROTOCOL_MODE_REPORT; + + // LED output report + hid_rpt_map[3].id = hidReportRefLedOut[0]; + hid_rpt_map[3].type = hidReportRefLedOut[1]; + hid_rpt_map[3].handle = hidd_le_env.hidd_inst.att_tbl[HIDD_LE_IDX_REPORT_LED_OUT_VAL]; + hid_rpt_map[3].cccdHandle = 0; + hid_rpt_map[3].mode = HID_PROTOCOL_MODE_REPORT; + + // Boot keyboard input report + // Use same ID and type as key input report + hid_rpt_map[4].id = hidReportRefKeyIn[0]; + hid_rpt_map[4].type = hidReportRefKeyIn[1]; + hid_rpt_map[4].handle = hidd_le_env.hidd_inst.att_tbl[HIDD_LE_IDX_BOOT_KB_IN_REPORT_VAL]; + hid_rpt_map[4].cccdHandle = 0; + hid_rpt_map[4].mode = HID_PROTOCOL_MODE_BOOT; + + // Boot keyboard output report + // Use same ID and type as LED output report + hid_rpt_map[5].id = hidReportRefLedOut[0]; + hid_rpt_map[5].type = hidReportRefLedOut[1]; + hid_rpt_map[5].handle = hidd_le_env.hidd_inst.att_tbl[HIDD_LE_IDX_BOOT_KB_OUT_REPORT_VAL]; + hid_rpt_map[5].cccdHandle = 0; + hid_rpt_map[5].mode = HID_PROTOCOL_MODE_BOOT; + + // Boot mouse input report + // Use same ID and type as mouse input report + hid_rpt_map[6].id = hidReportRefMouseIn[0]; + hid_rpt_map[6].type = hidReportRefMouseIn[1]; + hid_rpt_map[6].handle = hidd_le_env.hidd_inst.att_tbl[HIDD_LE_IDX_BOOT_MOUSE_IN_REPORT_VAL]; + hid_rpt_map[6].cccdHandle = 0; + hid_rpt_map[6].mode = HID_PROTOCOL_MODE_BOOT; + + // Feature report + hid_rpt_map[7].id = hidReportRefFeature[0]; + hid_rpt_map[7].type = hidReportRefFeature[1]; + hid_rpt_map[7].handle = hidd_le_env.hidd_inst.att_tbl[HIDD_LE_IDX_REPORT_VAL]; + hid_rpt_map[7].cccdHandle = 0; + hid_rpt_map[7].mode = HID_PROTOCOL_MODE_REPORT; + + + // Setup report ID map + hid_dev_register_reports(HID_NUM_REPORTS, hid_rpt_map); +} + diff --git a/main/hidd_le_prf_int.h b/main/hidd_le_prf_int.h new file mode 100644 index 0000000..442a723 --- /dev/null +++ b/main/hidd_le_prf_int.h @@ -0,0 +1,339 @@ +// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at + +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + + + +#ifndef __HID_DEVICE_LE_PRF__ +#define __HID_DEVICE_LE_PRF__ +#include "esp_gatts_api.h" +#include "esp_gatt_defs.h" +#include "esp_hidd_prf_api.h" +#include "esp_gap_ble_api.h" +#include "hid_dev.h" + + +/// Maximal number of HIDS that can be added in the DB +#ifndef USE_ONE_HIDS_INSTANCE +#define HIDD_LE_NB_HIDS_INST_MAX (2) +#else +#define HIDD_LE_NB_HIDS_INST_MAX (1) +#endif + +#define HIDD_GREAT_VER 0x01 //Version + Subversion +#define HIDD_SUB_VER 0x00 //Version + Subversion +#define HIDD_VERSION ((HIDD_GREAT_VER<<8)|HIDD_SUB_VER) //Version + Subversion + +#define HID_MAX_APPS 1 + +// Number of HID reports defined in the service +#define HID_NUM_REPORTS 9 + +// HID Report IDs for the service +#define HID_RPT_ID_MOUSE_IN 1 // Mouse input report ID +#define HID_RPT_ID_KEY_IN 2 // Keyboard input report ID +#define HID_RPT_ID_CC_IN 3 //Consumer Control input report ID +#define HID_RPT_ID_LED_OUT 0 // LED output report ID +#define HID_RPT_ID_FEATURE 0 // Feature report ID + +#define HIDD_APP_ID 0x1812//ATT_SVC_HID + +#define BATTRAY_APP_ID 0x180f + + +#define ATT_SVC_HID 0x1812 + +/// Maximal number of Report Char. that can be added in the DB for one HIDS - Up to 11 +#define HIDD_LE_NB_REPORT_INST_MAX (5) + +/// Maximal length of Report Char. Value +#define HIDD_LE_REPORT_MAX_LEN (45) +/// Maximal length of Report Map Char. Value +#define HIDD_LE_REPORT_MAP_MAX_LEN (512) + +/// Length of Boot Report Char. Value Maximal Length +#define HIDD_LE_BOOT_REPORT_MAX_LEN (8) + +/// Boot KB Input Report Notification Configuration Bit Mask +#define HIDD_LE_BOOT_KB_IN_NTF_CFG_MASK (0x40) +/// Boot KB Input Report Notification Configuration Bit Mask +#define HIDD_LE_BOOT_MOUSE_IN_NTF_CFG_MASK (0x80) +/// Boot Report Notification Configuration Bit Mask +#define HIDD_LE_REPORT_NTF_CFG_MASK (0x20) + + +/* HID information flags */ +#define HID_FLAGS_REMOTE_WAKE 0x01 // RemoteWake +#define HID_FLAGS_NORMALLY_CONNECTABLE 0x02 // NormallyConnectable + +/* Control point commands */ +#define HID_CMD_SUSPEND 0x00 // Suspend +#define HID_CMD_EXIT_SUSPEND 0x01 // Exit Suspend + +/* HID protocol mode values */ +#define HID_PROTOCOL_MODE_BOOT 0x00 // Boot Protocol Mode +#define HID_PROTOCOL_MODE_REPORT 0x01 // Report Protocol Mode + +/* Attribute value lengths */ +#define HID_PROTOCOL_MODE_LEN 1 // HID Protocol Mode +#define HID_INFORMATION_LEN 4 // HID Information +#define HID_REPORT_REF_LEN 2 // HID Report Reference Descriptor +#define HID_EXT_REPORT_REF_LEN 2 // External Report Reference Descriptor + +// HID feature flags +#define HID_KBD_FLAGS HID_FLAGS_REMOTE_WAKE + +/* HID Report type */ +#define HID_REPORT_TYPE_INPUT 1 +#define HID_REPORT_TYPE_OUTPUT 2 +#define HID_REPORT_TYPE_FEATURE 3 + + +/// HID Service Attributes Indexes +enum { + HIDD_LE_IDX_SVC, + + // Included Service + HIDD_LE_IDX_INCL_SVC, + + // HID Information + HIDD_LE_IDX_HID_INFO_CHAR, + HIDD_LE_IDX_HID_INFO_VAL, + + // HID Control Point + HIDD_LE_IDX_HID_CTNL_PT_CHAR, + HIDD_LE_IDX_HID_CTNL_PT_VAL, + + // Report Map + HIDD_LE_IDX_REPORT_MAP_CHAR, + HIDD_LE_IDX_REPORT_MAP_VAL, + HIDD_LE_IDX_REPORT_MAP_EXT_REP_REF, + + // Protocol Mode + HIDD_LE_IDX_PROTO_MODE_CHAR, + HIDD_LE_IDX_PROTO_MODE_VAL, + + // Report mouse input + HIDD_LE_IDX_REPORT_MOUSE_IN_CHAR, + HIDD_LE_IDX_REPORT_MOUSE_IN_VAL, + HIDD_LE_IDX_REPORT_MOUSE_IN_CCC, + HIDD_LE_IDX_REPORT_MOUSE_REP_REF, + //Report Key input + HIDD_LE_IDX_REPORT_KEY_IN_CHAR, + HIDD_LE_IDX_REPORT_KEY_IN_VAL, + HIDD_LE_IDX_REPORT_KEY_IN_CCC, + HIDD_LE_IDX_REPORT_KEY_IN_REP_REF, + ///Report Led output + HIDD_LE_IDX_REPORT_LED_OUT_CHAR, + HIDD_LE_IDX_REPORT_LED_OUT_VAL, + HIDD_LE_IDX_REPORT_LED_OUT_REP_REF, + + HIDD_LE_IDX_REPORT_CC_IN_CHAR, + HIDD_LE_IDX_REPORT_CC_IN_VAL, + HIDD_LE_IDX_REPORT_CC_IN_CCC, + HIDD_LE_IDX_REPORT_CC_IN_REP_REF, + + // Boot Keyboard Input Report + HIDD_LE_IDX_BOOT_KB_IN_REPORT_CHAR, + HIDD_LE_IDX_BOOT_KB_IN_REPORT_VAL, + HIDD_LE_IDX_BOOT_KB_IN_REPORT_NTF_CFG, + + // Boot Keyboard Output Report + HIDD_LE_IDX_BOOT_KB_OUT_REPORT_CHAR, + HIDD_LE_IDX_BOOT_KB_OUT_REPORT_VAL, + + // Boot Mouse Input Report + HIDD_LE_IDX_BOOT_MOUSE_IN_REPORT_CHAR, + HIDD_LE_IDX_BOOT_MOUSE_IN_REPORT_VAL, + HIDD_LE_IDX_BOOT_MOUSE_IN_REPORT_NTF_CFG, + + // Report + HIDD_LE_IDX_REPORT_CHAR, + HIDD_LE_IDX_REPORT_VAL, + HIDD_LE_IDX_REPORT_REP_REF, + //HIDD_LE_IDX_REPORT_NTF_CFG, + + HIDD_LE_IDX_NB, +}; + + +/// Attribute Table Indexes +enum { + HIDD_LE_INFO_CHAR, + HIDD_LE_CTNL_PT_CHAR, + HIDD_LE_REPORT_MAP_CHAR, + HIDD_LE_REPORT_CHAR, + HIDD_LE_PROTO_MODE_CHAR, + HIDD_LE_BOOT_KB_IN_REPORT_CHAR, + HIDD_LE_BOOT_KB_OUT_REPORT_CHAR, + HIDD_LE_BOOT_MOUSE_IN_REPORT_CHAR, + HIDD_LE_CHAR_MAX //= HIDD_LE_REPORT_CHAR + HIDD_LE_NB_REPORT_INST_MAX, +}; + +///att read event table Indexs +enum { + HIDD_LE_READ_INFO_EVT, + HIDD_LE_READ_CTNL_PT_EVT, + HIDD_LE_READ_REPORT_MAP_EVT, + HIDD_LE_READ_REPORT_EVT, + HIDD_LE_READ_PROTO_MODE_EVT, + HIDD_LE_BOOT_KB_IN_REPORT_EVT, + HIDD_LE_BOOT_KB_OUT_REPORT_EVT, + HIDD_LE_BOOT_MOUSE_IN_REPORT_EVT, + + HID_LE_EVT_MAX +}; + +/// Client Characteristic Configuration Codes +enum { + HIDD_LE_DESC_MASK = 0x10, + + HIDD_LE_BOOT_KB_IN_REPORT_CFG = HIDD_LE_BOOT_KB_IN_REPORT_CHAR | HIDD_LE_DESC_MASK, + HIDD_LE_BOOT_MOUSE_IN_REPORT_CFG = HIDD_LE_BOOT_MOUSE_IN_REPORT_CHAR | HIDD_LE_DESC_MASK, + HIDD_LE_REPORT_CFG = HIDD_LE_REPORT_CHAR | HIDD_LE_DESC_MASK, +}; + +/// Features Flag Values +enum { + HIDD_LE_CFG_KEYBOARD = 0x01, + HIDD_LE_CFG_MOUSE = 0x02, + HIDD_LE_CFG_PROTO_MODE = 0x04, + HIDD_LE_CFG_MAP_EXT_REF = 0x08, + HIDD_LE_CFG_BOOT_KB_WR = 0x10, + HIDD_LE_CFG_BOOT_MOUSE_WR = 0x20, +}; + +/// Report Char. Configuration Flag Values +enum { + HIDD_LE_CFG_REPORT_IN = 0x01, + HIDD_LE_CFG_REPORT_OUT = 0x02, + //HOGPD_CFG_REPORT_FEAT can be used as a mask to check Report type + HIDD_LE_CFG_REPORT_FEAT = 0x03, + HIDD_LE_CFG_REPORT_WR = 0x10, +}; + +/// Pointer to the connection clean-up function +#define HIDD_LE_CLEANUP_FNCT (NULL) + +/* + * TYPE DEFINITIONS + **************************************************************************************** + */ + +/// HIDD Features structure +typedef struct { + /// Service Features + uint8_t svc_features; + /// Number of Report Char. instances to add in the database + uint8_t report_nb; + /// Report Char. Configuration + uint8_t report_char_cfg[HIDD_LE_NB_REPORT_INST_MAX]; +} hidd_feature_t; + + +typedef struct { + bool in_use; + bool congest; + uint16_t conn_id; + bool connected; + esp_bd_addr_t remote_bda; + uint32_t trans_id; + uint8_t cur_srvc_id; + +} hidd_clcb_t; + +// HID report mapping table +typedef struct { + uint16_t handle; // Handle of report characteristic + uint16_t cccdHandle; // Handle of CCCD for report characteristic + uint8_t id; // Report ID + uint8_t type; // Report type + uint8_t mode; // Protocol mode (report or boot) +} hidRptMap_t; + + +typedef struct { + /// hidd profile id + uint8_t app_id; + /// Notified handle + uint16_t ntf_handle; + ///Attribute handle Table + uint16_t att_tbl[HIDD_LE_IDX_NB]; + /// Supported Features + hidd_feature_t hidd_feature[HIDD_LE_NB_HIDS_INST_MAX]; + /// Current Protocol Mode + uint8_t proto_mode[HIDD_LE_NB_HIDS_INST_MAX]; + /// Number of HIDS added in the database + uint8_t hids_nb; + uint8_t pending_evt; + uint16_t pending_hal; +} hidd_inst_t; + +/// Report Reference structure +typedef struct +{ + ///Report ID + uint8_t report_id; + ///Report Type + uint8_t report_type; +}hids_report_ref_t; + +/// HID Information structure +typedef struct +{ + /// bcdHID + uint16_t bcdHID; + /// bCountryCode + uint8_t bCountryCode; + /// Flags + uint8_t flags; +}hids_hid_info_t; + + +/* service engine control block */ +typedef struct { + hidd_clcb_t hidd_clcb[HID_MAX_APPS]; /* connection link*/ + esp_gatt_if_t gatt_if; + bool enabled; + bool is_take; + bool is_primery; + hidd_inst_t hidd_inst; + esp_hidd_event_cb_t hidd_cb; + uint8_t inst_id; +} hidd_le_env_t; + +extern hidd_le_env_t hidd_le_env; +extern uint8_t hidProtocolMode; + + +void hidd_clcb_alloc (uint16_t conn_id, esp_bd_addr_t bda); + +bool hidd_clcb_dealloc (uint16_t conn_id); + +void hidd_le_create_service(esp_gatt_if_t gatts_if); + +void hidd_set_attr_value(uint16_t handle, uint16_t val_len, const uint8_t *value); + +void hidd_get_attr_value(uint16_t handle, uint16_t *length, uint8_t **value); + + +/** set the bCountryCode field of the HID info. + * @warning Set this before initializing anything else! + * */ +void hidd_set_countrycode(uint8_t countrycode); + +esp_err_t hidd_register_cb(void); + + +#endif ///__HID_DEVICE_LE_PRF__ + diff --git a/main/keyboard.c b/main/keyboard.c new file mode 100644 index 0000000..3dfd11b --- /dev/null +++ b/main/keyboard.c @@ -0,0 +1,2092 @@ +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, + * MA 02110-1301, USA. + * + * Copyright 2017 Benjamin Aigner + * + * Heavily based on Paul Stoffregens usb_api.cpp from Teensyduino + * http://www.pjrc.com/teensy/teensyduino.html + * Copyright (c) 2008 PJRC.COM, LLC + * THANK YOU VERY MUCH FOR THIS EFFORT ON KEYBOARD + LAYOUTS! + * + */ + +#include +#include +#include +#include +#include "keyboard.h" +#include "esp_log.h" +#define TAG "KB" + +const uint16_t deadkey_USINT[2][5] = { + #include "undefkeylayouts.h" + #define LAYOUT_US_INTERNATIONAL + #include "keylayouts.h" + {CIRCUMFLEX_BITS, ACUTE_ACCENT_BITS, GRAVE_ACCENT_BITS, TILDE_BITS, DIAERESIS_BITS}, + {DEADKEY_CIRCUMFLEX, DEADKEY_ACUTE_ACCENT, DEADKEY_GRAVE_ACCENT, DEADKEY_TILDE, DEADKEY_DIAERESIS} +}; +const uint16_t deadkey_DE[2][3] = { + #include "undefkeylayouts.h" + #define LAYOUT_GERMAN + #include "keylayouts.h" + {CIRCUMFLEX_BITS, ACUTE_ACCENT_BITS, GRAVE_ACCENT_BITS}, + {DEADKEY_CIRCUMFLEX, DEADKEY_ACUTE_ACCENT, DEADKEY_GRAVE_ACCENT} +}; +const uint16_t deadkey_DEMAC[2][5] = { + #include "undefkeylayouts.h" + #define LAYOUT_GERMAN_MAC + #include "keylayouts.h" + {CIRCUMFLEX_BITS, ACUTE_ACCENT_BITS, GRAVE_ACCENT_BITS, TILDE_BITS, DIAERESIS_BITS}, + {DEADKEY_CIRCUMFLEX, DEADKEY_ACUTE_ACCENT, DEADKEY_GRAVE_ACCENT, DEADKEY_TILDE, DEADKEY_DIAERESIS} +}; +const uint16_t deadkey_CAFR[2][5] = { + #include "undefkeylayouts.h" + #define LAYOUT_CANADIAN_FRENCH + #include "keylayouts.h" + {CIRCUMFLEX_BITS, ACUTE_ACCENT_BITS, GRAVE_ACCENT_BITS, DIAERESIS_BITS, CEDILLA_BITS}, + {DEADKEY_CIRCUMFLEX, DEADKEY_ACUTE_ACCENT, DEADKEY_GRAVE_ACCENT, DEADKEY_DIAERESIS, DEADKEY_CEDILLA} +}; +const uint16_t deadkey_CAINT[2][7] = { + #include "undefkeylayouts.h" + #define LAYOUT_CANADIAN_MULTILINGUAL + #include "keylayouts.h" + {CIRCUMFLEX_BITS, ACUTE_ACCENT_BITS, GRAVE_ACCENT_BITS, DIAERESIS_BITS, CEDILLA_BITS, TILDE_BITS, RING_ABOVE_BITS}, + {DEADKEY_CIRCUMFLEX, DEADKEY_ACUTE_ACCENT, DEADKEY_GRAVE_ACCENT, DEADKEY_DIAERESIS, DEADKEY_CEDILLA, DEADKEY_TILDE, DEADKEY_RING_ABOVE} +}; +const uint16_t deadkey_UK[2][1] = {{0},{0}}; +const uint16_t deadkey_FI[2][5] = { + #include "undefkeylayouts.h" + #define LAYOUT_FINNISH + #include "keylayouts.h" + {CIRCUMFLEX_BITS, ACUTE_ACCENT_BITS, GRAVE_ACCENT_BITS, TILDE_BITS, DIAERESIS_BITS}, + {DEADKEY_CIRCUMFLEX, DEADKEY_ACUTE_ACCENT, DEADKEY_GRAVE_ACCENT, DEADKEY_TILDE, DEADKEY_DIAERESIS} +}; +const uint16_t deadkey_FR[2][4] = { + #include "undefkeylayouts.h" + #define LAYOUT_FRENCH + #include "keylayouts.h" + {CIRCUMFLEX_BITS, GRAVE_ACCENT_BITS, TILDE_BITS, DIAERESIS_BITS}, + {DEADKEY_CIRCUMFLEX, DEADKEY_GRAVE_ACCENT, DEADKEY_TILDE, DEADKEY_DIAERESIS} +}; +const uint16_t deadkey_DK[2][5] = { + #include "undefkeylayouts.h" + #define LAYOUT_DANISH + #include "keylayouts.h" + {CIRCUMFLEX_BITS, ACUTE_ACCENT_BITS, GRAVE_ACCENT_BITS, TILDE_BITS, DIAERESIS_BITS}, + {DEADKEY_CIRCUMFLEX, DEADKEY_ACUTE_ACCENT, DEADKEY_GRAVE_ACCENT, DEADKEY_TILDE, DEADKEY_DIAERESIS} +}; +const uint16_t deadkey_NW[2][5] = { + #include "undefkeylayouts.h" + #define LAYOUT_NORWEGIAN + #include "keylayouts.h" + {CIRCUMFLEX_BITS, ACUTE_ACCENT_BITS, GRAVE_ACCENT_BITS, TILDE_BITS, DIAERESIS_BITS}, + {DEADKEY_CIRCUMFLEX, DEADKEY_ACUTE_ACCENT, DEADKEY_GRAVE_ACCENT, DEADKEY_TILDE, DEADKEY_DIAERESIS} +}; +const uint16_t deadkey_SW[2][5] = { + #include "undefkeylayouts.h" + #define LAYOUT_SWEDISH + #include "keylayouts.h" + {CIRCUMFLEX_BITS, ACUTE_ACCENT_BITS, GRAVE_ACCENT_BITS, TILDE_BITS, DIAERESIS_BITS}, + {DEADKEY_CIRCUMFLEX, DEADKEY_ACUTE_ACCENT, DEADKEY_GRAVE_ACCENT, DEADKEY_TILDE, DEADKEY_DIAERESIS} +}; +const uint16_t deadkey_ES[2][5] = { + #include "undefkeylayouts.h" + #define LAYOUT_SPANISH + #include "keylayouts.h" + {CIRCUMFLEX_BITS, ACUTE_ACCENT_BITS, GRAVE_ACCENT_BITS, TILDE_BITS, DIAERESIS_BITS}, + {DEADKEY_CIRCUMFLEX, DEADKEY_ACUTE_ACCENT, DEADKEY_GRAVE_ACCENT, DEADKEY_TILDE, DEADKEY_DIAERESIS} +}; +const uint16_t deadkey_PT[2][5] = { + #include "undefkeylayouts.h" + #define LAYOUT_PORTUGUESE + #include "keylayouts.h" + {CIRCUMFLEX_BITS, ACUTE_ACCENT_BITS, GRAVE_ACCENT_BITS, TILDE_BITS, DIAERESIS_BITS}, + {DEADKEY_CIRCUMFLEX, DEADKEY_ACUTE_ACCENT, DEADKEY_GRAVE_ACCENT, DEADKEY_TILDE, DEADKEY_DIAERESIS} +}; +const uint16_t deadkey_IT[2][1] = {{0},{0}}; + +const uint16_t deadkey_PTBR[2][5] = { + #include "undefkeylayouts.h" + #define LAYOUT_PORTUGUESE_BRAZILIAN + #include "keylayouts.h" + {CIRCUMFLEX_BITS, ACUTE_ACCENT_BITS, GRAVE_ACCENT_BITS, TILDE_BITS, DIAERESIS_BITS}, + {DEADKEY_CIRCUMFLEX, DEADKEY_ACUTE_ACCENT, DEADKEY_GRAVE_ACCENT, DEADKEY_TILDE, DEADKEY_DIAERESIS} +}; +const uint16_t deadkey_FRBE[2][5] = { + #include "undefkeylayouts.h" + #define LAYOUT_FRENCH_BELGIAN + #include "keylayouts.h" + {CIRCUMFLEX_BITS, ACUTE_ACCENT_BITS, GRAVE_ACCENT_BITS, TILDE_BITS, DIAERESIS_BITS}, + {DEADKEY_CIRCUMFLEX, DEADKEY_ACUTE_ACCENT, DEADKEY_GRAVE_ACCENT, DEADKEY_TILDE, DEADKEY_DIAERESIS} +}; +const uint16_t deadkey_DESW[2][5] = { + #include "undefkeylayouts.h" + #define LAYOUT_GERMAN_SWISS + #include "keylayouts.h" + {CIRCUMFLEX_BITS, ACUTE_ACCENT_BITS, GRAVE_ACCENT_BITS, TILDE_BITS, DIAERESIS_BITS}, + {DEADKEY_CIRCUMFLEX, DEADKEY_ACUTE_ACCENT, DEADKEY_GRAVE_ACCENT, DEADKEY_TILDE, DEADKEY_DIAERESIS} +}; +const uint16_t deadkey_FRSW[2][5] = { + #include "undefkeylayouts.h" + #define LAYOUT_FRENCH_SWISS + #include "keylayouts.h" + {CIRCUMFLEX_BITS, ACUTE_ACCENT_BITS, GRAVE_ACCENT_BITS, TILDE_BITS, DIAERESIS_BITS}, + {DEADKEY_CIRCUMFLEX, DEADKEY_ACUTE_ACCENT, DEADKEY_GRAVE_ACCENT, DEADKEY_TILDE, DEADKEY_DIAERESIS} +}; +const uint16_t deadkey_ESLAT[2][4] = { + #include "undefkeylayouts.h" + #define LAYOUT_SPANISH_LATIN_AMERICA + #include "keylayouts.h" + {CIRCUMFLEX_BITS, ACUTE_ACCENT_BITS, GRAVE_ACCENT_BITS, DIAERESIS_BITS}, + {DEADKEY_CIRCUMFLEX, DEADKEY_ACUTE_ACCENT, DEADKEY_GRAVE_ACCENT, DEADKEY_DIAERESIS} +}; +const uint16_t deadkey_IR[2][2] = { + #include "undefkeylayouts.h" + #define LAYOUT_IRISH + #include "keylayouts.h" + {ACUTE_ACCENT_BITS, GRAVE_ACCENT_BITS}, + {DEADKEY_ACUTE_ACCENT, DEADKEY_GRAVE_ACCENT} +}; +const uint16_t deadkey_IC[2][5] = { + #include "undefkeylayouts.h" + #define LAYOUT_ICELANDIC + #include "keylayouts.h" + {CIRCUMFLEX_BITS, ACUTE_ACCENT_BITS, GRAVE_ACCENT_BITS, RING_ABOVE_BITS, DIAERESIS_BITS}, + {DEADKEY_CIRCUMFLEX, DEADKEY_ACUTE_ACCENT, DEADKEY_GRAVE_ACCENT, DEADKEY_RING_ABOVE, DEADKEY_DIAERESIS} +}; +const uint16_t deadkey_TK[2][5] = { + #include "undefkeylayouts.h" + #define LAYOUT_TURKISH + #include "keylayouts.h" + {CIRCUMFLEX_BITS, ACUTE_ACCENT_BITS, GRAVE_ACCENT_BITS, TILDE_BITS, DIAERESIS_BITS}, + {DEADKEY_CIRCUMFLEX, DEADKEY_ACUTE_ACCENT, DEADKEY_GRAVE_ACCENT, DEADKEY_TILDE, DEADKEY_DIAERESIS} +}; +const uint16_t deadkey_CZ[2][8] = { + #include "undefkeylayouts.h" + #define LAYOUT_CZECH + #include "keylayouts.h" + {/*CIRCUMFLEX_BITS,*/ DOUBLE_ACUTE_BITS, CEDILLA_BITS, DEGREE_SIGN_BITS, CARON_BITS, ACUTE_ACCENT_BITS, BREVE_BITS, /*GRAVE_ACCENT_BITS,*/ DOT_ABOVE_BITS, /*DIAERESIS_BITS, */ OGONEK_BITS}, + {/*DEADKEY_CIRCUMFLEX,*/ DEADKEY_DOUBLE_ACUTE, DEADKEY_CEDILLA, DEADKEY_DEGREE_SIGN, DEADKEY_CARON, DEADKEY_ACUTE_ACCENT, DEADKEY_BREVE, /*DEADKEY_GRAVE_ACCENT,*/ DEADKEY_DOT_ABOVE, /*DEADKEY_DIAERESIS, */ DEADKEY_OGONEK} +}; +const uint16_t deadkey_SR[2][10] = { + #include "undefkeylayouts.h" + #define LAYOUT_SERBIAN_LATIN_ONLY + #include "keylayouts.h" + {CIRCUMFLEX_BITS, DOUBLE_ACUTE_BITS, CEDILLA_BITS, DEGREE_SIGN_BITS, CARON_BITS, ACUTE_ACCENT_BITS, BREVE_BITS, DOT_ABOVE_BITS, DIAERESIS_BITS, OGONEK_BITS}, + {DEADKEY_CIRCUMFLEX, DEADKEY_DOUBLE_ACUTE, DEADKEY_CEDILLA, DEADKEY_DEGREE_SIGN, DEADKEY_CARON, DEADKEY_ACUTE_ACCENT, DEADKEY_BREVE, DEADKEY_DOT_ABOVE, DEADKEY_DIAERESIS, DEADKEY_OGONEK} +}; + +const uint16_t keycodes_masks[][5] = { + #include "undefkeylayouts.h" + #define LAYOUT_US_ENGLISH + #include "keylayouts.h" + { SHIFT_MASK, 0, 0, KEYCODE_MASK, 0}, + #include "undefkeylayouts.h" + #define LAYOUT_US_INTERNATIONAL + #include "keylayouts.h" + { SHIFT_MASK, ALTGR_MASK, DEADKEYS_MASK, KEYCODE_MASK, 0}, + #include "undefkeylayouts.h" + #define LAYOUT_GERMAN + #include "keylayouts.h" + { SHIFT_MASK, ALTGR_MASK, DEADKEYS_MASK, KEYCODE_MASK, 0}, + #include "undefkeylayouts.h" + #define LAYOUT_GERMAN_MAC + #include "keylayouts.h" + { SHIFT_MASK, ALTGR_MASK, DEADKEYS_MASK, KEYCODE_MASK, 0}, + #include "undefkeylayouts.h" + #define LAYOUT_CANADIAN_FRENCH + #include "keylayouts.h" + { SHIFT_MASK, ALTGR_MASK, DEADKEYS_MASK, KEYCODE_MASK, 0}, + #include "undefkeylayouts.h" + #define LAYOUT_CANADIAN_MULTILINGUAL + #include "keylayouts.h" + { SHIFT_MASK, ALTGR_MASK, DEADKEYS_MASK, KEYCODE_MASK, RCTRL_MASK}, + #include "undefkeylayouts.h" + #define LAYOUT_UNITED_KINGDOM + #include "keylayouts.h" + { SHIFT_MASK, ALTGR_MASK, 0, KEYCODE_MASK, 0}, + #include "undefkeylayouts.h" + #define LAYOUT_FINNISH + #include "keylayouts.h" + { SHIFT_MASK, ALTGR_MASK, DEADKEYS_MASK, KEYCODE_MASK, 0}, + #include "undefkeylayouts.h" + #define LAYOUT_FRENCH + #include "keylayouts.h" + { SHIFT_MASK, ALTGR_MASK, DEADKEYS_MASK, KEYCODE_MASK, 0}, + #include "undefkeylayouts.h" + #define LAYOUT_DANISH + #include "keylayouts.h" + { SHIFT_MASK, ALTGR_MASK, DEADKEYS_MASK, KEYCODE_MASK, 0}, + #include "undefkeylayouts.h" + #define LAYOUT_NORWEGIAN + #include "keylayouts.h" + { SHIFT_MASK, ALTGR_MASK, DEADKEYS_MASK, KEYCODE_MASK, 0}, + #include "undefkeylayouts.h" + #define LAYOUT_SWEDISH + #include "keylayouts.h" + { SHIFT_MASK, ALTGR_MASK, DEADKEYS_MASK, KEYCODE_MASK, 0}, + #include "undefkeylayouts.h" + #define LAYOUT_SPANISH + #include "keylayouts.h" + { SHIFT_MASK, ALTGR_MASK, DEADKEYS_MASK, KEYCODE_MASK, 0}, + #include "undefkeylayouts.h" + #define LAYOUT_PORTUGUESE + #include "keylayouts.h" + { SHIFT_MASK, ALTGR_MASK, DEADKEYS_MASK, KEYCODE_MASK, 0}, + #include "undefkeylayouts.h" + #define LAYOUT_ITALIAN + #include "keylayouts.h" + { SHIFT_MASK, ALTGR_MASK, 0, KEYCODE_MASK, 0}, + #include "undefkeylayouts.h" + #define LAYOUT_PORTUGUESE_BRAZILIAN + #include "keylayouts.h" + { SHIFT_MASK, ALTGR_MASK, DEADKEYS_MASK, KEYCODE_MASK, 0}, + #include "undefkeylayouts.h" + #define LAYOUT_FRENCH_BELGIAN + #include "keylayouts.h" + { SHIFT_MASK, ALTGR_MASK, DEADKEYS_MASK, KEYCODE_MASK, 0}, + #include "undefkeylayouts.h" + #define LAYOUT_GERMAN_SWISS + #include "keylayouts.h" + { SHIFT_MASK, ALTGR_MASK, DEADKEYS_MASK, KEYCODE_MASK, 0}, + #include "undefkeylayouts.h" + #define LAYOUT_FRENCH_SWISS + #include "keylayouts.h" + { SHIFT_MASK, ALTGR_MASK, DEADKEYS_MASK, KEYCODE_MASK, 0}, + #include "undefkeylayouts.h" + #define LAYOUT_SPANISH_LATIN_AMERICA + #include "keylayouts.h" + { SHIFT_MASK, ALTGR_MASK, DEADKEYS_MASK, KEYCODE_MASK, 0}, + #include "undefkeylayouts.h" + #define LAYOUT_IRISH + #include "keylayouts.h" + { SHIFT_MASK, ALTGR_MASK, DEADKEYS_MASK, KEYCODE_MASK, 0}, + #include "undefkeylayouts.h" + #define LAYOUT_ICELANDIC + #include "keylayouts.h" + { SHIFT_MASK, ALTGR_MASK, DEADKEYS_MASK, KEYCODE_MASK, 0}, + #include "undefkeylayouts.h" + #define LAYOUT_TURKISH + #include "keylayouts.h" + { SHIFT_MASK, ALTGR_MASK, DEADKEYS_MASK, KEYCODE_MASK, 0}, + #include "undefkeylayouts.h" + #define LAYOUT_CZECH + #include "keylayouts.h" + { SHIFT_MASK, ALTGR_MASK, DEADKEYS_MASK, KEYCODE_MASK, 0}, + #include "undefkeylayouts.h" + #define LAYOUT_SERBIAN_LATIN_ONLY + #include "keylayouts.h" + { SHIFT_MASK, ALTGR_MASK, DEADKEYS_MASK, KEYCODE_MASK, 0} +}; + +/** + * array of pointers to a deadkey bits array for each locale. + * + * @see keycodes_deadkey_DE (or any other language) + * WARNING: locale offset is different, because there is no + * LAYOUT_US_ENGLISH! + * */ +const uint16_t* keycodes_deadkey_bits[] = { + deadkey_USINT[0], + deadkey_DE[0], + deadkey_DEMAC[0], + deadkey_CAFR[0], + deadkey_CAINT[0], + deadkey_UK[0], + deadkey_FI[0], + deadkey_FR[0], + deadkey_DK[0], + deadkey_NW[0], + deadkey_SW[0], + deadkey_ES[0], + deadkey_PT[0], + deadkey_IT[0], + deadkey_PTBR[0], + deadkey_FRBE[0], + deadkey_DESW[0], + deadkey_FRSW[0], + deadkey_ESLAT[0], + deadkey_IR[0], + deadkey_IC[0], + deadkey_TK[0], + deadkey_CZ[0], + deadkey_SR[0] +}; +/** + * array of pointers to a deadkey array for each locale. + * Index position of deadkey and deadkey bits equals between + * keycodes_deadkey_bits and keycodes_deadkey. + * + * @see keycodes_deadkey_DE (or any other language) + * WARNING: locale offset is different, because there is no + * LAYOUT_US_ENGLISH! + * */ +const uint16_t* keycodes_deadkey[] = { + deadkey_USINT[1], + deadkey_DE[1], + deadkey_DEMAC[1], + deadkey_CAFR[1], + deadkey_CAINT[1], + deadkey_UK[1], + deadkey_FI[1], + deadkey_FR[1], + deadkey_DK[1], + deadkey_NW[1], + deadkey_SW[1], + deadkey_ES[1], + deadkey_PT[1], + deadkey_IT[1], + deadkey_PTBR[1], + deadkey_FRBE[1], + deadkey_DESW[1], + deadkey_FRSW[1], + deadkey_ESLAT[1], + deadkey_IR[1], + deadkey_IC[1], + deadkey_TK[1], + deadkey_CZ[1], + deadkey_SR[1] +}; + + +#if 0 +/** TODO: add extra unicodes; most layouts just use UNICODE_EXTRA00 + * which is mostly 0x20AC (Euro Sign). */ +const uint16_t keycodes_unicode_extra[][11] = { + #include "undefkeylayouts.h" + #define LAYOUT_US_ENGLISH + #include "keylayouts.h" + { + UNICODE_EXTRA00,KEYCODE_EXTRA00,UNICODE_EXTRA01,KEYCODE_EXTRA01, + UNICODE_EXTRA02,KEYCODE_EXTRA02,UNICODE_EXTRA03,KEYCODE_EXTRA03, + UNICODE_EXTRA04,KEYCODE_EXTRA04,UNICODE_EXTRA05,KEYCODE_EXTRA05, + UNICODE_EXTRA06,KEYCODE_EXTRA06,UNICODE_EXTRA07,KEYCODE_EXTRA07, + UNICODE_EXTRA08,KEYCODE_EXTRA08,UNICODE_EXTRA09,KEYCODE_EXTRA09, + UNICODE_EXTRA0A,KEYCODE_EXTRA0A + } + +}; +#endif + +const uint16_t keycodes_ascii[][96] = { + #include "undefkeylayouts.h" + #define LAYOUT_US_ENGLISH + #include "keylayouts.h" + { + ASCII_20, ASCII_21, ASCII_22, ASCII_23, + ASCII_24, ASCII_25, ASCII_26, ASCII_27, + ASCII_28, ASCII_29, ASCII_2A, ASCII_2B, + ASCII_2C, ASCII_2D, ASCII_2E, ASCII_2F, + ASCII_30, ASCII_31, ASCII_32, ASCII_33, + ASCII_34, ASCII_35, ASCII_36, ASCII_37, + ASCII_38, ASCII_39, ASCII_3A, ASCII_3B, + ASCII_3C, ASCII_3D, ASCII_3E, ASCII_3F, + ASCII_40, ASCII_41, ASCII_42, ASCII_43, + ASCII_44, ASCII_45, ASCII_46, ASCII_47, + ASCII_48, ASCII_49, ASCII_4A, ASCII_4B, + ASCII_4C, ASCII_4D, ASCII_4E, ASCII_4F, + ASCII_50, ASCII_51, ASCII_52, ASCII_53, + ASCII_54, ASCII_55, ASCII_56, ASCII_57, + ASCII_58, ASCII_59, ASCII_5A, ASCII_5B, + ASCII_5C, ASCII_5D, ASCII_5E, ASCII_5F, + ASCII_60, ASCII_61, ASCII_62, ASCII_63, + ASCII_64, ASCII_65, ASCII_66, ASCII_67, + ASCII_68, ASCII_69, ASCII_6A, ASCII_6B, + ASCII_6C, ASCII_6D, ASCII_6E, ASCII_6F, + ASCII_70, ASCII_71, ASCII_72, ASCII_73, + ASCII_74, ASCII_75, ASCII_76, ASCII_77, + ASCII_78, ASCII_79, ASCII_7A, ASCII_7B, + ASCII_7C, ASCII_7D, ASCII_7E, ASCII_7F + }, + #include "undefkeylayouts.h" + #define LAYOUT_US_INTERNATIONAL + #include "keylayouts.h" + { + ASCII_20, ASCII_21, ASCII_22, ASCII_23, + ASCII_24, ASCII_25, ASCII_26, ASCII_27, + ASCII_28, ASCII_29, ASCII_2A, ASCII_2B, + ASCII_2C, ASCII_2D, ASCII_2E, ASCII_2F, + ASCII_30, ASCII_31, ASCII_32, ASCII_33, + ASCII_34, ASCII_35, ASCII_36, ASCII_37, + ASCII_38, ASCII_39, ASCII_3A, ASCII_3B, + ASCII_3C, ASCII_3D, ASCII_3E, ASCII_3F, + ASCII_40, ASCII_41, ASCII_42, ASCII_43, + ASCII_44, ASCII_45, ASCII_46, ASCII_47, + ASCII_48, ASCII_49, ASCII_4A, ASCII_4B, + ASCII_4C, ASCII_4D, ASCII_4E, ASCII_4F, + ASCII_50, ASCII_51, ASCII_52, ASCII_53, + ASCII_54, ASCII_55, ASCII_56, ASCII_57, + ASCII_58, ASCII_59, ASCII_5A, ASCII_5B, + ASCII_5C, ASCII_5D, ASCII_5E, ASCII_5F, + ASCII_60, ASCII_61, ASCII_62, ASCII_63, + ASCII_64, ASCII_65, ASCII_66, ASCII_67, + ASCII_68, ASCII_69, ASCII_6A, ASCII_6B, + ASCII_6C, ASCII_6D, ASCII_6E, ASCII_6F, + ASCII_70, ASCII_71, ASCII_72, ASCII_73, + ASCII_74, ASCII_75, ASCII_76, ASCII_77, + ASCII_78, ASCII_79, ASCII_7A, ASCII_7B, + ASCII_7C, ASCII_7D, ASCII_7E, ASCII_7F + }, + #include "undefkeylayouts.h" + #define LAYOUT_GERMAN + #include "keylayouts.h" + { + ASCII_20, ASCII_21, ASCII_22, ASCII_23, + ASCII_24, ASCII_25, ASCII_26, ASCII_27, + ASCII_28, ASCII_29, ASCII_2A, ASCII_2B, + ASCII_2C, ASCII_2D, ASCII_2E, ASCII_2F, + ASCII_30, ASCII_31, ASCII_32, ASCII_33, + ASCII_34, ASCII_35, ASCII_36, ASCII_37, + ASCII_38, ASCII_39, ASCII_3A, ASCII_3B, + ASCII_3C, ASCII_3D, ASCII_3E, ASCII_3F, + ASCII_40, ASCII_41, ASCII_42, ASCII_43, + ASCII_44, ASCII_45, ASCII_46, ASCII_47, + ASCII_48, ASCII_49, ASCII_4A, ASCII_4B, + ASCII_4C, ASCII_4D, ASCII_4E, ASCII_4F, + ASCII_50, ASCII_51, ASCII_52, ASCII_53, + ASCII_54, ASCII_55, ASCII_56, ASCII_57, + ASCII_58, ASCII_59, ASCII_5A, ASCII_5B, + ASCII_5C, ASCII_5D, ASCII_5E, ASCII_5F, + ASCII_60, ASCII_61, ASCII_62, ASCII_63, + ASCII_64, ASCII_65, ASCII_66, ASCII_67, + ASCII_68, ASCII_69, ASCII_6A, ASCII_6B, + ASCII_6C, ASCII_6D, ASCII_6E, ASCII_6F, + ASCII_70, ASCII_71, ASCII_72, ASCII_73, + ASCII_74, ASCII_75, ASCII_76, ASCII_77, + ASCII_78, ASCII_79, ASCII_7A, ASCII_7B, + ASCII_7C, ASCII_7D, ASCII_7E, ASCII_7F + }, + #include "undefkeylayouts.h" + #define LAYOUT_GERMAN_MAC + #include "keylayouts.h" + { + ASCII_20, ASCII_21, ASCII_22, ASCII_23, + ASCII_24, ASCII_25, ASCII_26, ASCII_27, + ASCII_28, ASCII_29, ASCII_2A, ASCII_2B, + ASCII_2C, ASCII_2D, ASCII_2E, ASCII_2F, + ASCII_30, ASCII_31, ASCII_32, ASCII_33, + ASCII_34, ASCII_35, ASCII_36, ASCII_37, + ASCII_38, ASCII_39, ASCII_3A, ASCII_3B, + ASCII_3C, ASCII_3D, ASCII_3E, ASCII_3F, + ASCII_40, ASCII_41, ASCII_42, ASCII_43, + ASCII_44, ASCII_45, ASCII_46, ASCII_47, + ASCII_48, ASCII_49, ASCII_4A, ASCII_4B, + ASCII_4C, ASCII_4D, ASCII_4E, ASCII_4F, + ASCII_50, ASCII_51, ASCII_52, ASCII_53, + ASCII_54, ASCII_55, ASCII_56, ASCII_57, + ASCII_58, ASCII_59, ASCII_5A, ASCII_5B, + ASCII_5C, ASCII_5D, ASCII_5E, ASCII_5F, + ASCII_60, ASCII_61, ASCII_62, ASCII_63, + ASCII_64, ASCII_65, ASCII_66, ASCII_67, + ASCII_68, ASCII_69, ASCII_6A, ASCII_6B, + ASCII_6C, ASCII_6D, ASCII_6E, ASCII_6F, + ASCII_70, ASCII_71, ASCII_72, ASCII_73, + ASCII_74, ASCII_75, ASCII_76, ASCII_77, + ASCII_78, ASCII_79, ASCII_7A, ASCII_7B, + ASCII_7C, ASCII_7D, ASCII_7E, ASCII_7F + }, + #include "undefkeylayouts.h" + #define LAYOUT_CANADIAN_FRENCH + #include "keylayouts.h" + { + ASCII_20, ASCII_21, ASCII_22, ASCII_23, + ASCII_24, ASCII_25, ASCII_26, ASCII_27, + ASCII_28, ASCII_29, ASCII_2A, ASCII_2B, + ASCII_2C, ASCII_2D, ASCII_2E, ASCII_2F, + ASCII_30, ASCII_31, ASCII_32, ASCII_33, + ASCII_34, ASCII_35, ASCII_36, ASCII_37, + ASCII_38, ASCII_39, ASCII_3A, ASCII_3B, + ASCII_3C, ASCII_3D, ASCII_3E, ASCII_3F, + ASCII_40, ASCII_41, ASCII_42, ASCII_43, + ASCII_44, ASCII_45, ASCII_46, ASCII_47, + ASCII_48, ASCII_49, ASCII_4A, ASCII_4B, + ASCII_4C, ASCII_4D, ASCII_4E, ASCII_4F, + ASCII_50, ASCII_51, ASCII_52, ASCII_53, + ASCII_54, ASCII_55, ASCII_56, ASCII_57, + ASCII_58, ASCII_59, ASCII_5A, ASCII_5B, + ASCII_5C, ASCII_5D, ASCII_5E, ASCII_5F, + ASCII_60, ASCII_61, ASCII_62, ASCII_63, + ASCII_64, ASCII_65, ASCII_66, ASCII_67, + ASCII_68, ASCII_69, ASCII_6A, ASCII_6B, + ASCII_6C, ASCII_6D, ASCII_6E, ASCII_6F, + ASCII_70, ASCII_71, ASCII_72, ASCII_73, + ASCII_74, ASCII_75, ASCII_76, ASCII_77, + ASCII_78, ASCII_79, ASCII_7A, ASCII_7B, + ASCII_7C, ASCII_7D, ASCII_7E, ASCII_7F + }, + #include "undefkeylayouts.h" + #define LAYOUT_CANADIAN_MULTILINGUAL + #include "keylayouts.h" + { + ASCII_20, ASCII_21, ASCII_22, ASCII_23, + ASCII_24, ASCII_25, ASCII_26, ASCII_27, + ASCII_28, ASCII_29, ASCII_2A, ASCII_2B, + ASCII_2C, ASCII_2D, ASCII_2E, ASCII_2F, + ASCII_30, ASCII_31, ASCII_32, ASCII_33, + ASCII_34, ASCII_35, ASCII_36, ASCII_37, + ASCII_38, ASCII_39, ASCII_3A, ASCII_3B, + ASCII_3C, ASCII_3D, ASCII_3E, ASCII_3F, + ASCII_40, ASCII_41, ASCII_42, ASCII_43, + ASCII_44, ASCII_45, ASCII_46, ASCII_47, + ASCII_48, ASCII_49, ASCII_4A, ASCII_4B, + ASCII_4C, ASCII_4D, ASCII_4E, ASCII_4F, + ASCII_50, ASCII_51, ASCII_52, ASCII_53, + ASCII_54, ASCII_55, ASCII_56, ASCII_57, + ASCII_58, ASCII_59, ASCII_5A, ASCII_5B, + ASCII_5C, ASCII_5D, ASCII_5E, ASCII_5F, + ASCII_60, ASCII_61, ASCII_62, ASCII_63, + ASCII_64, ASCII_65, ASCII_66, ASCII_67, + ASCII_68, ASCII_69, ASCII_6A, ASCII_6B, + ASCII_6C, ASCII_6D, ASCII_6E, ASCII_6F, + ASCII_70, ASCII_71, ASCII_72, ASCII_73, + ASCII_74, ASCII_75, ASCII_76, ASCII_77, + ASCII_78, ASCII_79, ASCII_7A, ASCII_7B, + ASCII_7C, ASCII_7D, ASCII_7E, ASCII_7F + }, + #include "undefkeylayouts.h" + #define LAYOUT_UNITED_KINGDOM + #include "keylayouts.h" + { + ASCII_20, ASCII_21, ASCII_22, ASCII_23, + ASCII_24, ASCII_25, ASCII_26, ASCII_27, + ASCII_28, ASCII_29, ASCII_2A, ASCII_2B, + ASCII_2C, ASCII_2D, ASCII_2E, ASCII_2F, + ASCII_30, ASCII_31, ASCII_32, ASCII_33, + ASCII_34, ASCII_35, ASCII_36, ASCII_37, + ASCII_38, ASCII_39, ASCII_3A, ASCII_3B, + ASCII_3C, ASCII_3D, ASCII_3E, ASCII_3F, + ASCII_40, ASCII_41, ASCII_42, ASCII_43, + ASCII_44, ASCII_45, ASCII_46, ASCII_47, + ASCII_48, ASCII_49, ASCII_4A, ASCII_4B, + ASCII_4C, ASCII_4D, ASCII_4E, ASCII_4F, + ASCII_50, ASCII_51, ASCII_52, ASCII_53, + ASCII_54, ASCII_55, ASCII_56, ASCII_57, + ASCII_58, ASCII_59, ASCII_5A, ASCII_5B, + ASCII_5C, ASCII_5D, ASCII_5E, ASCII_5F, + ASCII_60, ASCII_61, ASCII_62, ASCII_63, + ASCII_64, ASCII_65, ASCII_66, ASCII_67, + ASCII_68, ASCII_69, ASCII_6A, ASCII_6B, + ASCII_6C, ASCII_6D, ASCII_6E, ASCII_6F, + ASCII_70, ASCII_71, ASCII_72, ASCII_73, + ASCII_74, ASCII_75, ASCII_76, ASCII_77, + ASCII_78, ASCII_79, ASCII_7A, ASCII_7B, + ASCII_7C, ASCII_7D, ASCII_7E, ASCII_7F + }, + #include "undefkeylayouts.h" + #define LAYOUT_FINNISH + #include "keylayouts.h" + { + ASCII_20, ASCII_21, ASCII_22, ASCII_23, + ASCII_24, ASCII_25, ASCII_26, ASCII_27, + ASCII_28, ASCII_29, ASCII_2A, ASCII_2B, + ASCII_2C, ASCII_2D, ASCII_2E, ASCII_2F, + ASCII_30, ASCII_31, ASCII_32, ASCII_33, + ASCII_34, ASCII_35, ASCII_36, ASCII_37, + ASCII_38, ASCII_39, ASCII_3A, ASCII_3B, + ASCII_3C, ASCII_3D, ASCII_3E, ASCII_3F, + ASCII_40, ASCII_41, ASCII_42, ASCII_43, + ASCII_44, ASCII_45, ASCII_46, ASCII_47, + ASCII_48, ASCII_49, ASCII_4A, ASCII_4B, + ASCII_4C, ASCII_4D, ASCII_4E, ASCII_4F, + ASCII_50, ASCII_51, ASCII_52, ASCII_53, + ASCII_54, ASCII_55, ASCII_56, ASCII_57, + ASCII_58, ASCII_59, ASCII_5A, ASCII_5B, + ASCII_5C, ASCII_5D, ASCII_5E, ASCII_5F, + ASCII_60, ASCII_61, ASCII_62, ASCII_63, + ASCII_64, ASCII_65, ASCII_66, ASCII_67, + ASCII_68, ASCII_69, ASCII_6A, ASCII_6B, + ASCII_6C, ASCII_6D, ASCII_6E, ASCII_6F, + ASCII_70, ASCII_71, ASCII_72, ASCII_73, + ASCII_74, ASCII_75, ASCII_76, ASCII_77, + ASCII_78, ASCII_79, ASCII_7A, ASCII_7B, + ASCII_7C, ASCII_7D, ASCII_7E, ASCII_7F + }, + #include "undefkeylayouts.h" + #define LAYOUT_FRENCH + #include "keylayouts.h" + { + ASCII_20, ASCII_21, ASCII_22, ASCII_23, + ASCII_24, ASCII_25, ASCII_26, ASCII_27, + ASCII_28, ASCII_29, ASCII_2A, ASCII_2B, + ASCII_2C, ASCII_2D, ASCII_2E, ASCII_2F, + ASCII_30, ASCII_31, ASCII_32, ASCII_33, + ASCII_34, ASCII_35, ASCII_36, ASCII_37, + ASCII_38, ASCII_39, ASCII_3A, ASCII_3B, + ASCII_3C, ASCII_3D, ASCII_3E, ASCII_3F, + ASCII_40, ASCII_41, ASCII_42, ASCII_43, + ASCII_44, ASCII_45, ASCII_46, ASCII_47, + ASCII_48, ASCII_49, ASCII_4A, ASCII_4B, + ASCII_4C, ASCII_4D, ASCII_4E, ASCII_4F, + ASCII_50, ASCII_51, ASCII_52, ASCII_53, + ASCII_54, ASCII_55, ASCII_56, ASCII_57, + ASCII_58, ASCII_59, ASCII_5A, ASCII_5B, + ASCII_5C, ASCII_5D, ASCII_5E, ASCII_5F, + ASCII_60, ASCII_61, ASCII_62, ASCII_63, + ASCII_64, ASCII_65, ASCII_66, ASCII_67, + ASCII_68, ASCII_69, ASCII_6A, ASCII_6B, + ASCII_6C, ASCII_6D, ASCII_6E, ASCII_6F, + ASCII_70, ASCII_71, ASCII_72, ASCII_73, + ASCII_74, ASCII_75, ASCII_76, ASCII_77, + ASCII_78, ASCII_79, ASCII_7A, ASCII_7B, + ASCII_7C, ASCII_7D, ASCII_7E, ASCII_7F + }, + #include "undefkeylayouts.h" + #define LAYOUT_DANISH + #include "keylayouts.h" + { + ASCII_20, ASCII_21, ASCII_22, ASCII_23, + ASCII_24, ASCII_25, ASCII_26, ASCII_27, + ASCII_28, ASCII_29, ASCII_2A, ASCII_2B, + ASCII_2C, ASCII_2D, ASCII_2E, ASCII_2F, + ASCII_30, ASCII_31, ASCII_32, ASCII_33, + ASCII_34, ASCII_35, ASCII_36, ASCII_37, + ASCII_38, ASCII_39, ASCII_3A, ASCII_3B, + ASCII_3C, ASCII_3D, ASCII_3E, ASCII_3F, + ASCII_40, ASCII_41, ASCII_42, ASCII_43, + ASCII_44, ASCII_45, ASCII_46, ASCII_47, + ASCII_48, ASCII_49, ASCII_4A, ASCII_4B, + ASCII_4C, ASCII_4D, ASCII_4E, ASCII_4F, + ASCII_50, ASCII_51, ASCII_52, ASCII_53, + ASCII_54, ASCII_55, ASCII_56, ASCII_57, + ASCII_58, ASCII_59, ASCII_5A, ASCII_5B, + ASCII_5C, ASCII_5D, ASCII_5E, ASCII_5F, + ASCII_60, ASCII_61, ASCII_62, ASCII_63, + ASCII_64, ASCII_65, ASCII_66, ASCII_67, + ASCII_68, ASCII_69, ASCII_6A, ASCII_6B, + ASCII_6C, ASCII_6D, ASCII_6E, ASCII_6F, + ASCII_70, ASCII_71, ASCII_72, ASCII_73, + ASCII_74, ASCII_75, ASCII_76, ASCII_77, + ASCII_78, ASCII_79, ASCII_7A, ASCII_7B, + ASCII_7C, ASCII_7D, ASCII_7E, ASCII_7F + }, + #include "undefkeylayouts.h" + #define LAYOUT_NORWEGIAN + #include "keylayouts.h" + { + ASCII_20, ASCII_21, ASCII_22, ASCII_23, + ASCII_24, ASCII_25, ASCII_26, ASCII_27, + ASCII_28, ASCII_29, ASCII_2A, ASCII_2B, + ASCII_2C, ASCII_2D, ASCII_2E, ASCII_2F, + ASCII_30, ASCII_31, ASCII_32, ASCII_33, + ASCII_34, ASCII_35, ASCII_36, ASCII_37, + ASCII_38, ASCII_39, ASCII_3A, ASCII_3B, + ASCII_3C, ASCII_3D, ASCII_3E, ASCII_3F, + ASCII_40, ASCII_41, ASCII_42, ASCII_43, + ASCII_44, ASCII_45, ASCII_46, ASCII_47, + ASCII_48, ASCII_49, ASCII_4A, ASCII_4B, + ASCII_4C, ASCII_4D, ASCII_4E, ASCII_4F, + ASCII_50, ASCII_51, ASCII_52, ASCII_53, + ASCII_54, ASCII_55, ASCII_56, ASCII_57, + ASCII_58, ASCII_59, ASCII_5A, ASCII_5B, + ASCII_5C, ASCII_5D, ASCII_5E, ASCII_5F, + ASCII_60, ASCII_61, ASCII_62, ASCII_63, + ASCII_64, ASCII_65, ASCII_66, ASCII_67, + ASCII_68, ASCII_69, ASCII_6A, ASCII_6B, + ASCII_6C, ASCII_6D, ASCII_6E, ASCII_6F, + ASCII_70, ASCII_71, ASCII_72, ASCII_73, + ASCII_74, ASCII_75, ASCII_76, ASCII_77, + ASCII_78, ASCII_79, ASCII_7A, ASCII_7B, + ASCII_7C, ASCII_7D, ASCII_7E, ASCII_7F + }, + #include "undefkeylayouts.h" + #define LAYOUT_SWEDISH + #include "keylayouts.h" + { + ASCII_20, ASCII_21, ASCII_22, ASCII_23, + ASCII_24, ASCII_25, ASCII_26, ASCII_27, + ASCII_28, ASCII_29, ASCII_2A, ASCII_2B, + ASCII_2C, ASCII_2D, ASCII_2E, ASCII_2F, + ASCII_30, ASCII_31, ASCII_32, ASCII_33, + ASCII_34, ASCII_35, ASCII_36, ASCII_37, + ASCII_38, ASCII_39, ASCII_3A, ASCII_3B, + ASCII_3C, ASCII_3D, ASCII_3E, ASCII_3F, + ASCII_40, ASCII_41, ASCII_42, ASCII_43, + ASCII_44, ASCII_45, ASCII_46, ASCII_47, + ASCII_48, ASCII_49, ASCII_4A, ASCII_4B, + ASCII_4C, ASCII_4D, ASCII_4E, ASCII_4F, + ASCII_50, ASCII_51, ASCII_52, ASCII_53, + ASCII_54, ASCII_55, ASCII_56, ASCII_57, + ASCII_58, ASCII_59, ASCII_5A, ASCII_5B, + ASCII_5C, ASCII_5D, ASCII_5E, ASCII_5F, + ASCII_60, ASCII_61, ASCII_62, ASCII_63, + ASCII_64, ASCII_65, ASCII_66, ASCII_67, + ASCII_68, ASCII_69, ASCII_6A, ASCII_6B, + ASCII_6C, ASCII_6D, ASCII_6E, ASCII_6F, + ASCII_70, ASCII_71, ASCII_72, ASCII_73, + ASCII_74, ASCII_75, ASCII_76, ASCII_77, + ASCII_78, ASCII_79, ASCII_7A, ASCII_7B, + ASCII_7C, ASCII_7D, ASCII_7E, ASCII_7F + }, + #include "undefkeylayouts.h" + #define LAYOUT_SPANISH + #include "keylayouts.h" + { + ASCII_20, ASCII_21, ASCII_22, ASCII_23, + ASCII_24, ASCII_25, ASCII_26, ASCII_27, + ASCII_28, ASCII_29, ASCII_2A, ASCII_2B, + ASCII_2C, ASCII_2D, ASCII_2E, ASCII_2F, + ASCII_30, ASCII_31, ASCII_32, ASCII_33, + ASCII_34, ASCII_35, ASCII_36, ASCII_37, + ASCII_38, ASCII_39, ASCII_3A, ASCII_3B, + ASCII_3C, ASCII_3D, ASCII_3E, ASCII_3F, + ASCII_40, ASCII_41, ASCII_42, ASCII_43, + ASCII_44, ASCII_45, ASCII_46, ASCII_47, + ASCII_48, ASCII_49, ASCII_4A, ASCII_4B, + ASCII_4C, ASCII_4D, ASCII_4E, ASCII_4F, + ASCII_50, ASCII_51, ASCII_52, ASCII_53, + ASCII_54, ASCII_55, ASCII_56, ASCII_57, + ASCII_58, ASCII_59, ASCII_5A, ASCII_5B, + ASCII_5C, ASCII_5D, ASCII_5E, ASCII_5F, + ASCII_60, ASCII_61, ASCII_62, ASCII_63, + ASCII_64, ASCII_65, ASCII_66, ASCII_67, + ASCII_68, ASCII_69, ASCII_6A, ASCII_6B, + ASCII_6C, ASCII_6D, ASCII_6E, ASCII_6F, + ASCII_70, ASCII_71, ASCII_72, ASCII_73, + ASCII_74, ASCII_75, ASCII_76, ASCII_77, + ASCII_78, ASCII_79, ASCII_7A, ASCII_7B, + ASCII_7C, ASCII_7D, ASCII_7E, ASCII_7F + }, + #include "undefkeylayouts.h" + #define LAYOUT_PORTUGUESE + #include "keylayouts.h" + { + ASCII_20, ASCII_21, ASCII_22, ASCII_23, + ASCII_24, ASCII_25, ASCII_26, ASCII_27, + ASCII_28, ASCII_29, ASCII_2A, ASCII_2B, + ASCII_2C, ASCII_2D, ASCII_2E, ASCII_2F, + ASCII_30, ASCII_31, ASCII_32, ASCII_33, + ASCII_34, ASCII_35, ASCII_36, ASCII_37, + ASCII_38, ASCII_39, ASCII_3A, ASCII_3B, + ASCII_3C, ASCII_3D, ASCII_3E, ASCII_3F, + ASCII_40, ASCII_41, ASCII_42, ASCII_43, + ASCII_44, ASCII_45, ASCII_46, ASCII_47, + ASCII_48, ASCII_49, ASCII_4A, ASCII_4B, + ASCII_4C, ASCII_4D, ASCII_4E, ASCII_4F, + ASCII_50, ASCII_51, ASCII_52, ASCII_53, + ASCII_54, ASCII_55, ASCII_56, ASCII_57, + ASCII_58, ASCII_59, ASCII_5A, ASCII_5B, + ASCII_5C, ASCII_5D, ASCII_5E, ASCII_5F, + ASCII_60, ASCII_61, ASCII_62, ASCII_63, + ASCII_64, ASCII_65, ASCII_66, ASCII_67, + ASCII_68, ASCII_69, ASCII_6A, ASCII_6B, + ASCII_6C, ASCII_6D, ASCII_6E, ASCII_6F, + ASCII_70, ASCII_71, ASCII_72, ASCII_73, + ASCII_74, ASCII_75, ASCII_76, ASCII_77, + ASCII_78, ASCII_79, ASCII_7A, ASCII_7B, + ASCII_7C, ASCII_7D, ASCII_7E, ASCII_7F + }, + #include "undefkeylayouts.h" + #define LAYOUT_ITALIAN + #include "keylayouts.h" + { + ASCII_20, ASCII_21, ASCII_22, ASCII_23, + ASCII_24, ASCII_25, ASCII_26, ASCII_27, + ASCII_28, ASCII_29, ASCII_2A, ASCII_2B, + ASCII_2C, ASCII_2D, ASCII_2E, ASCII_2F, + ASCII_30, ASCII_31, ASCII_32, ASCII_33, + ASCII_34, ASCII_35, ASCII_36, ASCII_37, + ASCII_38, ASCII_39, ASCII_3A, ASCII_3B, + ASCII_3C, ASCII_3D, ASCII_3E, ASCII_3F, + ASCII_40, ASCII_41, ASCII_42, ASCII_43, + ASCII_44, ASCII_45, ASCII_46, ASCII_47, + ASCII_48, ASCII_49, ASCII_4A, ASCII_4B, + ASCII_4C, ASCII_4D, ASCII_4E, ASCII_4F, + ASCII_50, ASCII_51, ASCII_52, ASCII_53, + ASCII_54, ASCII_55, ASCII_56, ASCII_57, + ASCII_58, ASCII_59, ASCII_5A, ASCII_5B, + ASCII_5C, ASCII_5D, ASCII_5E, ASCII_5F, + ASCII_60, ASCII_61, ASCII_62, ASCII_63, + ASCII_64, ASCII_65, ASCII_66, ASCII_67, + ASCII_68, ASCII_69, ASCII_6A, ASCII_6B, + ASCII_6C, ASCII_6D, ASCII_6E, ASCII_6F, + ASCII_70, ASCII_71, ASCII_72, ASCII_73, + ASCII_74, ASCII_75, ASCII_76, ASCII_77, + ASCII_78, ASCII_79, ASCII_7A, ASCII_7B, + ASCII_7C, ASCII_7D, ASCII_7E, ASCII_7F + }, + #include "undefkeylayouts.h" + #define LAYOUT_PORTUGUESE_BRAZILIAN + #include "keylayouts.h" + { + ASCII_20, ASCII_21, ASCII_22, ASCII_23, + ASCII_24, ASCII_25, ASCII_26, ASCII_27, + ASCII_28, ASCII_29, ASCII_2A, ASCII_2B, + ASCII_2C, ASCII_2D, ASCII_2E, ASCII_2F, + ASCII_30, ASCII_31, ASCII_32, ASCII_33, + ASCII_34, ASCII_35, ASCII_36, ASCII_37, + ASCII_38, ASCII_39, ASCII_3A, ASCII_3B, + ASCII_3C, ASCII_3D, ASCII_3E, ASCII_3F, + ASCII_40, ASCII_41, ASCII_42, ASCII_43, + ASCII_44, ASCII_45, ASCII_46, ASCII_47, + ASCII_48, ASCII_49, ASCII_4A, ASCII_4B, + ASCII_4C, ASCII_4D, ASCII_4E, ASCII_4F, + ASCII_50, ASCII_51, ASCII_52, ASCII_53, + ASCII_54, ASCII_55, ASCII_56, ASCII_57, + ASCII_58, ASCII_59, ASCII_5A, ASCII_5B, + ASCII_5C, ASCII_5D, ASCII_5E, ASCII_5F, + ASCII_60, ASCII_61, ASCII_62, ASCII_63, + ASCII_64, ASCII_65, ASCII_66, ASCII_67, + ASCII_68, ASCII_69, ASCII_6A, ASCII_6B, + ASCII_6C, ASCII_6D, ASCII_6E, ASCII_6F, + ASCII_70, ASCII_71, ASCII_72, ASCII_73, + ASCII_74, ASCII_75, ASCII_76, ASCII_77, + ASCII_78, ASCII_79, ASCII_7A, ASCII_7B, + ASCII_7C, ASCII_7D, ASCII_7E, ASCII_7F + }, + #include "undefkeylayouts.h" + #define LAYOUT_FRENCH_BELGIAN + #include "keylayouts.h" + { + ASCII_20, ASCII_21, ASCII_22, ASCII_23, + ASCII_24, ASCII_25, ASCII_26, ASCII_27, + ASCII_28, ASCII_29, ASCII_2A, ASCII_2B, + ASCII_2C, ASCII_2D, ASCII_2E, ASCII_2F, + ASCII_30, ASCII_31, ASCII_32, ASCII_33, + ASCII_34, ASCII_35, ASCII_36, ASCII_37, + ASCII_38, ASCII_39, ASCII_3A, ASCII_3B, + ASCII_3C, ASCII_3D, ASCII_3E, ASCII_3F, + ASCII_40, ASCII_41, ASCII_42, ASCII_43, + ASCII_44, ASCII_45, ASCII_46, ASCII_47, + ASCII_48, ASCII_49, ASCII_4A, ASCII_4B, + ASCII_4C, ASCII_4D, ASCII_4E, ASCII_4F, + ASCII_50, ASCII_51, ASCII_52, ASCII_53, + ASCII_54, ASCII_55, ASCII_56, ASCII_57, + ASCII_58, ASCII_59, ASCII_5A, ASCII_5B, + ASCII_5C, ASCII_5D, ASCII_5E, ASCII_5F, + ASCII_60, ASCII_61, ASCII_62, ASCII_63, + ASCII_64, ASCII_65, ASCII_66, ASCII_67, + ASCII_68, ASCII_69, ASCII_6A, ASCII_6B, + ASCII_6C, ASCII_6D, ASCII_6E, ASCII_6F, + ASCII_70, ASCII_71, ASCII_72, ASCII_73, + ASCII_74, ASCII_75, ASCII_76, ASCII_77, + ASCII_78, ASCII_79, ASCII_7A, ASCII_7B, + ASCII_7C, ASCII_7D, ASCII_7E, ASCII_7F + }, + #include "undefkeylayouts.h" + #define LAYOUT_GERMAN_SWISS + #include "keylayouts.h" + { + ASCII_20, ASCII_21, ASCII_22, ASCII_23, + ASCII_24, ASCII_25, ASCII_26, ASCII_27, + ASCII_28, ASCII_29, ASCII_2A, ASCII_2B, + ASCII_2C, ASCII_2D, ASCII_2E, ASCII_2F, + ASCII_30, ASCII_31, ASCII_32, ASCII_33, + ASCII_34, ASCII_35, ASCII_36, ASCII_37, + ASCII_38, ASCII_39, ASCII_3A, ASCII_3B, + ASCII_3C, ASCII_3D, ASCII_3E, ASCII_3F, + ASCII_40, ASCII_41, ASCII_42, ASCII_43, + ASCII_44, ASCII_45, ASCII_46, ASCII_47, + ASCII_48, ASCII_49, ASCII_4A, ASCII_4B, + ASCII_4C, ASCII_4D, ASCII_4E, ASCII_4F, + ASCII_50, ASCII_51, ASCII_52, ASCII_53, + ASCII_54, ASCII_55, ASCII_56, ASCII_57, + ASCII_58, ASCII_59, ASCII_5A, ASCII_5B, + ASCII_5C, ASCII_5D, ASCII_5E, ASCII_5F, + ASCII_60, ASCII_61, ASCII_62, ASCII_63, + ASCII_64, ASCII_65, ASCII_66, ASCII_67, + ASCII_68, ASCII_69, ASCII_6A, ASCII_6B, + ASCII_6C, ASCII_6D, ASCII_6E, ASCII_6F, + ASCII_70, ASCII_71, ASCII_72, ASCII_73, + ASCII_74, ASCII_75, ASCII_76, ASCII_77, + ASCII_78, ASCII_79, ASCII_7A, ASCII_7B, + ASCII_7C, ASCII_7D, ASCII_7E, ASCII_7F + }, + #include "undefkeylayouts.h" + #define LAYOUT_FRENCH_SWISS + #include "keylayouts.h" + { + ASCII_20, ASCII_21, ASCII_22, ASCII_23, + ASCII_24, ASCII_25, ASCII_26, ASCII_27, + ASCII_28, ASCII_29, ASCII_2A, ASCII_2B, + ASCII_2C, ASCII_2D, ASCII_2E, ASCII_2F, + ASCII_30, ASCII_31, ASCII_32, ASCII_33, + ASCII_34, ASCII_35, ASCII_36, ASCII_37, + ASCII_38, ASCII_39, ASCII_3A, ASCII_3B, + ASCII_3C, ASCII_3D, ASCII_3E, ASCII_3F, + ASCII_40, ASCII_41, ASCII_42, ASCII_43, + ASCII_44, ASCII_45, ASCII_46, ASCII_47, + ASCII_48, ASCII_49, ASCII_4A, ASCII_4B, + ASCII_4C, ASCII_4D, ASCII_4E, ASCII_4F, + ASCII_50, ASCII_51, ASCII_52, ASCII_53, + ASCII_54, ASCII_55, ASCII_56, ASCII_57, + ASCII_58, ASCII_59, ASCII_5A, ASCII_5B, + ASCII_5C, ASCII_5D, ASCII_5E, ASCII_5F, + ASCII_60, ASCII_61, ASCII_62, ASCII_63, + ASCII_64, ASCII_65, ASCII_66, ASCII_67, + ASCII_68, ASCII_69, ASCII_6A, ASCII_6B, + ASCII_6C, ASCII_6D, ASCII_6E, ASCII_6F, + ASCII_70, ASCII_71, ASCII_72, ASCII_73, + ASCII_74, ASCII_75, ASCII_76, ASCII_77, + ASCII_78, ASCII_79, ASCII_7A, ASCII_7B, + ASCII_7C, ASCII_7D, ASCII_7E, ASCII_7F + }, + #include "undefkeylayouts.h" + #define LAYOUT_SPANISH_LATIN_AMERICA + #include "keylayouts.h" + { + ASCII_20, ASCII_21, ASCII_22, ASCII_23, + ASCII_24, ASCII_25, ASCII_26, ASCII_27, + ASCII_28, ASCII_29, ASCII_2A, ASCII_2B, + ASCII_2C, ASCII_2D, ASCII_2E, ASCII_2F, + ASCII_30, ASCII_31, ASCII_32, ASCII_33, + ASCII_34, ASCII_35, ASCII_36, ASCII_37, + ASCII_38, ASCII_39, ASCII_3A, ASCII_3B, + ASCII_3C, ASCII_3D, ASCII_3E, ASCII_3F, + ASCII_40, ASCII_41, ASCII_42, ASCII_43, + ASCII_44, ASCII_45, ASCII_46, ASCII_47, + ASCII_48, ASCII_49, ASCII_4A, ASCII_4B, + ASCII_4C, ASCII_4D, ASCII_4E, ASCII_4F, + ASCII_50, ASCII_51, ASCII_52, ASCII_53, + ASCII_54, ASCII_55, ASCII_56, ASCII_57, + ASCII_58, ASCII_59, ASCII_5A, ASCII_5B, + ASCII_5C, ASCII_5D, ASCII_5E, ASCII_5F, + ASCII_60, ASCII_61, ASCII_62, ASCII_63, + ASCII_64, ASCII_65, ASCII_66, ASCII_67, + ASCII_68, ASCII_69, ASCII_6A, ASCII_6B, + ASCII_6C, ASCII_6D, ASCII_6E, ASCII_6F, + ASCII_70, ASCII_71, ASCII_72, ASCII_73, + ASCII_74, ASCII_75, ASCII_76, ASCII_77, + ASCII_78, ASCII_79, ASCII_7A, ASCII_7B, + ASCII_7C, ASCII_7D, ASCII_7E, ASCII_7F + }, + #include "undefkeylayouts.h" + #define LAYOUT_IRISH + #include "keylayouts.h" + { + ASCII_20, ASCII_21, ASCII_22, ASCII_23, + ASCII_24, ASCII_25, ASCII_26, ASCII_27, + ASCII_28, ASCII_29, ASCII_2A, ASCII_2B, + ASCII_2C, ASCII_2D, ASCII_2E, ASCII_2F, + ASCII_30, ASCII_31, ASCII_32, ASCII_33, + ASCII_34, ASCII_35, ASCII_36, ASCII_37, + ASCII_38, ASCII_39, ASCII_3A, ASCII_3B, + ASCII_3C, ASCII_3D, ASCII_3E, ASCII_3F, + ASCII_40, ASCII_41, ASCII_42, ASCII_43, + ASCII_44, ASCII_45, ASCII_46, ASCII_47, + ASCII_48, ASCII_49, ASCII_4A, ASCII_4B, + ASCII_4C, ASCII_4D, ASCII_4E, ASCII_4F, + ASCII_50, ASCII_51, ASCII_52, ASCII_53, + ASCII_54, ASCII_55, ASCII_56, ASCII_57, + ASCII_58, ASCII_59, ASCII_5A, ASCII_5B, + ASCII_5C, ASCII_5D, ASCII_5E, ASCII_5F, + ASCII_60, ASCII_61, ASCII_62, ASCII_63, + ASCII_64, ASCII_65, ASCII_66, ASCII_67, + ASCII_68, ASCII_69, ASCII_6A, ASCII_6B, + ASCII_6C, ASCII_6D, ASCII_6E, ASCII_6F, + ASCII_70, ASCII_71, ASCII_72, ASCII_73, + ASCII_74, ASCII_75, ASCII_76, ASCII_77, + ASCII_78, ASCII_79, ASCII_7A, ASCII_7B, + ASCII_7C, ASCII_7D, ASCII_7E, ASCII_7F + }, + #include "undefkeylayouts.h" + #define LAYOUT_ICELANDIC + #include "keylayouts.h" + { + ASCII_20, ASCII_21, ASCII_22, ASCII_23, + ASCII_24, ASCII_25, ASCII_26, ASCII_27, + ASCII_28, ASCII_29, ASCII_2A, ASCII_2B, + ASCII_2C, ASCII_2D, ASCII_2E, ASCII_2F, + ASCII_30, ASCII_31, ASCII_32, ASCII_33, + ASCII_34, ASCII_35, ASCII_36, ASCII_37, + ASCII_38, ASCII_39, ASCII_3A, ASCII_3B, + ASCII_3C, ASCII_3D, ASCII_3E, ASCII_3F, + ASCII_40, ASCII_41, ASCII_42, ASCII_43, + ASCII_44, ASCII_45, ASCII_46, ASCII_47, + ASCII_48, ASCII_49, ASCII_4A, ASCII_4B, + ASCII_4C, ASCII_4D, ASCII_4E, ASCII_4F, + ASCII_50, ASCII_51, ASCII_52, ASCII_53, + ASCII_54, ASCII_55, ASCII_56, ASCII_57, + ASCII_58, ASCII_59, ASCII_5A, ASCII_5B, + ASCII_5C, ASCII_5D, ASCII_5E, ASCII_5F, + ASCII_60, ASCII_61, ASCII_62, ASCII_63, + ASCII_64, ASCII_65, ASCII_66, ASCII_67, + ASCII_68, ASCII_69, ASCII_6A, ASCII_6B, + ASCII_6C, ASCII_6D, ASCII_6E, ASCII_6F, + ASCII_70, ASCII_71, ASCII_72, ASCII_73, + ASCII_74, ASCII_75, ASCII_76, ASCII_77, + ASCII_78, ASCII_79, ASCII_7A, ASCII_7B, + ASCII_7C, ASCII_7D, ASCII_7E, ASCII_7F + }, + #include "undefkeylayouts.h" + #define LAYOUT_TURKISH + #include "keylayouts.h" + { + ASCII_20, ASCII_21, ASCII_22, ASCII_23, + ASCII_24, ASCII_25, ASCII_26, ASCII_27, + ASCII_28, ASCII_29, ASCII_2A, ASCII_2B, + ASCII_2C, ASCII_2D, ASCII_2E, ASCII_2F, + ASCII_30, ASCII_31, ASCII_32, ASCII_33, + ASCII_34, ASCII_35, ASCII_36, ASCII_37, + ASCII_38, ASCII_39, ASCII_3A, ASCII_3B, + ASCII_3C, ASCII_3D, ASCII_3E, ASCII_3F, + ASCII_40, ASCII_41, ASCII_42, ASCII_43, + ASCII_44, ASCII_45, ASCII_46, ASCII_47, + ASCII_48, ASCII_49, ASCII_4A, ASCII_4B, + ASCII_4C, ASCII_4D, ASCII_4E, ASCII_4F, + ASCII_50, ASCII_51, ASCII_52, ASCII_53, + ASCII_54, ASCII_55, ASCII_56, ASCII_57, + ASCII_58, ASCII_59, ASCII_5A, ASCII_5B, + ASCII_5C, ASCII_5D, ASCII_5E, ASCII_5F, + ASCII_60, ASCII_61, ASCII_62, ASCII_63, + ASCII_64, ASCII_65, ASCII_66, ASCII_67, + ASCII_68, ASCII_69, ASCII_6A, ASCII_6B, + ASCII_6C, ASCII_6D, ASCII_6E, ASCII_6F, + ASCII_70, ASCII_71, ASCII_72, ASCII_73, + ASCII_74, ASCII_75, ASCII_76, ASCII_77, + ASCII_78, ASCII_79, ASCII_7A, ASCII_7B, + ASCII_7C, ASCII_7D, ASCII_7E, ASCII_7F + }, + #include "undefkeylayouts.h" + #define LAYOUT_CZECH + #include "keylayouts.h" + { + ASCII_20, ASCII_21, ASCII_22, ASCII_23, + ASCII_24, ASCII_25, ASCII_26, ASCII_27, + ASCII_28, ASCII_29, ASCII_2A, ASCII_2B, + ASCII_2C, ASCII_2D, ASCII_2E, ASCII_2F, + ASCII_30, ASCII_31, ASCII_32, ASCII_33, + ASCII_34, ASCII_35, ASCII_36, ASCII_37, + ASCII_38, ASCII_39, ASCII_3A, ASCII_3B, + ASCII_3C, ASCII_3D, ASCII_3E, ASCII_3F, + ASCII_40, ASCII_41, ASCII_42, ASCII_43, + ASCII_44, ASCII_45, ASCII_46, ASCII_47, + ASCII_48, ASCII_49, ASCII_4A, ASCII_4B, + ASCII_4C, ASCII_4D, ASCII_4E, ASCII_4F, + ASCII_50, ASCII_51, ASCII_52, ASCII_53, + ASCII_54, ASCII_55, ASCII_56, ASCII_57, + ASCII_58, ASCII_59, ASCII_5A, ASCII_5B, + ASCII_5C, ASCII_5D, ASCII_5E, ASCII_5F, + ASCII_60, ASCII_61, ASCII_62, ASCII_63, + ASCII_64, ASCII_65, ASCII_66, ASCII_67, + ASCII_68, ASCII_69, ASCII_6A, ASCII_6B, + ASCII_6C, ASCII_6D, ASCII_6E, ASCII_6F, + ASCII_70, ASCII_71, ASCII_72, ASCII_73, + ASCII_74, ASCII_75, ASCII_76, ASCII_77, + ASCII_78, ASCII_79, ASCII_7A, ASCII_7B, + ASCII_7C, ASCII_7D, ASCII_7E, ASCII_7F + }, + #include "undefkeylayouts.h" + #define LAYOUT_SERBIAN_LATIN_ONLY + #include "keylayouts.h" + { + ASCII_20, ASCII_21, ASCII_22, ASCII_23, + ASCII_24, ASCII_25, ASCII_26, ASCII_27, + ASCII_28, ASCII_29, ASCII_2A, ASCII_2B, + ASCII_2C, ASCII_2D, ASCII_2E, ASCII_2F, + ASCII_30, ASCII_31, ASCII_32, ASCII_33, + ASCII_34, ASCII_35, ASCII_36, ASCII_37, + ASCII_38, ASCII_39, ASCII_3A, ASCII_3B, + ASCII_3C, ASCII_3D, ASCII_3E, ASCII_3F, + ASCII_40, ASCII_41, ASCII_42, ASCII_43, + ASCII_44, ASCII_45, ASCII_46, ASCII_47, + ASCII_48, ASCII_49, ASCII_4A, ASCII_4B, + ASCII_4C, ASCII_4D, ASCII_4E, ASCII_4F, + ASCII_50, ASCII_51, ASCII_52, ASCII_53, + ASCII_54, ASCII_55, ASCII_56, ASCII_57, + ASCII_58, ASCII_59, ASCII_5A, ASCII_5B, + ASCII_5C, ASCII_5D, ASCII_5E, ASCII_5F, + ASCII_60, ASCII_61, ASCII_62, ASCII_63, + ASCII_64, ASCII_65, ASCII_66, ASCII_67, + ASCII_68, ASCII_69, ASCII_6A, ASCII_6B, + ASCII_6C, ASCII_6D, ASCII_6E, ASCII_6F, + ASCII_70, ASCII_71, ASCII_72, ASCII_73, + ASCII_74, ASCII_75, ASCII_76, ASCII_77, + ASCII_78, ASCII_79, ASCII_7A, ASCII_7B, + ASCII_7C, ASCII_7D, ASCII_7E, ASCII_7F + } +}; + +/** + * array of keycodes for ISO8859 code points. + * WARNING: locale offset is different, because there is no + * LAYOUT_US_ENGLISH! + * */ +const uint16_t keycodes_iso_8859_1[][96] = { + #include "undefkeylayouts.h" + #define LAYOUT_US_INTERNATIONAL + #include "keylayouts.h" + { + ISO_8859_1_A0, ISO_8859_1_A1, ISO_8859_1_A2, ISO_8859_1_A3, + ISO_8859_1_A4, ISO_8859_1_A5, ISO_8859_1_A6, ISO_8859_1_A7, + ISO_8859_1_A8, ISO_8859_1_A9, ISO_8859_1_AA, ISO_8859_1_AB, + ISO_8859_1_AC, ISO_8859_1_AD, ISO_8859_1_AE, ISO_8859_1_AF, + ISO_8859_1_B0, ISO_8859_1_B1, ISO_8859_1_B2, ISO_8859_1_B3, + ISO_8859_1_B4, ISO_8859_1_B5, ISO_8859_1_B6, ISO_8859_1_B7, + ISO_8859_1_B8, ISO_8859_1_B9, ISO_8859_1_BA, ISO_8859_1_BB, + ISO_8859_1_BC, ISO_8859_1_BD, ISO_8859_1_BE, ISO_8859_1_BF, + ISO_8859_1_C0, ISO_8859_1_C1, ISO_8859_1_C2, ISO_8859_1_C3, + ISO_8859_1_C4, ISO_8859_1_C5, ISO_8859_1_C6, ISO_8859_1_C7, + ISO_8859_1_C8, ISO_8859_1_C9, ISO_8859_1_CA, ISO_8859_1_CB, + ISO_8859_1_CC, ISO_8859_1_CD, ISO_8859_1_CE, ISO_8859_1_CF, + ISO_8859_1_D0, ISO_8859_1_D1, ISO_8859_1_D2, ISO_8859_1_D3, + ISO_8859_1_D4, ISO_8859_1_D5, ISO_8859_1_D6, ISO_8859_1_D7, + ISO_8859_1_D8, ISO_8859_1_D9, ISO_8859_1_DA, ISO_8859_1_DB, + ISO_8859_1_DC, ISO_8859_1_DD, ISO_8859_1_DE, ISO_8859_1_DF, + ISO_8859_1_E0, ISO_8859_1_E1, ISO_8859_1_E2, ISO_8859_1_E3, + ISO_8859_1_E4, ISO_8859_1_E5, ISO_8859_1_E6, ISO_8859_1_E7, + ISO_8859_1_E8, ISO_8859_1_E9, ISO_8859_1_EA, ISO_8859_1_EB, + ISO_8859_1_EC, ISO_8859_1_ED, ISO_8859_1_EE, ISO_8859_1_EF, + ISO_8859_1_F0, ISO_8859_1_F1, ISO_8859_1_F2, ISO_8859_1_F3, + ISO_8859_1_F4, ISO_8859_1_F5, ISO_8859_1_F6, ISO_8859_1_F7, + ISO_8859_1_F8, ISO_8859_1_F9, ISO_8859_1_FA, ISO_8859_1_FB, + ISO_8859_1_FC, ISO_8859_1_FD, ISO_8859_1_FE, ISO_8859_1_FF + }, + #include "undefkeylayouts.h" + #define LAYOUT_GERMAN + #include "keylayouts.h" + { + ISO_8859_1_A0, ISO_8859_1_A1, ISO_8859_1_A2, ISO_8859_1_A3, + ISO_8859_1_A4, ISO_8859_1_A5, ISO_8859_1_A6, ISO_8859_1_A7, + ISO_8859_1_A8, ISO_8859_1_A9, ISO_8859_1_AA, ISO_8859_1_AB, + ISO_8859_1_AC, ISO_8859_1_AD, ISO_8859_1_AE, ISO_8859_1_AF, + ISO_8859_1_B0, ISO_8859_1_B1, ISO_8859_1_B2, ISO_8859_1_B3, + ISO_8859_1_B4, ISO_8859_1_B5, ISO_8859_1_B6, ISO_8859_1_B7, + ISO_8859_1_B8, ISO_8859_1_B9, ISO_8859_1_BA, ISO_8859_1_BB, + ISO_8859_1_BC, ISO_8859_1_BD, ISO_8859_1_BE, ISO_8859_1_BF, + ISO_8859_1_C0, ISO_8859_1_C1, ISO_8859_1_C2, ISO_8859_1_C3, + ISO_8859_1_C4, ISO_8859_1_C5, ISO_8859_1_C6, ISO_8859_1_C7, + ISO_8859_1_C8, ISO_8859_1_C9, ISO_8859_1_CA, ISO_8859_1_CB, + ISO_8859_1_CC, ISO_8859_1_CD, ISO_8859_1_CE, ISO_8859_1_CF, + ISO_8859_1_D0, ISO_8859_1_D1, ISO_8859_1_D2, ISO_8859_1_D3, + ISO_8859_1_D4, ISO_8859_1_D5, ISO_8859_1_D6, ISO_8859_1_D7, + ISO_8859_1_D8, ISO_8859_1_D9, ISO_8859_1_DA, ISO_8859_1_DB, + ISO_8859_1_DC, ISO_8859_1_DD, ISO_8859_1_DE, ISO_8859_1_DF, + ISO_8859_1_E0, ISO_8859_1_E1, ISO_8859_1_E2, ISO_8859_1_E3, + ISO_8859_1_E4, ISO_8859_1_E5, ISO_8859_1_E6, ISO_8859_1_E7, + ISO_8859_1_E8, ISO_8859_1_E9, ISO_8859_1_EA, ISO_8859_1_EB, + ISO_8859_1_EC, ISO_8859_1_ED, ISO_8859_1_EE, ISO_8859_1_EF, + ISO_8859_1_F0, ISO_8859_1_F1, ISO_8859_1_F2, ISO_8859_1_F3, + ISO_8859_1_F4, ISO_8859_1_F5, ISO_8859_1_F6, ISO_8859_1_F7, + ISO_8859_1_F8, ISO_8859_1_F9, ISO_8859_1_FA, ISO_8859_1_FB, + ISO_8859_1_FC, ISO_8859_1_FD, ISO_8859_1_FE, ISO_8859_1_FF + }, + #include "undefkeylayouts.h" + #define LAYOUT_GERMAN_MAC + #include "keylayouts.h" + { + ISO_8859_1_A0, ISO_8859_1_A1, ISO_8859_1_A2, ISO_8859_1_A3, + ISO_8859_1_A4, ISO_8859_1_A5, ISO_8859_1_A6, ISO_8859_1_A7, + ISO_8859_1_A8, ISO_8859_1_A9, ISO_8859_1_AA, ISO_8859_1_AB, + ISO_8859_1_AC, ISO_8859_1_AD, ISO_8859_1_AE, ISO_8859_1_AF, + ISO_8859_1_B0, ISO_8859_1_B1, ISO_8859_1_B2, ISO_8859_1_B3, + ISO_8859_1_B4, ISO_8859_1_B5, ISO_8859_1_B6, ISO_8859_1_B7, + ISO_8859_1_B8, ISO_8859_1_B9, ISO_8859_1_BA, ISO_8859_1_BB, + ISO_8859_1_BC, ISO_8859_1_BD, ISO_8859_1_BE, ISO_8859_1_BF, + ISO_8859_1_C0, ISO_8859_1_C1, ISO_8859_1_C2, ISO_8859_1_C3, + ISO_8859_1_C4, ISO_8859_1_C5, ISO_8859_1_C6, ISO_8859_1_C7, + ISO_8859_1_C8, ISO_8859_1_C9, ISO_8859_1_CA, ISO_8859_1_CB, + ISO_8859_1_CC, ISO_8859_1_CD, ISO_8859_1_CE, ISO_8859_1_CF, + ISO_8859_1_D0, ISO_8859_1_D1, ISO_8859_1_D2, ISO_8859_1_D3, + ISO_8859_1_D4, ISO_8859_1_D5, ISO_8859_1_D6, ISO_8859_1_D7, + ISO_8859_1_D8, ISO_8859_1_D9, ISO_8859_1_DA, ISO_8859_1_DB, + ISO_8859_1_DC, ISO_8859_1_DD, ISO_8859_1_DE, ISO_8859_1_DF, + ISO_8859_1_E0, ISO_8859_1_E1, ISO_8859_1_E2, ISO_8859_1_E3, + ISO_8859_1_E4, ISO_8859_1_E5, ISO_8859_1_E6, ISO_8859_1_E7, + ISO_8859_1_E8, ISO_8859_1_E9, ISO_8859_1_EA, ISO_8859_1_EB, + ISO_8859_1_EC, ISO_8859_1_ED, ISO_8859_1_EE, ISO_8859_1_EF, + ISO_8859_1_F0, ISO_8859_1_F1, ISO_8859_1_F2, ISO_8859_1_F3, + ISO_8859_1_F4, ISO_8859_1_F5, ISO_8859_1_F6, ISO_8859_1_F7, + ISO_8859_1_F8, ISO_8859_1_F9, ISO_8859_1_FA, ISO_8859_1_FB, + ISO_8859_1_FC, ISO_8859_1_FD, ISO_8859_1_FE, ISO_8859_1_FF + }, + #include "undefkeylayouts.h" + #define LAYOUT_CANADIAN_FRENCH + #include "keylayouts.h" + { + ISO_8859_1_A0, ISO_8859_1_A1, ISO_8859_1_A2, ISO_8859_1_A3, + ISO_8859_1_A4, ISO_8859_1_A5, ISO_8859_1_A6, ISO_8859_1_A7, + ISO_8859_1_A8, ISO_8859_1_A9, ISO_8859_1_AA, ISO_8859_1_AB, + ISO_8859_1_AC, ISO_8859_1_AD, ISO_8859_1_AE, ISO_8859_1_AF, + ISO_8859_1_B0, ISO_8859_1_B1, ISO_8859_1_B2, ISO_8859_1_B3, + ISO_8859_1_B4, ISO_8859_1_B5, ISO_8859_1_B6, ISO_8859_1_B7, + ISO_8859_1_B8, ISO_8859_1_B9, ISO_8859_1_BA, ISO_8859_1_BB, + ISO_8859_1_BC, ISO_8859_1_BD, ISO_8859_1_BE, ISO_8859_1_BF, + ISO_8859_1_C0, ISO_8859_1_C1, ISO_8859_1_C2, ISO_8859_1_C3, + ISO_8859_1_C4, ISO_8859_1_C5, ISO_8859_1_C6, ISO_8859_1_C7, + ISO_8859_1_C8, ISO_8859_1_C9, ISO_8859_1_CA, ISO_8859_1_CB, + ISO_8859_1_CC, ISO_8859_1_CD, ISO_8859_1_CE, ISO_8859_1_CF, + ISO_8859_1_D0, ISO_8859_1_D1, ISO_8859_1_D2, ISO_8859_1_D3, + ISO_8859_1_D4, ISO_8859_1_D5, ISO_8859_1_D6, ISO_8859_1_D7, + ISO_8859_1_D8, ISO_8859_1_D9, ISO_8859_1_DA, ISO_8859_1_DB, + ISO_8859_1_DC, ISO_8859_1_DD, ISO_8859_1_DE, ISO_8859_1_DF, + ISO_8859_1_E0, ISO_8859_1_E1, ISO_8859_1_E2, ISO_8859_1_E3, + ISO_8859_1_E4, ISO_8859_1_E5, ISO_8859_1_E6, ISO_8859_1_E7, + ISO_8859_1_E8, ISO_8859_1_E9, ISO_8859_1_EA, ISO_8859_1_EB, + ISO_8859_1_EC, ISO_8859_1_ED, ISO_8859_1_EE, ISO_8859_1_EF, + ISO_8859_1_F0, ISO_8859_1_F1, ISO_8859_1_F2, ISO_8859_1_F3, + ISO_8859_1_F4, ISO_8859_1_F5, ISO_8859_1_F6, ISO_8859_1_F7, + ISO_8859_1_F8, ISO_8859_1_F9, ISO_8859_1_FA, ISO_8859_1_FB, + ISO_8859_1_FC, ISO_8859_1_FD, ISO_8859_1_FE, ISO_8859_1_FF + }, + #include "undefkeylayouts.h" + #define LAYOUT_CANADIAN_MULTILINGUAL + #include "keylayouts.h" + { + ISO_8859_1_A0, ISO_8859_1_A1, ISO_8859_1_A2, ISO_8859_1_A3, + ISO_8859_1_A4, ISO_8859_1_A5, ISO_8859_1_A6, ISO_8859_1_A7, + ISO_8859_1_A8, ISO_8859_1_A9, ISO_8859_1_AA, ISO_8859_1_AB, + ISO_8859_1_AC, ISO_8859_1_AD, ISO_8859_1_AE, ISO_8859_1_AF, + ISO_8859_1_B0, ISO_8859_1_B1, ISO_8859_1_B2, ISO_8859_1_B3, + ISO_8859_1_B4, ISO_8859_1_B5, ISO_8859_1_B6, ISO_8859_1_B7, + ISO_8859_1_B8, ISO_8859_1_B9, ISO_8859_1_BA, ISO_8859_1_BB, + ISO_8859_1_BC, ISO_8859_1_BD, ISO_8859_1_BE, ISO_8859_1_BF, + ISO_8859_1_C0, ISO_8859_1_C1, ISO_8859_1_C2, ISO_8859_1_C3, + ISO_8859_1_C4, ISO_8859_1_C5, ISO_8859_1_C6, ISO_8859_1_C7, + ISO_8859_1_C8, ISO_8859_1_C9, ISO_8859_1_CA, ISO_8859_1_CB, + ISO_8859_1_CC, ISO_8859_1_CD, ISO_8859_1_CE, ISO_8859_1_CF, + ISO_8859_1_D0, ISO_8859_1_D1, ISO_8859_1_D2, ISO_8859_1_D3, + ISO_8859_1_D4, ISO_8859_1_D5, ISO_8859_1_D6, ISO_8859_1_D7, + ISO_8859_1_D8, ISO_8859_1_D9, ISO_8859_1_DA, ISO_8859_1_DB, + ISO_8859_1_DC, ISO_8859_1_DD, ISO_8859_1_DE, ISO_8859_1_DF, + ISO_8859_1_E0, ISO_8859_1_E1, ISO_8859_1_E2, ISO_8859_1_E3, + ISO_8859_1_E4, ISO_8859_1_E5, ISO_8859_1_E6, ISO_8859_1_E7, + ISO_8859_1_E8, ISO_8859_1_E9, ISO_8859_1_EA, ISO_8859_1_EB, + ISO_8859_1_EC, ISO_8859_1_ED, ISO_8859_1_EE, ISO_8859_1_EF, + ISO_8859_1_F0, ISO_8859_1_F1, ISO_8859_1_F2, ISO_8859_1_F3, + ISO_8859_1_F4, ISO_8859_1_F5, ISO_8859_1_F6, ISO_8859_1_F7, + ISO_8859_1_F8, ISO_8859_1_F9, ISO_8859_1_FA, ISO_8859_1_FB, + ISO_8859_1_FC, ISO_8859_1_FD, ISO_8859_1_FE, ISO_8859_1_FF + }, + #include "undefkeylayouts.h" + #define LAYOUT_UNITED_KINGDOM + #include "keylayouts.h" + { + ISO_8859_1_A0, ISO_8859_1_A1, ISO_8859_1_A2, ISO_8859_1_A3, + ISO_8859_1_A4, ISO_8859_1_A5, ISO_8859_1_A6, ISO_8859_1_A7, + ISO_8859_1_A8, ISO_8859_1_A9, ISO_8859_1_AA, ISO_8859_1_AB, + ISO_8859_1_AC, ISO_8859_1_AD, ISO_8859_1_AE, ISO_8859_1_AF, + ISO_8859_1_B0, ISO_8859_1_B1, ISO_8859_1_B2, ISO_8859_1_B3, + ISO_8859_1_B4, ISO_8859_1_B5, ISO_8859_1_B6, ISO_8859_1_B7, + ISO_8859_1_B8, ISO_8859_1_B9, ISO_8859_1_BA, ISO_8859_1_BB, + ISO_8859_1_BC, ISO_8859_1_BD, ISO_8859_1_BE, ISO_8859_1_BF, + ISO_8859_1_C0, ISO_8859_1_C1, ISO_8859_1_C2, ISO_8859_1_C3, + ISO_8859_1_C4, ISO_8859_1_C5, ISO_8859_1_C6, ISO_8859_1_C7, + ISO_8859_1_C8, ISO_8859_1_C9, ISO_8859_1_CA, ISO_8859_1_CB, + ISO_8859_1_CC, ISO_8859_1_CD, ISO_8859_1_CE, ISO_8859_1_CF, + ISO_8859_1_D0, ISO_8859_1_D1, ISO_8859_1_D2, ISO_8859_1_D3, + ISO_8859_1_D4, ISO_8859_1_D5, ISO_8859_1_D6, ISO_8859_1_D7, + ISO_8859_1_D8, ISO_8859_1_D9, ISO_8859_1_DA, ISO_8859_1_DB, + ISO_8859_1_DC, ISO_8859_1_DD, ISO_8859_1_DE, ISO_8859_1_DF, + ISO_8859_1_E0, ISO_8859_1_E1, ISO_8859_1_E2, ISO_8859_1_E3, + ISO_8859_1_E4, ISO_8859_1_E5, ISO_8859_1_E6, ISO_8859_1_E7, + ISO_8859_1_E8, ISO_8859_1_E9, ISO_8859_1_EA, ISO_8859_1_EB, + ISO_8859_1_EC, ISO_8859_1_ED, ISO_8859_1_EE, ISO_8859_1_EF, + ISO_8859_1_F0, ISO_8859_1_F1, ISO_8859_1_F2, ISO_8859_1_F3, + ISO_8859_1_F4, ISO_8859_1_F5, ISO_8859_1_F6, ISO_8859_1_F7, + ISO_8859_1_F8, ISO_8859_1_F9, ISO_8859_1_FA, ISO_8859_1_FB, + ISO_8859_1_FC, ISO_8859_1_FD, ISO_8859_1_FE, ISO_8859_1_FF + }, + #include "undefkeylayouts.h" + #define LAYOUT_FINNISH + #include "keylayouts.h" + { + ISO_8859_1_A0, ISO_8859_1_A1, ISO_8859_1_A2, ISO_8859_1_A3, + ISO_8859_1_A4, ISO_8859_1_A5, ISO_8859_1_A6, ISO_8859_1_A7, + ISO_8859_1_A8, ISO_8859_1_A9, ISO_8859_1_AA, ISO_8859_1_AB, + ISO_8859_1_AC, ISO_8859_1_AD, ISO_8859_1_AE, ISO_8859_1_AF, + ISO_8859_1_B0, ISO_8859_1_B1, ISO_8859_1_B2, ISO_8859_1_B3, + ISO_8859_1_B4, ISO_8859_1_B5, ISO_8859_1_B6, ISO_8859_1_B7, + ISO_8859_1_B8, ISO_8859_1_B9, ISO_8859_1_BA, ISO_8859_1_BB, + ISO_8859_1_BC, ISO_8859_1_BD, ISO_8859_1_BE, ISO_8859_1_BF, + ISO_8859_1_C0, ISO_8859_1_C1, ISO_8859_1_C2, ISO_8859_1_C3, + ISO_8859_1_C4, ISO_8859_1_C5, ISO_8859_1_C6, ISO_8859_1_C7, + ISO_8859_1_C8, ISO_8859_1_C9, ISO_8859_1_CA, ISO_8859_1_CB, + ISO_8859_1_CC, ISO_8859_1_CD, ISO_8859_1_CE, ISO_8859_1_CF, + ISO_8859_1_D0, ISO_8859_1_D1, ISO_8859_1_D2, ISO_8859_1_D3, + ISO_8859_1_D4, ISO_8859_1_D5, ISO_8859_1_D6, ISO_8859_1_D7, + ISO_8859_1_D8, ISO_8859_1_D9, ISO_8859_1_DA, ISO_8859_1_DB, + ISO_8859_1_DC, ISO_8859_1_DD, ISO_8859_1_DE, ISO_8859_1_DF, + ISO_8859_1_E0, ISO_8859_1_E1, ISO_8859_1_E2, ISO_8859_1_E3, + ISO_8859_1_E4, ISO_8859_1_E5, ISO_8859_1_E6, ISO_8859_1_E7, + ISO_8859_1_E8, ISO_8859_1_E9, ISO_8859_1_EA, ISO_8859_1_EB, + ISO_8859_1_EC, ISO_8859_1_ED, ISO_8859_1_EE, ISO_8859_1_EF, + ISO_8859_1_F0, ISO_8859_1_F1, ISO_8859_1_F2, ISO_8859_1_F3, + ISO_8859_1_F4, ISO_8859_1_F5, ISO_8859_1_F6, ISO_8859_1_F7, + ISO_8859_1_F8, ISO_8859_1_F9, ISO_8859_1_FA, ISO_8859_1_FB, + ISO_8859_1_FC, ISO_8859_1_FD, ISO_8859_1_FE, ISO_8859_1_FF + }, + #include "undefkeylayouts.h" + #define LAYOUT_FRENCH + #include "keylayouts.h" + { + ISO_8859_1_A0, ISO_8859_1_A1, ISO_8859_1_A2, ISO_8859_1_A3, + ISO_8859_1_A4, ISO_8859_1_A5, ISO_8859_1_A6, ISO_8859_1_A7, + ISO_8859_1_A8, ISO_8859_1_A9, ISO_8859_1_AA, ISO_8859_1_AB, + ISO_8859_1_AC, ISO_8859_1_AD, ISO_8859_1_AE, ISO_8859_1_AF, + ISO_8859_1_B0, ISO_8859_1_B1, ISO_8859_1_B2, ISO_8859_1_B3, + ISO_8859_1_B4, ISO_8859_1_B5, ISO_8859_1_B6, ISO_8859_1_B7, + ISO_8859_1_B8, ISO_8859_1_B9, ISO_8859_1_BA, ISO_8859_1_BB, + ISO_8859_1_BC, ISO_8859_1_BD, ISO_8859_1_BE, ISO_8859_1_BF, + ISO_8859_1_C0, ISO_8859_1_C1, ISO_8859_1_C2, ISO_8859_1_C3, + ISO_8859_1_C4, ISO_8859_1_C5, ISO_8859_1_C6, ISO_8859_1_C7, + ISO_8859_1_C8, ISO_8859_1_C9, ISO_8859_1_CA, ISO_8859_1_CB, + ISO_8859_1_CC, ISO_8859_1_CD, ISO_8859_1_CE, ISO_8859_1_CF, + ISO_8859_1_D0, ISO_8859_1_D1, ISO_8859_1_D2, ISO_8859_1_D3, + ISO_8859_1_D4, ISO_8859_1_D5, ISO_8859_1_D6, ISO_8859_1_D7, + ISO_8859_1_D8, ISO_8859_1_D9, ISO_8859_1_DA, ISO_8859_1_DB, + ISO_8859_1_DC, ISO_8859_1_DD, ISO_8859_1_DE, ISO_8859_1_DF, + ISO_8859_1_E0, ISO_8859_1_E1, ISO_8859_1_E2, ISO_8859_1_E3, + ISO_8859_1_E4, ISO_8859_1_E5, ISO_8859_1_E6, ISO_8859_1_E7, + ISO_8859_1_E8, ISO_8859_1_E9, ISO_8859_1_EA, ISO_8859_1_EB, + ISO_8859_1_EC, ISO_8859_1_ED, ISO_8859_1_EE, ISO_8859_1_EF, + ISO_8859_1_F0, ISO_8859_1_F1, ISO_8859_1_F2, ISO_8859_1_F3, + ISO_8859_1_F4, ISO_8859_1_F5, ISO_8859_1_F6, ISO_8859_1_F7, + ISO_8859_1_F8, ISO_8859_1_F9, ISO_8859_1_FA, ISO_8859_1_FB, + ISO_8859_1_FC, ISO_8859_1_FD, ISO_8859_1_FE, ISO_8859_1_FF + }, + #include "undefkeylayouts.h" + #define LAYOUT_DANISH + #include "keylayouts.h" + { + ISO_8859_1_A0, ISO_8859_1_A1, ISO_8859_1_A2, ISO_8859_1_A3, + ISO_8859_1_A4, ISO_8859_1_A5, ISO_8859_1_A6, ISO_8859_1_A7, + ISO_8859_1_A8, ISO_8859_1_A9, ISO_8859_1_AA, ISO_8859_1_AB, + ISO_8859_1_AC, ISO_8859_1_AD, ISO_8859_1_AE, ISO_8859_1_AF, + ISO_8859_1_B0, ISO_8859_1_B1, ISO_8859_1_B2, ISO_8859_1_B3, + ISO_8859_1_B4, ISO_8859_1_B5, ISO_8859_1_B6, ISO_8859_1_B7, + ISO_8859_1_B8, ISO_8859_1_B9, ISO_8859_1_BA, ISO_8859_1_BB, + ISO_8859_1_BC, ISO_8859_1_BD, ISO_8859_1_BE, ISO_8859_1_BF, + ISO_8859_1_C0, ISO_8859_1_C1, ISO_8859_1_C2, ISO_8859_1_C3, + ISO_8859_1_C4, ISO_8859_1_C5, ISO_8859_1_C6, ISO_8859_1_C7, + ISO_8859_1_C8, ISO_8859_1_C9, ISO_8859_1_CA, ISO_8859_1_CB, + ISO_8859_1_CC, ISO_8859_1_CD, ISO_8859_1_CE, ISO_8859_1_CF, + ISO_8859_1_D0, ISO_8859_1_D1, ISO_8859_1_D2, ISO_8859_1_D3, + ISO_8859_1_D4, ISO_8859_1_D5, ISO_8859_1_D6, ISO_8859_1_D7, + ISO_8859_1_D8, ISO_8859_1_D9, ISO_8859_1_DA, ISO_8859_1_DB, + ISO_8859_1_DC, ISO_8859_1_DD, ISO_8859_1_DE, ISO_8859_1_DF, + ISO_8859_1_E0, ISO_8859_1_E1, ISO_8859_1_E2, ISO_8859_1_E3, + ISO_8859_1_E4, ISO_8859_1_E5, ISO_8859_1_E6, ISO_8859_1_E7, + ISO_8859_1_E8, ISO_8859_1_E9, ISO_8859_1_EA, ISO_8859_1_EB, + ISO_8859_1_EC, ISO_8859_1_ED, ISO_8859_1_EE, ISO_8859_1_EF, + ISO_8859_1_F0, ISO_8859_1_F1, ISO_8859_1_F2, ISO_8859_1_F3, + ISO_8859_1_F4, ISO_8859_1_F5, ISO_8859_1_F6, ISO_8859_1_F7, + ISO_8859_1_F8, ISO_8859_1_F9, ISO_8859_1_FA, ISO_8859_1_FB, + ISO_8859_1_FC, ISO_8859_1_FD, ISO_8859_1_FE, ISO_8859_1_FF + }, + #include "undefkeylayouts.h" + #define LAYOUT_NORWEGIAN + #include "keylayouts.h" + { + ISO_8859_1_A0, ISO_8859_1_A1, ISO_8859_1_A2, ISO_8859_1_A3, + ISO_8859_1_A4, ISO_8859_1_A5, ISO_8859_1_A6, ISO_8859_1_A7, + ISO_8859_1_A8, ISO_8859_1_A9, ISO_8859_1_AA, ISO_8859_1_AB, + ISO_8859_1_AC, ISO_8859_1_AD, ISO_8859_1_AE, ISO_8859_1_AF, + ISO_8859_1_B0, ISO_8859_1_B1, ISO_8859_1_B2, ISO_8859_1_B3, + ISO_8859_1_B4, ISO_8859_1_B5, ISO_8859_1_B6, ISO_8859_1_B7, + ISO_8859_1_B8, ISO_8859_1_B9, ISO_8859_1_BA, ISO_8859_1_BB, + ISO_8859_1_BC, ISO_8859_1_BD, ISO_8859_1_BE, ISO_8859_1_BF, + ISO_8859_1_C0, ISO_8859_1_C1, ISO_8859_1_C2, ISO_8859_1_C3, + ISO_8859_1_C4, ISO_8859_1_C5, ISO_8859_1_C6, ISO_8859_1_C7, + ISO_8859_1_C8, ISO_8859_1_C9, ISO_8859_1_CA, ISO_8859_1_CB, + ISO_8859_1_CC, ISO_8859_1_CD, ISO_8859_1_CE, ISO_8859_1_CF, + ISO_8859_1_D0, ISO_8859_1_D1, ISO_8859_1_D2, ISO_8859_1_D3, + ISO_8859_1_D4, ISO_8859_1_D5, ISO_8859_1_D6, ISO_8859_1_D7, + ISO_8859_1_D8, ISO_8859_1_D9, ISO_8859_1_DA, ISO_8859_1_DB, + ISO_8859_1_DC, ISO_8859_1_DD, ISO_8859_1_DE, ISO_8859_1_DF, + ISO_8859_1_E0, ISO_8859_1_E1, ISO_8859_1_E2, ISO_8859_1_E3, + ISO_8859_1_E4, ISO_8859_1_E5, ISO_8859_1_E6, ISO_8859_1_E7, + ISO_8859_1_E8, ISO_8859_1_E9, ISO_8859_1_EA, ISO_8859_1_EB, + ISO_8859_1_EC, ISO_8859_1_ED, ISO_8859_1_EE, ISO_8859_1_EF, + ISO_8859_1_F0, ISO_8859_1_F1, ISO_8859_1_F2, ISO_8859_1_F3, + ISO_8859_1_F4, ISO_8859_1_F5, ISO_8859_1_F6, ISO_8859_1_F7, + ISO_8859_1_F8, ISO_8859_1_F9, ISO_8859_1_FA, ISO_8859_1_FB, + ISO_8859_1_FC, ISO_8859_1_FD, ISO_8859_1_FE, ISO_8859_1_FF + }, + #include "undefkeylayouts.h" + #define LAYOUT_SWEDISH + #include "keylayouts.h" + { + ISO_8859_1_A0, ISO_8859_1_A1, ISO_8859_1_A2, ISO_8859_1_A3, + ISO_8859_1_A4, ISO_8859_1_A5, ISO_8859_1_A6, ISO_8859_1_A7, + ISO_8859_1_A8, ISO_8859_1_A9, ISO_8859_1_AA, ISO_8859_1_AB, + ISO_8859_1_AC, ISO_8859_1_AD, ISO_8859_1_AE, ISO_8859_1_AF, + ISO_8859_1_B0, ISO_8859_1_B1, ISO_8859_1_B2, ISO_8859_1_B3, + ISO_8859_1_B4, ISO_8859_1_B5, ISO_8859_1_B6, ISO_8859_1_B7, + ISO_8859_1_B8, ISO_8859_1_B9, ISO_8859_1_BA, ISO_8859_1_BB, + ISO_8859_1_BC, ISO_8859_1_BD, ISO_8859_1_BE, ISO_8859_1_BF, + ISO_8859_1_C0, ISO_8859_1_C1, ISO_8859_1_C2, ISO_8859_1_C3, + ISO_8859_1_C4, ISO_8859_1_C5, ISO_8859_1_C6, ISO_8859_1_C7, + ISO_8859_1_C8, ISO_8859_1_C9, ISO_8859_1_CA, ISO_8859_1_CB, + ISO_8859_1_CC, ISO_8859_1_CD, ISO_8859_1_CE, ISO_8859_1_CF, + ISO_8859_1_D0, ISO_8859_1_D1, ISO_8859_1_D2, ISO_8859_1_D3, + ISO_8859_1_D4, ISO_8859_1_D5, ISO_8859_1_D6, ISO_8859_1_D7, + ISO_8859_1_D8, ISO_8859_1_D9, ISO_8859_1_DA, ISO_8859_1_DB, + ISO_8859_1_DC, ISO_8859_1_DD, ISO_8859_1_DE, ISO_8859_1_DF, + ISO_8859_1_E0, ISO_8859_1_E1, ISO_8859_1_E2, ISO_8859_1_E3, + ISO_8859_1_E4, ISO_8859_1_E5, ISO_8859_1_E6, ISO_8859_1_E7, + ISO_8859_1_E8, ISO_8859_1_E9, ISO_8859_1_EA, ISO_8859_1_EB, + ISO_8859_1_EC, ISO_8859_1_ED, ISO_8859_1_EE, ISO_8859_1_EF, + ISO_8859_1_F0, ISO_8859_1_F1, ISO_8859_1_F2, ISO_8859_1_F3, + ISO_8859_1_F4, ISO_8859_1_F5, ISO_8859_1_F6, ISO_8859_1_F7, + ISO_8859_1_F8, ISO_8859_1_F9, ISO_8859_1_FA, ISO_8859_1_FB, + ISO_8859_1_FC, ISO_8859_1_FD, ISO_8859_1_FE, ISO_8859_1_FF + }, + #include "undefkeylayouts.h" + #define LAYOUT_SPANISH + #include "keylayouts.h" + { + ISO_8859_1_A0, ISO_8859_1_A1, ISO_8859_1_A2, ISO_8859_1_A3, + ISO_8859_1_A4, ISO_8859_1_A5, ISO_8859_1_A6, ISO_8859_1_A7, + ISO_8859_1_A8, ISO_8859_1_A9, ISO_8859_1_AA, ISO_8859_1_AB, + ISO_8859_1_AC, ISO_8859_1_AD, ISO_8859_1_AE, ISO_8859_1_AF, + ISO_8859_1_B0, ISO_8859_1_B1, ISO_8859_1_B2, ISO_8859_1_B3, + ISO_8859_1_B4, ISO_8859_1_B5, ISO_8859_1_B6, ISO_8859_1_B7, + ISO_8859_1_B8, ISO_8859_1_B9, ISO_8859_1_BA, ISO_8859_1_BB, + ISO_8859_1_BC, ISO_8859_1_BD, ISO_8859_1_BE, ISO_8859_1_BF, + ISO_8859_1_C0, ISO_8859_1_C1, ISO_8859_1_C2, ISO_8859_1_C3, + ISO_8859_1_C4, ISO_8859_1_C5, ISO_8859_1_C6, ISO_8859_1_C7, + ISO_8859_1_C8, ISO_8859_1_C9, ISO_8859_1_CA, ISO_8859_1_CB, + ISO_8859_1_CC, ISO_8859_1_CD, ISO_8859_1_CE, ISO_8859_1_CF, + ISO_8859_1_D0, ISO_8859_1_D1, ISO_8859_1_D2, ISO_8859_1_D3, + ISO_8859_1_D4, ISO_8859_1_D5, ISO_8859_1_D6, ISO_8859_1_D7, + ISO_8859_1_D8, ISO_8859_1_D9, ISO_8859_1_DA, ISO_8859_1_DB, + ISO_8859_1_DC, ISO_8859_1_DD, ISO_8859_1_DE, ISO_8859_1_DF, + ISO_8859_1_E0, ISO_8859_1_E1, ISO_8859_1_E2, ISO_8859_1_E3, + ISO_8859_1_E4, ISO_8859_1_E5, ISO_8859_1_E6, ISO_8859_1_E7, + ISO_8859_1_E8, ISO_8859_1_E9, ISO_8859_1_EA, ISO_8859_1_EB, + ISO_8859_1_EC, ISO_8859_1_ED, ISO_8859_1_EE, ISO_8859_1_EF, + ISO_8859_1_F0, ISO_8859_1_F1, ISO_8859_1_F2, ISO_8859_1_F3, + ISO_8859_1_F4, ISO_8859_1_F5, ISO_8859_1_F6, ISO_8859_1_F7, + ISO_8859_1_F8, ISO_8859_1_F9, ISO_8859_1_FA, ISO_8859_1_FB, + ISO_8859_1_FC, ISO_8859_1_FD, ISO_8859_1_FE, ISO_8859_1_FF + }, + #include "undefkeylayouts.h" + #define LAYOUT_PORTUGUESE + #include "keylayouts.h" + { + ISO_8859_1_A0, ISO_8859_1_A1, ISO_8859_1_A2, ISO_8859_1_A3, + ISO_8859_1_A4, ISO_8859_1_A5, ISO_8859_1_A6, ISO_8859_1_A7, + ISO_8859_1_A8, ISO_8859_1_A9, ISO_8859_1_AA, ISO_8859_1_AB, + ISO_8859_1_AC, ISO_8859_1_AD, ISO_8859_1_AE, ISO_8859_1_AF, + ISO_8859_1_B0, ISO_8859_1_B1, ISO_8859_1_B2, ISO_8859_1_B3, + ISO_8859_1_B4, ISO_8859_1_B5, ISO_8859_1_B6, ISO_8859_1_B7, + ISO_8859_1_B8, ISO_8859_1_B9, ISO_8859_1_BA, ISO_8859_1_BB, + ISO_8859_1_BC, ISO_8859_1_BD, ISO_8859_1_BE, ISO_8859_1_BF, + ISO_8859_1_C0, ISO_8859_1_C1, ISO_8859_1_C2, ISO_8859_1_C3, + ISO_8859_1_C4, ISO_8859_1_C5, ISO_8859_1_C6, ISO_8859_1_C7, + ISO_8859_1_C8, ISO_8859_1_C9, ISO_8859_1_CA, ISO_8859_1_CB, + ISO_8859_1_CC, ISO_8859_1_CD, ISO_8859_1_CE, ISO_8859_1_CF, + ISO_8859_1_D0, ISO_8859_1_D1, ISO_8859_1_D2, ISO_8859_1_D3, + ISO_8859_1_D4, ISO_8859_1_D5, ISO_8859_1_D6, ISO_8859_1_D7, + ISO_8859_1_D8, ISO_8859_1_D9, ISO_8859_1_DA, ISO_8859_1_DB, + ISO_8859_1_DC, ISO_8859_1_DD, ISO_8859_1_DE, ISO_8859_1_DF, + ISO_8859_1_E0, ISO_8859_1_E1, ISO_8859_1_E2, ISO_8859_1_E3, + ISO_8859_1_E4, ISO_8859_1_E5, ISO_8859_1_E6, ISO_8859_1_E7, + ISO_8859_1_E8, ISO_8859_1_E9, ISO_8859_1_EA, ISO_8859_1_EB, + ISO_8859_1_EC, ISO_8859_1_ED, ISO_8859_1_EE, ISO_8859_1_EF, + ISO_8859_1_F0, ISO_8859_1_F1, ISO_8859_1_F2, ISO_8859_1_F3, + ISO_8859_1_F4, ISO_8859_1_F5, ISO_8859_1_F6, ISO_8859_1_F7, + ISO_8859_1_F8, ISO_8859_1_F9, ISO_8859_1_FA, ISO_8859_1_FB, + ISO_8859_1_FC, ISO_8859_1_FD, ISO_8859_1_FE, ISO_8859_1_FF + }, + #include "undefkeylayouts.h" + #define LAYOUT_ITALIAN + #include "keylayouts.h" + { + ISO_8859_1_A0, ISO_8859_1_A1, ISO_8859_1_A2, ISO_8859_1_A3, + ISO_8859_1_A4, ISO_8859_1_A5, ISO_8859_1_A6, ISO_8859_1_A7, + ISO_8859_1_A8, ISO_8859_1_A9, ISO_8859_1_AA, ISO_8859_1_AB, + ISO_8859_1_AC, ISO_8859_1_AD, ISO_8859_1_AE, ISO_8859_1_AF, + ISO_8859_1_B0, ISO_8859_1_B1, ISO_8859_1_B2, ISO_8859_1_B3, + ISO_8859_1_B4, ISO_8859_1_B5, ISO_8859_1_B6, ISO_8859_1_B7, + ISO_8859_1_B8, ISO_8859_1_B9, ISO_8859_1_BA, ISO_8859_1_BB, + ISO_8859_1_BC, ISO_8859_1_BD, ISO_8859_1_BE, ISO_8859_1_BF, + ISO_8859_1_C0, ISO_8859_1_C1, ISO_8859_1_C2, ISO_8859_1_C3, + ISO_8859_1_C4, ISO_8859_1_C5, ISO_8859_1_C6, ISO_8859_1_C7, + ISO_8859_1_C8, ISO_8859_1_C9, ISO_8859_1_CA, ISO_8859_1_CB, + ISO_8859_1_CC, ISO_8859_1_CD, ISO_8859_1_CE, ISO_8859_1_CF, + ISO_8859_1_D0, ISO_8859_1_D1, ISO_8859_1_D2, ISO_8859_1_D3, + ISO_8859_1_D4, ISO_8859_1_D5, ISO_8859_1_D6, ISO_8859_1_D7, + ISO_8859_1_D8, ISO_8859_1_D9, ISO_8859_1_DA, ISO_8859_1_DB, + ISO_8859_1_DC, ISO_8859_1_DD, ISO_8859_1_DE, ISO_8859_1_DF, + ISO_8859_1_E0, ISO_8859_1_E1, ISO_8859_1_E2, ISO_8859_1_E3, + ISO_8859_1_E4, ISO_8859_1_E5, ISO_8859_1_E6, ISO_8859_1_E7, + ISO_8859_1_E8, ISO_8859_1_E9, ISO_8859_1_EA, ISO_8859_1_EB, + ISO_8859_1_EC, ISO_8859_1_ED, ISO_8859_1_EE, ISO_8859_1_EF, + ISO_8859_1_F0, ISO_8859_1_F1, ISO_8859_1_F2, ISO_8859_1_F3, + ISO_8859_1_F4, ISO_8859_1_F5, ISO_8859_1_F6, ISO_8859_1_F7, + ISO_8859_1_F8, ISO_8859_1_F9, ISO_8859_1_FA, ISO_8859_1_FB, + ISO_8859_1_FC, ISO_8859_1_FD, ISO_8859_1_FE, ISO_8859_1_FF + }, + #include "undefkeylayouts.h" + #define LAYOUT_PORTUGUESE_BRAZILIAN + #include "keylayouts.h" + { + ISO_8859_1_A0, ISO_8859_1_A1, ISO_8859_1_A2, ISO_8859_1_A3, + ISO_8859_1_A4, ISO_8859_1_A5, ISO_8859_1_A6, ISO_8859_1_A7, + ISO_8859_1_A8, ISO_8859_1_A9, ISO_8859_1_AA, ISO_8859_1_AB, + ISO_8859_1_AC, ISO_8859_1_AD, ISO_8859_1_AE, ISO_8859_1_AF, + ISO_8859_1_B0, ISO_8859_1_B1, ISO_8859_1_B2, ISO_8859_1_B3, + ISO_8859_1_B4, ISO_8859_1_B5, ISO_8859_1_B6, ISO_8859_1_B7, + ISO_8859_1_B8, ISO_8859_1_B9, ISO_8859_1_BA, ISO_8859_1_BB, + ISO_8859_1_BC, ISO_8859_1_BD, ISO_8859_1_BE, ISO_8859_1_BF, + ISO_8859_1_C0, ISO_8859_1_C1, ISO_8859_1_C2, ISO_8859_1_C3, + ISO_8859_1_C4, ISO_8859_1_C5, ISO_8859_1_C6, ISO_8859_1_C7, + ISO_8859_1_C8, ISO_8859_1_C9, ISO_8859_1_CA, ISO_8859_1_CB, + ISO_8859_1_CC, ISO_8859_1_CD, ISO_8859_1_CE, ISO_8859_1_CF, + ISO_8859_1_D0, ISO_8859_1_D1, ISO_8859_1_D2, ISO_8859_1_D3, + ISO_8859_1_D4, ISO_8859_1_D5, ISO_8859_1_D6, ISO_8859_1_D7, + ISO_8859_1_D8, ISO_8859_1_D9, ISO_8859_1_DA, ISO_8859_1_DB, + ISO_8859_1_DC, ISO_8859_1_DD, ISO_8859_1_DE, ISO_8859_1_DF, + ISO_8859_1_E0, ISO_8859_1_E1, ISO_8859_1_E2, ISO_8859_1_E3, + ISO_8859_1_E4, ISO_8859_1_E5, ISO_8859_1_E6, ISO_8859_1_E7, + ISO_8859_1_E8, ISO_8859_1_E9, ISO_8859_1_EA, ISO_8859_1_EB, + ISO_8859_1_EC, ISO_8859_1_ED, ISO_8859_1_EE, ISO_8859_1_EF, + ISO_8859_1_F0, ISO_8859_1_F1, ISO_8859_1_F2, ISO_8859_1_F3, + ISO_8859_1_F4, ISO_8859_1_F5, ISO_8859_1_F6, ISO_8859_1_F7, + ISO_8859_1_F8, ISO_8859_1_F9, ISO_8859_1_FA, ISO_8859_1_FB, + ISO_8859_1_FC, ISO_8859_1_FD, ISO_8859_1_FE, ISO_8859_1_FF + }, + #include "undefkeylayouts.h" + #define LAYOUT_FRENCH_BELGIAN + #include "keylayouts.h" + { + ISO_8859_1_A0, ISO_8859_1_A1, ISO_8859_1_A2, ISO_8859_1_A3, + ISO_8859_1_A4, ISO_8859_1_A5, ISO_8859_1_A6, ISO_8859_1_A7, + ISO_8859_1_A8, ISO_8859_1_A9, ISO_8859_1_AA, ISO_8859_1_AB, + ISO_8859_1_AC, ISO_8859_1_AD, ISO_8859_1_AE, ISO_8859_1_AF, + ISO_8859_1_B0, ISO_8859_1_B1, ISO_8859_1_B2, ISO_8859_1_B3, + ISO_8859_1_B4, ISO_8859_1_B5, ISO_8859_1_B6, ISO_8859_1_B7, + ISO_8859_1_B8, ISO_8859_1_B9, ISO_8859_1_BA, ISO_8859_1_BB, + ISO_8859_1_BC, ISO_8859_1_BD, ISO_8859_1_BE, ISO_8859_1_BF, + ISO_8859_1_C0, ISO_8859_1_C1, ISO_8859_1_C2, ISO_8859_1_C3, + ISO_8859_1_C4, ISO_8859_1_C5, ISO_8859_1_C6, ISO_8859_1_C7, + ISO_8859_1_C8, ISO_8859_1_C9, ISO_8859_1_CA, ISO_8859_1_CB, + ISO_8859_1_CC, ISO_8859_1_CD, ISO_8859_1_CE, ISO_8859_1_CF, + ISO_8859_1_D0, ISO_8859_1_D1, ISO_8859_1_D2, ISO_8859_1_D3, + ISO_8859_1_D4, ISO_8859_1_D5, ISO_8859_1_D6, ISO_8859_1_D7, + ISO_8859_1_D8, ISO_8859_1_D9, ISO_8859_1_DA, ISO_8859_1_DB, + ISO_8859_1_DC, ISO_8859_1_DD, ISO_8859_1_DE, ISO_8859_1_DF, + ISO_8859_1_E0, ISO_8859_1_E1, ISO_8859_1_E2, ISO_8859_1_E3, + ISO_8859_1_E4, ISO_8859_1_E5, ISO_8859_1_E6, ISO_8859_1_E7, + ISO_8859_1_E8, ISO_8859_1_E9, ISO_8859_1_EA, ISO_8859_1_EB, + ISO_8859_1_EC, ISO_8859_1_ED, ISO_8859_1_EE, ISO_8859_1_EF, + ISO_8859_1_F0, ISO_8859_1_F1, ISO_8859_1_F2, ISO_8859_1_F3, + ISO_8859_1_F4, ISO_8859_1_F5, ISO_8859_1_F6, ISO_8859_1_F7, + ISO_8859_1_F8, ISO_8859_1_F9, ISO_8859_1_FA, ISO_8859_1_FB, + ISO_8859_1_FC, ISO_8859_1_FD, ISO_8859_1_FE, ISO_8859_1_FF + }, + #include "undefkeylayouts.h" + #define LAYOUT_GERMAN_SWISS + #include "keylayouts.h" + { + ISO_8859_1_A0, ISO_8859_1_A1, ISO_8859_1_A2, ISO_8859_1_A3, + ISO_8859_1_A4, ISO_8859_1_A5, ISO_8859_1_A6, ISO_8859_1_A7, + ISO_8859_1_A8, ISO_8859_1_A9, ISO_8859_1_AA, ISO_8859_1_AB, + ISO_8859_1_AC, ISO_8859_1_AD, ISO_8859_1_AE, ISO_8859_1_AF, + ISO_8859_1_B0, ISO_8859_1_B1, ISO_8859_1_B2, ISO_8859_1_B3, + ISO_8859_1_B4, ISO_8859_1_B5, ISO_8859_1_B6, ISO_8859_1_B7, + ISO_8859_1_B8, ISO_8859_1_B9, ISO_8859_1_BA, ISO_8859_1_BB, + ISO_8859_1_BC, ISO_8859_1_BD, ISO_8859_1_BE, ISO_8859_1_BF, + ISO_8859_1_C0, ISO_8859_1_C1, ISO_8859_1_C2, ISO_8859_1_C3, + ISO_8859_1_C4, ISO_8859_1_C5, ISO_8859_1_C6, ISO_8859_1_C7, + ISO_8859_1_C8, ISO_8859_1_C9, ISO_8859_1_CA, ISO_8859_1_CB, + ISO_8859_1_CC, ISO_8859_1_CD, ISO_8859_1_CE, ISO_8859_1_CF, + ISO_8859_1_D0, ISO_8859_1_D1, ISO_8859_1_D2, ISO_8859_1_D3, + ISO_8859_1_D4, ISO_8859_1_D5, ISO_8859_1_D6, ISO_8859_1_D7, + ISO_8859_1_D8, ISO_8859_1_D9, ISO_8859_1_DA, ISO_8859_1_DB, + ISO_8859_1_DC, ISO_8859_1_DD, ISO_8859_1_DE, ISO_8859_1_DF, + ISO_8859_1_E0, ISO_8859_1_E1, ISO_8859_1_E2, ISO_8859_1_E3, + ISO_8859_1_E4, ISO_8859_1_E5, ISO_8859_1_E6, ISO_8859_1_E7, + ISO_8859_1_E8, ISO_8859_1_E9, ISO_8859_1_EA, ISO_8859_1_EB, + ISO_8859_1_EC, ISO_8859_1_ED, ISO_8859_1_EE, ISO_8859_1_EF, + ISO_8859_1_F0, ISO_8859_1_F1, ISO_8859_1_F2, ISO_8859_1_F3, + ISO_8859_1_F4, ISO_8859_1_F5, ISO_8859_1_F6, ISO_8859_1_F7, + ISO_8859_1_F8, ISO_8859_1_F9, ISO_8859_1_FA, ISO_8859_1_FB, + ISO_8859_1_FC, ISO_8859_1_FD, ISO_8859_1_FE, ISO_8859_1_FF + }, + #include "undefkeylayouts.h" + #define LAYOUT_FRENCH_SWISS + #include "keylayouts.h" + { + ISO_8859_1_A0, ISO_8859_1_A1, ISO_8859_1_A2, ISO_8859_1_A3, + ISO_8859_1_A4, ISO_8859_1_A5, ISO_8859_1_A6, ISO_8859_1_A7, + ISO_8859_1_A8, ISO_8859_1_A9, ISO_8859_1_AA, ISO_8859_1_AB, + ISO_8859_1_AC, ISO_8859_1_AD, ISO_8859_1_AE, ISO_8859_1_AF, + ISO_8859_1_B0, ISO_8859_1_B1, ISO_8859_1_B2, ISO_8859_1_B3, + ISO_8859_1_B4, ISO_8859_1_B5, ISO_8859_1_B6, ISO_8859_1_B7, + ISO_8859_1_B8, ISO_8859_1_B9, ISO_8859_1_BA, ISO_8859_1_BB, + ISO_8859_1_BC, ISO_8859_1_BD, ISO_8859_1_BE, ISO_8859_1_BF, + ISO_8859_1_C0, ISO_8859_1_C1, ISO_8859_1_C2, ISO_8859_1_C3, + ISO_8859_1_C4, ISO_8859_1_C5, ISO_8859_1_C6, ISO_8859_1_C7, + ISO_8859_1_C8, ISO_8859_1_C9, ISO_8859_1_CA, ISO_8859_1_CB, + ISO_8859_1_CC, ISO_8859_1_CD, ISO_8859_1_CE, ISO_8859_1_CF, + ISO_8859_1_D0, ISO_8859_1_D1, ISO_8859_1_D2, ISO_8859_1_D3, + ISO_8859_1_D4, ISO_8859_1_D5, ISO_8859_1_D6, ISO_8859_1_D7, + ISO_8859_1_D8, ISO_8859_1_D9, ISO_8859_1_DA, ISO_8859_1_DB, + ISO_8859_1_DC, ISO_8859_1_DD, ISO_8859_1_DE, ISO_8859_1_DF, + ISO_8859_1_E0, ISO_8859_1_E1, ISO_8859_1_E2, ISO_8859_1_E3, + ISO_8859_1_E4, ISO_8859_1_E5, ISO_8859_1_E6, ISO_8859_1_E7, + ISO_8859_1_E8, ISO_8859_1_E9, ISO_8859_1_EA, ISO_8859_1_EB, + ISO_8859_1_EC, ISO_8859_1_ED, ISO_8859_1_EE, ISO_8859_1_EF, + ISO_8859_1_F0, ISO_8859_1_F1, ISO_8859_1_F2, ISO_8859_1_F3, + ISO_8859_1_F4, ISO_8859_1_F5, ISO_8859_1_F6, ISO_8859_1_F7, + ISO_8859_1_F8, ISO_8859_1_F9, ISO_8859_1_FA, ISO_8859_1_FB, + ISO_8859_1_FC, ISO_8859_1_FD, ISO_8859_1_FE, ISO_8859_1_FF + }, + #include "undefkeylayouts.h" + #define LAYOUT_SPANISH_LATIN_AMERICA + #include "keylayouts.h" + { + ISO_8859_1_A0, ISO_8859_1_A1, ISO_8859_1_A2, ISO_8859_1_A3, + ISO_8859_1_A4, ISO_8859_1_A5, ISO_8859_1_A6, ISO_8859_1_A7, + ISO_8859_1_A8, ISO_8859_1_A9, ISO_8859_1_AA, ISO_8859_1_AB, + ISO_8859_1_AC, ISO_8859_1_AD, ISO_8859_1_AE, ISO_8859_1_AF, + ISO_8859_1_B0, ISO_8859_1_B1, ISO_8859_1_B2, ISO_8859_1_B3, + ISO_8859_1_B4, ISO_8859_1_B5, ISO_8859_1_B6, ISO_8859_1_B7, + ISO_8859_1_B8, ISO_8859_1_B9, ISO_8859_1_BA, ISO_8859_1_BB, + ISO_8859_1_BC, ISO_8859_1_BD, ISO_8859_1_BE, ISO_8859_1_BF, + ISO_8859_1_C0, ISO_8859_1_C1, ISO_8859_1_C2, ISO_8859_1_C3, + ISO_8859_1_C4, ISO_8859_1_C5, ISO_8859_1_C6, ISO_8859_1_C7, + ISO_8859_1_C8, ISO_8859_1_C9, ISO_8859_1_CA, ISO_8859_1_CB, + ISO_8859_1_CC, ISO_8859_1_CD, ISO_8859_1_CE, ISO_8859_1_CF, + ISO_8859_1_D0, ISO_8859_1_D1, ISO_8859_1_D2, ISO_8859_1_D3, + ISO_8859_1_D4, ISO_8859_1_D5, ISO_8859_1_D6, ISO_8859_1_D7, + ISO_8859_1_D8, ISO_8859_1_D9, ISO_8859_1_DA, ISO_8859_1_DB, + ISO_8859_1_DC, ISO_8859_1_DD, ISO_8859_1_DE, ISO_8859_1_DF, + ISO_8859_1_E0, ISO_8859_1_E1, ISO_8859_1_E2, ISO_8859_1_E3, + ISO_8859_1_E4, ISO_8859_1_E5, ISO_8859_1_E6, ISO_8859_1_E7, + ISO_8859_1_E8, ISO_8859_1_E9, ISO_8859_1_EA, ISO_8859_1_EB, + ISO_8859_1_EC, ISO_8859_1_ED, ISO_8859_1_EE, ISO_8859_1_EF, + ISO_8859_1_F0, ISO_8859_1_F1, ISO_8859_1_F2, ISO_8859_1_F3, + ISO_8859_1_F4, ISO_8859_1_F5, ISO_8859_1_F6, ISO_8859_1_F7, + ISO_8859_1_F8, ISO_8859_1_F9, ISO_8859_1_FA, ISO_8859_1_FB, + ISO_8859_1_FC, ISO_8859_1_FD, ISO_8859_1_FE, ISO_8859_1_FF + }, + #include "undefkeylayouts.h" + #define LAYOUT_IRISH + #include "keylayouts.h" + { + ISO_8859_1_A0, ISO_8859_1_A1, ISO_8859_1_A2, ISO_8859_1_A3, + ISO_8859_1_A4, ISO_8859_1_A5, ISO_8859_1_A6, ISO_8859_1_A7, + ISO_8859_1_A8, ISO_8859_1_A9, ISO_8859_1_AA, ISO_8859_1_AB, + ISO_8859_1_AC, ISO_8859_1_AD, ISO_8859_1_AE, ISO_8859_1_AF, + ISO_8859_1_B0, ISO_8859_1_B1, ISO_8859_1_B2, ISO_8859_1_B3, + ISO_8859_1_B4, ISO_8859_1_B5, ISO_8859_1_B6, ISO_8859_1_B7, + ISO_8859_1_B8, ISO_8859_1_B9, ISO_8859_1_BA, ISO_8859_1_BB, + ISO_8859_1_BC, ISO_8859_1_BD, ISO_8859_1_BE, ISO_8859_1_BF, + ISO_8859_1_C0, ISO_8859_1_C1, ISO_8859_1_C2, ISO_8859_1_C3, + ISO_8859_1_C4, ISO_8859_1_C5, ISO_8859_1_C6, ISO_8859_1_C7, + ISO_8859_1_C8, ISO_8859_1_C9, ISO_8859_1_CA, ISO_8859_1_CB, + ISO_8859_1_CC, ISO_8859_1_CD, ISO_8859_1_CE, ISO_8859_1_CF, + ISO_8859_1_D0, ISO_8859_1_D1, ISO_8859_1_D2, ISO_8859_1_D3, + ISO_8859_1_D4, ISO_8859_1_D5, ISO_8859_1_D6, ISO_8859_1_D7, + ISO_8859_1_D8, ISO_8859_1_D9, ISO_8859_1_DA, ISO_8859_1_DB, + ISO_8859_1_DC, ISO_8859_1_DD, ISO_8859_1_DE, ISO_8859_1_DF, + ISO_8859_1_E0, ISO_8859_1_E1, ISO_8859_1_E2, ISO_8859_1_E3, + ISO_8859_1_E4, ISO_8859_1_E5, ISO_8859_1_E6, ISO_8859_1_E7, + ISO_8859_1_E8, ISO_8859_1_E9, ISO_8859_1_EA, ISO_8859_1_EB, + ISO_8859_1_EC, ISO_8859_1_ED, ISO_8859_1_EE, ISO_8859_1_EF, + ISO_8859_1_F0, ISO_8859_1_F1, ISO_8859_1_F2, ISO_8859_1_F3, + ISO_8859_1_F4, ISO_8859_1_F5, ISO_8859_1_F6, ISO_8859_1_F7, + ISO_8859_1_F8, ISO_8859_1_F9, ISO_8859_1_FA, ISO_8859_1_FB, + ISO_8859_1_FC, ISO_8859_1_FD, ISO_8859_1_FE, ISO_8859_1_FF + }, + #include "undefkeylayouts.h" + #define LAYOUT_ICELANDIC + #include "keylayouts.h" + { + ISO_8859_1_A0, ISO_8859_1_A1, ISO_8859_1_A2, ISO_8859_1_A3, + ISO_8859_1_A4, ISO_8859_1_A5, ISO_8859_1_A6, ISO_8859_1_A7, + ISO_8859_1_A8, ISO_8859_1_A9, ISO_8859_1_AA, ISO_8859_1_AB, + ISO_8859_1_AC, ISO_8859_1_AD, ISO_8859_1_AE, ISO_8859_1_AF, + ISO_8859_1_B0, ISO_8859_1_B1, ISO_8859_1_B2, ISO_8859_1_B3, + ISO_8859_1_B4, ISO_8859_1_B5, ISO_8859_1_B6, ISO_8859_1_B7, + ISO_8859_1_B8, ISO_8859_1_B9, ISO_8859_1_BA, ISO_8859_1_BB, + ISO_8859_1_BC, ISO_8859_1_BD, ISO_8859_1_BE, ISO_8859_1_BF, + ISO_8859_1_C0, ISO_8859_1_C1, ISO_8859_1_C2, ISO_8859_1_C3, + ISO_8859_1_C4, ISO_8859_1_C5, ISO_8859_1_C6, ISO_8859_1_C7, + ISO_8859_1_C8, ISO_8859_1_C9, ISO_8859_1_CA, ISO_8859_1_CB, + ISO_8859_1_CC, ISO_8859_1_CD, ISO_8859_1_CE, ISO_8859_1_CF, + ISO_8859_1_D0, ISO_8859_1_D1, ISO_8859_1_D2, ISO_8859_1_D3, + ISO_8859_1_D4, ISO_8859_1_D5, ISO_8859_1_D6, ISO_8859_1_D7, + ISO_8859_1_D8, ISO_8859_1_D9, ISO_8859_1_DA, ISO_8859_1_DB, + ISO_8859_1_DC, ISO_8859_1_DD, ISO_8859_1_DE, ISO_8859_1_DF, + ISO_8859_1_E0, ISO_8859_1_E1, ISO_8859_1_E2, ISO_8859_1_E3, + ISO_8859_1_E4, ISO_8859_1_E5, ISO_8859_1_E6, ISO_8859_1_E7, + ISO_8859_1_E8, ISO_8859_1_E9, ISO_8859_1_EA, ISO_8859_1_EB, + ISO_8859_1_EC, ISO_8859_1_ED, ISO_8859_1_EE, ISO_8859_1_EF, + ISO_8859_1_F0, ISO_8859_1_F1, ISO_8859_1_F2, ISO_8859_1_F3, + ISO_8859_1_F4, ISO_8859_1_F5, ISO_8859_1_F6, ISO_8859_1_F7, + ISO_8859_1_F8, ISO_8859_1_F9, ISO_8859_1_FA, ISO_8859_1_FB, + ISO_8859_1_FC, ISO_8859_1_FD, ISO_8859_1_FE, ISO_8859_1_FF + }, + #include "undefkeylayouts.h" + #define LAYOUT_TURKISH + #include "keylayouts.h" + { + ISO_8859_1_A0, ISO_8859_1_A1, ISO_8859_1_A2, ISO_8859_1_A3, + ISO_8859_1_A4, ISO_8859_1_A5, ISO_8859_1_A6, ISO_8859_1_A7, + ISO_8859_1_A8, ISO_8859_1_A9, ISO_8859_1_AA, ISO_8859_1_AB, + ISO_8859_1_AC, ISO_8859_1_AD, ISO_8859_1_AE, ISO_8859_1_AF, + ISO_8859_1_B0, ISO_8859_1_B1, ISO_8859_1_B2, ISO_8859_1_B3, + ISO_8859_1_B4, ISO_8859_1_B5, ISO_8859_1_B6, ISO_8859_1_B7, + ISO_8859_1_B8, ISO_8859_1_B9, ISO_8859_1_BA, ISO_8859_1_BB, + ISO_8859_1_BC, ISO_8859_1_BD, ISO_8859_1_BE, ISO_8859_1_BF, + ISO_8859_1_C0, ISO_8859_1_C1, ISO_8859_1_C2, ISO_8859_1_C3, + ISO_8859_1_C4, ISO_8859_1_C5, ISO_8859_1_C6, ISO_8859_1_C7, + ISO_8859_1_C8, ISO_8859_1_C9, ISO_8859_1_CA, ISO_8859_1_CB, + ISO_8859_1_CC, ISO_8859_1_CD, ISO_8859_1_CE, ISO_8859_1_CF, + ISO_8859_1_D0, ISO_8859_1_D1, ISO_8859_1_D2, ISO_8859_1_D3, + ISO_8859_1_D4, ISO_8859_1_D5, ISO_8859_1_D6, ISO_8859_1_D7, + ISO_8859_1_D8, ISO_8859_1_D9, ISO_8859_1_DA, ISO_8859_1_DB, + ISO_8859_1_DC, ISO_8859_1_DD, ISO_8859_1_DE, ISO_8859_1_DF, + ISO_8859_1_E0, ISO_8859_1_E1, ISO_8859_1_E2, ISO_8859_1_E3, + ISO_8859_1_E4, ISO_8859_1_E5, ISO_8859_1_E6, ISO_8859_1_E7, + ISO_8859_1_E8, ISO_8859_1_E9, ISO_8859_1_EA, ISO_8859_1_EB, + ISO_8859_1_EC, ISO_8859_1_ED, ISO_8859_1_EE, ISO_8859_1_EF, + ISO_8859_1_F0, ISO_8859_1_F1, ISO_8859_1_F2, ISO_8859_1_F3, + ISO_8859_1_F4, ISO_8859_1_F5, ISO_8859_1_F6, ISO_8859_1_F7, + ISO_8859_1_F8, ISO_8859_1_F9, ISO_8859_1_FA, ISO_8859_1_FB, + ISO_8859_1_FC, ISO_8859_1_FD, ISO_8859_1_FE, ISO_8859_1_FF + }, + #include "undefkeylayouts.h" + #define LAYOUT_CZECH + #include "keylayouts.h" + { + ISO_8859_1_A0, ISO_8859_1_A1, ISO_8859_1_A2, ISO_8859_1_A3, + ISO_8859_1_A4, ISO_8859_1_A5, ISO_8859_1_A6, ISO_8859_1_A7, + ISO_8859_1_A8, ISO_8859_1_A9, ISO_8859_1_AA, ISO_8859_1_AB, + ISO_8859_1_AC, ISO_8859_1_AD, ISO_8859_1_AE, ISO_8859_1_AF, + ISO_8859_1_B0, ISO_8859_1_B1, ISO_8859_1_B2, ISO_8859_1_B3, + ISO_8859_1_B4, ISO_8859_1_B5, ISO_8859_1_B6, ISO_8859_1_B7, + ISO_8859_1_B8, ISO_8859_1_B9, ISO_8859_1_BA, ISO_8859_1_BB, + ISO_8859_1_BC, ISO_8859_1_BD, ISO_8859_1_BE, ISO_8859_1_BF, + ISO_8859_1_C0, ISO_8859_1_C1, ISO_8859_1_C2, ISO_8859_1_C3, + ISO_8859_1_C4, ISO_8859_1_C5, ISO_8859_1_C6, ISO_8859_1_C7, + ISO_8859_1_C8, ISO_8859_1_C9, ISO_8859_1_CA, ISO_8859_1_CB, + ISO_8859_1_CC, ISO_8859_1_CD, ISO_8859_1_CE, ISO_8859_1_CF, + ISO_8859_1_D0, ISO_8859_1_D1, ISO_8859_1_D2, ISO_8859_1_D3, + ISO_8859_1_D4, ISO_8859_1_D5, ISO_8859_1_D6, ISO_8859_1_D7, + ISO_8859_1_D8, ISO_8859_1_D9, ISO_8859_1_DA, ISO_8859_1_DB, + ISO_8859_1_DC, ISO_8859_1_DD, ISO_8859_1_DE, ISO_8859_1_DF, + ISO_8859_1_E0, ISO_8859_1_E1, ISO_8859_1_E2, ISO_8859_1_E3, + ISO_8859_1_E4, ISO_8859_1_E5, ISO_8859_1_E6, ISO_8859_1_E7, + ISO_8859_1_E8, ISO_8859_1_E9, ISO_8859_1_EA, ISO_8859_1_EB, + ISO_8859_1_EC, ISO_8859_1_ED, ISO_8859_1_EE, ISO_8859_1_EF, + ISO_8859_1_F0, ISO_8859_1_F1, ISO_8859_1_F2, ISO_8859_1_F3, + ISO_8859_1_F4, ISO_8859_1_F5, ISO_8859_1_F6, ISO_8859_1_F7, + ISO_8859_1_F8, ISO_8859_1_F9, ISO_8859_1_FA, ISO_8859_1_FB, + ISO_8859_1_FC, ISO_8859_1_FD, ISO_8859_1_FE, ISO_8859_1_FF + }, + #include "undefkeylayouts.h" + #define LAYOUT_SERBIAN_LATIN_ONLY + #include "keylayouts.h" + { + ISO_8859_1_A0, ISO_8859_1_A1, ISO_8859_1_A2, ISO_8859_1_A3, + ISO_8859_1_A4, ISO_8859_1_A5, ISO_8859_1_A6, ISO_8859_1_A7, + ISO_8859_1_A8, ISO_8859_1_A9, ISO_8859_1_AA, ISO_8859_1_AB, + ISO_8859_1_AC, ISO_8859_1_AD, ISO_8859_1_AE, ISO_8859_1_AF, + ISO_8859_1_B0, ISO_8859_1_B1, ISO_8859_1_B2, ISO_8859_1_B3, + ISO_8859_1_B4, ISO_8859_1_B5, ISO_8859_1_B6, ISO_8859_1_B7, + ISO_8859_1_B8, ISO_8859_1_B9, ISO_8859_1_BA, ISO_8859_1_BB, + ISO_8859_1_BC, ISO_8859_1_BD, ISO_8859_1_BE, ISO_8859_1_BF, + ISO_8859_1_C0, ISO_8859_1_C1, ISO_8859_1_C2, ISO_8859_1_C3, + ISO_8859_1_C4, ISO_8859_1_C5, ISO_8859_1_C6, ISO_8859_1_C7, + ISO_8859_1_C8, ISO_8859_1_C9, ISO_8859_1_CA, ISO_8859_1_CB, + ISO_8859_1_CC, ISO_8859_1_CD, ISO_8859_1_CE, ISO_8859_1_CF, + ISO_8859_1_D0, ISO_8859_1_D1, ISO_8859_1_D2, ISO_8859_1_D3, + ISO_8859_1_D4, ISO_8859_1_D5, ISO_8859_1_D6, ISO_8859_1_D7, + ISO_8859_1_D8, ISO_8859_1_D9, ISO_8859_1_DA, ISO_8859_1_DB, + ISO_8859_1_DC, ISO_8859_1_DD, ISO_8859_1_DE, ISO_8859_1_DF, + ISO_8859_1_E0, ISO_8859_1_E1, ISO_8859_1_E2, ISO_8859_1_E3, + ISO_8859_1_E4, ISO_8859_1_E5, ISO_8859_1_E6, ISO_8859_1_E7, + ISO_8859_1_E8, ISO_8859_1_E9, ISO_8859_1_EA, ISO_8859_1_EB, + ISO_8859_1_EC, ISO_8859_1_ED, ISO_8859_1_EE, ISO_8859_1_EF, + ISO_8859_1_F0, ISO_8859_1_F1, ISO_8859_1_F2, ISO_8859_1_F3, + ISO_8859_1_F4, ISO_8859_1_F5, ISO_8859_1_F6, ISO_8859_1_F7, + ISO_8859_1_F8, ISO_8859_1_F9, ISO_8859_1_FA, ISO_8859_1_FB, + ISO_8859_1_FC, ISO_8859_1_FD, ISO_8859_1_FE, ISO_8859_1_FF + } +}; + +uint16_t unicode_to_keycode(uint16_t cpoint, uint8_t locale) +{ + // Unicode code points beyond U+FFFF are not supported + // technically this input should probably be called UCS-2 + if (cpoint < 32) { + if (cpoint == 10) + { + ESP_LOGI(TAG,"cpoint %d, locale %d, mask %d, key %d",cpoint,locale,keycodes_masks[locale][3],KEY_ENTER); + return KEY_ENTER & keycodes_masks[locale][3]; + } + if (cpoint == 11) + { + ESP_LOGI(TAG,"cpoint %d, locale %d, mask %d, key %d",cpoint,locale,keycodes_masks[locale][3],KEY_TAB); + return KEY_TAB & keycodes_masks[locale][3]; + } + return 0; + } + if (cpoint < 128) + { + ESP_LOGI(TAG,"ASCII lookup"); + ESP_LOGI(TAG,"cpoint %d, locale %d, mask --, key %d",cpoint,locale,keycodes_ascii[locale][cpoint - 0x20]); + return keycodes_ascii[locale][cpoint - 0x20]; + } + if (cpoint <= 0xA0) + { + ESP_LOGE(TAG,"unkown cpoint"); + return 0; + } + if (cpoint < 0x100) + { + if(locale == LAYOUT_US_ENGLISH) + { + ESP_LOGE(TAG,"locale is LAYOUT_US_ENGLISH, no unicode available"); + return 0; + } else { + ESP_LOGI(TAG,"cpoint %d, locale %d, mask --, key %d",cpoint,locale,keycodes_iso_8859_1[locale-1][cpoint-0xA0]); + return keycodes_iso_8859_1[locale-1][cpoint-0xA0]; + } + } + //TODO: do UNICODE_EXTRA characters here.... + ESP_LOGE(TAG,"nothing applies in unicode_to_keycode"); + return 0; +} + +uint16_t deadkey_to_keycode(uint16_t keycode, uint8_t locale) +{ + keycode &= keycodes_masks[locale][2]; + if (keycode == 0) return 0; + ESP_LOGI(TAG,"deadkeys: applying mask 0x%X, result: %d", keycodes_masks[locale][2], keycode); + for(uint8_t i = 0; i= LAYOUT_MAX) return 0; + + if (inputdata < 0x80) { + // single byte encoded, 0x00 to 0x7F + utf8_state = 0; + keycode = unicode_to_keycode(inputdata, locale); + deadkey = deadkey_to_keycode(keycode,locale); + *keycode_modifier = keycode_to_modifier(keycode,locale); + if(deadkey) *deadkey_first_keycode = keycode_to_key(deadkey); + else *deadkey_first_keycode = 0; + return keycode_to_key(keycode & keycodes_masks[locale][3]); + } else if (inputdata < 0xC0) { + // 2nd, 3rd or 4th byte, 0x80 to 0xBF + inputdata &= 0x3F; + if (utf8_state == 1) { + utf8_state = 0; + keycode = unicode_to_keycode(unicode_wchar | inputdata, locale); + deadkey = deadkey_to_keycode(keycode,locale); + *keycode_modifier = keycode_to_modifier(keycode,locale); + if(deadkey) *deadkey_first_keycode = keycode_to_key(deadkey); + else *deadkey_first_keycode = 0; + return keycode_to_key(keycode & keycodes_masks[locale][3]); + } else if (utf8_state == 2) { + unicode_wchar |= ((uint16_t)inputdata << 6); + utf8_state = 1; + } + } else if (inputdata < 0xE0) { + // begin 2 byte sequence, 0xC2 to 0xDF + // or illegal 2 byte sequence, 0xC0 to 0xC1 + unicode_wchar = (uint16_t)(inputdata & 0x1F) << 6; + utf8_state = 1; + } else if (inputdata < 0xF0) { + // begin 3 byte sequence, 0xE0 to 0xEF + unicode_wchar = (uint16_t)(inputdata & 0x0F) << 12; + utf8_state = 2; + } else { + // begin 4 byte sequence (not supported), 0xF0 to 0xF4 + // or illegal, 0xF5 to 0xFF + utf8_state = 255; + } + return 0; +} + +/** remove a keycode from the given HID keycode array. + * + * @note The size of the keycode_arr parameter MUST be 6 + * @return 0 if the keycode was removed, 1 if the keycode was not in the array + * */ +uint8_t remove_keycode(uint8_t keycode,uint8_t *keycode_arr) +{ + uint8_t ret = 1; + if(keycode == 0) return 1; + //source: Arduino core Keyboard.cpp + for (uint8_t i=0; i<6; i++) { + if (keycode_arr[i] == keycode) + { + keycode_arr[i] = 0; + ret = 0; + } + } + return ret; +} + +/** add a keycode to the given HID keycode array. + * + * @note The size of the keycode_arr parameter MUST be 6 + * @return 0 if the keycode was added, 1 if the keycode was already in the array and 2 if there was no space + * */ +uint8_t add_keycode(uint8_t keycode,uint8_t *keycode_arr) +{ + uint8_t i; + //source: Arduino core Keyboard.cpp + // Add k to the key array only if it's not already present + // and if there is an empty slot. + if (keycode_arr[0] != keycode && keycode_arr[1] != keycode && + keycode_arr[2] != keycode && keycode_arr[3] != keycode && + keycode_arr[4] != keycode && keycode_arr[5] != keycode) { + + for (i=0; i<6; i++) { + if (keycode_arr[i] == 0x00) { + keycode_arr[i] = keycode; + return 0; + } + } + if (i == 6) { + return 2; + } + } + return 1; +} + + +/** get a keycode for the given UTF codepoint + * + * This method parses a 16bit unicode character to a keycode. + * If a modifier is needed the given modifier byte is updated. + * + * @see keyboard_layouts + * @return 0 if no keycode is found; the keycode otherwise + * */ +uint8_t get_keycode(uint16_t cpoint,uint8_t locale,uint8_t *keycode_modifier, uint8_t *deadkey_first_keystroke) +{ + uint8_t part = cpoint & 0x00FF; + uint8_t keycode = 0; + keycode = parse_for_keycode(part,locale,keycode_modifier,deadkey_first_keystroke); + //if the first part is evaluated as zero, try again with high byte + if(keycode == 0) + { + part = (cpoint & 0xFF00) >> 8; + keycode = parse_for_keycode(part,locale,keycode_modifier,deadkey_first_keystroke); + } + return keycode; +} + + +/** getting the HID country code for a given locale + * + * Source: USB Device class definition for HID, page 33 + * + * @see keyboard_layouts + * @return bCountryCode value for HID info + * @param locale Locale number, as defined in keyboard_layouts + **/ +uint8_t get_hid_country_code(uint8_t locale) +{ + switch(locale) + { + case LAYOUT_US_ENGLISH: + case LAYOUT_US_INTERNATIONAL: + return 33; + + case LAYOUT_GERMAN: + case LAYOUT_GERMAN_MAC: + return 9; + + case LAYOUT_PORTUGUESE_BRAZILIAN: + case LAYOUT_PORTUGUESE: + return 22; + + case LAYOUT_FRENCH_BELGIAN: + case LAYOUT_FRENCH: + return 8; + + case LAYOUT_SPANISH_LATIN_AMERICA: /*same code for Latin America?*/ + case LAYOUT_SPANISH: + return 25; + + case LAYOUT_CANADIAN_FRENCH: return 04; + case LAYOUT_CANADIAN_MULTILINGUAL: return 03; + case LAYOUT_UNITED_KINGDOM: return 32; + case LAYOUT_FINNISH: return 07; + case LAYOUT_FRENCH_SWISS: return 27; + case LAYOUT_DANISH: return 06; + case LAYOUT_NORWEGIAN: return 19; + case LAYOUT_SWEDISH: return 26; + case LAYOUT_ITALIAN: return 14; + case LAYOUT_GERMAN_SWISS: return 28; + case LAYOUT_TURKISH: return 31; + case LAYOUT_CZECH: return 5; + //case LAYOUT_SERBIAN_LATIN_ONLY: + // return 34; /*HID code for Yugoslavia?!?*/ + + //now returning International, OK? + //no defined country codes available + case LAYOUT_IRISH: + case LAYOUT_ICELANDIC: + return 13; + + default: + ESP_LOGE(TAG,"no hid country code found for locale %d",locale); + return 0; + } +} + + + diff --git a/main/keyboard.h b/main/keyboard.h new file mode 100644 index 0000000..7e92914 --- /dev/null +++ b/main/keyboard.h @@ -0,0 +1,118 @@ +/* + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, + * MA 02110-1301, USA. + * + * Copyright 2017 Benjamin Aigner + * + * Heavily based on Paul Stoffregens usb_api.cpp from Teensyduino + * http://www.pjrc.com/teensy/teensyduino.html + * Copyright (c) 2008 PJRC.COM, LLC + * THANK YOU VERY MUCH FOR THIS EFFORT ON KEYBOARD + LAYOUTS! + * + */ + +#ifndef _KEYBOARD_H_ +#define _KEYBOARD_H_ + +#include +#include +#include + +enum keyboard_layouts{ + LAYOUT_US_ENGLISH, + LAYOUT_US_INTERNATIONAL, + LAYOUT_GERMAN, + LAYOUT_GERMAN_MAC, + LAYOUT_CANADIAN_FRENCH, + LAYOUT_CANADIAN_MULTILINGUAL, + LAYOUT_UNITED_KINGDOM, + LAYOUT_FINNISH, + LAYOUT_FRENCH, + LAYOUT_DANISH, + LAYOUT_NORWEGIAN, + LAYOUT_SWEDISH, + LAYOUT_SPANISH, + LAYOUT_PORTUGUESE, + LAYOUT_ITALIAN, + LAYOUT_PORTUGUESE_BRAZILIAN, + LAYOUT_FRENCH_BELGIAN, + LAYOUT_GERMAN_SWISS, + LAYOUT_FRENCH_SWISS, + LAYOUT_SPANISH_LATIN_AMERICA, + LAYOUT_IRISH, + LAYOUT_ICELANDIC, + LAYOUT_TURKISH, + LAYOUT_CZECH, + LAYOUT_SERBIAN_LATIN_ONLY, + LAYOUT_MAX +}; + +/** parse an incoming byte for a keycode + * + * This method parses one incoming byte for the given locale. + * It returns 0 if there is no keycode or another byte is needed (Unicode input). + * If a modifier is needed the given modifier byte is updated. + * + * @see keyboard_layouts + * @return 0 if another byte is needed or no keycode is found; the keycode otherwise + * + * */ +uint8_t parse_for_keycode(uint8_t inputdata, uint8_t locale, uint8_t *keycode_modifier, uint8_t *deadkey_first_keycode); + +/** remove a keycode from the given HID keycode array. + * + * @note The size of the keycode_arr parameter MUST be 6 + * @return 0 if the keycode was removed, 1 if the keycode was not in the array + * */ +uint8_t remove_keycode(uint8_t keycode,uint8_t *keycode_arr); + +/** add a keycode to the given HID keycode array. + * + * @note The size of the keycode_arr parameter MUST be 6 + * @return 0 if the keycode was added, 1 if the keycode was already in the array + * */ +uint8_t add_keycode(uint8_t keycode,uint8_t *keycode_arr); + + +/** get a keycode for the given UTF codepoint + * + * This method parses a 16bit unicode character to a keycode. + * If a modifier is needed the given modifier byte is updated. + * + * @see keyboard_layouts + * @return 0 if no keycode is found; the keycode otherwise + * */ +uint8_t get_keycode(uint16_t cpoint,uint8_t locale,uint8_t *keycode_modifier, uint8_t *deadkey_first_keystroke); + + +/** translate Unicode characters between different locales + * + * This method translates a 16bit Unicode cpoint from one locale to another one. + * + * @see keyboard_layouts + * @return 0 if no cpoint is found; the cpoint otherwise + * */ +uint16_t get_cpoint(uint16_t cpoint,uint8_t locale_src,uint8_t locale_dst); + +/** getting the HID country code for a given locale + * + * @see keyboard_layouts + * @return bCountryCode value for HID info + * @param locale Locale number, as defined in keyboard_layouts + **/ +uint8_t get_hid_country_code(uint8_t locale); + +#endif + diff --git a/main/keylayouts.h b/main/keylayouts.h new file mode 100644 index 0000000..c183c76 --- /dev/null +++ b/main/keylayouts.h @@ -0,0 +1,5782 @@ +/* Teensyduino Core Library + * http://www.pjrc.com/teensy/ + * Copyright (c) 2013 PJRC.COM, LLC. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * 1. The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * 2. If the Software is incorporated into a build system that allows + * selection among a list of target devices, then similar target + * devices manufactured by PJRC.COM must be included in the list of + * target devices and selectable in the same manner. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#ifndef KEYLAYOUTS_H__ +#define KEYLAYOUTS_H__ + +#include + +#ifdef __cplusplus +extern "C"{ +#endif + +//#define LAYOUT_US_ENGLISH +//#define LAYOUT_CANADIAN_FRENCH +//#define LAYOUT_CANADIAN_MULTILINGUAL +//#define LAYOUT_DANISH +//#define LAYOUT_FINNISH +//#define LAYOUT_FRENCH +//#define LAYOUT_FRENCH_BELGIAN +//#define LAYOUT_FRENCH_SWISS +//#define LAYOUT_GERMAN +//#define LAYOUT_GERMAN_MAC +//#define LAYOUT_GERMAN_SWISS +//#define LAYOUT_ICELANDIC +//#define LAYOUT_IRISH +//#define LAYOUT_ITALIAN +//#define LAYOUT_NORWEGIAN +//#define LAYOUT_PORTUGUESE +//#define LAYOUT_PORTUGUESE_BRAZILIAN +//#define LAYOUT_SPANISH +//#define LAYOUT_SPANISH_LATIN_AMERICA +//#define LAYOUT_SWEDISH +//#define LAYOUT_TURKISH +//#define LAYOUT_UNITED_KINGDOM +//#define LAYOUT_US_INTERNATIONAL + + + +// http://en.wikipedia.org/wiki/Keyboard_layout + + +#define MODIFIERKEY_CTRL ( 0x01 | 0xE000 ) +#define MODIFIERKEY_SHIFT ( 0x02 | 0xE000 ) +#define MODIFIERKEY_ALT ( 0x04 | 0xE000 ) +#define MODIFIERKEY_GUI ( 0x08 | 0xE000 ) +#define MODIFIERKEY_LEFT_CTRL ( 0x01 | 0xE000 ) +#define MODIFIERKEY_LEFT_SHIFT ( 0x02 | 0xE000 ) +#define MODIFIERKEY_LEFT_ALT ( 0x04 | 0xE000 ) +#define MODIFIERKEY_LEFT_GUI ( 0x08 | 0xE000 ) +#define MODIFIERKEY_RIGHT_CTRL ( 0x10 | 0xE000 ) +#define MODIFIERKEY_RIGHT_SHIFT ( 0x20 | 0xE000 ) +#define MODIFIERKEY_RIGHT_ALT ( 0x40 | 0xE000 ) +#define MODIFIERKEY_RIGHT_GUI ( 0x80 | 0xE000 ) + +#define KEY_SYSTEM_POWER_DOWN ( 0x81 | 0xE200 ) +#define KEY_SYSTEM_SLEEP ( 0x82 | 0xE200 ) +#define KEY_SYSTEM_WAKE_UP ( 0x83 | 0xE200 ) + +#define KEY_MEDIA_PLAY ( 0xB0 | 0xE400 ) +#define KEY_MEDIA_PAUSE ( 0xB1 | 0xE400 ) +#define KEY_MEDIA_RECORD ( 0xB2 | 0xE400 ) +#define KEY_MEDIA_FAST_FORWARD ( 0xB3 | 0xE400 ) +#define KEY_MEDIA_REWIND ( 0xB4 | 0xE400 ) +#define KEY_MEDIA_NEXT_TRACK ( 0xB5 | 0xE400 ) +#define KEY_MEDIA_PREV_TRACK ( 0xB6 | 0xE400 ) +#define KEY_MEDIA_STOP ( 0xB7 | 0xE400 ) +#define KEY_MEDIA_EJECT ( 0xB8 | 0xE400 ) +#define KEY_MEDIA_RANDOM_PLAY ( 0xB0 | 0xE400 ) +#define KEY_MEDIA_PLAY_PAUSE ( 0xCD | 0xE400 ) +#define KEY_MEDIA_PLAY_SKIP ( 0xCE | 0xE400 ) +#define KEY_MEDIA_MUTE ( 0xE2 | 0xE400 ) +#define KEY_MEDIA_VOLUME_INC ( 0xE9 | 0xE400 ) +#define KEY_MEDIA_VOLUME_DEC ( 0xEA | 0xE400 ) + +#define KEY_A ( 4 | 0xF000 ) +#define KEY_B ( 5 | 0xF000 ) +#define KEY_C ( 6 | 0xF000 ) +#define KEY_D ( 7 | 0xF000 ) +#define KEY_E ( 8 | 0xF000 ) +#define KEY_F ( 9 | 0xF000 ) +#define KEY_G ( 10 | 0xF000 ) +#define KEY_H ( 11 | 0xF000 ) +#define KEY_I ( 12 | 0xF000 ) +#define KEY_J ( 13 | 0xF000 ) +#define KEY_K ( 14 | 0xF000 ) +#define KEY_L ( 15 | 0xF000 ) +#define KEY_M ( 16 | 0xF000 ) +#define KEY_N ( 17 | 0xF000 ) +#define KEY_O ( 18 | 0xF000 ) +#define KEY_P ( 19 | 0xF000 ) +#define KEY_Q ( 20 | 0xF000 ) +#define KEY_R ( 21 | 0xF000 ) +#define KEY_S ( 22 | 0xF000 ) +#define KEY_T ( 23 | 0xF000 ) +#define KEY_U ( 24 | 0xF000 ) +#define KEY_V ( 25 | 0xF000 ) +#define KEY_W ( 26 | 0xF000 ) +#define KEY_X ( 27 | 0xF000 ) +#define KEY_Y ( 28 | 0xF000 ) +#define KEY_Z ( 29 | 0xF000 ) +#define KEY_1 ( 30 | 0xF000 ) +#define KEY_2 ( 31 | 0xF000 ) +#define KEY_3 ( 32 | 0xF000 ) +#define KEY_4 ( 33 | 0xF000 ) +#define KEY_5 ( 34 | 0xF000 ) +#define KEY_6 ( 35 | 0xF000 ) +#define KEY_7 ( 36 | 0xF000 ) +#define KEY_8 ( 37 | 0xF000 ) +#define KEY_9 ( 38 | 0xF000 ) +#define KEY_0 ( 39 | 0xF000 ) +#define KEY_ENTER ( 40 | 0xF000 ) +#define KEY_ESC ( 41 | 0xF000 ) +#define KEY_BACKSPACE ( 42 | 0xF000 ) +#define KEY_TAB ( 43 | 0xF000 ) +#define KEY_SPACE ( 44 | 0xF000 ) +#define KEY_MINUS ( 45 | 0xF000 ) +#define KEY_EQUAL ( 46 | 0xF000 ) +#define KEY_LEFT_BRACE ( 47 | 0xF000 ) +#define KEY_RIGHT_BRACE ( 48 | 0xF000 ) +#define KEY_BACKSLASH ( 49 | 0xF000 ) +#define KEY_NON_US_NUM ( 50 | 0xF000 ) +#define KEY_SEMICOLON ( 51 | 0xF000 ) +#define KEY_QUOTE ( 52 | 0xF000 ) +#define KEY_TILDE ( 53 | 0xF000 ) +#define KEY_COMMA ( 54 | 0xF000 ) +#define KEY_PERIOD ( 55 | 0xF000 ) +#define KEY_SLASH ( 56 | 0xF000 ) +#define KEY_CAPS_LOCK ( 57 | 0xF000 ) +#define KEY_F1 ( 58 | 0xF000 ) +#define KEY_F2 ( 59 | 0xF000 ) +#define KEY_F3 ( 60 | 0xF000 ) +#define KEY_F4 ( 61 | 0xF000 ) +#define KEY_F5 ( 62 | 0xF000 ) +#define KEY_F6 ( 63 | 0xF000 ) +#define KEY_F7 ( 64 | 0xF000 ) +#define KEY_F8 ( 65 | 0xF000 ) +#define KEY_F9 ( 66 | 0xF000 ) +#define KEY_F10 ( 67 | 0xF000 ) +#define KEY_F11 ( 68 | 0xF000 ) +#define KEY_F12 ( 69 | 0xF000 ) +#define KEY_PRINTSCREEN ( 70 | 0xF000 ) +#define KEY_SCROLL_LOCK ( 71 | 0xF000 ) +#define KEY_PAUSE ( 72 | 0xF000 ) +#define KEY_INSERT ( 73 | 0xF000 ) +#define KEY_HOME ( 74 | 0xF000 ) +#define KEY_PAGE_UP ( 75 | 0xF000 ) +#define KEY_DELETE ( 76 | 0xF000 ) +#define KEY_END ( 77 | 0xF000 ) +#define KEY_PAGE_DOWN ( 78 | 0xF000 ) +#define KEY_RIGHT ( 79 | 0xF000 ) +#define KEY_LEFT ( 80 | 0xF000 ) +#define KEY_DOWN ( 81 | 0xF000 ) +#define KEY_UP ( 82 | 0xF000 ) +#define KEY_NUM_LOCK ( 83 | 0xF000 ) +#define KEYPAD_SLASH ( 84 | 0xF000 ) +#define KEYPAD_ASTERIX ( 85 | 0xF000 ) +#define KEYPAD_MINUS ( 86 | 0xF000 ) +#define KEYPAD_PLUS ( 87 | 0xF000 ) +#define KEYPAD_ENTER ( 88 | 0xF000 ) +#define KEYPAD_1 ( 89 | 0xF000 ) +#define KEYPAD_2 ( 90 | 0xF000 ) +#define KEYPAD_3 ( 91 | 0xF000 ) +#define KEYPAD_4 ( 92 | 0xF000 ) +#define KEYPAD_5 ( 93 | 0xF000 ) +#define KEYPAD_6 ( 94 | 0xF000 ) +#define KEYPAD_7 ( 95 | 0xF000 ) +#define KEYPAD_8 ( 96 | 0xF000 ) +#define KEYPAD_9 ( 97 | 0xF000 ) +#define KEYPAD_0 ( 98 | 0xF000 ) +#define KEYPAD_PERIOD ( 99 | 0xF000 ) +#define KEY_NON_US_BS ( 100 | 0xF000 ) +#define KEY_MENU ( 101 | 0xF000 ) +#define KEY_F13 ( 104 | 0xF000 ) +#define KEY_F14 ( 105 | 0xF000 ) +#define KEY_F15 ( 106 | 0xF000 ) +#define KEY_F16 ( 107 | 0xF000 ) +#define KEY_F17 ( 108 | 0xF000 ) +#define KEY_F18 ( 109 | 0xF000 ) +#define KEY_F19 ( 110 | 0xF000 ) +#define KEY_F20 ( 111 | 0xF000 ) +#define KEY_F21 ( 112 | 0xF000 ) +#define KEY_F22 ( 113 | 0xF000 ) +#define KEY_F23 ( 114 | 0xF000 ) +#define KEY_F24 ( 115 | 0xF000 ) + +// for compatibility with Leonardo's slightly different names +#define KEY_UP_ARROW KEY_UP +#define KEY_DOWN_ARROW KEY_DOWN +#define KEY_LEFT_ARROW KEY_LEFT +#define KEY_RIGHT_ARROW KEY_RIGHT +#define KEY_RETURN KEY_ENTER +#define KEY_LEFT_CTRL MODIFIERKEY_LEFT_CTRL +#define KEY_LEFT_SHIFT MODIFIERKEY_LEFT_SHIFT +#define KEY_LEFT_ALT MODIFIERKEY_LEFT_ALT +#define KEY_LEFT_GUI MODIFIERKEY_LEFT_GUI +#define KEY_RIGHT_CTRL MODIFIERKEY_RIGHT_CTRL +#define KEY_RIGHT_SHIFT MODIFIERKEY_RIGHT_SHIFT +#define KEY_RIGHT_ALT MODIFIERKEY_RIGHT_ALT +#define KEY_RIGHT_GUI MODIFIERKEY_RIGHT_GUI + + +// Everything below this line is not intended for use in "normal" programs. +// These private symbols populate lookup tables, which are used to translate +// ascii and UTF8 unicode into keystroke sequences. + + +#ifdef LAYOUT_US_ENGLISH + +#define SHIFT_MASK 0x40 +#define KEYCODE_TYPE uint8_t +#define KEYCODE_MASK 0x007F + +#define ASCII_20 KEY_SPACE // 32 +#define ASCII_21 KEY_1 + SHIFT_MASK // 33 ! +#define ASCII_22 KEY_QUOTE + SHIFT_MASK // 34 " +#define ASCII_23 KEY_3 + SHIFT_MASK // 35 # +#define ASCII_24 KEY_4 + SHIFT_MASK // 36 $ +#define ASCII_25 KEY_5 + SHIFT_MASK // 37 % +#define ASCII_26 KEY_7 + SHIFT_MASK // 38 & +#define ASCII_27 KEY_QUOTE // 39 ' +#define ASCII_28 KEY_9 + SHIFT_MASK // 40 ( +#define ASCII_29 KEY_0 + SHIFT_MASK // 41 ) +#define ASCII_2A KEY_8 + SHIFT_MASK // 42 * +#define ASCII_2B KEY_EQUAL + SHIFT_MASK // 43 + +#define ASCII_2C KEY_COMMA // 44 , +#define ASCII_2D KEY_MINUS // 45 - +#define ASCII_2E KEY_PERIOD // 46 . +#define ASCII_2F KEY_SLASH // 47 / +#define ASCII_30 KEY_0 // 48 0 +#define ASCII_31 KEY_1 // 49 1 +#define ASCII_32 KEY_2 // 50 2 +#define ASCII_33 KEY_3 // 51 3 +#define ASCII_34 KEY_4 // 52 4 +#define ASCII_35 KEY_5 // 53 5 +#define ASCII_36 KEY_6 // 54 6 +#define ASCII_37 KEY_7 // 55 7 +#define ASCII_38 KEY_8 // 55 8 +#define ASCII_39 KEY_9 // 57 9 +#define ASCII_3A KEY_SEMICOLON + SHIFT_MASK // 58 : +#define ASCII_3B KEY_SEMICOLON // 59 ; +#define ASCII_3C KEY_COMMA + SHIFT_MASK // 60 < +#define ASCII_3D KEY_EQUAL // 61 = +#define ASCII_3E KEY_PERIOD + SHIFT_MASK // 62 > +#define ASCII_3F KEY_SLASH + SHIFT_MASK // 63 ? +#define ASCII_40 KEY_2 + SHIFT_MASK // 64 @ +#define ASCII_41 KEY_A + SHIFT_MASK // 65 A +#define ASCII_42 KEY_B + SHIFT_MASK // 66 B +#define ASCII_43 KEY_C + SHIFT_MASK // 67 C +#define ASCII_44 KEY_D + SHIFT_MASK // 68 D +#define ASCII_45 KEY_E + SHIFT_MASK // 69 E +#define ASCII_46 KEY_F + SHIFT_MASK // 70 F +#define ASCII_47 KEY_G + SHIFT_MASK // 71 G +#define ASCII_48 KEY_H + SHIFT_MASK // 72 H +#define ASCII_49 KEY_I + SHIFT_MASK // 73 I +#define ASCII_4A KEY_J + SHIFT_MASK // 74 J +#define ASCII_4B KEY_K + SHIFT_MASK // 75 K +#define ASCII_4C KEY_L + SHIFT_MASK // 76 L +#define ASCII_4D KEY_M + SHIFT_MASK // 77 M +#define ASCII_4E KEY_N + SHIFT_MASK // 78 N +#define ASCII_4F KEY_O + SHIFT_MASK // 79 O +#define ASCII_50 KEY_P + SHIFT_MASK // 80 P +#define ASCII_51 KEY_Q + SHIFT_MASK // 81 Q +#define ASCII_52 KEY_R + SHIFT_MASK // 82 R +#define ASCII_53 KEY_S + SHIFT_MASK // 83 S +#define ASCII_54 KEY_T + SHIFT_MASK // 84 T +#define ASCII_55 KEY_U + SHIFT_MASK // 85 U +#define ASCII_56 KEY_V + SHIFT_MASK // 86 V +#define ASCII_57 KEY_W + SHIFT_MASK // 87 W +#define ASCII_58 KEY_X + SHIFT_MASK // 88 X +#define ASCII_59 KEY_Y + SHIFT_MASK // 89 Y +#define ASCII_5A KEY_Z + SHIFT_MASK // 90 Z +#define ASCII_5B KEY_LEFT_BRACE // 91 [ +#define ASCII_5C KEY_BACKSLASH // 92 +#define ASCII_5D KEY_RIGHT_BRACE // 93 ] +#define ASCII_5E KEY_6 + SHIFT_MASK // 94 ^ +#define ASCII_5F KEY_MINUS + SHIFT_MASK // 95 _ +#define ASCII_60 KEY_TILDE // 96 ` +#define ASCII_61 KEY_A // 97 a +#define ASCII_62 KEY_B // 98 b +#define ASCII_63 KEY_C // 99 c +#define ASCII_64 KEY_D // 100 d +#define ASCII_65 KEY_E // 101 e +#define ASCII_66 KEY_F // 102 f +#define ASCII_67 KEY_G // 103 g +#define ASCII_68 KEY_H // 104 h +#define ASCII_69 KEY_I // 105 i +#define ASCII_6A KEY_J // 106 j +#define ASCII_6B KEY_K // 107 k +#define ASCII_6C KEY_L // 108 l +#define ASCII_6D KEY_M // 109 m +#define ASCII_6E KEY_N // 110 n +#define ASCII_6F KEY_O // 111 o +#define ASCII_70 KEY_P // 112 p +#define ASCII_71 KEY_Q // 113 q +#define ASCII_72 KEY_R // 114 r +#define ASCII_73 KEY_S // 115 s +#define ASCII_74 KEY_T // 116 t +#define ASCII_75 KEY_U // 117 u +#define ASCII_76 KEY_V // 118 v +#define ASCII_77 KEY_W // 119 w +#define ASCII_78 KEY_X // 120 x +#define ASCII_79 KEY_Y // 121 y +#define ASCII_7A KEY_Z // 122 z +#define ASCII_7B KEY_LEFT_BRACE + SHIFT_MASK // 123 { +#define ASCII_7C KEY_BACKSLASH + SHIFT_MASK // 124 | +#define ASCII_7D KEY_RIGHT_BRACE + SHIFT_MASK // 125 } +#define ASCII_7E KEY_TILDE + SHIFT_MASK // 126 ~ +#define ASCII_7F KEY_BACKSPACE // 127 + +#endif // LAYOUT_US_ENGLISH + + + + +#ifdef LAYOUT_US_INTERNATIONAL + +#define SHIFT_MASK 0x0040 +#define ALTGR_MASK 0x0080 +#define DEADKEYS_MASK 0x0700 +#define CIRCUMFLEX_BITS 0x0100 +#define ACUTE_ACCENT_BITS 0x0200 +#define GRAVE_ACCENT_BITS 0x0300 +#define TILDE_BITS 0x0400 +#define DIAERESIS_BITS 0x0500 +#define KEYCODE_TYPE uint16_t +#define KEYCODE_MASK 0x07FF +#define DEADKEY_CIRCUMFLEX KEY_6 + SHIFT_MASK +#define DEADKEY_ACUTE_ACCENT KEY_QUOTE +#define DEADKEY_GRAVE_ACCENT KEY_TILDE +#define DEADKEY_TILDE KEY_TILDE + SHIFT_MASK +#define DEADKEY_DIAERESIS KEY_QUOTE + SHIFT_MASK + +#define ASCII_20 KEY_SPACE // 32 +#define ASCII_21 KEY_1 + SHIFT_MASK // 33 ! +#define ASCII_22 DIAERESIS_BITS + KEY_SPACE // 34 " +#define ASCII_23 KEY_3 + SHIFT_MASK // 35 # +#define ASCII_24 KEY_4 + SHIFT_MASK // 36 $ +#define ASCII_25 KEY_5 + SHIFT_MASK // 37 % +#define ASCII_26 KEY_7 + SHIFT_MASK // 38 & +#define ASCII_27 ACUTE_ACCENT_BITS + KEY_SPACE // 39 ' +#define ASCII_28 KEY_9 + SHIFT_MASK // 40 ( +#define ASCII_29 KEY_0 + SHIFT_MASK // 41 ) +#define ASCII_2A KEY_8 + SHIFT_MASK // 42 * +#define ASCII_2B KEY_EQUAL + SHIFT_MASK // 43 + +#define ASCII_2C KEY_COMMA // 44 , +#define ASCII_2D KEY_MINUS // 45 - +#define ASCII_2E KEY_PERIOD // 46 . +#define ASCII_2F KEY_SLASH // 47 / +#define ASCII_30 KEY_0 // 48 0 +#define ASCII_31 KEY_1 // 49 1 +#define ASCII_32 KEY_2 // 50 2 +#define ASCII_33 KEY_3 // 51 3 +#define ASCII_34 KEY_4 // 52 4 +#define ASCII_35 KEY_5 // 53 5 +#define ASCII_36 KEY_6 // 54 6 +#define ASCII_37 KEY_7 // 55 7 +#define ASCII_38 KEY_8 // 55 8 +#define ASCII_39 KEY_9 // 57 9 +#define ASCII_3A KEY_SEMICOLON + SHIFT_MASK // 58 : +#define ASCII_3B KEY_SEMICOLON // 59 ; +#define ASCII_3C KEY_COMMA + SHIFT_MASK // 60 < +#define ASCII_3D KEY_EQUAL // 61 = +#define ASCII_3E KEY_PERIOD + SHIFT_MASK // 62 > +#define ASCII_3F KEY_SLASH + SHIFT_MASK // 63 ? +#define ASCII_40 KEY_2 + SHIFT_MASK // 64 @ +#define ASCII_41 KEY_A + SHIFT_MASK // 65 A +#define ASCII_42 KEY_B + SHIFT_MASK // 66 B +#define ASCII_43 KEY_C + SHIFT_MASK // 67 C +#define ASCII_44 KEY_D + SHIFT_MASK // 68 D +#define ASCII_45 KEY_E + SHIFT_MASK // 69 E +#define ASCII_46 KEY_F + SHIFT_MASK // 70 F +#define ASCII_47 KEY_G + SHIFT_MASK // 71 G +#define ASCII_48 KEY_H + SHIFT_MASK // 72 H +#define ASCII_49 KEY_I + SHIFT_MASK // 73 I +#define ASCII_4A KEY_J + SHIFT_MASK // 74 J +#define ASCII_4B KEY_K + SHIFT_MASK // 75 K +#define ASCII_4C KEY_L + SHIFT_MASK // 76 L +#define ASCII_4D KEY_M + SHIFT_MASK // 77 M +#define ASCII_4E KEY_N + SHIFT_MASK // 78 N +#define ASCII_4F KEY_O + SHIFT_MASK // 79 O +#define ASCII_50 KEY_P + SHIFT_MASK // 80 P +#define ASCII_51 KEY_Q + SHIFT_MASK // 81 Q +#define ASCII_52 KEY_R + SHIFT_MASK // 82 R +#define ASCII_53 KEY_S + SHIFT_MASK // 83 S +#define ASCII_54 KEY_T + SHIFT_MASK // 84 T +#define ASCII_55 KEY_U + SHIFT_MASK // 85 U +#define ASCII_56 KEY_V + SHIFT_MASK // 86 V +#define ASCII_57 KEY_W + SHIFT_MASK // 87 W +#define ASCII_58 KEY_X + SHIFT_MASK // 88 X +#define ASCII_59 KEY_Y + SHIFT_MASK // 89 Y +#define ASCII_5A KEY_Z + SHIFT_MASK // 90 Z +#define ASCII_5B KEY_LEFT_BRACE // 91 [ +#define ASCII_5C KEY_BACKSLASH // 92 +#define ASCII_5D KEY_RIGHT_BRACE // 93 ] +#define ASCII_5E CIRCUMFLEX_BITS + KEY_SPACE // 94 ^ +#define ASCII_5F KEY_MINUS + SHIFT_MASK // 95 _ +#define ASCII_60 GRAVE_ACCENT_BITS + KEY_SPACE // 96 ` +#define ASCII_61 KEY_A // 97 a +#define ASCII_62 KEY_B // 98 b +#define ASCII_63 KEY_C // 99 c +#define ASCII_64 KEY_D // 100 d +#define ASCII_65 KEY_E // 101 e +#define ASCII_66 KEY_F // 102 f +#define ASCII_67 KEY_G // 103 g +#define ASCII_68 KEY_H // 104 h +#define ASCII_69 KEY_I // 105 i +#define ASCII_6A KEY_J // 106 j +#define ASCII_6B KEY_K // 107 k +#define ASCII_6C KEY_L // 108 l +#define ASCII_6D KEY_M // 109 m +#define ASCII_6E KEY_N // 110 n +#define ASCII_6F KEY_O // 111 o +#define ASCII_70 KEY_P // 112 p +#define ASCII_71 KEY_Q // 113 q +#define ASCII_72 KEY_R // 114 r +#define ASCII_73 KEY_S // 115 s +#define ASCII_74 KEY_T // 116 t +#define ASCII_75 KEY_U // 117 u +#define ASCII_76 KEY_V // 118 v +#define ASCII_77 KEY_W // 119 w +#define ASCII_78 KEY_X // 120 x +#define ASCII_79 KEY_Y // 121 y +#define ASCII_7A KEY_Z // 122 z +#define ASCII_7B KEY_LEFT_BRACE + SHIFT_MASK // 123 { +#define ASCII_7C KEY_BACKSLASH + SHIFT_MASK // 124 | +#define ASCII_7D KEY_RIGHT_BRACE + SHIFT_MASK // 125 } +#define ASCII_7E TILDE_BITS + KEY_SPACE // 126 ~ +#define ASCII_7F KEY_BACKSPACE // 127 +#define ISO_8859_1_A0 KEY_SPACE // 160 Nonbreakng Space +#define ISO_8859_1_A1 KEY_1 + ALTGR_MASK // 161 ¡ Inverted Exclamation +#define ISO_8859_1_A2 KEY_C + ALTGR_MASK + SHIFT_MASK // 162 ¢ Cent SIGN +#define ISO_8859_1_A3 KEY_4 + ALTGR_MASK + SHIFT_MASK // 163 £ Pound Sign +#define ISO_8859_1_A4 KEY_4 + ALTGR_MASK // 164 ¤ Currency or Euro Sign +#define ISO_8859_1_A5 KEY_MINUS + ALTGR_MASK // 165 ¥ YEN SIGN +#define ISO_8859_1_A6 KEY_BACKSLASH + ALTGR_MASK + SHIFT_MASK // 166 ¦ BROKEN BAR ?? +#define ISO_8859_1_A7 KEY_S + ALTGR_MASK + SHIFT_MASK // 167 § SECTION SIGN +#define ISO_8859_1_A8 KEY_QUOTE + ALTGR_MASK + SHIFT_MASK // 168 ¨ DIAERESIS +#define ISO_8859_1_A9 KEY_C + ALTGR_MASK // 169 © COPYRIGHT SIGN +#define ISO_8859_1_AA 0 // 170 ª FEMININE ORDINAL +#define ISO_8859_1_AB KEY_LEFT_BRACE + ALTGR_MASK // 171 « LEFT DOUBLE ANGLE QUOTE +#define ISO_8859_1_AC KEY_BACKSLASH + ALTGR_MASK // 172 ¬ NOT SIGN ?? +#define ISO_8859_1_AD 0 // 173 SOFT HYPHEN +#define ISO_8859_1_AE KEY_R + ALTGR_MASK // 174 ® REGISTERED SIGN +#define ISO_8859_1_AF 0 // 175 ¯ MACRON +#define ISO_8859_1_B0 KEY_SEMICOLON + ALTGR_MASK + SHIFT_MASK // 176 ° DEGREE SIGN +#define ISO_8859_1_B1 0 // 177 ± PLUS-MINUS SIGN +#define ISO_8859_1_B2 KEY_2 + ALTGR_MASK // 178 ² SUPERSCRIPT TWO +#define ISO_8859_1_B3 KEY_3 + ALTGR_MASK // 179 ³ SUPERSCRIPT THREE +#define ISO_8859_1_B4 KEY_QUOTE + ALTGR_MASK // 180 ´ ACUTE ACCENT +#define ISO_8859_1_B5 KEY_M + ALTGR_MASK // 181 µ MICRO SIGN +#define ISO_8859_1_B6 KEY_SEMICOLON + ALTGR_MASK // 182 ¶ PILCROW SIGN +#define ISO_8859_1_B7 0 // 183 · MIDDLE DOT +#define ISO_8859_1_B8 0 // 184 ¸ CEDILLA +#define ISO_8859_1_B9 KEY_1 + ALTGR_MASK + SHIFT_MASK // 185 ¹ SUPERSCRIPT ONE +#define ISO_8859_1_BA 0 // 186 º MASCULINE ORDINAL +#define ISO_8859_1_BB KEY_RIGHT_BRACE + ALTGR_MASK // 187 » RIGHT DOUBLE ANGLE QUOTE +#define ISO_8859_1_BC KEY_6 + ALTGR_MASK // 188 ¼ FRACTION ONE QUARTER +#define ISO_8859_1_BD KEY_7 + ALTGR_MASK // 189 ½ FRACTION ONE HALF +#define ISO_8859_1_BE KEY_8 + ALTGR_MASK // 190 ¾ FRACTION THREE QUARTERS +#define ISO_8859_1_BF KEY_SLASH + ALTGR_MASK // 191 ¿ INVERTED QUESTION MARK +#define ISO_8859_1_C0 GRAVE_ACCENT_BITS + KEY_A + SHIFT_MASK // 192 À A GRAVE +#define ISO_8859_1_C1 KEY_A + ALTGR_MASK + SHIFT_MASK // 193 Á A ACUTE +#define ISO_8859_1_C2 CIRCUMFLEX_BITS + KEY_A + SHIFT_MASK // 194 Â A CIRCUMFLEX +#define ISO_8859_1_C3 TILDE_BITS + KEY_A + SHIFT_MASK // 195 Ã A TILDE +#define ISO_8859_1_C4 KEY_Q + ALTGR_MASK + SHIFT_MASK // 196 Ä A DIAERESIS +#define ISO_8859_1_C5 KEY_W + ALTGR_MASK + SHIFT_MASK // 197 Å A RING ABOVE +#define ISO_8859_1_C6 KEY_Z + ALTGR_MASK + SHIFT_MASK // 198 Æ AE +#define ISO_8859_1_C7 KEY_COMMA + ALTGR_MASK + SHIFT_MASK // 199 Ç C CEDILLA +#define ISO_8859_1_C8 GRAVE_ACCENT_BITS + KEY_E + SHIFT_MASK // 200 È E GRAVE +#define ISO_8859_1_C9 KEY_E + ALTGR_MASK + SHIFT_MASK // 201 É E ACUTE +#define ISO_8859_1_CA CIRCUMFLEX_BITS + KEY_E + SHIFT_MASK // 202 Ê E CIRCUMFLEX +#define ISO_8859_1_CB DIAERESIS_BITS + KEY_E + SHIFT_MASK // 203 Ë E DIAERESIS +#define ISO_8859_1_CC GRAVE_ACCENT_BITS + KEY_I + SHIFT_MASK // 204 Ì I GRAVE +#define ISO_8859_1_CD KEY_I + ALTGR_MASK + SHIFT_MASK // 205 Í I ACUTE +#define ISO_8859_1_CE CIRCUMFLEX_BITS + KEY_I + SHIFT_MASK // 206 Î I CIRCUMFLEX +#define ISO_8859_1_CF DIAERESIS_BITS + KEY_I + SHIFT_MASK // 207 Ï I DIAERESIS +#define ISO_8859_1_D0 KEY_D + ALTGR_MASK + SHIFT_MASK // 208 Ð ETH +#define ISO_8859_1_D1 KEY_N + ALTGR_MASK + SHIFT_MASK // 209 Ñ N TILDE +#define ISO_8859_1_D2 GRAVE_ACCENT_BITS + KEY_O + SHIFT_MASK // 210 Ò O GRAVE +#define ISO_8859_1_D3 KEY_O + ALTGR_MASK + SHIFT_MASK // 211 Ó O ACUTE +#define ISO_8859_1_D4 CIRCUMFLEX_BITS + KEY_O + SHIFT_MASK // 212 Ô O CIRCUMFLEX +#define ISO_8859_1_D5 TILDE_BITS + KEY_O + SHIFT_MASK // 213 Õ O TILDE +#define ISO_8859_1_D6 KEY_P + ALTGR_MASK + SHIFT_MASK // 214 Ö O DIAERESIS +#define ISO_8859_1_D7 KEY_EQUAL + ALTGR_MASK // 215 × MULTIPLICATION +#define ISO_8859_1_D8 KEY_L + ALTGR_MASK + SHIFT_MASK // 216 Ø O STROKE +#define ISO_8859_1_D9 GRAVE_ACCENT_BITS + KEY_U + SHIFT_MASK // 217 Ù U GRAVE +#define ISO_8859_1_DA KEY_U + ALTGR_MASK + SHIFT_MASK // 218 Ú U ACUTE +#define ISO_8859_1_DB CIRCUMFLEX_BITS + KEY_U + SHIFT_MASK // 219 Û U CIRCUMFLEX +#define ISO_8859_1_DC KEY_Y + ALTGR_MASK + SHIFT_MASK // 220 Ü U DIAERESIS +#define ISO_8859_1_DD ACUTE_ACCENT_BITS + KEY_Y + SHIFT_MASK // 221 Ý Y ACUTE +#define ISO_8859_1_DE KEY_T + ALTGR_MASK + SHIFT_MASK // 222 Þ THORN +#define ISO_8859_1_DF KEY_S + ALTGR_MASK // 223 ß SHARP S +#define ISO_8859_1_E0 GRAVE_ACCENT_BITS + KEY_A // 224 à a GRAVE +#define ISO_8859_1_E1 KEY_A + ALTGR_MASK // 225 á a ACUTE +#define ISO_8859_1_E2 CIRCUMFLEX_BITS + KEY_A // 226 â a CIRCUMFLEX +#define ISO_8859_1_E3 TILDE_BITS + KEY_A // 227 ã a TILDE +#define ISO_8859_1_E4 DIAERESIS_BITS + KEY_A // 228 ä a DIAERESIS +#define ISO_8859_1_E5 KEY_W + ALTGR_MASK // 229 å a RING ABOVE +#define ISO_8859_1_E6 KEY_Z + ALTGR_MASK // 230 æ ae +#define ISO_8859_1_E7 KEY_COMMA + ALTGR_MASK // 231 ç c CEDILLA +#define ISO_8859_1_E8 GRAVE_ACCENT_BITS + KEY_E // 232 è e GRAVE +#define ISO_8859_1_E9 ACUTE_ACCENT_BITS + KEY_E // 233 é e ACUTE +#define ISO_8859_1_EA CIRCUMFLEX_BITS + KEY_E // 234 ê e CIRCUMFLEX +#define ISO_8859_1_EB DIAERESIS_BITS + KEY_E // 235 ë e DIAERESIS +#define ISO_8859_1_EC GRAVE_ACCENT_BITS + KEY_I // 236 ì i GRAVE +#define ISO_8859_1_ED KEY_I + ALTGR_MASK // 237 í i ACUTE +#define ISO_8859_1_EE CIRCUMFLEX_BITS + KEY_I // 238 î i CIRCUMFLEX +#define ISO_8859_1_EF DIAERESIS_BITS + KEY_I // 239 ï i DIAERESIS +#define ISO_8859_1_F0 KEY_D + ALTGR_MASK // 240 ð ETH +#define ISO_8859_1_F1 KEY_N + ALTGR_MASK // 241 ñ n TILDE +#define ISO_8859_1_F2 GRAVE_ACCENT_BITS + KEY_O // 242 ò o GRAVE +#define ISO_8859_1_F3 KEY_O + ALTGR_MASK // 243 ó o ACUTE +#define ISO_8859_1_F4 CIRCUMFLEX_BITS + KEY_O // 244 ô o CIRCUMFLEX +#define ISO_8859_1_F5 TILDE_BITS + KEY_O // 245 õ o TILDE +#define ISO_8859_1_F6 KEY_P + ALTGR_MASK // 246 ö o DIAERESIS +#define ISO_8859_1_F7 KEY_EQUAL + ALTGR_MASK + SHIFT_MASK // 247 ÷ DIVISION +#define ISO_8859_1_F8 KEY_L + ALTGR_MASK // 248 ø o STROKE +#define ISO_8859_1_F9 GRAVE_ACCENT_BITS + KEY_U // 249 ù u GRAVE +#define ISO_8859_1_FA KEY_U + ALTGR_MASK // 250 ú u ACUTE +#define ISO_8859_1_FB CIRCUMFLEX_BITS + KEY_U // 251 û u CIRCUMFLEX +#define ISO_8859_1_FC KEY_Y + ALTGR_MASK // 252 ü u DIAERESIS +#define ISO_8859_1_FD ACUTE_ACCENT_BITS + KEY_Y // 253 ý y ACUTE +#define ISO_8859_1_FE KEY_T + ALTGR_MASK // 254 þ THORN +#define ISO_8859_1_FF DIAERESIS_BITS + KEY_Y // 255 ÿ y DIAERESIS +#define UNICODE_20AC KEY_5 + ALTGR_MASK // € Euro Sign +// not yet implemented +#define UNICODE_EXTRA00 0x20AC +#define KEYCODE_EXTRA00 KEY_5 + ALTGR_MASK // 20AC € Euro Sign + +#endif // LAYOUT_US_INTERNATIONAL + + + +#ifdef LAYOUT_GERMAN + +#define SHIFT_MASK 0x0040 +#define ALTGR_MASK 0x0080 +#define DEADKEYS_MASK 0x0700 +#define CIRCUMFLEX_BITS 0x0300 +#define ACUTE_ACCENT_BITS 0x0400 +#define GRAVE_ACCENT_BITS 0x0500 +#define KEYCODE_TYPE uint16_t +#define KEYCODE_MASK 0x07FF +#define DEADKEY_CIRCUMFLEX KEY_TILDE +#define DEADKEY_ACUTE_ACCENT KEY_EQUAL +#define DEADKEY_GRAVE_ACCENT KEY_EQUAL + SHIFT_MASK +#define KEY_NON_US_100 63 + +#define ASCII_20 KEY_SPACE // 32 +#define ASCII_21 KEY_1 + SHIFT_MASK // 33 ! +#define ASCII_22 KEY_2 + SHIFT_MASK // 34 " +#define ASCII_23 KEY_BACKSLASH // 35 # ?? +#define ASCII_24 KEY_4 + SHIFT_MASK // 36 $ +#define ASCII_25 KEY_5 + SHIFT_MASK // 37 % +#define ASCII_26 KEY_6 + SHIFT_MASK // 38 & +#define ASCII_27 KEY_BACKSLASH + SHIFT_MASK // 39 ' +#define ASCII_28 KEY_8 + SHIFT_MASK // 40 ( +#define ASCII_29 KEY_9 + SHIFT_MASK // 41 ) +#define ASCII_2A KEY_RIGHT_BRACE + SHIFT_MASK // 42 * +#define ASCII_2B KEY_RIGHT_BRACE // 43 + +#define ASCII_2C KEY_COMMA // 44 , +#define ASCII_2D KEY_SLASH // 45 - +#define ASCII_2E KEY_PERIOD // 46 . +#define ASCII_2F KEY_7 + SHIFT_MASK // 47 / +#define ASCII_30 KEY_0 // 48 0 +#define ASCII_31 KEY_1 // 49 1 +#define ASCII_32 KEY_2 // 50 2 +#define ASCII_33 KEY_3 // 51 3 +#define ASCII_34 KEY_4 // 52 4 +#define ASCII_35 KEY_5 // 53 5 +#define ASCII_36 KEY_6 // 54 6 +#define ASCII_37 KEY_7 // 55 7 +#define ASCII_38 KEY_8 // 55 8 +#define ASCII_39 KEY_9 // 57 9 +#define ASCII_3A KEY_PERIOD + SHIFT_MASK // 58 : +#define ASCII_3B KEY_COMMA + SHIFT_MASK // 59 ; +#define ASCII_3C KEY_NON_US_100 // 60 < +#define ASCII_3D KEY_0 + SHIFT_MASK // 61 = +#define ASCII_3E KEY_NON_US_100 + SHIFT_MASK // 62 > +#define ASCII_3F KEY_MINUS + SHIFT_MASK // 63 ? +#define ASCII_40 KEY_Q + ALTGR_MASK // 64 @ +#define ASCII_41 KEY_A + SHIFT_MASK // 65 A +#define ASCII_42 KEY_B + SHIFT_MASK // 66 B +#define ASCII_43 KEY_C + SHIFT_MASK // 67 C +#define ASCII_44 KEY_D + SHIFT_MASK // 68 D +#define ASCII_45 KEY_E + SHIFT_MASK // 69 E +#define ASCII_46 KEY_F + SHIFT_MASK // 70 F +#define ASCII_47 KEY_G + SHIFT_MASK // 71 G +#define ASCII_48 KEY_H + SHIFT_MASK // 72 H +#define ASCII_49 KEY_I + SHIFT_MASK // 73 I +#define ASCII_4A KEY_J + SHIFT_MASK // 74 J +#define ASCII_4B KEY_K + SHIFT_MASK // 75 K +#define ASCII_4C KEY_L + SHIFT_MASK // 76 L +#define ASCII_4D KEY_M + SHIFT_MASK // 77 M +#define ASCII_4E KEY_N + SHIFT_MASK // 78 N +#define ASCII_4F KEY_O + SHIFT_MASK // 79 O +#define ASCII_50 KEY_P + SHIFT_MASK // 80 P +#define ASCII_51 KEY_Q + SHIFT_MASK // 81 Q +#define ASCII_52 KEY_R + SHIFT_MASK // 82 R +#define ASCII_53 KEY_S + SHIFT_MASK // 83 S +#define ASCII_54 KEY_T + SHIFT_MASK // 84 T +#define ASCII_55 KEY_U + SHIFT_MASK // 85 U +#define ASCII_56 KEY_V + SHIFT_MASK // 86 V +#define ASCII_57 KEY_W + SHIFT_MASK // 87 W +#define ASCII_58 KEY_X + SHIFT_MASK // 88 X +#define ASCII_59 KEY_Z + SHIFT_MASK // 89 Y +#define ASCII_5A KEY_Y + SHIFT_MASK // 90 Z +#define ASCII_5B KEY_8 + ALTGR_MASK // 91 [ +#define ASCII_5C KEY_MINUS + ALTGR_MASK // 92 +#define ASCII_5D KEY_9 + ALTGR_MASK // 93 ] +#define ASCII_5E CIRCUMFLEX_BITS + KEY_SPACE // 94 ^ +#define ASCII_5F KEY_SLASH + SHIFT_MASK // 95 _ +#define ASCII_60 GRAVE_ACCENT_BITS + KEY_SPACE // 96 ` +#define ASCII_61 KEY_A // 97 a +#define ASCII_62 KEY_B // 98 b +#define ASCII_63 KEY_C // 99 c +#define ASCII_64 KEY_D // 100 d +#define ASCII_65 KEY_E // 101 e +#define ASCII_66 KEY_F // 102 f +#define ASCII_67 KEY_G // 103 g +#define ASCII_68 KEY_H // 104 h +#define ASCII_69 KEY_I // 105 i +#define ASCII_6A KEY_J // 106 j +#define ASCII_6B KEY_K // 107 k +#define ASCII_6C KEY_L // 108 l +#define ASCII_6D KEY_M // 109 m +#define ASCII_6E KEY_N // 110 n +#define ASCII_6F KEY_O // 111 o +#define ASCII_70 KEY_P // 112 p +#define ASCII_71 KEY_Q // 113 q +#define ASCII_72 KEY_R // 114 r +#define ASCII_73 KEY_S // 115 s +#define ASCII_74 KEY_T // 116 t +#define ASCII_75 KEY_U // 117 u +#define ASCII_76 KEY_V // 118 v +#define ASCII_77 KEY_W // 119 w +#define ASCII_78 KEY_X // 120 x +#define ASCII_79 KEY_Z // 121 y +#define ASCII_7A KEY_Y // 122 z +#define ASCII_7B KEY_7 + ALTGR_MASK // 123 { +#define ASCII_7C KEY_NON_US_100 + ALTGR_MASK // 124 | +#define ASCII_7D KEY_0 + ALTGR_MASK // 125 } +#define ASCII_7E KEY_RIGHT_BRACE + ALTGR_MASK // 126 ~ +#define ASCII_7F KEY_BACKSPACE // 127 +#define ISO_8859_1_A0 KEY_SPACE // 160 Nonbreakng Space +#define ISO_8859_1_A1 0 // 161 ¡ Inverted Exclamation +#define ISO_8859_1_A2 0 // 162 ¢ Cent Sign +#define ISO_8859_1_A3 0 // 163 £ Pound Sign +#define ISO_8859_1_A4 KEY_E + ALTGR_MASK // 164 ¤ Currency Sign +#define ISO_8859_1_A5 0 // 165 ¥ YEN SIGN +#define ISO_8859_1_A6 0 // 166 ¦ BROKEN BAR +#define ISO_8859_1_A7 KEY_3 + SHIFT_MASK // 167 § SECTION SIGN +#define ISO_8859_1_A8 0 // 168 ¨ DIAERESIS +#define ISO_8859_1_A9 0 // 169 © COPYRIGHT SIGN +#define ISO_8859_1_AA 0 // 170 ª FEMININE ORDINAL +#define ISO_8859_1_AB 0 // 171 « LEFT DOUBLE ANGLE QUOTE +#define ISO_8859_1_AC 0 // 172 ¬ NOT SIGN +#define ISO_8859_1_AD 0 // 173 SOFT HYPHEN +#define ISO_8859_1_AE 0 // 174 ® REGISTERED SIGN +#define ISO_8859_1_AF 0 // 175 ¯ MACRON +#define ISO_8859_1_B0 KEY_TILDE + SHIFT_MASK // 176 ° DEGREE SIGN +#define ISO_8859_1_B1 0 // 177 ± PLUS-MINUS SIGN +#define ISO_8859_1_B2 KEY_2 + ALTGR_MASK // 178 ² SUPERSCRIPT TWO +#define ISO_8859_1_B3 KEY_3 + ALTGR_MASK // 179 ³ SUPERSCRIPT THREE +#define ISO_8859_1_B4 0 // 180 ´ ACUTE ACCENT +#define ISO_8859_1_B5 KEY_M + ALTGR_MASK // 181 µ MICRO SIGN +#define ISO_8859_1_B6 0 // 182 ¶ PILCROW SIGN +#define ISO_8859_1_B7 0 // 183 · MIDDLE DOT +#define ISO_8859_1_B8 0 // 184 ¸ CEDILLA +#define ISO_8859_1_B9 0 // 185 ¹ SUPERSCRIPT ONE +#define ISO_8859_1_BA 0 // 186 º MASCULINE ORDINAL +#define ISO_8859_1_BB 0 // 187 » RIGHT DOUBLE ANGLE QUOTE +#define ISO_8859_1_BC 0 // 188 ¼ FRACTION ONE QUARTER +#define ISO_8859_1_BD 0 // 189 ½ FRACTION ONE HALF +#define ISO_8859_1_BE 0 // 190 ¾ FRACTION THREE QUARTERS +#define ISO_8859_1_BF 0 // 191 ¿ INVERTED QUESTION MARK +#define ISO_8859_1_C0 GRAVE_ACCENT_BITS + KEY_A + SHIFT_MASK // 192 À A GRAVE +#define ISO_8859_1_C1 ACUTE_ACCENT_BITS + KEY_A + SHIFT_MASK // 193 Á A ACUTE +#define ISO_8859_1_C2 CIRCUMFLEX_BITS + KEY_A + SHIFT_MASK // 194 Â A CIRCUMFLEX +#define ISO_8859_1_C3 0 // 195 Ã A TILDE +#define ISO_8859_1_C4 KEY_QUOTE + SHIFT_MASK // 196 Ä A DIAERESIS +#define ISO_8859_1_C5 0 // 197 Å A RING ABOVE +#define ISO_8859_1_C6 0 // 198 Æ AE +#define ISO_8859_1_C7 0 // 199 Ç C CEDILLA +#define ISO_8859_1_C8 GRAVE_ACCENT_BITS + KEY_E + SHIFT_MASK // 200 È E GRAVE +#define ISO_8859_1_C9 ACUTE_ACCENT_BITS + KEY_E + SHIFT_MASK // 201 É E ACUTE +#define ISO_8859_1_CA CIRCUMFLEX_BITS + KEY_E + SHIFT_MASK // 202 Ê E CIRCUMFLEX +#define ISO_8859_1_CB 0 // 203 Ë E DIAERESIS +#define ISO_8859_1_CC GRAVE_ACCENT_BITS + KEY_I + SHIFT_MASK // 204 Ì I GRAVE +#define ISO_8859_1_CD ACUTE_ACCENT_BITS + KEY_I + SHIFT_MASK // 205 Í I ACUTE +#define ISO_8859_1_CE CIRCUMFLEX_BITS + KEY_I + SHIFT_MASK // 206 Î I CIRCUMFLEX +#define ISO_8859_1_CF 0 // 207 Ï I DIAERESIS +#define ISO_8859_1_D0 0 // 208 Ð ETH +#define ISO_8859_1_D1 0 // 209 Ñ N TILDE +#define ISO_8859_1_D2 GRAVE_ACCENT_BITS + KEY_O + SHIFT_MASK // 210 Ò O GRAVE +#define ISO_8859_1_D3 ACUTE_ACCENT_BITS + KEY_O + SHIFT_MASK // 211 Ó O ACUTE +#define ISO_8859_1_D4 CIRCUMFLEX_BITS + KEY_O + SHIFT_MASK // 212 Ô O CIRCUMFLEX +#define ISO_8859_1_D5 0 // 213 Õ O TILDE +#define ISO_8859_1_D6 KEY_SEMICOLON + SHIFT_MASK // 214 Ö O DIAERESIS +#define ISO_8859_1_D7 0 // 215 × MULTIPLICATION +#define ISO_8859_1_D8 0 // 216 Ø O STROKE +#define ISO_8859_1_D9 GRAVE_ACCENT_BITS + KEY_U + SHIFT_MASK // 217 Ù U GRAVE +#define ISO_8859_1_DA ACUTE_ACCENT_BITS + KEY_U + SHIFT_MASK // 218 Ú U ACUTE +#define ISO_8859_1_DB CIRCUMFLEX_BITS + KEY_U + SHIFT_MASK // 219 Û U CIRCUMFLEX +#define ISO_8859_1_DC KEY_LEFT_BRACE + SHIFT_MASK // 220 Ü U DIAERESIS +#define ISO_8859_1_DD ACUTE_ACCENT_BITS + KEY_Z + SHIFT_MASK // 221 Ý Y ACUTE +#define ISO_8859_1_DE 0 // 222 Þ THORN +#define ISO_8859_1_DF KEY_MINUS // 223 ß SHARP S +#define ISO_8859_1_E0 GRAVE_ACCENT_BITS + KEY_A // 224 à a GRAVE +#define ISO_8859_1_E1 ACUTE_ACCENT_BITS + KEY_A // 225 á a ACUTE +#define ISO_8859_1_E2 CIRCUMFLEX_BITS + KEY_A // 226 â a CIRCUMFLEX +#define ISO_8859_1_E3 0 // 227 ã a TILDE +#define ISO_8859_1_E4 KEY_QUOTE // 228 ä a DIAERESIS +#define ISO_8859_1_E5 0 // 229 å a RING ABOVE +#define ISO_8859_1_E6 0 // 230 æ ae +#define ISO_8859_1_E7 0 // 231 ç c CEDILLA +#define ISO_8859_1_E8 GRAVE_ACCENT_BITS + KEY_E // 232 è e GRAVE +#define ISO_8859_1_E9 ACUTE_ACCENT_BITS + KEY_E // 233 é e ACUTE +#define ISO_8859_1_EA CIRCUMFLEX_BITS + KEY_E // 234 ê e CIRCUMFLEX +#define ISO_8859_1_EB 0 // 235 ë e DIAERESIS +#define ISO_8859_1_EC GRAVE_ACCENT_BITS + KEY_I // 236 ì i GRAVE +#define ISO_8859_1_ED ACUTE_ACCENT_BITS + KEY_I // 237 í i ACUTE +#define ISO_8859_1_EE CIRCUMFLEX_BITS + KEY_I // 238 î i CIRCUMFLEX +#define ISO_8859_1_EF 0 // 239 ï i DIAERESIS +#define ISO_8859_1_F0 0 // 240 ð ETH +#define ISO_8859_1_F1 0 // 241 ñ n TILDE +#define ISO_8859_1_F2 GRAVE_ACCENT_BITS + KEY_O // 242 ò o GRAVE +#define ISO_8859_1_F3 ACUTE_ACCENT_BITS + KEY_O // 243 ó o ACUTE +#define ISO_8859_1_F4 CIRCUMFLEX_BITS + KEY_O // 244 ô o CIRCUMFLEX +#define ISO_8859_1_F5 0 // 245 õ o TILDE +#define ISO_8859_1_F6 KEY_SEMICOLON // 246 ö o DIAERESIS +#define ISO_8859_1_F7 0 // 247 ÷ DIVISION +#define ISO_8859_1_F8 0 // 248 ø o STROKE +#define ISO_8859_1_F9 GRAVE_ACCENT_BITS + KEY_U // 249 ù u GRAVE +#define ISO_8859_1_FA ACUTE_ACCENT_BITS + KEY_U // 250 ú u ACUTE +#define ISO_8859_1_FB CIRCUMFLEX_BITS + KEY_U // 251 û u CIRCUMFLEX +#define ISO_8859_1_FC KEY_LEFT_BRACE // 252 ü u DIAERESIS +#define ISO_8859_1_FD ACUTE_ACCENT_BITS + KEY_Z // 253 ý y ACUTE +#define ISO_8859_1_FE 0 // 254 þ THORN +#define ISO_8859_1_FF 0 // 255 ÿ y DIAERESIS +#define UNICODE_20AC KEY_E + ALTGR_MASK // € Euro Sign +// not yet implemented +#define UNICODE_EXTRA00 0x20AC +#define KEYCODE_EXTRA00 KEY_E + ALTGR_MASK // 20AC € Euro Sign + +#endif // LAYOUT_GERMAN + + + +#ifdef LAYOUT_GERMAN_MAC + +#define SHIFT_MASK 0x0040 +#define ALTGR_MASK 0x0080 +#define DEADKEYS_MASK 0x0700 +#define ACUTE_ACCENT_BITS 0x0100 +#define GRAVE_ACCENT_BITS 0x0200 +#define CIRCUMFLEX_BITS 0x0300 +#define DIAERESIS_BITS 0x0400 +#define TILDE_BITS 0x0500 +#define KEYCODE_TYPE uint16_t +#define KEYCODE_MASK 0x07FF +#define DEADKEY_ACUTE_ACCENT KEY_EQUAL +#define DEADKEY_GRAVE_ACCENT KEY_EQUAL + SHIFT_MASK +#define DEADKEY_CIRCUMFLEX KEY_6 + SHIFT_MASK + ALTGR_MASK +#define DEADKEY_DIAERESIS KEY_U + ALTGR_MASK +#define DEADKEY_TILDE KEY_N + ALTGR_MASK +#define KEY_NON_US_100 63 + +#define ASCII_20 KEY_SPACE // 32 +#define ASCII_21 KEY_1 + SHIFT_MASK // 33 ! +#define ASCII_22 KEY_2 + SHIFT_MASK // 34 " +#define ASCII_23 KEY_BACKSLASH // 35 # ?? +#define ASCII_24 KEY_4 + SHIFT_MASK // 36 $ +#define ASCII_25 KEY_5 + SHIFT_MASK // 37 % +#define ASCII_26 KEY_6 + SHIFT_MASK // 38 & +#define ASCII_27 KEY_BACKSLASH + SHIFT_MASK // 39 ' +#define ASCII_28 KEY_8 + SHIFT_MASK // 40 ( +#define ASCII_29 KEY_9 + SHIFT_MASK // 41 ) +#define ASCII_2A KEY_RIGHT_BRACE + SHIFT_MASK // 42 * +#define ASCII_2B KEY_RIGHT_BRACE // 43 + +#define ASCII_2C KEY_COMMA // 44 , +#define ASCII_2D KEY_SLASH // 45 - +#define ASCII_2E KEY_PERIOD // 46 . +#define ASCII_2F KEY_7 + SHIFT_MASK // 47 / +#define ASCII_30 KEY_0 // 48 0 +#define ASCII_31 KEY_1 // 49 1 +#define ASCII_32 KEY_2 // 50 2 +#define ASCII_33 KEY_3 // 51 3 +#define ASCII_34 KEY_4 // 52 4 +#define ASCII_35 KEY_5 // 53 5 +#define ASCII_36 KEY_6 // 54 6 +#define ASCII_37 KEY_7 // 55 7 +#define ASCII_38 KEY_8 // 55 8 +#define ASCII_39 KEY_9 // 57 9 +#define ASCII_3A KEY_PERIOD + SHIFT_MASK // 58 : +#define ASCII_3B KEY_COMMA + SHIFT_MASK // 59 ; +#define ASCII_3C KEY_TILDE // 60 < +#define ASCII_3D KEY_0 + SHIFT_MASK // 61 = +#define ASCII_3E KEY_TILDE + SHIFT_MASK // 62 > +#define ASCII_3F KEY_MINUS + SHIFT_MASK // 63 ? +#define ASCII_40 KEY_Q + ALTGR_MASK // 64 @ +#define ASCII_41 KEY_A + SHIFT_MASK // 65 A +#define ASCII_42 KEY_B + SHIFT_MASK // 66 B +#define ASCII_43 KEY_C + SHIFT_MASK // 67 C +#define ASCII_44 KEY_D + SHIFT_MASK // 68 D +#define ASCII_45 KEY_E + SHIFT_MASK // 69 E +#define ASCII_46 KEY_F + SHIFT_MASK // 70 F +#define ASCII_47 KEY_G + SHIFT_MASK // 71 G +#define ASCII_48 KEY_H + SHIFT_MASK // 72 H +#define ASCII_49 KEY_I + SHIFT_MASK // 73 I +#define ASCII_4A KEY_J + SHIFT_MASK // 74 J +#define ASCII_4B KEY_K + SHIFT_MASK // 75 K +#define ASCII_4C KEY_L + SHIFT_MASK // 76 L +#define ASCII_4D KEY_M + SHIFT_MASK // 77 M +#define ASCII_4E KEY_N + SHIFT_MASK // 78 N +#define ASCII_4F KEY_O + SHIFT_MASK // 79 O +#define ASCII_50 KEY_P + SHIFT_MASK // 80 P +#define ASCII_51 KEY_Q + SHIFT_MASK // 81 Q +#define ASCII_52 KEY_R + SHIFT_MASK // 82 R +#define ASCII_53 KEY_S + SHIFT_MASK // 83 S +#define ASCII_54 KEY_T + SHIFT_MASK // 84 T +#define ASCII_55 KEY_U + SHIFT_MASK // 85 U +#define ASCII_56 KEY_V + SHIFT_MASK // 86 V +#define ASCII_57 KEY_W + SHIFT_MASK // 87 W +#define ASCII_58 KEY_X + SHIFT_MASK // 88 X +#define ASCII_59 KEY_Z + SHIFT_MASK // 89 Y +#define ASCII_5A KEY_Y + SHIFT_MASK // 90 Z +#define ASCII_5B KEY_5 + ALTGR_MASK // 91 [ +#define ASCII_5C KEY_7 + ALTGR_MASK + SHIFT_MASK // 92 +#define ASCII_5D KEY_6 + ALTGR_MASK // 93 ] +#define ASCII_5E CIRCUMFLEX_BITS + KEY_SPACE // 94 ^ +#define ASCII_5F KEY_SLASH + SHIFT_MASK // 95 _ +#define ASCII_60 GRAVE_ACCENT_BITS + KEY_SPACE // 96 ` +#define ASCII_61 KEY_A // 97 a +#define ASCII_62 KEY_B // 98 b +#define ASCII_63 KEY_C // 99 c +#define ASCII_64 KEY_D // 100 d +#define ASCII_65 KEY_E // 101 e +#define ASCII_66 KEY_F // 102 f +#define ASCII_67 KEY_G // 103 g +#define ASCII_68 KEY_H // 104 h +#define ASCII_69 KEY_I // 105 i +#define ASCII_6A KEY_J // 106 j +#define ASCII_6B KEY_K // 107 k +#define ASCII_6C KEY_L // 108 l +#define ASCII_6D KEY_M // 109 m +#define ASCII_6E KEY_N // 110 n +#define ASCII_6F KEY_O // 111 o +#define ASCII_70 KEY_P // 112 p +#define ASCII_71 KEY_Q // 113 q +#define ASCII_72 KEY_R // 114 r +#define ASCII_73 KEY_S // 115 s +#define ASCII_74 KEY_T // 116 t +#define ASCII_75 KEY_U // 117 u +#define ASCII_76 KEY_V // 118 v +#define ASCII_77 KEY_W // 119 w +#define ASCII_78 KEY_X // 120 x +#define ASCII_79 KEY_Z // 121 y +#define ASCII_7A KEY_Y // 122 z +#define ASCII_7B KEY_8 + ALTGR_MASK // 123 { +#define ASCII_7C KEY_7 + ALTGR_MASK // 124 | +#define ASCII_7D KEY_9 + ALTGR_MASK // 125 } +#define ASCII_7E TILDE_BITS + KEY_SPACE // 126 ~ +#define ASCII_7F KEY_BACKSPACE // 127 +#define ISO_8859_1_A0 KEY_SPACE // 160 Nonbreakng Space +#define ISO_8859_1_A1 KEY_1 + ALTGR_MASK // 161 ¡ Inverted Exclamation +#define ISO_8859_1_A2 KEY_4 + ALTGR_MASK // 162 ¢ Cent Sign +#define ISO_8859_1_A3 KEY_4 + SHIFT_MASK + ALTGR_MASK // 163 £ Pound Sign +#define ISO_8859_1_A4 KEY_E + ALTGR_MASK // 164 ¤ Currency Sign +#define ISO_8859_1_A5 KEY_Z + ALTGR_MASK // 165 ¥ YEN SIGN +#define ISO_8859_1_A6 0 // 166 ¦ BROKEN BAR +#define ISO_8859_1_A7 KEY_3 + SHIFT_MASK // 167 § SECTION SIGN +#define ISO_8859_1_A8 DIAERESIS_BITS + KEY_SPACE // 168 ¨ DIAERESIS +#define ISO_8859_1_A9 KEY_G + ALTGR_MASK // 169 © COPYRIGHT SIGN +#define ISO_8859_1_AA KEY_H + ALTGR_MASK // 170 ª FEMININE ORDINAL +#define ISO_8859_1_AB KEY_Q + ALTGR_MASK // 171 « LEFT DOUBLE ANGLE QUOTE +#define ISO_8859_1_AC 0 // 172 ¬ NOT SIGN +#define ISO_8859_1_AD 0 // 173 SOFT HYPHEN +#define ISO_8859_1_AE KEY_R + ALTGR_MASK // 174 ® REGISTERED SIGN +#define ISO_8859_1_AF KEY_0 + SHIFT_MASK + ALTGR_MASK // 175 ¯ MACRON +#define ISO_8859_1_B0 KEY_LEFT_BRACE + ALTGR_MASK + SHIFT_MASK// 176 ° DEGREE SIGN +#define ISO_8859_1_B1 KEY_RIGHT_BRACE + ALTGR_MASK // 177 ± PLUS-MINUS SIGN +#define ISO_8859_1_B2 0 // 178 ² SUPERSCRIPT TWO +#define ISO_8859_1_B3 0 // 179 ³ SUPERSCRIPT THREE +#define ISO_8859_1_B4 ACUTE_ACCENT_BITS + KEY_SPACE // 180 ´ ACUTE ACCENT +#define ISO_8859_1_B5 KEY_M + ALTGR_MASK // 181 µ MICRO SIGN +#define ISO_8859_1_B6 KEY_3 + ALTGR_MASK // 182 ¶ PILCROW SIGN +#define ISO_8859_1_B7 KEY_9 + SHIFT_MASK + ALTGR_MASK // 183 · MIDDLE DOT +#define ISO_8859_1_B8 0 // 184 ¸ CEDILLA +#define ISO_8859_1_B9 0 // 185 ¹ SUPERSCRIPT ONE +#define ISO_8859_1_BA KEY_J + ALTGR_MASK // 186 º MASCULINE ORDINAL +#define ISO_8859_1_BB KEY_Q + SHIFT_MASK + ALTGR_MASK // 187 » RIGHT DOUBLE ANGLE QUOTE +#define ISO_8859_1_BC 0 // 188 ¼ FRACTION ONE QUARTER +#define ISO_8859_1_BD 0 // 189 ½ FRACTION ONE HALF +#define ISO_8859_1_BE 0 // 190 ¾ FRACTION THREE QUARTERS +#define ISO_8859_1_BF KEY_MINUS + ALTGR_MASK // 191 ¿ INVERTED QUESTION MARK +#define ISO_8859_1_C0 GRAVE_ACCENT_BITS + KEY_A + SHIFT_MASK // 192 À A GRAVE +#define ISO_8859_1_C1 ACUTE_ACCENT_BITS + KEY_A + SHIFT_MASK // 193 Á A ACUTE +#define ISO_8859_1_C2 CIRCUMFLEX_BITS + KEY_A + SHIFT_MASK // 194 Â A CIRCUMFLEX +#define ISO_8859_1_C3 TILDE_BITS + KEY_A + SHIFT_MASK // 195 Ã A TILDE +#define ISO_8859_1_C4 KEY_QUOTE + SHIFT_MASK // 196 Ä A DIAERESIS +#define ISO_8859_1_C5 KEY_A + ALTGR_MASK + SHIFT_MASK // 197 Å A RING ABOVE +#define ISO_8859_1_C6 KEY_QUOTE + ALTGR_MASK + SHIFT_MASK // 198 Æ AE +#define ISO_8859_1_C7 KEY_C + ALTGR_MASK + SHIFT_MASK // 199 Ç C CEDILLA +#define ISO_8859_1_C8 GRAVE_ACCENT_BITS + KEY_E + SHIFT_MASK // 200 È E GRAVE +#define ISO_8859_1_C9 ACUTE_ACCENT_BITS + KEY_E + SHIFT_MASK // 201 É E ACUTE +#define ISO_8859_1_CA CIRCUMFLEX_BITS + KEY_E + SHIFT_MASK // 202 Ê E CIRCUMFLEX +#define ISO_8859_1_CB DIAERESIS_BITS + KEY_E + SHIFT_MASK // 203 Ë E DIAERESIS +#define ISO_8859_1_CC GRAVE_ACCENT_BITS + KEY_I + SHIFT_MASK // 204 Ì I GRAVE +#define ISO_8859_1_CD ACUTE_ACCENT_BITS + KEY_I + SHIFT_MASK // 205 Í I ACUTE +#define ISO_8859_1_CE CIRCUMFLEX_BITS + KEY_I + SHIFT_MASK // 206 Î I CIRCUMFLEX +#define ISO_8859_1_CF DIAERESIS_BITS + KEY_I + SHIFT_MASK // 207 Ï I DIAERESIS +#define ISO_8859_1_D0 0 // 208 Ð ETH +#define ISO_8859_1_D1 TILDE_BITS + KEY_N + SHIFT_MASK // 209 Ñ N TILDE +#define ISO_8859_1_D2 GRAVE_ACCENT_BITS + KEY_O + SHIFT_MASK // 210 Ò O GRAVE +#define ISO_8859_1_D3 ACUTE_ACCENT_BITS + KEY_O + SHIFT_MASK // 211 Ó O ACUTE +#define ISO_8859_1_D4 CIRCUMFLEX_BITS + KEY_O + SHIFT_MASK // 212 Ô O CIRCUMFLEX +#define ISO_8859_1_D5 TILDE_BITS + KEY_O + SHIFT_MASK // 213 Õ O TILDE +#define ISO_8859_1_D6 KEY_SEMICOLON + SHIFT_MASK // 214 Ö O DIAERESIS +#define ISO_8859_1_D7 0 // 215 × MULTIPLICATION +#define ISO_8859_1_D8 KEY_O + ALTGR_MASK + SHIFT_MASK // 216 Ø O STROKE +#define ISO_8859_1_D9 GRAVE_ACCENT_BITS + KEY_U + SHIFT_MASK // 217 Ù U GRAVE +#define ISO_8859_1_DA ACUTE_ACCENT_BITS + KEY_U + SHIFT_MASK // 218 Ú U ACUTE +#define ISO_8859_1_DB CIRCUMFLEX_BITS + KEY_U + SHIFT_MASK // 219 Û U CIRCUMFLEX +#define ISO_8859_1_DC KEY_LEFT_BRACE + SHIFT_MASK // 220 Ü U DIAERESIS +#define ISO_8859_1_DD ACUTE_ACCENT_BITS + KEY_Z + SHIFT_MASK // 221 Ý Y ACUTE +#define ISO_8859_1_DE 0 // 222 Þ THORN +#define ISO_8859_1_DF KEY_MINUS // 223 ß SHARP S +#define ISO_8859_1_E0 GRAVE_ACCENT_BITS + KEY_A // 224 à a GRAVE +#define ISO_8859_1_E1 ACUTE_ACCENT_BITS + KEY_A // 225 á a ACUTE +#define ISO_8859_1_E2 CIRCUMFLEX_BITS + KEY_A // 226 â a CIRCUMFLEX +#define ISO_8859_1_E3 TILDE_BITS + KEY_A // 227 ã a TILDE +#define ISO_8859_1_E4 KEY_QUOTE // 228 ä a DIAERESIS +#define ISO_8859_1_E5 KEY_A + ALTGR_MASK // 229 å a RING ABOVE +#define ISO_8859_1_E6 KEY_QUOTE + ALTGR_MASK // 230 æ ae +#define ISO_8859_1_E7 KEY_C + ALTGR_MASK // 231 ç c CEDILLA +#define ISO_8859_1_E8 GRAVE_ACCENT_BITS + KEY_E // 232 è e GRAVE +#define ISO_8859_1_E9 ACUTE_ACCENT_BITS + KEY_E // 233 é e ACUTE +#define ISO_8859_1_EA CIRCUMFLEX_BITS + KEY_E // 234 ê e CIRCUMFLEX +#define ISO_8859_1_EB DIAERESIS_BITS + KEY_E // 235 ë e DIAERESIS +#define ISO_8859_1_EC GRAVE_ACCENT_BITS + KEY_I // 236 ì i GRAVE +#define ISO_8859_1_ED ACUTE_ACCENT_BITS + KEY_I // 237 í i ACUTE +#define ISO_8859_1_EE CIRCUMFLEX_BITS + KEY_I // 238 î i CIRCUMFLEX +#define ISO_8859_1_EF DIAERESIS_BITS + KEY_I // 239 ï i DIAERESIS +#define ISO_8859_1_F0 0 // 240 ð ETH +#define ISO_8859_1_F1 TILDE_BITS + KEY_N // 241 ñ n TILDE +#define ISO_8859_1_F2 GRAVE_ACCENT_BITS + KEY_O // 242 ò o GRAVE +#define ISO_8859_1_F3 ACUTE_ACCENT_BITS + KEY_O // 243 ó o ACUTE +#define ISO_8859_1_F4 CIRCUMFLEX_BITS + KEY_O // 244 ô o CIRCUMFLEX +#define ISO_8859_1_F5 TILDE_BITS + KEY_O // 245 õ o TILDE +#define ISO_8859_1_F6 KEY_SEMICOLON // 246 ö o DIAERESIS +#define ISO_8859_1_F7 0 // 247 ÷ DIVISION +#define ISO_8859_1_F8 KEY_O + ALTGR_MASK // 248 ø o STROKE +#define ISO_8859_1_F9 GRAVE_ACCENT_BITS + KEY_U // 249 ù u GRAVE +#define ISO_8859_1_FA ACUTE_ACCENT_BITS + KEY_U // 250 ú u ACUTE +#define ISO_8859_1_FB CIRCUMFLEX_BITS + KEY_U // 251 û u CIRCUMFLEX +#define ISO_8859_1_FC KEY_LEFT_BRACE // 252 ü u DIAERESIS +#define ISO_8859_1_FD ACUTE_ACCENT_BITS + KEY_Z // 253 ý y ACUTE +#define ISO_8859_1_FE 0 // 254 þ THORN +#define ISO_8859_1_FF DIAERESIS_BITS + KEY_Z // 255 ÿ y DIAERESIS +#define UNICODE_20AC KEY_E + ALTGR_MASK // € Euro Sign +// not yet implemented +#define UNICODE_EXTRA00 0x20AC +#define KEYCODE_EXTRA00 KEY_E + ALTGR_MASK // 20AC € Euro Sign + +#endif // LAYOUT_GERMAN_MAC + + + + + + +#ifdef LAYOUT_CANADIAN_FRENCH + +#define SHIFT_MASK 0x0040 +#define ALTGR_MASK 0x0080 +#define DEADKEYS_MASK 0x0700 +#define CIRCUMFLEX_BITS 0x0100 +#define ACUTE_ACCENT_BITS 0x0200 +#define GRAVE_ACCENT_BITS 0x0300 +#define DIAERESIS_BITS 0x0400 +#define CEDILLA_BITS 0x0500 + +#define KEYCODE_TYPE uint16_t +#define KEYCODE_MASK 0x07FF +#define DEADKEY_CIRCUMFLEX KEY_LEFT_BRACE +#define DEADKEY_ACUTE_ACCENT KEY_SLASH + ALTGR_MASK +#define DEADKEY_GRAVE_ACCENT KEY_QUOTE +#define DEADKEY_DIAERESIS KEY_RIGHT_BRACE + SHIFT_MASK +#define DEADKEY_CEDILLA KEY_RIGHT_BRACE +#define KEY_NON_US_100 63 + +#define ASCII_20 KEY_SPACE // 32 +#define ASCII_21 KEY_1 + SHIFT_MASK // 33 ! +#define ASCII_22 KEY_2 + SHIFT_MASK // 34 " +#define ASCII_23 KEY_TILDE + SHIFT_MASK // 35 # +#define ASCII_24 KEY_4 + SHIFT_MASK // 36 $ +#define ASCII_25 KEY_5 + SHIFT_MASK // 37 % +#define ASCII_26 KEY_7 + SHIFT_MASK // 38 & +#define ASCII_27 KEY_COMMA + SHIFT_MASK // 39 ' +//#define ASCII_27 ACUTE_ACCENT_BITS + KEY_SPACE // 39 ' +#define ASCII_28 KEY_9 + SHIFT_MASK // 40 ( +#define ASCII_29 KEY_0 + SHIFT_MASK // 41 ) +#define ASCII_2A KEY_8 + SHIFT_MASK // 42 * +#define ASCII_2B KEY_EQUAL + SHIFT_MASK // 43 + +#define ASCII_2C KEY_COMMA // 44 , +#define ASCII_2D KEY_MINUS // 45 - +#define ASCII_2E KEY_PERIOD // 46 . +#define ASCII_2F KEY_3 + SHIFT_MASK // 47 / +#define ASCII_30 KEY_0 // 48 0 +#define ASCII_31 KEY_1 // 49 1 +#define ASCII_32 KEY_2 // 50 2 +#define ASCII_33 KEY_3 // 51 3 +#define ASCII_34 KEY_4 // 52 4 +#define ASCII_35 KEY_5 // 53 5 +#define ASCII_36 KEY_6 // 54 6 +#define ASCII_37 KEY_7 // 55 7 +#define ASCII_38 KEY_8 // 55 8 +#define ASCII_39 KEY_9 // 57 9 +#define ASCII_3A KEY_SEMICOLON + SHIFT_MASK // 58 : +#define ASCII_3B KEY_SEMICOLON // 59 ; +#define ASCII_3C KEY_BACKSLASH // 60 < +#define ASCII_3D KEY_EQUAL // 61 = +#define ASCII_3E KEY_BACKSLASH + SHIFT_MASK // 62 > +#define ASCII_3F KEY_6 + SHIFT_MASK // 63 ? +#define ASCII_40 KEY_2 + ALTGR_MASK // 64 @ +#define ASCII_41 KEY_A + SHIFT_MASK // 65 A +#define ASCII_42 KEY_B + SHIFT_MASK // 66 B +#define ASCII_43 KEY_C + SHIFT_MASK // 67 C +#define ASCII_44 KEY_D + SHIFT_MASK // 68 D +#define ASCII_45 KEY_E + SHIFT_MASK // 69 E +#define ASCII_46 KEY_F + SHIFT_MASK // 70 F +#define ASCII_47 KEY_G + SHIFT_MASK // 71 G +#define ASCII_48 KEY_H + SHIFT_MASK // 72 H +#define ASCII_49 KEY_I + SHIFT_MASK // 73 I +#define ASCII_4A KEY_J + SHIFT_MASK // 74 J +#define ASCII_4B KEY_K + SHIFT_MASK // 75 K +#define ASCII_4C KEY_L + SHIFT_MASK // 76 L +#define ASCII_4D KEY_M + SHIFT_MASK // 77 M +#define ASCII_4E KEY_N + SHIFT_MASK // 78 N +#define ASCII_4F KEY_O + SHIFT_MASK // 79 O +#define ASCII_50 KEY_P + SHIFT_MASK // 80 P +#define ASCII_51 KEY_Q + SHIFT_MASK // 81 Q +#define ASCII_52 KEY_R + SHIFT_MASK // 82 R +#define ASCII_53 KEY_S + SHIFT_MASK // 83 S +#define ASCII_54 KEY_T + SHIFT_MASK // 84 T +#define ASCII_55 KEY_U + SHIFT_MASK // 85 U +#define ASCII_56 KEY_V + SHIFT_MASK // 86 V +#define ASCII_57 KEY_W + SHIFT_MASK // 87 W +#define ASCII_58 KEY_X + SHIFT_MASK // 88 X +#define ASCII_59 KEY_Y + SHIFT_MASK // 89 Y +#define ASCII_5A KEY_Z + SHIFT_MASK // 90 Z +#define ASCII_5B KEY_LEFT_BRACE + ALTGR_MASK // 91 [ +#define ASCII_5C KEY_TILDE + ALTGR_MASK // 92 +#define ASCII_5D KEY_RIGHT_BRACE + ALTGR_MASK // 93 ] +#define ASCII_5E CIRCUMFLEX_BITS + KEY_SPACE // 94 ^ +#define ASCII_5F KEY_MINUS + SHIFT_MASK // 95 _ +#define ASCII_60 GRAVE_ACCENT_BITS + KEY_SPACE // 96 ` +#define ASCII_61 KEY_A // 97 a +#define ASCII_62 KEY_B // 98 b +#define ASCII_63 KEY_C // 99 c +#define ASCII_64 KEY_D // 100 d +#define ASCII_65 KEY_E // 101 e +#define ASCII_66 KEY_F // 102 f +#define ASCII_67 KEY_G // 103 g +#define ASCII_68 KEY_H // 104 h +#define ASCII_69 KEY_I // 105 i +#define ASCII_6A KEY_J // 106 j +#define ASCII_6B KEY_K // 107 k +#define ASCII_6C KEY_L // 108 l +#define ASCII_6D KEY_M // 109 m +#define ASCII_6E KEY_N // 110 n +#define ASCII_6F KEY_O // 111 o +#define ASCII_70 KEY_P // 112 p +#define ASCII_71 KEY_Q // 113 q +#define ASCII_72 KEY_R // 114 r +#define ASCII_73 KEY_S // 115 s +#define ASCII_74 KEY_T // 116 t +#define ASCII_75 KEY_U // 117 u +#define ASCII_76 KEY_V // 118 v +#define ASCII_77 KEY_W // 119 w +#define ASCII_78 KEY_X // 120 x +#define ASCII_79 KEY_Y // 121 y +#define ASCII_7A KEY_Z // 122 z +#define ASCII_7B KEY_QUOTE + ALTGR_MASK // 123 { +#define ASCII_7C KEY_TILDE + SHIFT_MASK // 124 | +#define ASCII_7D KEY_BACKSLASH + ALTGR_MASK // 125 } +#define ASCII_7E KEY_SEMICOLON + ALTGR_MASK // 126 ~ +#define ASCII_7F KEY_BACKSPACE // 127 +#define ISO_8859_1_A0 KEY_SPACE // 160 Nonbreakng Space +#define ISO_8859_1_A1 0 // 161 ¡ Inverted Exclamation +#define ISO_8859_1_A2 KEY_4 + ALTGR_MASK // 162 ¢ Cent SIGN +#define ISO_8859_1_A3 KEY_3 + ALTGR_MASK // 163 £ Pound Sign +#define ISO_8859_1_A4 KEY_5 + ALTGR_MASK // 164 ¤ Currency or Euro Sign +#define ISO_8859_1_A5 0 // 165 ¥ YEN SIGN +#define ISO_8859_1_A6 KEY_7 + ALTGR_MASK // 166 ¦ BROKEN BAR +#define ISO_8859_1_A7 KEY_O + ALTGR_MASK // 167 § SECTION SIGN +#define ISO_8859_1_A8 0 // 168 ¨ DIAERESIS +#define ISO_8859_1_A9 0 // 169 © COPYRIGHT SIGN +#define ISO_8859_1_AA 0 // 170 ª FEMININE ORDINAL +#define ISO_8859_1_AB KEY_NON_US_100 // 171 « LEFT DOUBLE ANGLE QUOTE +#define ISO_8859_1_AC KEY_6 + ALTGR_MASK // 172 ¬ NOT SIGN +#define ISO_8859_1_AD KEY_PERIOD + ALTGR_MASK // 173 SOFT HYPHEN +#define ISO_8859_1_AE 0 // 174 ® REGISTERED SIGN +#define ISO_8859_1_AF KEY_COMMA + ALTGR_MASK // 175 ¯ MACRON +#define ISO_8859_1_B0 KEY_NON_US_100 + ALTGR_MASK // 176 ° DEGREE SIGN +#define ISO_8859_1_B1 KEY_1 + ALTGR_MASK // 177 ± PLUS-MINUS SIGN +#define ISO_8859_1_B2 KEY_8 + ALTGR_MASK // 178 ² SUPERSCRIPT TWO +#define ISO_8859_1_B3 KEY_9 + ALTGR_MASK // 179 ³ SUPERSCRIPT THREE +#define ISO_8859_1_B4 0 // 180 ´ ACUTE ACCENT +#define ISO_8859_1_B5 KEY_M + ALTGR_MASK // 181 µ MICRO SIGN +#define ISO_8859_1_B6 KEY_P + ALTGR_MASK // 182 ¶ PILCROW SIGN +#define ISO_8859_1_B7 0 // 183 · MIDDLE DOT +#define ISO_8859_1_B8 0 // 184 ¸ CEDILLA +#define ISO_8859_1_B9 0 // 185 ¹ SUPERSCRIPT ONE +#define ISO_8859_1_BA 0 // 186 º MASCULINE ORDINAL +#define ISO_8859_1_BB KEY_NON_US_100 + SHIFT_MASK // 187 » RIGHT DOUBLE ANGLE QUOTE +#define ISO_8859_1_BC KEY_0 + ALTGR_MASK // 188 ¼ FRACTION ONE QUARTER +#define ISO_8859_1_BD KEY_MINUS + ALTGR_MASK // 189 ½ FRACTION ONE HALF +#define ISO_8859_1_BE KEY_EQUAL + ALTGR_MASK // 190 ¾ FRACTION THREE QUARTERS +#define ISO_8859_1_BF 0 // 191 ¿ INVERTED QUESTION MARK +#define ISO_8859_1_C0 GRAVE_ACCENT_BITS + KEY_A + SHIFT_MASK // 192 À A GRAVE +#define ISO_8859_1_C1 ACUTE_ACCENT_BITS + KEY_A + SHIFT_MASK // 193 Á A ACUTE +#define ISO_8859_1_C2 CIRCUMFLEX_BITS + KEY_A + SHIFT_MASK // 194 Â A CIRCUMFLEX +#define ISO_8859_1_C3 0 // 195 Ã A TILDE +#define ISO_8859_1_C4 DIAERESIS_BITS + KEY_A + SHIFT_MASK // 196 Ä A DIAERESIS +#define ISO_8859_1_C5 0 // 197 Å A RING ABOVE +#define ISO_8859_1_C6 0 // 198 Æ AE +#define ISO_8859_1_C7 CEDILLA_BITS + KEY_C + SHIFT_MASK // 199 Ç C CEDILLA +#define ISO_8859_1_C8 GRAVE_ACCENT_BITS + KEY_E + SHIFT_MASK // 200 È E GRAVE +#define ISO_8859_1_C9 KEY_SLASH + SHIFT_MASK // 201 É E ACUTE +#define ISO_8859_1_CA CIRCUMFLEX_BITS + KEY_E + SHIFT_MASK // 202 Ê E CIRCUMFLEX +#define ISO_8859_1_CB DIAERESIS_BITS + KEY_E + SHIFT_MASK // 203 Ë E DIAERESIS +#define ISO_8859_1_CC GRAVE_ACCENT_BITS + KEY_I + SHIFT_MASK // 204 Ì I GRAVE +#define ISO_8859_1_CD ACUTE_ACCENT_BITS + KEY_I + SHIFT_MASK // 205 Í I ACUTE +#define ISO_8859_1_CE CIRCUMFLEX_BITS + KEY_I + SHIFT_MASK // 206 Î I CIRCUMFLEX +#define ISO_8859_1_CF DIAERESIS_BITS + KEY_I + SHIFT_MASK // 207 Ï I DIAERESIS +#define ISO_8859_1_D0 0 // 208 Ð ETH +#define ISO_8859_1_D1 0 // 209 Ñ N TILDE +#define ISO_8859_1_D2 GRAVE_ACCENT_BITS + KEY_O + SHIFT_MASK // 210 Ò O GRAVE +#define ISO_8859_1_D3 ACUTE_ACCENT_BITS + KEY_O + SHIFT_MASK // 211 Ó O ACUTE +#define ISO_8859_1_D4 CIRCUMFLEX_BITS + KEY_O + SHIFT_MASK // 212 Ô O CIRCUMFLEX +#define ISO_8859_1_D5 0 // 213 Õ O TILDE +#define ISO_8859_1_D6 DIAERESIS_BITS + KEY_O + SHIFT_MASK // 214 Ö O DIAERESIS +#define ISO_8859_1_D7 0 // 215 × MULTIPLICATION +#define ISO_8859_1_D8 0 // 216 Ø O STROKE +#define ISO_8859_1_D9 GRAVE_ACCENT_BITS + KEY_U + SHIFT_MASK // 217 Ù U GRAVE +#define ISO_8859_1_DA ACUTE_ACCENT_BITS + KEY_U + SHIFT_MASK // 218 Ú U ACUTE +#define ISO_8859_1_DB CIRCUMFLEX_BITS + KEY_U + SHIFT_MASK // 219 Û U CIRCUMFLEX +#define ISO_8859_1_DC DIAERESIS_BITS + KEY_U // 220 Ü U DIAERESIS +#define ISO_8859_1_DD ACUTE_ACCENT_BITS + KEY_Y + SHIFT_MASK // 221 Ý Y ACUTE +#define ISO_8859_1_DE 0 // 222 Þ THORN +#define ISO_8859_1_DF 0 // 223 ß SHARP S +#define ISO_8859_1_E0 GRAVE_ACCENT_BITS + KEY_A // 224 à a GRAVE +#define ISO_8859_1_E1 ACUTE_ACCENT_BITS + KEY_A // 225 á a ACUTE +#define ISO_8859_1_E2 CIRCUMFLEX_BITS + KEY_A // 226 â a CIRCUMFLEX +#define ISO_8859_1_E3 0 // 227 ã a TILDE +#define ISO_8859_1_E4 DIAERESIS_BITS + KEY_A // 228 ä a DIAERESIS +#define ISO_8859_1_E5 0 // 229 å a RING ABOVE +#define ISO_8859_1_E6 0 // 230 æ ae +#define ISO_8859_1_E7 CEDILLA_BITS + KEY_C // 231 ç c CEDILLA +#define ISO_8859_1_E8 GRAVE_ACCENT_BITS + KEY_E // 232 è e GRAVE +#define ISO_8859_1_E9 KEY_SLASH // 233 é e ACUTE +#define ISO_8859_1_EA CIRCUMFLEX_BITS + KEY_E // 234 ê e CIRCUMFLEX +#define ISO_8859_1_EB DIAERESIS_BITS + KEY_E // 235 ë e DIAERESIS +#define ISO_8859_1_EC GRAVE_ACCENT_BITS + KEY_I // 236 ì i GRAVE +#define ISO_8859_1_ED ACUTE_ACCENT_BITS + KEY_I // 237 í i ACUTE +#define ISO_8859_1_EE CIRCUMFLEX_BITS + KEY_I // 238 î i CIRCUMFLEX +#define ISO_8859_1_EF DIAERESIS_BITS + KEY_I // 239 ï i DIAERESIS +#define ISO_8859_1_F0 0 // 240 ð ETH +#define ISO_8859_1_F1 0 // 241 ñ n TILDE +#define ISO_8859_1_F2 GRAVE_ACCENT_BITS + KEY_O // 242 ò o GRAVE +#define ISO_8859_1_F3 ACUTE_ACCENT_BITS + KEY_O // 243 ó o ACUTE +#define ISO_8859_1_F4 CIRCUMFLEX_BITS + KEY_O // 244 ô o CIRCUMFLEX +#define ISO_8859_1_F5 0 // 245 õ o TILDE +#define ISO_8859_1_F6 DIAERESIS_BITS + KEY_O // 246 ö o DIAERESIS +#define ISO_8859_1_F7 0 // 247 ÷ DIVISION +#define ISO_8859_1_F8 0 // 248 ø o STROKE +#define ISO_8859_1_F9 GRAVE_ACCENT_BITS + KEY_U // 249 ù u GRAVE +#define ISO_8859_1_FA ACUTE_ACCENT_BITS + KEY_U // 250 ú u ACUTE +#define ISO_8859_1_FB CIRCUMFLEX_BITS + KEY_U // 251 û u CIRCUMFLEX +#define ISO_8859_1_FC DIAERESIS_BITS + KEY_U // 252 ü u DIAERESIS +#define ISO_8859_1_FD ACUTE_ACCENT_BITS + KEY_Y // 253 ý y ACUTE +#define ISO_8859_1_FE 0 // 254 þ THORN +#define ISO_8859_1_FF DIAERESIS_BITS + KEY_Y // 255 ÿ y DIAERESIS + +#endif // LAYOUT_CANADIAN_FRENCH + + + +#ifdef LAYOUT_CANADIAN_MULTILINGUAL + +#define SHIFT_MASK 0x0040 +#define ALTGR_MASK 0x0080 +#define RCTRL_MASK 0x0800 +#define DEADKEYS_MASK 0x0700 +#define CIRCUMFLEX_BITS 0x0100 +#define DIAERESIS_BITS 0x0200 +#define ACUTE_ACCENT_BITS 0x0300 +#define CEDILLA_BITS 0x0400 +#define GRAVE_ACCENT_BITS 0x0500 +#define TILDE_BITS 0x0600 +#define RING_ABOVE_BITS 0x0700 +#define KEYCODE_TYPE uint16_t +#define KEYCODE_MASK 0x0FFF +#define DEADKEY_CIRCUMFLEX KEY_LEFT_BRACE +#define DEADKEY_DIAERESIS KEY_LEFT_BRACE + SHIFT_MASK +#define DEADKEY_ACUTE_ACCENT KEY_SEMICOLON + RCTRL_MASK +#define DEADKEY_CEDILLA KEY_EQUAL + RCTRL_MASK +#define DEADKEY_GRAVE_ACCENT KEY_LEFT_BRACE + ALTGR_MASK +#define DEADKEY_TILDE KEY_RIGHT_BRACE + ALTGR_MASK +#define DEADKEY_RING_ABOVE KEY_LEFT_BRACE + SHIFT_MASK + RCTRL_MASK +#define KEY_NON_US_100 63 + +#define ASCII_20 KEY_SPACE // 32 +#define ASCII_21 KEY_1 + SHIFT_MASK // 33 ! +#define ASCII_22 KEY_PERIOD + SHIFT_MASK // 34 " +#define ASCII_23 KEY_3 + SHIFT_MASK // 35 # +#define ASCII_24 KEY_4 + SHIFT_MASK // 36 $ +#define ASCII_25 KEY_5 + SHIFT_MASK // 37 % +#define ASCII_26 KEY_7 + SHIFT_MASK // 38 & +#define ASCII_27 KEY_COMMA + SHIFT_MASK // 39 ' +#define ASCII_28 KEY_9 + SHIFT_MASK // 40 ( +#define ASCII_29 KEY_0 + SHIFT_MASK // 41 ) +#define ASCII_2A KEY_8 + SHIFT_MASK // 42 * +#define ASCII_2B KEY_EQUAL + SHIFT_MASK // 43 + +#define ASCII_2C KEY_COMMA // 44 , +#define ASCII_2D KEY_MINUS // 45 - +#define ASCII_2E KEY_PERIOD // 46 . +#define ASCII_2F KEY_TILDE // 47 / +#define ASCII_30 KEY_0 // 48 0 +#define ASCII_31 KEY_1 // 49 1 +#define ASCII_32 KEY_2 // 50 2 +#define ASCII_33 KEY_3 // 51 3 +#define ASCII_34 KEY_4 // 52 4 +#define ASCII_35 KEY_5 // 53 5 +#define ASCII_36 KEY_6 // 54 6 +#define ASCII_37 KEY_7 // 55 7 +#define ASCII_38 KEY_8 // 55 8 +#define ASCII_39 KEY_9 // 57 9 +#define ASCII_3A KEY_SEMICOLON + SHIFT_MASK // 58 : +#define ASCII_3B KEY_SEMICOLON // 59 ; +#define ASCII_3C KEY_COMMA + ALTGR_MASK // 60 < +#define ASCII_3D KEY_EQUAL // 61 = +#define ASCII_3E KEY_PERIOD + ALTGR_MASK // 62 > +#define ASCII_3F KEY_6 + SHIFT_MASK // 63 ? +#define ASCII_40 KEY_2 + SHIFT_MASK // 64 @ +#define ASCII_41 KEY_A + SHIFT_MASK // 65 A +#define ASCII_42 KEY_B + SHIFT_MASK // 66 B +#define ASCII_43 KEY_C + SHIFT_MASK // 67 C +#define ASCII_44 KEY_D + SHIFT_MASK // 68 D +#define ASCII_45 KEY_E + SHIFT_MASK // 69 E +#define ASCII_46 KEY_F + SHIFT_MASK // 70 F +#define ASCII_47 KEY_G + SHIFT_MASK // 71 G +#define ASCII_48 KEY_H + SHIFT_MASK // 72 H +#define ASCII_49 KEY_I + SHIFT_MASK // 73 I +#define ASCII_4A KEY_J + SHIFT_MASK // 74 J +#define ASCII_4B KEY_K + SHIFT_MASK // 75 K +#define ASCII_4C KEY_L + SHIFT_MASK // 76 L +#define ASCII_4D KEY_M + SHIFT_MASK // 77 M +#define ASCII_4E KEY_N + SHIFT_MASK // 78 N +#define ASCII_4F KEY_O + SHIFT_MASK // 79 O +#define ASCII_50 KEY_P + SHIFT_MASK // 80 P +#define ASCII_51 KEY_Q + SHIFT_MASK // 81 Q +#define ASCII_52 KEY_R + SHIFT_MASK // 82 R +#define ASCII_53 KEY_S + SHIFT_MASK // 83 S +#define ASCII_54 KEY_T + SHIFT_MASK // 84 T +#define ASCII_55 KEY_U + SHIFT_MASK // 85 U +#define ASCII_56 KEY_V + SHIFT_MASK // 86 V +#define ASCII_57 KEY_W + SHIFT_MASK // 87 W +#define ASCII_58 KEY_X + SHIFT_MASK // 88 X +#define ASCII_59 KEY_Y + SHIFT_MASK // 89 Y +#define ASCII_5A KEY_Z + SHIFT_MASK // 90 Z +#define ASCII_5B KEY_9 + ALTGR_MASK // 91 [ +#define ASCII_5C KEY_TILDE + SHIFT_MASK // 92 +#define ASCII_5D KEY_0 + ALTGR_MASK // 93 ] +#define ASCII_5E CIRCUMFLEX_BITS + KEY_SPACE // 94 ^ +#define ASCII_5F KEY_MINUS + SHIFT_MASK // 95 _ +#define ASCII_60 GRAVE_ACCENT_BITS + KEY_SPACE // 96 ` +#define ASCII_61 KEY_A // 97 a +#define ASCII_62 KEY_B // 98 b +#define ASCII_63 KEY_C // 99 c +#define ASCII_64 KEY_D // 100 d +#define ASCII_65 KEY_E // 101 e +#define ASCII_66 KEY_F // 102 f +#define ASCII_67 KEY_G // 103 g +#define ASCII_68 KEY_H // 104 h +#define ASCII_69 KEY_I // 105 i +#define ASCII_6A KEY_J // 106 j +#define ASCII_6B KEY_K // 107 k +#define ASCII_6C KEY_L // 108 l +#define ASCII_6D KEY_M // 109 m +#define ASCII_6E KEY_N // 110 n +#define ASCII_6F KEY_O // 111 o +#define ASCII_70 KEY_P // 112 p +#define ASCII_71 KEY_Q // 113 q +#define ASCII_72 KEY_R // 114 r +#define ASCII_73 KEY_S // 115 s +#define ASCII_74 KEY_T // 116 t +#define ASCII_75 KEY_U // 117 u +#define ASCII_76 KEY_V // 118 v +#define ASCII_77 KEY_W // 119 w +#define ASCII_78 KEY_X // 120 x +#define ASCII_79 KEY_Y // 121 y +#define ASCII_7A KEY_Z // 122 z +#define ASCII_7B KEY_7 + ALTGR_MASK // 123 { +#define ASCII_7C KEY_TILDE + ALTGR_MASK // 124 | +#define ASCII_7D KEY_8 + ALTGR_MASK // 125 } +#define ASCII_7E KEY_RIGHT_BRACE + RCTRL_MASK // 126 ~ +#define ASCII_7F KEY_BACKSPACE // 127 +#define ISO_8859_1_A0 KEY_SPACE + ALTGR_MASK // 160 Nonbreakng Space +#define ISO_8859_1_A1 KEY_1 + SHIFT_MASK + RCTRL_MASK // 161 ¡ Inverted Exclamation +#define ISO_8859_1_A2 KEY_C + RCTRL_MASK // 162 ¢ Cent SIGN +#define ISO_8859_1_A3 KEY_3 + SHIFT_MASK + RCTRL_MASK // 163 £ Pound Sign +#define ISO_8859_1_A4 KEY_4 + SHIFT_MASK + RCTRL_MASK // 164 ¤ Currency or Euro Sign +#define ISO_8859_1_A5 KEY_Y + SHIFT_MASK + RCTRL_MASK // 165 ¥ YEN SIGN +#define ISO_8859_1_A6 KEY_NON_US_100 + SHIFT_MASK + RCTRL_MASK// 166 ¦ BROKEN BAR +#define ISO_8859_1_A7 KEY_S + SHIFT_MASK + RCTRL_MASK // 167 § SECTION SIGN +#define ISO_8859_1_A8 DIAERESIS_BITS + KEY_SPACE // 168 ¨ DIAERESIS +#define ISO_8859_1_A9 KEY_C + SHIFT_MASK + RCTRL_MASK // 169 © COPYRIGHT SIGN +#define ISO_8859_1_AA KEY_F + SHIFT_MASK + RCTRL_MASK // 170 ª FEMININE ORDINAL +#define ISO_8859_1_AB KEY_Z + ALTGR_MASK // 171 « LEFT DOUBLE ANGLE QUOTE +#define ISO_8859_1_AC KEY_EQUAL + ALTGR_MASK // 172 ¬ NOT SIGN +#define ISO_8859_1_AD KEY_TILDE + SHIFT_MASK + RCTRL_MASK // 173 SOFT HYPHEN +#define ISO_8859_1_AE KEY_R + SHIFT_MASK + RCTRL_MASK // 174 ® REGISTERED SIGN +#define ISO_8859_1_AF 0 // special dead key - no implemented // 175 ¯ MACRON +#define ISO_8859_1_B0 KEY_SEMICOLON + ALTGR_MASK // 176 ° DEGREE SIGN +#define ISO_8859_1_B1 KEY_9 + SHIFT_MASK + RCTRL_MASK // 177 ± PLUS-MINUS SIGN +#define ISO_8859_1_B2 KEY_2 + RCTRL_MASK // 178 ² SUPERSCRIPT TWO +#define ISO_8859_1_B3 KEY_3 + RCTRL_MASK // 179 ³ SUPERSCRIPT THREE +#define ISO_8859_1_B4 ACUTE_ACCENT_BITS + KEY_SPACE // 180 ´ ACUTE ACCENT +#define ISO_8859_1_B5 KEY_M + RCTRL_MASK // 181 µ MICRO SIGN +#define ISO_8859_1_B6 KEY_R + RCTRL_MASK // 182 ¶ PILCROW SIGN +#define ISO_8859_1_B7 0 // 183 · MIDDLE DOT +#define ISO_8859_1_B8 CEDILLA_BITS + KEY_SPACE // 184 ¸ CEDILLA +#define ISO_8859_1_B9 KEY_1 + RCTRL_MASK // 185 ¹ SUPERSCRIPT ONE +#define ISO_8859_1_BA KEY_M + SHIFT_MASK + RCTRL_MASK // 186 º MASCULINE ORDINAL +#define ISO_8859_1_BB KEY_X + ALTGR_MASK // 187 » RIGHT DOUBLE ANGLE QUOTE +#define ISO_8859_1_BC KEY_4 + RCTRL_MASK // 188 ¼ FRACTION ONE QUARTER +#define ISO_8859_1_BD KEY_5 + RCTRL_MASK // 189 ½ FRACTION ONE HALF +#define ISO_8859_1_BE KEY_6 + RCTRL_MASK // 190 ¾ FRACTION THREE QUARTERS +#define ISO_8859_1_BF KEY_MINUS + SHIFT_MASK + RCTRL_MASK // 191 ¿ INVERTED QUESTION MARK +#define ISO_8859_1_C0 KEY_BACKSLASH + SHIFT_MASK // 192 À A GRAVE +#define ISO_8859_1_C1 ACUTE_ACCENT_BITS + KEY_A + SHIFT_MASK // 193 Á A ACUTE +#define ISO_8859_1_C2 CIRCUMFLEX_BITS + KEY_A + SHIFT_MASK // 194 Â A CIRCUMFLEX +#define ISO_8859_1_C3 TILDE_BITS + KEY_A + SHIFT_MASK // 195 Ã A TILDE +#define ISO_8859_1_C4 DIAERESIS_BITS + KEY_A + SHIFT_MASK // 196 Ä A DIAERESIS +#define ISO_8859_1_C5 RING_ABOVE_BITS + KEY_A + SHIFT_MASK // 197 Å A RING ABOVE +#define ISO_8859_1_C6 KEY_A + SHIFT_MASK + RCTRL_MASK // 198 Æ AE +#define ISO_8859_1_C7 KEY_RIGHT_BRACE + SHIFT_MASK // 199 Ç C CEDILLA +#define ISO_8859_1_C8 KEY_QUOTE + SHIFT_MASK // 200 È E GRAVE +#define ISO_8859_1_C9 KEY_SLASH + SHIFT_MASK // 201 É E ACUTE +#define ISO_8859_1_CA CIRCUMFLEX_BITS + KEY_E + SHIFT_MASK // 202 Ê E CIRCUMFLEX +#define ISO_8859_1_CB DIAERESIS_BITS + KEY_E + SHIFT_MASK // 203 Ë E DIAERESIS +#define ISO_8859_1_CC GRAVE_ACCENT_BITS + KEY_I + SHIFT_MASK // 204 Ì I GRAVE +#define ISO_8859_1_CD ACUTE_ACCENT_BITS + KEY_I + SHIFT_MASK // 205 Í I ACUTE +#define ISO_8859_1_CE CIRCUMFLEX_BITS + KEY_I + SHIFT_MASK // 206 Î I CIRCUMFLEX +#define ISO_8859_1_CF DIAERESIS_BITS + KEY_I + SHIFT_MASK // 207 Ï I DIAERESIS +#define ISO_8859_1_D0 KEY_D + SHIFT_MASK + RCTRL_MASK // 208 Ð ETH +#define ISO_8859_1_D1 TILDE_BITS + KEY_N + SHIFT_MASK // 209 Ñ N TILDE +#define ISO_8859_1_D2 GRAVE_ACCENT_BITS + KEY_O + SHIFT_MASK // 210 Ò O GRAVE +#define ISO_8859_1_D3 ACUTE_ACCENT_BITS + KEY_O + SHIFT_MASK // 211 Ó O ACUTE +#define ISO_8859_1_D4 CIRCUMFLEX_BITS + KEY_O + SHIFT_MASK // 212 Ô O CIRCUMFLEX +#define ISO_8859_1_D5 TILDE_BITS + KEY_O + SHIFT_MASK // 213 Õ O TILDE +#define ISO_8859_1_D6 DIAERESIS_BITS + KEY_O + SHIFT_MASK // 214 Ö O DIAERESIS +#define ISO_8859_1_D7 KEY_COMMA + SHIFT_MASK + RCTRL_MASK // 215 × MULTIPLICATION +#define ISO_8859_1_D8 KEY_O + SHIFT_MASK + RCTRL_MASK // 216 Ø O STROKE +#define ISO_8859_1_D9 KEY_NON_US_100 + SHIFT_MASK // 217 Ù U GRAVE +#define ISO_8859_1_DA ACUTE_ACCENT_BITS + KEY_U + SHIFT_MASK // 218 Ú U ACUTE +#define ISO_8859_1_DB CIRCUMFLEX_BITS + KEY_U + SHIFT_MASK // 219 Û U CIRCUMFLEX +#define ISO_8859_1_DC DIAERESIS_BITS + KEY_U // 220 Ü U DIAERESIS +#define ISO_8859_1_DD ACUTE_ACCENT_BITS + KEY_Y + SHIFT_MASK // 221 Ý Y ACUTE +#define ISO_8859_1_DE KEY_P + RCTRL_MASK + SHIFT_MASK // 222 Þ THORN +#define ISO_8859_1_DF KEY_S + RCTRL_MASK // 223 ß SHARP S +#define ISO_8859_1_E0 KEY_BACKSLASH // 224 à a GRAVE +#define ISO_8859_1_E1 ACUTE_ACCENT_BITS + KEY_A // 225 á a ACUTE +#define ISO_8859_1_E2 CIRCUMFLEX_BITS + KEY_A // 226 â a CIRCUMFLEX +#define ISO_8859_1_E3 TILDE_BITS + KEY_A // 227 ã a TILDE +#define ISO_8859_1_E4 DIAERESIS_BITS + KEY_A // 228 ä a DIAERESIS +#define ISO_8859_1_E5 RING_ABOVE_BITS + KEY_A // 229 å a RING ABOVE +#define ISO_8859_1_E6 KEY_A + RCTRL_MASK // 230 æ ae +#define ISO_8859_1_E7 KEY_RIGHT_BRACE // 231 ç c CEDILLA +#define ISO_8859_1_E8 KEY_QUOTE // 232 è e GRAVE +#define ISO_8859_1_E9 KEY_SLASH // 233 é e ACUTE +#define ISO_8859_1_EA CIRCUMFLEX_BITS + KEY_E // 234 ê e CIRCUMFLEX +#define ISO_8859_1_EB DIAERESIS_BITS + KEY_E // 235 ë e DIAERESIS +#define ISO_8859_1_EC GRAVE_ACCENT_BITS + KEY_I // 236 ì i GRAVE +#define ISO_8859_1_ED ACUTE_ACCENT_BITS + KEY_I // 237 í i ACUTE +#define ISO_8859_1_EE CIRCUMFLEX_BITS + KEY_I // 238 î i CIRCUMFLEX +#define ISO_8859_1_EF DIAERESIS_BITS + KEY_I // 239 ï i DIAERESIS +#define ISO_8859_1_F0 KEY_D + RCTRL_MASK // 240 ð ETH +#define ISO_8859_1_F1 TILDE_BITS + KEY_N // 241 ñ n TILDE +#define ISO_8859_1_F2 GRAVE_ACCENT_BITS + KEY_O // 242 ò o GRAVE +#define ISO_8859_1_F3 ACUTE_ACCENT_BITS + KEY_O // 243 ó o ACUTE +#define ISO_8859_1_F4 CIRCUMFLEX_BITS + KEY_O // 244 ô o CIRCUMFLEX +#define ISO_8859_1_F5 TILDE_BITS + KEY_O // 245 õ o TILDE +#define ISO_8859_1_F6 DIAERESIS_BITS + KEY_O // 246 ö o DIAERESIS +#define ISO_8859_1_F7 KEY_PERIOD + SHIFT_MASK + RCTRL_MASK // 247 ÷ DIVISION +#define ISO_8859_1_F8 KEY_O + RCTRL_MASK // 248 ø o STROKE +#define ISO_8859_1_F9 KEY_NON_US_100 // 249 ù u GRAVE +#define ISO_8859_1_FA ACUTE_ACCENT_BITS + KEY_U // 250 ú u ACUTE +#define ISO_8859_1_FB CIRCUMFLEX_BITS + KEY_U // 251 û u CIRCUMFLEX +#define ISO_8859_1_FC DIAERESIS_BITS + KEY_U // 252 ü u DIAERESIS +#define ISO_8859_1_FD ACUTE_ACCENT_BITS + KEY_Y // 253 ý y ACUTE +#define ISO_8859_1_FE KEY_P + RCTRL_MASK // 254 þ THORN +#define ISO_8859_1_FF DIAERESIS_BITS + KEY_Y // 255 ÿ y DIAERESIS + +#endif // LAYOUT_CANADIAN_MULTILINGUAL + + + + + + +#ifdef LAYOUT_UNITED_KINGDOM + +#define SHIFT_MASK 0x0040 +#define ALTGR_MASK 0x0080 +#define KEYCODE_TYPE uint8_t +#define KEYCODE_MASK 0x00FF +#define KEY_NON_US_100 63 + +#define ASCII_20 KEY_SPACE // 32 +#define ASCII_21 KEY_1 + SHIFT_MASK // 33 ! +#define ASCII_22 KEY_2 + SHIFT_MASK // 34 " +#define ASCII_23 KEY_BACKSPACE // 35 # +#define ASCII_24 KEY_4 + SHIFT_MASK // 36 $ +#define ASCII_25 KEY_5 + SHIFT_MASK // 37 % +#define ASCII_26 KEY_7 + SHIFT_MASK // 38 & +#define ASCII_27 KEY_QUOTE // 39 ' +#define ASCII_28 KEY_9 + SHIFT_MASK // 40 ( +#define ASCII_29 KEY_0 + SHIFT_MASK // 41 ) +#define ASCII_2A KEY_8 + SHIFT_MASK // 42 * +#define ASCII_2B KEY_EQUAL + SHIFT_MASK // 43 + +#define ASCII_2C KEY_COMMA // 44 , +#define ASCII_2D KEY_MINUS // 45 - +#define ASCII_2E KEY_PERIOD // 46 . +#define ASCII_2F KEY_SLASH // 47 / +#define ASCII_30 KEY_0 // 48 0 +#define ASCII_31 KEY_1 // 49 1 +#define ASCII_32 KEY_2 // 50 2 +#define ASCII_33 KEY_3 // 51 3 +#define ASCII_34 KEY_4 // 52 4 +#define ASCII_35 KEY_5 // 53 5 +#define ASCII_36 KEY_6 // 54 6 +#define ASCII_37 KEY_7 // 55 7 +#define ASCII_38 KEY_8 // 55 8 +#define ASCII_39 KEY_9 // 57 9 +#define ASCII_3A KEY_SEMICOLON + SHIFT_MASK // 58 : +#define ASCII_3B KEY_SEMICOLON // 59 ; +#define ASCII_3C KEY_COMMA + SHIFT_MASK // 60 < +#define ASCII_3D KEY_EQUAL // 61 = +#define ASCII_3E KEY_PERIOD + SHIFT_MASK // 62 > +#define ASCII_3F KEY_SLASH + SHIFT_MASK // 63 ? +#define ASCII_40 KEY_QUOTE + SHIFT_MASK // 64 @ +#define ASCII_41 KEY_A + SHIFT_MASK // 65 A +#define ASCII_42 KEY_B + SHIFT_MASK // 66 B +#define ASCII_43 KEY_C + SHIFT_MASK // 67 C +#define ASCII_44 KEY_D + SHIFT_MASK // 68 D +#define ASCII_45 KEY_E + SHIFT_MASK // 69 E +#define ASCII_46 KEY_F + SHIFT_MASK // 70 F +#define ASCII_47 KEY_G + SHIFT_MASK // 71 G +#define ASCII_48 KEY_H + SHIFT_MASK // 72 H +#define ASCII_49 KEY_I + SHIFT_MASK // 73 I +#define ASCII_4A KEY_J + SHIFT_MASK // 74 J +#define ASCII_4B KEY_K + SHIFT_MASK // 75 K +#define ASCII_4C KEY_L + SHIFT_MASK // 76 L +#define ASCII_4D KEY_M + SHIFT_MASK // 77 M +#define ASCII_4E KEY_N + SHIFT_MASK // 78 N +#define ASCII_4F KEY_O + SHIFT_MASK // 79 O +#define ASCII_50 KEY_P + SHIFT_MASK // 80 P +#define ASCII_51 KEY_Q + SHIFT_MASK // 81 Q +#define ASCII_52 KEY_R + SHIFT_MASK // 82 R +#define ASCII_53 KEY_S + SHIFT_MASK // 83 S +#define ASCII_54 KEY_T + SHIFT_MASK // 84 T +#define ASCII_55 KEY_U + SHIFT_MASK // 85 U +#define ASCII_56 KEY_V + SHIFT_MASK // 86 V +#define ASCII_57 KEY_W + SHIFT_MASK // 87 W +#define ASCII_58 KEY_X + SHIFT_MASK // 88 X +#define ASCII_59 KEY_Y + SHIFT_MASK // 89 Y +#define ASCII_5A KEY_Z + SHIFT_MASK // 90 Z +#define ASCII_5B KEY_LEFT_BRACE // 91 [ +#define ASCII_5C KEY_NON_US_100 // 92 +#define ASCII_5D KEY_RIGHT_BRACE // 93 ] +#define ASCII_5E KEY_6 + SHIFT_MASK // 94 ^ +#define ASCII_5F KEY_MINUS + SHIFT_MASK // 95 _ +#define ASCII_60 KEY_TILDE // 96 ` +#define ASCII_61 KEY_A // 97 a +#define ASCII_62 KEY_B // 98 b +#define ASCII_63 KEY_C // 99 c +#define ASCII_64 KEY_D // 100 d +#define ASCII_65 KEY_E // 101 e +#define ASCII_66 KEY_F // 102 f +#define ASCII_67 KEY_G // 103 g +#define ASCII_68 KEY_H // 104 h +#define ASCII_69 KEY_I // 105 i +#define ASCII_6A KEY_J // 106 j +#define ASCII_6B KEY_K // 107 k +#define ASCII_6C KEY_L // 108 l +#define ASCII_6D KEY_M // 109 m +#define ASCII_6E KEY_N // 110 n +#define ASCII_6F KEY_O // 111 o +#define ASCII_70 KEY_P // 112 p +#define ASCII_71 KEY_Q // 113 q +#define ASCII_72 KEY_R // 114 r +#define ASCII_73 KEY_S // 115 s +#define ASCII_74 KEY_T // 116 t +#define ASCII_75 KEY_U // 117 u +#define ASCII_76 KEY_V // 118 v +#define ASCII_77 KEY_W // 119 w +#define ASCII_78 KEY_X // 120 x +#define ASCII_79 KEY_Y // 121 y +#define ASCII_7A KEY_Z // 122 z +#define ASCII_7B KEY_LEFT_BRACE + SHIFT_MASK // 123 { +#define ASCII_7C KEY_NON_US_100 + SHIFT_MASK // 124 | +#define ASCII_7D KEY_RIGHT_BRACE + SHIFT_MASK // 125 } +#define ASCII_7E KEY_BACKSLASH + SHIFT_MASK // 126 ~ +#define ASCII_7F KEY_BACKSPACE // 127 + +#define ISO_8859_1_A0 KEY_SPACE // 160 Nonbreakng Space +#define ISO_8859_1_A1 0 // 161 ¡ Inverted Exclamation +#define ISO_8859_1_A2 0 // 162 ¢ Cent SIGN +#define ISO_8859_1_A3 KEY_3 + SHIFT_MASK // 163 £ Pound Sign +#define ISO_8859_1_A4 0 // 164 ¤ Currency or Euro Sign +#define ISO_8859_1_A5 0 // 165 ¥ YEN SIGN +#define ISO_8859_1_A6 KEY_TILDE + ALTGR_MASK // 166 ¦ BROKEN BAR +#define ISO_8859_1_A7 0 // 167 § SECTION SIGN +#define ISO_8859_1_A8 0 // 168 ¨ DIAERESIS +#define ISO_8859_1_A9 0 // 169 © COPYRIGHT SIGN +#define ISO_8859_1_AA 0 // 170 ª FEMININE ORDINAL +#define ISO_8859_1_AB 0 // 171 « LEFT DOUBLE ANGLE QUOTE +#define ISO_8859_1_AC KEY_TILDE + SHIFT_MASK // 172 ¬ NOT SIGN +#define ISO_8859_1_AD 0 // 173 SOFT HYPHEN +#define ISO_8859_1_AE 0 // 174 ® REGISTERED SIGN +#define ISO_8859_1_AF 0 // 175 ¯ MACRON +#define ISO_8859_1_B0 0 // 176 ° DEGREE SIGN +#define ISO_8859_1_B1 0 // 177 ± PLUS-MINUS SIGN +#define ISO_8859_1_B2 0 // 178 ² SUPERSCRIPT TWO +#define ISO_8859_1_B3 0 // 179 ³ SUPERSCRIPT THREE +#define ISO_8859_1_B4 0 // 180 ´ ACUTE ACCENT +#define ISO_8859_1_B5 0 // 181 µ MICRO SIGN +#define ISO_8859_1_B6 0 // 182 ¶ PILCROW SIGN +#define ISO_8859_1_B7 0 // 183 · MIDDLE DOT +#define ISO_8859_1_B8 0 // 184 ¸ CEDILLA +#define ISO_8859_1_B9 0 // 185 ¹ SUPERSCRIPT ONE +#define ISO_8859_1_BA 0 // 186 º MASCULINE ORDINAL +#define ISO_8859_1_BB 0 // 187 » RIGHT DOUBLE ANGLE QUOTE +#define ISO_8859_1_BC 0 // 188 ¼ FRACTION ONE QUARTER +#define ISO_8859_1_BD 0 // 189 ½ FRACTION ONE HALF +#define ISO_8859_1_BE 0 // 190 ¾ FRACTION THREE QUARTERS +#define ISO_8859_1_BF 0 // 191 ¿ INVERTED QUESTION MARK +#define ISO_8859_1_C0 0 // 192 À A GRAVE +#define ISO_8859_1_C1 KEY_A + ALTGR_MASK + SHIFT_MASK // 193 Á A ACUTE +#define ISO_8859_1_C2 0 // 194 Â A CIRCUMFLEX +#define ISO_8859_1_C3 0 // 195 Ã A TILDE +#define ISO_8859_1_C4 0 // 196 Ä A DIAERESIS +#define ISO_8859_1_C5 0 // 197 Å A RING ABOVE +#define ISO_8859_1_C6 0 // 198 Æ AE +#define ISO_8859_1_C7 0 // 199 Ç C CEDILLA +#define ISO_8859_1_C8 0 // 200 È E GRAVE +#define ISO_8859_1_C9 KEY_E + ALTGR_MASK + SHIFT_MASK // 201 É E ACUTE +#define ISO_8859_1_CA 0 // 202 Ê E CIRCUMFLEX +#define ISO_8859_1_CB 0 // 203 Ë E DIAERESIS +#define ISO_8859_1_CC 0 // 204 Ì I GRAVE +#define ISO_8859_1_CD KEY_I + ALTGR_MASK + SHIFT_MASK // 205 Í I ACUTE +#define ISO_8859_1_CE 0 // 206 Î I CIRCUMFLEX +#define ISO_8859_1_CF 0 // 207 Ï I DIAERESIS +#define ISO_8859_1_D0 0 // 208 Ð ETH +#define ISO_8859_1_D1 0 // 209 Ñ N TILDE +#define ISO_8859_1_D2 0 // 210 Ò O GRAVE +#define ISO_8859_1_D3 KEY_O + ALTGR_MASK + SHIFT_MASK // 211 Ó O ACUTE +#define ISO_8859_1_D4 0 // 212 Ô O CIRCUMFLEX +#define ISO_8859_1_D5 0 // 213 Õ O TILDE +#define ISO_8859_1_D6 0 // 214 Ö O DIAERESIS +#define ISO_8859_1_D7 0 // 215 × MULTIPLICATION +#define ISO_8859_1_D8 0 // 216 Ø O STROKE +#define ISO_8859_1_D9 0 // 217 Ù U GRAVE +#define ISO_8859_1_DA KEY_U + ALTGR_MASK + SHIFT_MASK // 218 Ú U ACUTE +#define ISO_8859_1_DB 0 // 219 Û U CIRCUMFLEX +#define ISO_8859_1_DC 0 // 220 Ü U DIAERESIS +#define ISO_8859_1_DD 0 // 221 Ý Y ACUTE +#define ISO_8859_1_DE 0 // 222 Þ THORN +#define ISO_8859_1_DF 0 // 223 ß SHARP S +#define ISO_8859_1_E0 0 // 224 à a GRAVE +#define ISO_8859_1_E1 KEY_A + ALTGR_MASK // 225 á a ACUTE +#define ISO_8859_1_E2 0 // 226 â a CIRCUMFLEX +#define ISO_8859_1_E3 0 // 227 ã a TILDE +#define ISO_8859_1_E4 0 // 228 ä a DIAERESIS +#define ISO_8859_1_E5 0 // 229 å a RING ABOVE +#define ISO_8859_1_E6 0 // 230 æ ae +#define ISO_8859_1_E7 0 // 231 ç c CEDILLA +#define ISO_8859_1_E8 0 // 232 è e GRAVE +#define ISO_8859_1_E9 KEY_E + ALTGR_MASK // 233 é e ACUTE +#define ISO_8859_1_EA 0 // 234 ê e CIRCUMFLEX +#define ISO_8859_1_EB 0 // 235 ë e DIAERESIS +#define ISO_8859_1_EC 0 // 236 ì i GRAVE +#define ISO_8859_1_ED KEY_I + ALTGR_MASK // 237 í i ACUTE +#define ISO_8859_1_EE 0 // 238 î i CIRCUMFLEX +#define ISO_8859_1_EF 0 // 239 ï i DIAERESIS +#define ISO_8859_1_F0 0 // 240 ð ETH +#define ISO_8859_1_F1 0 // 241 ñ n TILDE +#define ISO_8859_1_F2 0 // 242 ò o GRAVE +#define ISO_8859_1_F3 KEY_O + ALTGR_MASK // 243 ó o ACUTE +#define ISO_8859_1_F4 0 // 244 ô o CIRCUMFLEX +#define ISO_8859_1_F5 0 // 245 õ o TILDE +#define ISO_8859_1_F6 0 // 246 ö o DIAERESIS +#define ISO_8859_1_F7 0 // 247 ÷ DIVISION +#define ISO_8859_1_F8 0 // 248 ø o STROKE +#define ISO_8859_1_F9 0 // 249 ù u GRAVE +#define ISO_8859_1_FA KEY_U + ALTGR_MASK // 250 ú u ACUTE +#define ISO_8859_1_FB 0 // 251 û u CIRCUMFLEX +#define ISO_8859_1_FC 0 // 252 ü u DIAERESIS +#define ISO_8859_1_FD 0 // 253 ý y ACUTE +#define ISO_8859_1_FE 0 // 254 þ THORN +#define ISO_8859_1_FF 0 // 255 ÿ y DIAERESIS +#define UNICODE_20AC KEY_4 + ALTGR_MASK // € Euro Sign +// not yet implemented +#define UNICODE_EXTRA00 0x20AC +#define KEYCODE_EXTRA00 KEY_4 + ALTGR_MASK // 20AC € Euro Sign + +#endif // LAYOUT_UNITED_KINGDOM + + + +#ifdef LAYOUT_FINNISH + +#define SHIFT_MASK 0x0040 +#define ALTGR_MASK 0x0080 +#define DEADKEYS_MASK 0x0700 +#define CIRCUMFLEX_BITS 0x0100 +#define ACUTE_ACCENT_BITS 0x0200 +#define GRAVE_ACCENT_BITS 0x0300 +#define TILDE_BITS 0x0400 +#define DIAERESIS_BITS 0x0500 +#define KEYCODE_TYPE uint16_t +#define KEYCODE_MASK 0x07FF +#define DEADKEY_CIRCUMFLEX KEY_RIGHT_BRACE + SHIFT_MASK +#define DEADKEY_ACUTE_ACCENT KEY_EQUAL +#define DEADKEY_GRAVE_ACCENT KEY_EQUAL + SHIFT_MASK +#define DEADKEY_TILDE KEY_RIGHT_BRACE + ALTGR_MASK +#define DEADKEY_DIAERESIS KEY_RIGHT_BRACE +#define KEY_NON_US_100 63 + +#define ASCII_20 KEY_SPACE // 32 +#define ASCII_21 KEY_1 + SHIFT_MASK // 33 ! +#define ASCII_22 KEY_2 + SHIFT_MASK // 34 " +#define ASCII_23 KEY_3 + SHIFT_MASK // 35 # +#define ASCII_24 KEY_4 + ALTGR_MASK // 36 $ +#define ASCII_25 KEY_5 + SHIFT_MASK // 37 % +#define ASCII_26 KEY_6 + SHIFT_MASK // 38 & +#define ASCII_27 KEY_BACKSLASH // 39 ' +#define ASCII_28 KEY_8 + SHIFT_MASK // 40 ( +#define ASCII_29 KEY_9 + SHIFT_MASK // 41 ) +#define ASCII_2A KEY_BACKSLASH + SHIFT_MASK // 42 * +#define ASCII_2B KEY_MINUS // 43 + +#define ASCII_2C KEY_COMMA // 44 , +#define ASCII_2D KEY_SLASH // 45 - +#define ASCII_2E KEY_PERIOD // 46 . +#define ASCII_2F KEY_7 + SHIFT_MASK // 47 / +#define ASCII_30 KEY_0 // 48 0 +#define ASCII_31 KEY_1 // 49 1 +#define ASCII_32 KEY_2 // 50 2 +#define ASCII_33 KEY_3 // 51 3 +#define ASCII_34 KEY_4 // 52 4 +#define ASCII_35 KEY_5 // 53 5 +#define ASCII_36 KEY_6 // 54 6 +#define ASCII_37 KEY_7 // 55 7 +#define ASCII_38 KEY_8 // 55 8 +#define ASCII_39 KEY_9 // 57 9 +#define ASCII_3A KEY_PERIOD + SHIFT_MASK // 58 : +#define ASCII_3B KEY_COMMA + SHIFT_MASK // 59 ; +#define ASCII_3C KEY_NON_US_100 // 60 < +#define ASCII_3D KEY_0 + SHIFT_MASK // 61 = +#define ASCII_3E KEY_NON_US_100 + SHIFT_MASK // 62 > +#define ASCII_3F KEY_MINUS + SHIFT_MASK // 63 ? +#define ASCII_40 KEY_2 + ALTGR_MASK // 64 @ +#define ASCII_41 KEY_A + SHIFT_MASK // 65 A +#define ASCII_42 KEY_B + SHIFT_MASK // 66 B +#define ASCII_43 KEY_C + SHIFT_MASK // 67 C +#define ASCII_44 KEY_D + SHIFT_MASK // 68 D +#define ASCII_45 KEY_E + SHIFT_MASK // 69 E +#define ASCII_46 KEY_F + SHIFT_MASK // 70 F +#define ASCII_47 KEY_G + SHIFT_MASK // 71 G +#define ASCII_48 KEY_H + SHIFT_MASK // 72 H +#define ASCII_49 KEY_I + SHIFT_MASK // 73 I +#define ASCII_4A KEY_J + SHIFT_MASK // 74 J +#define ASCII_4B KEY_K + SHIFT_MASK // 75 K +#define ASCII_4C KEY_L + SHIFT_MASK // 76 L +#define ASCII_4D KEY_M + SHIFT_MASK // 77 M +#define ASCII_4E KEY_N + SHIFT_MASK // 78 N +#define ASCII_4F KEY_O + SHIFT_MASK // 79 O +#define ASCII_50 KEY_P + SHIFT_MASK // 80 P +#define ASCII_51 KEY_Q + SHIFT_MASK // 81 Q +#define ASCII_52 KEY_R + SHIFT_MASK // 82 R +#define ASCII_53 KEY_S + SHIFT_MASK // 83 S +#define ASCII_54 KEY_T + SHIFT_MASK // 84 T +#define ASCII_55 KEY_U + SHIFT_MASK // 85 U +#define ASCII_56 KEY_V + SHIFT_MASK // 86 V +#define ASCII_57 KEY_W + SHIFT_MASK // 87 W +#define ASCII_58 KEY_X + SHIFT_MASK // 88 X +#define ASCII_59 KEY_Y + SHIFT_MASK // 89 Y +#define ASCII_5A KEY_Z + SHIFT_MASK // 90 Z +#define ASCII_5B KEY_8 + ALTGR_MASK // 91 [ +#define ASCII_5C KEY_MINUS + ALTGR_MASK // 92 +#define ASCII_5D KEY_9 + ALTGR_MASK // 93 ] +#define ASCII_5E CIRCUMFLEX_BITS + KEY_SPACE // 94 ^ +#define ASCII_5F KEY_SLASH + SHIFT_MASK // 95 _ +#define ASCII_60 GRAVE_ACCENT_BITS + KEY_SPACE // 96 ` +#define ASCII_61 KEY_A // 97 a +#define ASCII_62 KEY_B // 98 b +#define ASCII_63 KEY_C // 99 c +#define ASCII_64 KEY_D // 100 d +#define ASCII_65 KEY_E // 101 e +#define ASCII_66 KEY_F // 102 f +#define ASCII_67 KEY_G // 103 g +#define ASCII_68 KEY_H // 104 h +#define ASCII_69 KEY_I // 105 i +#define ASCII_6A KEY_J // 106 j +#define ASCII_6B KEY_K // 107 k +#define ASCII_6C KEY_L // 108 l +#define ASCII_6D KEY_M // 109 m +#define ASCII_6E KEY_N // 110 n +#define ASCII_6F KEY_O // 111 o +#define ASCII_70 KEY_P // 112 p +#define ASCII_71 KEY_Q // 113 q +#define ASCII_72 KEY_R // 114 r +#define ASCII_73 KEY_S // 115 s +#define ASCII_74 KEY_T // 116 t +#define ASCII_75 KEY_U // 117 u +#define ASCII_76 KEY_V // 118 v +#define ASCII_77 KEY_W // 119 w +#define ASCII_78 KEY_X // 120 x +#define ASCII_79 KEY_Y // 121 y +#define ASCII_7A KEY_Z // 122 z +#define ASCII_7B KEY_7 + ALTGR_MASK // 123 { +#define ASCII_7C KEY_NON_US_100 + ALTGR_MASK // 124 | +#define ASCII_7D KEY_0 + ALTGR_MASK // 125 } +#define ASCII_7E TILDE_BITS + KEY_SPACE // 126 ~ +#define ASCII_7F KEY_BACKSPACE // 127 +#define ISO_8859_1_A0 KEY_SPACE + ALTGR_MASK // 160 Nonbreakng Space +#define ISO_8859_1_A1 KEY_1 + SHIFT_MASK + ALTGR_MASK // 161 ¡ Inverted Exclamation +#define ISO_8859_1_A2 0 // 162 ¢ Cent SIGN +#define ISO_8859_1_A3 KEY_3 + ALTGR_MASK // 163 £ Pound Sign +#define ISO_8859_1_A4 KEY_4 + SHIFT_MASK // 164 ¤ Currency or Euro Sign +#define ISO_8859_1_A5 0 // 165 ¥ YEN SIGN +#define ISO_8859_1_A6 0 // 166 ¦ BROKEN BAR +#define ISO_8859_1_A7 KEY_TILDE // 167 § SECTION SIGN +#define ISO_8859_1_A8 DIAERESIS_BITS + KEY_SPACE // 168 ¨ DIAERESIS +#define ISO_8859_1_A9 0 // 169 © COPYRIGHT SIGN +#define ISO_8859_1_AA 0 // 170 ª FEMININE ORDINAL +#define ISO_8859_1_AB KEY_4 + ALTGR_MASK + SHIFT_MASK // 171 « LEFT DOUBLE ANGLE QUOTE +#define ISO_8859_1_AC 0 // 172 ¬ NOT SIGN +#define ISO_8859_1_AD KEY_SLASH + ALTGR_MASK // 173 SOFT HYPHEN +#define ISO_8859_1_AE 0 // 174 ® REGISTERED SIGN +#define ISO_8859_1_AF 0 // 175 ¯ MACRON +#define ISO_8859_1_B0 KEY_0 + ALTGR_MASK + SHIFT_MASK // 176 ° DEGREE SIGN +#define ISO_8859_1_B1 0 // 177 ± PLUS-MINUS SIGN +#define ISO_8859_1_B2 0 // 178 ² SUPERSCRIPT TWO +#define ISO_8859_1_B3 0 // 179 ³ SUPERSCRIPT THREE +#define ISO_8859_1_B4 ACUTE_ACCENT_BITS + KEY_SPACE // 180 ´ ACUTE ACCENT +#define ISO_8859_1_B5 KEY_M + ALTGR_MASK // 181 µ MICRO SIGN +#define ISO_8859_1_B6 0 // 182 ¶ PILCROW SIGN +#define ISO_8859_1_B7 KEY_X + ALTGR_MASK + SHIFT_MASK // 183 · MIDDLE DOT +#define ISO_8859_1_B8 0 // 184 ¸ CEDILLA +#define ISO_8859_1_B9 0 // 185 ¹ SUPERSCRIPT ONE +#define ISO_8859_1_BA 0 // 186 º MASCULINE ORDINAL +#define ISO_8859_1_BB KEY_3 + ALTGR_MASK + SHIFT_MASK // 187 » RIGHT DOUBLE ANGLE QUOTE +#define ISO_8859_1_BC 0 // 188 ¼ FRACTION ONE QUARTER +#define ISO_8859_1_BD KEY_TILDE + SHIFT_MASK // 189 ½ FRACTION ONE HALF +#define ISO_8859_1_BE 0 // 190 ¾ FRACTION THREE QUARTERS +#define ISO_8859_1_BF KEY_MINUS + ALTGR_MASK + SHIFT_MASK // 191 ¿ INVERTED QUESTION MARK +#define ISO_8859_1_C0 GRAVE_ACCENT_BITS + KEY_A + SHIFT_MASK // 192 À A GRAVE +#define ISO_8859_1_C1 ACUTE_ACCENT_BITS + KEY_A + SHIFT_MASK // 193 Á A ACUTE +#define ISO_8859_1_C2 CIRCUMFLEX_BITS + KEY_A + SHIFT_MASK // 194 Â A CIRCUMFLEX +#define ISO_8859_1_C3 TILDE_BITS + KEY_A + SHIFT_MASK // 195 Ã A TILDE +#define ISO_8859_1_C4 KEY_QUOTE + SHIFT_MASK // 196 Ä A DIAERESIS +#define ISO_8859_1_C5 KEY_LEFT_BRACE + SHIFT_MASK // 197 Å A RING ABOVE +#define ISO_8859_1_C6 KEY_QUOTE + ALTGR_MASK + SHIFT_MASK // 198 Æ AE +#define ISO_8859_1_C7 0 // 199 Ç C CEDILLA +#define ISO_8859_1_C8 GRAVE_ACCENT_BITS + KEY_E + SHIFT_MASK // 200 È E GRAVE +#define ISO_8859_1_C9 ACUTE_ACCENT_BITS + KEY_E + SHIFT_MASK // 201 É E ACUTE +#define ISO_8859_1_CA CIRCUMFLEX_BITS + KEY_E + SHIFT_MASK // 202 Ê E CIRCUMFLEX +#define ISO_8859_1_CB DIAERESIS_BITS + KEY_E + SHIFT_MASK // 203 Ë E DIAERESIS +#define ISO_8859_1_CC GRAVE_ACCENT_BITS + KEY_I + SHIFT_MASK // 204 Ì I GRAVE +#define ISO_8859_1_CD ACUTE_ACCENT_BITS + KEY_I + SHIFT_MASK // 205 Í I ACUTE +#define ISO_8859_1_CE CIRCUMFLEX_BITS + KEY_I + SHIFT_MASK // 206 Î I CIRCUMFLEX +#define ISO_8859_1_CF DIAERESIS_BITS + KEY_I + SHIFT_MASK // 207 Ï I DIAERESIS +#define ISO_8859_1_D0 KEY_D + ALTGR_MASK + SHIFT_MASK // 208 Ð ETH +#define ISO_8859_1_D1 TILDE_BITS + KEY_N + SHIFT_MASK // 209 Ñ N TILDE +#define ISO_8859_1_D2 GRAVE_ACCENT_BITS + KEY_O + SHIFT_MASK // 210 Ò O GRAVE +#define ISO_8859_1_D3 ACUTE_ACCENT_BITS + KEY_O + SHIFT_MASK // 211 Ó O ACUTE +#define ISO_8859_1_D4 CIRCUMFLEX_BITS + KEY_O + SHIFT_MASK // 212 Ô O CIRCUMFLEX +#define ISO_8859_1_D5 TILDE_BITS + KEY_O + SHIFT_MASK // 213 Õ O TILDE +#define ISO_8859_1_D6 KEY_SEMICOLON + SHIFT_MASK // 214 Ö O DIAERESIS +#define ISO_8859_1_D7 KEY_X + ALTGR_MASK // 215 × MULTIPLICATION +#define ISO_8859_1_D8 KEY_SEMICOLON + ALTGR_MASK + SHIFT_MASK // 216 Ø O STROKE +#define ISO_8859_1_D9 GRAVE_ACCENT_BITS + KEY_U + SHIFT_MASK // 217 Ù U GRAVE +#define ISO_8859_1_DA ACUTE_ACCENT_BITS + KEY_U + SHIFT_MASK // 218 Ú U ACUTE +#define ISO_8859_1_DB CIRCUMFLEX_BITS + KEY_U + SHIFT_MASK // 219 Û U CIRCUMFLEX +#define ISO_8859_1_DC DIAERESIS_BITS + KEY_U + SHIFT_MASK // 220 Ü U DIAERESIS +#define ISO_8859_1_DD ACUTE_ACCENT_BITS + KEY_Y + SHIFT_MASK // 221 Ý Y ACUTE +#define ISO_8859_1_DE KEY_T + ALTGR_MASK + SHIFT_MASK // 222 Þ THORN +#define ISO_8859_1_DF KEY_S + ALTGR_MASK // 223 ß SHARP S +#define ISO_8859_1_E0 GRAVE_ACCENT_BITS + KEY_A // 224 à a GRAVE +#define ISO_8859_1_E1 ACUTE_ACCENT_BITS + KEY_A // 225 á a ACUTE +#define ISO_8859_1_E2 CIRCUMFLEX_BITS + KEY_A // 226 â a CIRCUMFLEX +#define ISO_8859_1_E3 TILDE_BITS + KEY_A // 227 ã a TILDE +#define ISO_8859_1_E4 KEY_QUOTE // 228 ä a DIAERESIS +#define ISO_8859_1_E5 KEY_LEFT_BRACE // 229 å a RING ABOVE +#define ISO_8859_1_E6 KEY_QUOTE + ALTGR_MASK // 230 æ ae +#define ISO_8859_1_E7 0 // 231 ç c CEDILLA +#define ISO_8859_1_E8 GRAVE_ACCENT_BITS + KEY_E // 232 è e GRAVE +#define ISO_8859_1_E9 ACUTE_ACCENT_BITS + KEY_E // 233 é e ACUTE +#define ISO_8859_1_EA CIRCUMFLEX_BITS + KEY_E // 234 ê e CIRCUMFLEX +#define ISO_8859_1_EB DIAERESIS_BITS + KEY_E // 235 ë e DIAERESIS +#define ISO_8859_1_EC GRAVE_ACCENT_BITS + KEY_I // 236 ì i GRAVE +#define ISO_8859_1_ED ACUTE_ACCENT_BITS + KEY_I // 237 í i ACUTE +#define ISO_8859_1_EE CIRCUMFLEX_BITS + KEY_I // 238 î i CIRCUMFLEX +#define ISO_8859_1_EF DIAERESIS_BITS + KEY_I // 239 ï i DIAERESIS +#define ISO_8859_1_F0 KEY_D + ALTGR_MASK // 240 ð ETH +#define ISO_8859_1_F1 TILDE_BITS + KEY_N // 241 ñ n TILDE +#define ISO_8859_1_F2 GRAVE_ACCENT_BITS + KEY_O // 242 ò o GRAVE +#define ISO_8859_1_F3 ACUTE_ACCENT_BITS + KEY_O // 243 ó o ACUTE +#define ISO_8859_1_F4 CIRCUMFLEX_BITS + KEY_O // 244 ô o CIRCUMFLEX +#define ISO_8859_1_F5 TILDE_BITS + KEY_O // 245 õ o TILDE +#define ISO_8859_1_F6 KEY_SEMICOLON // 246 ö o DIAERESIS +#define ISO_8859_1_F7 0 // 247 ÷ DIVISION +#define ISO_8859_1_F8 KEY_SEMICOLON + ALTGR_MASK // 248 ø o STROKE +#define ISO_8859_1_F9 GRAVE_ACCENT_BITS + KEY_U // 249 ù u GRAVE +#define ISO_8859_1_FA ACUTE_ACCENT_BITS + KEY_U // 250 ú u ACUTE +#define ISO_8859_1_FB CIRCUMFLEX_BITS + KEY_U // 251 û u CIRCUMFLEX +#define ISO_8859_1_FC DIAERESIS_BITS + KEY_U // 252 ü u DIAERESIS +#define ISO_8859_1_FD ACUTE_ACCENT_BITS + KEY_Y // 253 ý y ACUTE +#define ISO_8859_1_FE KEY_T + ALTGR_MASK // 254 þ THORN +#define ISO_8859_1_FF DIAERESIS_BITS + KEY_Y // 255 ÿ y DIAERESIS +#define UNICODE_20AC KEY_E + ALTGR_MASK // € Euro Sign +// not yet implemented +#define UNICODE_EXTRA00 0x20AC +#define KEYCODE_EXTRA00 KEY_E + ALTGR_MASK // 20AC € Euro Sign +// TODO: Finnish Multilingual layout can type many more glyphs +// but we currently don't have tables tables to store them... + +#endif // LAYOUT_FINNISH + + + + + + + +#ifdef LAYOUT_FRENCH + +#define SHIFT_MASK 0x0040 +#define ALTGR_MASK 0x0080 +#define DEADKEYS_MASK 0x0700 +#define CIRCUMFLEX_BITS 0x0100 +#define GRAVE_ACCENT_BITS 0x0200 +#define DIAERESIS_BITS 0x0300 +#define TILDE_BITS 0x0400 +#define KEYCODE_TYPE uint16_t +#define KEYCODE_MASK 0x07FF +#define DEADKEY_CIRCUMFLEX KEY_LEFT_BRACE +#define DEADKEY_GRAVE_ACCENT KEY_7 + ALTGR_MASK +#define DEADKEY_DIAERESIS KEY_LEFT_BRACE + SHIFT_MASK +#define DEADKEY_TILDE KEY_2 + ALTGR_MASK +#define KEY_NON_US_100 63 + +#define ASCII_20 KEY_SPACE // 32 +#define ASCII_21 KEY_SLASH // 33 ! +#define ASCII_22 KEY_3 // 34 " +#define ASCII_23 KEY_3 + ALTGR_MASK // 35 # +#define ASCII_24 KEY_RIGHT_BRACE // 36 $ +#define ASCII_25 KEY_QUOTE + SHIFT_MASK // 37 % +#define ASCII_26 KEY_1 // 38 & +#define ASCII_27 KEY_4 // 39 ' +#define ASCII_28 KEY_5 // 40 ( +#define ASCII_29 KEY_MINUS // 41 ) +#define ASCII_2A KEY_BACKSLASH // 42 * +#define ASCII_2B KEY_EQUAL + SHIFT_MASK // 43 + +#define ASCII_2C KEY_M // 44 , +#define ASCII_2D KEY_6 // 45 - +#define ASCII_2E KEY_COMMA + SHIFT_MASK // 46 . +#define ASCII_2F KEY_PERIOD + SHIFT_MASK // 47 / +#define ASCII_30 KEY_0 + SHIFT_MASK // 48 0 +#define ASCII_31 KEY_1 + SHIFT_MASK // 49 1 +#define ASCII_32 KEY_2 + SHIFT_MASK // 50 2 +#define ASCII_33 KEY_3 + SHIFT_MASK // 51 3 +#define ASCII_34 KEY_4 + SHIFT_MASK // 52 4 +#define ASCII_35 KEY_5 + SHIFT_MASK // 53 5 +#define ASCII_36 KEY_6 + SHIFT_MASK // 54 6 +#define ASCII_37 KEY_7 + SHIFT_MASK // 55 7 +#define ASCII_38 KEY_8 + SHIFT_MASK // 55 8 +#define ASCII_39 KEY_9 + SHIFT_MASK // 57 9 +#define ASCII_3A KEY_PERIOD // 58 : +#define ASCII_3B KEY_COMMA // 59 ; +#define ASCII_3C KEY_NON_US_100 // 60 < +#define ASCII_3D KEY_EQUAL // 61 = +#define ASCII_3E KEY_NON_US_100 + SHIFT_MASK // 62 > +#define ASCII_3F KEY_M + SHIFT_MASK // 63 ? +#define ASCII_40 KEY_0 + ALTGR_MASK // 64 @ +#define ASCII_41 KEY_Q + SHIFT_MASK // 65 A +#define ASCII_42 KEY_B + SHIFT_MASK // 66 B +#define ASCII_43 KEY_C + SHIFT_MASK // 67 C +#define ASCII_44 KEY_D + SHIFT_MASK // 68 D +#define ASCII_45 KEY_E + SHIFT_MASK // 69 E +#define ASCII_46 KEY_F + SHIFT_MASK // 70 F +#define ASCII_47 KEY_G + SHIFT_MASK // 71 G +#define ASCII_48 KEY_H + SHIFT_MASK // 72 H +#define ASCII_49 KEY_I + SHIFT_MASK // 73 I +#define ASCII_4A KEY_J + SHIFT_MASK // 74 J +#define ASCII_4B KEY_K + SHIFT_MASK // 75 K +#define ASCII_4C KEY_L + SHIFT_MASK // 76 L +#define ASCII_4D KEY_SEMICOLON + SHIFT_MASK // 77 M +#define ASCII_4E KEY_N + SHIFT_MASK // 78 N +#define ASCII_4F KEY_O + SHIFT_MASK // 79 O +#define ASCII_50 KEY_P + SHIFT_MASK // 80 P +#define ASCII_51 KEY_A + SHIFT_MASK // 81 Q +#define ASCII_52 KEY_R + SHIFT_MASK // 82 R +#define ASCII_53 KEY_S + SHIFT_MASK // 83 S +#define ASCII_54 KEY_T + SHIFT_MASK // 84 T +#define ASCII_55 KEY_U + SHIFT_MASK // 85 U +#define ASCII_56 KEY_V + SHIFT_MASK // 86 V +#define ASCII_57 KEY_Z + SHIFT_MASK // 87 W +#define ASCII_58 KEY_X + SHIFT_MASK // 88 X +#define ASCII_59 KEY_Y + SHIFT_MASK // 89 Y +#define ASCII_5A KEY_W + SHIFT_MASK // 90 Z +#define ASCII_5B KEY_5 + ALTGR_MASK // 91 [ +#define ASCII_5C KEY_8 + ALTGR_MASK // 92 +#define ASCII_5D KEY_MINUS + ALTGR_MASK // 93 ] +#define ASCII_5E KEY_9 + ALTGR_MASK // 94 ^ +#define ASCII_5F KEY_8 // 95 _ +#define ASCII_60 GRAVE_ACCENT_BITS + KEY_SPACE // 96 ` +#define ASCII_61 KEY_Q // 97 a +#define ASCII_62 KEY_B // 98 b +#define ASCII_63 KEY_C // 99 c +#define ASCII_64 KEY_D // 100 d +#define ASCII_65 KEY_E // 101 e +#define ASCII_66 KEY_F // 102 f +#define ASCII_67 KEY_G // 103 g +#define ASCII_68 KEY_H // 104 h +#define ASCII_69 KEY_I // 105 i +#define ASCII_6A KEY_J // 106 j +#define ASCII_6B KEY_K // 107 k +#define ASCII_6C KEY_L // 108 l +#define ASCII_6D KEY_SEMICOLON // 109 m +#define ASCII_6E KEY_N // 110 n +#define ASCII_6F KEY_O // 111 o +#define ASCII_70 KEY_P // 112 p +#define ASCII_71 KEY_A // 113 q +#define ASCII_72 KEY_R // 114 r +#define ASCII_73 KEY_S // 115 s +#define ASCII_74 KEY_T // 116 t +#define ASCII_75 KEY_U // 117 u +#define ASCII_76 KEY_V // 118 v +#define ASCII_77 KEY_Z // 119 w +#define ASCII_78 KEY_X // 120 x +#define ASCII_79 KEY_Y // 121 y +#define ASCII_7A KEY_W // 122 z +#define ASCII_7B KEY_4 + ALTGR_MASK // 123 { +#define ASCII_7C KEY_6 + ALTGR_MASK // 124 | +#define ASCII_7D KEY_EQUAL + ALTGR_MASK // 125 } +#define ASCII_7E TILDE_BITS + KEY_SPACE // 126 ~ +#define ASCII_7F KEY_BACKSPACE // 127 +#define ISO_8859_1_A0 KEY_SPACE // 160 Nonbreakng Space +#define ISO_8859_1_A1 0 // 161 ¡ Inverted Exclamation +#define ISO_8859_1_A2 0 // 162 ¢ Cent SIGN +#define ISO_8859_1_A3 KEY_RIGHT_BRACE + SHIFT_MASK // 163 £ Pound Sign +#define ISO_8859_1_A4 KEY_RIGHT_BRACE + ALTGR_MASK // 164 ¤ Currency or Euro Sign +#define ISO_8859_1_A5 0 // 165 ¥ YEN SIGN +#define ISO_8859_1_A6 0 // 166 ¦ BROKEN BAR +#define ISO_8859_1_A7 KEY_SLASH + SHIFT_MASK // 167 § SECTION SIGN +#define ISO_8859_1_A8 DIAERESIS_BITS + KEY_SPACE // 168 ¨ DIAERESIS +#define ISO_8859_1_A9 0 // 169 © COPYRIGHT SIGN +#define ISO_8859_1_AA 0 // 170 ª FEMININE ORDINAL +#define ISO_8859_1_AB 0 // 171 « LEFT DOUBLE ANGLE QUOTE +#define ISO_8859_1_AC 0 // 172 ¬ NOT SIGN +#define ISO_8859_1_AD 0 // 173 SOFT HYPHEN +#define ISO_8859_1_AE 0 // 174 ® REGISTERED SIGN +#define ISO_8859_1_AF 0 // 175 ¯ MACRON +#define ISO_8859_1_B0 KEY_MINUS + SHIFT_MASK // 176 ° DEGREE SIGN +#define ISO_8859_1_B1 0 // 177 ± PLUS-MINUS SIGN +#define ISO_8859_1_B2 KEY_TILDE // 178 ² SUPERSCRIPT TWO +#define ISO_8859_1_B3 0 // 179 ³ SUPERSCRIPT THREE +#define ISO_8859_1_B4 0 // 180 ´ ACUTE ACCENT +#define ISO_8859_1_B5 KEY_BACKSLASH + SHIFT_MASK // 181 µ MICRO SIGN +#define ISO_8859_1_B6 0 // 182 ¶ PILCROW SIGN +#define ISO_8859_1_B7 0 // 183 · MIDDLE DOT +#define ISO_8859_1_B8 0 // 184 ¸ CEDILLA +#define ISO_8859_1_B9 0 // 185 ¹ SUPERSCRIPT ONE +#define ISO_8859_1_BA 0 // 186 º MASCULINE ORDINAL +#define ISO_8859_1_BB 0 // 187 » RIGHT DOUBLE ANGLE QUOTE +#define ISO_8859_1_BC 0 // 188 ¼ FRACTION ONE QUARTER +#define ISO_8859_1_BD 0 // 189 ½ FRACTION ONE HALF +#define ISO_8859_1_BE 0 // 190 ¾ FRACTION THREE QUARTERS +#define ISO_8859_1_BF 0 // 191 ¿ INVERTED QUESTION MARK +#define ISO_8859_1_C0 GRAVE_ACCENT_BITS + KEY_Q + SHIFT_MASK // 192 À A GRAVE +#define ISO_8859_1_C1 0 // 193 Á A ACUTE +#define ISO_8859_1_C2 CIRCUMFLEX_BITS + KEY_Q + SHIFT_MASK // 194 Â A CIRCUMFLEX +#define ISO_8859_1_C3 TILDE_BITS + KEY_Q + SHIFT_MASK // 195 Ã A TILDE +#define ISO_8859_1_C4 DIAERESIS_BITS + KEY_Q + SHIFT_MASK // 196 Ä A DIAERESIS +#define ISO_8859_1_C5 0 // 197 Å A RING ABOVE +#define ISO_8859_1_C6 0 // 198 Æ AE +#define ISO_8859_1_C7 0 // 199 Ç C CEDILLA +#define ISO_8859_1_C8 GRAVE_ACCENT_BITS + KEY_E + SHIFT_MASK // 200 È E GRAVE +#define ISO_8859_1_C9 0 // 201 É E ACUTE +#define ISO_8859_1_CA CIRCUMFLEX_BITS + KEY_E + SHIFT_MASK // 202 Ê E CIRCUMFLEX +#define ISO_8859_1_CB DIAERESIS_BITS + KEY_E + SHIFT_MASK // 203 Ë E DIAERESIS +#define ISO_8859_1_CC GRAVE_ACCENT_BITS + KEY_I + SHIFT_MASK // 204 Ì I GRAVE +#define ISO_8859_1_CD 0 // 205 Í I ACUTE +#define ISO_8859_1_CE CIRCUMFLEX_BITS + KEY_I + SHIFT_MASK // 206 Î I CIRCUMFLEX +#define ISO_8859_1_CF DIAERESIS_BITS + KEY_I + SHIFT_MASK // 207 Ï I DIAERESIS +#define ISO_8859_1_D0 0 // 208 Ð ETH +#define ISO_8859_1_D1 TILDE_BITS + KEY_N + SHIFT_MASK // 209 Ñ N TILDE +#define ISO_8859_1_D2 GRAVE_ACCENT_BITS + KEY_O + SHIFT_MASK // 210 Ò O GRAVE +#define ISO_8859_1_D3 0 // 211 Ó O ACUTE +#define ISO_8859_1_D4 CIRCUMFLEX_BITS + KEY_O + SHIFT_MASK // 212 Ô O CIRCUMFLEX +#define ISO_8859_1_D5 TILDE_BITS + KEY_O + SHIFT_MASK // 213 Õ O TILDE +#define ISO_8859_1_D6 DIAERESIS_BITS + KEY_O + SHIFT_MASK // 214 Ö O DIAERESIS +#define ISO_8859_1_D7 0 // 215 × MULTIPLICATION +#define ISO_8859_1_D8 0 // 216 Ø O STROKE +#define ISO_8859_1_D9 GRAVE_ACCENT_BITS + KEY_U + SHIFT_MASK // 217 Ù U GRAVE +#define ISO_8859_1_DA 0 // 218 Ú U ACUTE +#define ISO_8859_1_DB CIRCUMFLEX_BITS + KEY_U + SHIFT_MASK // 219 Û U CIRCUMFLEX +#define ISO_8859_1_DC DIAERESIS_BITS + KEY_U // 220 Ü U DIAERESIS +#define ISO_8859_1_DD 0 // 221 Ý Y ACUTE +#define ISO_8859_1_DE 0 // 222 Þ THORN +#define ISO_8859_1_DF 0 // 223 ß SHARP S +#define ISO_8859_1_E0 KEY_0 // 224 à a GRAVE +#define ISO_8859_1_E1 0 // 225 á a ACUTE +#define ISO_8859_1_E2 CIRCUMFLEX_BITS + KEY_Q // 226 â a CIRCUMFLEX +#define ISO_8859_1_E3 TILDE_BITS + KEY_Q // 227 ã a TILDE +#define ISO_8859_1_E4 DIAERESIS_BITS + KEY_Q // 228 ä a DIAERESIS +#define ISO_8859_1_E5 0 // 229 å a RING ABOVE +#define ISO_8859_1_E6 0 // 230 æ ae +#define ISO_8859_1_E7 KEY_9 // 231 ç c CEDILLA +#define ISO_8859_1_E8 KEY_7 // 232 è e GRAVE +#define ISO_8859_1_E9 KEY_2 // 233 é e ACUTE +#define ISO_8859_1_EA CIRCUMFLEX_BITS + KEY_E // 234 ê e CIRCUMFLEX +#define ISO_8859_1_EB DIAERESIS_BITS + KEY_E // 235 ë e DIAERESIS +#define ISO_8859_1_EC GRAVE_ACCENT_BITS + KEY_I // 236 ì i GRAVE +#define ISO_8859_1_ED 0 // 237 í i ACUTE +#define ISO_8859_1_EE CIRCUMFLEX_BITS + KEY_I // 238 î i CIRCUMFLEX +#define ISO_8859_1_EF DIAERESIS_BITS + KEY_I // 239 ï i DIAERESIS +#define ISO_8859_1_F0 0 // 240 ð ETH +#define ISO_8859_1_F1 TILDE_BITS + KEY_N // 241 ñ n TILDE +#define ISO_8859_1_F2 GRAVE_ACCENT_BITS + KEY_O // 242 ò o GRAVE +#define ISO_8859_1_F3 0 // 243 ó o ACUTE +#define ISO_8859_1_F4 CIRCUMFLEX_BITS + KEY_O // 244 ô o CIRCUMFLEX +#define ISO_8859_1_F5 TILDE_BITS + KEY_O // 245 õ o TILDE +#define ISO_8859_1_F6 DIAERESIS_BITS + KEY_O // 246 ö o DIAERESIS +#define ISO_8859_1_F7 0 // 247 ÷ DIVISION +#define ISO_8859_1_F8 0 // 248 ø o STROKE +#define ISO_8859_1_F9 KEY_SEMICOLON // 249 ù u GRAVE +#define ISO_8859_1_FA 0 // 250 ú u ACUTE +#define ISO_8859_1_FB CIRCUMFLEX_BITS + KEY_U // 251 û u CIRCUMFLEX +#define ISO_8859_1_FC DIAERESIS_BITS + KEY_U // 252 ü u DIAERESIS +#define ISO_8859_1_FD 0 // 253 ý y ACUTE +#define ISO_8859_1_FE 0 // 254 þ THORN +#define ISO_8859_1_FF DIAERESIS_BITS + KEY_Y // 255 ÿ y DIAERESIS +#define UNICODE_20AC KEY_E + ALTGR_MASK // € Euro Sign +// not yet implemented +#define UNICODE_EXTRA00 0x20AC +#define KEYCODE_EXTRA00 KEY_E + ALTGR_MASK // 20AC € Euro Sign + +#endif // LAYOUT_FRENCH + + + + + +#ifdef LAYOUT_DANISH + +#define SHIFT_MASK 0x0040 +#define ALTGR_MASK 0x0080 +#define DEADKEYS_MASK 0x0700 +#define CIRCUMFLEX_BITS 0x0100 +#define ACUTE_ACCENT_BITS 0x0200 +#define GRAVE_ACCENT_BITS 0x0300 +#define TILDE_BITS 0x0400 +#define DIAERESIS_BITS 0x0500 +#define KEYCODE_TYPE uint16_t +#define KEYCODE_MASK 0x07FF +#define DEADKEY_CIRCUMFLEX KEY_RIGHT_BRACE + SHIFT_MASK +#define DEADKEY_ACUTE_ACCENT KEY_EQUAL +#define DEADKEY_GRAVE_ACCENT KEY_EQUAL + SHIFT_MASK +#define DEADKEY_TILDE KEY_RIGHT_BRACE + ALTGR_MASK +#define DEADKEY_DIAERESIS KEY_RIGHT_BRACE +#define KEY_NON_US_100 63 + +#define ASCII_20 KEY_SPACE // 32 +#define ASCII_21 KEY_1 + SHIFT_MASK // 33 ! +#define ASCII_22 KEY_2 + SHIFT_MASK // 34 " +#define ASCII_23 KEY_3 + SHIFT_MASK // 35 # +#define ASCII_24 KEY_4 + ALTGR_MASK // 36 $ +#define ASCII_25 KEY_5 + SHIFT_MASK // 37 % +#define ASCII_26 KEY_6 + SHIFT_MASK // 38 & +#define ASCII_27 KEY_BACKSLASH // 39 ' +#define ASCII_28 KEY_8 + SHIFT_MASK // 40 ( +#define ASCII_29 KEY_9 + SHIFT_MASK // 41 ) +#define ASCII_2A KEY_BACKSLASH + SHIFT_MASK // 42 * +#define ASCII_2B KEY_MINUS // 43 + +#define ASCII_2C KEY_COMMA // 44 , +#define ASCII_2D KEY_SLASH // 45 - +#define ASCII_2E KEY_PERIOD // 46 . +#define ASCII_2F KEY_7 + SHIFT_MASK // 47 / +#define ASCII_30 KEY_0 // 48 0 +#define ASCII_31 KEY_1 // 49 1 +#define ASCII_32 KEY_2 // 50 2 +#define ASCII_33 KEY_3 // 51 3 +#define ASCII_34 KEY_4 // 52 4 +#define ASCII_35 KEY_5 // 53 5 +#define ASCII_36 KEY_6 // 54 6 +#define ASCII_37 KEY_7 // 55 7 +#define ASCII_38 KEY_8 // 55 8 +#define ASCII_39 KEY_9 // 57 9 +#define ASCII_3A KEY_PERIOD + SHIFT_MASK // 58 : +#define ASCII_3B KEY_COMMA + SHIFT_MASK // 59 ; +#define ASCII_3C KEY_NON_US_100 // 60 < +#define ASCII_3D KEY_0 + SHIFT_MASK // 61 = +#define ASCII_3E KEY_NON_US_100 + SHIFT_MASK // 62 > +#define ASCII_3F KEY_MINUS + SHIFT_MASK // 63 ? +#define ASCII_40 KEY_2 + ALTGR_MASK // 64 @ +#define ASCII_41 KEY_A + SHIFT_MASK // 65 A +#define ASCII_42 KEY_B + SHIFT_MASK // 66 B +#define ASCII_43 KEY_C + SHIFT_MASK // 67 C +#define ASCII_44 KEY_D + SHIFT_MASK // 68 D +#define ASCII_45 KEY_E + SHIFT_MASK // 69 E +#define ASCII_46 KEY_F + SHIFT_MASK // 70 F +#define ASCII_47 KEY_G + SHIFT_MASK // 71 G +#define ASCII_48 KEY_H + SHIFT_MASK // 72 H +#define ASCII_49 KEY_I + SHIFT_MASK // 73 I +#define ASCII_4A KEY_J + SHIFT_MASK // 74 J +#define ASCII_4B KEY_K + SHIFT_MASK // 75 K +#define ASCII_4C KEY_L + SHIFT_MASK // 76 L +#define ASCII_4D KEY_M + SHIFT_MASK // 77 M +#define ASCII_4E KEY_N + SHIFT_MASK // 78 N +#define ASCII_4F KEY_O + SHIFT_MASK // 79 O +#define ASCII_50 KEY_P + SHIFT_MASK // 80 P +#define ASCII_51 KEY_Q + SHIFT_MASK // 81 Q +#define ASCII_52 KEY_R + SHIFT_MASK // 82 R +#define ASCII_53 KEY_S + SHIFT_MASK // 83 S +#define ASCII_54 KEY_T + SHIFT_MASK // 84 T +#define ASCII_55 KEY_U + SHIFT_MASK // 85 U +#define ASCII_56 KEY_V + SHIFT_MASK // 86 V +#define ASCII_57 KEY_W + SHIFT_MASK // 87 W +#define ASCII_58 KEY_X + SHIFT_MASK // 88 X +#define ASCII_59 KEY_Y + SHIFT_MASK // 89 Y +#define ASCII_5A KEY_Z + SHIFT_MASK // 90 Z +#define ASCII_5B KEY_8 + ALTGR_MASK // 91 [ +#define ASCII_5C KEY_NON_US_100 + ALTGR_MASK // 92 +#define ASCII_5D KEY_9 + ALTGR_MASK // 93 ] +#define ASCII_5E CIRCUMFLEX_BITS + KEY_SPACE // 94 ^ +#define ASCII_5F KEY_SLASH + SHIFT_MASK // 95 _ +#define ASCII_60 GRAVE_ACCENT_BITS + KEY_SPACE // 96 ` +#define ASCII_61 KEY_A // 97 a +#define ASCII_62 KEY_B // 98 b +#define ASCII_63 KEY_C // 99 c +#define ASCII_64 KEY_D // 100 d +#define ASCII_65 KEY_E // 101 e +#define ASCII_66 KEY_F // 102 f +#define ASCII_67 KEY_G // 103 g +#define ASCII_68 KEY_H // 104 h +#define ASCII_69 KEY_I // 105 i +#define ASCII_6A KEY_J // 106 j +#define ASCII_6B KEY_K // 107 k +#define ASCII_6C KEY_L // 108 l +#define ASCII_6D KEY_M // 109 m +#define ASCII_6E KEY_N // 110 n +#define ASCII_6F KEY_O // 111 o +#define ASCII_70 KEY_P // 112 p +#define ASCII_71 KEY_Q // 113 q +#define ASCII_72 KEY_R // 114 r +#define ASCII_73 KEY_S // 115 s +#define ASCII_74 KEY_T // 116 t +#define ASCII_75 KEY_U // 117 u +#define ASCII_76 KEY_V // 118 v +#define ASCII_77 KEY_W // 119 w +#define ASCII_78 KEY_X // 120 x +#define ASCII_79 KEY_Y // 121 y +#define ASCII_7A KEY_Z // 122 z +#define ASCII_7B KEY_7 + ALTGR_MASK // 123 { +#define ASCII_7C KEY_EQUAL + ALTGR_MASK // 124 | +#define ASCII_7D KEY_0 + ALTGR_MASK // 125 } +#define ASCII_7E TILDE_BITS + KEY_SPACE // 126 ~ +#define ASCII_7F KEY_BACKSPACE // 127 + +#define ISO_8859_1_A0 KEY_SPACE // 160 Nonbreakng Space +#define ISO_8859_1_A1 0 // 161 ¡ Inverted Exclamation +#define ISO_8859_1_A2 0 // 162 ¢ Cent SIGN +#define ISO_8859_1_A3 KEY_3 + ALTGR_MASK // 163 £ Pound Sign +#define ISO_8859_1_A4 KEY_4 + SHIFT_MASK // 164 ¤ Currency Sign +#define ISO_8859_1_A5 0 // 165 ¥ YEN SIGN +#define ISO_8859_1_A6 0 // 166 ¦ BROKEN BAR +#define ISO_8859_1_A7 KEY_TILDE + SHIFT_MASK // 167 § SECTION SIGN +#define ISO_8859_1_A8 DIAERESIS_BITS + KEY_SPACE // 168 ¨ DIAERESIS +#define ISO_8859_1_A9 0 // 169 © COPYRIGHT SIGN +#define ISO_8859_1_AA 0 // 170 ª FEMININE ORDINAL +#define ISO_8859_1_AB KEY_4 // 171 « LEFT DOUBLE ANGLE QUOTE +#define ISO_8859_1_AC 0 // 172 ¬ NOT SIGN +#define ISO_8859_1_AD 0 // 173 SOFT HYPHEN +#define ISO_8859_1_AE 0 // 174 ® REGISTERED SIGN +#define ISO_8859_1_AF 0 // 175 ¯ MACRON +#define ISO_8859_1_B0 0 // 176 ° DEGREE SIGN +#define ISO_8859_1_B1 0 // 177 ± PLUS-MINUS SIGN +#define ISO_8859_1_B2 0 // 178 ² SUPERSCRIPT TWO +#define ISO_8859_1_B3 0 // 179 ³ SUPERSCRIPT THREE +#define ISO_8859_1_B4 ACUTE_ACCENT_BITS + KEY_SPACE // 180 ´ ACUTE ACCENT +#define ISO_8859_1_B5 KEY_M + ALTGR_MASK // 181 µ MICRO SIGN +#define ISO_8859_1_B6 0 // 182 ¶ PILCROW SIGN +#define ISO_8859_1_B7 0 // 183 · MIDDLE DOT +#define ISO_8859_1_B8 0 // 184 ¸ CEDILLA +#define ISO_8859_1_B9 0 // 185 ¹ SUPERSCRIPT ONE +#define ISO_8859_1_BA 0 // 186 º MASCULINE ORDINAL +#define ISO_8859_1_BB 0 // 187 » RIGHT DOUBLE ANGLE QUOTE +#define ISO_8859_1_BC 0 // 188 ¼ FRACTION ONE QUARTER +#define ISO_8859_1_BD KEY_TILDE // 189 ½ FRACTION ONE HALF +#define ISO_8859_1_BE 0 // 190 ¾ FRACTION THREE QUARTERS +#define ISO_8859_1_BF 0 // 191 ¿ INVERTED QUESTION MARK +#define ISO_8859_1_C0 GRAVE_ACCENT_BITS + KEY_A + SHIFT_MASK // 192 À A GRAVE +#define ISO_8859_1_C1 ACUTE_ACCENT_BITS + KEY_A + SHIFT_MASK // 193 Á A ACUTE +#define ISO_8859_1_C2 CIRCUMFLEX_BITS + KEY_A + SHIFT_MASK // 194 Â A CIRCUMFLEX +#define ISO_8859_1_C3 TILDE_BITS + KEY_A + SHIFT_MASK // 195 Ã A TILDE +#define ISO_8859_1_C4 DIAERESIS_BITS + KEY_A + SHIFT_MASK // 196 Ä A DIAERESIS +#define ISO_8859_1_C5 KEY_LEFT_BRACE + SHIFT_MASK // 197 Å A RING ABOVE +#define ISO_8859_1_C6 KEY_SEMICOLON + SHIFT_MASK // 198 Æ AE +#define ISO_8859_1_C7 0 // 199 Ç C CEDILLA +#define ISO_8859_1_C8 GRAVE_ACCENT_BITS + KEY_E + SHIFT_MASK // 200 È E GRAVE +#define ISO_8859_1_C9 ACUTE_ACCENT_BITS + KEY_E + SHIFT_MASK // 201 É E ACUTE +#define ISO_8859_1_CA CIRCUMFLEX_BITS + KEY_E + SHIFT_MASK // 202 Ê E CIRCUMFLEX +#define ISO_8859_1_CB DIAERESIS_BITS + KEY_E + SHIFT_MASK // 203 Ë E DIAERESIS +#define ISO_8859_1_CC GRAVE_ACCENT_BITS + KEY_I + SHIFT_MASK // 204 Ì I GRAVE +#define ISO_8859_1_CD ACUTE_ACCENT_BITS + KEY_I + SHIFT_MASK // 205 Í I ACUTE +#define ISO_8859_1_CE CIRCUMFLEX_BITS + KEY_I + SHIFT_MASK // 206 Î I CIRCUMFLEX +#define ISO_8859_1_CF DIAERESIS_BITS + KEY_I + SHIFT_MASK // 207 Ï I DIAERESIS +#define ISO_8859_1_D0 KEY_D + ALTGR_MASK + SHIFT_MASK // 208 Ð ETH +#define ISO_8859_1_D1 TILDE_BITS + KEY_N + SHIFT_MASK // 209 Ñ N TILDE +#define ISO_8859_1_D2 GRAVE_ACCENT_BITS + KEY_O + SHIFT_MASK // 210 Ò O GRAVE +#define ISO_8859_1_D3 ACUTE_ACCENT_BITS + KEY_O + SHIFT_MASK // 211 Ó O ACUTE +#define ISO_8859_1_D4 CIRCUMFLEX_BITS + KEY_O + SHIFT_MASK // 212 Ô O CIRCUMFLEX +#define ISO_8859_1_D5 TILDE_BITS + KEY_O + SHIFT_MASK // 213 Õ O TILDE +#define ISO_8859_1_D6 DIAERESIS_BITS + KEY_O + SHIFT_MASK // 214 Ö O DIAERESIS +#define ISO_8859_1_D7 0 // 215 × MULTIPLICATION +#define ISO_8859_1_D8 KEY_QUOTE + SHIFT_MASK // 216 Ø O STROKE +#define ISO_8859_1_D9 GRAVE_ACCENT_BITS + KEY_U + SHIFT_MASK // 217 Ù U GRAVE +#define ISO_8859_1_DA ACUTE_ACCENT_BITS + KEY_U + SHIFT_MASK // 218 Ú U ACUTE +#define ISO_8859_1_DB CIRCUMFLEX_BITS + KEY_U + SHIFT_MASK // 219 Û U CIRCUMFLEX +#define ISO_8859_1_DC DIAERESIS_BITS + KEY_U + SHIFT_MASK // 220 Ü U DIAERESIS +#define ISO_8859_1_DD ACUTE_ACCENT_BITS + KEY_Y + SHIFT_MASK // 221 Ý Y ACUTE +#define ISO_8859_1_DE KEY_T + ALTGR_MASK + SHIFT_MASK // 222 Þ THORN +#define ISO_8859_1_DF KEY_S + ALTGR_MASK // 223 ß SHARP S +#define ISO_8859_1_E0 GRAVE_ACCENT_BITS + KEY_A // 224 à a GRAVE +#define ISO_8859_1_E1 ACUTE_ACCENT_BITS + KEY_A // 225 á a ACUTE +#define ISO_8859_1_E2 CIRCUMFLEX_BITS + KEY_A // 226 â a CIRCUMFLEX +#define ISO_8859_1_E3 TILDE_BITS + KEY_A // 227 ã a TILDE +#define ISO_8859_1_E4 DIAERESIS_BITS + KEY_A // 228 ä a DIAERESIS +#define ISO_8859_1_E5 KEY_LEFT_BRACE // 229 å a RING ABOVE +#define ISO_8859_1_E6 KEY_SEMICOLON // 230 æ ae +#define ISO_8859_1_E7 0 // 231 ç c CEDILLA +#define ISO_8859_1_E8 GRAVE_ACCENT_BITS + KEY_E // 232 è e GRAVE +#define ISO_8859_1_E9 ACUTE_ACCENT_BITS + KEY_E // 233 é e ACUTE +#define ISO_8859_1_EA CIRCUMFLEX_BITS + KEY_E // 234 ê e CIRCUMFLEX +#define ISO_8859_1_EB DIAERESIS_BITS + KEY_E // 235 ë e DIAERESIS +#define ISO_8859_1_EC GRAVE_ACCENT_BITS + KEY_I // 236 ì i GRAVE +#define ISO_8859_1_ED ACUTE_ACCENT_BITS + KEY_I // 237 í i ACUTE +#define ISO_8859_1_EE CIRCUMFLEX_BITS + KEY_I // 238 î i CIRCUMFLEX +#define ISO_8859_1_EF DIAERESIS_BITS + KEY_I // 239 ï i DIAERESIS +#define ISO_8859_1_F0 KEY_D + ALTGR_MASK // 240 ð ETH +#define ISO_8859_1_F1 TILDE_BITS + KEY_N // 241 ñ n TILDE +#define ISO_8859_1_F2 GRAVE_ACCENT_BITS + KEY_O // 242 ò o GRAVE +#define ISO_8859_1_F3 ACUTE_ACCENT_BITS + KEY_O // 243 ó o ACUTE +#define ISO_8859_1_F4 CIRCUMFLEX_BITS + KEY_O // 244 ô o CIRCUMFLEX +#define ISO_8859_1_F5 TILDE_BITS + KEY_O // 245 õ o TILDE +#define ISO_8859_1_F6 DIAERESIS_BITS + KEY_O // 246 ö o DIAERESIS +#define ISO_8859_1_F7 0 // 247 ÷ DIVISION +#define ISO_8859_1_F8 KEY_QUOTE // 248 ø o STROKE +#define ISO_8859_1_F9 GRAVE_ACCENT_BITS + KEY_U // 249 ù u GRAVE +#define ISO_8859_1_FA ACUTE_ACCENT_BITS + KEY_U // 250 ú u ACUTE +#define ISO_8859_1_FB CIRCUMFLEX_BITS + KEY_U // 251 û u CIRCUMFLEX +#define ISO_8859_1_FC DIAERESIS_BITS + KEY_U // 252 ü u DIAERESIS +#define ISO_8859_1_FD ACUTE_ACCENT_BITS + KEY_Y // 253 ý y ACUTE +#define ISO_8859_1_FE KEY_T + ALTGR_MASK // 254 þ THORN +#define ISO_8859_1_FF DIAERESIS_BITS + KEY_Y // 255 ÿ y DIAERESIS +#define UNICODE_20AC KEY_E + ALTGR_MASK // € Euro Sign +// not yet implemented +#define UNICODE_EXTRA00 0x20AC +#define KEYCODE_EXTRA00 KEY_E + ALTGR_MASK // 20AC € Euro Sign + +#endif // LAYOUT_DANISH + + + + + +#ifdef LAYOUT_NORWEGIAN + +#define SHIFT_MASK 0x0040 +#define ALTGR_MASK 0x0080 +#define DEADKEYS_MASK 0x0700 +#define CIRCUMFLEX_BITS 0x0100 +#define ACUTE_ACCENT_BITS 0x0200 +#define GRAVE_ACCENT_BITS 0x0300 +#define TILDE_BITS 0x0400 +#define DIAERESIS_BITS 0x0500 +#define KEYCODE_TYPE uint16_t +#define KEYCODE_MASK 0x07FF +#define DEADKEY_CIRCUMFLEX KEY_RIGHT_BRACE + SHIFT_MASK +#define DEADKEY_ACUTE_ACCENT KEY_EQUAL + ALTGR_MASK +#define DEADKEY_GRAVE_ACCENT KEY_EQUAL + SHIFT_MASK +#define DEADKEY_TILDE KEY_RIGHT_BRACE + ALTGR_MASK +#define DEADKEY_DIAERESIS KEY_RIGHT_BRACE +#define KEY_NON_US_100 63 + +#define ASCII_20 KEY_SPACE // 32 +#define ASCII_21 KEY_1 + SHIFT_MASK // 33 ! +#define ASCII_22 KEY_2 + SHIFT_MASK // 34 " +#define ASCII_23 KEY_3 + SHIFT_MASK // 35 # +#define ASCII_24 KEY_4 + ALTGR_MASK // 36 $ +#define ASCII_25 KEY_5 + SHIFT_MASK // 37 % +#define ASCII_26 KEY_6 + SHIFT_MASK // 38 & +#define ASCII_27 KEY_BACKSLASH // 39 ' +#define ASCII_28 KEY_8 + SHIFT_MASK // 40 ( +#define ASCII_29 KEY_9 + SHIFT_MASK // 41 ) +#define ASCII_2A KEY_BACKSLASH + SHIFT_MASK // 42 * +#define ASCII_2B KEY_MINUS // 43 + +#define ASCII_2C KEY_COMMA // 44 , +#define ASCII_2D KEY_SLASH // 45 - +#define ASCII_2E KEY_PERIOD // 46 . +#define ASCII_2F KEY_7 + SHIFT_MASK // 47 / +#define ASCII_30 KEY_0 // 48 0 +#define ASCII_31 KEY_1 // 49 1 +#define ASCII_32 KEY_2 // 50 2 +#define ASCII_33 KEY_3 // 51 3 +#define ASCII_34 KEY_4 // 52 4 +#define ASCII_35 KEY_5 // 53 5 +#define ASCII_36 KEY_6 // 54 6 +#define ASCII_37 KEY_7 // 55 7 +#define ASCII_38 KEY_8 // 55 8 +#define ASCII_39 KEY_9 // 57 9 +#define ASCII_3A KEY_PERIOD + SHIFT_MASK // 58 : +#define ASCII_3B KEY_COMMA + SHIFT_MASK // 59 ; +#define ASCII_3C KEY_NON_US_100 // 60 < +#define ASCII_3D KEY_0 + SHIFT_MASK // 61 = +#define ASCII_3E KEY_NON_US_100 + SHIFT_MASK // 62 > +#define ASCII_3F KEY_MINUS + SHIFT_MASK // 63 ? +#define ASCII_40 KEY_2 + ALTGR_MASK // 64 @ +#define ASCII_41 KEY_A + SHIFT_MASK // 65 A +#define ASCII_42 KEY_B + SHIFT_MASK // 66 B +#define ASCII_43 KEY_C + SHIFT_MASK // 67 C +#define ASCII_44 KEY_D + SHIFT_MASK // 68 D +#define ASCII_45 KEY_E + SHIFT_MASK // 69 E +#define ASCII_46 KEY_F + SHIFT_MASK // 70 F +#define ASCII_47 KEY_G + SHIFT_MASK // 71 G +#define ASCII_48 KEY_H + SHIFT_MASK // 72 H +#define ASCII_49 KEY_I + SHIFT_MASK // 73 I +#define ASCII_4A KEY_J + SHIFT_MASK // 74 J +#define ASCII_4B KEY_K + SHIFT_MASK // 75 K +#define ASCII_4C KEY_L + SHIFT_MASK // 76 L +#define ASCII_4D KEY_M + SHIFT_MASK // 77 M +#define ASCII_4E KEY_N + SHIFT_MASK // 78 N +#define ASCII_4F KEY_O + SHIFT_MASK // 79 O +#define ASCII_50 KEY_P + SHIFT_MASK // 80 P +#define ASCII_51 KEY_Q + SHIFT_MASK // 81 Q +#define ASCII_52 KEY_R + SHIFT_MASK // 82 R +#define ASCII_53 KEY_S + SHIFT_MASK // 83 S +#define ASCII_54 KEY_T + SHIFT_MASK // 84 T +#define ASCII_55 KEY_U + SHIFT_MASK // 85 U +#define ASCII_56 KEY_V + SHIFT_MASK // 86 V +#define ASCII_57 KEY_W + SHIFT_MASK // 87 W +#define ASCII_58 KEY_X + SHIFT_MASK // 88 X +#define ASCII_59 KEY_Y + SHIFT_MASK // 89 Y +#define ASCII_5A KEY_Z + SHIFT_MASK // 90 Z +#define ASCII_5B KEY_8 + ALTGR_MASK // 91 [ +#define ASCII_5C KEY_EQUAL // 92 +#define ASCII_5D KEY_9 + ALTGR_MASK // 93 ] +#define ASCII_5E CIRCUMFLEX_BITS + KEY_SPACE // 94 ^ +#define ASCII_5F KEY_SLASH + SHIFT_MASK // 95 _ +#define ASCII_60 GRAVE_ACCENT_BITS + KEY_SPACE // 96 ` +#define ASCII_61 KEY_A // 97 a +#define ASCII_62 KEY_B // 98 b +#define ASCII_63 KEY_C // 99 c +#define ASCII_64 KEY_D // 100 d +#define ASCII_65 KEY_E // 101 e +#define ASCII_66 KEY_F // 102 f +#define ASCII_67 KEY_G // 103 g +#define ASCII_68 KEY_H // 104 h +#define ASCII_69 KEY_I // 105 i +#define ASCII_6A KEY_J // 106 j +#define ASCII_6B KEY_K // 107 k +#define ASCII_6C KEY_L // 108 l +#define ASCII_6D KEY_M // 109 m +#define ASCII_6E KEY_N // 110 n +#define ASCII_6F KEY_O // 111 o +#define ASCII_70 KEY_P // 112 p +#define ASCII_71 KEY_Q // 113 q +#define ASCII_72 KEY_R // 114 r +#define ASCII_73 KEY_S // 115 s +#define ASCII_74 KEY_T // 116 t +#define ASCII_75 KEY_U // 117 u +#define ASCII_76 KEY_V // 118 v +#define ASCII_77 KEY_W // 119 w +#define ASCII_78 KEY_X // 120 x +#define ASCII_79 KEY_Y // 121 y +#define ASCII_7A KEY_Z // 122 z +#define ASCII_7B KEY_7 + ALTGR_MASK // 123 { +#define ASCII_7C KEY_TILDE // 124 | +#define ASCII_7D KEY_0 + ALTGR_MASK // 125 } +#define ASCII_7E TILDE_BITS + KEY_SPACE // 126 ~ +#define ASCII_7F KEY_BACKSPACE // 127 + +#define ISO_8859_1_A0 KEY_SPACE // 160 Nonbreakng Space +#define ISO_8859_1_A1 0 // 161 ¡ Inverted Exclamation +#define ISO_8859_1_A2 0 // 162 ¢ Cent SIGN +#define ISO_8859_1_A3 KEY_3 + ALTGR_MASK // 163 £ Pound Sign +#define ISO_8859_1_A4 KEY_4 + SHIFT_MASK // 164 ¤ Currency Sign +#define ISO_8859_1_A5 0 // 165 ¥ YEN SIGN +#define ISO_8859_1_A6 0 // 166 ¦ BROKEN BAR +#define ISO_8859_1_A7 KEY_TILDE + SHIFT_MASK // 167 § SECTION SIGN +#define ISO_8859_1_A8 DIAERESIS_BITS + KEY_SPACE // 168 ¨ DIAERESIS +#define ISO_8859_1_A9 0 // 169 © COPYRIGHT SIGN +#define ISO_8859_1_AA 0 // 170 ª FEMININE ORDINAL +#define ISO_8859_1_AB KEY_4 // 171 « LEFT DOUBLE ANGLE QUOTE +#define ISO_8859_1_AC 0 // 172 ¬ NOT SIGN +#define ISO_8859_1_AD 0 // 173 SOFT HYPHEN +#define ISO_8859_1_AE 0 // 174 ® REGISTERED SIGN +#define ISO_8859_1_AF 0 // 175 ¯ MACRON +#define ISO_8859_1_B0 0 // 176 ° DEGREE SIGN +#define ISO_8859_1_B1 0 // 177 ± PLUS-MINUS SIGN +#define ISO_8859_1_B2 0 // 178 ² SUPERSCRIPT TWO +#define ISO_8859_1_B3 0 // 179 ³ SUPERSCRIPT THREE +#define ISO_8859_1_B4 ACUTE_ACCENT_BITS + KEY_SPACE // 180 ´ ACUTE ACCENT +#define ISO_8859_1_B5 KEY_M + ALTGR_MASK // 181 µ MICRO SIGN +#define ISO_8859_1_B6 0 // 182 ¶ PILCROW SIGN +#define ISO_8859_1_B7 0 // 183 · MIDDLE DOT +#define ISO_8859_1_B8 0 // 184 ¸ CEDILLA +#define ISO_8859_1_B9 0 // 185 ¹ SUPERSCRIPT ONE +#define ISO_8859_1_BA 0 // 186 º MASCULINE ORDINAL +#define ISO_8859_1_BB 0 // 187 » RIGHT DOUBLE ANGLE QUOTE +#define ISO_8859_1_BC 0 // 188 ¼ FRACTION ONE QUARTER +#define ISO_8859_1_BD KEY_TILDE // 189 ½ FRACTION ONE HALF +#define ISO_8859_1_BE 0 // 190 ¾ FRACTION THREE QUARTERS +#define ISO_8859_1_BF 0 // 191 ¿ INVERTED QUESTION MARK +#define ISO_8859_1_C0 GRAVE_ACCENT_BITS + KEY_A + SHIFT_MASK // 192 À A GRAVE +#define ISO_8859_1_C1 ACUTE_ACCENT_BITS + KEY_A + SHIFT_MASK // 193 Á A ACUTE +#define ISO_8859_1_C2 CIRCUMFLEX_BITS + KEY_A + SHIFT_MASK // 194 Â A CIRCUMFLEX +#define ISO_8859_1_C3 TILDE_BITS + KEY_A + SHIFT_MASK // 195 Ã A TILDE +#define ISO_8859_1_C4 DIAERESIS_BITS + KEY_A + SHIFT_MASK // 196 Ä A DIAERESIS +#define ISO_8859_1_C5 KEY_LEFT_BRACE + SHIFT_MASK // 197 Å A RING ABOVE +#define ISO_8859_1_C6 KEY_QUOTE + SHIFT_MASK // 198 Æ AE +#define ISO_8859_1_C7 0 // 199 Ç C CEDILLA +#define ISO_8859_1_C8 GRAVE_ACCENT_BITS + KEY_E + SHIFT_MASK // 200 È E GRAVE +#define ISO_8859_1_C9 ACUTE_ACCENT_BITS + KEY_E + SHIFT_MASK // 201 É E ACUTE +#define ISO_8859_1_CA CIRCUMFLEX_BITS + KEY_E + SHIFT_MASK // 202 Ê E CIRCUMFLEX +#define ISO_8859_1_CB DIAERESIS_BITS + KEY_E + SHIFT_MASK // 203 Ë E DIAERESIS +#define ISO_8859_1_CC GRAVE_ACCENT_BITS + KEY_I + SHIFT_MASK // 204 Ì I GRAVE +#define ISO_8859_1_CD ACUTE_ACCENT_BITS + KEY_I + SHIFT_MASK // 205 Í I ACUTE +#define ISO_8859_1_CE CIRCUMFLEX_BITS + KEY_I + SHIFT_MASK // 206 Î I CIRCUMFLEX +#define ISO_8859_1_CF DIAERESIS_BITS + KEY_I + SHIFT_MASK // 207 Ï I DIAERESIS +#define ISO_8859_1_D0 KEY_D + ALTGR_MASK + SHIFT_MASK // 208 Ð ETH +#define ISO_8859_1_D1 TILDE_BITS + KEY_N + SHIFT_MASK // 209 Ñ N TILDE +#define ISO_8859_1_D2 GRAVE_ACCENT_BITS + KEY_O + SHIFT_MASK // 210 Ò O GRAVE +#define ISO_8859_1_D3 ACUTE_ACCENT_BITS + KEY_O + SHIFT_MASK // 211 Ó O ACUTE +#define ISO_8859_1_D4 CIRCUMFLEX_BITS + KEY_O + SHIFT_MASK // 212 Ô O CIRCUMFLEX +#define ISO_8859_1_D5 TILDE_BITS + KEY_O + SHIFT_MASK // 213 Õ O TILDE +#define ISO_8859_1_D6 DIAERESIS_BITS + KEY_O + SHIFT_MASK // 214 Ö O DIAERESIS +#define ISO_8859_1_D7 0 // 215 × MULTIPLICATION +#define ISO_8859_1_D8 KEY_SEMICOLON + SHIFT_MASK // 216 Ø O STROKE +#define ISO_8859_1_D9 GRAVE_ACCENT_BITS + KEY_U + SHIFT_MASK // 217 Ù U GRAVE +#define ISO_8859_1_DA ACUTE_ACCENT_BITS + KEY_U + SHIFT_MASK // 218 Ú U ACUTE +#define ISO_8859_1_DB CIRCUMFLEX_BITS + KEY_U + SHIFT_MASK // 219 Û U CIRCUMFLEX +#define ISO_8859_1_DC DIAERESIS_BITS + KEY_U + SHIFT_MASK // 220 Ü U DIAERESIS +#define ISO_8859_1_DD ACUTE_ACCENT_BITS + KEY_Y + SHIFT_MASK // 221 Ý Y ACUTE +#define ISO_8859_1_DE KEY_T + ALTGR_MASK + SHIFT_MASK // 222 Þ THORN +#define ISO_8859_1_DF KEY_S + ALTGR_MASK // 223 ß SHARP S +#define ISO_8859_1_E0 GRAVE_ACCENT_BITS + KEY_A // 224 à a GRAVE +#define ISO_8859_1_E1 ACUTE_ACCENT_BITS + KEY_A // 225 á a ACUTE +#define ISO_8859_1_E2 CIRCUMFLEX_BITS + KEY_A // 226 â a CIRCUMFLEX +#define ISO_8859_1_E3 TILDE_BITS + KEY_A // 227 ã a TILDE +#define ISO_8859_1_E4 DIAERESIS_BITS + KEY_A // 228 ä a DIAERESIS +#define ISO_8859_1_E5 KEY_LEFT_BRACE // 229 å a RING ABOVE +#define ISO_8859_1_E6 KEY_QUOTE // 230 æ ae +#define ISO_8859_1_E7 0 // 231 ç c CEDILLA +#define ISO_8859_1_E8 GRAVE_ACCENT_BITS + KEY_E // 232 è e GRAVE +#define ISO_8859_1_E9 ACUTE_ACCENT_BITS + KEY_E // 233 é e ACUTE +#define ISO_8859_1_EA CIRCUMFLEX_BITS + KEY_E // 234 ê e CIRCUMFLEX +#define ISO_8859_1_EB DIAERESIS_BITS + KEY_E // 235 ë e DIAERESIS +#define ISO_8859_1_EC GRAVE_ACCENT_BITS + KEY_I // 236 ì i GRAVE +#define ISO_8859_1_ED ACUTE_ACCENT_BITS + KEY_I // 237 í i ACUTE +#define ISO_8859_1_EE CIRCUMFLEX_BITS + KEY_I // 238 î i CIRCUMFLEX +#define ISO_8859_1_EF DIAERESIS_BITS + KEY_I // 239 ï i DIAERESIS +#define ISO_8859_1_F0 KEY_D + ALTGR_MASK // 240 ð ETH +#define ISO_8859_1_F1 TILDE_BITS + KEY_N // 241 ñ n TILDE +#define ISO_8859_1_F2 GRAVE_ACCENT_BITS + KEY_O // 242 ò o GRAVE +#define ISO_8859_1_F3 ACUTE_ACCENT_BITS + KEY_O // 243 ó o ACUTE +#define ISO_8859_1_F4 CIRCUMFLEX_BITS + KEY_O // 244 ô o CIRCUMFLEX +#define ISO_8859_1_F5 TILDE_BITS + KEY_O // 245 õ o TILDE +#define ISO_8859_1_F6 DIAERESIS_BITS + KEY_O // 246 ö o DIAERESIS +#define ISO_8859_1_F7 0 // 247 ÷ DIVISION +#define ISO_8859_1_F8 KEY_SEMICOLON // 248 ø o STROKE +#define ISO_8859_1_F9 GRAVE_ACCENT_BITS + KEY_U // 249 ù u GRAVE +#define ISO_8859_1_FA ACUTE_ACCENT_BITS + KEY_U // 250 ú u ACUTE +#define ISO_8859_1_FB CIRCUMFLEX_BITS + KEY_U // 251 û u CIRCUMFLEX +#define ISO_8859_1_FC DIAERESIS_BITS + KEY_U // 252 ü u DIAERESIS +#define ISO_8859_1_FD ACUTE_ACCENT_BITS + KEY_Y // 253 ý y ACUTE +#define ISO_8859_1_FE KEY_T + ALTGR_MASK // 254 þ THORN +#define ISO_8859_1_FF DIAERESIS_BITS + KEY_Y // 255 ÿ y DIAERESIS +#define UNICODE_20AC KEY_E + ALTGR_MASK // € Euro Sign +// not yet implemented +#define UNICODE_EXTRA00 0x20AC +#define KEYCODE_EXTRA00 KEY_E + ALTGR_MASK // 20AC € Euro Sign + +#endif // LAYOUT_NORWEGIAN + + + + + + +#ifdef LAYOUT_SWEDISH + +#define SHIFT_MASK 0x0040 +#define ALTGR_MASK 0x0080 +#define DEADKEYS_MASK 0x0700 +#define CIRCUMFLEX_BITS 0x0100 +#define ACUTE_ACCENT_BITS 0x0200 +#define GRAVE_ACCENT_BITS 0x0300 +#define TILDE_BITS 0x0400 +#define DIAERESIS_BITS 0x0500 +#define KEYCODE_TYPE uint16_t +#define KEYCODE_MASK 0x07FF +#define DEADKEY_CIRCUMFLEX KEY_RIGHT_BRACE + SHIFT_MASK +#define DEADKEY_ACUTE_ACCENT KEY_EQUAL +#define DEADKEY_GRAVE_ACCENT KEY_EQUAL + SHIFT_MASK +#define DEADKEY_TILDE KEY_RIGHT_BRACE + ALTGR_MASK +#define DEADKEY_DIAERESIS KEY_RIGHT_BRACE +#define KEY_NON_US_100 63 + +#define ASCII_20 KEY_SPACE // 32 +#define ASCII_21 KEY_1 + SHIFT_MASK // 33 ! +#define ASCII_22 KEY_2 + SHIFT_MASK // 34 " +#define ASCII_23 KEY_3 + SHIFT_MASK // 35 # +#define ASCII_24 KEY_4 + ALTGR_MASK // 36 $ +#define ASCII_25 KEY_5 + SHIFT_MASK // 37 % +#define ASCII_26 KEY_6 + SHIFT_MASK // 38 & +#define ASCII_27 KEY_BACKSLASH // 39 ' +#define ASCII_28 KEY_8 + SHIFT_MASK // 40 ( +#define ASCII_29 KEY_9 + SHIFT_MASK // 41 ) +#define ASCII_2A KEY_BACKSLASH + SHIFT_MASK // 42 * +#define ASCII_2B KEY_MINUS // 43 + +#define ASCII_2C KEY_COMMA // 44 , +#define ASCII_2D KEY_SLASH // 45 - +#define ASCII_2E KEY_PERIOD // 46 . +#define ASCII_2F KEY_7 + SHIFT_MASK // 47 / +#define ASCII_30 KEY_0 // 48 0 +#define ASCII_31 KEY_1 // 49 1 +#define ASCII_32 KEY_2 // 50 2 +#define ASCII_33 KEY_3 // 51 3 +#define ASCII_34 KEY_4 // 52 4 +#define ASCII_35 KEY_5 // 53 5 +#define ASCII_36 KEY_6 // 54 6 +#define ASCII_37 KEY_7 // 55 7 +#define ASCII_38 KEY_8 // 55 8 +#define ASCII_39 KEY_9 // 57 9 +#define ASCII_3A KEY_PERIOD + SHIFT_MASK // 58 : +#define ASCII_3B KEY_COMMA + SHIFT_MASK // 59 ; +#define ASCII_3C KEY_NON_US_100 // 60 < +#define ASCII_3D KEY_0 + SHIFT_MASK // 61 = +#define ASCII_3E KEY_NON_US_100 + SHIFT_MASK // 62 > +#define ASCII_3F KEY_MINUS + SHIFT_MASK // 63 ? +#define ASCII_40 KEY_2 + ALTGR_MASK // 64 @ +#define ASCII_41 KEY_A + SHIFT_MASK // 65 A +#define ASCII_42 KEY_B + SHIFT_MASK // 66 B +#define ASCII_43 KEY_C + SHIFT_MASK // 67 C +#define ASCII_44 KEY_D + SHIFT_MASK // 68 D +#define ASCII_45 KEY_E + SHIFT_MASK // 69 E +#define ASCII_46 KEY_F + SHIFT_MASK // 70 F +#define ASCII_47 KEY_G + SHIFT_MASK // 71 G +#define ASCII_48 KEY_H + SHIFT_MASK // 72 H +#define ASCII_49 KEY_I + SHIFT_MASK // 73 I +#define ASCII_4A KEY_J + SHIFT_MASK // 74 J +#define ASCII_4B KEY_K + SHIFT_MASK // 75 K +#define ASCII_4C KEY_L + SHIFT_MASK // 76 L +#define ASCII_4D KEY_M + SHIFT_MASK // 77 M +#define ASCII_4E KEY_N + SHIFT_MASK // 78 N +#define ASCII_4F KEY_O + SHIFT_MASK // 79 O +#define ASCII_50 KEY_P + SHIFT_MASK // 80 P +#define ASCII_51 KEY_Q + SHIFT_MASK // 81 Q +#define ASCII_52 KEY_R + SHIFT_MASK // 82 R +#define ASCII_53 KEY_S + SHIFT_MASK // 83 S +#define ASCII_54 KEY_T + SHIFT_MASK // 84 T +#define ASCII_55 KEY_U + SHIFT_MASK // 85 U +#define ASCII_56 KEY_V + SHIFT_MASK // 86 V +#define ASCII_57 KEY_W + SHIFT_MASK // 87 W +#define ASCII_58 KEY_X + SHIFT_MASK // 88 X +#define ASCII_59 KEY_Y + SHIFT_MASK // 89 Y +#define ASCII_5A KEY_Z + SHIFT_MASK // 90 Z +#define ASCII_5B KEY_8 + ALTGR_MASK // 91 [ +#define ASCII_5C KEY_MINUS + ALTGR_MASK // 92 +#define ASCII_5D KEY_9 + ALTGR_MASK // 93 ] +#define ASCII_5E CIRCUMFLEX_BITS + KEY_SPACE // 94 ^ +#define ASCII_5F KEY_SLASH + SHIFT_MASK // 95 _ +#define ASCII_60 GRAVE_ACCENT_BITS + KEY_SPACE // 96 ` +#define ASCII_61 KEY_A // 97 a +#define ASCII_62 KEY_B // 98 b +#define ASCII_63 KEY_C // 99 c +#define ASCII_64 KEY_D // 100 d +#define ASCII_65 KEY_E // 101 e +#define ASCII_66 KEY_F // 102 f +#define ASCII_67 KEY_G // 103 g +#define ASCII_68 KEY_H // 104 h +#define ASCII_69 KEY_I // 105 i +#define ASCII_6A KEY_J // 106 j +#define ASCII_6B KEY_K // 107 k +#define ASCII_6C KEY_L // 108 l +#define ASCII_6D KEY_M // 109 m +#define ASCII_6E KEY_N // 110 n +#define ASCII_6F KEY_O // 111 o +#define ASCII_70 KEY_P // 112 p +#define ASCII_71 KEY_Q // 113 q +#define ASCII_72 KEY_R // 114 r +#define ASCII_73 KEY_S // 115 s +#define ASCII_74 KEY_T // 116 t +#define ASCII_75 KEY_U // 117 u +#define ASCII_76 KEY_V // 118 v +#define ASCII_77 KEY_W // 119 w +#define ASCII_78 KEY_X // 120 x +#define ASCII_79 KEY_Y // 121 y +#define ASCII_7A KEY_Z // 122 z +#define ASCII_7B KEY_7 + ALTGR_MASK // 123 { +#define ASCII_7C KEY_NON_US_100 + ALTGR_MASK // 124 | +#define ASCII_7D KEY_0 + ALTGR_MASK // 125 } +#define ASCII_7E TILDE_BITS + KEY_SPACE // 126 ~ +#define ASCII_7F KEY_BACKSPACE // 127 + +#define ISO_8859_1_A0 KEY_SPACE // 160 Nonbreakng Space +#define ISO_8859_1_A1 0 // 161 ¡ Inverted Exclamation +#define ISO_8859_1_A2 0 // 162 ¢ Cent SIGN +#define ISO_8859_1_A3 KEY_3 + ALTGR_MASK // 163 £ Pound Sign +#define ISO_8859_1_A4 KEY_4 + SHIFT_MASK // 164 ¤ Currency Sign +#define ISO_8859_1_A5 0 // 165 ¥ YEN SIGN +#define ISO_8859_1_A6 0 // 166 ¦ BROKEN BAR +#define ISO_8859_1_A7 KEY_TILDE // 167 § SECTION SIGN +#define ISO_8859_1_A8 DIAERESIS_BITS + KEY_SPACE // 168 ¨ DIAERESIS +#define ISO_8859_1_A9 0 // 169 © COPYRIGHT SIGN +#define ISO_8859_1_AA 0 // 170 ª FEMININE ORDINAL +#define ISO_8859_1_AB KEY_4 // 171 « LEFT DOUBLE ANGLE QUOTE +#define ISO_8859_1_AC 0 // 172 ¬ NOT SIGN +#define ISO_8859_1_AD 0 // 173 SOFT HYPHEN +#define ISO_8859_1_AE 0 // 174 ® REGISTERED SIGN +#define ISO_8859_1_AF 0 // 175 ¯ MACRON +#define ISO_8859_1_B0 0 // 176 ° DEGREE SIGN +#define ISO_8859_1_B1 0 // 177 ± PLUS-MINUS SIGN +#define ISO_8859_1_B2 0 // 178 ² SUPERSCRIPT TWO +#define ISO_8859_1_B3 0 // 179 ³ SUPERSCRIPT THREE +#define ISO_8859_1_B4 ACUTE_ACCENT_BITS + KEY_SPACE // 180 ´ ACUTE ACCENT +#define ISO_8859_1_B5 KEY_M + ALTGR_MASK // 181 µ MICRO SIGN +#define ISO_8859_1_B6 0 // 182 ¶ PILCROW SIGN +#define ISO_8859_1_B7 0 // 183 · MIDDLE DOT +#define ISO_8859_1_B8 0 // 184 ¸ CEDILLA +#define ISO_8859_1_B9 0 // 185 ¹ SUPERSCRIPT ONE +#define ISO_8859_1_BA 0 // 186 º MASCULINE ORDINAL +#define ISO_8859_1_BB 0 // 187 » RIGHT DOUBLE ANGLE QUOTE +#define ISO_8859_1_BC 0 // 188 ¼ FRACTION ONE QUARTER +#define ISO_8859_1_BD KEY_TILDE + SHIFT_MASK // 189 ½ FRACTION ONE HALF +#define ISO_8859_1_BE 0 // 190 ¾ FRACTION THREE QUARTERS +#define ISO_8859_1_BF 0 // 191 ¿ INVERTED QUESTION MARK +#define ISO_8859_1_C0 GRAVE_ACCENT_BITS + KEY_A + SHIFT_MASK // 192 À A GRAVE +#define ISO_8859_1_C1 ACUTE_ACCENT_BITS + KEY_A + SHIFT_MASK // 193 Á A ACUTE +#define ISO_8859_1_C2 CIRCUMFLEX_BITS + KEY_A + SHIFT_MASK // 194 Â A CIRCUMFLEX +#define ISO_8859_1_C3 TILDE_BITS + KEY_A + SHIFT_MASK // 195 Ã A TILDE +#define ISO_8859_1_C4 KEY_QUOTE + SHIFT_MASK // 196 Ä A DIAERESIS +#define ISO_8859_1_C5 KEY_LEFT_BRACE + SHIFT_MASK // 197 Å A RING ABOVE +#define ISO_8859_1_C6 0 // 198 Æ AE +#define ISO_8859_1_C7 0 // 199 Ç C CEDILLA +#define ISO_8859_1_C8 GRAVE_ACCENT_BITS + KEY_E + SHIFT_MASK // 200 È E GRAVE +#define ISO_8859_1_C9 ACUTE_ACCENT_BITS + KEY_E + SHIFT_MASK // 201 É E ACUTE +#define ISO_8859_1_CA CIRCUMFLEX_BITS + KEY_E + SHIFT_MASK // 202 Ê E CIRCUMFLEX +#define ISO_8859_1_CB DIAERESIS_BITS + KEY_E + SHIFT_MASK // 203 Ë E DIAERESIS +#define ISO_8859_1_CC GRAVE_ACCENT_BITS + KEY_I + SHIFT_MASK // 204 Ì I GRAVE +#define ISO_8859_1_CD ACUTE_ACCENT_BITS + KEY_I + SHIFT_MASK // 205 Í I ACUTE +#define ISO_8859_1_CE CIRCUMFLEX_BITS + KEY_I + SHIFT_MASK // 206 Î I CIRCUMFLEX +#define ISO_8859_1_CF DIAERESIS_BITS + KEY_I + SHIFT_MASK // 207 Ï I DIAERESIS +#define ISO_8859_1_D0 KEY_D + ALTGR_MASK + SHIFT_MASK // 208 Ð ETH +#define ISO_8859_1_D1 TILDE_BITS + KEY_N + SHIFT_MASK // 209 Ñ N TILDE +#define ISO_8859_1_D2 GRAVE_ACCENT_BITS + KEY_O + SHIFT_MASK // 210 Ò O GRAVE +#define ISO_8859_1_D3 ACUTE_ACCENT_BITS + KEY_O + SHIFT_MASK // 211 Ó O ACUTE +#define ISO_8859_1_D4 CIRCUMFLEX_BITS + KEY_O + SHIFT_MASK // 212 Ô O CIRCUMFLEX +#define ISO_8859_1_D5 TILDE_BITS + KEY_O + SHIFT_MASK // 213 Õ O TILDE +#define ISO_8859_1_D6 KEY_SEMICOLON + SHIFT_MASK // 214 Ö O DIAERESIS +#define ISO_8859_1_D7 0 // 215 × MULTIPLICATION +#define ISO_8859_1_D8 0 // 216 Ø O STROKE +#define ISO_8859_1_D9 GRAVE_ACCENT_BITS + KEY_U + SHIFT_MASK // 217 Ù U GRAVE +#define ISO_8859_1_DA ACUTE_ACCENT_BITS + KEY_U + SHIFT_MASK // 218 Ú U ACUTE +#define ISO_8859_1_DB CIRCUMFLEX_BITS + KEY_U + SHIFT_MASK // 219 Û U CIRCUMFLEX +#define ISO_8859_1_DC DIAERESIS_BITS + KEY_U + SHIFT_MASK // 220 Ü U DIAERESIS +#define ISO_8859_1_DD ACUTE_ACCENT_BITS + KEY_Y + SHIFT_MASK // 221 Ý Y ACUTE +#define ISO_8859_1_DE KEY_T + ALTGR_MASK + SHIFT_MASK // 222 Þ THORN +#define ISO_8859_1_DF KEY_S + ALTGR_MASK // 223 ß SHARP S +#define ISO_8859_1_E0 GRAVE_ACCENT_BITS + KEY_A // 224 à a GRAVE +#define ISO_8859_1_E1 ACUTE_ACCENT_BITS + KEY_A // 225 á a ACUTE +#define ISO_8859_1_E2 CIRCUMFLEX_BITS + KEY_A // 226 â a CIRCUMFLEX +#define ISO_8859_1_E3 TILDE_BITS + KEY_A // 227 ã a TILDE +#define ISO_8859_1_E4 KEY_QUOTE // 228 ä a DIAERESIS +#define ISO_8859_1_E5 KEY_LEFT_BRACE // 229 å a RING ABOVE +#define ISO_8859_1_E6 0 // 230 æ ae +#define ISO_8859_1_E7 0 // 231 ç c CEDILLA +#define ISO_8859_1_E8 GRAVE_ACCENT_BITS + KEY_E // 232 è e GRAVE +#define ISO_8859_1_E9 ACUTE_ACCENT_BITS + KEY_E // 233 é e ACUTE +#define ISO_8859_1_EA CIRCUMFLEX_BITS + KEY_E // 234 ê e CIRCUMFLEX +#define ISO_8859_1_EB DIAERESIS_BITS + KEY_E // 235 ë e DIAERESIS +#define ISO_8859_1_EC GRAVE_ACCENT_BITS + KEY_I // 236 ì i GRAVE +#define ISO_8859_1_ED ACUTE_ACCENT_BITS + KEY_I // 237 í i ACUTE +#define ISO_8859_1_EE CIRCUMFLEX_BITS + KEY_I // 238 î i CIRCUMFLEX +#define ISO_8859_1_EF DIAERESIS_BITS + KEY_I // 239 ï i DIAERESIS +#define ISO_8859_1_F0 KEY_D + ALTGR_MASK // 240 ð ETH +#define ISO_8859_1_F1 TILDE_BITS + KEY_N // 241 ñ n TILDE +#define ISO_8859_1_F2 GRAVE_ACCENT_BITS + KEY_O // 242 ò o GRAVE +#define ISO_8859_1_F3 ACUTE_ACCENT_BITS + KEY_O // 243 ó o ACUTE +#define ISO_8859_1_F4 CIRCUMFLEX_BITS + KEY_O // 244 ô o CIRCUMFLEX +#define ISO_8859_1_F5 TILDE_BITS + KEY_O // 245 õ o TILDE +#define ISO_8859_1_F6 KEY_SEMICOLON // 246 ö o DIAERESIS +#define ISO_8859_1_F7 0 // 247 ÷ DIVISION +#define ISO_8859_1_F8 0 // 248 ø o STROKE +#define ISO_8859_1_F9 GRAVE_ACCENT_BITS + KEY_U // 249 ù u GRAVE +#define ISO_8859_1_FA ACUTE_ACCENT_BITS + KEY_U // 250 ú u ACUTE +#define ISO_8859_1_FB CIRCUMFLEX_BITS + KEY_U // 251 û u CIRCUMFLEX +#define ISO_8859_1_FC DIAERESIS_BITS + KEY_U // 252 ü u DIAERESIS +#define ISO_8859_1_FD ACUTE_ACCENT_BITS + KEY_Y // 253 ý y ACUTE +#define ISO_8859_1_FE KEY_T + ALTGR_MASK // 254 þ THORN +#define ISO_8859_1_FF DIAERESIS_BITS + KEY_Y // 255 ÿ y DIAERESIS +#define UNICODE_20AC KEY_E + ALTGR_MASK // € Euro Sign +// not yet implemented +#define UNICODE_EXTRA00 0x20AC +#define KEYCODE_EXTRA00 KEY_E + ALTGR_MASK // 20AC € Euro Sign + +#endif // LAYOUT_SWEDISH + + + + + + +#ifdef LAYOUT_SPANISH + +#define SHIFT_MASK 0x0040 +#define ALTGR_MASK 0x0080 +#define DEADKEYS_MASK 0x0700 +#define CIRCUMFLEX_BITS 0x0100 +#define ACUTE_ACCENT_BITS 0x0200 +#define GRAVE_ACCENT_BITS 0x0300 +#define TILDE_BITS 0x0400 +#define DIAERESIS_BITS 0x0500 +#define KEYCODE_TYPE uint16_t +#define KEYCODE_MASK 0x07FF +#define DEADKEY_CIRCUMFLEX KEY_LEFT_BRACE + SHIFT_MASK +#define DEADKEY_ACUTE_ACCENT KEY_QUOTE +#define DEADKEY_GRAVE_ACCENT KEY_LEFT_BRACE +#define DEADKEY_TILDE KEY_4 + ALTGR_MASK +#define DEADKEY_DIAERESIS KEY_QUOTE + SHIFT_MASK +#define KEY_NON_US_100 63 + +#define ASCII_20 KEY_SPACE // 32 +#define ASCII_21 KEY_1 + SHIFT_MASK // 33 ! +#define ASCII_22 KEY_2 + SHIFT_MASK // 34 " +#define ASCII_23 KEY_3 + ALTGR_MASK // 35 # +#define ASCII_24 KEY_4 + SHIFT_MASK // 36 $ +#define ASCII_25 KEY_5 + SHIFT_MASK // 37 % +#define ASCII_26 KEY_6 + SHIFT_MASK // 38 & +#define ASCII_27 KEY_MINUS // 39 ' +#define ASCII_28 KEY_8 + SHIFT_MASK // 40 ( +#define ASCII_29 KEY_9 + SHIFT_MASK // 41 ) +#define ASCII_2A KEY_RIGHT_BRACE + SHIFT_MASK // 42 * +#define ASCII_2B KEY_RIGHT_BRACE // 43 + +#define ASCII_2C KEY_COMMA // 44 , +#define ASCII_2D KEY_SLASH // 45 - +#define ASCII_2E KEY_PERIOD // 46 . +#define ASCII_2F KEY_7 + SHIFT_MASK // 47 / +#define ASCII_30 KEY_0 // 48 0 +#define ASCII_31 KEY_1 // 49 1 +#define ASCII_32 KEY_2 // 50 2 +#define ASCII_33 KEY_3 // 51 3 +#define ASCII_34 KEY_4 // 52 4 +#define ASCII_35 KEY_5 // 53 5 +#define ASCII_36 KEY_6 // 54 6 +#define ASCII_37 KEY_7 // 55 7 +#define ASCII_38 KEY_8 // 55 8 +#define ASCII_39 KEY_9 // 57 9 +#define ASCII_3A KEY_PERIOD + SHIFT_MASK // 58 : +#define ASCII_3B KEY_COMMA + SHIFT_MASK // 59 ; +#define ASCII_3C KEY_NON_US_100 // 60 < +#define ASCII_3D KEY_0 + SHIFT_MASK // 61 = +#define ASCII_3E KEY_NON_US_100 + SHIFT_MASK // 62 > +#define ASCII_3F KEY_MINUS + SHIFT_MASK // 63 ? +#define ASCII_40 KEY_2 + ALTGR_MASK // 64 @ +#define ASCII_41 KEY_A + SHIFT_MASK // 65 A +#define ASCII_42 KEY_B + SHIFT_MASK // 66 B +#define ASCII_43 KEY_C + SHIFT_MASK // 67 C +#define ASCII_44 KEY_D + SHIFT_MASK // 68 D +#define ASCII_45 KEY_E + SHIFT_MASK // 69 E +#define ASCII_46 KEY_F + SHIFT_MASK // 70 F +#define ASCII_47 KEY_G + SHIFT_MASK // 71 G +#define ASCII_48 KEY_H + SHIFT_MASK // 72 H +#define ASCII_49 KEY_I + SHIFT_MASK // 73 I +#define ASCII_4A KEY_J + SHIFT_MASK // 74 J +#define ASCII_4B KEY_K + SHIFT_MASK // 75 K +#define ASCII_4C KEY_L + SHIFT_MASK // 76 L +#define ASCII_4D KEY_M + SHIFT_MASK // 77 M +#define ASCII_4E KEY_N + SHIFT_MASK // 78 N +#define ASCII_4F KEY_O + SHIFT_MASK // 79 O +#define ASCII_50 KEY_P + SHIFT_MASK // 80 P +#define ASCII_51 KEY_Q + SHIFT_MASK // 81 Q +#define ASCII_52 KEY_R + SHIFT_MASK // 82 R +#define ASCII_53 KEY_S + SHIFT_MASK // 83 S +#define ASCII_54 KEY_T + SHIFT_MASK // 84 T +#define ASCII_55 KEY_U + SHIFT_MASK // 85 U +#define ASCII_56 KEY_V + SHIFT_MASK // 86 V +#define ASCII_57 KEY_W + SHIFT_MASK // 87 W +#define ASCII_58 KEY_X + SHIFT_MASK // 88 X +#define ASCII_59 KEY_Y + SHIFT_MASK // 89 Y +#define ASCII_5A KEY_Z + SHIFT_MASK // 90 Z +#define ASCII_5B KEY_LEFT_BRACE + ALTGR_MASK // 91 [ +#define ASCII_5C KEY_TILDE + ALTGR_MASK // 92 +#define ASCII_5D KEY_RIGHT_BRACE + ALTGR_MASK // 93 ] +#define ASCII_5E CIRCUMFLEX_BITS + KEY_SPACE // 94 ^ +#define ASCII_5F KEY_SLASH + SHIFT_MASK // 95 _ +#define ASCII_60 GRAVE_ACCENT_BITS + KEY_SPACE // 96 ` +#define ASCII_61 KEY_A // 97 a +#define ASCII_62 KEY_B // 98 b +#define ASCII_63 KEY_C // 99 c +#define ASCII_64 KEY_D // 100 d +#define ASCII_65 KEY_E // 101 e +#define ASCII_66 KEY_F // 102 f +#define ASCII_67 KEY_G // 103 g +#define ASCII_68 KEY_H // 104 h +#define ASCII_69 KEY_I // 105 i +#define ASCII_6A KEY_J // 106 j +#define ASCII_6B KEY_K // 107 k +#define ASCII_6C KEY_L // 108 l +#define ASCII_6D KEY_M // 109 m +#define ASCII_6E KEY_N // 110 n +#define ASCII_6F KEY_O // 111 o +#define ASCII_70 KEY_P // 112 p +#define ASCII_71 KEY_Q // 113 q +#define ASCII_72 KEY_R // 114 r +#define ASCII_73 KEY_S // 115 s +#define ASCII_74 KEY_T // 116 t +#define ASCII_75 KEY_U // 117 u +#define ASCII_76 KEY_V // 118 v +#define ASCII_77 KEY_W // 119 w +#define ASCII_78 KEY_X // 120 x +#define ASCII_79 KEY_Y // 121 y +#define ASCII_7A KEY_Z // 122 z +#define ASCII_7B KEY_QUOTE + ALTGR_MASK // 123 { +#define ASCII_7C KEY_1 + ALTGR_MASK // 124 | +#define ASCII_7D KEY_BACKSLASH + ALTGR_MASK // 125 } +#define ASCII_7E TILDE_BITS + KEY_SPACE // 126 ~ +#define ASCII_7F KEY_BACKSPACE // 127 + +#define ISO_8859_1_A0 KEY_SPACE // 160 Nonbreakng Space +#define ISO_8859_1_A1 KEY_EQUAL // 161 ¡ Inverted Exclamation +#define ISO_8859_1_A2 0 // 162 ¢ Cent SIGN +#define ISO_8859_1_A3 0 // 163 £ Pound Sign +#define ISO_8859_1_A4 0 // 164 ¤ Currency Sign +#define ISO_8859_1_A5 0 // 165 ¥ YEN SIGN +#define ISO_8859_1_A6 0 // 166 ¦ BROKEN BAR +#define ISO_8859_1_A7 0 // 167 § SECTION SIGN +#define ISO_8859_1_A8 DIAERESIS_BITS + KEY_SPACE // 168 ¨ DIAERESIS +#define ISO_8859_1_A9 0 // 169 © COPYRIGHT SIGN +#define ISO_8859_1_AA KEY_TILDE + SHIFT_MASK // 170 ª FEMININE ORDINAL +#define ISO_8859_1_AB 0 // 171 « LEFT DOUBLE ANGLE QUOTE +#define ISO_8859_1_AC KEY_6 + ALTGR_MASK // 172 ¬ NOT SIGN +#define ISO_8859_1_AD 0 // 173 SOFT HYPHEN +#define ISO_8859_1_AE 0 // 174 ® REGISTERED SIGN +#define ISO_8859_1_AF 0 // 175 ¯ MACRON +#define ISO_8859_1_B0 0 // 176 ° DEGREE SIGN +#define ISO_8859_1_B1 0 // 177 ± PLUS-MINUS SIGN +#define ISO_8859_1_B2 0 // 178 ² SUPERSCRIPT TWO +#define ISO_8859_1_B3 0 // 179 ³ SUPERSCRIPT THREE +#define ISO_8859_1_B4 ACUTE_ACCENT_BITS + KEY_SPACE // 180 ´ ACUTE ACCENT +#define ISO_8859_1_B5 0 // 181 µ MICRO SIGN +#define ISO_8859_1_B6 0 // 182 ¶ PILCROW SIGN +#define ISO_8859_1_B7 KEY_3 + SHIFT_MASK // 183 · MIDDLE DOT +#define ISO_8859_1_B8 0 // 184 ¸ CEDILLA +#define ISO_8859_1_B9 0 // 185 ¹ SUPERSCRIPT ONE +#define ISO_8859_1_BA KEY_TILDE // 186 º MASCULINE ORDINAL +#define ISO_8859_1_BB 0 // 187 » RIGHT DOUBLE ANGLE QUOTE +#define ISO_8859_1_BC 0 // 188 ¼ FRACTION ONE QUARTER +#define ISO_8859_1_BD 0 // 189 ½ FRACTION ONE HALF +#define ISO_8859_1_BE 0 // 190 ¾ FRACTION THREE QUARTERS +#define ISO_8859_1_BF KEY_EQUAL // 191 ¿ INVERTED QUESTION MARK +#define ISO_8859_1_C0 GRAVE_ACCENT_BITS + KEY_A + SHIFT_MASK // 192 À A GRAVE +#define ISO_8859_1_C1 ACUTE_ACCENT_BITS + KEY_A + SHIFT_MASK // 193 Á A ACUTE +#define ISO_8859_1_C2 CIRCUMFLEX_BITS + KEY_A + SHIFT_MASK // 194 Â A CIRCUMFLEX +#define ISO_8859_1_C3 TILDE_BITS + KEY_A + SHIFT_MASK // 195 Ã A TILDE +#define ISO_8859_1_C4 DIAERESIS_BITS + KEY_A + SHIFT_MASK // 196 Ä A DIAERESIS +#define ISO_8859_1_C5 0 // 197 Å A RING ABOVE +#define ISO_8859_1_C6 0 // 198 Æ AE +#define ISO_8859_1_C7 KEY_BACKSLASH + SHIFT_MASK // 199 Ç C CEDILLA +#define ISO_8859_1_C8 GRAVE_ACCENT_BITS + KEY_E + SHIFT_MASK // 200 È E GRAVE +#define ISO_8859_1_C9 ACUTE_ACCENT_BITS + KEY_E + SHIFT_MASK // 201 É E ACUTE +#define ISO_8859_1_CA CIRCUMFLEX_BITS + KEY_E + SHIFT_MASK // 202 Ê E CIRCUMFLEX +#define ISO_8859_1_CB DIAERESIS_BITS + KEY_E + SHIFT_MASK // 203 Ë E DIAERESIS +#define ISO_8859_1_CC GRAVE_ACCENT_BITS + KEY_I + SHIFT_MASK // 204 Ì I GRAVE +#define ISO_8859_1_CD ACUTE_ACCENT_BITS + KEY_I + SHIFT_MASK // 205 Í I ACUTE +#define ISO_8859_1_CE CIRCUMFLEX_BITS + KEY_I + SHIFT_MASK // 206 Î I CIRCUMFLEX +#define ISO_8859_1_CF DIAERESIS_BITS + KEY_I + SHIFT_MASK // 207 Ï I DIAERESIS +#define ISO_8859_1_D0 0 // 208 Ð ETH +#define ISO_8859_1_D1 KEY_SEMICOLON + SHIFT_MASK // 209 Ñ N TILDE +#define ISO_8859_1_D2 GRAVE_ACCENT_BITS + KEY_O + SHIFT_MASK // 210 Ò O GRAVE +#define ISO_8859_1_D3 ACUTE_ACCENT_BITS + KEY_O + SHIFT_MASK // 211 Ó O ACUTE +#define ISO_8859_1_D4 CIRCUMFLEX_BITS + KEY_O + SHIFT_MASK // 212 Ô O CIRCUMFLEX +#define ISO_8859_1_D5 TILDE_BITS + KEY_O + SHIFT_MASK // 213 Õ O TILDE +#define ISO_8859_1_D6 DIAERESIS_BITS + KEY_O + SHIFT_MASK // 214 Ö O DIAERESIS +#define ISO_8859_1_D7 0 // 215 × MULTIPLICATION +#define ISO_8859_1_D8 0 // 216 Ø O STROKE +#define ISO_8859_1_D9 GRAVE_ACCENT_BITS + KEY_U + SHIFT_MASK // 217 Ù U GRAVE +#define ISO_8859_1_DA ACUTE_ACCENT_BITS + KEY_U + SHIFT_MASK // 218 Ú U ACUTE +#define ISO_8859_1_DB CIRCUMFLEX_BITS + KEY_U + SHIFT_MASK // 219 Û U CIRCUMFLEX +#define ISO_8859_1_DC DIAERESIS_BITS + KEY_U + SHIFT_MASK // 220 Ü U DIAERESIS +#define ISO_8859_1_DD ACUTE_ACCENT_BITS + KEY_Y + SHIFT_MASK // 221 Ý Y ACUTE +#define ISO_8859_1_DE 0 // 222 Þ THORN +#define ISO_8859_1_DF 0 // 223 ß SHARP S +#define ISO_8859_1_E0 GRAVE_ACCENT_BITS + KEY_A // 224 à a GRAVE +#define ISO_8859_1_E1 ACUTE_ACCENT_BITS + KEY_A // 225 á a ACUTE +#define ISO_8859_1_E2 CIRCUMFLEX_BITS + KEY_A // 226 â a CIRCUMFLEX +#define ISO_8859_1_E3 TILDE_BITS + KEY_A // 227 ã a TILDE +#define ISO_8859_1_E4 DIAERESIS_BITS + KEY_A // 228 ä a DIAERESIS +#define ISO_8859_1_E5 0 // 229 å a RING ABOVE +#define ISO_8859_1_E6 0 // 230 æ ae +#define ISO_8859_1_E7 KEY_BACKSLASH // 231 ç c CEDILLA +#define ISO_8859_1_E8 GRAVE_ACCENT_BITS + KEY_E // 232 è e GRAVE +#define ISO_8859_1_E9 ACUTE_ACCENT_BITS + KEY_E // 233 é e ACUTE +#define ISO_8859_1_EA CIRCUMFLEX_BITS + KEY_E // 234 ê e CIRCUMFLEX +#define ISO_8859_1_EB DIAERESIS_BITS + KEY_E // 235 ë e DIAERESIS +#define ISO_8859_1_EC GRAVE_ACCENT_BITS + KEY_I // 236 ì i GRAVE +#define ISO_8859_1_ED ACUTE_ACCENT_BITS + KEY_I // 237 í i ACUTE +#define ISO_8859_1_EE CIRCUMFLEX_BITS + KEY_I // 238 î i CIRCUMFLEX +#define ISO_8859_1_EF DIAERESIS_BITS + KEY_I // 239 ï i DIAERESIS +#define ISO_8859_1_F0 0 // 240 ð ETH +#define ISO_8859_1_F1 KEY_SEMICOLON // 241 ñ n TILDE +#define ISO_8859_1_F2 GRAVE_ACCENT_BITS + KEY_O // 242 ò o GRAVE +#define ISO_8859_1_F3 ACUTE_ACCENT_BITS + KEY_O // 243 ó o ACUTE +#define ISO_8859_1_F4 CIRCUMFLEX_BITS + KEY_O // 244 ô o CIRCUMFLEX +#define ISO_8859_1_F5 TILDE_BITS + KEY_O // 245 õ o TILDE +#define ISO_8859_1_F6 DIAERESIS_BITS + KEY_O // 246 ö o DIAERESIS +#define ISO_8859_1_F7 0 // 247 ÷ DIVISION +#define ISO_8859_1_F8 0 // 248 ø o STROKE +#define ISO_8859_1_F9 GRAVE_ACCENT_BITS + KEY_U // 249 ù u GRAVE +#define ISO_8859_1_FA ACUTE_ACCENT_BITS + KEY_U // 250 ú u ACUTE +#define ISO_8859_1_FB CIRCUMFLEX_BITS + KEY_U // 251 û u CIRCUMFLEX +#define ISO_8859_1_FC DIAERESIS_BITS + KEY_U // 252 ü u DIAERESIS +#define ISO_8859_1_FD ACUTE_ACCENT_BITS + KEY_Y // 253 ý y ACUTE +#define ISO_8859_1_FE 0 // 254 þ THORN +#define ISO_8859_1_FF DIAERESIS_BITS + KEY_Y // 255 ÿ y DIAERESIS +#define UNICODE_20AC KEY_5 + ALTGR_MASK // € Euro Sign +// not yet implemented +#define UNICODE_EXTRA00 0x20AC +#define KEYCODE_EXTRA00 KEY_5 + ALTGR_MASK // 20AC € Euro Sign + +#endif // LAYOUT_SPANISH + + + + +#ifdef LAYOUT_PORTUGUESE + +#define SHIFT_MASK 0x0040 +#define ALTGR_MASK 0x0080 +#define DEADKEYS_MASK 0x0700 +#define CIRCUMFLEX_BITS 0x0100 +#define ACUTE_ACCENT_BITS 0x0200 +#define GRAVE_ACCENT_BITS 0x0300 +#define TILDE_BITS 0x0400 +#define DIAERESIS_BITS 0x0500 +#define KEYCODE_TYPE uint16_t +#define KEYCODE_MASK 0x07FF +#define DEADKEY_CIRCUMFLEX KEY_BACKSLASH +#define DEADKEY_ACUTE_ACCENT KEY_RIGHT_BRACE + SHIFT_MASK +#define DEADKEY_GRAVE_ACCENT KEY_RIGHT_BRACE + SHIFT_MASK +#define DEADKEY_TILDE KEY_BACKSLASH +#define DEADKEY_DIAERESIS KEY_LEFT_BRACE + SHIFT_MASK +#define KEY_NON_US_100 63 + +#define ASCII_20 KEY_SPACE // 32 +#define ASCII_21 KEY_1 + SHIFT_MASK // 33 ! +#define ASCII_22 KEY_2 + SHIFT_MASK // 34 " +#define ASCII_23 KEY_3 + ALTGR_MASK // 35 # +#define ASCII_24 KEY_4 + SHIFT_MASK // 36 $ +#define ASCII_25 KEY_5 + SHIFT_MASK // 37 % +#define ASCII_26 KEY_6 + SHIFT_MASK // 38 & +#define ASCII_27 KEY_MINUS // 39 ' +#define ASCII_28 KEY_8 + SHIFT_MASK // 40 ( +#define ASCII_29 KEY_9 + SHIFT_MASK // 41 ) +#define ASCII_2A KEY_LEFT_BRACE + SHIFT_MASK // 42 * +#define ASCII_2B KEY_LEFT_BRACE // 43 + +#define ASCII_2C KEY_COMMA // 44 , +#define ASCII_2D KEY_SLASH // 45 - +#define ASCII_2E KEY_PERIOD // 46 . +#define ASCII_2F KEY_7 + SHIFT_MASK // 47 / +#define ASCII_30 KEY_0 // 48 0 +#define ASCII_31 KEY_1 // 49 1 +#define ASCII_32 KEY_2 // 50 2 +#define ASCII_33 KEY_3 // 51 3 +#define ASCII_34 KEY_4 // 52 4 +#define ASCII_35 KEY_5 // 53 5 +#define ASCII_36 KEY_6 // 54 6 +#define ASCII_37 KEY_7 // 55 7 +#define ASCII_38 KEY_8 // 55 8 +#define ASCII_39 KEY_9 // 57 9 +#define ASCII_3A KEY_PERIOD + SHIFT_MASK // 58 : +#define ASCII_3B KEY_COMMA + SHIFT_MASK // 59 ; +#define ASCII_3C KEY_NON_US_100 // 60 < +#define ASCII_3D KEY_0 + SHIFT_MASK // 61 = +#define ASCII_3E KEY_NON_US_100 + SHIFT_MASK // 62 > +#define ASCII_3F KEY_MINUS + SHIFT_MASK // 63 ? +#define ASCII_40 KEY_2 + ALTGR_MASK // 64 @ +#define ASCII_41 KEY_A + SHIFT_MASK // 65 A +#define ASCII_42 KEY_B + SHIFT_MASK // 66 B +#define ASCII_43 KEY_C + SHIFT_MASK // 67 C +#define ASCII_44 KEY_D + SHIFT_MASK // 68 D +#define ASCII_45 KEY_E + SHIFT_MASK // 69 E +#define ASCII_46 KEY_F + SHIFT_MASK // 70 F +#define ASCII_47 KEY_G + SHIFT_MASK // 71 G +#define ASCII_48 KEY_H + SHIFT_MASK // 72 H +#define ASCII_49 KEY_I + SHIFT_MASK // 73 I +#define ASCII_4A KEY_J + SHIFT_MASK // 74 J +#define ASCII_4B KEY_K + SHIFT_MASK // 75 K +#define ASCII_4C KEY_L + SHIFT_MASK // 76 L +#define ASCII_4D KEY_M + SHIFT_MASK // 77 M +#define ASCII_4E KEY_N + SHIFT_MASK // 78 N +#define ASCII_4F KEY_O + SHIFT_MASK // 79 O +#define ASCII_50 KEY_P + SHIFT_MASK // 80 P +#define ASCII_51 KEY_Q + SHIFT_MASK // 81 Q +#define ASCII_52 KEY_R + SHIFT_MASK // 82 R +#define ASCII_53 KEY_S + SHIFT_MASK // 83 S +#define ASCII_54 KEY_T + SHIFT_MASK // 84 T +#define ASCII_55 KEY_U + SHIFT_MASK // 85 U +#define ASCII_56 KEY_V + SHIFT_MASK // 86 V +#define ASCII_57 KEY_W + SHIFT_MASK // 87 W +#define ASCII_58 KEY_X + SHIFT_MASK // 88 X +#define ASCII_59 KEY_Y + SHIFT_MASK // 89 Y +#define ASCII_5A KEY_Z + SHIFT_MASK // 90 Z +#define ASCII_5B KEY_8 + ALTGR_MASK // 91 [ +#define ASCII_5C KEY_TILDE + ALTGR_MASK // 92 +#define ASCII_5D KEY_9 + ALTGR_MASK // 93 ] +#define ASCII_5E CIRCUMFLEX_BITS + KEY_SPACE // 94 ^ +#define ASCII_5F KEY_SLASH + SHIFT_MASK // 95 _ +#define ASCII_60 GRAVE_ACCENT_BITS + KEY_SPACE // 96 ` +#define ASCII_61 KEY_A // 97 a +#define ASCII_62 KEY_B // 98 b +#define ASCII_63 KEY_C // 99 c +#define ASCII_64 KEY_D // 100 d +#define ASCII_65 KEY_E // 101 e +#define ASCII_66 KEY_F // 102 f +#define ASCII_67 KEY_G // 103 g +#define ASCII_68 KEY_H // 104 h +#define ASCII_69 KEY_I // 105 i +#define ASCII_6A KEY_J // 106 j +#define ASCII_6B KEY_K // 107 k +#define ASCII_6C KEY_L // 108 l +#define ASCII_6D KEY_M // 109 m +#define ASCII_6E KEY_N // 110 n +#define ASCII_6F KEY_O // 111 o +#define ASCII_70 KEY_P // 112 p +#define ASCII_71 KEY_Q // 113 q +#define ASCII_72 KEY_R // 114 r +#define ASCII_73 KEY_S // 115 s +#define ASCII_74 KEY_T // 116 t +#define ASCII_75 KEY_U // 117 u +#define ASCII_76 KEY_V // 118 v +#define ASCII_77 KEY_W // 119 w +#define ASCII_78 KEY_X // 120 x +#define ASCII_79 KEY_Y // 121 y +#define ASCII_7A KEY_Z // 122 z +#define ASCII_7B KEY_7 + ALTGR_MASK // 123 { +#define ASCII_7C KEY_TILDE + SHIFT_MASK // 124 | +#define ASCII_7D KEY_0 + ALTGR_MASK // 125 } +#define ASCII_7E TILDE_BITS + KEY_SPACE // 126 ~ +#define ASCII_7F KEY_BACKSPACE // 127 + +#define ISO_8859_1_A0 KEY_SPACE // 160 Nonbreakng Space +#define ISO_8859_1_A1 0 // 161 ¡ Inverted Exclamation +#define ISO_8859_1_A2 0 // 162 ¢ Cent SIGN +#define ISO_8859_1_A3 KEY_3 + ALTGR_MASK // 163 £ Pound Sign +#define ISO_8859_1_A4 0 // 164 ¤ Currency Sign +#define ISO_8859_1_A5 0 // 165 ¥ YEN SIGN +#define ISO_8859_1_A6 0 // 166 ¦ BROKEN BAR +#define ISO_8859_1_A7 KEY_4 + ALTGR_MASK // 167 § SECTION SIGN +#define ISO_8859_1_A8 DIAERESIS_BITS + KEY_SPACE // 168 ¨ DIAERESIS +#define ISO_8859_1_A9 0 // 169 © COPYRIGHT SIGN +#define ISO_8859_1_AA KEY_QUOTE + SHIFT_MASK // 170 ª FEMININE ORDINAL +#define ISO_8859_1_AB KEY_EQUAL // 171 « LEFT DOUBLE ANGLE QUOTE +#define ISO_8859_1_AC 0 // 172 ¬ NOT SIGN +#define ISO_8859_1_AD 0 // 173 SOFT HYPHEN +#define ISO_8859_1_AE 0 // 174 ® REGISTERED SIGN +#define ISO_8859_1_AF 0 // 175 ¯ MACRON +#define ISO_8859_1_B0 0 // 176 ° DEGREE SIGN +#define ISO_8859_1_B1 0 // 177 ± PLUS-MINUS SIGN +#define ISO_8859_1_B2 0 // 178 ² SUPERSCRIPT TWO +#define ISO_8859_1_B3 0 // 179 ³ SUPERSCRIPT THREE +#define ISO_8859_1_B4 ACUTE_ACCENT_BITS + KEY_SPACE // 180 ´ ACUTE ACCENT +#define ISO_8859_1_B5 0 // 181 µ MICRO SIGN +#define ISO_8859_1_B6 0 // 182 ¶ PILCROW SIGN +#define ISO_8859_1_B7 0 // 183 · MIDDLE DOT +#define ISO_8859_1_B8 0 // 184 ¸ CEDILLA +#define ISO_8859_1_B9 0 // 185 ¹ SUPERSCRIPT ONE +#define ISO_8859_1_BA KEY_QUOTE // 186 º MASCULINE ORDINAL +#define ISO_8859_1_BB KEY_EQUAL + SHIFT_MASK // 187 » RIGHT DOUBLE ANGLE QUOTE +#define ISO_8859_1_BC 0 // 188 ¼ FRACTION ONE QUARTER +#define ISO_8859_1_BD 0 // 189 ½ FRACTION ONE HALF +#define ISO_8859_1_BE 0 // 190 ¾ FRACTION THREE QUARTERS +#define ISO_8859_1_BF 0 // 191 ¿ INVERTED QUESTION MARK +#define ISO_8859_1_C0 GRAVE_ACCENT_BITS + KEY_A + SHIFT_MASK // 192 À A GRAVE +#define ISO_8859_1_C1 ACUTE_ACCENT_BITS + KEY_A + SHIFT_MASK // 193 Á A ACUTE +#define ISO_8859_1_C2 CIRCUMFLEX_BITS + KEY_A + SHIFT_MASK // 194 Â A CIRCUMFLEX +#define ISO_8859_1_C3 TILDE_BITS + KEY_A + SHIFT_MASK // 195 Ã A TILDE +#define ISO_8859_1_C4 DIAERESIS_BITS + KEY_A + SHIFT_MASK // 196 Ä A DIAERESIS +#define ISO_8859_1_C5 0 // 197 Å A RING ABOVE +#define ISO_8859_1_C6 0 // 198 Æ AE +#define ISO_8859_1_C7 KEY_SEMICOLON + SHIFT_MASK // 199 Ç C CEDILLA +#define ISO_8859_1_C8 GRAVE_ACCENT_BITS + KEY_E + SHIFT_MASK // 200 È E GRAVE +#define ISO_8859_1_C9 ACUTE_ACCENT_BITS + KEY_E + SHIFT_MASK // 201 É E ACUTE +#define ISO_8859_1_CA CIRCUMFLEX_BITS + KEY_E + SHIFT_MASK // 202 Ê E CIRCUMFLEX +#define ISO_8859_1_CB DIAERESIS_BITS + KEY_E + SHIFT_MASK // 203 Ë E DIAERESIS +#define ISO_8859_1_CC GRAVE_ACCENT_BITS + KEY_I + SHIFT_MASK // 204 Ì I GRAVE +#define ISO_8859_1_CD ACUTE_ACCENT_BITS + KEY_I + SHIFT_MASK // 205 Í I ACUTE +#define ISO_8859_1_CE CIRCUMFLEX_BITS + KEY_I + SHIFT_MASK // 206 Î I CIRCUMFLEX +#define ISO_8859_1_CF DIAERESIS_BITS + KEY_I + SHIFT_MASK // 207 Ï I DIAERESIS +#define ISO_8859_1_D0 0 // 208 Ð ETH +#define ISO_8859_1_D1 TILDE_BITS + KEY_N + SHIFT_MASK // 209 Ñ N TILDE +#define ISO_8859_1_D2 GRAVE_ACCENT_BITS + KEY_O + SHIFT_MASK // 210 Ò O GRAVE +#define ISO_8859_1_D3 ACUTE_ACCENT_BITS + KEY_O + SHIFT_MASK // 211 Ó O ACUTE +#define ISO_8859_1_D4 CIRCUMFLEX_BITS + KEY_O + SHIFT_MASK // 212 Ô O CIRCUMFLEX +#define ISO_8859_1_D5 TILDE_BITS + KEY_O + SHIFT_MASK // 213 Õ O TILDE +#define ISO_8859_1_D6 DIAERESIS_BITS + KEY_O + SHIFT_MASK // 214 Ö O DIAERESIS +#define ISO_8859_1_D7 0 // 215 × MULTIPLICATION +#define ISO_8859_1_D8 0 // 216 Ø O STROKE +#define ISO_8859_1_D9 GRAVE_ACCENT_BITS + KEY_U + SHIFT_MASK // 217 Ù U GRAVE +#define ISO_8859_1_DA ACUTE_ACCENT_BITS + KEY_U + SHIFT_MASK // 218 Ú U ACUTE +#define ISO_8859_1_DB CIRCUMFLEX_BITS + KEY_U + SHIFT_MASK // 219 Û U CIRCUMFLEX +#define ISO_8859_1_DC DIAERESIS_BITS + KEY_U + SHIFT_MASK // 220 Ü U DIAERESIS +#define ISO_8859_1_DD ACUTE_ACCENT_BITS + KEY_Y + SHIFT_MASK // 221 Ý Y ACUTE +#define ISO_8859_1_DE 0 // 222 Þ THORN +#define ISO_8859_1_DF 0 // 223 ß SHARP S +#define ISO_8859_1_E0 GRAVE_ACCENT_BITS + KEY_A // 224 à a GRAVE +#define ISO_8859_1_E1 ACUTE_ACCENT_BITS + KEY_A // 225 á a ACUTE +#define ISO_8859_1_E2 CIRCUMFLEX_BITS + KEY_A // 226 â a CIRCUMFLEX +#define ISO_8859_1_E3 TILDE_BITS + KEY_A // 227 ã a TILDE +#define ISO_8859_1_E4 DIAERESIS_BITS + KEY_A // 228 ä a DIAERESIS +#define ISO_8859_1_E5 0 // 229 å a RING ABOVE +#define ISO_8859_1_E6 0 // 230 æ ae +#define ISO_8859_1_E7 KEY_SEMICOLON // 231 ç c CEDILLA +#define ISO_8859_1_E8 GRAVE_ACCENT_BITS + KEY_E // 232 è e GRAVE +#define ISO_8859_1_E9 ACUTE_ACCENT_BITS + KEY_E // 233 é e ACUTE +#define ISO_8859_1_EA CIRCUMFLEX_BITS + KEY_E // 234 ê e CIRCUMFLEX +#define ISO_8859_1_EB DIAERESIS_BITS + KEY_E // 235 ë e DIAERESIS +#define ISO_8859_1_EC GRAVE_ACCENT_BITS + KEY_I // 236 ì i GRAVE +#define ISO_8859_1_ED ACUTE_ACCENT_BITS + KEY_I // 237 í i ACUTE +#define ISO_8859_1_EE CIRCUMFLEX_BITS + KEY_I // 238 î i CIRCUMFLEX +#define ISO_8859_1_EF DIAERESIS_BITS + KEY_I // 239 ï i DIAERESIS +#define ISO_8859_1_F0 0 // 240 ð ETH +#define ISO_8859_1_F1 TILDE_BITS + KEY_N // 241 ñ n TILDE +#define ISO_8859_1_F2 GRAVE_ACCENT_BITS + KEY_O // 242 ò o GRAVE +#define ISO_8859_1_F3 ACUTE_ACCENT_BITS + KEY_O // 243 ó o ACUTE +#define ISO_8859_1_F4 CIRCUMFLEX_BITS + KEY_O // 244 ô o CIRCUMFLEX +#define ISO_8859_1_F5 TILDE_BITS + KEY_O // 245 õ o TILDE +#define ISO_8859_1_F6 DIAERESIS_BITS + KEY_O // 246 ö o DIAERESIS +#define ISO_8859_1_F7 0 // 247 ÷ DIVISION +#define ISO_8859_1_F8 0 // 248 ø o STROKE +#define ISO_8859_1_F9 GRAVE_ACCENT_BITS + KEY_U // 249 ù u GRAVE +#define ISO_8859_1_FA ACUTE_ACCENT_BITS + KEY_U // 250 ú u ACUTE +#define ISO_8859_1_FB CIRCUMFLEX_BITS + KEY_U // 251 û u CIRCUMFLEX +#define ISO_8859_1_FC DIAERESIS_BITS + KEY_U // 252 ü u DIAERESIS +#define ISO_8859_1_FD ACUTE_ACCENT_BITS + KEY_Y // 253 ý y ACUTE +#define ISO_8859_1_FE 0 // 254 þ THORN +#define ISO_8859_1_FF DIAERESIS_BITS + KEY_Y // 255 ÿ y DIAERESIS +#define UNICODE_20AC KEY_E + ALTGR_MASK // € Euro Sign +// not yet implemented +#define UNICODE_EXTRA00 0x20AC +#define KEYCODE_EXTRA00 KEY_E + ALTGR_MASK // 20AC € Euro Sign + +#endif // LAYOUT_PORTUGUESE + + + + + + + +#ifdef LAYOUT_ITALIAN + +#define SHIFT_MASK 0x40 +#define ALTGR_MASK 0x80 +#define KEYCODE_TYPE uint8_t +#define KEYCODE_MASK 0x00FF +#define KEY_NON_US_100 63 + +#define ASCII_20 KEY_SPACE // 32 +#define ASCII_21 KEY_1 + SHIFT_MASK // 33 ! +#define ASCII_22 KEY_2 + SHIFT_MASK // 34 " +#define ASCII_23 KEY_QUOTE + ALTGR_MASK // 35 # +#define ASCII_24 KEY_4 + SHIFT_MASK // 36 $ +#define ASCII_25 KEY_5 + SHIFT_MASK // 37 % +#define ASCII_26 KEY_6 + SHIFT_MASK // 38 & +#define ASCII_27 KEY_MINUS // 39 ' +#define ASCII_28 KEY_8 + SHIFT_MASK // 40 ( +#define ASCII_29 KEY_9 + SHIFT_MASK // 41 ) +#define ASCII_2A KEY_RIGHT_BRACE + SHIFT_MASK // 42 * +#define ASCII_2B KEY_RIGHT_BRACE // 43 + +#define ASCII_2C KEY_COMMA // 44 , +#define ASCII_2D KEY_SLASH // 45 - +#define ASCII_2E KEY_PERIOD // 46 . +#define ASCII_2F KEY_7 + SHIFT_MASK // 47 / +#define ASCII_30 KEY_0 // 48 0 +#define ASCII_31 KEY_1 // 49 1 +#define ASCII_32 KEY_2 // 50 2 +#define ASCII_33 KEY_3 // 51 3 +#define ASCII_34 KEY_4 // 52 4 +#define ASCII_35 KEY_5 // 53 5 +#define ASCII_36 KEY_6 // 54 6 +#define ASCII_37 KEY_7 // 55 7 +#define ASCII_38 KEY_8 // 55 8 +#define ASCII_39 KEY_9 // 57 9 +#define ASCII_3A KEY_PERIOD + SHIFT_MASK // 58 : +#define ASCII_3B KEY_COMMA + SHIFT_MASK // 59 ; +#define ASCII_3C KEY_NON_US_100 // 60 < +#define ASCII_3D KEY_0 + SHIFT_MASK // 61 = +#define ASCII_3E KEY_NON_US_100 + SHIFT_MASK // 62 > +#define ASCII_3F KEY_MINUS + SHIFT_MASK // 63 ? +#define ASCII_40 KEY_SEMICOLON + ALTGR_MASK // 64 @ +#define ASCII_41 KEY_A + SHIFT_MASK // 65 A +#define ASCII_42 KEY_B + SHIFT_MASK // 66 B +#define ASCII_43 KEY_C + SHIFT_MASK // 67 C +#define ASCII_44 KEY_D + SHIFT_MASK // 68 D +#define ASCII_45 KEY_E + SHIFT_MASK // 69 E +#define ASCII_46 KEY_F + SHIFT_MASK // 70 F +#define ASCII_47 KEY_G + SHIFT_MASK // 71 G +#define ASCII_48 KEY_H + SHIFT_MASK // 72 H +#define ASCII_49 KEY_I + SHIFT_MASK // 73 I +#define ASCII_4A KEY_J + SHIFT_MASK // 74 J +#define ASCII_4B KEY_K + SHIFT_MASK // 75 K +#define ASCII_4C KEY_L + SHIFT_MASK // 76 L +#define ASCII_4D KEY_M + SHIFT_MASK // 77 M +#define ASCII_4E KEY_N + SHIFT_MASK // 78 N +#define ASCII_4F KEY_O + SHIFT_MASK // 79 O +#define ASCII_50 KEY_P + SHIFT_MASK // 80 P +#define ASCII_51 KEY_Q + SHIFT_MASK // 81 Q +#define ASCII_52 KEY_R + SHIFT_MASK // 82 R +#define ASCII_53 KEY_S + SHIFT_MASK // 83 S +#define ASCII_54 KEY_T + SHIFT_MASK // 84 T +#define ASCII_55 KEY_U + SHIFT_MASK // 85 U +#define ASCII_56 KEY_V + SHIFT_MASK // 86 V +#define ASCII_57 KEY_W + SHIFT_MASK // 87 W +#define ASCII_58 KEY_X + SHIFT_MASK // 88 X +#define ASCII_59 KEY_Y + SHIFT_MASK // 89 Y +#define ASCII_5A KEY_Z + SHIFT_MASK // 90 Z +#define ASCII_5B KEY_LEFT_BRACE + ALTGR_MASK // 91 [ +#define ASCII_5C KEY_TILDE // 92 +#define ASCII_5D KEY_RIGHT_BRACE + ALTGR_MASK // 93 ] +#define ASCII_5E KEY_EQUAL + SHIFT_MASK // 94 ^ +#define ASCII_5F KEY_SLASH + SHIFT_MASK // 95 _ +#define ASCII_60 0 // 96 ` (how to type this on Italian?) +#define ASCII_61 KEY_A // 97 a +#define ASCII_62 KEY_B // 98 b +#define ASCII_63 KEY_C // 99 c +#define ASCII_64 KEY_D // 100 d +#define ASCII_65 KEY_E // 101 e +#define ASCII_66 KEY_F // 102 f +#define ASCII_67 KEY_G // 103 g +#define ASCII_68 KEY_H // 104 h +#define ASCII_69 KEY_I // 105 i +#define ASCII_6A KEY_J // 106 j +#define ASCII_6B KEY_K // 107 k +#define ASCII_6C KEY_L // 108 l +#define ASCII_6D KEY_M // 109 m +#define ASCII_6E KEY_N // 110 n +#define ASCII_6F KEY_O // 111 o +#define ASCII_70 KEY_P // 112 p +#define ASCII_71 KEY_Q // 113 q +#define ASCII_72 KEY_R // 114 r +#define ASCII_73 KEY_S // 115 s +#define ASCII_74 KEY_T // 116 t +#define ASCII_75 KEY_U // 117 u +#define ASCII_76 KEY_V // 118 v +#define ASCII_77 KEY_W // 119 w +#define ASCII_78 KEY_X // 120 x +#define ASCII_79 KEY_Y // 121 y +#define ASCII_7A KEY_Z // 122 z +#define ASCII_7B KEY_LEFT_BRACE + SHIFT_MASK + ALTGR_MASK // 123 { +#define ASCII_7C KEY_TILDE + SHIFT_MASK // 124 | +#define ASCII_7D KEY_RIGHT_BRACE + SHIFT_MASK + ALTGR_MASK // 125 } +#define ASCII_7E 0 // 126 ~ (how to type this on Italian?) +#define ASCII_7F KEY_BACKSPACE // 127 + +#define ISO_8859_1_A0 KEY_SPACE // 160 Nonbreakng Space +#define ISO_8859_1_A1 0 // 161 ¡ Inverted Exclamation +#define ISO_8859_1_A2 0 // 162 ¢ Cent Sign +#define ISO_8859_1_A3 KEY_3 + SHIFT_MASK // 163 £ Pound Sign +#define ISO_8859_1_A4 0 // 164 ¤ Currency Sign +#define ISO_8859_1_A5 0 // 165 ¥ YEN SIGN +#define ISO_8859_1_A6 0 // 166 ¦ BROKEN BAR +#define ISO_8859_1_A7 KEY_BACKSLASH + SHIFT_MASK // 167 § SECTION SIGN +#define ISO_8859_1_A8 0 // 168 ¨ DIAERESIS +#define ISO_8859_1_A9 0 // 169 © COPYRIGHT SIGN +#define ISO_8859_1_AA 0 // 170 ª FEMININE ORDINAL +#define ISO_8859_1_AB 0 // 171 « LEFT DOUBLE ANGLE QUOTE +#define ISO_8859_1_AC 0 // 172 ¬ NOT SIGN +#define ISO_8859_1_AD 0 // 173 SOFT HYPHEN +#define ISO_8859_1_AE 0 // 174 ® REGISTERED SIGN +#define ISO_8859_1_AF 0 // 175 ¯ MACRON +#define ISO_8859_1_B0 KEY_QUOTE + SHIFT_MASK // 176 ° DEGREE SIGN +#define ISO_8859_1_B1 0 // 177 ± PLUS-MINUS SIGN +#define ISO_8859_1_B2 0 // 178 ² SUPERSCRIPT TWO +#define ISO_8859_1_B3 0 // 179 ³ SUPERSCRIPT THREE +#define ISO_8859_1_B4 0 // 180 ´ ACUTE ACCENT +#define ISO_8859_1_B5 0 // 181 µ MICRO SIGN +#define ISO_8859_1_B6 0 // 182 ¶ PILCROW SIGN +#define ISO_8859_1_B7 0 // 183 · MIDDLE DOT +#define ISO_8859_1_B8 0 // 184 ¸ CEDILLA +#define ISO_8859_1_B9 0 // 185 ¹ SUPERSCRIPT ONE +#define ISO_8859_1_BA 0 // 186 º MASCULINE ORDINAL +#define ISO_8859_1_BB 0 // 187 » RIGHT DOUBLE ANGLE QUOTE +#define ISO_8859_1_BC 0 // 188 ¼ FRACTION ONE QUARTER +#define ISO_8859_1_BD 0 // 189 ½ FRACTION ONE HALF +#define ISO_8859_1_BE 0 // 190 ¾ FRACTION THREE QUARTERS +#define ISO_8859_1_BF 0 // 191 ¿ INVERTED QUESTION MARK +#define ISO_8859_1_C0 0 // 192 À A GRAVE +#define ISO_8859_1_C1 0 // 193 Á A ACUTE +#define ISO_8859_1_C2 0 // 194 Â A CIRCUMFLEX +#define ISO_8859_1_C3 0 // 195 Ã A TILDE +#define ISO_8859_1_C4 0 // 196 Ä A DIAERESIS +#define ISO_8859_1_C5 0 // 197 Å A RING ABOVE +#define ISO_8859_1_C6 0 // 198 Æ AE +#define ISO_8859_1_C7 0 // 199 Ç C CEDILLA +#define ISO_8859_1_C8 0 // 200 È E GRAVE +#define ISO_8859_1_C9 0 // 201 É E ACUTE +#define ISO_8859_1_CA 0 // 202 Ê E CIRCUMFLEX +#define ISO_8859_1_CB 0 // 203 Ë E DIAERESIS +#define ISO_8859_1_CC 0 // 204 Ì I GRAVE +#define ISO_8859_1_CD 0 // 205 Í I ACUTE +#define ISO_8859_1_CE 0 // 206 Î I CIRCUMFLEX +#define ISO_8859_1_CF 0 // 207 Ï I DIAERESIS +#define ISO_8859_1_D0 0 // 208 Ð ETH +#define ISO_8859_1_D1 0 // 209 Ñ N TILDE +#define ISO_8859_1_D2 0 // 210 Ò O GRAVE +#define ISO_8859_1_D3 0 // 211 Ó O ACUTE +#define ISO_8859_1_D4 0 // 212 Ô O CIRCUMFLEX +#define ISO_8859_1_D5 0 // 213 Õ O TILDE +#define ISO_8859_1_D6 0 // 214 Ö O DIAERESIS +#define ISO_8859_1_D7 0 // 215 × MULTIPLICATION +#define ISO_8859_1_D8 0 // 216 Ø O STROKE +#define ISO_8859_1_D9 0 // 217 Ù U GRAVE +#define ISO_8859_1_DA 0 // 218 Ú U ACUTE +#define ISO_8859_1_DB 0 // 219 Û U CIRCUMFLEX +#define ISO_8859_1_DC 0 // 220 Ü U DIAERESIS +#define ISO_8859_1_DD 0 // 221 Ý Y ACUTE +#define ISO_8859_1_DE 0 // 222 Þ THORN +#define ISO_8859_1_DF 0 // 223 ß SHARP S +#define ISO_8859_1_E0 KEY_QUOTE // 224 à a GRAVE +#define ISO_8859_1_E1 0 // 225 á a ACUTE +#define ISO_8859_1_E2 0 // 226 â a CIRCUMFLEX +#define ISO_8859_1_E3 0 // 227 ã a TILDE +#define ISO_8859_1_E4 0 // 228 ä a DIAERESIS +#define ISO_8859_1_E5 0 // 229 å a RING ABOVE +#define ISO_8859_1_E6 0 // 230 æ ae +#define ISO_8859_1_E7 KEY_SEMICOLON + SHIFT_MASK // 231 ç c CEDILLA +#define ISO_8859_1_E8 KEY_LEFT_BRACE // 232 è e GRAVE +#define ISO_8859_1_E9 KEY_LEFT_BRACE + SHIFT_MASK // 233 é e ACUTE +#define ISO_8859_1_EA 0 // 234 ê e CIRCUMFLEX +#define ISO_8859_1_EB 0 // 235 ë e DIAERESIS +#define ISO_8859_1_EC KEY_EQUAL // 236 ì i GRAVE +#define ISO_8859_1_ED 0 // 237 í i ACUTE +#define ISO_8859_1_EE 0 // 238 î i CIRCUMFLEX +#define ISO_8859_1_EF 0 // 239 ï i DIAERESIS +#define ISO_8859_1_F0 0 // 240 ð ETH +#define ISO_8859_1_F1 0 // 241 ñ n TILDE +#define ISO_8859_1_F2 KEY_SEMICOLON // 242 ò o GRAVE +#define ISO_8859_1_F3 0 // 243 ó o ACUTE +#define ISO_8859_1_F4 0 // 244 ô o CIRCUMFLEX +#define ISO_8859_1_F5 0 // 245 õ o TILDE +#define ISO_8859_1_F6 0 // 246 ö o DIAERESIS +#define ISO_8859_1_F7 0 // 247 ÷ DIVISION +#define ISO_8859_1_F8 0 // 248 ø o STROKE +#define ISO_8859_1_F9 KEY_BACKSLASH // 249 ù u GRAVE +#define ISO_8859_1_FA 0 // 250 ú u ACUTE +#define ISO_8859_1_FB 0 // 251 û u CIRCUMFLEX +#define ISO_8859_1_FC 0 // 252 ü u DIAERESIS +#define ISO_8859_1_FD 0 // 253 ý y ACUTE +#define ISO_8859_1_FE 0 // 254 þ THORN +#define ISO_8859_1_FF 0 // 255 ÿ y DIAERESIS + +#endif // LAYOUT_ITALIAN + + + + +#ifdef LAYOUT_PORTUGUESE_BRAZILIAN + +#define SHIFT_MASK 0x0040 +#define ALTGR_MASK 0x0080 +#define DEADKEYS_MASK 0x0700 +#define CIRCUMFLEX_BITS 0x0100 +#define ACUTE_ACCENT_BITS 0x0200 +#define GRAVE_ACCENT_BITS 0x0300 +#define TILDE_BITS 0x0400 +#define DIAERESIS_BITS 0x0500 +#define KEYCODE_TYPE uint16_t +#define KEYCODE_MASK 0x07FF +#define DEADKEY_CIRCUMFLEX KEY_QUOTE + SHIFT_MASK +#define DEADKEY_ACUTE_ACCENT KEY_LEFT_BRACE +#define DEADKEY_GRAVE_ACCENT KEY_LEFT_BRACE + SHIFT_MASK +#define DEADKEY_TILDE KEY_QUOTE +#define DEADKEY_DIAERESIS KEY_6 + SHIFT_MASK +#define KEY_NON_US_100 63 + +#define ASCII_20 KEY_SPACE // 32 +#define ASCII_21 KEY_1 + SHIFT_MASK // 33 ! +#define ASCII_22 KEY_TILDE + SHIFT_MASK // 34 " +#define ASCII_23 KEY_3 + ALTGR_MASK // 35 # +#define ASCII_24 KEY_4 + SHIFT_MASK // 36 $ +#define ASCII_25 KEY_5 + SHIFT_MASK // 37 % +#define ASCII_26 KEY_7 + SHIFT_MASK // 38 & +#define ASCII_27 KEY_TILDE // 39 ' +#define ASCII_28 KEY_9 + SHIFT_MASK // 40 ( +#define ASCII_29 KEY_0 + SHIFT_MASK // 41 ) +#define ASCII_2A KEY_7 + SHIFT_MASK // 42 * +#define ASCII_2B KEY_EQUAL + SHIFT_MASK // 43 + +#define ASCII_2C KEY_COMMA // 44 , +#define ASCII_2D KEY_MINUS // 45 - +#define ASCII_2E KEY_PERIOD // 46 . +#define ASCII_2F KEY_Q + ALTGR_MASK // 47 / +#define ASCII_30 KEY_0 // 48 0 +#define ASCII_31 KEY_1 // 49 1 +#define ASCII_32 KEY_2 // 50 2 +#define ASCII_33 KEY_3 // 51 3 +#define ASCII_34 KEY_4 // 52 4 +#define ASCII_35 KEY_5 // 53 5 +#define ASCII_36 KEY_6 // 54 6 +#define ASCII_37 KEY_7 // 55 7 +#define ASCII_38 KEY_8 // 55 8 +#define ASCII_39 KEY_9 // 57 9 +#define ASCII_3A KEY_SLASH + SHIFT_MASK // 58 : +#define ASCII_3B KEY_SLASH // 59 ; +#define ASCII_3C KEY_COMMA + SHIFT_MASK // 60 < +#define ASCII_3D KEY_EQUAL // 61 = +#define ASCII_3E KEY_PERIOD + SHIFT_MASK // 62 > +#define ASCII_3F KEY_W + ALTGR_MASK // 63 ? +#define ASCII_40 KEY_2 + SHIFT_MASK // 64 @ +#define ASCII_41 KEY_A + SHIFT_MASK // 65 A +#define ASCII_42 KEY_B + SHIFT_MASK // 66 B +#define ASCII_43 KEY_C + SHIFT_MASK // 67 C +#define ASCII_44 KEY_D + SHIFT_MASK // 68 D +#define ASCII_45 KEY_E + SHIFT_MASK // 69 E +#define ASCII_46 KEY_F + SHIFT_MASK // 70 F +#define ASCII_47 KEY_G + SHIFT_MASK // 71 G +#define ASCII_48 KEY_H + SHIFT_MASK // 72 H +#define ASCII_49 KEY_I + SHIFT_MASK // 73 I +#define ASCII_4A KEY_J + SHIFT_MASK // 74 J +#define ASCII_4B KEY_K + SHIFT_MASK // 75 K +#define ASCII_4C KEY_L + SHIFT_MASK // 76 L +#define ASCII_4D KEY_M + SHIFT_MASK // 77 M +#define ASCII_4E KEY_N + SHIFT_MASK // 78 N +#define ASCII_4F KEY_O + SHIFT_MASK // 79 O +#define ASCII_50 KEY_P + SHIFT_MASK // 80 P +#define ASCII_51 KEY_Q + SHIFT_MASK // 81 Q +#define ASCII_52 KEY_R + SHIFT_MASK // 82 R +#define ASCII_53 KEY_S + SHIFT_MASK // 83 S +#define ASCII_54 KEY_T + SHIFT_MASK // 84 T +#define ASCII_55 KEY_U + SHIFT_MASK // 85 U +#define ASCII_56 KEY_V + SHIFT_MASK // 86 V +#define ASCII_57 KEY_W + SHIFT_MASK // 87 W +#define ASCII_58 KEY_X + SHIFT_MASK // 88 X +#define ASCII_59 KEY_Y + SHIFT_MASK // 89 Y +#define ASCII_5A KEY_Z + SHIFT_MASK // 90 Z +#define ASCII_5B KEY_RIGHT_BRACE // 91 [ +#define ASCII_5C KEY_NON_US_100 // 92 +#define ASCII_5D KEY_BACKSLASH // 93 ] +#define ASCII_5E CIRCUMFLEX_BITS + KEY_SPACE // 94 ^ +#define ASCII_5F KEY_MINUS + SHIFT_MASK // 95 _ +#define ASCII_60 GRAVE_ACCENT_BITS + KEY_SPACE // 96 ` +#define ASCII_61 KEY_A // 97 a +#define ASCII_62 KEY_B // 98 b +#define ASCII_63 KEY_C // 99 c +#define ASCII_64 KEY_D // 100 d +#define ASCII_65 KEY_E // 101 e +#define ASCII_66 KEY_F // 102 f +#define ASCII_67 KEY_G // 103 g +#define ASCII_68 KEY_H // 104 h +#define ASCII_69 KEY_I // 105 i +#define ASCII_6A KEY_J // 106 j +#define ASCII_6B KEY_K // 107 k +#define ASCII_6C KEY_L // 108 l +#define ASCII_6D KEY_M // 109 m +#define ASCII_6E KEY_N // 110 n +#define ASCII_6F KEY_O // 111 o +#define ASCII_70 KEY_P // 112 p +#define ASCII_71 KEY_Q // 113 q +#define ASCII_72 KEY_R // 114 r +#define ASCII_73 KEY_S // 115 s +#define ASCII_74 KEY_T // 116 t +#define ASCII_75 KEY_U // 117 u +#define ASCII_76 KEY_V // 118 v +#define ASCII_77 KEY_W // 119 w +#define ASCII_78 KEY_X // 120 x +#define ASCII_79 KEY_Y // 121 y +#define ASCII_7A KEY_Z // 122 z +#define ASCII_7B KEY_RIGHT_BRACE + SHIFT_MASK // 123 { +#define ASCII_7C KEY_NON_US_100 + SHIFT_MASK // 124 | +#define ASCII_7D KEY_BACKSLASH + SHIFT_MASK // 125 } +#define ASCII_7E TILDE_BITS + KEY_SPACE // 126 ~ +#define ASCII_7F KEY_BACKSPACE // 127 + +#define ISO_8859_1_A0 KEY_SPACE // 160 Nonbreakng Space +#define ISO_8859_1_A1 0 // 161 ¡ Inverted Exclamation +#define ISO_8859_1_A2 KEY_5 + ALTGR_MASK // 162 ¢ Cent SIGN +#define ISO_8859_1_A3 KEY_4 + ALTGR_MASK // 163 £ Pound Sign +#define ISO_8859_1_A4 0 // 164 ¤ Currency Sign +#define ISO_8859_1_A5 0 // 165 ¥ YEN SIGN +#define ISO_8859_1_A6 0 // 166 ¦ BROKEN BAR +#define ISO_8859_1_A7 KEY_EQUAL + ALTGR_MASK // 167 § SECTION SIGN +#define ISO_8859_1_A8 DIAERESIS_BITS + KEY_SPACE // 168 ¨ DIAERESIS +#define ISO_8859_1_A9 0 // 169 © COPYRIGHT SIGN +#define ISO_8859_1_AA KEY_RIGHT_BRACE + ALTGR_MASK // 170 ª FEMININE ORDINAL +#define ISO_8859_1_AB 0 // 171 « LEFT DOUBLE ANGLE QUOTE +#define ISO_8859_1_AC KEY_6 + ALTGR_MASK // 172 ¬ NOT SIGN +#define ISO_8859_1_AD 0 // 173 SOFT HYPHEN +#define ISO_8859_1_AE 0 // 174 ® REGISTERED SIGN +#define ISO_8859_1_AF 0 // 175 ¯ MACRON +#define ISO_8859_1_B0 KEY_E + ALTGR_MASK // 176 ° DEGREE SIGN +#define ISO_8859_1_B1 0 // 177 ± PLUS-MINUS SIGN +#define ISO_8859_1_B2 KEY_2 + ALTGR_MASK // 178 ² SUPERSCRIPT TWO +#define ISO_8859_1_B3 KEY_2 + ALTGR_MASK // 179 ³ SUPERSCRIPT THREE +#define ISO_8859_1_B4 ACUTE_ACCENT_BITS + KEY_SPACE // 180 ´ ACUTE ACCENT +#define ISO_8859_1_B5 0 // 181 µ MICRO SIGN +#define ISO_8859_1_B6 0 // 182 ¶ PILCROW SIGN +#define ISO_8859_1_B7 0 // 183 · MIDDLE DOT +#define ISO_8859_1_B8 0 // 184 ¸ CEDILLA +#define ISO_8859_1_B9 KEY_1 + ALTGR_MASK // 185 ¹ SUPERSCRIPT ONE +#define ISO_8859_1_BA KEY_BACKSLASH + ALTGR_MASK // 186 º MASCULINE ORDINAL +#define ISO_8859_1_BB 0 // 187 » RIGHT DOUBLE ANGLE QUOTE +#define ISO_8859_1_BC 0 // 188 ¼ FRACTION ONE QUARTER +#define ISO_8859_1_BD 0 // 189 ½ FRACTION ONE HALF +#define ISO_8859_1_BE 0 // 190 ¾ FRACTION THREE QUARTERS +#define ISO_8859_1_BF 0 // 191 ¿ INVERTED QUESTION MARK +#define ISO_8859_1_C0 GRAVE_ACCENT_BITS + KEY_A + SHIFT_MASK // 192 À A GRAVE +#define ISO_8859_1_C1 ACUTE_ACCENT_BITS + KEY_A + SHIFT_MASK // 193 Á A ACUTE +#define ISO_8859_1_C2 CIRCUMFLEX_BITS + KEY_A + SHIFT_MASK // 194 Â A CIRCUMFLEX +#define ISO_8859_1_C3 TILDE_BITS + KEY_A + SHIFT_MASK // 195 Ã A TILDE +#define ISO_8859_1_C4 DIAERESIS_BITS + KEY_A + SHIFT_MASK // 196 Ä A DIAERESIS +#define ISO_8859_1_C5 0 // 197 Å A RING ABOVE +#define ISO_8859_1_C6 0 // 198 Æ AE +#define ISO_8859_1_C7 0 // 199 Ç C CEDILLA +#define ISO_8859_1_C8 GRAVE_ACCENT_BITS + KEY_E + SHIFT_MASK // 200 È E GRAVE +#define ISO_8859_1_C9 ACUTE_ACCENT_BITS + KEY_E + SHIFT_MASK // 201 É E ACUTE +#define ISO_8859_1_CA CIRCUMFLEX_BITS + KEY_E + SHIFT_MASK // 202 Ê E CIRCUMFLEX +#define ISO_8859_1_CB DIAERESIS_BITS + KEY_E + SHIFT_MASK // 203 Ë E DIAERESIS +#define ISO_8859_1_CC GRAVE_ACCENT_BITS + KEY_I + SHIFT_MASK // 204 Ì I GRAVE +#define ISO_8859_1_CD ACUTE_ACCENT_BITS + KEY_I + SHIFT_MASK // 205 Í I ACUTE +#define ISO_8859_1_CE CIRCUMFLEX_BITS + KEY_I + SHIFT_MASK // 206 Î I CIRCUMFLEX +#define ISO_8859_1_CF DIAERESIS_BITS + KEY_I + SHIFT_MASK // 207 Ï I DIAERESIS +#define ISO_8859_1_D0 0 // 208 Ð ETH +#define ISO_8859_1_D1 TILDE_BITS + KEY_N + SHIFT_MASK // 209 Ñ N TILDE +#define ISO_8859_1_D2 GRAVE_ACCENT_BITS + KEY_O + SHIFT_MASK // 210 Ò O GRAVE +#define ISO_8859_1_D3 ACUTE_ACCENT_BITS + KEY_O + SHIFT_MASK // 211 Ó O ACUTE +#define ISO_8859_1_D4 CIRCUMFLEX_BITS + KEY_O + SHIFT_MASK // 212 Ô O CIRCUMFLEX +#define ISO_8859_1_D5 TILDE_BITS + KEY_O + SHIFT_MASK // 213 Õ O TILDE +#define ISO_8859_1_D6 DIAERESIS_BITS + KEY_O + SHIFT_MASK // 214 Ö O DIAERESIS +#define ISO_8859_1_D7 0 // 215 × MULTIPLICATION +#define ISO_8859_1_D8 0 // 216 Ø O STROKE +#define ISO_8859_1_D9 GRAVE_ACCENT_BITS + KEY_U + SHIFT_MASK // 217 Ù U GRAVE +#define ISO_8859_1_DA ACUTE_ACCENT_BITS + KEY_U + SHIFT_MASK // 218 Ú U ACUTE +#define ISO_8859_1_DB CIRCUMFLEX_BITS + KEY_U + SHIFT_MASK // 219 Û U CIRCUMFLEX +#define ISO_8859_1_DC DIAERESIS_BITS + KEY_U + SHIFT_MASK // 220 Ü U DIAERESIS +#define ISO_8859_1_DD ACUTE_ACCENT_BITS + KEY_Y + SHIFT_MASK // 221 Ý Y ACUTE +#define ISO_8859_1_DE 0 // 222 Þ THORN +#define ISO_8859_1_DF 0 // 223 ß SHARP S +#define ISO_8859_1_E0 GRAVE_ACCENT_BITS + KEY_A // 224 à a GRAVE +#define ISO_8859_1_E1 ACUTE_ACCENT_BITS + KEY_A // 225 á a ACUTE +#define ISO_8859_1_E2 CIRCUMFLEX_BITS + KEY_A // 226 â a CIRCUMFLEX +#define ISO_8859_1_E3 TILDE_BITS + KEY_A // 227 ã a TILDE +#define ISO_8859_1_E4 DIAERESIS_BITS + KEY_A // 228 ä a DIAERESIS +#define ISO_8859_1_E5 0 // 229 å a RING ABOVE +#define ISO_8859_1_E6 0 // 230 æ ae +#define ISO_8859_1_E7 0 // 231 ç c CEDILLA +#define ISO_8859_1_E8 GRAVE_ACCENT_BITS + KEY_E // 232 è e GRAVE +#define ISO_8859_1_E9 ACUTE_ACCENT_BITS + KEY_E // 233 é e ACUTE +#define ISO_8859_1_EA CIRCUMFLEX_BITS + KEY_E // 234 ê e CIRCUMFLEX +#define ISO_8859_1_EB DIAERESIS_BITS + KEY_E // 235 ë e DIAERESIS +#define ISO_8859_1_EC GRAVE_ACCENT_BITS + KEY_I // 236 ì i GRAVE +#define ISO_8859_1_ED ACUTE_ACCENT_BITS + KEY_I // 237 í i ACUTE +#define ISO_8859_1_EE CIRCUMFLEX_BITS + KEY_I // 238 î i CIRCUMFLEX +#define ISO_8859_1_EF DIAERESIS_BITS + KEY_I // 239 ï i DIAERESIS +#define ISO_8859_1_F0 0 // 240 ð ETH +#define ISO_8859_1_F1 TILDE_BITS + KEY_N // 241 ñ n TILDE +#define ISO_8859_1_F2 GRAVE_ACCENT_BITS + KEY_O // 242 ò o GRAVE +#define ISO_8859_1_F3 ACUTE_ACCENT_BITS + KEY_O // 243 ó o ACUTE +#define ISO_8859_1_F4 CIRCUMFLEX_BITS + KEY_O // 244 ô o CIRCUMFLEX +#define ISO_8859_1_F5 TILDE_BITS + KEY_O // 245 õ o TILDE +#define ISO_8859_1_F6 DIAERESIS_BITS + KEY_O // 246 ö o DIAERESIS +#define ISO_8859_1_F7 0 // 247 ÷ DIVISION +#define ISO_8859_1_F8 0 // 248 ø o STROKE +#define ISO_8859_1_F9 GRAVE_ACCENT_BITS + KEY_U // 249 ù u GRAVE +#define ISO_8859_1_FA ACUTE_ACCENT_BITS + KEY_U // 250 ú u ACUTE +#define ISO_8859_1_FB CIRCUMFLEX_BITS + KEY_U // 251 û u CIRCUMFLEX +#define ISO_8859_1_FC DIAERESIS_BITS + KEY_U // 252 ü u DIAERESIS +#define ISO_8859_1_FD ACUTE_ACCENT_BITS + KEY_Y // 253 ý y ACUTE +#define ISO_8859_1_FE 0 // 254 þ THORN +#define ISO_8859_1_FF DIAERESIS_BITS + KEY_Y // 255 ÿ y DIAERESIS + +#endif // LAYOUT_PORTUGUESE_BRAZILIAN + + + +#ifdef LAYOUT_FRENCH_BELGIAN + +#define SHIFT_MASK 0x0040 +#define ALTGR_MASK 0x0080 +#define DEADKEYS_MASK 0x0700 +#define CIRCUMFLEX_BITS 0x0100 +#define GRAVE_ACCENT_BITS 0x0200 +#define DIAERESIS_BITS 0x0300 +#define TILDE_BITS 0x0400 +#define ACUTE_ACCENT_BITS 0x0500 +#define KEYCODE_TYPE uint16_t +#define KEYCODE_MASK 0x07FF +#define DEADKEY_CIRCUMFLEX KEY_LEFT_BRACE +#define DEADKEY_ACUTE_ACCENT KEY_QUOTE + ALTGR_MASK +#define DEADKEY_GRAVE_ACCENT KEY_BACKSLASH + ALTGR_MASK +#define DEADKEY_DIAERESIS KEY_LEFT_BRACE + SHIFT_MASK +#define DEADKEY_TILDE KEY_SLASH + ALTGR_MASK +#define KEY_NON_US_100 63 + +#define ASCII_20 KEY_SPACE // 32 +#define ASCII_21 KEY_8 // 33 ! +#define ASCII_22 KEY_3 // 34 " +#define ASCII_23 KEY_3 + ALTGR_MASK // 35 # +#define ASCII_24 KEY_RIGHT_BRACE // 36 $ +#define ASCII_25 KEY_QUOTE + SHIFT_MASK // 37 % +#define ASCII_26 KEY_1 // 38 & +#define ASCII_27 KEY_4 // 39 ' +#define ASCII_28 KEY_5 // 40 ( +#define ASCII_29 KEY_MINUS // 41 ) +#define ASCII_2A KEY_RIGHT_BRACE + SHIFT_MASK // 42 * +#define ASCII_2B KEY_SLASH + SHIFT_MASK // 43 + +#define ASCII_2C KEY_M // 44 , +#define ASCII_2D KEY_EQUAL // 45 - +#define ASCII_2E KEY_COMMA + SHIFT_MASK // 46 . +#define ASCII_2F KEY_PERIOD + SHIFT_MASK // 47 / +#define ASCII_30 KEY_0 + SHIFT_MASK // 48 0 +#define ASCII_31 KEY_1 + SHIFT_MASK // 49 1 +#define ASCII_32 KEY_2 + SHIFT_MASK // 50 2 +#define ASCII_33 KEY_3 + SHIFT_MASK // 51 3 +#define ASCII_34 KEY_4 + SHIFT_MASK // 52 4 +#define ASCII_35 KEY_5 + SHIFT_MASK // 53 5 +#define ASCII_36 KEY_6 + SHIFT_MASK // 54 6 +#define ASCII_37 KEY_7 + SHIFT_MASK // 55 7 +#define ASCII_38 KEY_8 + SHIFT_MASK // 55 8 +#define ASCII_39 KEY_9 + SHIFT_MASK // 57 9 +#define ASCII_3A KEY_PERIOD // 58 : +#define ASCII_3B KEY_COMMA // 59 ; +#define ASCII_3C KEY_NON_US_100 // 60 < +#define ASCII_3D KEY_SLASH // 61 = +#define ASCII_3E KEY_NON_US_100 + SHIFT_MASK // 62 > +#define ASCII_3F KEY_M + SHIFT_MASK // 63 ? +#define ASCII_40 KEY_2 + ALTGR_MASK // 64 @ +#define ASCII_41 KEY_Q + SHIFT_MASK // 65 A +#define ASCII_42 KEY_B + SHIFT_MASK // 66 B +#define ASCII_43 KEY_C + SHIFT_MASK // 67 C +#define ASCII_44 KEY_D + SHIFT_MASK // 68 D +#define ASCII_45 KEY_E + SHIFT_MASK // 69 E +#define ASCII_46 KEY_F + SHIFT_MASK // 70 F +#define ASCII_47 KEY_G + SHIFT_MASK // 71 G +#define ASCII_48 KEY_H + SHIFT_MASK // 72 H +#define ASCII_49 KEY_I + SHIFT_MASK // 73 I +#define ASCII_4A KEY_J + SHIFT_MASK // 74 J +#define ASCII_4B KEY_K + SHIFT_MASK // 75 K +#define ASCII_4C KEY_L + SHIFT_MASK // 76 L +#define ASCII_4D KEY_SEMICOLON + SHIFT_MASK // 77 M +#define ASCII_4E KEY_N + SHIFT_MASK // 78 N +#define ASCII_4F KEY_O + SHIFT_MASK // 79 O +#define ASCII_50 KEY_P + SHIFT_MASK // 80 P +#define ASCII_51 KEY_A + SHIFT_MASK // 81 Q +#define ASCII_52 KEY_R + SHIFT_MASK // 82 R +#define ASCII_53 KEY_S + SHIFT_MASK // 83 S +#define ASCII_54 KEY_T + SHIFT_MASK // 84 T +#define ASCII_55 KEY_U + SHIFT_MASK // 85 U +#define ASCII_56 KEY_V + SHIFT_MASK // 86 V +#define ASCII_57 KEY_Z + SHIFT_MASK // 87 W +#define ASCII_58 KEY_X + SHIFT_MASK // 88 X +#define ASCII_59 KEY_Y + SHIFT_MASK // 89 Y +#define ASCII_5A KEY_W + SHIFT_MASK // 90 Z +#define ASCII_5B KEY_RIGHT_BRACE + ALTGR_MASK // 91 [ +#define ASCII_5C KEY_NON_US_100 + ALTGR_MASK // 92 +#define ASCII_5D KEY_LEFT_BRACE + ALTGR_MASK // 93 ] +#define ASCII_5E KEY_6 + ALTGR_MASK // 94 ^ +#define ASCII_5F KEY_EQUAL + SHIFT_MASK // 95 _ +#define ASCII_60 GRAVE_ACCENT_BITS + KEY_SPACE // 96 ` +#define ASCII_61 KEY_Q // 97 a +#define ASCII_62 KEY_B // 98 b +#define ASCII_63 KEY_C // 99 c +#define ASCII_64 KEY_D // 100 d +#define ASCII_65 KEY_E // 101 e +#define ASCII_66 KEY_F // 102 f +#define ASCII_67 KEY_G // 103 g +#define ASCII_68 KEY_H // 104 h +#define ASCII_69 KEY_I // 105 i +#define ASCII_6A KEY_J // 106 j +#define ASCII_6B KEY_K // 107 k +#define ASCII_6C KEY_L // 108 l +#define ASCII_6D KEY_SEMICOLON // 109 m +#define ASCII_6E KEY_N // 110 n +#define ASCII_6F KEY_O // 111 o +#define ASCII_70 KEY_P // 112 p +#define ASCII_71 KEY_A // 113 q +#define ASCII_72 KEY_R // 114 r +#define ASCII_73 KEY_S // 115 s +#define ASCII_74 KEY_T // 116 t +#define ASCII_75 KEY_U // 117 u +#define ASCII_76 KEY_V // 118 v +#define ASCII_77 KEY_Z // 119 w +#define ASCII_78 KEY_X // 120 x +#define ASCII_79 KEY_Y // 121 y +#define ASCII_7A KEY_W // 122 z +#define ASCII_7B KEY_9 + ALTGR_MASK // 123 { +#define ASCII_7C KEY_1 + ALTGR_MASK // 124 | +#define ASCII_7D KEY_0 + ALTGR_MASK // 125 } +#define ASCII_7E TILDE_BITS + KEY_SPACE // 126 ~ +#define ASCII_7F KEY_BACKSPACE // 127 +#define ISO_8859_1_A0 KEY_SPACE // 160 Nonbreakng Space +#define ISO_8859_1_A1 0 // 161 ¡ Inverted Exclamation +#define ISO_8859_1_A2 0 // 162 ¢ Cent SIGN +#define ISO_8859_1_A3 KEY_BACKSLASH + SHIFT_MASK // 163 £ Pound Sign +#define ISO_8859_1_A4 0 // 164 ¤ Currency or Euro Sign +#define ISO_8859_1_A5 0 // 165 ¥ YEN SIGN +#define ISO_8859_1_A6 0 // 166 ¦ BROKEN BAR +#define ISO_8859_1_A7 KEY_6 // 167 § SECTION SIGN +#define ISO_8859_1_A8 DIAERESIS_BITS + KEY_SPACE // 168 ¨ DIAERESIS +#define ISO_8859_1_A9 0 // 169 © COPYRIGHT SIGN +#define ISO_8859_1_AA 0 // 170 ª FEMININE ORDINAL +#define ISO_8859_1_AB 0 // 171 « LEFT DOUBLE ANGLE QUOTE +#define ISO_8859_1_AC 0 // 172 ¬ NOT SIGN +#define ISO_8859_1_AD 0 // 173 SOFT HYPHEN +#define ISO_8859_1_AE 0 // 174 ® REGISTERED SIGN +#define ISO_8859_1_AF 0 // 175 ¯ MACRON +#define ISO_8859_1_B0 KEY_MINUS + SHIFT_MASK // 176 ° DEGREE SIGN +#define ISO_8859_1_B1 0 // 177 ± PLUS-MINUS SIGN +#define ISO_8859_1_B2 KEY_TILDE // 178 ² SUPERSCRIPT TWO +#define ISO_8859_1_B3 KEY_TILDE + SHIFT_MASK // 179 ³ SUPERSCRIPT THREE +#define ISO_8859_1_B4 ACUTE_ACCENT_BITS + KEY_SPACE // 180 ´ ACUTE ACCENT +#define ISO_8859_1_B5 KEY_BACKSLASH // 181 µ MICRO SIGN +#define ISO_8859_1_B6 0 // 182 ¶ PILCROW SIGN +#define ISO_8859_1_B7 0 // 183 · MIDDLE DOT +#define ISO_8859_1_B8 0 // 184 ¸ CEDILLA +#define ISO_8859_1_B9 0 // 185 ¹ SUPERSCRIPT ONE +#define ISO_8859_1_BA 0 // 186 º MASCULINE ORDINAL +#define ISO_8859_1_BB 0 // 187 » RIGHT DOUBLE ANGLE QUOTE +#define ISO_8859_1_BC 0 // 188 ¼ FRACTION ONE QUARTER +#define ISO_8859_1_BD 0 // 189 ½ FRACTION ONE HALF +#define ISO_8859_1_BE 0 // 190 ¾ FRACTION THREE QUARTERS +#define ISO_8859_1_BF 0 // 191 ¿ INVERTED QUESTION MARK +#define ISO_8859_1_C0 GRAVE_ACCENT_BITS + KEY_Q + SHIFT_MASK // 192 À A GRAVE +#define ISO_8859_1_C1 ACUTE_ACCENT_BITS + KEY_Q + SHIFT_MASK // 193 Á A ACUTE +#define ISO_8859_1_C2 CIRCUMFLEX_BITS + KEY_Q + SHIFT_MASK // 194 Â A CIRCUMFLEX +#define ISO_8859_1_C3 TILDE_BITS + KEY_Q + SHIFT_MASK // 195 Ã A TILDE +#define ISO_8859_1_C4 DIAERESIS_BITS + KEY_Q + SHIFT_MASK // 196 Ä A DIAERESIS +#define ISO_8859_1_C5 0 // 197 Å A RING ABOVE +#define ISO_8859_1_C6 0 // 198 Æ AE +#define ISO_8859_1_C7 0 // 199 Ç C CEDILLA +#define ISO_8859_1_C8 GRAVE_ACCENT_BITS + KEY_E + SHIFT_MASK // 200 È E GRAVE +#define ISO_8859_1_C9 ACUTE_ACCENT_BITS + KEY_E + SHIFT_MASK // 201 É E ACUTE +#define ISO_8859_1_CA CIRCUMFLEX_BITS + KEY_E + SHIFT_MASK // 202 Ê E CIRCUMFLEX +#define ISO_8859_1_CB DIAERESIS_BITS + KEY_E + SHIFT_MASK // 203 Ë E DIAERESIS +#define ISO_8859_1_CC GRAVE_ACCENT_BITS + KEY_I + SHIFT_MASK // 204 Ì I GRAVE +#define ISO_8859_1_CD ACUTE_ACCENT_BITS + KEY_I + SHIFT_MASK // 205 Í I ACUTE +#define ISO_8859_1_CE CIRCUMFLEX_BITS + KEY_I + SHIFT_MASK // 206 Î I CIRCUMFLEX +#define ISO_8859_1_CF DIAERESIS_BITS + KEY_I + SHIFT_MASK // 207 Ï I DIAERESIS +#define ISO_8859_1_D0 0 // 208 Ð ETH +#define ISO_8859_1_D1 TILDE_BITS + KEY_N + SHIFT_MASK // 209 Ñ N TILDE +#define ISO_8859_1_D2 GRAVE_ACCENT_BITS + KEY_O + SHIFT_MASK // 210 Ò O GRAVE +#define ISO_8859_1_D3 ACUTE_ACCENT_BITS + KEY_O + SHIFT_MASK // 211 Ó O ACUTE +#define ISO_8859_1_D4 CIRCUMFLEX_BITS + KEY_O + SHIFT_MASK // 212 Ô O CIRCUMFLEX +#define ISO_8859_1_D5 TILDE_BITS + KEY_O + SHIFT_MASK // 213 Õ O TILDE +#define ISO_8859_1_D6 DIAERESIS_BITS + KEY_O + SHIFT_MASK // 214 Ö O DIAERESIS +#define ISO_8859_1_D7 0 // 215 × MULTIPLICATION +#define ISO_8859_1_D8 0 // 216 Ø O STROKE +#define ISO_8859_1_D9 GRAVE_ACCENT_BITS + KEY_U + SHIFT_MASK // 217 Ù U GRAVE +#define ISO_8859_1_DA ACUTE_ACCENT_BITS + KEY_U + SHIFT_MASK // 218 Ú U ACUTE +#define ISO_8859_1_DB CIRCUMFLEX_BITS + KEY_U + SHIFT_MASK // 219 Û U CIRCUMFLEX +#define ISO_8859_1_DC DIAERESIS_BITS + KEY_U // 220 Ü U DIAERESIS +#define ISO_8859_1_DD ACUTE_ACCENT_BITS + KEY_Y + SHIFT_MASK // 221 Ý Y ACUTE +#define ISO_8859_1_DE 0 // 222 Þ THORN +#define ISO_8859_1_DF 0 // 223 ß SHARP S +#define ISO_8859_1_E0 KEY_0 // 224 à a GRAVE +#define ISO_8859_1_E1 ACUTE_ACCENT_BITS + KEY_Q // 225 á a ACUTE +#define ISO_8859_1_E2 CIRCUMFLEX_BITS + KEY_Q // 226 â a CIRCUMFLEX +#define ISO_8859_1_E3 TILDE_BITS + KEY_Q // 227 ã a TILDE +#define ISO_8859_1_E4 DIAERESIS_BITS + KEY_Q // 228 ä a DIAERESIS +#define ISO_8859_1_E5 0 // 229 å a RING ABOVE +#define ISO_8859_1_E6 0 // 230 æ ae +#define ISO_8859_1_E7 KEY_9 // 231 ç c CEDILLA +#define ISO_8859_1_E8 KEY_7 // 232 è e GRAVE +#define ISO_8859_1_E9 KEY_2 // 233 é e ACUTE +#define ISO_8859_1_EA CIRCUMFLEX_BITS + KEY_E // 234 ê e CIRCUMFLEX +#define ISO_8859_1_EB DIAERESIS_BITS + KEY_E // 235 ë e DIAERESIS +#define ISO_8859_1_EC GRAVE_ACCENT_BITS + KEY_I // 236 ì i GRAVE +#define ISO_8859_1_ED ACUTE_ACCENT_BITS + KEY_I // 237 í i ACUTE +#define ISO_8859_1_EE CIRCUMFLEX_BITS + KEY_I // 238 î i CIRCUMFLEX +#define ISO_8859_1_EF DIAERESIS_BITS + KEY_I // 239 ï i DIAERESIS +#define ISO_8859_1_F0 0 // 240 ð ETH +#define ISO_8859_1_F1 TILDE_BITS + KEY_N // 241 ñ n TILDE +#define ISO_8859_1_F2 GRAVE_ACCENT_BITS + KEY_O // 242 ò o GRAVE +#define ISO_8859_1_F3 ACUTE_ACCENT_BITS + KEY_O // 243 ó o ACUTE +#define ISO_8859_1_F4 CIRCUMFLEX_BITS + KEY_O // 244 ô o CIRCUMFLEX +#define ISO_8859_1_F5 TILDE_BITS + KEY_O // 245 õ o TILDE +#define ISO_8859_1_F6 DIAERESIS_BITS + KEY_O // 246 ö o DIAERESIS +#define ISO_8859_1_F7 0 // 247 ÷ DIVISION +#define ISO_8859_1_F8 0 // 248 ø o STROKE +#define ISO_8859_1_F9 KEY_QUOTE // 249 ù u GRAVE - TODO; check FRENCH +#define ISO_8859_1_FA ACUTE_ACCENT_BITS + KEY_U // 250 ú u ACUTE +#define ISO_8859_1_FB CIRCUMFLEX_BITS + KEY_U // 251 û u CIRCUMFLEX +#define ISO_8859_1_FC DIAERESIS_BITS + KEY_U // 252 ü u DIAERESIS +#define ISO_8859_1_FD ACUTE_ACCENT_BITS + KEY_Y // 253 ý y ACUTE +#define ISO_8859_1_FE 0 // 254 þ THORN +#define ISO_8859_1_FF DIAERESIS_BITS + KEY_Y // 255 ÿ y DIAERESIS +#define UNICODE_20AC KEY_E + ALTGR_MASK // € Euro Sign +// not yet implemented +#define UNICODE_EXTRA00 0x20AC +#define KEYCODE_EXTRA00 KEY_E + ALTGR_MASK // 20AC € Euro Sign + +#endif // LAYOUT_FRENCH_BELGIAN + + + + +#ifdef LAYOUT_GERMAN_SWISS + +#define SHIFT_MASK 0x0040 +#define ALTGR_MASK 0x0080 +#define DEADKEYS_MASK 0x0700 +#define CIRCUMFLEX_BITS 0x0100 +#define GRAVE_ACCENT_BITS 0x0200 +#define DIAERESIS_BITS 0x0300 +#define TILDE_BITS 0x0400 +#define ACUTE_ACCENT_BITS 0x0500 +#define KEYCODE_TYPE uint16_t +#define KEYCODE_MASK 0x07FF +#define DEADKEY_CIRCUMFLEX KEY_EQUAL +#define DEADKEY_ACUTE_ACCENT KEY_MINUS + ALTGR_MASK +#define DEADKEY_GRAVE_ACCENT KEY_EQUAL + SHIFT_MASK +#define DEADKEY_DIAERESIS KEY_RIGHT_BRACE +#define DEADKEY_TILDE KEY_EQUAL + ALTGR_MASK +#define KEY_NON_US_100 63 + +#define ASCII_20 KEY_SPACE // 32 +#define ASCII_21 KEY_RIGHT_BRACE + SHIFT_MASK // 33 ! +#define ASCII_22 KEY_2 + SHIFT_MASK // 34 " +#define ASCII_23 KEY_3 + ALTGR_MASK // 35 # +#define ASCII_24 KEY_BACKSLASH // 36 $ +#define ASCII_25 KEY_5 + SHIFT_MASK // 37 % +#define ASCII_26 KEY_6 + SHIFT_MASK // 38 & +#define ASCII_27 KEY_MINUS // 39 ' +#define ASCII_28 KEY_8 + SHIFT_MASK // 40 ( +#define ASCII_29 KEY_9 + SHIFT_MASK // 41 ) +#define ASCII_2A KEY_3 + SHIFT_MASK // 42 * +#define ASCII_2B KEY_1 + SHIFT_MASK // 43 + +#define ASCII_2C KEY_COMMA // 44 , +#define ASCII_2D KEY_SLASH // 45 - +#define ASCII_2E KEY_PERIOD // 46 . +#define ASCII_2F KEY_7 + SHIFT_MASK // 47 / +#define ASCII_30 KEY_0 // 48 0 +#define ASCII_31 KEY_1 // 49 1 +#define ASCII_32 KEY_2 // 50 2 +#define ASCII_33 KEY_3 // 51 3 +#define ASCII_34 KEY_4 // 52 4 +#define ASCII_35 KEY_5 // 53 5 +#define ASCII_36 KEY_6 // 54 6 +#define ASCII_37 KEY_7 // 55 7 +#define ASCII_38 KEY_8 // 55 8 +#define ASCII_39 KEY_9 // 57 9 +#define ASCII_3A KEY_PERIOD + SHIFT_MASK // 58 : +#define ASCII_3B KEY_COMMA + SHIFT_MASK // 59 ; +#define ASCII_3C KEY_NON_US_100 // 60 < +#define ASCII_3D KEY_0 + SHIFT_MASK // 61 = +#define ASCII_3E KEY_NON_US_100 + SHIFT_MASK // 62 > +#define ASCII_3F KEY_MINUS + SHIFT_MASK // 63 ? +#define ASCII_40 KEY_2 + ALTGR_MASK // 64 @ +#define ASCII_41 KEY_A + SHIFT_MASK // 65 A +#define ASCII_42 KEY_B + SHIFT_MASK // 66 B +#define ASCII_43 KEY_C + SHIFT_MASK // 67 C +#define ASCII_44 KEY_D + SHIFT_MASK // 68 D +#define ASCII_45 KEY_E + SHIFT_MASK // 69 E +#define ASCII_46 KEY_F + SHIFT_MASK // 70 F +#define ASCII_47 KEY_G + SHIFT_MASK // 71 G +#define ASCII_48 KEY_H + SHIFT_MASK // 72 H +#define ASCII_49 KEY_I + SHIFT_MASK // 73 I +#define ASCII_4A KEY_J + SHIFT_MASK // 74 J +#define ASCII_4B KEY_K + SHIFT_MASK // 75 K +#define ASCII_4C KEY_L + SHIFT_MASK // 76 L +#define ASCII_4D KEY_M + SHIFT_MASK // 77 M +#define ASCII_4E KEY_N + SHIFT_MASK // 78 N +#define ASCII_4F KEY_O + SHIFT_MASK // 79 O +#define ASCII_50 KEY_P + SHIFT_MASK // 80 P +#define ASCII_51 KEY_Q + SHIFT_MASK // 81 Q +#define ASCII_52 KEY_R + SHIFT_MASK // 82 R +#define ASCII_53 KEY_S + SHIFT_MASK // 83 S +#define ASCII_54 KEY_T + SHIFT_MASK // 84 T +#define ASCII_55 KEY_U + SHIFT_MASK // 85 U +#define ASCII_56 KEY_V + SHIFT_MASK // 86 V +#define ASCII_57 KEY_W + SHIFT_MASK // 87 W +#define ASCII_58 KEY_X + SHIFT_MASK // 88 X +#define ASCII_59 KEY_Z + SHIFT_MASK // 89 Y +#define ASCII_5A KEY_Y + SHIFT_MASK // 90 Z +#define ASCII_5B KEY_LEFT_BRACE + ALTGR_MASK // 91 [ +#define ASCII_5C KEY_NON_US_100 + ALTGR_MASK // 92 +#define ASCII_5D KEY_RIGHT_BRACE + ALTGR_MASK // 93 ] +#define ASCII_5E CIRCUMFLEX_BITS + KEY_SPACE // 94 ^ +#define ASCII_5F KEY_SLASH + SHIFT_MASK // 95 _ +#define ASCII_60 GRAVE_ACCENT_BITS + KEY_SPACE // 96 ` +#define ASCII_61 KEY_A // 97 a +#define ASCII_62 KEY_B // 98 b +#define ASCII_63 KEY_C // 99 c +#define ASCII_64 KEY_D // 100 d +#define ASCII_65 KEY_E // 101 e +#define ASCII_66 KEY_F // 102 f +#define ASCII_67 KEY_G // 103 g +#define ASCII_68 KEY_H // 104 h +#define ASCII_69 KEY_I // 105 i +#define ASCII_6A KEY_J // 106 j +#define ASCII_6B KEY_K // 107 k +#define ASCII_6C KEY_L // 108 l +#define ASCII_6D KEY_M // 109 m +#define ASCII_6E KEY_N // 110 n +#define ASCII_6F KEY_O // 111 o +#define ASCII_70 KEY_P // 112 p +#define ASCII_71 KEY_Q // 113 q +#define ASCII_72 KEY_R // 114 r +#define ASCII_73 KEY_S // 115 s +#define ASCII_74 KEY_T // 116 t +#define ASCII_75 KEY_U // 117 u +#define ASCII_76 KEY_V // 118 v +#define ASCII_77 KEY_W // 119 w +#define ASCII_78 KEY_X // 120 x +#define ASCII_79 KEY_Z // 121 y +#define ASCII_7A KEY_Y // 122 z +#define ASCII_7B KEY_QUOTE + ALTGR_MASK // 123 { +#define ASCII_7C KEY_7 + ALTGR_MASK // 124 | +#define ASCII_7D KEY_BACKSLASH + ALTGR_MASK // 125 } +#define ASCII_7E TILDE_BITS + KEY_SPACE // 126 ~ +#define ASCII_7F KEY_BACKSPACE // 127 +#define ISO_8859_1_A0 KEY_SPACE // 160 Nonbreakng Space +#define ISO_8859_1_A1 0 // 161 ¡ Inverted Exclamation +#define ISO_8859_1_A2 KEY_8 + ALTGR_MASK // 162 ¢ Cent Sign +#define ISO_8859_1_A3 KEY_BACKSLASH + SHIFT_MASK // 163 £ Pound Sign +#define ISO_8859_1_A4 0 // 164 ¤ Currency Sign +#define ISO_8859_1_A5 0 // 165 ¥ YEN SIGN +#define ISO_8859_1_A6 KEY_1 + ALTGR_MASK // 166 ¦ BROKEN BAR +#define ISO_8859_1_A7 KEY_5 + ALTGR_MASK // 167 § SECTION SIGN +#define ISO_8859_1_A8 DIAERESIS_BITS + KEY_SPACE // 168 ¨ DIAERESIS +#define ISO_8859_1_A9 0 // 169 © COPYRIGHT SIGN +#define ISO_8859_1_AA 0 // 170 ª FEMININE ORDINAL +#define ISO_8859_1_AB 0 // 171 « LEFT DOUBLE ANGLE QUOTE +#define ISO_8859_1_AC KEY_6 + ALTGR_MASK // 172 ¬ NOT SIGN +#define ISO_8859_1_AD 0 // 173 SOFT HYPHEN +#define ISO_8859_1_AE 0 // 174 ® REGISTERED SIGN +#define ISO_8859_1_AF 0 // 175 ¯ MACRON +#define ISO_8859_1_B0 KEY_4 + ALTGR_MASK // 176 ° DEGREE SIGN +#define ISO_8859_1_B1 0 // 177 ± PLUS-MINUS SIGN +#define ISO_8859_1_B2 0 // 178 ² SUPERSCRIPT TWO +#define ISO_8859_1_B3 0 // 179 ³ SUPERSCRIPT THREE +#define ISO_8859_1_B4 ACUTE_ACCENT_BITS + KEY_SPACE // 180 ´ ACUTE ACCENT +#define ISO_8859_1_B5 0 // 181 µ MICRO SIGN +#define ISO_8859_1_B6 0 // 182 ¶ PILCROW SIGN +#define ISO_8859_1_B7 0 // 183 · MIDDLE DOT +#define ISO_8859_1_B8 0 // 184 ¸ CEDILLA +#define ISO_8859_1_B9 0 // 185 ¹ SUPERSCRIPT ONE +#define ISO_8859_1_BA 0 // 186 º MASCULINE ORDINAL +#define ISO_8859_1_BB 0 // 187 » RIGHT DOUBLE ANGLE QUOTE +#define ISO_8859_1_BC 0 // 188 ¼ FRACTION ONE QUARTER +#define ISO_8859_1_BD 0 // 189 ½ FRACTION ONE HALF +#define ISO_8859_1_BE 0 // 190 ¾ FRACTION THREE QUARTERS +#define ISO_8859_1_BF 0 // 191 ¿ INVERTED QUESTION MARK +#define ISO_8859_1_C0 GRAVE_ACCENT_BITS + KEY_A + SHIFT_MASK // 192 À A GRAVE +#define ISO_8859_1_C1 ACUTE_ACCENT_BITS + KEY_A + SHIFT_MASK // 193 Á A ACUTE +#define ISO_8859_1_C2 CIRCUMFLEX_BITS + KEY_A + SHIFT_MASK // 194 Â A CIRCUMFLEX +#define ISO_8859_1_C3 TILDE_BITS + KEY_A + SHIFT_MASK // 195 Ã A TILDE +#define ISO_8859_1_C4 DIAERESIS_BITS + KEY_A + SHIFT_MASK // 196 Ä A DIAERESIS +#define ISO_8859_1_C5 0 // 197 Å A RING ABOVE +#define ISO_8859_1_C6 0 // 198 Æ AE +#define ISO_8859_1_C7 0 // 199 Ç C CEDILLA +#define ISO_8859_1_C8 GRAVE_ACCENT_BITS + KEY_E + SHIFT_MASK // 200 È E GRAVE +#define ISO_8859_1_C9 ACUTE_ACCENT_BITS + KEY_E + SHIFT_MASK // 201 É E ACUTE +#define ISO_8859_1_CA CIRCUMFLEX_BITS + KEY_E + SHIFT_MASK // 202 Ê E CIRCUMFLEX +#define ISO_8859_1_CB DIAERESIS_BITS + KEY_E + SHIFT_MASK // 203 Ë E DIAERESIS +#define ISO_8859_1_CC GRAVE_ACCENT_BITS + KEY_I + SHIFT_MASK // 204 Ì I GRAVE +#define ISO_8859_1_CD ACUTE_ACCENT_BITS + KEY_I + SHIFT_MASK // 205 Í I ACUTE +#define ISO_8859_1_CE CIRCUMFLEX_BITS + KEY_I + SHIFT_MASK // 206 Î I CIRCUMFLEX +#define ISO_8859_1_CF DIAERESIS_BITS + KEY_I + SHIFT_MASK // 207 Ï I DIAERESIS +#define ISO_8859_1_D0 0 // 208 Ð ETH +#define ISO_8859_1_D1 TILDE_BITS + KEY_N + SHIFT_MASK // 209 Ñ N TILDE +#define ISO_8859_1_D2 GRAVE_ACCENT_BITS + KEY_O + SHIFT_MASK // 210 Ò O GRAVE +#define ISO_8859_1_D3 ACUTE_ACCENT_BITS + KEY_O + SHIFT_MASK // 211 Ó O ACUTE +#define ISO_8859_1_D4 CIRCUMFLEX_BITS + KEY_O + SHIFT_MASK // 212 Ô O CIRCUMFLEX +#define ISO_8859_1_D5 TILDE_BITS + KEY_O + SHIFT_MASK // 213 Õ O TILDE +#define ISO_8859_1_D6 DIAERESIS_BITS + KEY_O + SHIFT_MASK // 214 Ö O DIAERESIS +#define ISO_8859_1_D7 0 // 215 × MULTIPLICATION +#define ISO_8859_1_D8 0 // 216 Ø O STROKE +#define ISO_8859_1_D9 GRAVE_ACCENT_BITS + KEY_U + SHIFT_MASK // 217 Ù U GRAVE +#define ISO_8859_1_DA ACUTE_ACCENT_BITS + KEY_U + SHIFT_MASK // 218 Ú U ACUTE +#define ISO_8859_1_DB CIRCUMFLEX_BITS + KEY_U + SHIFT_MASK // 219 Û U CIRCUMFLEX +#define ISO_8859_1_DC DIAERESIS_BITS + KEY_U + SHIFT_MASK // 220 Ü U DIAERESIS +#define ISO_8859_1_DD ACUTE_ACCENT_BITS + KEY_Y + SHIFT_MASK // 221 Ý Y ACUTE +#define ISO_8859_1_DE 0 // 222 Þ THORN +#define ISO_8859_1_DF 0 // 223 ß SHARP S +#define ISO_8859_1_E0 KEY_QUOTE + SHIFT_MASK // 224 à a GRAVE +#define ISO_8859_1_E1 ACUTE_ACCENT_BITS + KEY_A // 225 á a ACUTE +#define ISO_8859_1_E2 CIRCUMFLEX_BITS + KEY_A // 226 â a CIRCUMFLEX +#define ISO_8859_1_E3 TILDE_BITS + KEY_A // 227 ã a TILDE +#define ISO_8859_1_E4 KEY_QUOTE // 228 ä a DIAERESIS +#define ISO_8859_1_E5 0 // 229 å a RING ABOVE +#define ISO_8859_1_E6 0 // 230 æ ae +#define ISO_8859_1_E7 KEY_4 + SHIFT_MASK // 231 ç c CEDILLA +#define ISO_8859_1_E8 KEY_LEFT_BRACE + SHIFT_MASK // 232 è e GRAVE +#define ISO_8859_1_E9 KEY_SEMICOLON + SHIFT_MASK // 233 é e ACUTE +#define ISO_8859_1_EA CIRCUMFLEX_BITS + KEY_E // 234 ê e CIRCUMFLEX +#define ISO_8859_1_EB DIAERESIS_BITS + KEY_E // 235 ë e DIAERESIS TODO: check this +#define ISO_8859_1_EC GRAVE_ACCENT_BITS + KEY_I // 236 ì i GRAVE +#define ISO_8859_1_ED ACUTE_ACCENT_BITS + KEY_I // 237 í i ACUTE +#define ISO_8859_1_EE CIRCUMFLEX_BITS + KEY_I // 238 î i CIRCUMFLEX +#define ISO_8859_1_EF DIAERESIS_BITS + KEY_I // 239 ï i DIAERESIS +#define ISO_8859_1_F0 0 // 240 ð ETH +#define ISO_8859_1_F1 TILDE_BITS + KEY_N // 241 ñ n TILDE +#define ISO_8859_1_F2 GRAVE_ACCENT_BITS + KEY_O // 242 ò o GRAVE +#define ISO_8859_1_F3 ACUTE_ACCENT_BITS + KEY_O // 243 ó o ACUTE +#define ISO_8859_1_F4 CIRCUMFLEX_BITS + KEY_O // 244 ô o CIRCUMFLEX +#define ISO_8859_1_F5 TILDE_BITS + KEY_O // 245 õ o TILDE +#define ISO_8859_1_F6 KEY_SEMICOLON // 246 ö o DIAERESIS +#define ISO_8859_1_F7 0 // 247 ÷ DIVISION +#define ISO_8859_1_F8 0 // 248 ø o STROKE +#define ISO_8859_1_F9 GRAVE_ACCENT_BITS + KEY_U // 249 ù u GRAVE +#define ISO_8859_1_FA ACUTE_ACCENT_BITS + KEY_U // 250 ú u ACUTE +#define ISO_8859_1_FB CIRCUMFLEX_BITS + KEY_U // 251 û u CIRCUMFLEX +#define ISO_8859_1_FC KEY_LEFT_BRACE // 252 ü u DIAERESIS +#define ISO_8859_1_FD ACUTE_ACCENT_BITS + KEY_Y // 253 ý y ACUTE +#define ISO_8859_1_FE 0 // 254 þ THORN +#define ISO_8859_1_FF DIAERESIS_BITS + KEY_Y // 255 ÿ y DIAERESIS +#define UNICODE_20AC KEY_E + ALTGR_MASK // € Euro Sign +// not yet implemented +#define UNICODE_EXTRA00 0x20AC +#define KEYCODE_EXTRA00 KEY_E + ALTGR_MASK // 20AC € Euro Sign + +#endif // LAYOUT_GERMAN_SWISS + + + + +#ifdef LAYOUT_FRENCH_SWISS + +#define SHIFT_MASK 0x0040 +#define ALTGR_MASK 0x0080 +#define DEADKEYS_MASK 0x0700 +#define CIRCUMFLEX_BITS 0x0100 +#define GRAVE_ACCENT_BITS 0x0200 +#define DIAERESIS_BITS 0x0300 +#define TILDE_BITS 0x0400 +#define ACUTE_ACCENT_BITS 0x0500 +#define KEYCODE_TYPE uint16_t +#define KEYCODE_MASK 0x07FF +#define DEADKEY_CIRCUMFLEX KEY_EQUAL +#define DEADKEY_ACUTE_ACCENT KEY_MINUS + ALTGR_MASK +#define DEADKEY_GRAVE_ACCENT KEY_EQUAL + SHIFT_MASK +#define DEADKEY_DIAERESIS KEY_RIGHT_BRACE +#define DEADKEY_TILDE KEY_EQUAL + ALTGR_MASK +#define KEY_NON_US_100 63 + +#define ASCII_20 KEY_SPACE // 32 +#define ASCII_21 KEY_RIGHT_BRACE + SHIFT_MASK // 33 ! +#define ASCII_22 KEY_2 + SHIFT_MASK // 34 " +#define ASCII_23 KEY_3 + ALTGR_MASK // 35 # +#define ASCII_24 KEY_BACKSLASH // 36 $ +#define ASCII_25 KEY_5 + SHIFT_MASK // 37 % +#define ASCII_26 KEY_6 + SHIFT_MASK // 38 & +#define ASCII_27 KEY_MINUS // 39 ' +#define ASCII_28 KEY_8 + SHIFT_MASK // 40 ( +#define ASCII_29 KEY_9 + SHIFT_MASK // 41 ) +#define ASCII_2A KEY_3 + SHIFT_MASK // 42 * +#define ASCII_2B KEY_1 + SHIFT_MASK // 43 + +#define ASCII_2C KEY_COMMA // 44 , +#define ASCII_2D KEY_SLASH // 45 - +#define ASCII_2E KEY_PERIOD // 46 . +#define ASCII_2F KEY_7 + SHIFT_MASK // 47 / +#define ASCII_30 KEY_0 // 48 0 +#define ASCII_31 KEY_1 // 49 1 +#define ASCII_32 KEY_2 // 50 2 +#define ASCII_33 KEY_3 // 51 3 +#define ASCII_34 KEY_4 // 52 4 +#define ASCII_35 KEY_5 // 53 5 +#define ASCII_36 KEY_6 // 54 6 +#define ASCII_37 KEY_7 // 55 7 +#define ASCII_38 KEY_8 // 55 8 +#define ASCII_39 KEY_9 // 57 9 +#define ASCII_3A KEY_PERIOD + SHIFT_MASK // 58 : +#define ASCII_3B KEY_COMMA + SHIFT_MASK // 59 ; +#define ASCII_3C KEY_NON_US_100 // 60 < +#define ASCII_3D KEY_0 + SHIFT_MASK // 61 = +#define ASCII_3E KEY_NON_US_100 + SHIFT_MASK // 62 > +#define ASCII_3F KEY_MINUS + SHIFT_MASK // 63 ? +#define ASCII_40 KEY_2 + ALTGR_MASK // 64 @ +#define ASCII_41 KEY_A + SHIFT_MASK // 65 A +#define ASCII_42 KEY_B + SHIFT_MASK // 66 B +#define ASCII_43 KEY_C + SHIFT_MASK // 67 C +#define ASCII_44 KEY_D + SHIFT_MASK // 68 D +#define ASCII_45 KEY_E + SHIFT_MASK // 69 E +#define ASCII_46 KEY_F + SHIFT_MASK // 70 F +#define ASCII_47 KEY_G + SHIFT_MASK // 71 G +#define ASCII_48 KEY_H + SHIFT_MASK // 72 H +#define ASCII_49 KEY_I + SHIFT_MASK // 73 I +#define ASCII_4A KEY_J + SHIFT_MASK // 74 J +#define ASCII_4B KEY_K + SHIFT_MASK // 75 K +#define ASCII_4C KEY_L + SHIFT_MASK // 76 L +#define ASCII_4D KEY_M + SHIFT_MASK // 77 M +#define ASCII_4E KEY_N + SHIFT_MASK // 78 N +#define ASCII_4F KEY_O + SHIFT_MASK // 79 O +#define ASCII_50 KEY_P + SHIFT_MASK // 80 P +#define ASCII_51 KEY_Q + SHIFT_MASK // 81 Q +#define ASCII_52 KEY_R + SHIFT_MASK // 82 R +#define ASCII_53 KEY_S + SHIFT_MASK // 83 S +#define ASCII_54 KEY_T + SHIFT_MASK // 84 T +#define ASCII_55 KEY_U + SHIFT_MASK // 85 U +#define ASCII_56 KEY_V + SHIFT_MASK // 86 V +#define ASCII_57 KEY_W + SHIFT_MASK // 87 W +#define ASCII_58 KEY_X + SHIFT_MASK // 88 X +#define ASCII_59 KEY_Z + SHIFT_MASK // 89 Y +#define ASCII_5A KEY_Y + SHIFT_MASK // 90 Z +#define ASCII_5B KEY_LEFT_BRACE + ALTGR_MASK // 91 [ +#define ASCII_5C KEY_NON_US_100 + ALTGR_MASK // 92 +#define ASCII_5D KEY_RIGHT_BRACE + ALTGR_MASK // 93 ] +#define ASCII_5E CIRCUMFLEX_BITS + KEY_SPACE // 94 ^ +#define ASCII_5F KEY_SLASH + SHIFT_MASK // 95 _ +#define ASCII_60 GRAVE_ACCENT_BITS + KEY_SPACE // 96 ` +#define ASCII_61 KEY_A // 97 a +#define ASCII_62 KEY_B // 98 b +#define ASCII_63 KEY_C // 99 c +#define ASCII_64 KEY_D // 100 d +#define ASCII_65 KEY_E // 101 e +#define ASCII_66 KEY_F // 102 f +#define ASCII_67 KEY_G // 103 g +#define ASCII_68 KEY_H // 104 h +#define ASCII_69 KEY_I // 105 i +#define ASCII_6A KEY_J // 106 j +#define ASCII_6B KEY_K // 107 k +#define ASCII_6C KEY_L // 108 l +#define ASCII_6D KEY_M // 109 m +#define ASCII_6E KEY_N // 110 n +#define ASCII_6F KEY_O // 111 o +#define ASCII_70 KEY_P // 112 p +#define ASCII_71 KEY_Q // 113 q +#define ASCII_72 KEY_R // 114 r +#define ASCII_73 KEY_S // 115 s +#define ASCII_74 KEY_T // 116 t +#define ASCII_75 KEY_U // 117 u +#define ASCII_76 KEY_V // 118 v +#define ASCII_77 KEY_W // 119 w +#define ASCII_78 KEY_X // 120 x +#define ASCII_79 KEY_Z // 121 y +#define ASCII_7A KEY_Y // 122 z +#define ASCII_7B KEY_QUOTE + ALTGR_MASK // 123 { +#define ASCII_7C KEY_7 + ALTGR_MASK // 124 | +#define ASCII_7D KEY_BACKSLASH + ALTGR_MASK // 125 } +#define ASCII_7E TILDE_BITS + KEY_SPACE // 126 ~ +#define ASCII_7F KEY_BACKSPACE // 127 +#define ISO_8859_1_A0 KEY_SPACE // 160 Nonbreakng Space +#define ISO_8859_1_A1 0 // 161 ¡ Inverted Exclamation +#define ISO_8859_1_A2 KEY_8 + ALTGR_MASK // 162 ¢ Cent Sign +#define ISO_8859_1_A3 KEY_BACKSLASH + SHIFT_MASK // 163 £ Pound Sign +#define ISO_8859_1_A4 0 // 164 ¤ Currency Sign +#define ISO_8859_1_A5 0 // 165 ¥ YEN SIGN +#define ISO_8859_1_A6 KEY_1 + ALTGR_MASK // 166 ¦ BROKEN BAR +#define ISO_8859_1_A7 KEY_5 + ALTGR_MASK // 167 § SECTION SIGN +#define ISO_8859_1_A8 DIAERESIS_BITS + KEY_SPACE // 168 ¨ DIAERESIS +#define ISO_8859_1_A9 0 // 169 © COPYRIGHT SIGN +#define ISO_8859_1_AA 0 // 170 ª FEMININE ORDINAL +#define ISO_8859_1_AB 0 // 171 « LEFT DOUBLE ANGLE QUOTE +#define ISO_8859_1_AC KEY_6 + ALTGR_MASK // 172 ¬ NOT SIGN +#define ISO_8859_1_AD 0 // 173 SOFT HYPHEN +#define ISO_8859_1_AE 0 // 174 ® REGISTERED SIGN +#define ISO_8859_1_AF 0 // 175 ¯ MACRON +#define ISO_8859_1_B0 KEY_4 + ALTGR_MASK // 176 ° DEGREE SIGN +#define ISO_8859_1_B1 0 // 177 ± PLUS-MINUS SIGN +#define ISO_8859_1_B2 0 // 178 ² SUPERSCRIPT TWO +#define ISO_8859_1_B3 0 // 179 ³ SUPERSCRIPT THREE +#define ISO_8859_1_B4 ACUTE_ACCENT_BITS + KEY_SPACE // 180 ´ ACUTE ACCENT +#define ISO_8859_1_B5 0 // 181 µ MICRO SIGN +#define ISO_8859_1_B6 0 // 182 ¶ PILCROW SIGN +#define ISO_8859_1_B7 0 // 183 · MIDDLE DOT +#define ISO_8859_1_B8 0 // 184 ¸ CEDILLA +#define ISO_8859_1_B9 0 // 185 ¹ SUPERSCRIPT ONE +#define ISO_8859_1_BA 0 // 186 º MASCULINE ORDINAL +#define ISO_8859_1_BB 0 // 187 » RIGHT DOUBLE ANGLE QUOTE +#define ISO_8859_1_BC 0 // 188 ¼ FRACTION ONE QUARTER +#define ISO_8859_1_BD 0 // 189 ½ FRACTION ONE HALF +#define ISO_8859_1_BE 0 // 190 ¾ FRACTION THREE QUARTERS +#define ISO_8859_1_BF 0 // 191 ¿ INVERTED QUESTION MARK +#define ISO_8859_1_C0 GRAVE_ACCENT_BITS + KEY_A + SHIFT_MASK // 192 À A GRAVE +#define ISO_8859_1_C1 ACUTE_ACCENT_BITS + KEY_A + SHIFT_MASK // 193 Á A ACUTE +#define ISO_8859_1_C2 CIRCUMFLEX_BITS + KEY_A + SHIFT_MASK // 194 Â A CIRCUMFLEX +#define ISO_8859_1_C3 TILDE_BITS + KEY_A + SHIFT_MASK // 195 Ã A TILDE +#define ISO_8859_1_C4 DIAERESIS_BITS + KEY_A + SHIFT_MASK // 196 Ä A DIAERESIS +#define ISO_8859_1_C5 0 // 197 Å A RING ABOVE +#define ISO_8859_1_C6 0 // 198 Æ AE +#define ISO_8859_1_C7 0 // 199 Ç C CEDILLA +#define ISO_8859_1_C8 GRAVE_ACCENT_BITS + KEY_E + SHIFT_MASK // 200 È E GRAVE +#define ISO_8859_1_C9 ACUTE_ACCENT_BITS + KEY_E + SHIFT_MASK // 201 É E ACUTE +#define ISO_8859_1_CA CIRCUMFLEX_BITS + KEY_E + SHIFT_MASK // 202 Ê E CIRCUMFLEX +#define ISO_8859_1_CB DIAERESIS_BITS + KEY_E + SHIFT_MASK // 203 Ë E DIAERESIS +#define ISO_8859_1_CC GRAVE_ACCENT_BITS + KEY_I + SHIFT_MASK // 204 Ì I GRAVE +#define ISO_8859_1_CD ACUTE_ACCENT_BITS + KEY_I + SHIFT_MASK // 205 Í I ACUTE +#define ISO_8859_1_CE CIRCUMFLEX_BITS + KEY_I + SHIFT_MASK // 206 Î I CIRCUMFLEX +#define ISO_8859_1_CF DIAERESIS_BITS + KEY_I + SHIFT_MASK // 207 Ï I DIAERESIS +#define ISO_8859_1_D0 0 // 208 Ð ETH +#define ISO_8859_1_D1 TILDE_BITS + KEY_N + SHIFT_MASK // 209 Ñ N TILDE +#define ISO_8859_1_D2 GRAVE_ACCENT_BITS + KEY_O + SHIFT_MASK // 210 Ò O GRAVE +#define ISO_8859_1_D3 ACUTE_ACCENT_BITS + KEY_O + SHIFT_MASK // 211 Ó O ACUTE +#define ISO_8859_1_D4 CIRCUMFLEX_BITS + KEY_O + SHIFT_MASK // 212 Ô O CIRCUMFLEX +#define ISO_8859_1_D5 TILDE_BITS + KEY_O + SHIFT_MASK // 213 Õ O TILDE +#define ISO_8859_1_D6 DIAERESIS_BITS + KEY_O + SHIFT_MASK // 214 Ö O DIAERESIS +#define ISO_8859_1_D7 0 // 215 × MULTIPLICATION +#define ISO_8859_1_D8 0 // 216 Ø O STROKE +#define ISO_8859_1_D9 GRAVE_ACCENT_BITS + KEY_U + SHIFT_MASK // 217 Ù U GRAVE +#define ISO_8859_1_DA ACUTE_ACCENT_BITS + KEY_U + SHIFT_MASK // 218 Ú U ACUTE +#define ISO_8859_1_DB CIRCUMFLEX_BITS + KEY_U + SHIFT_MASK // 219 Û U CIRCUMFLEX +#define ISO_8859_1_DC DIAERESIS_BITS + KEY_U + SHIFT_MASK // 220 Ü U DIAERESIS +#define ISO_8859_1_DD ACUTE_ACCENT_BITS + KEY_Y + SHIFT_MASK // 221 Ý Y ACUTE +#define ISO_8859_1_DE 0 // 222 Þ THORN +#define ISO_8859_1_DF 0 // 223 ß SHARP S +#define ISO_8859_1_E0 KEY_QUOTE // 224 à a GRAVE +#define ISO_8859_1_E1 ACUTE_ACCENT_BITS + KEY_A // 225 á a ACUTE +#define ISO_8859_1_E2 CIRCUMFLEX_BITS + KEY_A // 226 â a CIRCUMFLEX +#define ISO_8859_1_E3 TILDE_BITS + KEY_A // 227 ã a TILDE +#define ISO_8859_1_E4 KEY_QUOTE + SHIFT_MASK // 228 ä a DIAERESIS +#define ISO_8859_1_E5 0 // 229 å a RING ABOVE +#define ISO_8859_1_E6 0 // 230 æ ae +#define ISO_8859_1_E7 KEY_4 + SHIFT_MASK // 231 ç c CEDILLA +#define ISO_8859_1_E8 KEY_LEFT_BRACE // 232 è e GRAVE +#define ISO_8859_1_E9 KEY_SEMICOLON // 233 é e ACUTE +#define ISO_8859_1_EA CIRCUMFLEX_BITS + KEY_E // 234 ê e CIRCUMFLEX +#define ISO_8859_1_EB DIAERESIS_BITS + KEY_E // 235 ë e DIAERESIS +#define ISO_8859_1_EC GRAVE_ACCENT_BITS + KEY_I // 236 ì i GRAVE +#define ISO_8859_1_ED ACUTE_ACCENT_BITS + KEY_I // 237 í i ACUTE +#define ISO_8859_1_EE CIRCUMFLEX_BITS + KEY_I // 238 î i CIRCUMFLEX +#define ISO_8859_1_EF DIAERESIS_BITS + KEY_I // 239 ï i DIAERESIS +#define ISO_8859_1_F0 0 // 240 ð ETH +#define ISO_8859_1_F1 TILDE_BITS + KEY_N // 241 ñ n TILDE +#define ISO_8859_1_F2 GRAVE_ACCENT_BITS + KEY_O // 242 ò o GRAVE +#define ISO_8859_1_F3 ACUTE_ACCENT_BITS + KEY_O // 243 ó o ACUTE +#define ISO_8859_1_F4 CIRCUMFLEX_BITS + KEY_O // 244 ô o CIRCUMFLEX +#define ISO_8859_1_F5 TILDE_BITS + KEY_O // 245 õ o TILDE +#define ISO_8859_1_F6 KEY_SEMICOLON + SHIFT_MASK // 246 ö o DIAERESIS +#define ISO_8859_1_F7 0 // 247 ÷ DIVISION +#define ISO_8859_1_F8 0 // 248 ø o STROKE +#define ISO_8859_1_F9 GRAVE_ACCENT_BITS + KEY_U // 249 ù u GRAVE +#define ISO_8859_1_FA ACUTE_ACCENT_BITS + KEY_U // 250 ú u ACUTE +#define ISO_8859_1_FB CIRCUMFLEX_BITS + KEY_U // 251 û u CIRCUMFLEX +#define ISO_8859_1_FC KEY_LEFT_BRACE + SHIFT_MASK // 252 ü u DIAERESIS +#define ISO_8859_1_FD ACUTE_ACCENT_BITS + KEY_Y // 253 ý y ACUTE +#define ISO_8859_1_FE 0 // 254 þ THORN +#define ISO_8859_1_FF DIAERESIS_BITS + KEY_Y // 255 ÿ y DIAERESIS +#define UNICODE_20AC KEY_E + ALTGR_MASK // € Euro Sign +// not yet implemented +#define UNICODE_EXTRA00 0x20AC +#define KEYCODE_EXTRA00 KEY_E + ALTGR_MASK // 20AC € Euro Sign + +#endif // LAYOUT_FRENCH_SWISS + + + + + +#ifdef LAYOUT_SPANISH_LATIN_AMERICA + +#define SHIFT_MASK 0x0040 +#define ALTGR_MASK 0x0080 +#define DEADKEYS_MASK 0x0700 +#define CIRCUMFLEX_BITS 0x0100 +#define ACUTE_ACCENT_BITS 0x0200 +#define GRAVE_ACCENT_BITS 0x0300 +#define DIAERESIS_BITS 0x0400 +#define KEYCODE_TYPE uint16_t +#define KEYCODE_MASK 0x07FF +#define DEADKEY_CIRCUMFLEX KEY_QUOTE + ALTGR_MASK +#define DEADKEY_ACUTE_ACCENT KEY_LEFT_BRACE +#define DEADKEY_GRAVE_ACCENT KEY_BACKSLASH + ALTGR_MASK +#define DEADKEY_DIAERESIS KEY_LEFT_BRACE + SHIFT_MASK +#define KEY_NON_US_100 63 + +#define ASCII_20 KEY_SPACE // 32 +#define ASCII_21 KEY_1 + SHIFT_MASK // 33 ! +#define ASCII_22 KEY_2 + SHIFT_MASK // 34 " +#define ASCII_23 KEY_3 + ALTGR_MASK // 35 # +#define ASCII_24 KEY_4 + SHIFT_MASK // 36 $ +#define ASCII_25 KEY_5 + SHIFT_MASK // 37 % +#define ASCII_26 KEY_6 + SHIFT_MASK // 38 & +#define ASCII_27 KEY_MINUS // 39 ' +#define ASCII_28 KEY_8 + SHIFT_MASK // 40 ( +#define ASCII_29 KEY_9 + SHIFT_MASK // 41 ) +#define ASCII_2A KEY_RIGHT_BRACE + SHIFT_MASK // 42 * +#define ASCII_2B KEY_RIGHT_BRACE // 43 + +#define ASCII_2C KEY_COMMA // 44 , +#define ASCII_2D KEY_SLASH // 45 - +#define ASCII_2E KEY_PERIOD // 46 . +#define ASCII_2F KEY_7 + SHIFT_MASK // 47 / +#define ASCII_30 KEY_0 // 48 0 +#define ASCII_31 KEY_1 // 49 1 +#define ASCII_32 KEY_2 // 50 2 +#define ASCII_33 KEY_3 // 51 3 +#define ASCII_34 KEY_4 // 52 4 +#define ASCII_35 KEY_5 // 53 5 +#define ASCII_36 KEY_6 // 54 6 +#define ASCII_37 KEY_7 // 55 7 +#define ASCII_38 KEY_8 // 55 8 +#define ASCII_39 KEY_9 // 57 9 +#define ASCII_3A KEY_PERIOD + SHIFT_MASK // 58 : +#define ASCII_3B KEY_COMMA + SHIFT_MASK // 59 ; +#define ASCII_3C KEY_NON_US_100 // 60 < +#define ASCII_3D KEY_0 + SHIFT_MASK // 61 = +#define ASCII_3E KEY_NON_US_100 + SHIFT_MASK // 62 > +#define ASCII_3F KEY_MINUS + SHIFT_MASK // 63 ? +#define ASCII_40 KEY_Q + ALTGR_MASK // 64 @ +#define ASCII_41 KEY_A + SHIFT_MASK // 65 A +#define ASCII_42 KEY_B + SHIFT_MASK // 66 B +#define ASCII_43 KEY_C + SHIFT_MASK // 67 C +#define ASCII_44 KEY_D + SHIFT_MASK // 68 D +#define ASCII_45 KEY_E + SHIFT_MASK // 69 E +#define ASCII_46 KEY_F + SHIFT_MASK // 70 F +#define ASCII_47 KEY_G + SHIFT_MASK // 71 G +#define ASCII_48 KEY_H + SHIFT_MASK // 72 H +#define ASCII_49 KEY_I + SHIFT_MASK // 73 I +#define ASCII_4A KEY_J + SHIFT_MASK // 74 J +#define ASCII_4B KEY_K + SHIFT_MASK // 75 K +#define ASCII_4C KEY_L + SHIFT_MASK // 76 L +#define ASCII_4D KEY_M + SHIFT_MASK // 77 M +#define ASCII_4E KEY_N + SHIFT_MASK // 78 N +#define ASCII_4F KEY_O + SHIFT_MASK // 79 O +#define ASCII_50 KEY_P + SHIFT_MASK // 80 P +#define ASCII_51 KEY_Q + SHIFT_MASK // 81 Q +#define ASCII_52 KEY_R + SHIFT_MASK // 82 R +#define ASCII_53 KEY_S + SHIFT_MASK // 83 S +#define ASCII_54 KEY_T + SHIFT_MASK // 84 T +#define ASCII_55 KEY_U + SHIFT_MASK // 85 U +#define ASCII_56 KEY_V + SHIFT_MASK // 86 V +#define ASCII_57 KEY_W + SHIFT_MASK // 87 W +#define ASCII_58 KEY_X + SHIFT_MASK // 88 X +#define ASCII_59 KEY_Y + SHIFT_MASK // 89 Y +#define ASCII_5A KEY_Z + SHIFT_MASK // 90 Z +#define ASCII_5B KEY_QUOTE + SHIFT_MASK // 91 [ +#define ASCII_5C KEY_MINUS + ALTGR_MASK // 92 +#define ASCII_5D KEY_BACKSLASH + SHIFT_MASK // 93 ] +#define ASCII_5E CIRCUMFLEX_BITS + KEY_SPACE // 94 ^ +#define ASCII_5F KEY_SLASH + SHIFT_MASK // 95 _ +#define ASCII_60 GRAVE_ACCENT_BITS + KEY_SPACE // 96 ` +#define ASCII_61 KEY_A // 97 a +#define ASCII_62 KEY_B // 98 b +#define ASCII_63 KEY_C // 99 c +#define ASCII_64 KEY_D // 100 d +#define ASCII_65 KEY_E // 101 e +#define ASCII_66 KEY_F // 102 f +#define ASCII_67 KEY_G // 103 g +#define ASCII_68 KEY_H // 104 h +#define ASCII_69 KEY_I // 105 i +#define ASCII_6A KEY_J // 106 j +#define ASCII_6B KEY_K // 107 k +#define ASCII_6C KEY_L // 108 l +#define ASCII_6D KEY_M // 109 m +#define ASCII_6E KEY_N // 110 n +#define ASCII_6F KEY_O // 111 o +#define ASCII_70 KEY_P // 112 p +#define ASCII_71 KEY_Q // 113 q +#define ASCII_72 KEY_R // 114 r +#define ASCII_73 KEY_S // 115 s +#define ASCII_74 KEY_T // 116 t +#define ASCII_75 KEY_U // 117 u +#define ASCII_76 KEY_V // 118 v +#define ASCII_77 KEY_W // 119 w +#define ASCII_78 KEY_X // 120 x +#define ASCII_79 KEY_Y // 121 y +#define ASCII_7A KEY_Z // 122 z +#define ASCII_7B KEY_QUOTE // 123 { +#define ASCII_7C KEY_TILDE // 124 | +#define ASCII_7D KEY_BACKSLASH // 125 } +#define ASCII_7E KEY_RIGHT_BRACE + ALTGR_MASK // 126 ~ +#define ASCII_7F KEY_BACKSPACE // 127 + +#define ISO_8859_1_A0 KEY_SPACE // 160 Nonbreakng Space +#define ISO_8859_1_A1 KEY_EQUAL + SHIFT_MASK // 161 ¡ Inverted Exclamation +#define ISO_8859_1_A2 0 // 162 ¢ Cent SIGN +#define ISO_8859_1_A3 0 // 163 £ Pound Sign +#define ISO_8859_1_A4 0 // 164 ¤ Currency Sign +#define ISO_8859_1_A5 0 // 165 ¥ YEN SIGN +#define ISO_8859_1_A6 0 // 166 ¦ BROKEN BAR +#define ISO_8859_1_A7 0 // 167 § SECTION SIGN +#define ISO_8859_1_A8 DIAERESIS_BITS + KEY_SPACE // 168 ¨ DIAERESIS +#define ISO_8859_1_A9 0 // 169 © COPYRIGHT SIGN +#define ISO_8859_1_AA 0 // 170 ª FEMININE ORDINAL +#define ISO_8859_1_AB 0 // 171 « LEFT DOUBLE ANGLE QUOTE +#define ISO_8859_1_AC KEY_TILDE + ALTGR_MASK // 172 ¬ NOT SIGN +#define ISO_8859_1_AD 0 // 173 SOFT HYPHEN +#define ISO_8859_1_AE 0 // 174 ® REGISTERED SIGN +#define ISO_8859_1_AF 0 // 175 ¯ MACRON +#define ISO_8859_1_B0 KEY_TILDE + SHIFT_MASK // 176 ° DEGREE SIGN +#define ISO_8859_1_B1 0 // 177 ± PLUS-MINUS SIGN +#define ISO_8859_1_B2 0 // 178 ² SUPERSCRIPT TWO +#define ISO_8859_1_B3 0 // 179 ³ SUPERSCRIPT THREE +#define ISO_8859_1_B4 ACUTE_ACCENT_BITS + KEY_SPACE // 180 ´ ACUTE ACCENT +#define ISO_8859_1_B5 0 // 181 µ MICRO SIGN +#define ISO_8859_1_B6 0 // 182 ¶ PILCROW SIGN +#define ISO_8859_1_B7 0 // 183 · MIDDLE DOT +#define ISO_8859_1_B8 0 // 184 ¸ CEDILLA +#define ISO_8859_1_B9 0 // 185 ¹ SUPERSCRIPT ONE +#define ISO_8859_1_BA 0 // 186 º MASCULINE ORDINAL +#define ISO_8859_1_BB 0 // 187 » RIGHT DOUBLE ANGLE QUOTE +#define ISO_8859_1_BC 0 // 188 ¼ FRACTION ONE QUARTER +#define ISO_8859_1_BD 0 // 189 ½ FRACTION ONE HALF +#define ISO_8859_1_BE 0 // 190 ¾ FRACTION THREE QUARTERS +#define ISO_8859_1_BF KEY_EQUAL // 191 ¿ INVERTED QUESTION MARK +#define ISO_8859_1_C0 GRAVE_ACCENT_BITS + KEY_A + SHIFT_MASK // 192 À A GRAVE +#define ISO_8859_1_C1 ACUTE_ACCENT_BITS + KEY_A + SHIFT_MASK // 193 Á A ACUTE +#define ISO_8859_1_C2 CIRCUMFLEX_BITS + KEY_A + SHIFT_MASK // 194 Â A CIRCUMFLEX +#define ISO_8859_1_C3 0 // 195 Ã A TILDE +#define ISO_8859_1_C4 DIAERESIS_BITS + KEY_A + SHIFT_MASK // 196 Ä A DIAERESIS +#define ISO_8859_1_C5 0 // 197 Å A RING ABOVE +#define ISO_8859_1_C6 0 // 198 Æ AE +#define ISO_8859_1_C7 0 // 199 Ç C CEDILLA +#define ISO_8859_1_C8 GRAVE_ACCENT_BITS + KEY_E + SHIFT_MASK // 200 È E GRAVE +#define ISO_8859_1_C9 ACUTE_ACCENT_BITS + KEY_E + SHIFT_MASK // 201 É E ACUTE +#define ISO_8859_1_CA CIRCUMFLEX_BITS + KEY_E + SHIFT_MASK // 202 Ê E CIRCUMFLEX +#define ISO_8859_1_CB DIAERESIS_BITS + KEY_E + SHIFT_MASK // 203 Ë E DIAERESIS +#define ISO_8859_1_CC GRAVE_ACCENT_BITS + KEY_I + SHIFT_MASK // 204 Ì I GRAVE +#define ISO_8859_1_CD ACUTE_ACCENT_BITS + KEY_I + SHIFT_MASK // 205 Í I ACUTE +#define ISO_8859_1_CE CIRCUMFLEX_BITS + KEY_I + SHIFT_MASK // 206 Î I CIRCUMFLEX +#define ISO_8859_1_CF DIAERESIS_BITS + KEY_I + SHIFT_MASK // 207 Ï I DIAERESIS +#define ISO_8859_1_D0 0 // 208 Ð ETH +#define ISO_8859_1_D1 KEY_SEMICOLON + SHIFT_MASK // 209 Ñ N TILDE +#define ISO_8859_1_D2 GRAVE_ACCENT_BITS + KEY_O + SHIFT_MASK // 210 Ò O GRAVE +#define ISO_8859_1_D3 ACUTE_ACCENT_BITS + KEY_O + SHIFT_MASK // 211 Ó O ACUTE +#define ISO_8859_1_D4 CIRCUMFLEX_BITS + KEY_O + SHIFT_MASK // 212 Ô O CIRCUMFLEX +#define ISO_8859_1_D5 0 // 213 Õ O TILDE +#define ISO_8859_1_D6 DIAERESIS_BITS + KEY_O + SHIFT_MASK // 214 Ö O DIAERESIS +#define ISO_8859_1_D7 0 // 215 × MULTIPLICATION +#define ISO_8859_1_D8 0 // 216 Ø O STROKE +#define ISO_8859_1_D9 GRAVE_ACCENT_BITS + KEY_U + SHIFT_MASK // 217 Ù U GRAVE +#define ISO_8859_1_DA ACUTE_ACCENT_BITS + KEY_U + SHIFT_MASK // 218 Ú U ACUTE +#define ISO_8859_1_DB CIRCUMFLEX_BITS + KEY_U + SHIFT_MASK // 219 Û U CIRCUMFLEX +#define ISO_8859_1_DC DIAERESIS_BITS + KEY_U + SHIFT_MASK // 220 Ü U DIAERESIS +#define ISO_8859_1_DD ACUTE_ACCENT_BITS + KEY_Y + SHIFT_MASK // 221 Ý Y ACUTE +#define ISO_8859_1_DE 0 // 222 Þ THORN +#define ISO_8859_1_DF 0 // 223 ß SHARP S +#define ISO_8859_1_E0 GRAVE_ACCENT_BITS + KEY_A // 224 à a GRAVE +#define ISO_8859_1_E1 ACUTE_ACCENT_BITS + KEY_A // 225 á a ACUTE +#define ISO_8859_1_E2 CIRCUMFLEX_BITS + KEY_A // 226 â a CIRCUMFLEX +#define ISO_8859_1_E3 0 // 227 ã a TILDE +#define ISO_8859_1_E4 DIAERESIS_BITS + KEY_A // 228 ä a DIAERESIS +#define ISO_8859_1_E5 0 // 229 å a RING ABOVE +#define ISO_8859_1_E6 0 // 230 æ ae +#define ISO_8859_1_E7 0 // 231 ç c CEDILLA +#define ISO_8859_1_E8 GRAVE_ACCENT_BITS + KEY_E // 232 è e GRAVE +#define ISO_8859_1_E9 ACUTE_ACCENT_BITS + KEY_E // 233 é e ACUTE +#define ISO_8859_1_EA CIRCUMFLEX_BITS + KEY_E // 234 ê e CIRCUMFLEX +#define ISO_8859_1_EB DIAERESIS_BITS + KEY_E // 235 ë e DIAERESIS +#define ISO_8859_1_EC GRAVE_ACCENT_BITS + KEY_I // 236 ì i GRAVE +#define ISO_8859_1_ED ACUTE_ACCENT_BITS + KEY_I // 237 í i ACUTE +#define ISO_8859_1_EE CIRCUMFLEX_BITS + KEY_I // 238 î i CIRCUMFLEX +#define ISO_8859_1_EF DIAERESIS_BITS + KEY_I // 239 ï i DIAERESIS +#define ISO_8859_1_F0 0 // 240 ð ETH +#define ISO_8859_1_F1 KEY_SEMICOLON // 241 ñ n TILDE +#define ISO_8859_1_F2 GRAVE_ACCENT_BITS + KEY_O // 242 ò o GRAVE +#define ISO_8859_1_F3 ACUTE_ACCENT_BITS + KEY_O // 243 ó o ACUTE +#define ISO_8859_1_F4 CIRCUMFLEX_BITS + KEY_O // 244 ô o CIRCUMFLEX +#define ISO_8859_1_F5 0 // 245 õ o TILDE +#define ISO_8859_1_F6 DIAERESIS_BITS + KEY_O // 246 ö o DIAERESIS +#define ISO_8859_1_F7 0 // 247 ÷ DIVISION +#define ISO_8859_1_F8 0 // 248 ø o STROKE +#define ISO_8859_1_F9 GRAVE_ACCENT_BITS + KEY_U // 249 ù u GRAVE +#define ISO_8859_1_FA ACUTE_ACCENT_BITS + KEY_U // 250 ú u ACUTE +#define ISO_8859_1_FB CIRCUMFLEX_BITS + KEY_U // 251 û u CIRCUMFLEX +#define ISO_8859_1_FC DIAERESIS_BITS + KEY_U // 252 ü u DIAERESIS +#define ISO_8859_1_FD ACUTE_ACCENT_BITS + KEY_Y // 253 ý y ACUTE +#define ISO_8859_1_FE 0 // 254 þ THORN +#define ISO_8859_1_FF DIAERESIS_BITS + KEY_Y // 255 ÿ y DIAERESIS + +#endif // LAYOUT_SPANISH_LATIN_AMERICA + + + +#ifdef LAYOUT_IRISH + +#define SHIFT_MASK 0x0040 +#define ALTGR_MASK 0x0080 +#define DEADKEYS_MASK 0x0300 +#define GRAVE_ACCENT_BITS 0x0100 +#define ACUTE_ACCENT_BITS 0x0200 +#define KEYCODE_TYPE uint16_t +#define KEYCODE_MASK 0x03FF +#define DEADKEY_ACUTE_ACCENT KEY_QUOTE + ALTGR_MASK +#define DEADKEY_GRAVE_ACCENT KEY_TILDE +#define KEY_NON_US_100 63 + +#define ASCII_20 KEY_SPACE // 32 +#define ASCII_21 KEY_1 + SHIFT_MASK // 33 ! +#define ASCII_22 KEY_2 + SHIFT_MASK // 34 " +#define ASCII_23 KEY_BACKSPACE // 35 # +#define ASCII_24 KEY_4 + SHIFT_MASK // 36 $ +#define ASCII_25 KEY_5 + SHIFT_MASK // 37 % +#define ASCII_26 KEY_7 + SHIFT_MASK // 38 & +#define ASCII_27 KEY_QUOTE // 39 ' +#define ASCII_28 KEY_9 + SHIFT_MASK // 40 ( +#define ASCII_29 KEY_0 + SHIFT_MASK // 41 ) +#define ASCII_2A KEY_8 + SHIFT_MASK // 42 * +#define ASCII_2B KEY_EQUAL + SHIFT_MASK // 43 + +#define ASCII_2C KEY_COMMA // 44 , +#define ASCII_2D KEY_MINUS // 45 - +#define ASCII_2E KEY_PERIOD // 46 . +#define ASCII_2F KEY_SLASH // 47 / +#define ASCII_30 KEY_0 // 48 0 +#define ASCII_31 KEY_1 // 49 1 +#define ASCII_32 KEY_2 // 50 2 +#define ASCII_33 KEY_3 // 51 3 +#define ASCII_34 KEY_4 // 52 4 +#define ASCII_35 KEY_5 // 53 5 +#define ASCII_36 KEY_6 // 54 6 +#define ASCII_37 KEY_7 // 55 7 +#define ASCII_38 KEY_8 // 55 8 +#define ASCII_39 KEY_9 // 57 9 +#define ASCII_3A KEY_SEMICOLON + SHIFT_MASK // 58 : +#define ASCII_3B KEY_SEMICOLON // 59 ; +#define ASCII_3C KEY_COMMA + SHIFT_MASK // 60 < +#define ASCII_3D KEY_EQUAL // 61 = +#define ASCII_3E KEY_PERIOD + SHIFT_MASK // 62 > +#define ASCII_3F KEY_SLASH + SHIFT_MASK // 63 ? +#define ASCII_40 KEY_QUOTE + SHIFT_MASK // 64 @ +#define ASCII_41 KEY_A + SHIFT_MASK // 65 A +#define ASCII_42 KEY_B + SHIFT_MASK // 66 B +#define ASCII_43 KEY_C + SHIFT_MASK // 67 C +#define ASCII_44 KEY_D + SHIFT_MASK // 68 D +#define ASCII_45 KEY_E + SHIFT_MASK // 69 E +#define ASCII_46 KEY_F + SHIFT_MASK // 70 F +#define ASCII_47 KEY_G + SHIFT_MASK // 71 G +#define ASCII_48 KEY_H + SHIFT_MASK // 72 H +#define ASCII_49 KEY_I + SHIFT_MASK // 73 I +#define ASCII_4A KEY_J + SHIFT_MASK // 74 J +#define ASCII_4B KEY_K + SHIFT_MASK // 75 K +#define ASCII_4C KEY_L + SHIFT_MASK // 76 L +#define ASCII_4D KEY_M + SHIFT_MASK // 77 M +#define ASCII_4E KEY_N + SHIFT_MASK // 78 N +#define ASCII_4F KEY_O + SHIFT_MASK // 79 O +#define ASCII_50 KEY_P + SHIFT_MASK // 80 P +#define ASCII_51 KEY_Q + SHIFT_MASK // 81 Q +#define ASCII_52 KEY_R + SHIFT_MASK // 82 R +#define ASCII_53 KEY_S + SHIFT_MASK // 83 S +#define ASCII_54 KEY_T + SHIFT_MASK // 84 T +#define ASCII_55 KEY_U + SHIFT_MASK // 85 U +#define ASCII_56 KEY_V + SHIFT_MASK // 86 V +#define ASCII_57 KEY_W + SHIFT_MASK // 87 W +#define ASCII_58 KEY_X + SHIFT_MASK // 88 X +#define ASCII_59 KEY_Y + SHIFT_MASK // 89 Y +#define ASCII_5A KEY_Z + SHIFT_MASK // 90 Z +#define ASCII_5B KEY_LEFT_BRACE // 91 [ +#define ASCII_5C KEY_NON_US_100 // 92 +#define ASCII_5D KEY_RIGHT_BRACE // 93 ] +#define ASCII_5E KEY_6 + SHIFT_MASK // 94 ^ +#define ASCII_5F KEY_MINUS + SHIFT_MASK // 95 _ +#define ASCII_60 KEY_QUOTE + SHIFT_MASK + ALTGR_MASK // 96 ` +#define ASCII_61 KEY_A // 97 a +#define ASCII_62 KEY_B // 98 b +#define ASCII_63 KEY_C // 99 c +#define ASCII_64 KEY_D // 100 d +#define ASCII_65 KEY_E // 101 e +#define ASCII_66 KEY_F // 102 f +#define ASCII_67 KEY_G // 103 g +#define ASCII_68 KEY_H // 104 h +#define ASCII_69 KEY_I // 105 i +#define ASCII_6A KEY_J // 106 j +#define ASCII_6B KEY_K // 107 k +#define ASCII_6C KEY_L // 108 l +#define ASCII_6D KEY_M // 109 m +#define ASCII_6E KEY_N // 110 n +#define ASCII_6F KEY_O // 111 o +#define ASCII_70 KEY_P // 112 p +#define ASCII_71 KEY_Q // 113 q +#define ASCII_72 KEY_R // 114 r +#define ASCII_73 KEY_S // 115 s +#define ASCII_74 KEY_T // 116 t +#define ASCII_75 KEY_U // 117 u +#define ASCII_76 KEY_V // 118 v +#define ASCII_77 KEY_W // 119 w +#define ASCII_78 KEY_X // 120 x +#define ASCII_79 KEY_Y // 121 y +#define ASCII_7A KEY_Z // 122 z +#define ASCII_7B KEY_LEFT_BRACE + SHIFT_MASK // 123 { +#define ASCII_7C KEY_NON_US_100 + SHIFT_MASK // 124 | +#define ASCII_7D KEY_RIGHT_BRACE + SHIFT_MASK // 125 } +#define ASCII_7E KEY_BACKSLASH + SHIFT_MASK // 126 ~ +#define ASCII_7F KEY_BACKSPACE // 127 + +#define ISO_8859_1_A0 KEY_SPACE // 160 Nonbreakng Space +#define ISO_8859_1_A1 0 // 161 ¡ Inverted Exclamation +#define ISO_8859_1_A2 0 // 162 ¢ Cent SIGN +#define ISO_8859_1_A3 KEY_3 + SHIFT_MASK // 163 £ Pound Sign +#define ISO_8859_1_A4 0 // 164 ¤ Currency or Euro Sign +#define ISO_8859_1_A5 0 // 165 ¥ YEN SIGN +#define ISO_8859_1_A6 KEY_TILDE + ALTGR_MASK // 166 ¦ BROKEN BAR +#define ISO_8859_1_A7 0 // 167 § SECTION SIGN +#define ISO_8859_1_A8 0 // 168 ¨ DIAERESIS +#define ISO_8859_1_A9 0 // 169 © COPYRIGHT SIGN +#define ISO_8859_1_AA 0 // 170 ª FEMININE ORDINAL +#define ISO_8859_1_AB 0 // 171 « LEFT DOUBLE ANGLE QUOTE +#define ISO_8859_1_AC KEY_TILDE + SHIFT_MASK // 172 ¬ NOT SIGN +#define ISO_8859_1_AD 0 // 173 SOFT HYPHEN +#define ISO_8859_1_AE 0 // 174 ® REGISTERED SIGN +#define ISO_8859_1_AF 0 // 175 ¯ MACRON +#define ISO_8859_1_B0 0 // 176 ° DEGREE SIGN +#define ISO_8859_1_B1 0 // 177 ± PLUS-MINUS SIGN +#define ISO_8859_1_B2 0 // 178 ² SUPERSCRIPT TWO +#define ISO_8859_1_B3 0 // 179 ³ SUPERSCRIPT THREE +#define ISO_8859_1_B4 0 // 180 ´ ACUTE ACCENT +#define ISO_8859_1_B5 0 // 181 µ MICRO SIGN +#define ISO_8859_1_B6 0 // 182 ¶ PILCROW SIGN +#define ISO_8859_1_B7 0 // 183 · MIDDLE DOT +#define ISO_8859_1_B8 0 // 184 ¸ CEDILLA +#define ISO_8859_1_B9 0 // 185 ¹ SUPERSCRIPT ONE +#define ISO_8859_1_BA 0 // 186 º MASCULINE ORDINAL +#define ISO_8859_1_BB 0 // 187 » RIGHT DOUBLE ANGLE QUOTE +#define ISO_8859_1_BC 0 // 188 ¼ FRACTION ONE QUARTER +#define ISO_8859_1_BD 0 // 189 ½ FRACTION ONE HALF +#define ISO_8859_1_BE 0 // 190 ¾ FRACTION THREE QUARTERS +#define ISO_8859_1_BF 0 // 191 ¿ INVERTED QUESTION MARK +#define ISO_8859_1_C0 GRAVE_ACCENT_BITS + KEY_A // 192 À A GRAVE +#define ISO_8859_1_C1 KEY_A + ALTGR_MASK + SHIFT_MASK // 193 Á A ACUTE +#define ISO_8859_1_C2 0 // 194 Â A CIRCUMFLEX +#define ISO_8859_1_C3 0 // 195 Ã A TILDE +#define ISO_8859_1_C4 0 // 196 Ä A DIAERESIS +#define ISO_8859_1_C5 0 // 197 Å A RING ABOVE +#define ISO_8859_1_C6 0 // 198 Æ AE +#define ISO_8859_1_C7 0 // 199 Ç C CEDILLA +#define ISO_8859_1_C8 GRAVE_ACCENT_BITS + KEY_E // 200 È E GRAVE +#define ISO_8859_1_C9 KEY_E + ALTGR_MASK + SHIFT_MASK // 201 É E ACUTE +#define ISO_8859_1_CA 0 // 202 Ê E CIRCUMFLEX +#define ISO_8859_1_CB 0 // 203 Ë E DIAERESIS +#define ISO_8859_1_CC GRAVE_ACCENT_BITS + KEY_I // 204 Ì I GRAVE +#define ISO_8859_1_CD KEY_I + ALTGR_MASK + SHIFT_MASK // 205 Í I ACUTE +#define ISO_8859_1_CE 0 // 206 Î I CIRCUMFLEX +#define ISO_8859_1_CF 0 // 207 Ï I DIAERESIS +#define ISO_8859_1_D0 0 // 208 Ð ETH +#define ISO_8859_1_D1 0 // 209 Ñ N TILDE +#define ISO_8859_1_D2 GRAVE_ACCENT_BITS + KEY_O // 210 Ò O GRAVE +#define ISO_8859_1_D3 KEY_O + ALTGR_MASK + SHIFT_MASK // 211 Ó O ACUTE +#define ISO_8859_1_D4 0 // 212 Ô O CIRCUMFLEX +#define ISO_8859_1_D5 0 // 213 Õ O TILDE +#define ISO_8859_1_D6 0 // 214 Ö O DIAERESIS +#define ISO_8859_1_D7 0 // 215 × MULTIPLICATION +#define ISO_8859_1_D8 0 // 216 Ø O STROKE +#define ISO_8859_1_D9 GRAVE_ACCENT_BITS + KEY_U // 217 Ù U GRAVE +#define ISO_8859_1_DA KEY_U + ALTGR_MASK + SHIFT_MASK // 218 Ú U ACUTE +#define ISO_8859_1_DB 0 // 219 Û U CIRCUMFLEX +#define ISO_8859_1_DC 0 // 220 Ü U DIAERESIS +#define ISO_8859_1_DD ACUTE_ACCENT_BITS + KEY_Y + SHIFT_MASK // 221 Ý Y ACUTE +#define ISO_8859_1_DE 0 // 222 Þ THORN +#define ISO_8859_1_DF 0 // 223 ß SHARP S +#define ISO_8859_1_E0 GRAVE_ACCENT_BITS + KEY_A // 224 à a GRAVE +#define ISO_8859_1_E1 KEY_A + ALTGR_MASK // 225 á a ACUTE +#define ISO_8859_1_E2 0 // 226 â a CIRCUMFLEX +#define ISO_8859_1_E3 0 // 227 ã a TILDE +#define ISO_8859_1_E4 0 // 228 ä a DIAERESIS +#define ISO_8859_1_E5 0 // 229 å a RING ABOVE +#define ISO_8859_1_E6 0 // 230 æ ae +#define ISO_8859_1_E7 0 // 231 ç c CEDILLA +#define ISO_8859_1_E8 GRAVE_ACCENT_BITS + KEY_E // 232 è e GRAVE +#define ISO_8859_1_E9 KEY_E + ALTGR_MASK // 233 é e ACUTE +#define ISO_8859_1_EA 0 // 234 ê e CIRCUMFLEX +#define ISO_8859_1_EB 0 // 235 ë e DIAERESIS +#define ISO_8859_1_EC GRAVE_ACCENT_BITS + KEY_I // 236 ì i GRAVE +#define ISO_8859_1_ED KEY_I + ALTGR_MASK // 237 í i ACUTE +#define ISO_8859_1_EE 0 // 238 î i CIRCUMFLEX +#define ISO_8859_1_EF 0 // 239 ï i DIAERESIS +#define ISO_8859_1_F0 0 // 240 ð ETH +#define ISO_8859_1_F1 0 // 241 ñ n TILDE +#define ISO_8859_1_F2 GRAVE_ACCENT_BITS + KEY_O // 242 ò o GRAVE +#define ISO_8859_1_F3 KEY_O + ALTGR_MASK // 243 ó o ACUTE +#define ISO_8859_1_F4 0 // 244 ô o CIRCUMFLEX +#define ISO_8859_1_F5 0 // 245 õ o TILDE +#define ISO_8859_1_F6 0 // 246 ö o DIAERESIS +#define ISO_8859_1_F7 0 // 247 ÷ DIVISION +#define ISO_8859_1_F8 0 // 248 ø o STROKE +#define ISO_8859_1_F9 GRAVE_ACCENT_BITS + KEY_U // 249 ù u GRAVE +#define ISO_8859_1_FA KEY_U + ALTGR_MASK // 250 ú u ACUTE +#define ISO_8859_1_FB 0 // 251 û u CIRCUMFLEX +#define ISO_8859_1_FC 0 // 252 ü u DIAERESIS +#define ISO_8859_1_FD ACUTE_ACCENT_BITS + KEY_Y // 253 ý y ACUTE +#define ISO_8859_1_FE 0 // 254 þ THORN +#define ISO_8859_1_FF 0 // 255 ÿ y DIAERESIS +#define UNICODE_20AC KEY_4 + ALTGR_MASK // € Euro Sign +// not yet implemented +#define UNICODE_EXTRA00 0x20AC +#define KEYCODE_EXTRA00 KEY_4 + ALTGR_MASK // 20AC € Euro Sign + +#endif // LAYOUT_IRISH + + + + +#ifdef LAYOUT_ICELANDIC + +#define SHIFT_MASK 0x0040 +#define ALTGR_MASK 0x0080 +#define DEADKEYS_MASK 0x0700 +#define CIRCUMFLEX_BITS 0x0100 +#define ACUTE_ACCENT_BITS 0x0200 +#define GRAVE_ACCENT_BITS 0x0300 +#define DIAERESIS_BITS 0x0400 +#define RING_ABOVE_BITS 0x0500 +#define KEYCODE_TYPE uint16_t +#define KEYCODE_MASK 0x07FF +#define DEADKEY_CIRCUMFLEX KEY_QUOTE + ALTGR_MASK +#define DEADKEY_ACUTE_ACCENT KEY_QUOTE +#define DEADKEY_GRAVE_ACCENT KEY_BACKSLASH + ALTGR_MASK +#define DEADKEY_DIAERESIS KEY_TILDE + SHIFT_MASK +#define DEADKEY_RING_ABOVE KEY_TILDE +#define KEY_NON_US_100 63 + +#define ASCII_20 KEY_SPACE // 32 +#define ASCII_21 KEY_1 + SHIFT_MASK // 33 ! +#define ASCII_22 KEY_2 + SHIFT_MASK // 34 " +#define ASCII_23 KEY_3 + SHIFT_MASK // 35 # +#define ASCII_24 KEY_4 + SHIFT_MASK // 36 $ +#define ASCII_25 KEY_5 + SHIFT_MASK // 37 % +#define ASCII_26 KEY_6 + SHIFT_MASK // 38 & +#define ASCII_27 KEY_QUOTE + SHIFT_MASK // 39 ' +#define ASCII_28 KEY_8 + SHIFT_MASK // 40 ( +#define ASCII_29 KEY_9 + SHIFT_MASK // 41 ) +#define ASCII_2A KEY_BACKSLASH + SHIFT_MASK // 42 * +#define ASCII_2B KEY_BACKSLASH // 43 + +#define ASCII_2C KEY_COMMA // 44 , +#define ASCII_2D KEY_EQUAL // 45 - +#define ASCII_2E KEY_PERIOD // 46 . +#define ASCII_2F KEY_7 + SHIFT_MASK // 47 / +#define ASCII_30 KEY_0 // 48 0 +#define ASCII_31 KEY_1 // 49 1 +#define ASCII_32 KEY_2 // 50 2 +#define ASCII_33 KEY_3 // 51 3 +#define ASCII_34 KEY_4 // 52 4 +#define ASCII_35 KEY_5 // 53 5 +#define ASCII_36 KEY_6 // 54 6 +#define ASCII_37 KEY_7 // 55 7 +#define ASCII_38 KEY_8 // 55 8 +#define ASCII_39 KEY_9 // 57 9 +#define ASCII_3A KEY_PERIOD + SHIFT_MASK // 58 : +#define ASCII_3B KEY_COMMA + SHIFT_MASK // 59 ; +#define ASCII_3C KEY_NON_US_100 // 60 < +#define ASCII_3D KEY_0 + SHIFT_MASK // 61 = +#define ASCII_3E KEY_NON_US_100 + SHIFT_MASK // 62 > +#define ASCII_3F KEY_RIGHT_BRACE + SHIFT_MASK // 63 ? +#define ASCII_40 KEY_Q + ALTGR_MASK // 64 @ +#define ASCII_41 KEY_A + SHIFT_MASK // 65 A +#define ASCII_42 KEY_B + SHIFT_MASK // 66 B +#define ASCII_43 KEY_C + SHIFT_MASK // 67 C +#define ASCII_44 KEY_D + SHIFT_MASK // 68 D +#define ASCII_45 KEY_E + SHIFT_MASK // 69 E +#define ASCII_46 KEY_F + SHIFT_MASK // 70 F +#define ASCII_47 KEY_G + SHIFT_MASK // 71 G +#define ASCII_48 KEY_H + SHIFT_MASK // 72 H +#define ASCII_49 KEY_I + SHIFT_MASK // 73 I +#define ASCII_4A KEY_J + SHIFT_MASK // 74 J +#define ASCII_4B KEY_K + SHIFT_MASK // 75 K +#define ASCII_4C KEY_L + SHIFT_MASK // 76 L +#define ASCII_4D KEY_M + SHIFT_MASK // 77 M +#define ASCII_4E KEY_N + SHIFT_MASK // 78 N +#define ASCII_4F KEY_O + SHIFT_MASK // 79 O +#define ASCII_50 KEY_P + SHIFT_MASK // 80 P +#define ASCII_51 KEY_Q + SHIFT_MASK // 81 Q +#define ASCII_52 KEY_R + SHIFT_MASK // 82 R +#define ASCII_53 KEY_S + SHIFT_MASK // 83 S +#define ASCII_54 KEY_T + SHIFT_MASK // 84 T +#define ASCII_55 KEY_U + SHIFT_MASK // 85 U +#define ASCII_56 KEY_V + SHIFT_MASK // 86 V +#define ASCII_57 KEY_W + SHIFT_MASK // 87 W +#define ASCII_58 KEY_X + SHIFT_MASK // 88 X +#define ASCII_59 KEY_Y + SHIFT_MASK // 89 Y +#define ASCII_5A KEY_Z + SHIFT_MASK // 90 Z +#define ASCII_5B KEY_8 + ALTGR_MASK // 91 [ +#define ASCII_5C KEY_MINUS + ALTGR_MASK // 92 +#define ASCII_5D KEY_9 + ALTGR_MASK // 93 ] +#define ASCII_5E CIRCUMFLEX_BITS + KEY_SPACE // 94 ^ +#define ASCII_5F KEY_EQUAL + SHIFT_MASK // 95 _ +#define ASCII_60 GRAVE_ACCENT_BITS + KEY_SPACE // 96 ` +#define ASCII_61 KEY_A // 97 a +#define ASCII_62 KEY_B // 98 b +#define ASCII_63 KEY_C // 99 c +#define ASCII_64 KEY_D // 100 d +#define ASCII_65 KEY_E // 101 e +#define ASCII_66 KEY_F // 102 f +#define ASCII_67 KEY_G // 103 g +#define ASCII_68 KEY_H // 104 h +#define ASCII_69 KEY_I // 105 i +#define ASCII_6A KEY_J // 106 j +#define ASCII_6B KEY_K // 107 k +#define ASCII_6C KEY_L // 108 l +#define ASCII_6D KEY_M // 109 m +#define ASCII_6E KEY_N // 110 n +#define ASCII_6F KEY_O // 111 o +#define ASCII_70 KEY_P // 112 p +#define ASCII_71 KEY_Q // 113 q +#define ASCII_72 KEY_R // 114 r +#define ASCII_73 KEY_S // 115 s +#define ASCII_74 KEY_T // 116 t +#define ASCII_75 KEY_U // 117 u +#define ASCII_76 KEY_V // 118 v +#define ASCII_77 KEY_W // 119 w +#define ASCII_78 KEY_X // 120 x +#define ASCII_79 KEY_Y // 121 y +#define ASCII_7A KEY_Z // 122 z +#define ASCII_7B KEY_7 + ALTGR_MASK // 123 { +#define ASCII_7C KEY_NON_US_100 + ALTGR_MASK // 124 | +#define ASCII_7D KEY_0 + ALTGR_MASK // 125 } +#define ASCII_7E KEY_RIGHT_BRACE + ALTGR_MASK // 126 ~ +#define ASCII_7F KEY_BACKSPACE // 127 + +#define ISO_8859_1_A0 KEY_SPACE // 160 Nonbreakng Space +#define ISO_8859_1_A1 0 // 161 ¡ Inverted Exclamation +#define ISO_8859_1_A2 0 // 162 ¢ Cent SIGN +#define ISO_8859_1_A3 0 // 163 £ Pound Sign +#define ISO_8859_1_A4 0 // 164 ¤ Currency or Euro Sign +#define ISO_8859_1_A5 0 // 165 ¥ YEN SIGN +#define ISO_8859_1_A6 0 // 166 ¦ BROKEN BAR ?? +#define ISO_8859_1_A7 0 // 167 § SECTION SIGN +#define ISO_8859_1_A8 DIAERESIS_BITS + KEY_SPACE // 168 ¨ DIAERESIS +#define ISO_8859_1_A9 0 // 169 © COPYRIGHT SIGN +#define ISO_8859_1_AA 0 // 170 ª FEMININE ORDINAL +#define ISO_8859_1_AB 0 // 171 « LEFT DOUBLE ANGLE QUOTE +#define ISO_8859_1_AC 0 // 172 ¬ NOT SIGN ?? +#define ISO_8859_1_AD 0 // 173 SOFT HYPHEN +#define ISO_8859_1_AE 0 // 174 ® REGISTERED SIGN +#define ISO_8859_1_AF 0 // 175 ¯ MACRON +#define ISO_8859_1_B0 KEY_TILDE + ALTGR_MASK // 176 ° DEGREE SIGN +#define ISO_8859_1_B1 0 // 177 ± PLUS-MINUS SIGN +#define ISO_8859_1_B2 0 // 178 ² SUPERSCRIPT TWO +#define ISO_8859_1_B3 0 // 179 ³ SUPERSCRIPT THREE +#define ISO_8859_1_B4 ACUTE_ACCENT_BITS + KEY_SPACE // 180 ´ ACUTE ACCENT +#define ISO_8859_1_B5 KEY_M + ALTGR_MASK // 181 µ MICRO SIGN +#define ISO_8859_1_B6 0 // 182 ¶ PILCROW SIGN +#define ISO_8859_1_B7 0 // 183 · MIDDLE DOT +#define ISO_8859_1_B8 0 // 184 ¸ CEDILLA +#define ISO_8859_1_B9 0 // 185 ¹ SUPERSCRIPT ONE +#define ISO_8859_1_BA 0 // 186 º MASCULINE ORDINAL +#define ISO_8859_1_BB 0 // 187 » RIGHT DOUBLE ANGLE QUOTE +#define ISO_8859_1_BC 0 // 188 ¼ FRACTION ONE QUARTER +#define ISO_8859_1_BD 0 // 189 ½ FRACTION ONE HALF +#define ISO_8859_1_BE 0 // 190 ¾ FRACTION THREE QUARTERS +#define ISO_8859_1_BF 0 // 191 ¿ INVERTED QUESTION MARK +#define ISO_8859_1_C0 GRAVE_ACCENT_BITS + KEY_A + SHIFT_MASK // 192 À A GRAVE +#define ISO_8859_1_C1 ACUTE_ACCENT_BITS + KEY_A + ALTGR_MASK // 193 Á A ACUTE +#define ISO_8859_1_C2 CIRCUMFLEX_BITS + KEY_A + SHIFT_MASK // 194 Â A CIRCUMFLEX +#define ISO_8859_1_C3 0 // 195 Ã A TILDE +#define ISO_8859_1_C4 DIAERESIS_BITS + KEY_A + SHIFT_MASK // 196 Ä A DIAERESIS +#define ISO_8859_1_C5 RING_ABOVE_BITS + KEY_A + SHIFT_MASK // 197 Å A RING ABOVE +#define ISO_8859_1_C6 KEY_SEMICOLON + SHIFT_MASK // 198 Æ AE +#define ISO_8859_1_C7 0 // 199 Ç C CEDILLA +#define ISO_8859_1_C8 GRAVE_ACCENT_BITS + KEY_E + SHIFT_MASK // 200 È E GRAVE +#define ISO_8859_1_C9 ACUTE_ACCENT_BITS + KEY_E + SHIFT_MASK // 201 É E ACUTE +#define ISO_8859_1_CA CIRCUMFLEX_BITS + KEY_E + SHIFT_MASK // 202 Ê E CIRCUMFLEX +#define ISO_8859_1_CB DIAERESIS_BITS + KEY_E + SHIFT_MASK // 203 Ë E DIAERESIS +#define ISO_8859_1_CC GRAVE_ACCENT_BITS + KEY_I + SHIFT_MASK // 204 Ì I GRAVE +#define ISO_8859_1_CD ACUTE_ACCENT_BITS + KEY_I + SHIFT_MASK // 205 Í I ACUTE +#define ISO_8859_1_CE CIRCUMFLEX_BITS + KEY_I + SHIFT_MASK // 206 Î I CIRCUMFLEX +#define ISO_8859_1_CF DIAERESIS_BITS + KEY_I + SHIFT_MASK // 207 Ï I DIAERESIS +#define ISO_8859_1_D0 KEY_LEFT_BRACE + SHIFT_MASK // 208 Ð ETH +#define ISO_8859_1_D1 0 // 209 Ñ N TILDE +#define ISO_8859_1_D2 GRAVE_ACCENT_BITS + KEY_O + SHIFT_MASK // 210 Ò O GRAVE +#define ISO_8859_1_D3 ACUTE_ACCENT_BITS + KEY_O + SHIFT_MASK // 211 Ó O ACUTE +#define ISO_8859_1_D4 CIRCUMFLEX_BITS + KEY_O + SHIFT_MASK // 212 Ô O CIRCUMFLEX +#define ISO_8859_1_D5 0 // 213 Õ O TILDE +#define ISO_8859_1_D6 DIAERESIS_BITS + KEY_O + SHIFT_MASK // 214 Ö O DIAERESIS +#define ISO_8859_1_D7 0 // 215 × MULTIPLICATION +#define ISO_8859_1_D8 0 // 216 Ø O STROKE +#define ISO_8859_1_D9 GRAVE_ACCENT_BITS + KEY_U + SHIFT_MASK // 217 Ù U GRAVE +#define ISO_8859_1_DA ACUTE_ACCENT_BITS + KEY_U + SHIFT_MASK // 218 Ú U ACUTE +#define ISO_8859_1_DB CIRCUMFLEX_BITS + KEY_U + SHIFT_MASK // 219 Û U CIRCUMFLEX +#define ISO_8859_1_DC DIAERESIS_BITS + KEY_U + SHIFT_MASK // 220 Ü U DIAERESIS +#define ISO_8859_1_DD ACUTE_ACCENT_BITS + KEY_Y + SHIFT_MASK // 221 Ý Y ACUTE +#define ISO_8859_1_DE KEY_SLASH + SHIFT_MASK // 222 Þ THORN +#define ISO_8859_1_DF 0 // 223 ß SHARP S +#define ISO_8859_1_E0 GRAVE_ACCENT_BITS + KEY_A // 224 à a GRAVE +#define ISO_8859_1_E1 ACUTE_ACCENT_BITS + KEY_A // 225 á a ACUTE +#define ISO_8859_1_E2 CIRCUMFLEX_BITS + KEY_A // 226 â a CIRCUMFLEX +#define ISO_8859_1_E3 0 // 227 ã a TILDE +#define ISO_8859_1_E4 DIAERESIS_BITS + KEY_A // 228 ä a DIAERESIS +#define ISO_8859_1_E5 RING_ABOVE_BITS + KEY_A // 229 å a RING ABOVE +#define ISO_8859_1_E6 KEY_SEMICOLON // 230 æ ae +#define ISO_8859_1_E7 0 // 231 ç c CEDILLA +#define ISO_8859_1_E8 GRAVE_ACCENT_BITS + KEY_E // 232 è e GRAVE +#define ISO_8859_1_E9 ACUTE_ACCENT_BITS + KEY_E // 233 é e ACUTE +#define ISO_8859_1_EA CIRCUMFLEX_BITS + KEY_E // 234 ê e CIRCUMFLEX +#define ISO_8859_1_EB DIAERESIS_BITS + KEY_E // 235 ë e DIAERESIS +#define ISO_8859_1_EC GRAVE_ACCENT_BITS + KEY_I // 236 ì i GRAVE +#define ISO_8859_1_ED ACUTE_ACCENT_BITS + KEY_I // 237 í i ACUTE +#define ISO_8859_1_EE CIRCUMFLEX_BITS + KEY_I // 238 î i CIRCUMFLEX +#define ISO_8859_1_EF DIAERESIS_BITS + KEY_I // 239 ï i DIAERESIS +#define ISO_8859_1_F0 KEY_LEFT_BRACE // 240 ð ETH +#define ISO_8859_1_F1 0 // 241 ñ n TILDE +#define ISO_8859_1_F2 GRAVE_ACCENT_BITS + KEY_O // 242 ò o GRAVE +#define ISO_8859_1_F3 ACUTE_ACCENT_BITS + KEY_O // 243 ó o ACUTE +#define ISO_8859_1_F4 CIRCUMFLEX_BITS + KEY_O // 244 ô o CIRCUMFLEX +#define ISO_8859_1_F5 0 // 245 õ o TILDE +#define ISO_8859_1_F6 DIAERESIS_BITS + KEY_O // 246 ö o DIAERESIS +#define ISO_8859_1_F7 0 // 247 ÷ DIVISION +#define ISO_8859_1_F8 0 // 248 ø o STROKE +#define ISO_8859_1_F9 GRAVE_ACCENT_BITS + KEY_U // 249 ù u GRAVE +#define ISO_8859_1_FA ACUTE_ACCENT_BITS + KEY_U // 250 ú u ACUTE +#define ISO_8859_1_FB CIRCUMFLEX_BITS + KEY_U // 251 û u CIRCUMFLEX +#define ISO_8859_1_FC DIAERESIS_BITS + KEY_U // 252 ü u DIAERESIS +#define ISO_8859_1_FD ACUTE_ACCENT_BITS + KEY_Y // 253 ý y ACUTE +#define ISO_8859_1_FE KEY_SLASH // 254 þ THORN +#define ISO_8859_1_FF DIAERESIS_BITS + KEY_Y // 255 ÿ y DIAERESIS +#define UNICODE_20AC KEY_5 + ALTGR_MASK // € Euro Sign +// not yet implemented +#define UNICODE_EXTRA00 0x20AC +#define KEYCODE_EXTRA00 KEY_5 + ALTGR_MASK // 20AC € Euro Sign + +#endif // LAYOUT_ICELANDIC + + + +#ifdef LAYOUT_TURKISH +// http://forum.pjrc.com/threads/18781-Turkish-Language-Support + +#define SHIFT_MASK 0x0040 +#define ALTGR_MASK 0x0080 +#define DEADKEYS_MASK 0x0700 +#define CIRCUMFLEX_BITS 0x0100 +#define ACUTE_ACCENT_BITS 0x0200 +#define GRAVE_ACCENT_BITS 0x0300 +#define TILDE_BITS 0x0400 +#define DIAERESIS_BITS 0x0500 +#define KEYCODE_TYPE uint16_t +#define KEYCODE_MASK 0x07FF +#define DEADKEY_CIRCUMFLEX KEY_3 + SHIFT_MASK +#define DEADKEY_ACUTE_ACCENT KEY_SEMICOLON + ALTGR_MASK +#define DEADKEY_GRAVE_ACCENT KEY_BACKSLASH + ALTGR_MASK +#define DEADKEY_TILDE KEY_RIGHT_BRACE + ALTGR_MASK +#define DEADKEY_DIAERESIS KEY_LEFT_BRACE + ALTGR_MASK + +#define ASCII_20 KEY_SPACE // 32 +#define ASCII_21 KEY_1 + SHIFT_MASK // 33 ! +#define ASCII_22 KEY_TILDE // 34 " +#define ASCII_23 KEY_3 + ALTGR_MASK // 35 # +#define ASCII_24 KEY_4 + ALTGR_MASK // 36 $ +#define ASCII_25 KEY_5 + SHIFT_MASK // 37 % +#define ASCII_26 KEY_6 + SHIFT_MASK // 38 & +#define ASCII_27 KEY_2 + SHIFT_MASK // 39 ' +#define ASCII_28 KEY_8 + SHIFT_MASK // 40 ( +#define ASCII_29 KEY_9 + SHIFT_MASK // 41 ) +#define ASCII_2A KEY_MINUS // 42 * +#define ASCII_2B KEY_4 + SHIFT_MASK // 43 + +#define ASCII_2C KEY_BACKSLASH // 44 , +#define ASCII_2D KEY_EQUAL // 45 - +#define ASCII_2E KEY_SLASH // 46 . +#define ASCII_2F KEY_7 + SHIFT_MASK // 47 / +#define ASCII_30 KEY_0 // 48 0 +#define ASCII_31 KEY_1 // 49 1 +#define ASCII_32 KEY_2 // 50 2 +#define ASCII_33 KEY_3 // 51 3 +#define ASCII_34 KEY_4 // 52 4 +#define ASCII_35 KEY_5 // 53 5 +#define ASCII_36 KEY_6 // 54 6 +#define ASCII_37 KEY_7 // 55 7 +#define ASCII_38 KEY_8 // 55 8 +#define ASCII_39 KEY_9 // 57 9 +#define ASCII_3A KEY_SLASH + SHIFT_MASK // 58 : +#define ASCII_3B KEY_BACKSLASH + SHIFT_MASK // 59 ; +#define ASCII_3C KEY_TILDE + ALTGR_MASK // 60 < +#define ASCII_3D KEY_0 + SHIFT_MASK // 61 = +#define ASCII_3E KEY_1 + ALTGR_MASK // 62 > +#define ASCII_3F KEY_MINUS + SHIFT_MASK // 63 ? +#define ASCII_40 KEY_Q + ALTGR_MASK // 64 @ +#define ASCII_41 KEY_A + SHIFT_MASK // 65 A +#define ASCII_42 KEY_B + SHIFT_MASK // 66 B +#define ASCII_43 KEY_C + SHIFT_MASK // 67 C +#define ASCII_44 KEY_D + SHIFT_MASK // 68 D +#define ASCII_45 KEY_E + SHIFT_MASK // 69 E +#define ASCII_46 KEY_F + SHIFT_MASK // 70 F +#define ASCII_47 KEY_G + SHIFT_MASK // 71 G +#define ASCII_48 KEY_H + SHIFT_MASK // 72 H +#define ASCII_49 KEY_I + SHIFT_MASK // 73 I +#define ASCII_4A KEY_J + SHIFT_MASK // 74 J +#define ASCII_4B KEY_K + SHIFT_MASK // 75 K +#define ASCII_4C KEY_L + SHIFT_MASK // 76 L +#define ASCII_4D KEY_M + SHIFT_MASK // 77 M +#define ASCII_4E KEY_N + SHIFT_MASK // 78 N +#define ASCII_4F KEY_O + SHIFT_MASK // 79 O +#define ASCII_50 KEY_P + SHIFT_MASK // 80 P +#define ASCII_51 KEY_Q + SHIFT_MASK // 81 Q +#define ASCII_52 KEY_R + SHIFT_MASK // 82 R +#define ASCII_53 KEY_S + SHIFT_MASK // 83 S +#define ASCII_54 KEY_T + SHIFT_MASK // 84 T +#define ASCII_55 KEY_U + SHIFT_MASK // 85 U +#define ASCII_56 KEY_V + SHIFT_MASK // 86 V +#define ASCII_57 KEY_W + SHIFT_MASK // 87 W +#define ASCII_58 KEY_X + SHIFT_MASK // 88 X +#define ASCII_59 KEY_Y + SHIFT_MASK // 89 Y +#define ASCII_5A KEY_Z + SHIFT_MASK // 90 Z +#define ASCII_5B KEY_8 + ALTGR_MASK // 91 [ +#define ASCII_5C KEY_MINUS + ALTGR_MASK // 92 +#define ASCII_5D KEY_9 + ALTGR_MASK // 93 ] +#define ASCII_5E CIRCUMFLEX_BITS + KEY_SPACE // 94 ^ +#define ASCII_5F KEY_EQUAL + SHIFT_MASK // 95 _ +#define ASCII_60 GRAVE_ACCENT_BITS + KEY_SPACE // 96 ` +#define ASCII_61 KEY_A // 97 a +#define ASCII_62 KEY_B // 98 b +#define ASCII_63 KEY_C // 99 c +#define ASCII_64 KEY_D // 100 d +#define ASCII_65 KEY_E // 101 e +#define ASCII_66 KEY_F // 102 f +#define ASCII_67 KEY_G // 103 g +#define ASCII_68 KEY_H // 104 h +#define ASCII_69 KEY_QUOTE // 105 i +#define ASCII_6A KEY_J // 106 j +#define ASCII_6B KEY_K // 107 k +#define ASCII_6C KEY_L // 108 l +#define ASCII_6D KEY_M // 109 m +#define ASCII_6E KEY_N // 110 n +#define ASCII_6F KEY_O // 111 o +#define ASCII_70 KEY_P // 112 p +#define ASCII_71 KEY_Q // 113 q +#define ASCII_72 KEY_R // 114 r +#define ASCII_73 KEY_S // 115 s +#define ASCII_74 KEY_T // 116 t +#define ASCII_75 KEY_U // 117 u +#define ASCII_76 KEY_V // 118 v +#define ASCII_77 KEY_W // 119 w +#define ASCII_78 KEY_X // 120 x +#define ASCII_79 KEY_Y // 121 y +#define ASCII_7A KEY_Z // 122 z +#define ASCII_7B KEY_7 + ALTGR_MASK // 123 { +#define ASCII_7C KEY_EQUAL + ALTGR_MASK // 124 | +#define ASCII_7D KEY_0 + ALTGR_MASK // 125 } +#define ASCII_7E TILDE_BITS + KEY_SPACE // 126 ~ +#define ASCII_7F KEY_BACKSPACE // 127 + +#define ISO_8859_1_A0 KEY_SPACE // 160 Nonbreakng Space +#define ISO_8859_1_A1 0 // 161 ¡ Inverted Exclamation +#define ISO_8859_1_A2 0 // 162 ¢ Cent SIGN +#define ISO_8859_1_A3 KEY_2 + ALTGR_MASK // 163 £ Pound Sign +#define ISO_8859_1_A4 0 // 164 ¤ Currency or Euro Sign +#define ISO_8859_1_A5 0 // 165 ¥ YEN SIGN +#define ISO_8859_1_A6 0 // 166 ¦ BROKEN BAR ?? +#define ISO_8859_1_A7 0 // 167 § SECTION SIGN +#define ISO_8859_1_A8 DIAERESIS_BITS + KEY_SPACE // 168 ¨ DIAERESIS +#define ISO_8859_1_A9 0 // 169 © COPYRIGHT SIGN +#define ISO_8859_1_AA 0 // 170 ª FEMININE ORDINAL +#define ISO_8859_1_AB 0 // 171 « LEFT DOUBLE ANGLE QUOTE +#define ISO_8859_1_AC 0 // 172 ¬ NOT SIGN ?? +#define ISO_8859_1_AD 0 // 173 SOFT HYPHEN +#define ISO_8859_1_AE 0 // 174 ® REGISTERED SIGN +#define ISO_8859_1_AF 0 // 175 ¯ MACRON +#define ISO_8859_1_B0 0 // 176 ° DEGREE SIGN +#define ISO_8859_1_B1 0 // 177 ± PLUS-MINUS SIGN +#define ISO_8859_1_B2 0 // 178 ² SUPERSCRIPT TWO +#define ISO_8859_1_B3 0 // 179 ³ SUPERSCRIPT THREE +#define ISO_8859_1_B4 ACUTE_ACCENT_BITS + KEY_SPACE // 180 ´ ACUTE ACCENT +#define ISO_8859_1_B5 0 // 181 µ MICRO SIGN +#define ISO_8859_1_B6 0 // 182 ¶ PILCROW SIGN +#define ISO_8859_1_B7 0 // 183 · MIDDLE DOT +#define ISO_8859_1_B8 0 // 184 ¸ CEDILLA +#define ISO_8859_1_B9 0 // 185 ¹ SUPERSCRIPT ONE +#define ISO_8859_1_BA 0 // 186 º MASCULINE ORDINAL +#define ISO_8859_1_BB 0 // 187 » RIGHT DOUBLE ANGLE QUOTE +#define ISO_8859_1_BC 0 // 188 ¼ FRACTION ONE QUARTER +#define ISO_8859_1_BD KEY_5 + ALTGR_MASK // 189 ½ FRACTION ONE HALF +#define ISO_8859_1_BE 0 // 190 ¾ FRACTION THREE QUARTERS +#define ISO_8859_1_BF 0 // 191 ¿ INVERTED QUESTION MARK +#define ISO_8859_1_C0 GRAVE_ACCENT_BITS + KEY_A + SHIFT_MASK // 192 À A GRAVE +#define ISO_8859_1_C1 ACUTE_ACCENT_BITS + KEY_A + SHIFT_MASK // 193 Á A ACUTE +#define ISO_8859_1_C2 CIRCUMFLEX_BITS + KEY_A + SHIFT_MASK // 194 Â A CIRCUMFLEX +#define ISO_8859_1_C3 TILDE_BITS + KEY_A + SHIFT_MASK // 195 Ã A TILDE +#define ISO_8859_1_C4 DIAERESIS_BITS + KEY_A + SHIFT_MASK // 196 Ä A DIAERESIS +#define ISO_8859_1_C5 0 // 197 Å A RING ABOVE +#define ISO_8859_1_C6 KEY_A + ALTGR_MASK // 198 Æ AE +#define ISO_8859_1_C7 KEY_PERIOD + SHIFT_MASK // 199 Ç C CEDILLA +#define ISO_8859_1_C8 GRAVE_ACCENT_BITS + KEY_E + SHIFT_MASK // 200 È E GRAVE +#define ISO_8859_1_C9 ACUTE_ACCENT_BITS + KEY_E + SHIFT_MASK // 201 É E ACUTE +#define ISO_8859_1_CA CIRCUMFLEX_BITS + KEY_E + SHIFT_MASK // 202 Ê E CIRCUMFLEX +#define ISO_8859_1_CB DIAERESIS_BITS + KEY_E + SHIFT_MASK // 203 Ë E DIAERESIS +#define ISO_8859_1_CC GRAVE_ACCENT_BITS + KEY_I + SHIFT_MASK // 204 Ì I GRAVE +#define ISO_8859_1_CD ACUTE_ACCENT_BITS + KEY_I + SHIFT_MASK // 205 Í I ACUTE +#define ISO_8859_1_CE CIRCUMFLEX_BITS + KEY_I + SHIFT_MASK // 206 Î I CIRCUMFLEX +#define ISO_8859_1_CF DIAERESIS_BITS + KEY_I + SHIFT_MASK // 207 Ï I DIAERESIS +#define ISO_8859_1_D0 0 // 208 Ð ETH +#define ISO_8859_1_D1 TILDE_BITS + KEY_N + SHIFT_MASK // 209 Ñ N TILDE +#define ISO_8859_1_D2 GRAVE_ACCENT_BITS + KEY_O + SHIFT_MASK // 210 Ò O GRAVE +#define ISO_8859_1_D3 ACUTE_ACCENT_BITS + KEY_O + SHIFT_MASK // 211 Ó O ACUTE +#define ISO_8859_1_D4 CIRCUMFLEX_BITS + KEY_O + SHIFT_MASK // 212 Ô O CIRCUMFLEX +#define ISO_8859_1_D5 TILDE_BITS + KEY_O + SHIFT_MASK // 213 Õ O TILDE +#define ISO_8859_1_D6 KEY_COMMA + SHIFT_MASK // 214 Ö O DIAERESIS +#define ISO_8859_1_D7 0 // 215 × MULTIPLICATION +#define ISO_8859_1_D8 0 // 216 Ø O STROKE +#define ISO_8859_1_D9 GRAVE_ACCENT_BITS + KEY_U + SHIFT_MASK // 217 Ù U GRAVE +#define ISO_8859_1_DA ACUTE_ACCENT_BITS + KEY_U + SHIFT_MASK // 218 Ú U ACUTE +#define ISO_8859_1_DB CIRCUMFLEX_BITS + KEY_U + SHIFT_MASK // 219 Û U CIRCUMFLEX +#define ISO_8859_1_DC KEY_RIGHT_BRACE + SHIFT_MASK // 220 Ü U DIAERESIS +#define ISO_8859_1_DD ACUTE_ACCENT_BITS + KEY_Y + SHIFT_MASK // 221 Ý Y ACUTE +#define ISO_8859_1_DE 0 // 222 Þ THORN +#define ISO_8859_1_DF KEY_S + ALTGR_MASK // 223 ß SHARP S +#define ISO_8859_1_E0 GRAVE_ACCENT_BITS + KEY_A // 224 à a GRAVE +#define ISO_8859_1_E1 ACUTE_ACCENT_BITS + KEY_A // 225 á a ACUTE +#define ISO_8859_1_E2 CIRCUMFLEX_BITS + KEY_A // 226 â a CIRCUMFLEX +#define ISO_8859_1_E3 TILDE_BITS + KEY_A // 227 ã a TILDE +#define ISO_8859_1_E4 DIAERESIS_BITS + KEY_A // 228 ä a DIAERESIS +#define ISO_8859_1_E5 0 // 229 å a RING ABOVE +#define ISO_8859_1_E6 0 // 230 æ ae +#define ISO_8859_1_E7 KEY_PERIOD // 231 ç c CEDILLA +#define ISO_8859_1_E8 GRAVE_ACCENT_BITS + KEY_E // 232 è e GRAVE +#define ISO_8859_1_E9 KEY_TILDE + SHIFT_MASK // 233 é e ACUTE +#define ISO_8859_1_EA CIRCUMFLEX_BITS + KEY_E // 234 ê e CIRCUMFLEX +#define ISO_8859_1_EB DIAERESIS_BITS + KEY_E // 235 ë e DIAERESIS +#define ISO_8859_1_EC GRAVE_ACCENT_BITS + KEY_I // 236 ì i GRAVE +#define ISO_8859_1_ED ACUTE_ACCENT_BITS + KEY_I // 237 í i ACUTE +#define ISO_8859_1_EE CIRCUMFLEX_BITS + KEY_I // 238 î i CIRCUMFLEX +#define ISO_8859_1_EF DIAERESIS_BITS + KEY_I // 239 ï i DIAERESIS +#define ISO_8859_1_F0 0 // 240 ð ETH +#define ISO_8859_1_F1 TILDE_BITS + KEY_N // 241 ñ n TILDE +#define ISO_8859_1_F2 GRAVE_ACCENT_BITS + KEY_O // 242 ò o GRAVE +#define ISO_8859_1_F3 ACUTE_ACCENT_BITS + KEY_O // 243 ó o ACUTE +#define ISO_8859_1_F4 CIRCUMFLEX_BITS + KEY_O // 244 ô o CIRCUMFLEX +#define ISO_8859_1_F5 TILDE_BITS + KEY_O // 245 õ o TILDE +#define ISO_8859_1_F6 KEY_COMMA // 246 ö o DIAERESIS +#define ISO_8859_1_F7 0 // 247 ÷ DIVISION +#define ISO_8859_1_F8 0 // 248 ø o STROKE +#define ISO_8859_1_F9 GRAVE_ACCENT_BITS + KEY_U // 249 ù u GRAVE +#define ISO_8859_1_FA ACUTE_ACCENT_BITS + KEY_U // 250 ú u ACUTE +#define ISO_8859_1_FB CIRCUMFLEX_BITS + KEY_U // 251 û u CIRCUMFLEX +#define ISO_8859_1_FC KEY_RIGHT_BRACE // 252 ü u DIAERESIS +#define ISO_8859_1_FD ACUTE_ACCENT_BITS + KEY_Y // 253 ý y ACUTE +#define ISO_8859_1_FE 0 // 254 þ THORN +#define ISO_8859_1_FF DIAERESIS_BITS + KEY_Y // 255 ÿ y DIAERESIS +#define UNICODE_20AC KEY_E + ALTGR_MASK // € Euro Sign + +// not yet implemented +#define UNICODE_EXTRA00 0x20AC +#define KEYCODE_EXTRA00 KEY_E + ALTGR_MASK // 20AC € Euro Sign +#define UNICODE_EXTRA01 0x011E +#define KEYCODE_EXTRA01 KEY_LEFT_BRACE + SHIFT_MASK // 011E Ğ Latin capital letter G with breve +#define UNICODE_EXTRA02 0x011F +#define KEYCODE_EXTRA02 KEY_LEFT_BRACE // 011F ğ Latin small letter g with breve +#define UNICODE_EXTRA03 0x0130 +#define KEYCODE_EXTRA03 KEY_QUOTE + SHIFT_MASK // 0130 İ Latin captial letter I with dot above +#define UNICODE_EXTRA04 0x0131 +#define KEYCODE_EXTRA04 KEY_I // 0131 ı Latin small letter dotless i +#define UNICODE_EXTRA05 0x015E +#define KEYCODE_EXTRA05 KEY_SEMICOLON + SHIFT_MASK // 015E Ş Latin capital letter S with cedilla +#define UNICODE_EXTRA06 0x0151 +#define KEYCODE_EXTRA06 KEY_SEMICOLON // 0151 ş Latin small letter s with cedilla + +#endif // LAYOUT_TURKISH + + + +#ifdef LAYOUT_CZECH +// http://forum.pjrc.com/threads/24495-Czech-keyboard + +#define SHIFT_MASK 0x0040 +#define ALTGR_MASK 0x0080 +#define DEADKEYS_MASK 0x0F00 +#define ACUTE_ACCENT_BITS 0x0100 // TODO: the Czech might not support some +#define DEGREE_SIGN_BITS 0x0200 // of these deadkeys, perhaps not any??? +#define CARON_BITS 0x0300 +//#define CIRCUMFLEX_BITS 0x0400 +#define BREVE_BITS 0x0500 +#define OGONEK_BITS 0x0600 +//#define GRAVE_ACCENT_BITS 0x0700 +#define DOT_ABOVE_BITS 0x0800 +#define DOUBLE_ACUTE_BITS 0x0900 +//#define DIAERESIS_BITS 0x0A00 +#define CEDILLA_BITS 0x0B00 +#define KEYCODE_TYPE uint16_t +#define KEYCODE_MASK 0x0FFF +#define DEADKEY_ACUTE_ACCENT KEY_EQUAL // TODO: is it KEY_9 + ALTGR_MASK +#define DEADKEY_DEGREE_SIGN KEY_TILDE + SHIFT_MASK // TODO: is it KEY_5 + ALTGR_MASK +#define DEADKEY_CARON KEY_EQUAL + SHIFT_MASK // TODO: is it KEY_2 + ALTGR_MASK +//#define DEADKEY_CIRCUMFLEX KEY_3 + ALTGR_MASK +#define DEADKEY_BREVE KEY_4 + ALTGR_MASK +#define DEADKEY_OGONEK KEY_6 + ALTGR_MASK +//#define DEADKEY_GRAVE_ACCENT KEY_7 + ALTGR_MASK +#define DEADKEY_DOT_ABOVE KEY_8 + ALTGR_MASK +#define DEADKEY_DOUBLE_ACUTE KEY_0 + ALTGR_MASK +#define DEADKEY_DIAERESIS KEY_MINUS + ALTGR_MASK +#define DEADKEY_CEDILLA KEY_EQUAL + ALTGR_MASK +#define KEY_NON_US_100 63 +#define ASCII_20 KEY_SPACE // 32 +#define ASCII_21 KEY_QUOTE + SHIFT_MASK // 33 ! +#define ASCII_22 KEY_SEMICOLON + SHIFT_MASK // 34 " +#define ASCII_23 KEY_X + ALTGR_MASK // 35 # +#define ASCII_24 KEY_SEMICOLON + ALTGR_MASK // 36 $ +#define ASCII_25 KEY_MINUS + SHIFT_MASK // 37 % +#define ASCII_26 KEY_C + ALTGR_MASK // 38 & +#define ASCII_27 KEY_BACKSLASH + SHIFT_MASK // 39 ' +#define ASCII_28 KEY_RIGHT_BRACE + SHIFT_MASK // 40 ( +#define ASCII_29 KEY_RIGHT_BRACE // 41 ) +#define ASCII_2A KEY_SLASH + ALTGR_MASK // 42 * +#define ASCII_2B KEY_1 // 43 + +#define ASCII_2C KEY_COMMA // 44 , +#define ASCII_2D KEY_SLASH // 45 - +#define ASCII_2E KEY_PERIOD // 46 . +#define ASCII_2F KEY_LEFT_BRACE + SHIFT_MASK // 47 / +#define ASCII_30 KEY_0 + SHIFT_MASK // 48 0 +#define ASCII_31 KEY_1 + SHIFT_MASK // 49 1 +#define ASCII_32 KEY_2 + SHIFT_MASK // 50 2 +#define ASCII_33 KEY_3 + SHIFT_MASK // 51 3 +#define ASCII_34 KEY_4 + SHIFT_MASK // 52 4 +#define ASCII_35 KEY_5 + SHIFT_MASK // 53 5 +#define ASCII_36 KEY_6 + SHIFT_MASK // 54 6 +#define ASCII_37 KEY_7 + SHIFT_MASK // 55 7 +#define ASCII_38 KEY_8 + SHIFT_MASK // 55 8 +#define ASCII_39 KEY_9 + SHIFT_MASK // 57 9 +#define ASCII_3A KEY_PERIOD + SHIFT_MASK // 58 : +#define ASCII_3B KEY_TILDE // 59 ; +#define ASCII_3C KEY_COMMA + ALTGR_MASK // 60 < +#define ASCII_3D KEY_MINUS // 61 = +#define ASCII_3E KEY_PERIOD + ALTGR_MASK // 62 > +#define ASCII_3F KEY_COMMA + SHIFT_MASK // 63 ? +#define ASCII_40 KEY_V + ALTGR_MASK // 64 @ +#define ASCII_41 KEY_A + SHIFT_MASK // 65 A +#define ASCII_42 KEY_B + SHIFT_MASK // 66 B +#define ASCII_43 KEY_C + SHIFT_MASK // 67 C +#define ASCII_44 KEY_D + SHIFT_MASK // 68 D +#define ASCII_45 KEY_E + SHIFT_MASK // 69 E +#define ASCII_46 KEY_F + SHIFT_MASK // 70 F +#define ASCII_47 KEY_G + SHIFT_MASK // 71 G +#define ASCII_48 KEY_H + SHIFT_MASK // 72 H +#define ASCII_49 KEY_I + SHIFT_MASK // 73 I +#define ASCII_4A KEY_J + SHIFT_MASK // 74 J +#define ASCII_4B KEY_K + SHIFT_MASK // 75 K +#define ASCII_4C KEY_L + SHIFT_MASK // 76 L +#define ASCII_4D KEY_M + SHIFT_MASK // 77 M +#define ASCII_4E KEY_N + SHIFT_MASK // 78 N +#define ASCII_4F KEY_O + SHIFT_MASK // 79 O +#define ASCII_50 KEY_P + SHIFT_MASK // 80 P +#define ASCII_51 KEY_Q + SHIFT_MASK // 81 Q +#define ASCII_52 KEY_R + SHIFT_MASK // 82 R +#define ASCII_53 KEY_S + SHIFT_MASK // 83 S +#define ASCII_54 KEY_T + SHIFT_MASK // 84 T +#define ASCII_55 KEY_U + SHIFT_MASK // 85 U +#define ASCII_56 KEY_V + SHIFT_MASK // 86 V +#define ASCII_57 KEY_W + SHIFT_MASK // 87 W +#define ASCII_58 KEY_X + SHIFT_MASK // 88 X +#define ASCII_59 KEY_Z + SHIFT_MASK // 89 Y +#define ASCII_5A KEY_Y + SHIFT_MASK // 90 Z +#define ASCII_5B KEY_F + ALTGR_MASK // 91 [ +#define ASCII_5C KEY_NON_US_100 // 92 +#define ASCII_5D KEY_G + ALTGR_MASK // 93 ] +#define ASCII_5E KEY_3 + ALTGR_MASK // 94 ^ TODO: testme +#define ASCII_5F KEY_SLASH + SHIFT_MASK // 95 _ +#define ASCII_60 KEY_7 + ALTGR_MASK // 96 ` TODO: testme +#define ASCII_61 KEY_A // 97 a +#define ASCII_62 KEY_B // 98 b +#define ASCII_63 KEY_C // 99 c +#define ASCII_64 KEY_D // 100 d +#define ASCII_65 KEY_E // 101 e +#define ASCII_66 KEY_F // 102 f +#define ASCII_67 KEY_G // 103 g +#define ASCII_68 KEY_H // 104 h +#define ASCII_69 KEY_I // 105 i +#define ASCII_6A KEY_J // 106 j +#define ASCII_6B KEY_K // 107 k +#define ASCII_6C KEY_L // 108 l +#define ASCII_6D KEY_M // 109 m +#define ASCII_6E KEY_N // 110 n +#define ASCII_6F KEY_O // 111 o +#define ASCII_70 KEY_P // 112 p +#define ASCII_71 KEY_Q // 113 q +#define ASCII_72 KEY_R // 114 r +#define ASCII_73 KEY_S // 115 s +#define ASCII_74 KEY_T // 116 t +#define ASCII_75 KEY_U // 117 u +#define ASCII_76 KEY_V // 118 v +#define ASCII_77 KEY_W // 119 w +#define ASCII_78 KEY_X // 120 x +#define ASCII_79 KEY_Z // 121 y +#define ASCII_7A KEY_Y // 122 z +#define ASCII_7B KEY_B + ALTGR_MASK // 123 { +#define ASCII_7C KEY_NON_US_100 + SHIFT_MASK // 124 | +#define ASCII_7D KEY_N + ALTGR_MASK // 125 } +#define ASCII_7E KEY_1 + ALTGR_MASK // 126 ~ TODO: fixme +#define ASCII_7F KEY_BACKSPACE // 127 +#define ISO_8859_1_A0 KEY_SPACE // 160 Nonbreakng Space +#define ISO_8859_1_A1 0 // 161 ¡ Inverted Exclamation +#define ISO_8859_1_A2 0 // 162 ¢ Cent Sign +#define ISO_8859_1_A3 0 // 163 £ Pound Sign +#define ISO_8859_1_A4 KEY_BACKSLASH + ALTGR_MASK // 164 ¤ Currency Sign +#define ISO_8859_1_A5 0 // 165 ¥ YEN SIGN +#define ISO_8859_1_A6 0 // 166 ¦ BROKEN BAR +#define ISO_8859_1_A7 KEY_QUOTE // 167 § SECTION SIGN +#define ISO_8859_1_A8 0 // 168 ¨ DIAERESIS +#define ISO_8859_1_A9 0 // 169 © COPYRIGHT SIGN +#define ISO_8859_1_AA 0 // 170 ª FEMININE ORDINAL +#define ISO_8859_1_AB 0 // 171 « LEFT DOUBLE ANGLE QUOTE +#define ISO_8859_1_AC 0 // 172 ¬ NOT SIGN +#define ISO_8859_1_AD 0 // 173 SOFT HYPHEN +#define ISO_8859_1_AE 0 // 174 ® REGISTERED SIGN +#define ISO_8859_1_AF 0 // 175 ¯ MACRON +#define ISO_8859_1_B0 DEGREE_SIGN_BITS + KEY_SPACE // 176 ° DEGREE SIGN +#define ISO_8859_1_B1 0 // 177 ± PLUS-MINUS SIGN +#define ISO_8859_1_B2 0 // 178 ² SUPERSCRIPT TWO +#define ISO_8859_1_B3 0 // 179 ³ SUPERSCRIPT THREE +#define ISO_8859_1_B4 ACUTE_ACCENT_BITS + KEY_SPACE // 180 ´ ACUTE ACCENT +#define ISO_8859_1_B5 0 // 181 µ MICRO SIGN +#define ISO_8859_1_B6 0 // 182 ¶ PILCROW SIGN +#define ISO_8859_1_B7 0 // 183 · MIDDLE DOT +#define ISO_8859_1_B8 CEDILLA_BITS + KEY_SPACE // 184 ¸ CEDILLA +#define ISO_8859_1_B9 0 // 185 ¹ SUPERSCRIPT ONE +#define ISO_8859_1_BA 0 // 186 º MASCULINE ORDINAL +#define ISO_8859_1_BB 0 // 187 » RIGHT DOUBLE ANGLE QUOTE +#define ISO_8859_1_BC 0 // 188 ¼ FRACTION ONE QUARTER +#define ISO_8859_1_BD 0 // 189 ½ FRACTION ONE HALF +#define ISO_8859_1_BE 0 // 190 ¾ FRACTION THREE QUARTERS +#define ISO_8859_1_BF 0 // 191 ¿ INVERTED QUESTION MARK +#define ISO_8859_1_C0 0 // 192 À A GRAVE +#define ISO_8859_1_C1 ACUTE_ACCENT_BITS + KEY_A + SHIFT_MASK // 193 Á A ACUTE +#define ISO_8859_1_C2 0 // 194 Â A CIRCUMFLEX +#define ISO_8859_1_C3 0 // 195 Ã A TILDE +#define ISO_8859_1_C4 0 // 196 Ä A DIAERESIS +#define ISO_8859_1_C5 0 // 197 Å A RING ABOVE +#define ISO_8859_1_C6 0 // 198 Æ AE +#define ISO_8859_1_C7 CEDILLA_BITS + KEY_C + SHIFT_MASK // 199 Ç C CEDILLA +#define ISO_8859_1_C8 0 // 200 È E GRAVE +#define ISO_8859_1_C9 ACUTE_ACCENT_BITS + KEY_E + SHIFT_MASK // 201 É E ACUTE +#define ISO_8859_1_CA 0 // 202 Ê E CIRCUMFLEX +#define ISO_8859_1_CB 0 // 203 Ë E DIAERESIS +#define ISO_8859_1_CC 0 // 204 Ì I GRAVE +#define ISO_8859_1_CD ACUTE_ACCENT_BITS + KEY_I + SHIFT_MASK // 205 Í I ACUTE +#define ISO_8859_1_CE 0 // 206 Î I CIRCUMFLEX +#define ISO_8859_1_CF 0 // 207 Ï I DIAERESIS +#define ISO_8859_1_D0 0 // 208 Ð ETH +#define ISO_8859_1_D1 0 // 209 Ñ N TILDE +#define ISO_8859_1_D2 0 // 210 Ò O GRAVE +#define ISO_8859_1_D3 ACUTE_ACCENT_BITS + KEY_O + SHIFT_MASK // 211 Ó O ACUTE +#define ISO_8859_1_D4 0 // 212 Ô O CIRCUMFLEX +#define ISO_8859_1_D5 0 // 213 Õ O TILDE +#define ISO_8859_1_D6 0 // 214 Ö O DIAERESIS +#define ISO_8859_1_D7 KEY_RIGHT_BRACE + ALTGR_MASK // 215 × MULTIPLICATION +#define ISO_8859_1_D8 0 // 216 Ø O STROKE +#define ISO_8859_1_D9 0 // 217 Ù U GRAVE +#define ISO_8859_1_DA ACUTE_ACCENT_BITS + KEY_U + SHIFT_MASK // 218 Ú U ACUTE +#define ISO_8859_1_DB 0 // 219 Û U CIRCUMFLEX +#define ISO_8859_1_DC 0 // 220 Ü U DIAERESIS +#define ISO_8859_1_DD ACUTE_ACCENT_BITS + KEY_Z + SHIFT_MASK // 221 Ý Y ACUTE +#define ISO_8859_1_DE 0 // 222 Þ THORN +#define ISO_8859_1_DF KEY_QUOTE + ALTGR_MASK // 223 ß SHARP S TODO: testme +#define ISO_8859_1_E0 0 // 224 à a GRAVE +#define ISO_8859_1_E1 KEY_8 // 225 á a ACUTE +#define ISO_8859_1_E2 0 // 226 â a CIRCUMFLEX +#define ISO_8859_1_E3 0 // 227 ã a TILDE +#define ISO_8859_1_E4 0 // 228 ä a DIAERESIS +#define ISO_8859_1_E5 0 // 229 å a RING ABOVE +#define ISO_8859_1_E6 0 // 230 æ ae +#define ISO_8859_1_E7 CEDILLA_BITS + KEY_C // 231 ç c CEDILLA +#define ISO_8859_1_E8 0 // 232 è e GRAVE +#define ISO_8859_1_E9 KEY_0 // 233 é e ACUTE +#define ISO_8859_1_EA 0 // 234 ê e CIRCUMFLEX +#define ISO_8859_1_EB 0 // 235 ë e DIAERESIS +#define ISO_8859_1_EC 0 // 236 ì i GRAVE +#define ISO_8859_1_ED KEY_9 // 237 í i ACUTE +#define ISO_8859_1_EE 0 // 238 î i CIRCUMFLEX +#define ISO_8859_1_EF 0 // 239 ï i DIAERESIS +#define ISO_8859_1_F0 0 // 240 ð ETH +#define ISO_8859_1_F1 0 // 241 ñ n TILDE +#define ISO_8859_1_F2 0 // 242 ò o GRAVE +#define ISO_8859_1_F3 ACUTE_ACCENT_BITS + KEY_O // 243 ó o ACUTE +#define ISO_8859_1_F4 0 // 244 ô o CIRCUMFLEX +#define ISO_8859_1_F5 0 // 245 õ o TILDE +#define ISO_8859_1_F6 0 // 246 ö o DIAERESIS +#define ISO_8859_1_F7 KEY_LEFT_BRACE + ALTGR_MASK // 247 ÷ DIVISION +#define ISO_8859_1_F8 0 // 248 ø o STROKE +#define ISO_8859_1_F9 0 // 249 ù u GRAVE +#define ISO_8859_1_FA KEY_LEFT_BRACE // 250 ú u ACUTE +#define ISO_8859_1_FB 0 // 251 û u CIRCUMFLEX +#define ISO_8859_1_FC 0 // 252 ü u DIAERESIS +#define ISO_8859_1_FD KEY_7 // 253 ý y ACUTE +#define ISO_8859_1_FE 0 // 254 þ THORN +#define ISO_8859_1_FF 0 // 255 ÿ y DIAERESIS +#define UNICODE_20AC KEY_E + ALTGR_MASK // € Euro Sign + +#define UNICODE_EXTRA00 0x011B // ě Small Letter E with caron +#define KEYCODE_EXTRA00 KEY_2 +#define UNICODE_EXTRA01 0x0161 // š Small Letter S with caron +#define KEYCODE_EXTRA01 KEY_3 +#define UNICODE_EXTRA02 0x010D // č Small Letter C with caron +#define KEYCODE_EXTRA02 KEY_4 +#define UNICODE_EXTRA03 0x0159 // ř Small Letter R with caron +#define KEYCODE_EXTRA03 KEY_5 +#define UNICODE_EXTRA04 0x017E // ž Small Letter Z with caron +#define KEYCODE_EXTRA04 KEY_6 +#define UNICODE_EXTRA05 0x016F // ů Small Letter U with ring above +#define KEYCODE_EXTRA05 KEY_SEMICOLON +#define UNICODE_EXTRA06 0x0111 // đ Small Letter D with stroke +#define KEYCODE_EXTRA06 KEY_S + ALTGR_MASK +#define UNICODE_EXTRA07 0x0110 // Đ Capital Letter D with stroke +#define KEYCODE_EXTRA07 KEY_D + ALTGR_MASK +#define UNICODE_EXTRA08 0x0142 // ł Small Letter L with stroke +#define KEYCODE_EXTRA08 KEY_K + ALTGR_MASK +#define UNICODE_EXTRA09 0x0141 // Ł Capital Letter L with stroke +#define KEYCODE_EXTRA09 KEY_L + ALTGR_MASK +#define UNICODE_EXTRA0A 0x20AC // € Euro Sign +#define KEYCODE_EXTRA0A KEY_E + ALTGR_MASK + +#endif // LAYOUT_CZECH + + +#ifdef LAYOUT_SERBIAN_LATIN_ONLY +// http://forum.pjrc.com/threads/27032-Serbian-Keyboard-Layout + +#define SHIFT_MASK 0x0040 +#define ALTGR_MASK 0x0080 +#define DEADKEYS_MASK 0x0F00 +#define CEDILLA_BITS 0x0100 +#define CARON_BITS 0x0200 +#define CIRCUMFLEX_BITS 0x0300 +#define BREVE_BITS 0x0400 +#define DEGREE_SIGN_BITS 0x0500 +#define OGONEK_BITS 0x0600 +#define DOT_ABOVE_BITS 0x0700 +#define ACUTE_ACCENT_BITS 0x0800 +#define DOUBLE_ACUTE_BITS 0x0900 +#define DIAERESIS_BITS 0x0A00 +#define KEYCODE_TYPE uint16_t +#define KEYCODE_MASK 0x0FFF +#define DEADKEY_CEDILLA KEY_TILDE +#define DEADKEY_CARON KEY_2 + ALTGR_MASK +#define DEADKEY_CIRCUMFLEX KEY_3 + ALTGR_MASK +#define DEADKEY_BREVE KEY_4 + ALTGR_MASK +#define DEADKEY_DEGREE_SIGN KEY_5 + ALTGR_MASK +#define DEADKEY_OGONEK KEY_6 + ALTGR_MASK +#define DEADKEY_DOT_ABOVE KEY_8 + ALTGR_MASK +#define DEADKEY_ACUTE_ACCENT KEY_9 + ALTGR_MASK +#define DEADKEY_DOUBLE_ACUTE KEY_0 + ALTGR_MASK +#define DEADKEY_DIAERESIS KEY_MINUS + ALTGR_MASK +//#define DEADKEY_CEDILLA KEY_EQUAL + ALTGR_MASK <-- TODO: why are there 2 Cedilla deadkeys? +#define KEY_NON_US_100 63 + +#define ASCII_20 KEY_SPACE // 32 +#define ASCII_21 KEY_1 + SHIFT_MASK // 33 ! +#define ASCII_22 KEY_2 + SHIFT_MASK // 34 " +#define ASCII_23 KEY_3 + SHIFT_MASK // 35 # +#define ASCII_24 KEY_4 + SHIFT_MASK // 36 $ +#define ASCII_25 KEY_5 + SHIFT_MASK // 37 % +#define ASCII_26 KEY_6 + SHIFT_MASK // 38 & +#define ASCII_27 KEY_MINUS // 39 ' +#define ASCII_28 KEY_8 + SHIFT_MASK // 40 ( +#define ASCII_29 KEY_9 + SHIFT_MASK // 41 ) +#define ASCII_2A KEY_EQUAL + SHIFT_MASK // 42 * +#define ASCII_2B KEY_EQUAL // 43 + +#define ASCII_2C KEY_COMMA // 44 , +#define ASCII_2D KEY_SLASH // 45 - TODO: verify +#define ASCII_2E KEY_PERIOD // 46 . +#define ASCII_2F KEY_7 + SHIFT_MASK // 47 / +#define ASCII_30 KEY_0 // 48 0 +#define ASCII_31 KEY_1 // 49 1 +#define ASCII_32 KEY_2 // 50 2 +#define ASCII_33 KEY_3 // 51 3 +#define ASCII_34 KEY_4 // 52 4 +#define ASCII_35 KEY_5 // 53 5 +#define ASCII_36 KEY_6 // 54 6 +#define ASCII_37 KEY_7 // 55 7 +#define ASCII_38 KEY_8 // 55 8 +#define ASCII_39 KEY_9 // 57 9 +#define ASCII_3A KEY_PERIOD + SHIFT_MASK // 58 : +#define ASCII_3B KEY_COMMA + SHIFT_MASK // 59 ; +#define ASCII_3C KEY_NON_US_100 // 60 < +#define ASCII_3D KEY_0 + SHIFT_MASK // 61 = +#define ASCII_3E KEY_NON_US_100 + SHIFT_MASK // 62 > +#define ASCII_3F KEY_MINUS + SHIFT_MASK // 63 ? +#define ASCII_40 KEY_V + ALTGR_MASK // 64 @ +#define ASCII_41 KEY_A + SHIFT_MASK // 65 A +#define ASCII_42 KEY_B + SHIFT_MASK // 66 B +#define ASCII_43 KEY_C + SHIFT_MASK // 67 C +#define ASCII_44 KEY_D + SHIFT_MASK // 68 D +#define ASCII_45 KEY_E + SHIFT_MASK // 69 E +#define ASCII_46 KEY_F + SHIFT_MASK // 70 F +#define ASCII_47 KEY_G + SHIFT_MASK // 71 G +#define ASCII_48 KEY_H + SHIFT_MASK // 72 H +#define ASCII_49 KEY_I + SHIFT_MASK // 73 I +#define ASCII_4A KEY_J + SHIFT_MASK // 74 J +#define ASCII_4B KEY_K + SHIFT_MASK // 75 K +#define ASCII_4C KEY_L + SHIFT_MASK // 76 L +#define ASCII_4D KEY_M + SHIFT_MASK // 77 M +#define ASCII_4E KEY_N + SHIFT_MASK // 78 N +#define ASCII_4F KEY_O + SHIFT_MASK // 79 O +#define ASCII_50 KEY_P + SHIFT_MASK // 80 P +#define ASCII_51 KEY_Q + SHIFT_MASK // 81 Q +#define ASCII_52 KEY_R + SHIFT_MASK // 82 R +#define ASCII_53 KEY_S + SHIFT_MASK // 83 S +#define ASCII_54 KEY_T + SHIFT_MASK // 84 T +#define ASCII_55 KEY_U + SHIFT_MASK // 85 U +#define ASCII_56 KEY_V + SHIFT_MASK // 86 V +#define ASCII_57 KEY_W + SHIFT_MASK // 87 W +#define ASCII_58 KEY_X + SHIFT_MASK // 88 X +#define ASCII_59 KEY_Z + SHIFT_MASK // 89 Y +#define ASCII_5A KEY_Y + SHIFT_MASK // 90 Z +#define ASCII_5B KEY_F + ALTGR_MASK // 91 [ +#define ASCII_5C KEY_Q + ALTGR_MASK // 92 +#define ASCII_5D KEY_G + ALTGR_MASK // 93 ] +#define ASCII_5E CIRCUMFLEX_BITS + KEY_SPACE // 94 ^ +#define ASCII_5F KEY_SLASH + SHIFT_MASK // 95 _ TODO: verify +#define ASCII_60 KEY_7 + ALTGR_MASK // 96 ` +#define ASCII_61 KEY_A // 97 a +#define ASCII_62 KEY_B // 98 b +#define ASCII_63 KEY_C // 99 c +#define ASCII_64 KEY_D // 100 d +#define ASCII_65 KEY_E // 101 e +#define ASCII_66 KEY_F // 102 f +#define ASCII_67 KEY_G // 103 g +#define ASCII_68 KEY_H // 104 h +#define ASCII_69 KEY_I // 105 i +#define ASCII_6A KEY_J // 106 j +#define ASCII_6B KEY_K // 107 k +#define ASCII_6C KEY_L // 108 l +#define ASCII_6D KEY_M // 109 m +#define ASCII_6E KEY_N // 110 n +#define ASCII_6F KEY_O // 111 o +#define ASCII_70 KEY_P // 112 p +#define ASCII_71 KEY_Q // 113 q +#define ASCII_72 KEY_R // 114 r +#define ASCII_73 KEY_S // 115 s +#define ASCII_74 KEY_T // 116 t +#define ASCII_75 KEY_U // 117 u +#define ASCII_76 KEY_V // 118 v +#define ASCII_77 KEY_W // 119 w +#define ASCII_78 KEY_X // 120 x +#define ASCII_79 KEY_Z // 121 y +#define ASCII_7A KEY_Y // 122 z +#define ASCII_7B KEY_B + ALTGR_MASK // 123 { +#define ASCII_7C KEY_W + ALTGR_MASK // 124 | +#define ASCII_7D KEY_N + ALTGR_MASK // 125 } +#define ASCII_7E KEY_1 + ALTGR_MASK // 126 ~ +#define ASCII_7F KEY_BACKSPACE // 127 +#define ISO_8859_1_A0 KEY_SPACE // 160 Nonbreakng Space +#define ISO_8859_1_A1 0 // 161 ¡ Inverted Exclamation +#define ISO_8859_1_A2 0 // 162 ¢ Cent Sign +#define ISO_8859_1_A3 0 // 163 £ Pound Sign +#define ISO_8859_1_A4 KEY_BACKSLASH + ALTGR_MASK // 164 ¤ Currency Sign +#define ISO_8859_1_A5 0 // 165 ¥ YEN SIGN +#define ISO_8859_1_A6 0 // 166 ¦ BROKEN BAR +#define ISO_8859_1_A7 KEY_M + ALTGR_MASK // 167 § SECTION SIGN +#define ISO_8859_1_A8 DIAERESIS_BITS + KEY_SPACE // 168 ¨ DIAERESIS +#define ISO_8859_1_A9 0 // 169 © COPYRIGHT SIGN +#define ISO_8859_1_AA 0 // 170 ª FEMININE ORDINAL +#define ISO_8859_1_AB 0 // 171 « LEFT DOUBLE ANGLE QUOTE +#define ISO_8859_1_AC 0 // 172 ¬ NOT SIGN +#define ISO_8859_1_AD 0 // 173 SOFT HYPHEN +#define ISO_8859_1_AE 0 // 174 ® REGISTERED SIGN +#define ISO_8859_1_AF 0 // 175 ¯ MACRON +#define ISO_8859_1_B0 DEGREE_SIGN_BITS + KEY_SPACE // 176 ° DEGREE SIGN +#define ISO_8859_1_B1 0 // 177 ± PLUS-MINUS SIGN +#define ISO_8859_1_B2 0 // 178 ² SUPERSCRIPT TWO +#define ISO_8859_1_B3 0 // 179 ³ SUPERSCRIPT THREE +#define ISO_8859_1_B4 ACUTE_ACCENT_BITS + KEY_SPACE // 180 ´ ACUTE ACCENT +#define ISO_8859_1_B5 0 // 181 µ MICRO SIGN +#define ISO_8859_1_B6 0 // 182 ¶ PILCROW SIGN +#define ISO_8859_1_B7 0 // 183 · MIDDLE DOT +#define ISO_8859_1_B8 CEDILLA_BITS + KEY_SPACE // 184 ¸ CEDILLA +#define ISO_8859_1_B9 0 // 185 ¹ SUPERSCRIPT ONE +#define ISO_8859_1_BA 0 // 186 º MASCULINE ORDINAL +#define ISO_8859_1_BB 0 // 187 » RIGHT DOUBLE ANGLE QUOTE +#define ISO_8859_1_BC 0 // 188 ¼ FRACTION ONE QUARTER +#define ISO_8859_1_BD 0 // 189 ½ FRACTION ONE HALF +#define ISO_8859_1_BE 0 // 190 ¾ FRACTION THREE QUARTERS +#define ISO_8859_1_BF 0 // 191 ¿ INVERTED QUESTION MARK +#define ISO_8859_1_C0 0 // 192 À A GRAVE +#define ISO_8859_1_C1 ACUTE_ACCENT_BITS + KEY_A + SHIFT_MASK // 193 Á A ACUTE +#define ISO_8859_1_C2 CIRCUMFLEX_BITS + KEY_A + SHIFT_MASK // 194 Â A CIRCUMFLEX +#define ISO_8859_1_C3 0 // 195 Ã A TILDE +#define ISO_8859_1_C4 DIAERESIS_BITS + KEY_A + SHIFT_MASK // 196 Ä A DIAERESIS +#define ISO_8859_1_C5 0 // 197 Å A RING ABOVE +#define ISO_8859_1_C6 0 // 198 Æ AE +#define ISO_8859_1_C7 CEDILLA_BITS + KEY_C + SHIFT_MASK // 199 Ç C CEDILLA +#define ISO_8859_1_C8 0 // 200 È E GRAVE +#define ISO_8859_1_C9 ACUTE_ACCENT_BITS + KEY_E + SHIFT_MASK // 201 É E ACUTE +#define ISO_8859_1_CA CIRCUMFLEX_BITS + KEY_E + SHIFT_MASK // 202 Ê E CIRCUMFLEX +#define ISO_8859_1_CB DIAERESIS_BITS + KEY_E + SHIFT_MASK // 203 Ë E DIAERESIS +#define ISO_8859_1_CC 0 // 204 Ì I GRAVE +#define ISO_8859_1_CD ACUTE_ACCENT_BITS + KEY_I + SHIFT_MASK // 205 Í I ACUTE +#define ISO_8859_1_CE CIRCUMFLEX_BITS + KEY_I + SHIFT_MASK // 206 Î I CIRCUMFLEX +#define ISO_8859_1_CF DIAERESIS_BITS + KEY_I + SHIFT_MASK // 207 Ï I DIAERESIS +#define ISO_8859_1_D0 0 // 208 Ð ETH +#define ISO_8859_1_D1 0 // 209 Ñ N TILDE +#define ISO_8859_1_D2 0 // 210 Ò O GRAVE +#define ISO_8859_1_D3 ACUTE_ACCENT_BITS + KEY_O + SHIFT_MASK // 211 Ó O ACUTE +#define ISO_8859_1_D4 CIRCUMFLEX_BITS + KEY_O + SHIFT_MASK // 212 Ô O CIRCUMFLEX +#define ISO_8859_1_D5 0 // 213 Õ O TILDE +#define ISO_8859_1_D6 DIAERESIS_BITS + KEY_O + SHIFT_MASK // 214 Ö O DIAERESIS +#define ISO_8859_1_D7 KEY_RIGHT_BRACE + ALTGR_MASK // 215 × MULTIPLICATION +#define ISO_8859_1_D8 0 // 216 Ø O STROKE +#define ISO_8859_1_D9 0 // 217 Ù U GRAVE +#define ISO_8859_1_DA ACUTE_ACCENT_BITS + KEY_U + SHIFT_MASK // 218 Ú U ACUTE +#define ISO_8859_1_DB CIRCUMFLEX_BITS + KEY_U + SHIFT_MASK // 219 Û U CIRCUMFLEX +#define ISO_8859_1_DC DIAERESIS_BITS + KEY_U + SHIFT_MASK // 220 Ü U DIAERESIS +#define ISO_8859_1_DD ACUTE_ACCENT_BITS + KEY_Z + SHIFT_MASK // 221 Ý Y ACUTE +#define ISO_8859_1_DE 0 // 222 Þ THORN +#define ISO_8859_1_DF KEY_QUOTE + ALTGR_MASK // 223 ß SHARP S +#define ISO_8859_1_E0 0 // 224 à a GRAVE +#define ISO_8859_1_E1 ACUTE_ACCENT_BITS + KEY_A // 225 á a ACUTE +#define ISO_8859_1_E2 CIRCUMFLEX_BITS + KEY_A // 226 â a CIRCUMFLEX +#define ISO_8859_1_E3 0 // 227 ã a TILDE +#define ISO_8859_1_E4 DIAERESIS_BITS + KEY_A // 228 ä a DIAERESIS +#define ISO_8859_1_E5 0 // 229 å a RING ABOVE +#define ISO_8859_1_E6 0 // 230 æ ae +#define ISO_8859_1_E7 CEDILLA_BITS + KEY_C // 231 ç c CEDILLA +#define ISO_8859_1_E8 0 // 232 è e GRAVE +#define ISO_8859_1_E9 ACUTE_ACCENT_BITS + KEY_E // 233 é e ACUTE +#define ISO_8859_1_EA CIRCUMFLEX_BITS + KEY_E // 234 ê e CIRCUMFLEX +#define ISO_8859_1_EB DIAERESIS_BITS + KEY_E // 235 ë e DIAERESIS +#define ISO_8859_1_EC 0 // 236 ì i GRAVE +#define ISO_8859_1_ED ACUTE_ACCENT_BITS + KEY_I // 237 í i ACUTE +#define ISO_8859_1_EE CIRCUMFLEX_BITS + KEY_I // 238 î i CIRCUMFLEX +#define ISO_8859_1_EF DIAERESIS_BITS + KEY_I // 239 ï i DIAERESIS +#define ISO_8859_1_F0 0 // 240 ð ETH +#define ISO_8859_1_F1 0 // 241 ñ n TILDE +#define ISO_8859_1_F2 0 // 242 ò o GRAVE +#define ISO_8859_1_F3 ACUTE_ACCENT_BITS + KEY_O // 243 ó o ACUTE +#define ISO_8859_1_F4 CIRCUMFLEX_BITS + KEY_O // 244 ô o CIRCUMFLEX +#define ISO_8859_1_F5 0 // 245 õ o TILDE +#define ISO_8859_1_F6 DIAERESIS_BITS + KEY_O // 246 ö o DIAERESIS +#define ISO_8859_1_F7 KEY_LEFT_BRACE + ALTGR_MASK // 247 ÷ DIVISION +#define ISO_8859_1_F8 0 // 248 ø o STROKE +#define ISO_8859_1_F9 0 // 249 ù u GRAVE +#define ISO_8859_1_FA ACUTE_ACCENT_BITS + KEY_U // 250 ú u ACUTE +#define ISO_8859_1_FB CIRCUMFLEX_BITS + KEY_U // 251 û u CIRCUMFLEX +#define ISO_8859_1_FC DIAERESIS_BITS + KEY_U // 252 ü u DIAERESIS +#define ISO_8859_1_FD ACUTE_ACCENT_BITS + KEY_Z // 253 ý y ACUTE +#define ISO_8859_1_FE 0 // 254 þ THORN +#define ISO_8859_1_FF 0 // 255 ÿ y DIAERESIS +#define UNICODE_20AC KEY_E + ALTGR_MASK // € Euro Sign + +#define UNICODE_EXTRA00 0x0160 // S caron +#define KEYCODE_EXTRA00 KEY_LEFT_BRACE + SHIFT_MASK +#define UNICODE_EXTRA01 0x0161 // s caron +#define KEYCODE_EXTRA01 KEY_LEFT_BRACE +#define UNICODE_EXTRA02 0x0110 // D with stroke +#define KEYCODE_EXTRA02 KEY_RIGHT_BRACE + SHIFT_MASK +#define UNICODE_EXTRA03 0x0111 // d with stroke +#define KEYCODE_EXTRA03 KEY_RIGHT_BRACE +#define UNICODE_EXTRA04 0x010C // C with caron +#define KEYCODE_EXTRA04 KEY_SEMICOLON + SHIFT_MASK +#define UNICODE_EXTRA05 0x010D // c with caron +#define KEYCODE_EXTRA05 KEY_SEMICOLON +#define UNICODE_EXTRA06 0x0106 // C with acute +#define KEYCODE_EXTRA06 KEY_QUOTE + SHIFT_MASK +#define UNICODE_EXTRA07 0x0107 // c with acute +#define KEYCODE_EXTRA07 KEY_QUOTE +#define UNICODE_EXTRA08 0x017D // Z with caron +#define KEYCODE_EXTRA08 KEY_BACKSLASH + SHIFT_MASK +#define UNICODE_EXTRA09 0x017E // z with caron +#define KEYCODE_EXTRA09 KEY_BACKSLASH + +#define UNICODE_EXTRA10 0x0141 // L with stroke +#define KEYCODE_EXTRA10 KEY_L + ALTGR_MASK +#define UNICODE_EXTRA11 0x0142 // l with stroke +#define KEYCODE_EXTRA11 KEY_K + ALTGR_MASK +#define UNICODE_EXTRA12 0x010E // D with caron +#define KEYCODE_EXTRA12 CARON_BITS + KEY_D + SHIFT_MASK +#define UNICODE_EXTRA13 0x010F // d with caron +#define KEYCODE_EXTRA13 CARON_BITS + KEY_D +#define UNICODE_EXTRA14 0x011A // E with caron +#define KEYCODE_EXTRA14 CARON_BITS + KEY_E + SHIFT_MASK +#define UNICODE_EXTRA15 0x011B // e with caron +#define KEYCODE_EXTRA15 CARON_BITS + KEY_E +#define UNICODE_EXTRA16 0x013D // L with caron +#define KEYCODE_EXTRA16 CARON_BITS + KEY_L + SHIFT_MASK +#define UNICODE_EXTRA17 0x013E // l with caron +#define KEYCODE_EXTRA17 CARON_BITS + KEY_L +#define UNICODE_EXTRA18 0x0147 // N with caron +#define KEYCODE_EXTRA18 CARON_BITS + KEY_N + SHIFT_MASK +#define UNICODE_EXTRA19 0x0148 // n with caron +#define KEYCODE_EXTRA19 CARON_BITS + KEY_N + +#define UNICODE_EXTRA20 0x0158 // R with caron +#define KEYCODE_EXTRA20 CARON_BITS + KEY_R + SHIFT_MASK +#define UNICODE_EXTRA21 0x0159 // r with caron +#define KEYCODE_EXTRA21 CARON_BITS + KEY_R +#define UNICODE_EXTRA22 0x0164 // T with caron +#define KEYCODE_EXTRA22 CARON_BITS + KEY_T + SHIFT_MASK +#define UNICODE_EXTRA23 0x0165 // t with caron +#define KEYCODE_EXTRA23 CARON_BITS + KEY_T +#define UNICODE_EXTRA24 0x0102 // A with breve +#define KEYCODE_EXTRA24 BREVE_BITS + KEY_A + SHIFT_MASK +#define UNICODE_EXTRA25 0x0103 // a with breve +#define KEYCODE_EXTRA25 BREVE_BITS + KEY_A +#define UNICODE_EXTRA26 0x016E // U with ring above TODO: verify +#define KEYCODE_EXTRA26 DEADKEY_DEGREE_SIGN + KEY_U + SHIFT_MASK +#define UNICODE_EXTRA27 0x016F // u with ring above TODO: verify +#define KEYCODE_EXTRA27 DEADKEY_DEGREE_SIGN + KEY_U +#define UNICODE_EXTRA28 0x0104 // A with ogonek +#define KEYCODE_EXTRA28 OGONEK_BITS + KEY_A + SHIFT_MASK +#define UNICODE_EXTRA29 0x0105 // a with ogonek +#define KEYCODE_EXTRA29 OGONEK_BITS + KEY_A + +#define UNICODE_EXTRA30 0x0118 // E with ogonek +#define KEYCODE_EXTRA30 OGONEK_BITS + KEY_E + SHIFT_MASK +#define UNICODE_EXTRA31 0x0119 // e with ogonek +#define KEYCODE_EXTRA31 OGONEK_BITS + KEY_E +#define UNICODE_EXTRA32 0x017B // Z with dot above +#define KEYCODE_EXTRA32 DEADKEY_DOT_ABOVE + KEY_Z + SHIFT_MASK +#define UNICODE_EXTRA33 0x017C // z with dot above +#define KEYCODE_EXTRA33 DEADKEY_DOT_ABOVE + KEY_Z +#define UNICODE_EXTRA34 0x0139 // L with acute +#define KEYCODE_EXTRA34 ACUTE_ACCENT_BITS + KEY_L + SHIFT_MASK +#define UNICODE_EXTRA35 0x013A // l with acute +#define KEYCODE_EXTRA35 ACUTE_ACCENT_BITS + KEY_L +#define UNICODE_EXTRA36 0x0143 // N with acute +#define KEYCODE_EXTRA36 ACUTE_ACCENT_BITS + KEY_N + SHIFT_MASK +#define UNICODE_EXTRA37 0x0144 // n with acute +#define KEYCODE_EXTRA37 ACUTE_ACCENT_BITS + KEY_N +#define UNICODE_EXTRA38 0x0154 // R with acute +#define KEYCODE_EXTRA38 ACUTE_ACCENT_BITS + KEY_R + SHIFT_MASK +#define UNICODE_EXTRA39 0x0155 // r with acute +#define KEYCODE_EXTRA39 ACUTE_ACCENT_BITS + KEY_R + +#define UNICODE_EXTRA40 0x015A // S with acute +#define KEYCODE_EXTRA40 ACUTE_ACCENT_BITS + KEY_S + SHIFT_MASK +#define UNICODE_EXTRA41 0x015B // s with acute +#define KEYCODE_EXTRA41 ACUTE_ACCENT_BITS + KEY_S +#define UNICODE_EXTRA42 0x0179 // Z with acute +#define KEYCODE_EXTRA42 ACUTE_ACCENT_BITS + KEY_Z + SHIFT_MASK +#define UNICODE_EXTRA43 0x017A // z with acute +#define KEYCODE_EXTRA43 ACUTE_ACCENT_BITS + KEY_Z +#define UNICODE_EXTRA44 0x0150 // O with double acute +#define KEYCODE_EXTRA44 DOUBLE_ACUTE_BITS + KEY_O + SHIFT_MASK +#define UNICODE_EXTRA45 0x0151 // o with double acute +#define KEYCODE_EXTRA45 DOUBLE_ACUTE_BITS + KEY_O +#define UNICODE_EXTRA46 0x0170 // U with double acute +#define KEYCODE_EXTRA46 DOUBLE_ACUTE_BITS + KEY_u + SHIFT_MASK +#define UNICODE_EXTRA47 0x0171 // u with double acute +#define KEYCODE_EXTRA47 DOUBLE_ACUTE_BITS + KEY_u +#define UNICODE_EXTRA48 0x015E // S with cedilla +#define KEYCODE_EXTRA48 CEDILLA_BITS + KEY_S + SHIFT_MASK +#define UNICODE_EXTRA49 0x015F // s with cedilla +#define KEYCODE_EXTRA49 CEDILLA_BITS + KEY_S + +#define UNICODE_EXTRA50 0x201A // single low quote +#define KEYCODE_EXTRA50 KEY_TILDE +#define UNICODE_EXTRA51 0x20AC // euro sign +#define KEYCODE_EXTRA51 KEY_E + ALTGR_MASK + +#endif // LAYOUT_SERBIAN_LATIN_ONLY + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif diff --git a/main/undefkeylayouts.h b/main/undefkeylayouts.h new file mode 100644 index 0000000..cffe56b --- /dev/null +++ b/main/undefkeylayouts.h @@ -0,0 +1,434 @@ +/** very simple: + * undef everything from keylayouts.h */ + +#undef KEYLAYOUTS_H__ + +#undef LAYOUT_US_ENGLISH +#undef LAYOUT_CANADIAN_FRENCH +#undef LAYOUT_CANADIAN_MULTILINGUAL +#undef LAYOUT_DANISH +#undef LAYOUT_FINNISH +#undef LAYOUT_FRENCH +#undef LAYOUT_FRENCH_BELGIAN +#undef LAYOUT_FRENCH_SWISS +#undef LAYOUT_GERMAN +#undef LAYOUT_GERMAN_MAC +#undef LAYOUT_GERMAN_SWISS +#undef LAYOUT_ICELANDIC +#undef LAYOUT_IRISH +#undef LAYOUT_ITALIAN +#undef LAYOUT_NORWEGIAN +#undef LAYOUT_PORTUGUESE +#undef LAYOUT_PORTUGUESE_BRAZILIAN +#undef LAYOUT_SPANISH +#undef LAYOUT_SPANISH_LATIN_AMERICA +#undef LAYOUT_SWEDISH +#undef LAYOUT_TURKISH +#undef LAYOUT_UNITED_KINGDOM +#undef LAYOUT_US_INTERNATIONAL +#undef LAYOUT_SERBIAN_LATIN_ONLY +#undef LAYOUT_CZECH + +#undef SHIFT_MASK +#undef ALTGR_MASK +#undef DEADKEYS_MASK +#undef CIRCUMFLEX_BITS +#undef ACUTE_ACCENT_BITS +#undef GRAVE_ACCENT_BITS +#undef TILDE_BITS +#undef DIAERESIS_BITS +#undef KEYCODE_TYPE +#undef KEYCODE_MASK +#undef DEADKEY_CIRCUMFLEX +#undef DEADKEY_ACUTE_ACCENT +#undef DEADKEY_GRAVE_ACCENT +#undef DEADKEY_TILDE +#undef DEADKEY_DIAERESIS +#undef DEADKEY_RING_ABOVE +#undef DEADKEY_DEGREE_SIGN +#undef RING_ABOVE_BITS +#undef CARON_BITS +#undef DEADKEY_CARON +#undef BREVE_BITS +#undef DEADKEY_BREVE +#undef DEGREE_SIGN_BITS +#undef DOT_ABOVE_BITS +#undef DEADKEY_DOT_ABOVE + + +#undef UNICODE_20AC +#undef UNICODE_EXTRA00 +#undef UNICODE_EXTRA01 +#undef UNICODE_EXTRA02 +#undef UNICODE_EXTRA03 +#undef UNICODE_EXTRA04 +#undef UNICODE_EXTRA05 +#undef UNICODE_EXTRA06 +#undef UNICODE_EXTRA07 +#undef UNICODE_EXTRA08 +#undef UNICODE_EXTRA09 +#undef KEYCODE_EXTRA00 +#undef KEYCODE_EXTRA01 +#undef KEYCODE_EXTRA02 +#undef KEYCODE_EXTRA03 +#undef KEYCODE_EXTRA04 +#undef KEYCODE_EXTRA05 +#undef KEYCODE_EXTRA06 +#undef KEYCODE_EXTRA07 +#undef KEYCODE_EXTRA08 +#undef KEYCODE_EXTRA09 +#undef CEDILLA_BITS +#undef DEADKEY_CEDILLA + +#undef MODIFIERKEY_CTRL +#undef MODIFIERKEY_SHIFT +#undef MODIFIERKEY_ALT +#undef MODIFIERKEY_GUI +#undef MODIFIERKEY_LEFT_CTRL +#undef MODIFIERKEY_LEFT_SHIFT +#undef MODIFIERKEY_LEFT_ALT +#undef MODIFIERKEY_LEFT_GUI +#undef MODIFIERKEY_RIGHT_CTRL +#undef MODIFIERKEY_RIGHT_SHIFT +#undef MODIFIERKEY_RIGHT_ALT +#undef MODIFIERKEY_RIGHT_GUI + +#undef KEY_SYSTEM_POWER_DOWN +#undef KEY_SYSTEM_SLEEP +#undef KEY_SYSTEM_WAKE_UP + +#undef KEY_MEDIA_PLAY +#undef KEY_MEDIA_PAUSE +#undef KEY_MEDIA_RECORD +#undef KEY_MEDIA_FAST_FORWARD +#undef KEY_MEDIA_REWIND +#undef KEY_MEDIA_NEXT_TRACK +#undef KEY_MEDIA_PREV_TRACK +#undef KEY_MEDIA_STOP +#undef KEY_MEDIA_EJECT +#undef KEY_MEDIA_RANDOM_PLAY +#undef KEY_MEDIA_PLAY_PAUSE +#undef KEY_MEDIA_PLAY_SKIP +#undef KEY_MEDIA_MUTE +#undef KEY_MEDIA_VOLUME_INC +#undef KEY_MEDIA_VOLUME_DEC + +#undef KEY_A +#undef KEY_B +#undef KEY_C +#undef KEY_D +#undef KEY_E +#undef KEY_F +#undef KEY_G +#undef KEY_H +#undef KEY_I +#undef KEY_J +#undef KEY_K +#undef KEY_L +#undef KEY_M +#undef KEY_N +#undef KEY_O +#undef KEY_P +#undef KEY_Q +#undef KEY_R +#undef KEY_S +#undef KEY_T +#undef KEY_U +#undef KEY_V +#undef KEY_W +#undef KEY_X +#undef KEY_Y +#undef KEY_Z +#undef KEY_1 +#undef KEY_2 +#undef KEY_3 +#undef KEY_4 +#undef KEY_5 +#undef KEY_6 +#undef KEY_7 +#undef KEY_8 +#undef KEY_9 +#undef KEY_0 +#undef KEY_ENTER +#undef KEY_ESC +#undef KEY_BACKSPACE +#undef KEY_TAB +#undef KEY_SPACE +#undef KEY_MINUS +#undef KEY_EQUAL +#undef KEY_LEFT_BRACE +#undef KEY_RIGHT_BRACE +#undef KEY_BACKSLASH +#undef KEY_NON_US_NUM +#undef KEY_SEMICOLON +#undef KEY_QUOTE +#undef KEY_TILDE +#undef KEY_COMMA +#undef KEY_PERIOD +#undef KEY_SLASH +#undef KEY_CAPS_LOCK +#undef KEY_F1 +#undef KEY_F2 +#undef KEY_F3 +#undef KEY_F4 +#undef KEY_F5 +#undef KEY_F6 +#undef KEY_F7 +#undef KEY_F8 +#undef KEY_F9 +#undef KEY_F10 +#undef KEY_F11 +#undef KEY_F12 +#undef KEY_PRINTSCREEN +#undef KEY_SCROLL_LOCK +#undef KEY_PAUSE +#undef KEY_INSERT +#undef KEY_HOME +#undef KEY_PAGE_UP +#undef KEY_DELETE +#undef KEY_END +#undef KEY_PAGE_DOWN +#undef KEY_RIGHT +#undef KEY_LEFT +#undef KEY_DOWN +#undef KEY_UP +#undef KEY_NUM_LOCK +#undef KEYPAD_SLASH +#undef KEYPAD_ASTERIX +#undef KEYPAD_MINUS +#undef KEYPAD_PLUS +#undef KEYPAD_ENTER +#undef KEYPAD_1 +#undef KEYPAD_2 +#undef KEYPAD_3 +#undef KEYPAD_4 +#undef KEYPAD_5 +#undef KEYPAD_6 +#undef KEYPAD_7 +#undef KEYPAD_8 +#undef KEYPAD_9 +#undef KEYPAD_0 +#undef KEYPAD_PERIOD +#undef KEY_NON_US_BS +#undef KEY_MENU +#undef KEY_F13 +#undef KEY_F14 +#undef KEY_F15 +#undef KEY_F16 +#undef KEY_F17 +#undef KEY_F18 +#undef KEY_F19 +#undef KEY_F20 +#undef KEY_F21 +#undef KEY_F22 +#undef KEY_F23 +#undef KEY_F24 + +// for compatibility with Leonardo's slightly different names +#undef KEY_UP_ARROW +#undef KEY_DOWN_ARROW +#undef KEY_LEFT_ARROW +#undef KEY_RIGHT_ARROW +#undef KEY_RETURN +#undef KEY_LEFT_CTRL +#undef KEY_LEFT_SHIFT +#undef KEY_LEFT_ALT +#undef KEY_LEFT_GUI +#undef KEY_RIGHT_CTRL +#undef KEY_RIGHT_SHIFT +#undef KEY_RIGHT_ALT +#undef KEY_RIGHT_GUI + +#undef ASCII_20 +#undef ASCII_21 +#undef ASCII_22 +#undef ASCII_23 +#undef ASCII_24 +#undef ASCII_25 +#undef ASCII_26 +#undef ASCII_27 +#undef ASCII_28 +#undef ASCII_29 +#undef ASCII_2A +#undef ASCII_2B +#undef ASCII_2C +#undef ASCII_2D +#undef ASCII_2E +#undef ASCII_2F +#undef ASCII_30 +#undef ASCII_31 +#undef ASCII_32 +#undef ASCII_33 +#undef ASCII_34 +#undef ASCII_35 +#undef ASCII_36 +#undef ASCII_37 +#undef ASCII_38 +#undef ASCII_39 +#undef ASCII_3A +#undef ASCII_3B +#undef ASCII_3C +#undef ASCII_3D +#undef ASCII_3E +#undef ASCII_3F +#undef ASCII_40 +#undef ASCII_41 +#undef ASCII_42 +#undef ASCII_43 +#undef ASCII_44 +#undef ASCII_45 +#undef ASCII_46 +#undef ASCII_47 +#undef ASCII_48 +#undef ASCII_49 +#undef ASCII_4A +#undef ASCII_4B +#undef ASCII_4C +#undef ASCII_4D +#undef ASCII_4E +#undef ASCII_4F +#undef ASCII_50 +#undef ASCII_51 +#undef ASCII_52 +#undef ASCII_53 +#undef ASCII_54 +#undef ASCII_55 +#undef ASCII_56 +#undef ASCII_57 +#undef ASCII_58 +#undef ASCII_59 +#undef ASCII_5A +#undef ASCII_5B +#undef ASCII_5C +#undef ASCII_5D +#undef ASCII_5E +#undef ASCII_5F +#undef ASCII_60 +#undef ASCII_61 +#undef ASCII_62 +#undef ASCII_63 +#undef ASCII_64 +#undef ASCII_65 +#undef ASCII_66 +#undef ASCII_67 +#undef ASCII_68 +#undef ASCII_69 +#undef ASCII_6A +#undef ASCII_6B +#undef ASCII_6C +#undef ASCII_6D +#undef ASCII_6E +#undef ASCII_6F +#undef ASCII_70 +#undef ASCII_71 +#undef ASCII_72 +#undef ASCII_73 +#undef ASCII_74 +#undef ASCII_75 +#undef ASCII_76 +#undef ASCII_77 +#undef ASCII_78 +#undef ASCII_79 +#undef ASCII_7A +#undef ASCII_7B +#undef ASCII_7C +#undef ASCII_7D +#undef ASCII_7E +#undef ASCII_7F + +#undef ISO_8859_1_A0 +#undef ISO_8859_1_A1 +#undef ISO_8859_1_A2 +#undef ISO_8859_1_A3 +#undef ISO_8859_1_A4 +#undef ISO_8859_1_A5 +#undef ISO_8859_1_A6 +#undef ISO_8859_1_A7 +#undef ISO_8859_1_A8 +#undef ISO_8859_1_A9 +#undef ISO_8859_1_AA +#undef ISO_8859_1_AB +#undef ISO_8859_1_AC +#undef ISO_8859_1_AD +#undef ISO_8859_1_AE +#undef ISO_8859_1_AF +#undef ISO_8859_1_B0 +#undef ISO_8859_1_B1 +#undef ISO_8859_1_B2 +#undef ISO_8859_1_B3 +#undef ISO_8859_1_B4 +#undef ISO_8859_1_B5 +#undef ISO_8859_1_B6 +#undef ISO_8859_1_B7 +#undef ISO_8859_1_B8 +#undef ISO_8859_1_B9 +#undef ISO_8859_1_BA +#undef ISO_8859_1_BB +#undef ISO_8859_1_BC +#undef ISO_8859_1_BD +#undef ISO_8859_1_BE +#undef ISO_8859_1_BF +#undef ISO_8859_1_C0 +#undef ISO_8859_1_C1 +#undef ISO_8859_1_C2 +#undef ISO_8859_1_C3 +#undef ISO_8859_1_C4 +#undef ISO_8859_1_C5 +#undef ISO_8859_1_C6 +#undef ISO_8859_1_C7 +#undef ISO_8859_1_C8 +#undef ISO_8859_1_C9 +#undef ISO_8859_1_CA +#undef ISO_8859_1_CB +#undef ISO_8859_1_CC +#undef ISO_8859_1_CD +#undef ISO_8859_1_CE +#undef ISO_8859_1_CF +#undef ISO_8859_1_D0 +#undef ISO_8859_1_D1 +#undef ISO_8859_1_D2 +#undef ISO_8859_1_D3 +#undef ISO_8859_1_D4 +#undef ISO_8859_1_D5 +#undef ISO_8859_1_D6 +#undef ISO_8859_1_D7 +#undef ISO_8859_1_D8 +#undef ISO_8859_1_D9 +#undef ISO_8859_1_DA +#undef ISO_8859_1_DB +#undef ISO_8859_1_DC +#undef ISO_8859_1_DD +#undef ISO_8859_1_DE +#undef ISO_8859_1_DF +#undef ISO_8859_1_E0 +#undef ISO_8859_1_E1 +#undef ISO_8859_1_E2 +#undef ISO_8859_1_E3 +#undef ISO_8859_1_E4 +#undef ISO_8859_1_E5 +#undef ISO_8859_1_E6 +#undef ISO_8859_1_E7 +#undef ISO_8859_1_E8 +#undef ISO_8859_1_E9 +#undef ISO_8859_1_EA +#undef ISO_8859_1_EB +#undef ISO_8859_1_EC +#undef ISO_8859_1_ED +#undef ISO_8859_1_EE +#undef ISO_8859_1_EF +#undef ISO_8859_1_F0 +#undef ISO_8859_1_F1 +#undef ISO_8859_1_F2 +#undef ISO_8859_1_F3 +#undef ISO_8859_1_F4 +#undef ISO_8859_1_F5 +#undef ISO_8859_1_F6 +#undef ISO_8859_1_F7 +#undef ISO_8859_1_F8 +#undef ISO_8859_1_F9 +#undef ISO_8859_1_FA +#undef ISO_8859_1_FB +#undef ISO_8859_1_FC +#undef ISO_8859_1_FD +#undef ISO_8859_1_FE +#undef ISO_8859_1_FF diff --git a/sdkconfig b/sdkconfig new file mode 100644 index 0000000..480c8fd --- /dev/null +++ b/sdkconfig @@ -0,0 +1,509 @@ +# +# Automatically generated file; DO NOT EDIT. +# Espressif IoT Development Framework Configuration +# + +# +# SDK tool configuration +# +CONFIG_TOOLPREFIX="xtensa-esp32-elf-" +CONFIG_PYTHON="python" +CONFIG_MAKE_WARN_UNDEFINED_VARIABLES=y + +# +# Bootloader config +# +CONFIG_LOG_BOOTLOADER_LEVEL_NONE= +CONFIG_LOG_BOOTLOADER_LEVEL_ERROR= +CONFIG_LOG_BOOTLOADER_LEVEL_WARN= +CONFIG_LOG_BOOTLOADER_LEVEL_INFO=y +CONFIG_LOG_BOOTLOADER_LEVEL_DEBUG= +CONFIG_LOG_BOOTLOADER_LEVEL_VERBOSE= +CONFIG_LOG_BOOTLOADER_LEVEL=3 +CONFIG_BOOTLOADER_VDDSDIO_BOOST=y + +# +# Security features +# +CONFIG_SECURE_BOOT_ENABLED= +CONFIG_FLASH_ENCRYPTION_ENABLED= + +# +# Serial flasher config +# +CONFIG_ESPTOOLPY_PORT="/dev/ttyUSB0" +CONFIG_ESPTOOLPY_BAUD_115200B= +CONFIG_ESPTOOLPY_BAUD_230400B= +CONFIG_ESPTOOLPY_BAUD_921600B=y +CONFIG_ESPTOOLPY_BAUD_2MB= +CONFIG_ESPTOOLPY_BAUD_OTHER= +CONFIG_ESPTOOLPY_BAUD_OTHER_VAL=115200 +CONFIG_ESPTOOLPY_BAUD=921600 +CONFIG_ESPTOOLPY_COMPRESSED=y +CONFIG_FLASHMODE_QIO= +CONFIG_FLASHMODE_QOUT= +CONFIG_FLASHMODE_DIO=y +CONFIG_FLASHMODE_DOUT= +CONFIG_ESPTOOLPY_FLASHMODE="dio" +CONFIG_ESPTOOLPY_FLASHFREQ_80M=y +CONFIG_ESPTOOLPY_FLASHFREQ_40M= +CONFIG_ESPTOOLPY_FLASHFREQ_26M= +CONFIG_ESPTOOLPY_FLASHFREQ_20M= +CONFIG_ESPTOOLPY_FLASHFREQ="80m" +CONFIG_ESPTOOLPY_FLASHSIZE_1MB= +CONFIG_ESPTOOLPY_FLASHSIZE_2MB= +CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y +CONFIG_ESPTOOLPY_FLASHSIZE_8MB= +CONFIG_ESPTOOLPY_FLASHSIZE_16MB= +CONFIG_ESPTOOLPY_FLASHSIZE="4MB" +CONFIG_ESPTOOLPY_FLASHSIZE_DETECT=y +CONFIG_ESPTOOLPY_BEFORE_RESET=y +CONFIG_ESPTOOLPY_BEFORE_NORESET= +CONFIG_ESPTOOLPY_BEFORE="default_reset" +CONFIG_ESPTOOLPY_AFTER_RESET=y +CONFIG_ESPTOOLPY_AFTER_NORESET= +CONFIG_ESPTOOLPY_AFTER="hard_reset" +CONFIG_MONITOR_BAUD_9600B= +CONFIG_MONITOR_BAUD_57600B= +CONFIG_MONITOR_BAUD_115200B=y +CONFIG_MONITOR_BAUD_230400B= +CONFIG_MONITOR_BAUD_921600B= +CONFIG_MONITOR_BAUD_2MB= +CONFIG_MONITOR_BAUD_OTHER= +CONFIG_MONITOR_BAUD_OTHER_VAL=115200 +CONFIG_MONITOR_BAUD=115200 + +# +# Partition Table +# +CONFIG_PARTITION_TABLE_SINGLE_APP=y +CONFIG_PARTITION_TABLE_TWO_OTA= +CONFIG_PARTITION_TABLE_CUSTOM= +CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv" +CONFIG_PARTITION_TABLE_CUSTOM_APP_BIN_OFFSET=0x10000 +CONFIG_PARTITION_TABLE_FILENAME="partitions_singleapp.csv" +CONFIG_APP_OFFSET=0x10000 + +# +# Compiler options +# +CONFIG_OPTIMIZATION_LEVEL_DEBUG=y +CONFIG_OPTIMIZATION_LEVEL_RELEASE= +CONFIG_OPTIMIZATION_ASSERTIONS_ENABLED=y +CONFIG_OPTIMIZATION_ASSERTIONS_SILENT= +CONFIG_OPTIMIZATION_ASSERTIONS_DISABLED= +CONFIG_CXX_EXCEPTIONS= + +# +# Component config +# + +# +# Application Level Tracing +# +CONFIG_ESP32_APPTRACE_DEST_TRAX= +CONFIG_ESP32_APPTRACE_DEST_NONE=y +CONFIG_ESP32_APPTRACE_ENABLE= +CONFIG_ESP32_APPTRACE_LOCK_ENABLE=y + +# +# FreeRTOS SystemView Tracing +# +CONFIG_AWS_IOT_SDK= + +# +# Bluetooth +# +CONFIG_BT_ENABLED=y +CONFIG_BTDM_CONTROLLER_PINNED_TO_CORE=0 +CONFIG_BTDM_CONTROLLER_HCI_MODE_VHCI=y +CONFIG_BTDM_CONTROLLER_HCI_MODE_UART_H4= +CONFIG_BLUEDROID_ENABLED=y +CONFIG_BLUEDROID_PINNED_TO_CORE=0 +CONFIG_BTC_TASK_STACK_SIZE=4096 +CONFIG_BLUEDROID_MEM_DEBUG= +CONFIG_CLASSIC_BT_ENABLED=y +CONFIG_GATTS_ENABLE=y +CONFIG_GATTC_ENABLE=y +CONFIG_BLE_SMP_ENABLE=y +CONFIG_BT_STACK_NO_LOG= +CONFIG_BT_ACL_CONNECTIONS=4 +CONFIG_SMP_ENABLE=y +CONFIG_BT_RESERVE_DRAM=0x10000 + +# +# ESP32-specific +# +CONFIG_ESP32_DEFAULT_CPU_FREQ_80= +CONFIG_ESP32_DEFAULT_CPU_FREQ_160=y +CONFIG_ESP32_DEFAULT_CPU_FREQ_240= +CONFIG_ESP32_DEFAULT_CPU_FREQ_MHZ=160 +CONFIG_MEMMAP_SMP=y +CONFIG_SPIRAM_SUPPORT= +CONFIG_MEMMAP_TRACEMEM= +CONFIG_MEMMAP_TRACEMEM_TWOBANKS= +CONFIG_ESP32_TRAX= +CONFIG_TRACEMEM_RESERVE_DRAM=0x0 +CONFIG_ESP32_ENABLE_COREDUMP_TO_FLASH= +CONFIG_ESP32_ENABLE_COREDUMP_TO_UART= +CONFIG_ESP32_ENABLE_COREDUMP_TO_NONE=y +CONFIG_ESP32_ENABLE_COREDUMP= +CONFIG_TWO_UNIVERSAL_MAC_ADDRESS= +CONFIG_FOUR_UNIVERSAL_MAC_ADDRESS=y +CONFIG_NUMBER_OF_UNIVERSAL_MAC_ADDRESS=4 +CONFIG_SYSTEM_EVENT_QUEUE_SIZE=32 +CONFIG_SYSTEM_EVENT_TASK_STACK_SIZE=4096 +CONFIG_MAIN_TASK_STACK_SIZE=4096 +CONFIG_IPC_TASK_STACK_SIZE=1024 +CONFIG_TIMER_TASK_STACK_SIZE=4096 +CONFIG_NEWLIB_STDOUT_LINE_ENDING_CRLF=y +CONFIG_NEWLIB_STDOUT_LINE_ENDING_LF= +CONFIG_NEWLIB_STDOUT_LINE_ENDING_CR= +CONFIG_NEWLIB_STDIN_LINE_ENDING_CRLF= +CONFIG_NEWLIB_STDIN_LINE_ENDING_LF= +CONFIG_NEWLIB_STDIN_LINE_ENDING_CR=y +CONFIG_NEWLIB_NANO_FORMAT= +CONFIG_CONSOLE_UART_DEFAULT=y +CONFIG_CONSOLE_UART_CUSTOM= +CONFIG_CONSOLE_UART_NONE= +CONFIG_CONSOLE_UART_NUM=0 +CONFIG_CONSOLE_UART_BAUDRATE=115200 +CONFIG_ULP_COPROC_ENABLED= +CONFIG_ULP_COPROC_RESERVE_MEM=0 +CONFIG_ESP32_PANIC_PRINT_HALT= +CONFIG_ESP32_PANIC_PRINT_REBOOT=y +CONFIG_ESP32_PANIC_SILENT_REBOOT= +CONFIG_ESP32_PANIC_GDBSTUB= +CONFIG_ESP32_DEBUG_OCDAWARE=y +CONFIG_INT_WDT=y +CONFIG_INT_WDT_TIMEOUT_MS=300 +CONFIG_TASK_WDT=y +CONFIG_TASK_WDT_PANIC= +CONFIG_TASK_WDT_TIMEOUT_S=5 +CONFIG_TASK_WDT_CHECK_IDLE_TASK_CPU0=y +CONFIG_BROWNOUT_DET=y +CONFIG_BROWNOUT_DET_LVL_SEL_0=y +CONFIG_BROWNOUT_DET_LVL_SEL_1= +CONFIG_BROWNOUT_DET_LVL_SEL_2= +CONFIG_BROWNOUT_DET_LVL_SEL_3= +CONFIG_BROWNOUT_DET_LVL_SEL_4= +CONFIG_BROWNOUT_DET_LVL_SEL_5= +CONFIG_BROWNOUT_DET_LVL_SEL_6= +CONFIG_BROWNOUT_DET_LVL_SEL_7= +CONFIG_BROWNOUT_DET_LVL=0 +CONFIG_ESP32_TIME_SYSCALL_USE_RTC= +CONFIG_ESP32_TIME_SYSCALL_USE_RTC_FRC1=y +CONFIG_ESP32_TIME_SYSCALL_USE_FRC1= +CONFIG_ESP32_TIME_SYSCALL_USE_NONE= +CONFIG_ESP32_RTC_CLOCK_SOURCE_INTERNAL_RC=y +CONFIG_ESP32_RTC_CLOCK_SOURCE_EXTERNAL_CRYSTAL= +CONFIG_ESP32_RTC_CLK_CAL_CYCLES=1024 +CONFIG_ESP32_DEEP_SLEEP_WAKEUP_DELAY=0 +CONFIG_ESP32_XTAL_FREQ_40= +CONFIG_ESP32_XTAL_FREQ_26=y +CONFIG_ESP32_XTAL_FREQ_AUTO= +CONFIG_ESP32_XTAL_FREQ=26 +CONFIG_DISABLE_BASIC_ROM_CONSOLE= + +# +# Wi-Fi +# +CONFIG_SW_COEXIST_ENABLE= +CONFIG_ESP32_WIFI_STATIC_RX_BUFFER_NUM=10 +CONFIG_ESP32_WIFI_DYNAMIC_RX_BUFFER_NUM=0 +CONFIG_ESP32_WIFI_STATIC_TX_BUFFER= +CONFIG_ESP32_WIFI_DYNAMIC_TX_BUFFER=y +CONFIG_ESP32_WIFI_TX_BUFFER_TYPE=1 +CONFIG_ESP32_WIFI_DYNAMIC_TX_BUFFER_NUM=32 +CONFIG_ESP32_WIFI_AMPDU_ENABLED=y +CONFIG_ESP32_WIFI_TX_BA_WIN=6 +CONFIG_ESP32_WIFI_RX_BA_WIN=6 +CONFIG_ESP32_WIFI_NVS_ENABLED=y + +# +# PHY +# +CONFIG_ESP32_PHY_CALIBRATION_AND_DATA_STORAGE=y +CONFIG_ESP32_PHY_INIT_DATA_IN_PARTITION= +CONFIG_ESP32_PHY_MAX_WIFI_TX_POWER=20 +CONFIG_ESP32_PHY_MAX_TX_POWER=20 + +# +# Power Management +# +CONFIG_PM_ENABLE= + +# +# Ethernet +# +CONFIG_DMA_RX_BUF_NUM=10 +CONFIG_DMA_TX_BUF_NUM=10 +CONFIG_EMAC_L2_TO_L3_RX_BUF_MODE= +CONFIG_EMAC_TASK_PRIORITY=20 + +# +# FAT Filesystem support +# +CONFIG_FATFS_CODEPAGE_ASCII=y +CONFIG_FATFS_CODEPAGE_437= +CONFIG_FATFS_CODEPAGE_720= +CONFIG_FATFS_CODEPAGE_737= +CONFIG_FATFS_CODEPAGE_771= +CONFIG_FATFS_CODEPAGE_775= +CONFIG_FATFS_CODEPAGE_850= +CONFIG_FATFS_CODEPAGE_852= +CONFIG_FATFS_CODEPAGE_855= +CONFIG_FATFS_CODEPAGE_857= +CONFIG_FATFS_CODEPAGE_860= +CONFIG_FATFS_CODEPAGE_861= +CONFIG_FATFS_CODEPAGE_862= +CONFIG_FATFS_CODEPAGE_863= +CONFIG_FATFS_CODEPAGE_864= +CONFIG_FATFS_CODEPAGE_865= +CONFIG_FATFS_CODEPAGE_866= +CONFIG_FATFS_CODEPAGE_869= +CONFIG_FATFS_CODEPAGE_932= +CONFIG_FATFS_CODEPAGE_936= +CONFIG_FATFS_CODEPAGE_949= +CONFIG_FATFS_CODEPAGE_950= +CONFIG_FATFS_CODEPAGE=1 +CONFIG_FATFS_MAX_LFN=255 + +# +# FreeRTOS +# +CONFIG_FREERTOS_UNICORE=y +CONFIG_FREERTOS_CORETIMER_0=y +CONFIG_FREERTOS_CORETIMER_1= +CONFIG_FREERTOS_HZ=100 +CONFIG_FREERTOS_ASSERT_ON_UNTESTED_FUNCTION=y +CONFIG_FREERTOS_CHECK_STACKOVERFLOW_NONE= +CONFIG_FREERTOS_CHECK_STACKOVERFLOW_PTRVAL= +CONFIG_FREERTOS_CHECK_STACKOVERFLOW_CANARY=y +CONFIG_FREERTOS_WATCHPOINT_END_OF_STACK= +CONFIG_FREERTOS_INTERRUPT_BACKTRACE=y +CONFIG_FREERTOS_THREAD_LOCAL_STORAGE_POINTERS=1 +CONFIG_FREERTOS_ASSERT_FAIL_ABORT=y +CONFIG_FREERTOS_ASSERT_FAIL_PRINT_CONTINUE= +CONFIG_FREERTOS_ASSERT_DISABLE= +CONFIG_FREERTOS_IDLE_TASK_STACKSIZE=1024 +CONFIG_FREERTOS_ISR_STACKSIZE=1536 +CONFIG_FREERTOS_LEGACY_HOOKS= +CONFIG_FREERTOS_MAX_TASK_NAME_LEN=16 +CONFIG_SUPPORT_STATIC_ALLOCATION= +CONFIG_TIMER_TASK_PRIORITY=1 +CONFIG_TIMER_TASK_STACK_DEPTH=2048 +CONFIG_TIMER_QUEUE_LENGTH=10 +CONFIG_FREERTOS_USE_TRACE_FACILITY= +CONFIG_FREERTOS_DEBUG_INTERNALS= + +# +# Heap memory debugging +# +CONFIG_HEAP_POISONING_DISABLED=y +CONFIG_HEAP_POISONING_LIGHT= +CONFIG_HEAP_POISONING_COMPREHENSIVE= +CONFIG_HEAP_TRACING= + +# +# libsodium +# + +# +# Log output +# +CONFIG_LOG_DEFAULT_LEVEL_NONE= +CONFIG_LOG_DEFAULT_LEVEL_ERROR= +CONFIG_LOG_DEFAULT_LEVEL_WARN= +CONFIG_LOG_DEFAULT_LEVEL_INFO=y +CONFIG_LOG_DEFAULT_LEVEL_DEBUG= +CONFIG_LOG_DEFAULT_LEVEL_VERBOSE= +CONFIG_LOG_DEFAULT_LEVEL=3 +CONFIG_LOG_COLORS=y + +# +# LWIP +# +CONFIG_L2_TO_L3_COPY= +CONFIG_LWIP_MAX_SOCKETS=10 +CONFIG_LWIP_SO_REUSE=y +CONFIG_LWIP_SO_REUSE_RXTOALL=y +CONFIG_LWIP_SO_RCVBUF= +CONFIG_LWIP_DHCP_MAX_NTP_SERVERS=1 +CONFIG_LWIP_IP_FRAG= +CONFIG_LWIP_IP_REASSEMBLY= +CONFIG_LWIP_STATS= +CONFIG_LWIP_ETHARP_TRUST_IP_MAC=y +CONFIG_TCPIP_RECVMBOX_SIZE=32 +CONFIG_LWIP_DHCP_DOES_ARP_CHECK=y +CONFIG_LWIP_AUTOIP= +CONFIG_LWIP_NETIF_LOOPBACK=y +CONFIG_LWIP_LOOPBACK_MAX_PBUFS=8 + +# +# TCP +# +CONFIG_TCP_MAXRTX=12 +CONFIG_TCP_SYNMAXRTX=6 +CONFIG_TCP_MSS=1436 +CONFIG_TCP_MSL=60000 +CONFIG_TCP_SND_BUF_DEFAULT=5744 +CONFIG_TCP_WND_DEFAULT=5744 +CONFIG_TCP_RECVMBOX_SIZE=6 +CONFIG_TCP_QUEUE_OOSEQ=y +CONFIG_TCP_OVERSIZE_MSS=y +CONFIG_TCP_OVERSIZE_QUARTER_MSS= +CONFIG_TCP_OVERSIZE_DISABLE= + +# +# UDP +# +CONFIG_UDP_RECVMBOX_SIZE=6 +CONFIG_TCPIP_TASK_STACK_SIZE=2560 +CONFIG_PPP_SUPPORT= + +# +# ICMP +# +CONFIG_LWIP_MULTICAST_PING= +CONFIG_LWIP_BROADCAST_PING= + +# +# mbedTLS +# +CONFIG_MBEDTLS_SSL_MAX_CONTENT_LEN=16384 +CONFIG_MBEDTLS_DEBUG= +CONFIG_MBEDTLS_HARDWARE_AES=y +CONFIG_MBEDTLS_HARDWARE_MPI=y +CONFIG_MBEDTLS_MPI_USE_INTERRUPT=y +CONFIG_MBEDTLS_HARDWARE_SHA=y +CONFIG_MBEDTLS_HAVE_TIME=y +CONFIG_MBEDTLS_HAVE_TIME_DATE= +CONFIG_MBEDTLS_TLS_SERVER_AND_CLIENT=y +CONFIG_MBEDTLS_TLS_SERVER_ONLY= +CONFIG_MBEDTLS_TLS_CLIENT_ONLY= +CONFIG_MBEDTLS_TLS_DISABLED= +CONFIG_MBEDTLS_TLS_SERVER=y +CONFIG_MBEDTLS_TLS_CLIENT=y +CONFIG_MBEDTLS_TLS_ENABLED=y + +# +# TLS Key Exchange Methods +# +CONFIG_MBEDTLS_PSK_MODES= +CONFIG_MBEDTLS_KEY_EXCHANGE_RSA=y +CONFIG_MBEDTLS_KEY_EXCHANGE_DHE_RSA=y +CONFIG_MBEDTLS_KEY_EXCHANGE_ELLIPTIC_CURVE=y +CONFIG_MBEDTLS_KEY_EXCHANGE_ECDHE_RSA=y +CONFIG_MBEDTLS_KEY_EXCHANGE_ECDHE_ECDSA=y +CONFIG_MBEDTLS_KEY_EXCHANGE_ECDH_ECDSA=y +CONFIG_MBEDTLS_KEY_EXCHANGE_ECDH_RSA=y +CONFIG_MBEDTLS_SSL_RENEGOTIATION=y +CONFIG_MBEDTLS_SSL_PROTO_SSL3= +CONFIG_MBEDTLS_SSL_PROTO_TLS1=y +CONFIG_MBEDTLS_SSL_PROTO_TLS1_1=y +CONFIG_MBEDTLS_SSL_PROTO_TLS1_2=y +CONFIG_MBEDTLS_SSL_PROTO_DTLS= +CONFIG_MBEDTLS_SSL_ALPN=y +CONFIG_MBEDTLS_SSL_SESSION_TICKETS=y + +# +# Symmetric Ciphers +# +CONFIG_MBEDTLS_AES_C=y +CONFIG_MBEDTLS_CAMELLIA_C= +CONFIG_MBEDTLS_DES_C= +CONFIG_MBEDTLS_RC4_DISABLED=y +CONFIG_MBEDTLS_RC4_ENABLED_NO_DEFAULT= +CONFIG_MBEDTLS_RC4_ENABLED= +CONFIG_MBEDTLS_BLOWFISH_C= +CONFIG_MBEDTLS_XTEA_C= +CONFIG_MBEDTLS_CCM_C=y +CONFIG_MBEDTLS_GCM_C=y +CONFIG_MBEDTLS_RIPEMD160_C= + +# +# Certificates +# +CONFIG_MBEDTLS_PEM_PARSE_C=y +CONFIG_MBEDTLS_PEM_WRITE_C=y +CONFIG_MBEDTLS_X509_CRL_PARSE_C=y +CONFIG_MBEDTLS_X509_CSR_PARSE_C=y +CONFIG_MBEDTLS_ECP_C=y +CONFIG_MBEDTLS_ECDH_C=y +CONFIG_MBEDTLS_ECDSA_C=y +CONFIG_MBEDTLS_ECP_DP_SECP192R1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_SECP224R1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_SECP256R1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_SECP384R1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_SECP521R1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_SECP192K1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_SECP224K1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_SECP256K1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_BP256R1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_BP384R1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_BP512R1_ENABLED=y +CONFIG_MBEDTLS_ECP_DP_CURVE25519_ENABLED=y +CONFIG_MBEDTLS_ECP_NIST_OPTIM=y + +# +# OpenSSL +# +CONFIG_OPENSSL_DEBUG= +CONFIG_OPENSSL_ASSERT_DO_NOTHING=y +CONFIG_OPENSSL_ASSERT_EXIT= + +# +# PThreads +# +CONFIG_ESP32_PTHREAD_TASK_PRIO_DEFAULT=5 +CONFIG_ESP32_PTHREAD_TASK_STACK_SIZE_DEFAULT=2048 + +# +# SPI Flash driver +# +CONFIG_SPI_FLASH_ENABLE_COUNTERS= +CONFIG_SPI_FLASH_ROM_DRIVER_PATCH=y +CONFIG_SPI_FLASH_WRITING_DANGEROUS_REGIONS_ABORTS=y +CONFIG_SPI_FLASH_WRITING_DANGEROUS_REGIONS_FAILS= +CONFIG_SPI_FLASH_WRITING_DANGEROUS_REGIONS_ALLOWED= + +# +# SPIFFS Configuration +# +CONFIG_SPIFFS_MAX_PARTITIONS=3 + +# +# SPIFFS Cache Configuration +# +CONFIG_SPIFFS_CACHE=y +CONFIG_SPIFFS_CACHE_WR=y +CONFIG_SPIFFS_CACHE_STATS= +CONFIG_SPIFFS_PAGE_CHECK=y +CONFIG_SPIFFS_GC_MAX_RUNS=10 +CONFIG_SPIFFS_GC_STATS= +CONFIG_SPIFFS_OBJ_NAME_LEN=32 +CONFIG_SPIFFS_USE_MAGIC=y +CONFIG_SPIFFS_USE_MAGIC_LENGTH=y + +# +# Debug Configuration +# +CONFIG_SPIFFS_DBG= +CONFIG_SPIFFS_API_DBG= +CONFIG_SPIFFS_GC_DBG= +CONFIG_SPIFFS_CACHE_DBG= +CONFIG_SPIFFS_CHECK_DBG= +CONFIG_SPIFFS_TEST_VISUALISATION= + +# +# tcpip adapter +# +CONFIG_IP_LOST_TIMER_INTERVAL=120 + +# +# Wear Levelling +# +CONFIG_WL_SECTOR_SIZE_512= +CONFIG_WL_SECTOR_SIZE_4096=y +CONFIG_WL_SECTOR_SIZE=4096