samples.xml

<?xml version="1.0"?>
<root>
  <item>
    <name>Samples for Karabiner Binding Developers</name>
    <appendix>defined in .../include/checkbox/samples.xml</appendix>
    <item>
      <name>SetKeyboardType</name>
      <appendix>Showing __SetKeyboardType__ and KeyboardType::*</appendix>
      <item>
        <identifier>remap.samples_setkeyboardtype_macbook</identifier>
        <name>Set keyboardType = KeyboardType::MACBOOK</name>
        <autogen>__SetKeyboardType__ KeyboardType::MACBOOK</autogen>
      </item>
      <item>
        <identifier>remap.samples_setkeyboardtype_macbook_3_1</identifier>
        <name>Set keyboardType = KeyboardType::MACBOOK_3_1</name>
        <autogen>__SetKeyboardType__ KeyboardType::MACBOOK_3_1</autogen>
      </item>
      <item>
        <identifier>remap.samples_setkeyboardtype_jis_macbook_2008</identifier>
        <name>Set keyboardType = KeyboardType::JIS_MACBOOK_2008</name>
        <autogen>__SetKeyboardType__ KeyboardType::JIS_MACBOOK_2008</autogen>
      </item>
      <item>
        <identifier>remap.samples_setkeyboardtype_jis_macbook_2008_terminal</identifier>
        <name>Set keyboardType = KeyboardType::JIS_MACBOOK_2008 on Terminal.app</name>
        <only>TERMINAL</only>
        <autogen>__SetKeyboardType__ KeyboardType::JIS_MACBOOK_2008</autogen>
      </item>
    </item>

    <item>
      <name>Pass Through Mode</name>
      <appendix>(To "pass through" means to turn off further remapping.)</appendix>
      <item>
        <identifier>passthrough.samples</identifier>
        <name>Core - Toggle Passthrough</name>
        <appendix>Change A to toggle "Pass Through Mode"</appendix>
        <autogen>
          __KeyToKey__
          KeyCode::A,
          KeyCode::VK_CONFIG_TOGGLE_notsave_passthrough,
          Option::IGNORE_PASSTHROUGH,
        </autogen>
      </item>
      <item>
        <identifier>remap.samples_passthrough</identifier>
        <name>Mapping Samples</name>
        <appendix>(mappings to test passthrough)</appendix>
        <appendix></appendix>
        <autogen>__ShowStatusMessage__ Mapping Samples Active</autogen>

        <appendix>B to C (using __KeyToKey__ and KeyCode::*)</appendix>
        <appendix></appendix>
        <autogen>__KeyToKey__ KeyCode::B, KeyCode::C</autogen>

        <appendix>Volume Mute to A (using ConsumerKeyCode::VOLUME_MUTE)</appendix>
        <appendix></appendix>
        <autogen>__KeyToKey__ ConsumerKeyCode::VOLUME_MUTE, KeyCode::A</autogen>

        <appendix>RightClick+CursorMove to ScrollWheel</appendix>
        <appendix>(using __PointingRelativeToScroll__ and PointingButton::*</appendix>
        <appendix></appendix>
        <autogen>__PointingRelativeToScroll__ PointingButton::RIGHT</autogen>

        <appendix>Hold left click to open Mission Control</appendix>
        <appendix>(using __HoldingKeyToKey__, KeyCode::MISSION_CONTROL, NOREPEAT)</appendix>
        <appendix></appendix>
        <autogen>
          __HoldingKeyToKey__
          PointingButton::LEFT,
          @begin
          PointingButton::LEFT,
          @end
          @begin
          KeyCode::MISSION_CONTROL,
          KeyCode::VK_NONE,
          Option::NOREPEAT,
          @end
        </autogen>

        <appendix>Simultaneous Key Presses [D+F] to Escape</appendix>
        <appendix>(using __SimultaneousKeyPresses__)</appendix>
        <autogen>__SimultaneousKeyPresses__ KeyCode::F, KeyCode::D, KeyCode::ESCAPE</autogen>
      </item>
      <item>
        <identifier>remap.samples_passthrough_terminal</identifier>
        <name>Disable all settings while you are using Terminal.</name>
        <appendix>(using __PassThrough__ and only)</appendix>
        <only>TERMINAL</only>
        <autogen>__PassThrough__</autogen>
      </item>
      <item>
        <identifier>remap.samples_passthrough_apple_devices</identifier>
        <name>Disable all settings on Apple keyboards and pointing devices.</name>
        <appendix>(using device_only, DeviceVendor::*, DeviceProduct::*)</appendix>
        <device_only>DeviceVendor::APPLE_INC, DeviceProduct::ANY</device_only>
        <autogen>__PassThrough__</autogen>
      </item>
    </item>

    <item>
      <name>ShowStatusMessage</name>
      <appendix>(show a message box, usually in lower right corner)</appendix>
      <item>
        <identifier>remap.samples_showstatusmessage_sample1</identifier>
        <name>Sample1</name>
        <appendix>(using __ShowStatusMessage__)</appendix>
        <!--
            Note:
            __ShowStatusMessage__ ignores all filters. (eg: `only`, `not`, etc)
            It always shows the message when it is enabled.
        -->
        <autogen>__ShowStatusMessage__ Sample1</autogen>
      </item>
      <item>
        <identifier>remap.samples_showstatusmessage_sample2</identifier>
        <name>Sample2</name>
        <appendix>(shares box with Sample1 if both selected)</appendix>
        <autogen>__ShowStatusMessage__ Sample2</autogen>
      </item>
      <item>
        <identifier>remap.samples_showstatusmessage_longmessage</identifier>
        <name>A Long Message Taking Up Most Box Space</name>
        <appendix>(shares box with Sample1 if both selected)</appendix>
        <autogen>__ShowStatusMessage__ A Long Message Taking Up Most Box Space</autogen>
      </item>
      <item>
        <identifier>remap.samples_showstatusmessage_multilinemessage</identifier>
        <name>A Multiline Message Over Two Lines</name>
        <autogen>__ShowStatusMessage__ A Multiline Message Over
Two Lines</autogen>
      </item>
      <item>
        <identifier>remap.samples_showstatusmessage_sample3</identifier>
        <name>Sample3</name>
        <appendix>(cannot see if box is full)</appendix>
        <autogen>__ShowStatusMessage__ Sample3</autogen>
      </item>
      <item>
        <identifier>remap.samples_showstatusmessage_empty</identifier>
        <name>(Empty)</name>
        <appendix>(diplays box even when no other message active)</appendix>
        <autogen>__ShowStatusMessage__</autogen>
      </item>
      <item>
        <identifier>remap.samples_showstatusmessage_lock_sticky</identifier>
        <name>Lock modifiers and Sticky</name>
        <appendix>
          <![CDATA[
                   (See modifiers if Preferences pane->Status Message tab->Show Sticky Modifiers is checked)
          ]]>
        </appendix>
        <appendix>Q to Lock Control_L</appendix>
        <appendix>W to Lock Left Button</appendix>
        <appendix>E to Sticky Shift_L</appendix>
        <autogen>__KeyToKey__ KeyCode::Q, KeyCode::VK_LOCK_CONTROL_L</autogen>
        <autogen>__KeyToKey__ KeyCode::W, KeyCode::VK_MOUSEKEY_LOCK_BUTTON_LEFT</autogen>
        <autogen>__KeyToKey__ KeyCode::E, KeyCode::VK_STICKY_SHIFT_L</autogen>
      </item>
    </item>

    <item>
      <name>KeyToKey</name>
      <item>
        <identifier>remap.samples_keytokey_standard</identifier>
        <name>Standard Remappings</name>
        <appendix>(using __KeyToKey__ and KeyCode::*)</appendix>
        <appendix>A to B</appendix>
        <appendix>S to SHIFT_L</appendix>
        <appendix>SHIFT_L to Return</appendix>
        <appendix>Option_L to Command_L</appendix>
        <autogen>__KeyToKey__ KeyCode::A, KeyCode::B</autogen>
        <autogen>__KeyToKey__ KeyCode::S, KeyCode::SHIFT_L</autogen>
        <autogen>__KeyToKey__ KeyCode::SHIFT_L, KeyCode::RETURN</autogen>
        <autogen>__KeyToKey__ KeyCode::OPTION_L, KeyCode::COMMAND_L</autogen>
      </item>

      <item>
        <identifier>remap.samples_keytokey_right_left</identifier>
        <name>MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT</name>
        <appendix>Map A+(SHIFT_L or SHIFT_R) to B</appendix>
        <appendix>MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT is alias to</appendix>
        <appendix>ModifierFlag::SHIFT_L and ModifierFlag::SHIFT_R</appendix>
        <appendix>+--------------------------------------------</appendix>
        <appendix>|  &lt;autogen&gt;</appendix>
        <appendix>|    __KeyToKey__</appendix>
        <appendix>|    KeyCode::A, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT,</appendix>
        <appendix>|    KeyCode::B,</appendix>
        <appendix>|  &lt;/autogen&gt;</appendix>
        <appendix>+--------------------------------------------</appendix>
        <appendix>==&gt; __KeyToKey__ KeyCode::A, ModifierFlag::SHIFT_L, KeyCode::B</appendix>
        <appendix>==&gt; __KeyToKey__ KeyCode::A, ModifierFlag::SHIFT_R, KeyCode::B</appendix>
        <autogen>__KeyToKey__ KeyCode::A, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT, KeyCode::B</autogen>
      </item>
      <item>
        <identifier>remap.samples_keytokey_modifier_any</identifier>
        <name>MODIFIERFLAGS_ANY</name>
        <appendix>Map C+(any modifier keys) to D+(those same modifier keys) then E</appendix>
        <appendix>Multiple MODIFIERFLAG_* in one definition are replaced with same value.</appendix>
        <appendix>+--------------------------------------------</appendix>
        <appendix>|  &lt;autogen&gt;</appendix>
        <appendix>|    __KeyToKey__</appendix>
        <appendix>|    KeyCode::C, MODIFIERFLAGS_ANY,</appendix>
        <appendix>|    KeyCode::D, MODIFIERFLAGS_ANY,</appendix>
        <appendix>|    KeyCode::E,</appendix>
        <appendix>|  &lt;/autogen&gt;</appendix>
        <appendix>+--------------------------------------------</appendix>
        <appendix>==&gt; 2 MODIFIERFLAGS_ANYs are replaced to ModifierFlag::COMMAND_L</appendix>
        <appendix>==&gt; 2 MODIFIERFLAGS_ANYs are replaced to ModifierFlag::COMMAND_R</appendix>
        <appendix>==&gt; ... replaced to ModifierFlag::CONTROL_L</appendix>
        <appendix>==&gt; ... replaced to ModifierFlag::CONTROL_R</appendix>
        <appendix>==&gt; ... replaced to ModifierFlag::COMMAND_L|ModifierFlag::CONTROL_L</appendix>
        <appendix>==&gt; ...</appendix>
        <autogen>__KeyToKey__ KeyCode::C, MODIFIERFLAGS_ANY, KeyCode::D, MODIFIERFLAGS_ANY, KeyCode::E</autogen>
      </item>

      <item>
        <identifier>remap.samples_keytokey_key2xxx</identifier>
        <name>Key To Key with Modifier Flags</name>
        <appendix>A to Shift_L+B (Key to Key+Modifier)</appendix>
        <autogen>__KeyToKey__ KeyCode::A, KeyCode::B, ModifierFlag::SHIFT_L</autogen>

        <appendix>B to Command_L+Shift_L (Key to Modifier+Modifier)</appendix>
        <autogen>__KeyToKey__ KeyCode::B, KeyCode::COMMAND_L, ModifierFlag::SHIFT_L</autogen>


        <appendix>Shift+C to Space (Key+Modifier To Key)</appendix>
        <autogen>__KeyToKey__ KeyCode::C, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT, KeyCode::SPACE</autogen>

        <appendix>Shift+D to Option_L (Key+Modifier To Modifier)</appendix>
        <autogen>__KeyToKey__ KeyCode::D, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT, KeyCode::OPTION_L</autogen>

        <appendix>Shift+E to Control_L+Space (Key+Modifier To Key+Modifier)</appendix>
        <autogen>__KeyToKey__ KeyCode::E, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT, KeyCode::SPACE, ModifierFlag::CONTROL_L</autogen>

        <appendix>Shift+F to Option_L+Shift_L (Key+Modifier To Modifier+Modifier)</appendix>
        <autogen>__KeyToKey__ KeyCode::F, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT, KeyCode::SHIFT_L, ModifierFlag::OPTION_L</autogen>

        <appendix>G to CapsLock (To CapsLock)</appendix>
        <autogen>__KeyToKey__ KeyCode::G, KeyCode::CAPSLOCK</autogen>

        <appendix>Shift+Control+H to Option_L+Space</appendix>
        <autogen>__KeyToKey__ KeyCode::H, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_CONTROL | MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT, KeyCode::SPACE, ModifierFlag::OPTION_L</autogen>

        <appendix>Fn+hjkl to Left/Down/Up/Right (Key+Fn to Key) (around KeyPad)</appendix>
        <autogen>__KeyToKey__ KeyCode::H, ModifierFlag::FN, KeyCode::CURSOR_LEFT</autogen>
        <autogen>__KeyToKey__ KeyCode::J, ModifierFlag::FN, KeyCode::CURSOR_DOWN</autogen>
        <autogen>__KeyToKey__ KeyCode::K, ModifierFlag::FN, KeyCode::CURSOR_UP</autogen>
        <autogen>__KeyToKey__ KeyCode::L, ModifierFlag::FN, KeyCode::CURSOR_RIGHT</autogen>

        <appendix>S to Shift_L+Shift_R</appendix>
        <autogen>__KeyToKey__ KeyCode::S, KeyCode::SHIFT_R, ModifierFlag::SHIFT_L</autogen>

        <appendix>1 to A (only if no Modifiers)</appendix>
        <autogen>__KeyToKey__ KeyCode::KEY_1, ModifierFlag::NONE, KeyCode::A</autogen>

        <appendix>2 to A (only if Shift_L is only modifier)</appendix>
        <autogen>__KeyToKey__ KeyCode::KEY_2, ModifierFlag::SHIFT_L | ModifierFlag::NONE, KeyCode::A</autogen>

        <appendix>Command+Volume Down to Space (if no other modifiers pressed)</appendix>
        <autogen>
          __KeyToKey__
          ConsumerKeyCode::VOLUME_DOWN, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_COMMAND | ModifierFlag::NONE,
          KeyCode::SPACE,
        </autogen>

        <appendix>RightClick to CapsLock,A</appendix>
        <autogen>
          __KeyToKey__
          <!-- from -->
          PointingButton::RIGHT,
          <!-- to -->
          KeyCode::CAPSLOCK,
          KeyCode::A,
        </autogen>
      </item>

      <item>
        <identifier>remap.samples_keytokey_key2xxx_2</identifier>
        <name>Key To Key with Multiple Modifiers</name>
        <appendix>Option+A to Command_L+Shift_L+Tab</appendix>
        <appendix>Option+S to Command_L+Tab</appendix>
        <autogen>__KeyToKey__ KeyCode::A, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_OPTION, KeyCode::TAB, ModifierFlag::COMMAND_L | ModifierFlag::SHIFT_L</autogen>
        <autogen>__KeyToKey__ KeyCode::S, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_OPTION, KeyCode::TAB, ModifierFlag::COMMAND_L</autogen>
      </item>

      <item>
        <identifier>remap.samples_keytokey_key2xxx_3</identifier>
        <name>Key To Key with Capslock</name>
        <appendix>A to CapsLock</appendix>
        <autogen>__KeyToKey__ KeyCode::A,                               KeyCode::CAPSLOCK</autogen>

        <appendix>CapsLock+S to Shift_L+1</appendix>
        <autogen>__KeyToKey__ KeyCode::S,       ModifierFlag::CAPSLOCK, KeyCode::KEY_1, ModifierFlag::SHIFT_L</autogen>

        <appendix>CapsLock+O to Option_L+2</appendix>
        <autogen>__KeyToKey__ KeyCode::O,       ModifierFlag::CAPSLOCK, KeyCode::KEY_2, ModifierFlag::OPTION_L</autogen>

        <appendix>CapsLock+C to Command_L+3</appendix>
        <autogen>__KeyToKey__ KeyCode::C,       ModifierFlag::CAPSLOCK, KeyCode::KEY_3, ModifierFlag::COMMAND_L</autogen>

        <appendix></appendix>
        <appendix>Change Shift_L key to turning CapsLock off</appendix>
        <appendix>(Retain Shift_L movement when CapsLock is off)</appendix>
        <autogen>__KeyToKey__ KeyCode::SHIFT_L, ModifierFlag::CAPSLOCK, KeyCode::CAPSLOCK, KeyCode::VK_NONE</autogen>

        <appendix></appendix>
        <appendix>Change Shift_R key to turning CapsLock off</appendix>
        <appendix>(Retain Shift_R movement at all times)</appendix>
        <block>
          <modifier_only>ModifierFlag::CAPSLOCK</modifier_only>
          <autogen>__KeyToKey__ KeyCode::SHIFT_R, KeyCode::CAPSLOCK, KeyCode::SHIFT_R</autogen>
        </block>
      </item>

      <item>
        <identifier>remap.samples_keytokey_key2xxx_4</identifier>
        <name>Key To Key with Shift</name>
        <appendix>A to Shift_L</appendix>
        <appendix>Shift_L+A to B</appendix>
        <autogen>__KeyToKey__ KeyCode::A, ModifierFlag::SHIFT_L, KeyCode::B</autogen>
        <autogen>__KeyToKey__ KeyCode::A,                        KeyCode::SHIFT_L</autogen>
      </item>

      <item>
        <identifier>remap.samples_keytokey_modifier2xxx</identifier>
        <name>Modifiers To Modifiers</name>
        <appendix>Shift_R to Command_L+Option_L (Modifier to Modifier+Modifier)</appendix>
        <appendix>Fn+Option_L to Command_L (Modifier+Modifier To Modifier)</appendix>
        <autogen>__KeyToKey__ KeyCode::SHIFT_R, KeyCode::COMMAND_L, ModifierFlag::OPTION_L</autogen>
        <autogen>__KeyToKey__ KeyCode::OPTION_L, ModifierFlag::FN, KeyCode::COMMAND_L</autogen>
      </item>

      <item>
        <identifier>remap.samples_keytokey_interactions</identifier>
        <name>Key to Key interactions between mappings.</name>
        <appendix>(These are best understood by watching the result in EventViewer)</appendix>
        <appendix></appendix>

        <appendix>Shift_L to Shift_L (if no other modifiers pressed)</appendix>
        <appendix></appendix>
        <autogen>__KeyToKey__ KeyCode::SHIFT_L, ModifierFlag::SHIFT_L | ModifierFlag::NONE, KeyCode::SHIFT_L</autogen>

        <appendix>Shift_L to Command_L</appendix>
        <appendix>(but only with other modifiers because Shift_L by itself grabbed by above)</appendix>
        <appendix></appendix>
        <autogen>__KeyToKey__ KeyCode::SHIFT_L, KeyCode::COMMAND_L</autogen>

        <appendix>Shift+A to B</appendix>
        <appendix>(including Shift_L+A but Control+L_shift+A gives control+command+a)</appendix>
        <appendix></appendix>
        <autogen>__KeyToKey__ KeyCode::A, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT, KeyCode::B</autogen>

        <appendix>Shift_R to Shift_R+A (if no other modifiers pressed)</appendix>
        <appendix></appendix>
        <autogen>__KeyToKey__ KeyCode::SHIFT_R, ModifierFlag::SHIFT_R | ModifierFlag::NONE, KeyCode::A, ModifierFlag::SHIFT_R</autogen>

        <appendix>Command_L+Command_R to Command_L+Command_R (if no other modifiers pressed)</appendix>
        <autogen>__KeyToKey__ KeyCode::COMMAND_R, ModifierFlag::COMMAND_L | ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::COMMAND_R, ModifierFlag::COMMAND_L</autogen>

        <appendix>Command_L+Command_R+A to B</appendix>
        <autogen>__KeyToKey__ KeyCode::A, ModifierFlag::COMMAND_L | ModifierFlag::COMMAND_R, KeyCode::B</autogen>

        <appendix>Command_R to Option_R</appendix>
        <autogen>__KeyToKey__ KeyCode::COMMAND_R, KeyCode::OPTION_R</autogen>
      </item>
      <item>
        <identifier>remap.samples_keytokey_modifier_self</identifier>
        <name>Referencing a Modifier Key in its mapping</name>
        <appendix>(including self modifier, ModifierFlag::SHIFT_R)</appendix>
        <appendix>Shift_R to A</appendix>
        <appendix>Shift_L+Shift_R to B</appendix>
        <autogen>__KeyToKey__ KeyCode::SHIFT_R, ModifierFlag::SHIFT_L | ModifierFlag::SHIFT_R, KeyCode::B</autogen>
        <autogen>__KeyToKey__ KeyCode::SHIFT_R, KeyCode::A</autogen>

        <appendix></appendix>
        <appendix>(excluding self modfier, ModifierFlag::COMMAND_R)</appendix>
        <appendix>Command_R to A</appendix>
        <appendix>Command_L+Command_R to B</appendix>
        <autogen>__KeyToKey__ KeyCode::COMMAND_R, ModifierFlag::COMMAND_L, KeyCode::B</autogen>
        <autogen>__KeyToKey__ KeyCode::COMMAND_R, KeyCode::A</autogen>
      </item>

      <item>
        <identifier>remap.samples_consumertokey</identifier>
        <name>ConsumerKeyCode to KeyCode</name>
        <appendix>Command+Volume Down to A,S,Shift_L+D,Control_L+F,G</appendix>
        <appendix>Volume Down to A</appendix>
        <appendix>Option+Volume Up to Shift_L (Key+Modifier to Modifier)</appendix>
        <appendix>Shift+Volume Up to B (with Modifier)</appendix>
        <appendix>Volume Up to Control_L (to Modifier)</appendix>
        <appendix>Option+Volume Mute to Shift_L+C (to Key+Modifier)</appendix>
        <autogen>__KeyToKey__ ConsumerKeyCode::VOLUME_DOWN, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_COMMAND, KeyCode::A, KeyCode::S, KeyCode::D, ModifierFlag::SHIFT_L, KeyCode::F, ModifierFlag::CONTROL_L, KeyCode::G</autogen>
        <autogen>__KeyToKey__ ConsumerKeyCode::VOLUME_DOWN, KeyCode::A</autogen>
        <autogen>__KeyToKey__ ConsumerKeyCode::VOLUME_UP, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_OPTION, KeyCode::SHIFT_L</autogen>
        <autogen>__KeyToKey__ ConsumerKeyCode::VOLUME_UP, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT, KeyCode::B</autogen>
        <autogen>__KeyToKey__ ConsumerKeyCode::VOLUME_UP, KeyCode::CONTROL_L</autogen>
        <autogen>__KeyToKey__ ConsumerKeyCode::VOLUME_MUTE, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_OPTION, KeyCode::C, ModifierFlag::SHIFT_L</autogen>
      </item>

      <item>
        <identifier>remap.samples_keytoconsumer</identifier>
        <name>KeyCode to ConsumerKeyCode</name>
        <appendix>A to Volume Mute</appendix>
        <appendix>Shift+B to Volume Mute (With Modifier)</appendix>
        <appendix>Shift_L to Volume Mute (Modifier To)</appendix>
        <appendix>C to Option_L+Volume Mute (To Key+Modifier)</appendix>
        <appendix>D to Volume Up, Brightness Up</appendix>
        <autogen>__KeyToKey__ KeyCode::A, ConsumerKeyCode::VOLUME_MUTE</autogen>
        <autogen>__KeyToKey__ KeyCode::B, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT, ConsumerKeyCode::VOLUME_MUTE</autogen>
        <autogen>__KeyToKey__ KeyCode::SHIFT_L, ConsumerKeyCode::VOLUME_MUTE</autogen>
        <autogen>__KeyToKey__ KeyCode::C, ConsumerKeyCode::VOLUME_MUTE, ModifierFlag::OPTION_L</autogen>
        <autogen>__KeyToKey__ KeyCode::D, ConsumerKeyCode::VOLUME_UP, ConsumerKeyCode::BRIGHTNESS_UP</autogen>
      </item>

      <item>
        <identifier>remap.samples_consumertoconsumer</identifier>
        <name>ConsumerKeyCode to ConsumerKeyCode</name>
        <appendix>Volume Mute to Volume Up</appendix>
        <appendix>Volume Down to Volume Mute</appendix>
        <appendix>Shift+Volume Up to Volume Mute (with Modifier)</appendix>
        <appendix>Music Play to Power</appendix>
        <autogen>__KeyToKey__ ConsumerKeyCode::VOLUME_MUTE, ConsumerKeyCode::VOLUME_UP</autogen>
        <autogen>__KeyToKey__ ConsumerKeyCode::VOLUME_DOWN, ConsumerKeyCode::VOLUME_MUTE</autogen>
        <autogen>__KeyToKey__ ConsumerKeyCode::VOLUME_UP, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT, ConsumerKeyCode::VOLUME_MUTE</autogen>
        <autogen>__KeyToKey__ ConsumerKeyCode::MUSIC_PLAY, ConsumerKeyCode::POWER</autogen>
      </item>

      <item>
        <identifier>remap.samples_pointingbuttontokey</identifier>
        <name>PointingButton to KeyCode</name>
        <appendix>MiddleClick to Return</appendix>
        <appendix>Option_L+RightClick to Shift_L</appendix>
        <appendix>Command_L+RightClick to A, Shift_L+B, Control_L+C</appendix>
        <appendix>RightClick to Control_L</appendix>
        <appendix>RightClick to Tab (if application == TERMINAL)</appendix>
        <appendix>Control_L+LeftClick to Space</appendix>
        <autogen>__KeyToKey__ PointingButton::MIDDLE, KeyCode::RETURN</autogen>
        <autogen>__KeyToKey__ PointingButton::RIGHT, ModifierFlag::OPTION_L, KeyCode::SHIFT_L</autogen>
        <autogen>__KeyToKey__ PointingButton::RIGHT, ModifierFlag::COMMAND_L, KeyCode::A, KeyCode::B, ModifierFlag::SHIFT_L, KeyCode::C, ModifierFlag::CONTROL_L</autogen>
        <block>
          <only>TERMINAL</only>
          <autogen>__KeyToKey__ PointingButton::RIGHT, KeyCode::TAB</autogen>
        </block>
        <autogen>__KeyToKey__ PointingButton::RIGHT, KeyCode::CONTROL_L</autogen>
        <autogen>__KeyToKey__ PointingButton::LEFT, ModifierFlag::CONTROL_L, KeyCode::SPACE</autogen>
      </item>

      <item>
        <identifier>remap.samples_keytopointingbutton</identifier>
        <name>KeyCode to PointingButton</name>
        <appendix>A to LeftClick (Standard)</appendix>
        <appendix>S to Double-LeftClick</appendix>
        <appendix>D to Shift_L+LeftClick,RightClick</appendix>
        <appendix>Option_L to LeftClick (Modifier)</appendix>
        <appendix>Shift_R to LeftClick,RightClick (Modifier)</appendix>
        <appendix>Shift+B to RightClick (Key+Modifier)</appendix>
        <appendix>Shift+F to RightClick,MiddleClick (Key+Modifier)</appendix>
        <appendix>Shift+Control_L to RightClick (Modifier+Modifier)</appendix>
        <appendix>Shift+Command_L to RightClick,MiddleClick (Modifier+Modifier)</appendix>
        <appendix>1 to LeftClick</appendix>
        <appendix>2 to MiddleClick</appendix>
        <appendix>3 to RightClick</appendix>
        <appendix>4 to Button4</appendix>
        <appendix>5 to Button5</appendix>
        <appendix>6 to Button6</appendix>
        <appendix>7 to Button7</appendix>
        <appendix>8 to Button8</appendix>
        <appendix>Q to Button9</appendix>
        <appendix>W to Button10</appendix>
        <appendix>E to Button11</appendix>
        <appendix>R to Button12</appendix>
        <appendix>T to Button13</appendix>
        <appendix>Y to Button14</appendix>
        <appendix>U to Button15</appendix>
        <appendix>I to Button16</appendix>
        <autogen>__KeyToKey__ KeyCode::A, PointingButton::LEFT</autogen>
        <autogen>__KeyToKey__ KeyCode::S, PointingButton::LEFT, PointingButton::LEFT</autogen>
        <autogen>__KeyToKey__ KeyCode::D, PointingButton::LEFT, ModifierFlag::SHIFT_L, PointingButton::RIGHT</autogen>
        <autogen>__KeyToKey__ KeyCode::OPTION_L, PointingButton::LEFT</autogen>
        <autogen>__KeyToKey__ KeyCode::SHIFT_R,  PointingButton::LEFT, PointingButton::RIGHT</autogen>
        <autogen>__KeyToKey__ KeyCode::B, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT, PointingButton::RIGHT</autogen>
        <autogen>__KeyToKey__ KeyCode::F, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT, PointingButton::RIGHT, PointingButton::MIDDLE</autogen>
        <autogen>__KeyToKey__ KeyCode::CONTROL_L, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT, PointingButton::RIGHT</autogen>
        <autogen>__KeyToKey__ KeyCode::COMMAND_L, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT, PointingButton::RIGHT, PointingButton::MIDDLE</autogen>
        <autogen>__KeyToKey__ KeyCode::KEY_1, PointingButton::LEFT</autogen>
        <autogen>__KeyToKey__ KeyCode::KEY_2, PointingButton::MIDDLE</autogen>
        <autogen>__KeyToKey__ KeyCode::KEY_3, PointingButton::RIGHT</autogen>
        <autogen>__KeyToKey__ KeyCode::KEY_4, PointingButton::BUTTON4</autogen>
        <autogen>__KeyToKey__ KeyCode::KEY_5, PointingButton::BUTTON5</autogen>
        <autogen>__KeyToKey__ KeyCode::KEY_6, PointingButton::BUTTON6</autogen>
        <autogen>__KeyToKey__ KeyCode::KEY_7, PointingButton::BUTTON7</autogen>
        <autogen>__KeyToKey__ KeyCode::KEY_8, PointingButton::BUTTON8</autogen>
        <autogen>__KeyToKey__ KeyCode::Q,     PointingButton::BUTTON9</autogen>
        <autogen>__KeyToKey__ KeyCode::W,     PointingButton::BUTTON10</autogen>
        <autogen>__KeyToKey__ KeyCode::E,     PointingButton::BUTTON11</autogen>
        <autogen>__KeyToKey__ KeyCode::R,     PointingButton::BUTTON12</autogen>
        <autogen>__KeyToKey__ KeyCode::T,     PointingButton::BUTTON13</autogen>
        <autogen>__KeyToKey__ KeyCode::Y,     PointingButton::BUTTON14</autogen>
        <autogen>__KeyToKey__ KeyCode::U,     PointingButton::BUTTON15</autogen>
        <autogen>__KeyToKey__ KeyCode::I,     PointingButton::BUTTON16</autogen>
      </item>

      <item>
        <identifier>remap.samples_keytopointingbutton_modifier</identifier>
        <name>KeyCode to Modifier+PointingButton</name>
        <appendix>Escape to Command_L+LeftClick</appendix>
        <appendix></appendix>
        <appendix>Events should be following order.</appendix>
        <appendix></appendix>
        <appendix>eventType:keyMod    name:Command_L flags:Cmd</appendix>
        <appendix>eventType:mouseDown name:left      flags:Cmd</appendix>
        <appendix>eventType:mouseUp   name:left      flags:Cmd</appendix>
        <appendix>eventType:keyMod    name:Command_L flags:</appendix>
        <autogen>__KeyToKey__ KeyCode::ESCAPE, PointingButton::LEFT, ModifierFlag::COMMAND_L</autogen>
      </item>

      <item><name>──────────────────────────────</name></item>
      <item>
        <name>PointingButton to PointingButton</name>
      </item>
      <item>
        <identifier>remap.samples_pointingbuttontopointingbutton_r2m</identifier>
        <name>RightClick to MiddleClick</name>
        <autogen>__KeyToKey__ PointingButton::RIGHT, PointingButton::MIDDLE</autogen>
      </item>
      <item>
        <identifier>remap.samples_pointingbuttontopointingbutton_r2cl</identifier>
        <name>RightClick to Command_L+LeftClick</name>
        <autogen>
          __KeyToKey__
          PointingButton::RIGHT,
          PointingButton::LEFT, ModifierFlag::COMMAND_L
        </autogen>
      </item>
      <item>
        <identifier>remap.samples_pointingbuttontopointingbutton_ol2or</identifier>
        <name>Option+LeftClick to Option+RightClick</name>
        <autogen>
          __KeyToKey__
          PointingButton::LEFT, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_OPTION,
          PointingButton::RIGHT, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_OPTION
        </autogen>
      </item>
      <item>
        <identifier>remap.samples_pointingbuttontopointingbutton_ol2m</identifier>
        <name>Option+LeftClick to MiddleClick</name>
        <autogen>__KeyToKey__ PointingButton::LEFT, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_OPTION, PointingButton::MIDDLE</autogen>
      </item>
      <item>
        <identifier>remap.samples_pointingbuttontopointingbutton_fl2ol</identifier>
        <name>Fn+LeftClick to Option_L+LeftClick</name>
        <autogen>__KeyToKey__ PointingButton::LEFT, ModifierFlag::FN, PointingButton::LEFT, ModifierFlag::OPTION_L</autogen>
      </item>
      <item>
        <identifier>remap.samples_pointingbuttontopointingbutton_r2dl</identifier>
        <name>RightClick to Double-LeftClick</name>
        <autogen>__KeyToKey__ PointingButton::RIGHT, PointingButton::LEFT, PointingButton::LEFT</autogen>
      </item>
      <item>
        <identifier>remap.samples_pointingbuttontopointingbutton_r2sll</identifier>
        <name>RightClick to Shift_L+LeftClick, LeftClick</name>
        <autogen>__KeyToKey__ PointingButton::RIGHT, PointingButton::LEFT, ModifierFlag::SHIFT_L, PointingButton::LEFT</autogen>
      </item>
      <item>
        <identifier>remap.samples_pointingbuttontopointingbutton_r2slr</identifier>
        <name>RightClick to Shift_L+LeftClick, RightClick</name>
        <autogen>__KeyToKey__ PointingButton::RIGHT, PointingButton::LEFT, ModifierFlag::SHIFT_L, PointingButton::RIGHT</autogen>
      </item>
      <item>
        <identifier>remap.samples_pointingbuttontopointingbutton_cr2dl</identifier>
        <name>Control+RightClick to Double-LeftClick</name>
        <autogen>__KeyToKey__ PointingButton::RIGHT, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_CONTROL, PointingButton::LEFT, PointingButton::LEFT</autogen>
      </item>
      <item><name>──────────────────────────────</name></item>

      <item>
        <identifier>remap.samples_keytokey_combination</identifier>
        <name>Combination</name>
        <appendix>A to B,C (Standard)</appendix>
        <appendix>B to A,B,Shift_L+C,D,Control_L+P (Key To)</appendix>
        <appendix>C to JIS_KANA,A,I,JIS_EISUU,U (Key To with Japanese)</appendix>
        <appendix>Shift_L to A,B,Control_L+B,Shift_L+C,D (Modifier To)</appendix>
        <appendix>Control+D to Shift_L+A, Control_L+F (Key+Modifier To)</appendix>
        <appendix>E to Type "https://pqrs.org/osx/karabiner/"</appendix>
        <appendix>F to CapsLock,A,S,D,CapsLock</appendix>
        <appendix>G to Option_L,Shift_L,A,S</appendix>
        <appendix>Volume Mute to Volume Up,Brightness Up</appendix>
        <appendix></appendix>
        <appendix>H to A,KeyCode::VK_NONE</appendix>
        <appendix>(KeyDown and KeyUp will be fired at the same time when H key is pressed)</appendix>
        <autogen>__KeyToKey__ KeyCode::A, KeyCode::B, KeyCode::C</autogen>
        <autogen>__KeyToKey__ KeyCode::B, KeyCode::A, KeyCode::B, KeyCode::C, ModifierFlag::SHIFT_L, KeyCode::D, KeyCode::P, ModifierFlag::CONTROL_L</autogen>
        <autogen>__KeyToKey__ KeyCode::C, KeyCode::JIS_KANA, KeyCode::A, KeyCode::I, KeyCode::JIS_EISUU, KeyCode::U</autogen>
        <autogen>__KeyToKey__ KeyCode::SHIFT_L, KeyCode::A, KeyCode::B, KeyCode::B, ModifierFlag::CONTROL_L, KeyCode::C, ModifierFlag::SHIFT_L, KeyCode::D</autogen>
        <autogen>__KeyToKey__ KeyCode::D, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_CONTROL, KeyCode::A, ModifierFlag::SHIFT_L, KeyCode::F, ModifierFlag::CONTROL_L</autogen>
        <autogen>
          __KeyToKey__
          KeyCode::E, ModifierFlag::NONE,
          KeyCode::H, KeyCode::T, KeyCode::T, KeyCode::P, KeyCode::S,
          KeyCode::SEMICOLON, ModifierFlag::SHIFT_L, KeyCode::SLASH, KeyCode::SLASH,
          KeyCode::P, KeyCode::Q, KeyCode::R, KeyCode::S,
          KeyCode::DOT,
          KeyCode::O, KeyCode::R, KeyCode::G,
          KeyCode::SLASH,
          KeyCode::O, KeyCode::S, KeyCode::X,
          KeyCode::SLASH,
          KeyCode::K, KeyCode::A, KeyCode::R, KeyCode::A, KeyCode::B, KeyCode::I, KeyCode::N, KeyCode::E, KeyCode::R,
          KeyCode::SLASH
        </autogen>
        <autogen>__KeyToKey__ KeyCode::F, KeyCode::CAPSLOCK, KeyCode::A, KeyCode::S, KeyCode::D, KeyCode::CAPSLOCK</autogen>
        <autogen>__KeyToKey__ KeyCode::G, KeyCode::OPTION_L, KeyCode::SHIFT_L, KeyCode::A, KeyCode::S</autogen>
        <autogen>
          __KeyToKey__
          ConsumerKeyCode::VOLUME_MUTE,
          ConsumerKeyCode::VOLUME_UP,
          ConsumerKeyCode::BRIGHTNESS_UP,
        </autogen>
        <autogen>__KeyToKey__ KeyCode::H, KeyCode::A, KeyCode::VK_NONE</autogen>
      </item>

      <item>
        <identifier>remap.samples_keytokey_combination1</identifier>
        <name>Combination (2)</name>
        <appendix>A to A,S,Shift_L (Shift_L is active while we're pressing A key)</appendix>
        <appendix>Shift_R to A,S,Control_L (Control_L is active while we're pressing Shift_R key)</appendix>
        <appendix>Command+B to A,S,Shift_L (Shift_L is active while we're pressing B key)</appendix>
        <appendix>Control_L+Option_L to A,S,Shift_L (Shift_L is active while we're pressing Option_L key)</appendix>
        <autogen>__KeyToKey__ KeyCode::A,                                 KeyCode::A, KeyCode::S, KeyCode::SHIFT_L</autogen>
        <autogen>__KeyToKey__ KeyCode::SHIFT_R,                           KeyCode::A, KeyCode::S, KeyCode::CONTROL_L</autogen>
        <autogen>__KeyToKey__ KeyCode::B,        MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_COMMAND,              KeyCode::A, KeyCode::S, KeyCode::SHIFT_L</autogen>
        <autogen>__KeyToKey__ KeyCode::OPTION_L, ModifierFlag::CONTROL_L, KeyCode::A, KeyCode::S, KeyCode::SHIFT_L</autogen>
      </item>

      <item>
        <identifier>remap.samples_keytokey_combination_3</identifier>
        <name>Combination(3)</name>
        <appendix>Shift_L to A,Shift_L+S,D (if no other modifiers pressed)</appendix>
        <appendix>Command+A to Volume Mute (if no other modifiers pressed)</appendix>
        <autogen>__KeyToKey__ KeyCode::SHIFT_L, ModifierFlag::SHIFT_L | ModifierFlag::NONE, KeyCode::A, KeyCode::S, ModifierFlag::SHIFT_L, KeyCode::D</autogen>
        <autogen>
          __KeyToKey__
          KeyCode::A, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_COMMAND | ModifierFlag::NONE,
          ConsumerKeyCode::VOLUME_MUTE,
        </autogen>
      </item>

      <item>
        <identifier>remap.samples_keytokey_combination_4</identifier>
        <name>Combination(4)</name>
        <appendix>A to CapsLock,A,S</appendix>
        <appendix>// This has a issue with key repeat.</appendix>
        <appendix>// In key repeat, CapsLock status is not changed.</appendix>
        <autogen>__KeyToKey__ KeyCode::A, KeyCode::CAPSLOCK, KeyCode::A, KeyCode::S</autogen>
      </item>

      <item>
        <identifier>remap.samples_keytokey_norepeat</identifier>
        <name>NoRepeat</name>
        <appendix>1 to A (with Option::NOREPEAT)</appendix>
        <appendix>2 to A,B,C (with Option::NOREPEAT)</appendix>
        <appendix>3 to Shift_L (with Option::NOREPEAT)</appendix>
        <appendix>A to Volume Up (with Option::NOREPEAT)</appendix>
        <appendix>Volume Mute to Volume Up,Brightness Up (with NoRepeat)</appendix>
        <appendix>Volume Down to A (with Option::NOREPEAT)</appendix>
        <appendix>Volume Up to Volume Down (with NoRepeat)</appendix>
        <appendix>RightClick to A (with Option::NOREPEAT)</appendix>
        <autogen>__KeyToKey__ KeyCode::KEY_1, KeyCode::A, Option::NOREPEAT</autogen>
        <autogen>__KeyToKey__ KeyCode::KEY_2, KeyCode::A, KeyCode::B, KeyCode::C, Option::NOREPEAT</autogen>
        <autogen>__KeyToKey__ KeyCode::KEY_3, KeyCode::SHIFT_L, Option::NOREPEAT</autogen>
        <autogen>
          __KeyToKey__
          ConsumerKeyCode::VOLUME_MUTE,
          ConsumerKeyCode::VOLUME_UP,
          ConsumerKeyCode::BRIGHTNESS_UP,
          Option::NOREPEAT,
        </autogen>
        <autogen>__KeyToKey__ ConsumerKeyCode::VOLUME_DOWN, KeyCode::A, Option::NOREPEAT</autogen>
        <autogen>__KeyToKey__ ConsumerKeyCode::VOLUME_UP, ConsumerKeyCode::VOLUME_DOWN, Option::NOREPEAT</autogen>
        <autogen>__KeyToKey__ PointingButton::RIGHT, KeyCode::A, Option::NOREPEAT</autogen>
        <autogen>__KeyToKey__ KeyCode::A, ConsumerKeyCode::VOLUME_UP, Option::NOREPEAT</autogen>
      </item>

      <item>
        <identifier>remap.samples_keytokey_delayuntilrepeat</identifier>
        <name>DelayUntilRepeat, KeyRepeat</name>
        <appendix>1 to A (with DelayUntilRepeat::RawValue::1, KeyRepeat::RawValue::1)</appendix>
        <appendix>Volume Down to A (with DelayUntilRepeat::RawValue::1, KeyRepeat::RawValue::1)</appendix>
        <appendix>RightClick to A (with DelayUntilRepeat::RawValue::1, KeyRepeat::RawValue::1)</appendix>
        <autogen>
          __KeyToKey__
          KeyCode::KEY_1,
          KeyCode::A,
          <!-- 1 millisecond -->
          DelayUntilRepeat::RawValue::1,
          <!-- 1 millisecond -->
          KeyRepeat::RawValue::1,
        </autogen>
        <autogen>
          __KeyToKey__
          ConsumerKeyCode::VOLUME_DOWN,
          KeyCode::A,
          <!-- 1 millisecond -->
          DelayUntilRepeat::RawValue::1,
          <!-- 1 millisecond -->
          KeyRepeat::RawValue::1,
        </autogen>
        <autogen>
          __KeyToKey__
          PointingButton::RIGHT,
          KeyCode::A,
          <!-- 1 millisecond -->
          DelayUntilRepeat::RawValue::1,
          <!-- 1 millisecond -->
          KeyRepeat::RawValue::1,
        </autogen>
      </item>

      <item>
        <identifier>remap.samples_keytokey_beforekeydown</identifier>
        <name>BeforeKeyDown, AfterKeyUp</name>
        <appendix>1 to A (BeforeKeyDown Return, AfterKeyUp Tab)</appendix>
        <appendix>Shift_R to A (BeforeKeyDown Control+B,C AfterKeyUp Option+D,E)</appendix>
        <appendix></appendix>
        <appendix>Control_L+2 to Control+Option+A</appendix>
        <appendix>(BeforeKeyDown Shift+B,C AfterKeyUp Option+D,E,Control+F)</appendix>
        <appendix></appendix>
        <appendix>Control_L+Shift_L to A,B</appendix>
        <appendix>(BeforeKeyDown C AfterKeyUp D)</appendix>
        <appendix></appendix>
        <appendix>Change Input Source while pressing right option key.</appendix>
        <appendix>(Sending Command+Space when pressing/releasing right option key.)</appendix>
        <appendix></appendix>
        <appendix>SimultaneousKeyPresses S+D to B.</appendix>
        <appendix>(BeforeKeyDown C, AfterKeyUp D)</appendix>
        <appendix></appendix>
        <appendix>Volume Mute to B.</appendix>
        <appendix>(BeforeKeyDown C, AfterKeyUp D)</appendix>
        <appendix></appendix>
        <appendix>Right Click to B.</appendix>
        <appendix>(BeforeKeyDown C, AfterKeyUp D)</appendix>
        <autogen>
          __KeyToKey__
          KeyCode::KEY_1, KeyCode::A,
          Option::KEYTOKEY_BEFORE_KEYDOWN, KeyCode::RETURN,
          Option::KEYTOKEY_AFTER_KEYUP, KeyCode::TAB
        </autogen>
        <autogen>
          __KeyToKey__
          KeyCode::SHIFT_R, KeyCode::A,
          Option::KEYTOKEY_BEFORE_KEYDOWN, KeyCode::B, ModifierFlag::CONTROL_L, KeyCode::C,
          Option::KEYTOKEY_AFTER_KEYUP,    KeyCode::D, ModifierFlag::OPTION_L,  KeyCode::E,
        </autogen>
        <autogen>
          __KeyToKey__
          KeyCode::KEY_2, ModifierFlag::CONTROL_L, KeyCode::A, ModifierFlag::CONTROL_L | ModifierFlag::OPTION_L,
          Option::KEYTOKEY_BEFORE_KEYDOWN, KeyCode::B, ModifierFlag::SHIFT_R,  KeyCode::C,
          Option::KEYTOKEY_AFTER_KEYUP,    KeyCode::D, ModifierFlag::OPTION_L, KeyCode::E, KeyCode::F, ModifierFlag::CONTROL_L
        </autogen>
        <autogen>
          __KeyToKey__
          KeyCode::SHIFT_L, ModifierFlag::CONTROL_L, KeyCode::A, KeyCode::B,
          Option::KEYTOKEY_BEFORE_KEYDOWN, KeyCode::C,
          Option::KEYTOKEY_AFTER_KEYUP,    KeyCode::D
        </autogen>
        <!-- Hack: Sending KeyCode::CONTROL_L after send control-space to release the control key -->
        <autogen>
          __KeyToKey__
          KeyCode::OPTION_R, KeyCode::VK_NONE,
          Option::KEYTOKEY_BEFORE_KEYDOWN, {{ ENV_Select_the_previous_input_source_shortcut }}, KeyCode::CONTROL_L,
          Option::KEYTOKEY_AFTER_KEYUP,    {{ ENV_Select_the_previous_input_source_shortcut }},
        </autogen>
        <autogen>
          __SimultaneousKeyPresses__
          KeyCode::S, KeyCode::D,
          KeyCode::B,
          Option::KEYTOKEY_BEFORE_KEYDOWN, KeyCode::C,
          Option::KEYTOKEY_AFTER_KEYUP,    KeyCode::D,
        </autogen>
        <autogen>
          __KeyToKey__
          ConsumerKeyCode::VOLUME_MUTE,
          KeyCode::B,
          Option::KEYTOKEY_BEFORE_KEYDOWN, KeyCode::C,
          Option::KEYTOKEY_AFTER_KEYUP,    KeyCode::D,
        </autogen>
        <autogen>
          __KeyToKey__
          PointingButton::RIGHT,
          KeyCode::B,
          Option::KEYTOKEY_BEFORE_KEYDOWN, KeyCode::C,
          Option::KEYTOKEY_AFTER_KEYUP,    KeyCode::D,
        </autogen>
      </item>

      <item>
        <identifier>remap.samples_keytokey_afterkeyup1</identifier>
        <name>AfterKeyUp with ModifierFlag conditional pattern matching. (1)</name>
        <appendix>* Change the right option key to control key.</appendix>
        <appendix>* AfterKeyUp f1 when the left shift key and the left control key are pressed.</appendix>
        <appendix>* AfterKeyUp f2 when the left shift key is pressed.</appendix>
        <appendix>* AfterKeyUp f3 when the left control key is pressed.</appendix>
        <appendix>* Otherwise, AfterKeyUp f4.</appendix>
        <appendix></appendix>
        <appendix>For example, OPTION_R down, SHIFT_L down, OPTION_R up sends f2.</appendix>
        <autogen>
          __KeyToKey__
          KeyCode::OPTION_R,
          KeyCode::CONTROL_L,

          Option::KEYTOKEY_AFTER_KEYUP, ModifierFlag::SHIFT_L | ModifierFlag::CONTROL_L,
          KeyCode::F1,

          Option::KEYTOKEY_AFTER_KEYUP, ModifierFlag::SHIFT_L,
          KeyCode::F2,

          Option::KEYTOKEY_AFTER_KEYUP, ModifierFlag::CONTROL_L,
          KeyCode::F3,

          Option::KEYTOKEY_AFTER_KEYUP,
          KeyCode::F4,
        </autogen>
      </item>

      <item>
        <identifier>remap.samples_keytokey_afterkeyup2</identifier>
        <name>AfterKeyUp with ModifierFlag conditional pattern matching. (2)</name>
        <appendix>* Change the right shift key to shift-right arrow.</appendix>
        <appendix>* AfterKeyUp command-c.</appendix>
        <appendix>* If the escape key is pressed, AfterKeyUp will be cancel.</appendix>
        <autogen>
          __KeyToKey__
          KeyCode::SHIFT_R,
          KeyCode::CURSOR_RIGHT,

          Option::KEYTOKEY_BEFORE_KEYDOWN,
          KeyCode::VK_LOCK_SHIFT_R_FORCE_ON,

          Option::KEYTOKEY_AFTER_KEYUP, ModifierFlag::SHIFT_R,
          KeyCode::VK_LOCK_SHIFT_R_FORCE_OFF,
          KeyCode::C, ModifierFlag::COMMAND_L,
        </autogen>
        <autogen>
          __KeyToKey__
          KeyCode::ESCAPE, ModifierFlag::SHIFT_R,
          KeyCode::VK_LOCK_SHIFT_R_FORCE_OFF,
        </autogen>
      </item>

      <item>
        <identifier>remap.samples_keytokey_delayed_action</identifier>
        <name>Option::KEYTOKEY_DELAYED_ACTION</name>
        <appendix>────────</appendix>
        <appendix>Change the return key x2 to the space key.</appendix>
        <appendix></appendix>
        <appendix>* When you press the return key twice, a space key event will be sent. (no return key events)</appendix>
        <appendix>* When you press the return key once, a return key event will be sent.</appendix>
        <appendix>────────</appendix>
        <appendix>Change control-tab to the left shift key.</appendix>
        <appendix>+ Change control-tab x2 to a,option-b,control-c,d</appendix>
        <appendix></appendix>
        <appendix>* When you press control-tab twice, "left shift, a, option-b, control-c, d" will be sent.</appendix>
        <appendix>* When you press control-tab once, "left shift" will be sent.</appendix>
        <appendix>────────</appendix>
        <appendix>Change control-escape to option-1.</appendix>
        <appendix>+ Change control-escape x2 to option-2.</appendix>
        <appendix>────────</appendix>

        <autogen>
          __KeyToKey__
          KeyCode::RETURN,
          KeyCode::VK_NONE,

          <!--
              | You can send key events in the timeout callback that is set at key up by Option::KEYTOKEY_DELAYED_ACTION.
              | (You can adjust timeout milliseconds by Preferences > Parameters tab.)
              |
              | You can also send key events when timeout callback is cancelled.
              | * Option::KEYTOKEY_DELAYED_ACTION_CANCELED_BY
              | * Option::KEYTOKEY_DELAYED_ACTION_CANCELED_DEFAULT
              |
              | If you specify KeyCode::VK_KEYTOKEY_DELAYED_ACTION_DROP_EVENT,
              | the pressed key will be ignored.
              | For example, the following command sends the space key event if you interrupted timeout callback by the return key.
              | The KeyCode::VK_KEYTOKEY_DELAYED_ACTION_DROP_EVENT suppresses the return key event.
              | Without it, the space key and the return key events will be sent.
              |
              |   Option::KEYTOKEY_DELAYED_ACTION_CANCELED_BY, KeyCode::RETURN,
              |   KeyCode::SPACE,
              |   KeyCode::VK_KEYTOKEY_DELAYED_ACTION_DROP_EVENT,
          -->
          Option::KEYTOKEY_DELAYED_ACTION,
          KeyCode::RETURN,

          Option::KEYTOKEY_DELAYED_ACTION_CANCELED_BY, KeyCode::RETURN,
          KeyCode::SPACE,
          KeyCode::VK_KEYTOKEY_DELAYED_ACTION_DROP_EVENT, <!-- drop second return key event -->
        </autogen>

        <autogen>
          __KeyToKey__
          KeyCode::TAB, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_CONTROL,
          KeyCode::SHIFT_L,

          Option::KEYTOKEY_DELAYED_ACTION,
          KeyCode::VK_NONE,

          Option::KEYTOKEY_DELAYED_ACTION_CANCELED_BY, KeyCode::TAB,
          KeyCode::A,
          KeyCode::B, ModifierFlag::OPTION_L,
          KeyCode::C, ModifierFlag::CONTROL_L,
          KeyCode::D,
          KeyCode::VK_KEYTOKEY_DELAYED_ACTION_DROP_EVENT, <!-- drop second tab key event -->
        </autogen>

        <autogen>
          __KeyToKey__
          KeyCode::ESCAPE, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_CONTROL,
          KeyCode::VK_NONE,

          Option::KEYTOKEY_DELAYED_ACTION,
          KeyCode::KEY_1, ModifierFlag::OPTION_L,

          Option::KEYTOKEY_DELAYED_ACTION_CANCELED_BY, KeyCode::ESCAPE,
          KeyCode::KEY_2, ModifierFlag::OPTION_L,
          KeyCode::VK_KEYTOKEY_DELAYED_ACTION_DROP_EVENT, <!-- drop second escapet key event -->
        </autogen>
      </item>

      <item>
        <identifier>remap.samples_keytokey_delayed_action_2</identifier>
        <name>Option::KEYTOKEY_DELAYED_ACTION (2)</name>
        <appendix>────────</appendix>
        <appendix>Change the right command key x2 to shift-space.</appendix>
        <appendix></appendix>
        <appendix>* When you press the right command key twice, "right command, shift-space" will be sent.</appendix>
        <appendix>* When you press the right command key once, right command key event will be sent.</appendix>
        <appendix>────────</appendix>

        <autogen>
          __KeyToKey__
          KeyCode::COMMAND_R,
          KeyCode::COMMAND_R,

          Option::KEYTOKEY_DELAYED_ACTION,
          KeyCode::VK_NONE,

          Option::KEYTOKEY_DELAYED_ACTION_CANCELED_BY, KeyCode::COMMAND_R,
          KeyCode::SPACE, ModifierFlag::SHIFT_L,
          KeyCode::VK_KEYTOKEY_DELAYED_ACTION_DROP_EVENT, <!-- drop second right command key event -->
        </autogen>
      </item>

      <item>
        <identifier>remap.samples_keytokey_delayed_action_3</identifier>
        <name>Option::KEYTOKEY_DELAYED_ACTION (3)</name>
        <appendix>With __HoldingKeyToKey__</appendix>
        <appendix>────────</appendix>
        <appendix>Change the return key to `1`.</appendix>
        <appendix>+ Input `2` by holding the return key down.</appendix>
        <appendix>+ Input `3` by press the return key twice.</appendix>
        <appendix>────────</appendix>

        <autogen>
          __HoldingKeyToKey__
          KeyCode::RETURN,

          <!-- ======================================== -->
          <!-- normal press -->
          @begin
          KeyCode::VK_NONE,

          Option::KEYTOKEY_DELAYED_ACTION,
          KeyCode::KEY_1,

          Option::KEYTOKEY_DELAYED_ACTION_CANCELED_BY, KeyCode::RETURN,
          KeyCode::KEY_3,
          KeyCode::VK_KEYTOKEY_DELAYED_ACTION_DROP_EVENT,
          @end

          <!-- ======================================== -->
          <!-- holding -->
          @begin
          KeyCode::KEY_2,
          @end
        </autogen>
      </item>

      <item>
        <identifier>remap.samples_keytokey_delayed_action_4</identifier>
        <name>Option::KEYTOKEY_DELAYED_ACTION (4)</name>
        <appendix>* change space,1 to f1</appendix>
        <appendix>* change space,2 to f2</appendix>
        <appendix>* change space,3 to f3</appendix>
        <appendix>* change space,4 to f4</appendix>
        <appendix>* space will be the return key when another key is pressed (eg. change space,5 to return,5).</appendix>

        <autogen>
          __KeyToKey__
          KeyCode::SPACE,
          KeyCode::VK_NONE,

          Option::KEYTOKEY_DELAYED_ACTION,
          KeyCode::SPACE,

          Option::KEYTOKEY_DELAYED_ACTION_CANCELED_BY, KeyCode::KEY_1,
          KeyCode::F1,
          KeyCode::VK_KEYTOKEY_DELAYED_ACTION_DROP_EVENT,

          Option::KEYTOKEY_DELAYED_ACTION_CANCELED_BY, KeyCode::KEY_2,
          KeyCode::F2,
          KeyCode::VK_KEYTOKEY_DELAYED_ACTION_DROP_EVENT,

          Option::KEYTOKEY_DELAYED_ACTION_CANCELED_BY, KeyCode::KEY_3,
          KeyCode::F3,
          KeyCode::VK_KEYTOKEY_DELAYED_ACTION_DROP_EVENT,

          Option::KEYTOKEY_DELAYED_ACTION_CANCELED_BY, KeyCode::KEY_4,
          KeyCode::F4,
          KeyCode::VK_KEYTOKEY_DELAYED_ACTION_DROP_EVENT,

          Option::KEYTOKEY_DELAYED_ACTION_CANCELED_DEFAULT,
          KeyCode::RETURN,
        </autogen>
      </item>

      <item>
        <identifier>remap.samples_keytokey_delayed_action_5</identifier>
        <name>Option::KEYTOKEY_DELAYED_ACTION with key repeat</name>
        <appendix>* change space x2 to f1 with key repeat</appendix>

        <!-- The delayed action does not support key repeat itself. -->
        <!-- We have to change the key by __KeyToKey__ to support key repeat. -->
        <!-- Use sticky modifier to apply __KeyToKey__ only the second event. -->
        <block>
          <modifierstuck_only>ModifierFlag::EXTRA1</modifierstuck_only>
          <autogen>
            __KeyToKey__
            KeyCode::SPACE,
            KeyCode::F1,
          </autogen>
        </block>

        <autogen>
          __KeyToKey__
          KeyCode::SPACE,
          KeyCode::VK_NONE,

          Option::KEYTOKEY_DELAYED_ACTION,
          KeyCode::SPACE,

          Option::KEYTOKEY_DELAYED_ACTION_CANCELED_BY, KeyCode::SPACE,
          KeyCode::VK_STICKY_EXTRA1_FORCE_ON,
        </autogen>
      </item>

      <item>
        <identifier>remap.samples_keytokey_delayed_action_6</identifier>
        <name>Option::KEYTOKEY_DELAYED_ACTION_MILLISECONDS</name>
        <appendix>* change space x2 to f1. (the delay is 200 milliseconds.)</appendix>

        <autogen>
          __KeyToKey__
          KeyCode::SPACE,
          KeyCode::VK_NONE,

          Option::KEYTOKEY_DELAYED_ACTION,
          KeyCode::SPACE,

          Option::KEYTOKEY_DELAYED_ACTION_CANCELED_BY, KeyCode::SPACE,
          KeyCode::F1,

          Option::KEYTOKEY_DELAYED_ACTION_MILLISECONDS,
          Millisecond::RawValue::200,
        </autogen>
      </item>

      <item>
        <identifier>remap.samples_keytokey_KEYTOKEY_INCREASE_MODIFIER_FLAGS</identifier>
        <name>Option::KEYTOKEY_INCREASE_MODIFIER_FLAGS</name>
        <appendix>────────</appendix>
        <appendix>Change HJKL keys to arrow key while you press S key.</appendix>
        <appendix></appendix>
        <appendix><![CDATA[    * S down, J down, S up, L down, J up, L up =>  down arrow, right arrow  ]]></appendix>
        <appendix>────────</appendix>

        <autogen>
          __KeyOverlaidModifier__
          KeyCode::S,
          KeyCode::VK_MODIFIER_EXTRA1,
          KeyCode::S,
        </autogen>

        <!--
            | You do not need to use Option::KEYTOKEY_INCREASE_MODIFIER_FLAGS when:
            | * You want to change a key to key+modifier. (eg. change command-C to control-C.)
            | * You want to change a key to modifier combinations. (eg. change the right option key to option-shift.)
            |
            | This option is useful when you want to change a key to normal key and
            | you also want to increase modifiers while pressing the target key.
            |
            | See `notsave.simple_vi_mode` in `vi_mode.xml`.
        -->

        <block>
          <modifier_only>ModifierFlag::EXTRA1</modifier_only>
          <autogen>
            __KeyToKey__
            KeyCode::H,
            KeyCode::CURSOR_LEFT,

            Option::KEYTOKEY_INCREASE_MODIFIER_FLAGS,
            ModifierFlag::EXTRA1,
          </autogen>
          <autogen>
            __KeyToKey__
            KeyCode::J,
            KeyCode::CURSOR_DOWN,

            Option::KEYTOKEY_INCREASE_MODIFIER_FLAGS,
            ModifierFlag::EXTRA1,
          </autogen>
          <autogen>
            __KeyToKey__
            KeyCode::K,
            KeyCode::CURSOR_UP,

            Option::KEYTOKEY_INCREASE_MODIFIER_FLAGS,
            ModifierFlag::EXTRA1,
          </autogen>
          <autogen>
            __KeyToKey__
            KeyCode::L,
            KeyCode::CURSOR_RIGHT,

            Option::KEYTOKEY_INCREASE_MODIFIER_FLAGS,
            ModifierFlag::EXTRA1,
          </autogen>
        </block>
      </item>

      <item>
        <identifier>remap.samples_keytokey_apply_from_to_top</identifier>
        <name>Apply from the top sequentially.</name>
        <appendix>1 to A</appendix>
        <appendix>1 to B (skipped)</appendix>
        <appendix>2 to B </appendix>
        <appendix>2 to C (skipped)</appendix>
        <autogen>__KeyToKey__ KeyCode::KEY_1, KeyCode::A</autogen>
        <block>
          <autogen>__KeyToKey__ KeyCode::KEY_1, KeyCode::B</autogen>
          <autogen>__KeyToKey__ KeyCode::KEY_2, KeyCode::B</autogen>
        </block>
        <autogen>__KeyToKey__ KeyCode::KEY_2, KeyCode::C</autogen>
      </item>

      <item>
        <name>Apply from the top sequentially (&lt;list&gt; and &lt;item&gt;)</name>
        <appendix>(Turn on all settings. The settings labeled "skipped" will be ignored.)</appendix>
        <item>
          <identifier>remap.samples_keytokey_apply_from_to_top_item1</identifier>
          <name>1 to A</name>
          <autogen>__KeyToKey__ KeyCode::KEY_1, KeyCode::A</autogen>
        </item>
        <item>
          <name>list</name>
          <item>
            <identifier>remap.samples_keytokey_apply_from_to_top_item2</identifier>
            <name>1 to B (skipped)</name>
            <autogen>__KeyToKey__ KeyCode::KEY_1, KeyCode::B</autogen>
          </item>
          <item>
            <identifier>remap.samples_keytokey_apply_from_to_top_item3</identifier>
            <name>2 to B</name>
            <autogen>__KeyToKey__ KeyCode::KEY_2, KeyCode::B</autogen>
          </item>
        </item>
        <item>
          <identifier>remap.samples_keytokey_apply_from_to_top_item4</identifier>
          <name>2 to C (skipped)</name>
          <autogen>__KeyToKey__ KeyCode::KEY_2, KeyCode::C</autogen>
        </item>
      </item>
    </item>

    <item>
      <name>KeyOverlaidModifier</name>
      <item>
        <identifier>remap.samples_keyoverlaidmodifier</identifier>
        <name>Standard</name>
        <appendix>A to Shift_L (When type only, send Space) (Standard)</appendix>
        <appendix>Option_L to Shift_L (When type only, send Space) (Modifier)</appendix>
        <appendix>Control+B to Shift_L (When type only, send Space) (Key+Modifier)</appendix>
        <appendix>C to Shift_L (When type only, send Space) + [KeyRepeat]</appendix>
        <appendix>Command+D to Shift_L (When type only, send Control_L+F) + [KeyRepeat]</appendix>
        <appendix>E to KeyCode::VK_NONE</appendix>
        <appendix>F to Shift_L (When type only, send CapsLock)</appendix>
        <appendix>G to Shift_L (When type only, send A,B,Shift_L+C,Control_L+B)</appendix>
        <appendix>H to Shift_L (When type only, send A,B,Shift_L+C,Control_L+B) + [KeyRepeat]</appendix>
        <appendix>I to Shift_L (When type only, send Option_L)</appendix>
        <appendix>J to Shift_L+Option_L (When type only, send Space)</appendix>
        <appendix>Command_R to Shift_L (Without other modifiers) (When type only, send Space)</appendix>
        <autogen>__KeyOverlaidModifier__ KeyCode::A, KeyCode::SHIFT_L, KeyCode::SPACE</autogen>
        <autogen>__KeyOverlaidModifier__ KeyCode::OPTION_L, KeyCode::SHIFT_L, KeyCode::SPACE</autogen>
        <autogen>__KeyOverlaidModifier__ KeyCode::B, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_CONTROL, KeyCode::SHIFT_L, KeyCode::SPACE</autogen>
        <autogen>__KeyOverlaidModifierWithRepeat__ KeyCode::C, KeyCode::SHIFT_L, KeyCode::SPACE</autogen>
        <autogen>__KeyOverlaidModifierWithRepeat__ KeyCode::D, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_COMMAND, KeyCode::SHIFT_L, KeyCode::F, ModifierFlag::CONTROL_L</autogen>
        <autogen>__KeyToKey__ KeyCode::E, KeyCode::VK_NONE</autogen>
        <autogen>__KeyOverlaidModifier__ KeyCode::F, KeyCode::SHIFT_L, KeyCode::CAPSLOCK</autogen>
        <autogen>__KeyOverlaidModifier__           KeyCode::G, KeyCode::SHIFT_L, KeyCode::A, KeyCode::B, KeyCode::C, ModifierFlag::SHIFT_L, KeyCode::B, ModifierFlag::CONTROL_L</autogen>
        <autogen>__KeyOverlaidModifierWithRepeat__ KeyCode::H, KeyCode::SHIFT_L, KeyCode::A, KeyCode::B, KeyCode::C, ModifierFlag::SHIFT_L, KeyCode::B, ModifierFlag::CONTROL_L</autogen>
        <autogen>__KeyOverlaidModifier__ KeyCode::I, KeyCode::SHIFT_L, KeyCode::OPTION_L</autogen>
        <autogen>__KeyOverlaidModifier__ KeyCode::J, KeyCode::SHIFT_L, ModifierFlag::OPTION_L, KeyCode::SPACE</autogen>
        <autogen>__KeyOverlaidModifier__ KeyCode::COMMAND_R, ModifierFlag::COMMAND_R | ModifierFlag::NONE, KeyCode::SHIFT_L, KeyCode::SPACE</autogen>
      </item>
      <item>
        <identifier>remap.samples_keyoverlaidmodifier2</identifier>
        <name>Standard2</name>
        <appendix>A to Shift_L (Without other modifiers) (When type only, send Space)</appendix>
        <appendix>Command_R to Command_R (Without other modifiers) (When type only, send "command-a")</appendix>
        <autogen>__KeyOverlaidModifier__ KeyCode::A, ModifierFlag::NONE, KeyCode::SHIFT_L, KeyCode::SPACE</autogen>
        <autogen>
          __KeyOverlaidModifier__
          KeyCode::COMMAND_R, ModifierFlag::COMMAND_R | ModifierFlag::NONE,
          KeyCode::COMMAND_R,
          KeyCode::A, ModifierFlag::COMMAND_R,
        </autogen>
      </item>
      <item>
        <identifier>remap.samples_keyoverlaidmodifier3</identifier>
        <name>Standard3</name>
        <appendix>Change shift-A to option (send space when alone)</appendix>
        <appendix>Change shift-S to tab (send space when alone)</appendix>
        <appendix>Change shift-Control_L to option (send space when alone)</appendix>
        <appendix>Change shift-Command_L to tab (send space when alone)</appendix>
        <appendix></appendix>
        <appendix><![CDATA[  Press shift, Press A, Press Q -> option-Q  ]]></appendix>
        <appendix><![CDATA[  Press shift, Press S, Press Q -> tab,shift-Q  ]]></appendix>
        <appendix><![CDATA[  Press shift, Press Control_L, Press Q -> option-Q  ]]></appendix>
        <appendix><![CDATA[  Press shift, Press Command_L, Press Q -> tab,shift-Q  ]]></appendix>

        <autogen>
          __KeyOverlaidModifier__
          KeyCode::A, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT,
          KeyCode::OPTION_L,
          KeyCode::SPACE,
        </autogen>
        <autogen>
          __KeyOverlaidModifier__
          KeyCode::S, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT,
          KeyCode::TAB,
          KeyCode::SPACE,
        </autogen>
        <autogen>
          __KeyOverlaidModifier__
          KeyCode::CONTROL_L, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT,
          KeyCode::OPTION_L,
          KeyCode::SPACE,
        </autogen>
        <autogen>
          __KeyOverlaidModifier__
          KeyCode::COMMAND_L, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT,
          KeyCode::TAB,
          KeyCode::SPACE,
        </autogen>
      </item>
      <item>
        <identifier>remap.samples_keyoverlaidmodifier_pointingbutton</identifier>
        <name>With PointingButton</name>
        <appendix>Change the right click to shift. (click alone, send space)</appendix>
        <appendix>(Note: "right button down, move pointer, right button up" sends a space key event.)</appendix>
        <appendix></appendix>
        <appendix>Change button4 to shift. (click alone, send button4)</appendix>
        <autogen>
          __KeyOverlaidModifier__
          PointingButton::RIGHT,
          KeyCode::SHIFT_L,
          KeyCode::SPACE,
        </autogen>
        <autogen>
          __KeyOverlaidModifier__
          PointingButton::BUTTON4,
          KeyCode::SHIFT_L,
          PointingButton::BUTTON4,
        </autogen>
      </item>

      <!-- ============================================================ -->
      <item>
        <identifier>remap.samples_keyoverlaidmodifier_use_separator</identifier>
        <name>With @begin .. @end (1)</name>
        <appendix>Use "a" key to show status message "1" and "2" and left shift key.</appendix>
        <appendix>(Send space if you press only "a" key.)</appendix>
        <autogen>
          __KeyOverlaidModifier__
          KeyCode::A, ModifierFlag::NONE,

          <!--
              You need to put "KeyCode"s between @begin and @end
              when you want to specify multiple KeyCode.
          -->
          @begin
          <!-- hold 'a' -->
          KeyCode::VK_CONFIG_FORCE_ON_notsave_samples_keyoverlaidmodifier_use_separator_1,
          KeyCode::VK_CONFIG_FORCE_ON_notsave_samples_keyoverlaidmodifier_use_separator_2,
          KeyCode::SHIFT_L,
          @end

          @begin
          <!-- release 'a' -->
          KeyCode::SPACE,
          @end

          Option::KEYTOKEY_AFTER_KEYUP,
          KeyCode::VK_CONFIG_FORCE_OFF_notsave_samples_keyoverlaidmodifier_use_separator_1,
          KeyCode::VK_CONFIG_FORCE_OFF_notsave_samples_keyoverlaidmodifier_use_separator_2,
        </autogen>
      </item>
      <item hidden="true">
        <identifier vk_config="true">notsave.samples_keyoverlaidmodifier_use_separator_1</identifier>
        <autogen>__ShowStatusMessage__ 1</autogen>
      </item>
      <item hidden="true">
        <identifier vk_config="true">notsave.samples_keyoverlaidmodifier_use_separator_2</identifier>
        <autogen>__ShowStatusMessage__ 2</autogen>
      </item>
      <!-- ============================================================ -->

      <item>
        <identifier>remap.samples_keyoverlaidmodifier_use_separator_2</identifier>
        <name>With @begin .. @end (2)</name>
        <appendix>Change "a" key "abc" (no repeat).</appendix>
        <appendix>(Send "def" if you press only "a" key.)</appendix>
        <autogen>
          __KeyOverlaidModifier__
          KeyCode::A, ModifierFlag::NONE,

          @begin
          <!-- hold 'a' -->
          KeyCode::A,
          KeyCode::B,
          KeyCode::C,

          Option::NOREPEAT,
          @end

          @begin
          <!-- release 'a' -->
          KeyCode::D,
          KeyCode::E,
          KeyCode::F,
          @end
        </autogen>
      </item>

      <item>
        <identifier>remap.samples_keyoverlaidmodifier_repeat_tokeys</identifier>
        <name>With Option::KEYOVERLAIDMODIFIER_REPEAT_TOKEYS</name>
        <appendix>Change "a" key "abc". (+ repeat tokeys: "123".)</appendix>
        <appendix>(Send "def" if you press only "a" key.)</appendix>
        <appendix></appendix>
        <appendix>Change the right shift key to control-f. (+ repeat tokeys: option-e)</appendix>
        <appendix>(Send "command-a" if you press only the right shift key.)</appendix>
        <appendix></appendix>
        <appendix>Change "s" key "abc". (+ repeat tokeys: "123" + norepeat.)</appendix>
        <appendix>(Send "def" if you press only "a" key.)</appendix>
        <autogen>
          __KeyOverlaidModifier__
          KeyCode::A,

          @begin
          <!-- hold 'a' -->
          KeyCode::A,
          KeyCode::B,
          KeyCode::C,
          @end

          @begin
          <!-- release 'a' -->
          KeyCode::D,
          KeyCode::E,
          KeyCode::F,
          @end

          Option::KEYOVERLAIDMODIFIER_REPEAT,

          Option::KEYOVERLAIDMODIFIER_REPEAT_TOKEYS,
          @begin
          KeyCode::KEY_1,
          KeyCode::KEY_2,
          KeyCode::KEY_3,
          @end
        </autogen>
        <autogen>
          __KeyOverlaidModifier__
          KeyCode::SHIFT_R,
          KeyCode::F, ModifierFlag::CONTROL_L,
          KeyCode::A, ModifierFlag::COMMAND_L,

          Option::KEYOVERLAIDMODIFIER_REPEAT,

          Option::KEYOVERLAIDMODIFIER_REPEAT_TOKEYS,
          KeyCode::E, ModifierFlag::OPTION_L,
        </autogen>

        <autogen>
          __KeyOverlaidModifier__
          KeyCode::S,

          <!-- You can also use __{ }__ as well as @begin, @end. -->

          <!-- hold 'a' -->
          __{ KeyCode::A, KeyCode::B, KeyCode::C, }__

          <!-- release 'a' -->
          __{ KeyCode::D, KeyCode::E, KeyCode::F, }__

          Option::KEYOVERLAIDMODIFIER_REPEAT,

          Option::KEYOVERLAIDMODIFIER_REPEAT_TOKEYS,
          __{ KeyCode::KEY_1, KeyCode::KEY_2, KeyCode::KEY_3, Option::NOREPEAT, }__
        </autogen>
      </item>

      <item>
        <identifier>remap.samples_keyoverlaidmodifier_KEYTOKEY_BEFORE_KEYDOWN</identifier>
        <name>With Option::KEYTOKEY_BEFORE_KEYDOWN, Option::KEYTOKEY_AFTER_KEYUP</name>
        <appendix>Change right shift key to option key.</appendix>
        <appendix>(Send space key event if right shift key is pressed alone.)</appendix>
        <appendix>(BeforeKeyDown Shift+B,C AfterKeyUp Option+D,Shift+E,F)</appendix>
        <appendix></appendix>
        <appendix>Change option-a to shift.</appendix>
        <appendix>(Send space key event if option-a is pressed alone.)</appendix>
        <appendix>(BeforeKeyDown Shift+B,C AfterKeyUp Option+D,Shift+E,F)</appendix>
        <appendix></appendix>
        <appendix>Change option-s to tab.</appendix>
        <appendix>(Send space key event if option-a is pressed alone.)</appendix>
        <appendix>(BeforeKeyDown Shift+B,C AfterKeyUp Option+D,Shift+E,F)</appendix>
        <autogen>
          __KeyOverlaidModifier__
          KeyCode::SHIFT_R,

          @begin
          KeyCode::OPTION_L,
          @end

          @begin
          KeyCode::SPACE,
          @end

          Option::KEYTOKEY_BEFORE_KEYDOWN,
          KeyCode::B, ModifierFlag::SHIFT_R,
          KeyCode::C,

          Option::KEYTOKEY_AFTER_KEYUP,
          KeyCode::D, ModifierFlag::OPTION_L,
          KeyCode::E, ModifierFlag::SHIFT_R,
          KeyCode::F,
        </autogen>
        <autogen>
          __KeyOverlaidModifier__
          KeyCode::A, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_OPTION,

          @begin
          KeyCode::SHIFT_L,
          @end

          @begin
          KeyCode::SPACE,
          @end

          Option::KEYTOKEY_BEFORE_KEYDOWN,
          KeyCode::B, ModifierFlag::SHIFT_R,
          KeyCode::C,

          Option::KEYTOKEY_AFTER_KEYUP,
          KeyCode::D, ModifierFlag::OPTION_L,
          KeyCode::E, ModifierFlag::SHIFT_R,
          KeyCode::F,
        </autogen>
        <autogen>
          __KeyOverlaidModifier__
          KeyCode::S, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_OPTION,

          @begin
          KeyCode::TAB,
          @end

          @begin
          KeyCode::SPACE,
          @end

          Option::KEYTOKEY_BEFORE_KEYDOWN,
          KeyCode::B, ModifierFlag::SHIFT_R,
          KeyCode::C,

          Option::KEYTOKEY_AFTER_KEYUP,
          KeyCode::D, ModifierFlag::OPTION_L,
          KeyCode::E, ModifierFlag::SHIFT_R,
          KeyCode::F,
        </autogen>
      </item>

      <item>
        <identifier>remap.samples_keyoverlaidmodifier_delayuntilrepeat</identifier>
        <name>With DelayUntilRepeat,KeyRepeat</name>
        <appendix>Change "a" key "abc". (+ repeat tokeys: "1".)</appendix>
        <appendix>(Send "def" if you press only "a" key.)</appendix>
        <appendix>(with DelayUntilRepeat::RawValue::1, KeyRepeat::RawValue::1)</appendix>
        <autogen>
          __KeyOverlaidModifier__
          KeyCode::A,

          @begin
          <!-- hold 'a' -->
          KeyCode::A,
          KeyCode::B,
          KeyCode::C,
          @end

          @begin
          <!-- release 'a' -->
          KeyCode::D,
          KeyCode::E,
          KeyCode::F,
          @end

          Option::KEYOVERLAIDMODIFIER_REPEAT,

          Option::KEYOVERLAIDMODIFIER_REPEAT_TOKEYS,
          KeyCode::KEY_1,
          DelayUntilRepeat::RawValue::1,
          KeyRepeat::RawValue::1,
        </autogen>
      </item>

    </item>

    <item>
      <name>HoldingKeyToKey</name>
      <item>
        <identifier>remap.samples_holdingkeytokey</identifier>
        <name>Standard</name>
        <appendix>Escape to Tab (+ Holding Escape to Space)</appendix>
        <appendix>Tab to A,S,Control_L+D,F (+ Holding Tab to Q,W,Shift_L+E,R)</appendix>
        <appendix>Option+Shift_R to Return (+ Holding Option+Shift_R to Space)</appendix>
        <appendix>Shift+A to Option_L+B (+ Holding Shift+A to Command_L+Return)</appendix>
        <appendix>Control+B to Option_L+B,C (+ Holding Control+B to Space)</appendix>
        <appendix>C to Space (+ Holding C to Shift_L)</appendix>
        <appendix>D to Shift_L (+ Holding D to Option_L)</appendix>
        <appendix>Shift+E to Control_L (+ Holding Shift+E to Option_L)</appendix>
        <appendix>Delete to Tab,Tab (+ Holding Escape to Space,Space)</appendix>
        <appendix>Q to Space (+ Holding Q to double-click)</appendix>
        <!-- Note: Use KeyCode::VK_NONE as a separator of parameters -->
        <autogen>__HoldingKeyToKey__ KeyCode::ESCAPE, KeyCode::TAB, KeyCode::VK_NONE, KeyCode::SPACE</autogen>
        <autogen>__HoldingKeyToKey__ KeyCode::TAB, KeyCode::A, KeyCode::S, KeyCode::D, ModifierFlag::CONTROL_L, KeyCode::F, KeyCode::VK_NONE, KeyCode::Q, KeyCode::W, KeyCode::E, ModifierFlag::SHIFT_L, KeyCode::R</autogen>
        <autogen>__HoldingKeyToKey__ KeyCode::SHIFT_R, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_OPTION, KeyCode::RETURN, KeyCode::VK_NONE, KeyCode::SPACE</autogen>
        <autogen>__HoldingKeyToKey__ KeyCode::A, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT, KeyCode::B, ModifierFlag::OPTION_L, KeyCode::VK_NONE, KeyCode::RETURN, ModifierFlag::COMMAND_L</autogen>
        <autogen>__HoldingKeyToKey__ KeyCode::B, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_CONTROL, KeyCode::B, ModifierFlag::OPTION_L, KeyCode::C, KeyCode::VK_NONE, KeyCode::SPACE</autogen>
        <autogen>__HoldingKeyToKey__ KeyCode::C, KeyCode::SPACE, KeyCode::VK_NONE, KeyCode::SHIFT_L</autogen>
        <autogen>__HoldingKeyToKey__ KeyCode::D, KeyCode::SHIFT_L, KeyCode::VK_NONE, KeyCode::OPTION_L</autogen>
        <autogen>__HoldingKeyToKey__ KeyCode::E, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT, KeyCode::CONTROL_L, KeyCode::VK_NONE, KeyCode::OPTION_L</autogen>

        <autogen>
          __HoldingKeyToKey__
          KeyCode::DELETE,

          <!-- You can use @begin and @end as a separator of parameters -->

          @begin
          KeyCode::TAB,
          KeyCode::TAB,
          @end

          @begin
          KeyCode::SPACE,
          KeyCode::SPACE,
          @end
        </autogen>

        <autogen>
          __HoldingKeyToKey__
          KeyCode::Q,

          @begin
          KeyCode::SPACE,
          @end

          @begin
          KeyCode::VK_MOUSEKEY_BUTTON_LEFT,
          KeyCode::VK_MOUSEKEY_BUTTON_LEFT,
          KeyCode::VK_NONE,
          Option::NOREPEAT,
          @end
        </autogen>
      </item>
      <item>
        <identifier>remap.samples_holdingkeytokey_modifierflag_none</identifier>
        <name>with ModifierFlag::NONE</name>
        <appendix>Escape to Tab (without any modifiers) (+ Holding Escape to Space)</appendix>
        <appendix>Shift_R to Return (without other modifiers) (+ Holding Shift_R to Space)</appendix>
        <autogen>__HoldingKeyToKey__ KeyCode::ESCAPE, ModifierFlag::NONE, KeyCode::TAB, KeyCode::VK_NONE, KeyCode::SPACE</autogen>
        <autogen>__HoldingKeyToKey__ KeyCode::SHIFT_R, ModifierFlag::SHIFT_R | ModifierFlag::NONE, KeyCode::RETURN, KeyCode::VK_NONE, KeyCode::SPACE</autogen>
      </item>
      <item>
        <identifier>remap.samples_holdingkeytokey_norepeat</identifier>
        <name>NoRepeat</name>
        <appendix>Escape to Tab (+ Holding Escape to Space)</appendix>
        <appendix>Tab to VK_NONE (+ Holding Tab to Escape)</appendix>
        <autogen>__HoldingKeyToKey__ KeyCode::ESCAPE, KeyCode::TAB, KeyCode::VK_NONE, KeyCode::SPACE, Option::NOREPEAT</autogen>
        <autogen>__HoldingKeyToKey__ KeyCode::TAB, KeyCode::VK_NONE, KeyCode::ESCAPE, Option::NOREPEAT</autogen>
      </item>
      <item>
        <identifier>remap.samples_holdingkeytokey_delayuntilrepeat</identifier>
        <name>DelayUntilRepeat, KeyRepeat</name>
        <appendix>Escape to Tab (+ Holding Escape to Space)</appendix>
        <appendix>(with DelayUntilRepeat::RawValue::1, KeyRepeat::RawValue::1)</appendix>
        <autogen>
          __HoldingKeyToKey__
          KeyCode::ESCAPE,
          @begin
          KeyCode::TAB,
          @end
          @begin
          KeyCode::SPACE,
          @end
          DelayUntilRepeat::RawValue::1,
          KeyRepeat::RawValue::1,
        </autogen>
      </item>
      <item>
        <identifier>remap.samples_holdingkeytokey_KEYTOKEY_BEFORE_KEYDOWN</identifier>
        <name>With Option::KEYTOKEY_BEFORE_KEYDOWN, Option::KEYTOKEY_AFTER_KEYUP</name>
        <appendix>Right shift key to Tab (+ Holding right shift key to Space)</appendix>
        <appendix>(BeforeKeyDown Shift+B,C AfterKeyUp Option+D,Shift+E,F)</appendix>
        <autogen>
          __HoldingKeyToKey__
          KeyCode::SHIFT_R,

          @begin
          KeyCode::TAB,
          @end

          @begin
          KeyCode::SPACE,
          @end

          Option::KEYTOKEY_BEFORE_KEYDOWN,
          KeyCode::B, ModifierFlag::SHIFT_R,
          KeyCode::C,

          Option::KEYTOKEY_AFTER_KEYUP,
          KeyCode::D, ModifierFlag::OPTION_L,
          KeyCode::E, ModifierFlag::SHIFT_R,
          KeyCode::F,
        </autogen>
      </item>
      <item>
        <identifier>remap.samples_holdingkeytokey_ThresholdMillisecond</identifier>
        <name>with ThresholdMillisecond</name>
        <appendix>Escape to Tab (+ Holding Escape to Space for 3 seconds.)</appendix>
        <appendix></appendix>
        <appendix>Note:</appendix>
        <appendix>"escape down, right shift down, escape up, right shift up" sends tab,shift.</appendix>
        <appendix>"right shift down, escape down, right shift up, escape up" sends shift,shift-tab.</appendix>
        <autogen>
          __HoldingKeyToKey__
          KeyCode::ESCAPE,
          @begin
          KeyCode::TAB,
          @end
          @begin
          KeyCode::SPACE,
          @end
          ThresholdMillisecond::RawValue::3000,
        </autogen>
      </item>
    </item>

    <item>
      <name>DoublePressModifier</name>
      <item>
        <name style="important">Note:</name>
        <appendix>DoublePressModifier always sends the first event.</appendix>
        <appendix>For example, "change shift x2 to return" sends shift,shift,return when you press shift key twice.</appendix>
        <appendix></appendix>
        <appendix>If you want to cancel the first event, please use __KeyToKey__ and </appendix>
        <appendix>Option::KEYTOKEY_DELAYED_ACTION.</appendix>
        <appendix>For example, you should use __KeyToKey__ if you want</appendix>
        <appendix>"change semicolon(;) twice to colon(:)" that sends either semicolon or colon.</appendix>
      </item>
      <item>
        <identifier>remap.samples_doublepressmodifier</identifier>
        <name>Standard</name>
        <appendix>Shift_L x2 to RETURN</appendix>
        <appendix>(A to Control_L) + (A x2 to Shift_L+RETURN)</appendix>
        <appendix>(Shift+B to Control_L+Option_L) + (Shift+B x2 to A,S,Command_L+D)</appendix>
        <appendix>(C to KeyCode::VK_NONE) + (C x2 to SPACE)</appendix>
        <appendix>(Shift+Z to KeyCode::VK_NONE) + (Shift+Z x2 to SPACE)</appendix>
        <autogen>__DoublePressModifier__ KeyCode::SHIFT_L, KeyCode::SHIFT_L, KeyCode::RETURN</autogen>
        <autogen>__DoublePressModifier__ KeyCode::A, KeyCode::CONTROL_L, KeyCode::RETURN, ModifierFlag::SHIFT_L</autogen>
        <autogen>__DoublePressModifier__ KeyCode::B, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT, KeyCode::CONTROL_L, ModifierFlag::OPTION_L, KeyCode::A, KeyCode::S, KeyCode::D, ModifierFlag::COMMAND_L</autogen>
        <autogen>__DoublePressModifier__ KeyCode::C, KeyCode::VK_NONE, KeyCode::SPACE</autogen>
        <autogen>__DoublePressModifier__ KeyCode::Z, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT, KeyCode::VK_NONE, KeyCode::SPACE</autogen>
      </item>
      <item>
        <identifier>remap.samples_doublepressmodifier_separator</identifier>
        <name>Standard with @begin .. @end</name>
        <appendix>(A to A,B,C) + (A x2 to 1,2,3)</appendix>
        <autogen>
          __DoublePressModifier__
          KeyCode::A,

          @begin
          KeyCode::A,
          KeyCode::B,
          KeyCode::C,
          @end

          @begin
          KeyCode::KEY_1,
          KeyCode::KEY_2,
          KeyCode::KEY_3,
          @end
        </autogen>
      </item>
      <item>
        <identifier>remap.samples_doublepressmodifier_extra</identifier>
        <name>Extra</name>
        <appendix>KEY_0 x3 to Equal(=)</appendix>
        <appendix>(retain KEY_0)</appendix>
        <autogen>__KeyToKey__ KeyCode::KEY_0, ModifierFlag::EXTRA1, KeyCode::EQUAL</autogen>
        <autogen>__DoublePressModifier__ KeyCode::KEY_0, KeyCode::KEY_0, KeyCode::DELETE, KeyCode::DELETE, KeyCode::VK_STICKY_EXTRA1</autogen>
      </item>
    </item>

    <item>
      <name>BlockUntilKeyUp</name>

      <item>
        <identifier>remap.samples_BlockUntilKeyUp</identifier>
        <name>Standard</name>
        <appendix>* Events are blocked until keys are released when the space key is pressed.</appendix>
        <appendix></appendix>
        <appendix>Input: <![CDATA[  Space down -> T down -> T up -> Space up:  ]]></appendix>
        <appendix>Output:</appendix>
        <appendix>- Space down</appendix>
        <appendix>- T down</appendix>
        <appendix>- T up</appendix>
        <appendix>- Space up</appendix>
        <appendix></appendix>
        <appendix>Input: <![CDATA[  Space down -> T down -> Space up -> T up:  ]]></appendix>
        <appendix>Output:</appendix>
        <appendix>- Space down</appendix>
        <appendix>- Space up</appendix>
        <appendix>- T down</appendix>
        <appendix>- T up</appendix>
        <appendix></appendix>
        <appendix>Note: __BlockUntilKeyUp__ has timeout. You have to press these keys quickly.</appendix>
        <autogen>__BlockUntilKeyUp__ KeyCode::SPACE</autogen>
      </item>

      <item>
        <identifier>remap.samples_BlockUntilKeyUp_with_KeyOverlaidModifier</identifier>
        <name>With KeyOverlaidModifier</name>
        <appendix>* Change the space key to the left shift key.</appendix>
        <appendix>* Send a space key event when the space key is pressed alone.</appendix>
        <appendix></appendix>
        <appendix>Input: <![CDATA[  Space down -> T down -> T up -> Space up:  ]]></appendix>
        <appendix>Output: Shift+T</appendix>
        <appendix></appendix>
        <appendix>Input: <![CDATA[  Space down -> T down -> Space up -> T up:  ]]></appendix>
        <appendix>Output: Shift, Space, T</appendix>
        <appendix></appendix>
        <autogen>
          __KeyOverlaidModifier__
          KeyCode::SPACE,
          KeyCode::SHIFT_L,
          KeyCode::SPACE,
        </autogen>
        <block>
          <modifier_only>ModifierFlag::SHIFT_L</modifier_only>
          <autogen>__BlockUntilKeyUp__ KeyCode::SPACE</autogen>
        </block>
      </item>

      <item>
        <identifier>remap.samples_multiple_BlockUntilKeyUp</identifier>
        <name>Multiple __BlockUntilKeyUp__</name>
        <appendix>Input: <![CDATA[  A down -> S down -> A up -> D down -> S up -> D up:  ]]></appendix>
        <appendix>Output: A, S, D</appendix>
        <autogen>__KeyOverlaidModifier__ KeyCode::A, KeyCode::VK_MODIFIER_A, KeyCode::A</autogen>
        <autogen>__KeyOverlaidModifier__ KeyCode::S, KeyCode::VK_MODIFIER_S, KeyCode::S</autogen>
        <autogen>__KeyOverlaidModifier__ KeyCode::D, KeyCode::VK_MODIFIER_D, KeyCode::D</autogen>

        <block>
          <modifier_only>ModifierFlag::A</modifier_only>
          <autogen>__BlockUntilKeyUp__ KeyCode::A</autogen>
        </block>
        <block>
          <modifier_only>ModifierFlag::S</modifier_only>
          <autogen>__BlockUntilKeyUp__ KeyCode::S</autogen>
        </block>
        <block>
          <modifier_only>ModifierFlag::D</modifier_only>
          <autogen>__BlockUntilKeyUp__ KeyCode::D</autogen>
        </block>
      </item>
    </item>

    <item>
      <name>KeyDownUpToKey</name>

      <item>
        <identifier>remap.samples_KeyDownUpToKey</identifier>
        <name>Standard</name>
        <appendix>The A key will be changed the space key</appendix>
        <appendix>when you pressed and released the A key without other keys press.</appendix>
        <appendix></appendix>
        <appendix>Input: <![CDATA[  A down -> A up:  ]]></appendix>
        <appendix>Output:</appendix>
        <appendix>- Space</appendix>
        <appendix></appendix>
        <appendix>Input: <![CDATA[  A down -> S down -> A up:  ]]></appendix>
        <appendix>Output:</appendix>
        <appendix>- A</appendix>
        <appendix>- S</appendix>
        <appendix></appendix>
        <appendix>Input: <![CDATA[  S down -> A down -> S up -> A up:  ]]></appendix>
        <appendix>Output:</appendix>
        <appendix>- S</appendix>
        <appendix>- A</appendix>
        <appendix></appendix>

        <autogen>__KeyDownUpToKey__ KeyCode::A, KeyCode::SPACE</autogen>
      </item>

      <item>
        <identifier>remap.samples_KeyDownUpToKey_2</identifier>
        <name>Change key if interrupted</name>
        <appendix>The A key will be changed the space key</appendix>
        <appendix>when you pressed and released the A key without other keys press.</appendix>
        <appendix></appendix>
        <appendix>Otherwise change the A key to the tab key</appendix>
        <appendix></appendix>
        <appendix>Input: <![CDATA[  A down -> A up:  ]]></appendix>
        <appendix>Output:</appendix>
        <appendix>- Space</appendix>
        <appendix></appendix>
        <appendix>Input: <![CDATA[  A down -> S down -> A up:  ]]></appendix>
        <appendix>Output:</appendix>
        <appendix>- Tab</appendix>
        <appendix>- S</appendix>
        <appendix></appendix>
        <appendix>Input: <![CDATA[  S down -> A down -> S up -> A up:  ]]></appendix>
        <appendix>Output:</appendix>
        <appendix>- S</appendix>
        <appendix>- Tab</appendix>
        <appendix></appendix>
        <appendix></appendix>
        <appendix>The B key will be changed the space,return key</appendix>
        <appendix>when you pressed and released the B key without other keys press.</appendix>
        <appendix>Otherwise change the B key to the tab,escape key</appendix>

        <autogen>
          __KeyDownUpToKey__
          KeyCode::A,
          __{ KeyCode::SPACE }__
          __{ KeyCode::TAB }__
        </autogen>
        <autogen>
          __KeyDownUpToKey__
          KeyCode::B,
          __{ KeyCode::SPACE, KeyCode::RETURN }__
          __{ KeyCode::TAB, KeyCode::ESCAPE }__
        </autogen>
      </item>
    </item>

    <item>
      <name>DropKeyAfterRemap</name>
      <item>
        <identifier>remap.samples_dropkeyafterremap</identifier>
        <name>Standard</name>
        <appendix>Drop Tab</appendix>
        <appendix>Drop Shift+Return</appendix>
        <appendix>Drop Option+Return (if no other modifiers are not pressed)</appendix>
        <appendix>Change A to Tab (== dropped)</appendix>
        <appendix>Change B to Shift_L+Return (== dropped)</appendix>
        <appendix>Change C to Option_L+Return (== dropped)</appendix>
        <appendix></appendix>
        <appendix>Control+C will be Control+Option+Return and it will not be dropped.</appendix>
        <autogen>__KeyToKey__ KeyCode::A, KeyCode::TAB</autogen>
        <autogen>__DropKeyAfterRemap__ KeyCode::TAB</autogen>
        <autogen>__DropKeyAfterRemap__ KeyCode::RETURN, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT</autogen>
        <autogen>__DropKeyAfterRemap__ KeyCode::RETURN, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_OPTION | ModifierFlag::NONE</autogen>
        <autogen>__KeyToKey__ KeyCode::B, KeyCode::RETURN, ModifierFlag::SHIFT_L</autogen>
        <autogen>__KeyToKey__ KeyCode::C, KeyCode::RETURN, ModifierFlag::OPTION_L</autogen>
      </item>
    </item>

    <item>
      <name>DropAllKeys</name>
      <item>
        <identifier>remap.samples_DropAllKeys</identifier>
        <appendix>Drop all key combinations while the right option key is pressed.</appendix>
        <appendix>(Except option-qwer)</appendix>
        <appendix>(__DropAllKeys__ does not drop modifier events.)</appendix>
        <appendix></appendix>
        <appendix>With "change S to left shift key".</appendix>
        <appendix>(option-S sends option,shift key events.)</appendix>
        <appendix>(option-S-Q will be option-shift-Q, option-S-A will be ignored.)</appendix>
        <autogen>__KeyToKey__ KeyCode::Q, ModifierFlag::OPTION_R, KeyCode::Q, ModifierFlag::OPTION_R</autogen>
        <autogen>__KeyToKey__ KeyCode::W, ModifierFlag::OPTION_R, KeyCode::W, ModifierFlag::OPTION_R</autogen>
        <autogen>__KeyToKey__ KeyCode::E, ModifierFlag::OPTION_R, KeyCode::E, ModifierFlag::OPTION_R</autogen>
        <autogen>__KeyToKey__ KeyCode::R, ModifierFlag::OPTION_R, KeyCode::R, ModifierFlag::OPTION_R</autogen>
        <autogen>
          __DropAllKeys__
          <!-- You have to specify ModifierFlag to __DropAllKeys__. -->
          <!-- ModifierFlag::NONE is not permitted. -->
          ModifierFlag::OPTION_R,

          Option::DROPALLKEYS_DROP_KEY,
          Option::DROPALLKEYS_DROP_CONSUMERKEY,
          Option::DROPALLKEYS_DROP_POINTINGBUTTON,
        </autogen>
        <!-- Settings after __DropAllKeys__ will be ignored. -->
        <autogen>__KeyToKey__ KeyCode::A, ModifierFlag::OPTION_R, KeyCode::A, ModifierFlag::OPTION_R</autogen>
        <!-- However, modifier flags are enabled even if it is changed after __DropAllKeys__. -->
        <autogen>__KeyToKey__ KeyCode::S, ModifierFlag::OPTION_R, KeyCode::SHIFT_L, ModifierFlag::OPTION_R</autogen>
      </item>
      <item>
        <identifier>remap.samples_DropAllKeys_key</identifier>
        <appendix>Drop all keys while the right option key is pressed.</appendix>
        <autogen>
          __DropAllKeys__
          ModifierFlag::OPTION_R,

          Option::DROPALLKEYS_DROP_KEY,
        </autogen>
      </item>
      <item>
        <identifier>remap.samples_DropAllKeys_consumerkey</identifier>
        <appendix>Drop all consumer keys while the right option key is pressed.</appendix>
        <autogen>
          __DropAllKeys__
          ModifierFlag::OPTION_R,

          Option::DROPALLKEYS_DROP_CONSUMERKEY,
        </autogen>
      </item>
      <item>
        <identifier>remap.samples_DropAllKeys_pointingbutton</identifier>
        <appendix>Drop all pointing buttons while the right option key is pressed.</appendix>
        <autogen>
          __DropAllKeys__
          ModifierFlag::OPTION_R,

          Option::DROPALLKEYS_DROP_POINTINGBUTTON,
        </autogen>
      </item>
    </item>

    <item>
      <name>DropPointingRelativeCursorMove</name>
      <item>
        <identifier>remap.samples_droppointingrelativecursormove_config</identifier>
        <name>Standard</name>
        <appendix>A to toggle DropPointingRelativeCursorMove</appendix>
        <autogen>__KeyToKey__ KeyCode::A, KeyCode::VK_CONFIG_TOGGLE_remap_samples_droppointingrelativecursormove</autogen>
      </item>
      <item>
        <identifier vk_config="true">remap.samples_droppointingrelativecursormove</identifier>
        <name>Core</name>
        <appendix>(You need enable above setting.)</appendix>
        <config_only>remap.samples_droppointingrelativecursormove_config</config_only>
        <autogen>__ShowStatusMessage__ DropCursorMove</autogen>
        <autogen>__DropPointingRelativeCursorMove__</autogen>
      </item>
    </item>

    <item>
      <name>DropScrollWheel</name>
      <item>
        <identifier>remap.samples_dropscrollwheel</identifier>
        <name>Drop ScrollWheel at Emacs</name>
        <only>EMACS</only>
        <autogen>__DropScrollWheel__</autogen>
      </item>
      <item>
        <identifier>remap.samples_dropscrollwheel_horizontal_scroll</identifier>
        <name>Drop Horizontal Scroll</name>
        <autogen>__DropScrollWheel__ Option::DROPSCROLLWHEEL_DROP_HORIZONTAL_SCROLL</autogen>
      </item>
      <item>
        <identifier>remap.samples_dropscrollwheel_momentum_scroll</identifier>
        <name>Drop momentum (inertia) scrolling on safari</name>
        <only>SAFARI</only>
        <autogen>__DropScrollWheel__ Option::DROPSCROLLWHEEL_DROP_MOMENTUM_SCROLL</autogen>
      </item>
    </item>

    <item>
      <name>FlipPointingRelative</name>
      <item>
        <identifier>remap.samples_flippointingrelative</identifier>
        <name>Flip Horizontal and Vertical PointingRelative at Safari</name>
        <only>SAFARI</only>
        <autogen>
          __FlipPointingRelative__
          Option::FLIPPOINTINGRELATIVE_HORIZONTAL,
          Option::FLIPPOINTINGRELATIVE_VERTICAL,
        </autogen>
      </item>
      <item>
        <identifier>remap.samples_flippointingrelative_horizontal</identifier>
        <name>Flip Horizontal PointingRelative at Safari</name>
        <only>SAFARI</only>
        <autogen>
          __FlipPointingRelative__
          Option::FLIPPOINTINGRELATIVE_HORIZONTAL,
        </autogen>
      </item>
      <item>
        <identifier>remap.samples_flippointingrelative_vertical</identifier>
        <name>Flip Vertical PointingRelative at Safari</name>
        <only>SAFARI</only>
        <autogen>
          __FlipPointingRelative__
          Option::FLIPPOINTINGRELATIVE_VERTICAL,
        </autogen>
      </item>
    </item>

    <item>
      <name>FlipScrollWheel</name>
      <item>
        <identifier>remap.samples_flipscrollwheel</identifier>
        <name>Flip Horizontal and Vertical ScrollWheel at Safari</name>
        <only>SAFARI</only>
        <autogen>
          __FlipScrollWheel__
          Option::FLIPSCROLLWHEEL_HORIZONTAL,
          Option::FLIPSCROLLWHEEL_VERTICAL,
        </autogen>
      </item>
      <item>
        <identifier>remap.samples_flipscrollwheel_horizontal</identifier>
        <name>Flip Horizontal ScrollWheel at Safari</name>
        <only>SAFARI</only>
        <autogen>
          __FlipScrollWheel__
          Option::FLIPSCROLLWHEEL_HORIZONTAL,
        </autogen>
      </item>
      <item>
        <identifier>remap.samples_flipscrollwheel_vertical</identifier>
        <name>Flip Vertical ScrollWheel at Safari</name>
        <only>SAFARI</only>
        <autogen>
          __FlipScrollWheel__
          Option::FLIPSCROLLWHEEL_VERTICAL,
        </autogen>
      </item>
      <item>
        <identifier>remap.samples_flipscrollwheel_rotate</identifier>
        <name>Rotate ScrollWheel when option key is pressed.</name>
        <modifier_only>
          ModifierFlag::OPTION_L,
          ModifierFlag::OPTION_R,
        </modifier_only>
        <autogen>
          __FlipScrollWheel__
          Option::FLIPSCROLLWHEEL_ROTATE,
        </autogen>
      </item>
      <item>
        <identifier>remap.samples_flipscrollwheel_rotate_reverse</identifier>
        <name>Rotate ScrollWheel when option key is pressed. (reverse)</name>
        <modifier_only>
          ModifierFlag::OPTION_L,
          ModifierFlag::OPTION_R,
        </modifier_only>
        <autogen>
          __FlipScrollWheel__
          Option::FLIPSCROLLWHEEL_HORIZONTAL,
          Option::FLIPSCROLLWHEEL_VERTICAL,
          Option::FLIPSCROLLWHEEL_ROTATE,
        </autogen>
      </item>
    </item>

    <item>
      <name>IgnoreMultipleSameKeyPress</name>
      <item>
        <identifier>remap.samples_ignoremultiplesamekeypress</identifier>
        <name>Standard</name>
        <appendix>Ignore the multiple press of 'A'</appendix>
        <appendix>Ignore the multiple press of 'Shift+B' (with Modifier)</appendix>
        <appendix>Ignore the multiple press of 'Shift+Option+C' (with Modifier)</appendix>
        <autogen>__IgnoreMultipleSameKeyPress__ KeyCode::A</autogen>
        <autogen>__IgnoreMultipleSameKeyPress__ KeyCode::B, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT</autogen>
        <autogen>__IgnoreMultipleSameKeyPress__ KeyCode::C, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT | MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_OPTION</autogen>
      </item>
    </item>

    <item>
      <name>StripModifierFromScrollWheel</name>
      <item>
        <identifier>remap.samples_stripmodifierfromscrollwheel</identifier>
        <name>Standard</name>
        <appendix>Shift_L+ScrollWheel to ScrollWheel (strip Shift)</appendix>
        <appendix>Option+ScrollWheel to ScrollWheel (strip Option)</appendix>
        <autogen>__StripModifierFromScrollWheel__ ModifierFlag::SHIFT_L</autogen>
        <autogen>__StripModifierFromScrollWheel__ MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_OPTION</autogen>
      </item>
      <item>
        <identifier>remap.samples_stripmodifierfromscrollwheel_any</identifier>
        <name>MODIFIERFLAGS_ANY</name>
        <appendix>Any Modifiers+ScrollWheel to ScrollWheel (strip Any Modifiers)</appendix>
        <autogen>__StripModifierFromScrollWheel__ MODIFIERFLAGS_ANY</autogen>
      </item>
    </item>

    <item>
      <name>ScrollWheelToScrollWheel</name>
      <item>
        <identifier>remap.samples_ScrollWheelToScrollWheel</identifier>
        <name>Standard</name>
        <appendix>Shift_L+ScrollWheel to Control_L+ScrollWheel</appendix>
        <autogen>__ScrollWheelToScrollWheel__ ModifierFlag::SHIFT_L, ModifierFlag::CONTROL_L</autogen>
      </item>
    </item>

    <item>
      <name>ScrollWheelToKey</name>
      <item>
        <identifier>remap.samples_ScrollWheelToKey</identifier>
        <name>Standard</name>
        <appendix>ScrollWheel to Left/Right</appendix>
        <appendix>Shift+ScrollWheel to Option+Up/Down/Left/Right</appendix>
        <autogen>__ScrollWheelToKey__ ScrollWheel::LEFT,  ModifierFlag::NONE, KeyCode::CURSOR_LEFT</autogen>
        <autogen>__ScrollWheelToKey__ ScrollWheel::RIGHT, ModifierFlag::NONE, KeyCode::CURSOR_RIGHT</autogen>

        <autogen>__ScrollWheelToKey__ ScrollWheel::UP,    MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT, KeyCode::CURSOR_UP,    ModifierFlag::OPTION_L</autogen>
        <autogen>__ScrollWheelToKey__ ScrollWheel::DOWN,  MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT, KeyCode::CURSOR_DOWN,  ModifierFlag::OPTION_L</autogen>
        <autogen>__ScrollWheelToKey__ ScrollWheel::LEFT,  MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT, KeyCode::CURSOR_LEFT,  ModifierFlag::OPTION_L</autogen>
        <autogen>__ScrollWheelToKey__ ScrollWheel::RIGHT, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT, KeyCode::CURSOR_RIGHT, ModifierFlag::OPTION_L</autogen>
      </item>
      <item>
        <identifier>remap.samples_ScrollWheelToKey2</identifier>
        <name>Standard (2)</name>
        <appendix>ScrollWheel(Left) to Volume Down</appendix>
        <appendix>ScrollWheel(Right) to Volume Up</appendix>
        <appendix>ScrollWheel(Down) to Left Click</appendix>
        <appendix>ScrollWheel(Up) to Right Click</appendix>
        <autogen>__ScrollWheelToKey__ ScrollWheel::LEFT,  ConsumerKeyCode::VOLUME_DOWN</autogen>
        <autogen>__ScrollWheelToKey__ ScrollWheel::RIGHT, ConsumerKeyCode::VOLUME_UP</autogen>
        <autogen>__ScrollWheelToKey__ ScrollWheel::DOWN,  PointingButton::LEFT</autogen>
        <autogen>__ScrollWheelToKey__ ScrollWheel::UP,    PointingButton::RIGHT</autogen>
      </item>
    </item>

    <item>
      <name>SimultaneousKeyPresses</name>
      <item>
        <identifier>remap.samples_simultaneouskeypresses_keytokey</identifier>
        <name>KeyToKey</name>
        <appendix>(A+J to Down)</appendix>
        <appendix>(A+K to Up)</appendix>
        <appendix>(A+S to A,S,A,J)</appendix>
        <appendix>(A+D to A,Shift_L+S,Control_L+D,F)</appendix>
        <appendix>(A+G to Shift_L)</appendix>
        <appendix>(Command_R+[E+R] to Space)</appendix>
        <appendix>(Command_R+[R+T] to Option+Space)</appendix>
        <appendix>(Control_L+[R+T] to Shift_L)</appendix>
        <appendix>(R+T to Delete)</appendix>
        <appendix>(Fn+[K+L] to Space)</appendix>
        <appendix>(Shift_L+Shift_R to Space)</appendix>
        <appendix>(Control_L+Option_L to Fn)</appendix>
        <appendix>Return to Space</appendix>
        <appendix>(Z+X to Return (== to Return))</appendix>
        <appendix>(X+C to Return with Option::SIMULTANEOUSKEYPRESSES_RAW (== to Space))</appendix>
        <appendix>(W+E to Escape if application == TERMINAL)</appendix>
        <appendix>(Q+W to Escape if Input Source == English)</appendix>
        <autogen>__SimultaneousKeyPresses__ KeyCode::J, KeyCode::A, KeyCode::CURSOR_DOWN</autogen>
        <autogen>__SimultaneousKeyPresses__ KeyCode::K, KeyCode::A, KeyCode::CURSOR_UP</autogen>
        <autogen>__SimultaneousKeyPresses__ KeyCode::S, KeyCode::A, KeyCode::A, KeyCode::S, KeyCode::A, KeyCode::J</autogen>
        <autogen>__SimultaneousKeyPresses__ KeyCode::D, KeyCode::A, KeyCode::A, KeyCode::S, ModifierFlag::SHIFT_L, KeyCode::D, ModifierFlag::CONTROL_L, KeyCode::F</autogen>
        <autogen>__SimultaneousKeyPresses__ KeyCode::G, KeyCode::A, KeyCode::SHIFT_L</autogen>
        <autogen>__SimultaneousKeyPresses__ KeyCode::R, KeyCode::E, ModifierFlag::COMMAND_R, KeyCode::SPACE</autogen>
        <autogen>__SimultaneousKeyPresses__ KeyCode::T, KeyCode::R, ModifierFlag::COMMAND_R, KeyCode::SPACE, ModifierFlag::OPTION_L</autogen>
        <autogen>__SimultaneousKeyPresses__ KeyCode::T, KeyCode::R, ModifierFlag::CONTROL_L, KeyCode::SHIFT_L</autogen>
        <autogen>__SimultaneousKeyPresses__ KeyCode::T, KeyCode::R, KeyCode::DELETE</autogen>
        <autogen>__SimultaneousKeyPresses__ KeyCode::L, KeyCode::K, ModifierFlag::FN, KeyCode::SPACE</autogen>
        <autogen>__SimultaneousKeyPresses__ KeyCode::SHIFT_L, KeyCode::SHIFT_R, KeyCode::SPACE</autogen>
        <autogen>__SimultaneousKeyPresses__ KeyCode::CONTROL_L, KeyCode::OPTION_L, KeyCode::FN</autogen>
        <autogen>__KeyToKey__ KeyCode::RETURN, KeyCode::SPACE</autogen>
        <autogen>__SimultaneousKeyPresses__ KeyCode::X, KeyCode::Z, KeyCode::RETURN</autogen>
        <autogen>__SimultaneousKeyPresses__ KeyCode::C, KeyCode::X, KeyCode::RETURN, Option::SIMULTANEOUSKEYPRESSES_RAW</autogen>
        <block>
          <only>TERMINAL</only>
          <autogen>__SimultaneousKeyPresses__ KeyCode::E, KeyCode::W, KeyCode::ESCAPE</autogen>
        </block>
        <block>
          <inputsource_only>ENGLISH</inputsource_only>
          <autogen>__SimultaneousKeyPresses__ KeyCode::W, KeyCode::Q, KeyCode::ESCAPE</autogen>
        </block>
      </item>
      <item>
        <identifier>remap.samples_simultaneouskeypresses_consumer</identifier>
        <name>Consumer</name>
        <appendix>Volume Down+Volume Up to Mute</appendix>
        <autogen>
          __SimultaneousKeyPresses__
          __{ ConsumerKeyCode::VOLUME_DOWN, ConsumerKeyCode::VOLUME_UP, }__
          ConsumerKeyCode::VOLUME_MUTE,
        </autogen>
      </item>
      <item>
        <identifier>remap.samples_simultaneouskeypresses_buttontobutton</identifier>
        <name>ButtonToButton</name>
        <appendix>Shift+LeftClick+RightClick to Button4</appendix>
        <appendix>LeftClick+RightClick to MiddleClick</appendix>
        <autogen>__SimultaneousKeyPresses__ PointingButton::LEFT, PointingButton::RIGHT, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT, PointingButton::BUTTON4</autogen>
        <autogen>__SimultaneousKeyPresses__ PointingButton::LEFT, PointingButton::RIGHT, PointingButton::MIDDLE</autogen>
      </item>
      <item>
        <identifier>remap.samples_simultaneouskeypresses_keytobutton</identifier>
        <name>KeyToButton</name>
        <appendix>[A+S] to RightClick</appendix>
        <appendix>Shift+[S+D] to MiddleClick</appendix>
        <autogen>__SimultaneousKeyPresses__ KeyCode::S, KeyCode::A, PointingButton::RIGHT</autogen>
        <autogen>__SimultaneousKeyPresses__ KeyCode::D, KeyCode::S, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT, PointingButton::MIDDLE</autogen>
      </item>
      <item>
        <identifier>remap.samples_simultaneouskeypresses_buttontokey</identifier>
        <name>ButtonToKey</name>
        <appendix>Shift+LeftClick+RightClick to Space</appendix>
        <appendix>LeftClick+RightClick to Return</appendix>
        <autogen>__SimultaneousKeyPresses__ PointingButton::LEFT, PointingButton::RIGHT, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT, KeyCode::SPACE</autogen>
        <autogen>__SimultaneousKeyPresses__ PointingButton::LEFT, PointingButton::RIGHT, KeyCode::RETURN</autogen>
      </item>
      <item>
        <identifier>remap.samples_simultaneouskeypresses_norepeat</identifier>
        <name>NoRepeat</name>
        <appendix>(A+J to Down)</appendix>
        <appendix>LeftClick+RightClick to Return</appendix>
        <autogen>__SimultaneousKeyPresses__ KeyCode::J, KeyCode::A, KeyCode::CURSOR_DOWN, Option::NOREPEAT</autogen>
        <autogen>__SimultaneousKeyPresses__ PointingButton::LEFT, PointingButton::RIGHT, KeyCode::RETURN, Option::NOREPEAT</autogen>
      </item>
      <item>
        <identifier>remap.samples_simultaneouskeypresses_delayuntilrepeat</identifier>
        <name>DelayUntilRepeat, KeyRepeat</name>
        <appendix>A+J to Down (with DelayUntilRepeat::RawValue::1, KeyRepeat::RawValue::1)</appendix>
        <autogen>
          __SimultaneousKeyPresses__
          @begin
          KeyCode::J, KeyCode::A,
          @end
          KeyCode::CURSOR_DOWN,
          DelayUntilRepeat::RawValue::1,
          KeyRepeat::RawValue::1,
        </autogen>
      </item>
      <item>
        <identifier>remap.samples_simultaneouskeypresses_strict_key_order</identifier>
        <name>Strict Key Order</name>
        <appendix>[Strict] S+D to Right</appendix>
        <appendix>[Strict] D+S to Left</appendix>
        <appendix>[Strict] D+F to Up</appendix>
        <appendix>[Normal] J+K to Space)</appendix>
        <appendix>[Normal] K+J to Space)</appendix>
        <autogen>
          __SimultaneousKeyPresses__
          KeyCode::S, KeyCode::D,
          KeyCode::CURSOR_RIGHT,
          Option::SIMULTANEOUSKEYPRESSES_STRICT_KEY_ORDER
        </autogen>
        <autogen>
          __SimultaneousKeyPresses__
          KeyCode::D, KeyCode::S,
          KeyCode::CURSOR_LEFT,
          Option::SIMULTANEOUSKEYPRESSES_STRICT_KEY_ORDER
        </autogen>
        <autogen>
          __SimultaneousKeyPresses__
          KeyCode::D, KeyCode::F,
          KeyCode::CURSOR_UP,
          Option::SIMULTANEOUSKEYPRESSES_STRICT_KEY_ORDER
        </autogen>
        <autogen>
          __SimultaneousKeyPresses__
          KeyCode::J, KeyCode::K,
          KeyCode::SPACE,
        </autogen>
      </item>
      <item>
        <identifier>remap.samples_simultaneouskeypresses_separator</identifier>
        <name>Using more than three keys</name>
        <appendix>(S+D+F to Expose)</appendix>
        <appendix>(Q+W+E+R to Space)</appendix>
        <appendix>(J+K+L to Escape) (Strict Key Order)</appendix>
        <autogen>
          __SimultaneousKeyPresses__
          @begin
          KeyCode::S, KeyCode::D, KeyCode::F,
          @end

          @begin
          KeyCode::EXPOSE_ALL,
          @end
        </autogen>
        <autogen>
          __SimultaneousKeyPresses__
          @begin
          KeyCode::Q, KeyCode::W, KeyCode::E, KeyCode::R,
          @end

          @begin
          KeyCode::SPACE,
          @end
        </autogen>
        <autogen>
          __SimultaneousKeyPresses__
          @begin
          KeyCode::J, KeyCode::K, KeyCode::L,
          @end

          @begin
          KeyCode::ESCAPE,
          Option::SIMULTANEOUSKEYPRESSES_STRICT_KEY_ORDER,
          @end
        </autogen>
      </item>
      <item>
        <identifier>remap.samples_simultaneouskeypresses_SIMULTANEOUSKEYPRESSES_POST_FROM_EVENTS_AS_RAW</identifier>
        <name>With Option::SIMULTANEOUSKEYPRESSES_POST_FROM_EVENTS_AS_RAW</name>
        <appendix></appendix>
        <appendix>Change D+F to lock control key.</appendix>
        <appendix>* Unlock control key by escape key.</appendix>
        <appendix>* Change D key to left shift key when control is locked.</appendix>
        <appendix>* Change F key to left option key when control is locked.</appendix>
        <appendix></appendix>
        <appendix>When you press D+F, shift and option modifiers will be active until you release D,F keys.</appendix>
        <appendix><![CDATA[  * D down, F down, D up -> control down, shift down, option down, shift up  ]]></appendix>
        <appendix><![CDATA[  * D down, F down, F up -> control down, shift down, option down, option up  ]]></appendix>
        <appendix></appendix>
        <appendix></appendix>
        <appendix>Change F+G to EXTRA1 modifier key.</appendix>
        <appendix>* Change F key to left shift key when extra1 is pressed.</appendix>
        <appendix>* Change G key to left option key when extra1 is pressed.</appendix>
        <appendix></appendix>
        <autogen>
          __SimultaneousKeyPresses__
          __{ KeyCode::D, KeyCode::F, }__
          KeyCode::VK_LOCK_CONTROL_L_FORCE_ON,
          <!-- The D and F key will be sent and modified by below __KeyToKey__. -->
          Option::SIMULTANEOUSKEYPRESSES_POST_FROM_EVENTS_AS_RAW,

          <!--
              Note:
              The from events will be posted by the defined order.
              For example, the from events are always posted by D,F order
              even if you press them F,D order.
          -->
        </autogen>

        <!-- with virtual modifier -->
        <autogen>
          __SimultaneousKeyPresses__
          __{ KeyCode::F, KeyCode::G, }__
          KeyCode::VK_MODIFIER_EXTRA1,
          Option::SIMULTANEOUSKEYPRESSES_POST_FROM_EVENTS_AS_RAW,
        </autogen>

        <block>
          <modifierlocked_only>ModifierFlag::CONTROL_L</modifierlocked_only>
          <autogen>__KeyToKey__ KeyCode::D, KeyCode::SHIFT_L</autogen>
          <autogen>__KeyToKey__ KeyCode::F, KeyCode::OPTION_L</autogen>
          <autogen>__KeyToKey__ KeyCode::ESCAPE, KeyCode::VK_LOCK_CONTROL_L_FORCE_OFF</autogen>
        </block>

        <block>
          <modifier_only>ModifierFlag::EXTRA1</modifier_only>
          <!-- increase ModifierFlag::EXTRA1 to enable this setting in the case "F down, G down, F up, F down, G up, G down" -->
          <autogen>__KeyToKey__ KeyCode::F, KeyCode::SHIFT_L, ModifierFlag::EXTRA1</autogen>
          <autogen>__KeyToKey__ KeyCode::G, KeyCode::OPTION_L, ModifierFlag::EXTRA1</autogen>
        </block>
      </item>
      <item>
        <name>Note:</name>
        <appendix>Basically, a sending key will not be modified by other manipulators such as __KeyToKey__.</appendix>
        <appendix>Option::SIMULTANEOUSKEYPRESSES_RAW removes this restriction.</appendix>
        <appendix>This option allows you to modify a sending key once more by __KeyToKey__.</appendix>
        <appendix></appendix>
        <name>──────────────────────────────</name>
        <appendix>For example:</appendix>
        <appendix>A space key event is sent when you press Q and W keys simultaneously with following rules.</appendix>
        <appendix></appendix>
        <appendix>- Simultaneous [Q+W] to Return with Option::SIMULTANEOUSKEYPRESSES_RAW</appendix>
        <appendix>- Return to Space</appendix>
        <appendix></appendix>
        <appendix>__SimultaneousKeyPresses__ changes Q+W to Return and</appendix>
        <appendix>__KeyToKey__ changes Return to Space. So, Q+W becomes a space key event.</appendix>
        <name>──────────────────────────────</name>
        <appendix></appendix>
        <appendix>There are two limitations of Option::SIMULTANEOUSKEYPRESSES_RAW.</appendix>
        <appendix></appendix>
        <appendix>Limitation 1:</appendix>
        <appendix>This option strips modifiers from a sending key.</appendix>
        <appendix>For example, when you use Option::SIMULTANEOUSKEYPRESSES_RAW,</appendix>
        <appendix>"[Q+W] to Shift+Return" acts as "[Q+W] to Return".</appendix>
        <appendix>Please append modifiers to a sending key by __KeyToKey__ or other manipulators.</appendix>
        <appendix></appendix>
        <appendix>Limitation 2:</appendix>
        <appendix>This option does not send multiple keys. Only the first key will be sent.</appendix>
        <appendix>For example, when you use Option::SIMULTANEOUSKEYPRESSES_RAW,</appendix>
        <appendix>"[Q+W] to A,S,D,F" acts as "[Q+W] to A".</appendix>
        <appendix>Please send multiple keys by __KeyToKey__ or other manipulators.</appendix>
      </item>
    </item>

    <item>
      <name>PointingRelativeToScroll</name>
      <item>
        <identifier>remap.samples_pointingrelativetoscroll</identifier>
        <name>Standard</name>
        <appendix>MiddleClick+CursorMove to ScrollWheel (One Button)</appendix>
        <appendix>Option+CursorMove to ScrollWheel (Modifier)</appendix>
        <appendix>Shift+LeftClick+CursorMove to ScrollWheel (Button+Modifier)</appendix>
        <autogen>__PointingRelativeToScroll__ PointingButton::MIDDLE</autogen>
        <autogen>__PointingRelativeToScroll__ PointingButton::NONE, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_OPTION</autogen>
        <autogen>__PointingRelativeToScroll__ PointingButton::LEFT, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT</autogen>
      </item>
      <item>
        <identifier>remap.samples_pointingrelativetoscroll_keycode</identifier>
        <name>With KeyCode, ConsumerKeyCode</name>
        <appendix>Space+CursorMove to ScrollWheel</appendix>
        <appendix>Left Shift+CursorMove to ScrollWheel (Left Shift will not work as modifier.)</appendix>
        <appendix>Option+Q+CursorMove to ScrollWheel</appendix>
        <appendix>Volume Mute+CursorMove to ScrollWheel</appendix>
        <appendix></appendix>
        <appendix>Difference between KeyCode::SHIFT_L and ModifierFlag::SHIFT_L:</appendix>
        <appendix>* __PointingRelativeToScroll__ KeyCode::SHIFT_L</appendix>
        <appendix>===&gt; Left Shift will not work as modifier.</appendix>
        <appendix>* __PointingRelativeToScroll__ ModifierFlag::SHIFT_L</appendix>
        <appendix>===&gt; Left Shift will work as modifier.</appendix>
        <autogen>__PointingRelativeToScroll__ KeyCode::SPACE</autogen>
        <autogen>__PointingRelativeToScroll__ KeyCode::SHIFT_L</autogen>
        <autogen>__PointingRelativeToScroll__ KeyCode::Q, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_OPTION</autogen>
        <autogen>__PointingRelativeToScroll__ ConsumerKeyCode::VOLUME_MUTE</autogen>
      </item>
      <item>
        <identifier>remap.samples_pointingrelativetoscroll_with_toflags</identifier>
        <name>With ToFlags</name>
        <appendix>Command+CursorMove to Command+ScrollWheel</appendix>
        <appendix>Option+CursorMove to Control+ScrollWheel</appendix>
        <appendix>RightClick+CursorMove to Control+ScrollWheel</appendix>
        <autogen>
          __PointingRelativeToScroll__
          MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_COMMAND,
          Option::POINTINGRELATIVETOSCROLL_TOFLAGS,
          MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_COMMAND
        </autogen>
        <autogen>
          __PointingRelativeToScroll__
          MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_OPTION,
          Option::POINTINGRELATIVETOSCROLL_TOFLAGS,
          ModifierFlag::CONTROL_L
        </autogen>
        <autogen>
          __PointingRelativeToScroll__
          PointingButton::RIGHT,
          Option::POINTINGRELATIVETOSCROLL_TOFLAGS,
          ModifierFlag::CONTROL_L
        </autogen>
      </item>
      <item>
        <identifier>remap.samples_pointingrelativetoscroll_with_tokeys</identifier>
        <name>With ToButtons</name>
        <appendix>Change RightClick to MiddleClick</appendix>
        <appendix>+ (RightClick+CursorMove to ScrollWheel)</appendix>
        <appendix></appendix>
        <appendix>Change Shift+LeftClick to Option+A,B</appendix>
        <appendix>+ (Shift+LeftClick+CursorMove to ScrollWheel)</appendix>
        <appendix></appendix>
        <appendix>Change Option+LeftClick to Volume Mute</appendix>
        <appendix>+ (Option+LeftClick+CursorMove to ScrollWheel)</appendix>
        <appendix></appendix>
        <autogen>
          __PointingRelativeToScroll__
          PointingButton::RIGHT,

          Option::POINTINGRELATIVETOSCROLL_TOKEYS,
          PointingButton::MIDDLE,
        </autogen>
        <autogen>
          __PointingRelativeToScroll__
          PointingButton::LEFT, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT,

          Option::POINTINGRELATIVETOSCROLL_TOKEYS,
          KeyCode::A, ModifierFlag::OPTION_L,
          KeyCode::B,
        </autogen>
        <autogen>
          __PointingRelativeToScroll__
          PointingButton::LEFT, MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_OPTION,

          Option::POINTINGRELATIVETOSCROLL_TOKEYS,
          ConsumerKeyCode::VOLUME_MUTE,
        </autogen>
      </item>

      <item>
        <identifier>remap.samples_pointingrelativetoscroll_with_flipscrollwheel</identifier>
        <name>With FlipScrollWheel</name>
        <appendix>Option+CursorMove to ScrollWheel (Modifier)</appendix>
        <appendix>+ (Flip vertically in Safari)</appendix>
        <appendix>+ (Flip horizontally in Preview)</appendix>
        <appendix></appendix>
        <block>
          <only>SAFARI</only>
          <autogen>
            __PointingRelativeToScroll__
            MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_OPTION,

            Option::FLIPSCROLLWHEEL_VERTICAL,
          </autogen>
        </block>
        <block>
          <only>PREVIEW</only>
          <autogen>
            __PointingRelativeToScroll__
            MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_OPTION,

            Option::FLIPSCROLLWHEEL_HORIZONTAL,
          </autogen>
        </block>
        <autogen>
          __PointingRelativeToScroll__
          MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_OPTION,
        </autogen>
      </item>

      <item hidden="true">
        <identifier vk_config="true">notsave.samples_pointing_relative_to_scroll</identifier>
        <autogen>__PointingRelativeToScroll__ PointingButton::NONE</autogen>
      </item>
      <item>
        <identifier>remap.samples_pointingrelativetoscroll_simultaneouskeypresses</identifier>
        <name>SimultaneousKeyPresses</name>
        <appendix>LeftClick+RightClick+CursorMove to ScrollWheel</appendix>
        <autogen>__SimultaneousKeyPresses__ PointingButton::LEFT, PointingButton::RIGHT, KeyCode::VK_CONFIG_SYNC_KEYDOWNUP_notsave_samples_pointing_relative_to_scroll</autogen>
      </item>
    </item>

    <item>
      <name>PointingRelativeToKey</name>
      <item>
        <identifier>remap.samples_pointingrelativetokey</identifier>
        <name>Standard</name>
        <appendix>CursorMove without modifiers to Arrows</appendix>
        <appendix>Option+CursorMove to Shift+Arrows</appendix>
        <appendix>Shift+CursorMove to Launchpad</appendix>
        <appendix>(You can move pointer by Command+CursorMove)</appendix>

        <autogen>
          __PointingRelativeToKey__
          ModifierFlag::NONE,

          PointingRelative::UP,    KeyCode::CURSOR_UP,
          PointingRelative::DOWN,  KeyCode::CURSOR_DOWN,
          PointingRelative::LEFT,  KeyCode::CURSOR_LEFT,
          PointingRelative::RIGHT, KeyCode::CURSOR_RIGHT,
        </autogen>
        <autogen>
          __PointingRelativeToKey__
          MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_OPTION,

          PointingRelative::UP,    KeyCode::CURSOR_UP,    ModifierFlag::SHIFT_L,
          PointingRelative::DOWN,  KeyCode::CURSOR_DOWN,  ModifierFlag::SHIFT_L,
          PointingRelative::LEFT,  KeyCode::CURSOR_LEFT,  ModifierFlag::SHIFT_L,
          PointingRelative::RIGHT, KeyCode::CURSOR_RIGHT, ModifierFlag::SHIFT_L,
        </autogen>
        <autogen>
          __PointingRelativeToKey__
          MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_SHIFT,

          PointingRelative::UP,    KeyCode::LAUNCHPAD,
          PointingRelative::DOWN,  KeyCode::LAUNCHPAD,
          PointingRelative::LEFT,  KeyCode::LAUNCHPAD,
          PointingRelative::RIGHT, KeyCode::LAUNCHPAD,
        </autogen>
      </item>
      <item>
        <identifier vk_config="true">remap.samples_pointingrelativetokey2</identifier>
        <name>Standard (2)</name>
        <appendix>CursorMove to Arrows</appendix>
        <appendix>(+ You can disable this setting by escape key.)</appendix>

        <autogen>
          __KeyToKey__
          KeyCode::ESCAPE,
          KeyCode::VK_CONFIG_FORCE_OFF_remap_samples_pointingrelativetokey2,
        </autogen>
        <autogen>
          __PointingRelativeToKey__
          PointingRelative::UP,    KeyCode::CURSOR_UP,
          PointingRelative::DOWN,  KeyCode::CURSOR_DOWN,
          PointingRelative::LEFT,  KeyCode::CURSOR_LEFT,
          PointingRelative::RIGHT, KeyCode::CURSOR_RIGHT,
        </autogen>
      </item>
      <item>
        <identifier>remap.samples_pointingrelativetokey_KeyOverlaidModifier</identifier>
        <name>With __KeyOverlaidModifier__</name>
        <appendix>RightClick+CursorMove to Arrows</appendix>

        <autogen>
          __KeyOverlaidModifier__
          PointingButton::RIGHT,

          @begin
          KeyCode::VK_MODIFIER_EXTRA1,
          @end

          @begin
          PointingButton::RIGHT,
          @end
        </autogen>

        <autogen>
          __PointingRelativeToKey__
          ModifierFlag::EXTRA1,

          PointingRelative::UP,    KeyCode::CURSOR_UP,
          PointingRelative::DOWN,  KeyCode::CURSOR_DOWN,
          PointingRelative::LEFT,  KeyCode::CURSOR_LEFT,
          PointingRelative::RIGHT, KeyCode::CURSOR_RIGHT,
        </autogen>
      </item>
      <item>
        <identifier>remap.samples_pointingrelativetokey_any</identifier>
        <name>With PointingRelative::ANY</name>
        <appendix>Option+CursorMove to Shift+Space</appendix>

        <autogen>
          __PointingRelativeToKey__
          MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_OPTION,

          PointingRelative::ANY, KeyCode::SPACE, ModifierFlag::SHIFT_L,
        </autogen>
      </item>
      <item>
        <identifier>remap.samples_pointingrelativetokey_any_fallback</identifier>
        <name>With PointingRelative::ANY fallback</name>
        <appendix>Option+CursorMove (Up) to Command+Up-Arrow</appendix>
        <appendix>Option+CursorMove (Down) to Command+Down-Arrow</appendix>
        <appendix>Option+CursorMove (Other) to Shift+Space</appendix>

        <autogen>
          __PointingRelativeToKey__
          MODIFIERFLAG_EITHER_LEFT_OR_RIGHT_OPTION,

          PointingRelative::UP, KeyCode::CURSOR_UP, ModifierFlag::COMMAND_L,
          PointingRelative::DOWN, KeyCode::CURSOR_DOWN, ModifierFlag::COMMAND_L,

          PointingRelative::ANY, KeyCode::SPACE, ModifierFlag::SHIFT_L,
        </autogen>
      </item>
    </item>

    <item>
      <name>ForceNumLockOn</name>
      <item>
        <identifier>remap.samples_forcenumlockon</identifier>
        <name>Force turn NumLock on at Apple Keyboards.</name>
        <appendix>(The jkl keys will be changed to 123 when numlock is on.)</appendix>
        <autogen>
          __ForceNumLockOn__
          DeviceVendor::APPLE_INC,
          DeviceProduct::ANY,
        </autogen>
      </item>
      <item>
        <identifier>remap.samples_forcenumlockon_restore</identifier>
        <name>Toggle NumLock by fn-escape.</name>
        <autogen>
          __KeyToKey__
          KeyCode::ESCAPE, ModifierFlag::FN,
          KeyCode::VK_IOHIKEYBOARD_TOGGLE_NUMLOCK,
        </autogen>
      </item>
      <item>
        <identifier>remap.samples_forcenumlockon_force_off</identifier>
        <name>Force turn NumLock *off* at Apple Keyboards</name>
        <autogen>
          __ForceNumLockOn__
          DeviceVendor::APPLE_INC,
          DeviceProduct::ANY,
          Option::FORCENUMLOCKON_FORCE_OFF,
        </autogen>
      </item>
    </item>

    <item>
      <name>"NotSave" keymap overwriting</name>
      <item>
        <identifier>remap.samples_notsave</identifier>
        <name>base mapping</name>
        <appendix>A to toggle notsave.sample</appendix>
        <appendix>B to C</appendix>
        <appendix>(B becomes D when notsave.sample is active)</appendix>
        <autogen>__KeyToKey__ KeyCode::A, KeyCode::VK_CONFIG_TOGGLE_notsave_sample</autogen>
        <autogen>__KeyToKey__ KeyCode::B, KeyCode::C</autogen>
      </item>
      <item>
        <identifier vk_config="true">notsave.sample</identifier>
        <name>notsave.sample</name>
        <appendix>B to D</appendix>
        <autogen>__ShowStatusMessage__ notsave.sample</autogen>
        <autogen>__KeyToKey__ KeyCode::B, KeyCode::D</autogen>
      </item>

      <item><name>──────────────────────────────</name></item>

      <item>
        <identifier>remap.samples_high_priority</identifier>
        <name>high_priority attribute: base mapping</name>
        <appendix>B to C</appendix>
        <appendix>(B becomes D when `high_priority` is active)</appendix>
        <autogen>__KeyToKey__ KeyCode::B, KeyCode::C</autogen>
      </item>
      <item>
        <identifier high_priority="true">remap.samples_high_priority_2</identifier>
        <name>high_priority attribute: high_priority</name>
        <appendix>B to D</appendix>
        <autogen>__KeyToKey__ KeyCode::B, KeyCode::D</autogen>
      </item>
    </item>

    <item>
      <name>&lt;identifier&gt; which contains white space</name>
      <item>
        <name>Standard: &lt;identifier&gt; is "remap.sample change tab to space"</name>
        <appendix>Change Tab to Space</appendix>
        <identifier>
          remap.sample change tab to space
        </identifier>
        <autogen>__KeyToKey__ KeyCode::TAB, KeyCode::SPACE</autogen>
      </item>
      <item>
        <name>Filter</name>
        <item>
          <name>Core</name>
          <identifier>
            remap.sample filter core
          </identifier>
        </item>
        <item>
          <name>Change Tab to Space when the above setting is activated.</name>
          <identifier>
            remap.sample change tab to space filter core
          </identifier>
          <config_only>remap.sample filter core</config_only>
          <autogen>__KeyToKey__ KeyCode::TAB, KeyCode::SPACE</autogen>
        </item>
      </item>
      <item>
        <name>VK_CONFIG</name>
        <item>
          <name>Change Tab to Space</name>
          <identifier vk_config="true">
            remap.sample change tab to space vk config
          </identifier>
          <autogen>__ShowStatusMessage__ Change Tab to Space</autogen>
          <autogen>__KeyToKey__ KeyCode::TAB, KeyCode::SPACE</autogen>
        </item>
        <item>
          <name>Change A to toggle above setting.</name>
          <identifier>
            remap.sample change a to toggle vk config
          </identifier>
          <autogen>__KeyToKey__ KeyCode::A, KeyCode::VK_CONFIG_TOGGLE_remap_sample change tab to space vk config</autogen>
        </item>
      </item>
    </item>

    <include path="samples/filters.xml" />
    <include path="samples/virtual_keycodes.xml" />

    <item>
      <name>Environment variables</name>
      <item>
        <name>ENV_HOME:</name>
        <appendix>{{ ENV_HOME }}</appendix>
      </item>
      <item>
        <name>ENV_Karabiner_Resources:</name>
        <appendix>{{ ENV_Karabiner_Resources }}</appendix>
      </item>
      <item>
        <name>ENV_Select_the_previous_input_source_shortcut:</name>
        <appendix>{{ ENV_Select_the_previous_input_source_shortcut }}</appendix>
      </item>
      <item>
        <name>ENV_Select_next_source_in_input_menu_shortcut:</name>
        <appendix>{{ ENV_Select_next_source_in_input_menu_shortcut }}</appendix>
      </item>
    </item>
  </item>
</root>