Advertisement
Gamebuster

KeyType.java

Apr 7th, 2016
422
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 6.69 KB | None | 0 0
  1. package com.gamebuster19901.GameBuSK.types;
  2.  
  3. import ch.njol.skript.classes.ClassInfo;
  4. import ch.njol.skript.classes.Parser;
  5. import ch.njol.skript.lang.ParseContext;
  6. import ch.njol.skript.registrations.Classes;
  7.  
  8. import org.openqa.selenium.Keys;
  9.  
  10. public enum KeyType {
  11.     ESCAPE,
  12.     F1,
  13.     F2,
  14.     F3,
  15.     F4,
  16.     F5,
  17.     F6,
  18.     F7,
  19.     F8,
  20.     F9,
  21.     F10,
  22.     F11,
  23.     F12,
  24.     PAUSE,
  25.     TAB,
  26.     BACKSPACE,
  27.     INSERT,
  28.     HOME,
  29.     PAGE_UP,
  30.     DELETE,
  31.     END,
  32.     PAGE_DOWN,
  33.     ENTER,
  34.     LEFT_SHIFT,
  35.     SHIFT,
  36.     LEFT_CONTROL,
  37.     CONTROL,
  38.     LEFT_ALT,
  39.     ALT,
  40.     COMMAND,
  41.     UP,
  42.     DOWN,
  43.     LEFT,
  44.     RIGHT;
  45.    
  46.  
  47.     private KeyType() {
  48.     }
  49.  
  50.     public static String getString(KeyType k) {
  51.         Keys kf;
  52.         switch (k) {
  53.             case ESCAPE: {
  54.                 kf = Keys.ESCAPE;
  55.                 break;
  56.             }
  57.             case F1: {
  58.                 kf = Keys.F1;
  59.                 break;
  60.             }
  61.             case F2: {
  62.                 kf = Keys.F2;
  63.                 break;
  64.             }
  65.             case F3: {
  66.                 kf = Keys.F3;
  67.                 break;
  68.             }
  69.             case F4: {
  70.                 kf = Keys.F5;
  71.                 break;
  72.             }
  73.             case F6: {
  74.                 kf = Keys.F6;
  75.                 break;
  76.             }
  77.             case F7: {
  78.                 kf = Keys.F7;
  79.                 break;
  80.             }
  81.             case F8: {
  82.                 kf = Keys.F8;
  83.                 break;
  84.             }
  85.             case F9: {
  86.                 kf = Keys.F9;
  87.                 break;
  88.             }
  89.             case F10: {
  90.                 kf = Keys.F10;
  91.                 break;
  92.             }
  93.             case F11: {
  94.                 kf = Keys.F11;
  95.                 break;
  96.             }
  97.             case F12: {
  98.                 kf = Keys.F12;
  99.                 break;
  100.             }
  101.             case PAUSE: {
  102.                 kf = Keys.PAUSE;
  103.                 break;
  104.             }
  105.             case TAB: {
  106.                 kf = Keys.TAB;
  107.                 break;
  108.             }
  109.             case BACKSPACE: {
  110.                 kf = Keys.BACK_SPACE;
  111.                 break;
  112.             }
  113.             case INSERT: {
  114.                 kf = Keys.INSERT;
  115.                 break;
  116.             }
  117.             case HOME: {
  118.                 kf = Keys.HOME;
  119.                 break;
  120.             }
  121.             case PAGE_UP: {
  122.                 kf = Keys.PAGE_UP;
  123.                 break;
  124.             }
  125.             case DELETE: {
  126.                 kf = Keys.DELETE;
  127.                 break;
  128.             }
  129.             case END: {
  130.                 kf = Keys.END;
  131.                 break;
  132.             }
  133.             case PAGE_DOWN: {
  134.                 kf = Keys.PAGE_DOWN;
  135.                 break;
  136.             }
  137.             case ENTER: {
  138.                 kf = Keys.ENTER;
  139.                 break;
  140.             }
  141.             case LEFT_SHIFT: {
  142.                 kf = Keys.LEFT_SHIFT;
  143.                 break;
  144.             }
  145.             case SHIFT: {
  146.                 kf = Keys.SHIFT;
  147.                 break;
  148.             }
  149.             case LEFT_CONTROL: {
  150.                 kf = Keys.LEFT_CONTROL;
  151.                 break;
  152.             }
  153.             case CONTROL: {
  154.                 kf = Keys.CONTROL;
  155.                 break;
  156.             }
  157.             case LEFT_ALT: {
  158.                 kf = Keys.LEFT_ALT;
  159.                 break;
  160.             }
  161.             case ALT: {
  162.                 kf = Keys.ALT;
  163.                 break;
  164.             }
  165.             case COMMAND: {
  166.                 kf = Keys.COMMAND;
  167.                 break;
  168.             }
  169.             case UP: {
  170.                 kf = Keys.ARROW_UP;
  171.                 break;
  172.             }
  173.             case DOWN: {
  174.                 kf = Keys.ARROW_DOWN;
  175.                 break;
  176.             }
  177.             case LEFT: {
  178.                 kf = Keys.ARROW_LEFT;
  179.                 break;
  180.             }
  181.             case RIGHT: {
  182.                 kf = Keys.ARROW_RIGHT;
  183.                 break;
  184.             }
  185.             default: {
  186.                 kf = null;
  187.             }
  188.         }
  189.         return kf.toString();
  190.     }
  191.  
  192.     public static KeyType convertString(String s) {
  193.         s = s.replace(' ', '_');
  194.         KeyType k;
  195.         switch (s.toUpperCase()){
  196.             case "ESCAPE":{
  197.                 k = ESCAPE;
  198.             }
  199.             case "F1":{
  200.                 k = F1;
  201.             }
  202.             case "F2":{
  203.                 k = F2;
  204.             }
  205.             case "F3":{
  206.                 k = F4;
  207.             }
  208.             case "F5":{
  209.                 k = F5;
  210.             }
  211.             case "F6":{
  212.                 k = F6;
  213.             }
  214.             case "F7":{
  215.                 k = F7;
  216.             }
  217.             case "F8":{
  218.                 k = F8;
  219.             }
  220.             case "F9":{
  221.                 k = F9;
  222.             }
  223.             case "F10":{
  224.                 k = F10;
  225.             }
  226.             case "F11":{
  227.                 k = F11;
  228.             }
  229.             case "F12":{
  230.                 k = F12;
  231.             }
  232.             case "PAUSE":{
  233.                 k = PAUSE;
  234.             }
  235.             case "BREAK":{
  236.                 k = PAUSE;
  237.             }
  238.             case "TAB":{
  239.                 k = TAB;
  240.             }
  241.             case "BACKSPACE":{
  242.                 k = BACKSPACE;
  243.             }
  244.             case "INSERT":{
  245.                 k = INSERT;
  246.             }
  247.             case "HOME":{
  248.                 k = HOME;
  249.             }
  250.             case "PAGE_UP":{
  251.                 k = PAGE_UP;
  252.             }
  253.             case "DELETE":{
  254.                 k = DELETE;
  255.             }
  256.             case "END":{
  257.                 k = END;
  258.             }
  259.             case "PAGE_DOWN":{
  260.                 k = PAGE_DOWN;
  261.             }
  262.             case "ENTER":{
  263.                 k = ENTER;
  264.             }
  265.             case "LEFT_SHIFT":{
  266.                 k = LEFT_SHIFT;
  267.             }
  268.             case "SHIFT":{
  269.                 k = SHIFT;
  270.             }
  271.             case "LEFT_CONTROL":{
  272.                 k = LEFT_CONTROL;
  273.             }
  274.             case "CONTROL":{
  275.                 k = CONTROL;
  276.             }
  277.             case "LEFT_ALT":{
  278.                 k = LEFT_ALT;
  279.             }
  280.             case "ALT":{
  281.                 k = ALT;
  282.             }
  283.             case "COMMAND":{
  284.                 k = COMMAND;
  285.             }
  286.             case "UP":{
  287.                 k = UP;
  288.             }
  289.             case "DOWN":{
  290.                 k = DOWN;
  291.             }
  292.             case "LEFT":{
  293.                 k = LEFT;
  294.             }
  295.             case "RIGHT":{
  296.                 k = RIGHT;
  297.             }
  298.             default:{
  299.                 k = null;
  300.             }
  301.         }
  302.         return k;
  303.     }
  304.    
  305.     public static void register() {
  306.         Classes.registerClass(new ClassInfo<KeyType>(KeyType.class, "keytype").user("keytype").name("keytype")
  307.                 .parser(new Parser<KeyType>() {
  308.             @Override
  309.             public KeyType parse(String s, ParseContext context) {
  310.                 return KeyType.convertString(s);
  311.             }
  312.             @Override
  313.             public String toString(KeyType type, int flags) {
  314.                 return type.toString();
  315.             }
  316.             @Override
  317.             public String toVariableNameString(KeyType type) {
  318.                 return type.toString();
  319.             }
  320.             @Override
  321.             public String getVariableNamePattern() {
  322.                 return ".+";
  323.             }
  324.         }));
  325.     }
  326. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement