/** Adds the buttons (and other controls) to the screen in question. */
  public void initGui() {
    StringTranslate var1 = StringTranslate.getInstance();
    int var2 = 0;
    EnumOptions[] var3 = enumOptions;
    int var4 = var3.length;

    for (int var5 = 0; var5 < var4; ++var5) {
      EnumOptions var6 = var3[var5];
      int var7 = this.width / 2 - 155 + var2 % 2 * 160;
      int var8 = this.height / 6 + 21 * (var2 / 2) - 10;

      if (!var6.getEnumFloat()) {
        this.controlList.add(
            new GuiSmallButton(
                var6.returnEnumOrdinal(), var7, var8, var6, this.settings.getKeyBinding(var6)));
      } else {
        this.controlList.add(
            new GuiSlider(
                var6.returnEnumOrdinal(),
                var7,
                var8,
                var6,
                this.settings.getKeyBinding(var6),
                this.settings.getOptionFloatValue(var6)));
      }

      ++var2;
    }

    this.controlList.add(
        new GuiButton(
            200, this.width / 2 - 100, this.height / 6 + 168 + 11, var1.translateKey("gui.done")));
  }
  public void initGui() {
    StringTranslate stringtranslate = StringTranslate.getInstance();
    field_22107_a = stringtranslate.translateKey("options.videoTitle");
    int i = 0;
    EnumOptions aenumoptions[] = field_22108_k;
    int j = aenumoptions.length;
    for (int k = 0; k < j; k++) {
      EnumOptions enumoptions = aenumoptions[k];
      if (!enumoptions.getEnumFloat()) {
        controlList.add(
            new GuiSmallButton(
                enumoptions.returnEnumOrdinal(),
                (width / 2 - 155) + (i % 2) * 160,
                height / 6 + 24 * (i >> 1),
                enumoptions,
                guiGameSettings.getKeyBinding(enumoptions)));
      } else {
        controlList.add(
            new GuiSlider(
                enumoptions.returnEnumOrdinal(),
                (width / 2 - 155) + (i % 2) * 160,
                height / 6 + 24 * (i >> 1),
                enumoptions,
                guiGameSettings.getKeyBinding(enumoptions),
                guiGameSettings.getOptionFloatValue(enumoptions)));
      }
      i++;
    }

    controlList.add(
        new GuiButton(
            200, width / 2 - 100, height / 6 + 168, stringtranslate.translateKey("gui.done")));
  }
  /** Gets a key binding. */
  public String getKeyBinding(EnumOptions par1EnumOptions) {
    StringTranslate var2 = StringTranslate.getInstance();
    String var3 = var2.translateKey(par1EnumOptions.getEnumString()) + ": ";

    if (par1EnumOptions.getEnumFloat()) {
      float var5 = this.getOptionFloatValue(par1EnumOptions);
      return par1EnumOptions == EnumOptions.SENSITIVITY
          ? (var5 == 0.0F
              ? var3 + var2.translateKey("options.sensitivity.min")
              : (var5 == 1.0F
                  ? var3 + var2.translateKey("options.sensitivity.max")
                  : var3 + (int) (var5 * 200.0F) + "%"))
          : (par1EnumOptions == EnumOptions.FOV
              ? (var5 == 0.0F
                  ? var3 + var2.translateKey("options.fov.min")
                  : (var5 == 1.0F
                      ? var3 + var2.translateKey("options.fov.max")
                      : var3 + (int) (70.0F + var5 * 40.0F)))
              : (par1EnumOptions == EnumOptions.GAMMA
                  ? (var5 == 0.0F
                      ? var3 + var2.translateKey("options.gamma.min")
                      : (var5 == 1.0F
                          ? var3 + var2.translateKey("options.gamma.max")
                          : var3 + "+" + (int) (var5 * 100.0F) + "%"))
                  : (par1EnumOptions == EnumOptions.CHAT_OPACITY
                      ? var3 + (int) (var5 * 90.0F + 10.0F) + "%"
                      : (var5 == 0.0F
                          ? var3 + var2.translateKey("options.off")
                          : var3 + (int) (var5 * 100.0F) + "%"))));
    } else if (par1EnumOptions.getEnumBoolean()) {
      boolean var4 = this.getOptionOrdinalValue(par1EnumOptions);
      return var4
          ? var3 + var2.translateKey("options.on")
          : var3 + var2.translateKey("options.off");
    } else {
      return par1EnumOptions == EnumOptions.RENDER_DISTANCE
          ? var3 + getTranslation(RENDER_DISTANCES, this.renderDistance)
          : (par1EnumOptions == EnumOptions.DIFFICULTY
              ? var3 + getTranslation(DIFFICULTIES, this.difficulty)
              : (par1EnumOptions == EnumOptions.GUI_SCALE
                  ? var3 + getTranslation(GUISCALES, this.guiScale)
                  : (par1EnumOptions == EnumOptions.CHAT_VISIBILITY
                      ? var3 + getTranslation(CHAT_VISIBILITIES, this.chatVisibility)
                      : (par1EnumOptions == EnumOptions.PARTICLES
                          ? var3 + getTranslation(PARTICLES, this.particleSetting)
                          : (par1EnumOptions == EnumOptions.FRAMERATE_LIMIT
                              ? var3 + getTranslation(LIMIT_FRAMERATES, this.limitFramerate)
                              : (par1EnumOptions == EnumOptions.GRAPHICS
                                  ? (this.fancyGraphics
                                      ? var3 + var2.translateKey("options.graphics.fancy")
                                      : var3 + var2.translateKey("options.graphics.fast"))
                                  : var3))))));
    }
  }
 @Override
 protected String[] getTooltipLines(String displayString, int buttonId) {
   EnumOptions e = EnumOptions.getEnumOptions(buttonId);
   if (e != null)
     switch (e) {
       case CALIBRATION_STRATEGY:
         return new String[] {
           "Sets whether device calibration is performed when",
           "Minecraft is started.",
           "  At Startup: Calibration routines for all",
           "     utilised devices are run at startup.",
           "  Skip: No calibration will be performed. The user",
           "     will have to manually trigger calibration",
           "     at some point for correct device operation."
         };
       default:
         return null;
     }
   else
     switch (buttonId) {
         //                case 201:
         //                    return new String[] {
         //                            "Open this configuration screen to adjust the Head",
         //                            "  Tracker orientation (direction) settings. ",
         //                            "  Ex: Head Tracking Selection (Hydra/Oculus), Prediction"
         //                    };
       default:
         return null;
     }
 }
  private boolean getEnabledState(EnumOptions var8) {
    String s = var8.getEnumString();

    if (var8 == EnumOptions.HEAD_TRACK_SENSITIVITY) {
      if (this.mc.vrSettings.useQuaternions) return false;
      else return true;
    }

    return true;
  }
 /**
  * Fired when a control is clicked. This is the equivalent of
  * ActionListener.actionPerformed(ActionEvent e).
  */
 protected void actionPerformed(GuiButton par1GuiButton) {
   if (par1GuiButton.enabled) {
     if (par1GuiButton.id < 200 && par1GuiButton instanceof GuiSmallButtonEx) {
       EnumOptions num = EnumOptions.getEnumOptions(par1GuiButton.id);
       this.guivrSettings.setOptionValue(
           ((GuiSmallButtonEx) par1GuiButton).returnEnumOptions(), 1);
       par1GuiButton.displayString =
           this.guivrSettings.getKeyBinding(EnumOptions.getEnumOptions(par1GuiButton.id));
     } else if (par1GuiButton.id == 200) {
       this.mc.vrSettings.saveOptions();
       this.mc.displayGuiScreen(this.parentGuiScreen);
     } else if (par1GuiButton.id == 201) {
       this.guivrSettings.calibrationStrategy = VRSettings.CALIBRATION_STRATEGY_AT_STARTUP;
       this.mc.vrSettings.saveOptions();
       this.reinit = true;
     } else if (par1GuiButton.id == 202) {
       if (vrRenderer != null) vrRenderer.startCalibration();
     }
   }
 }
  /**
   * Fired when a control is clicked. This is the equivalent of
   * ActionListener.actionPerformed(ActionEvent e).
   */
  protected void actionPerformed(GuiButton par1GuiButton) {
    EnumOptions num = EnumOptions.getEnumOptions(par1GuiButton.id);

    if (par1GuiButton.enabled) {
      if (par1GuiButton.id < 200 && par1GuiButton instanceof GuiSmallButtonEx) {
        this.guivrSettings.setOptionValue(
            ((GuiSmallButtonEx) par1GuiButton).returnEnumOptions(), 1);
        par1GuiButton.displayString =
            this.guivrSettings.getKeyBinding(EnumOptions.getEnumOptions(par1GuiButton.id));

        if (num == EnumOptions.HEAD_TRACK_PREDICTION) {
          mc.headTracker.setPrediction(
              this.mc.vrSettings.headTrackPredictionTimeSecs,
              this.mc.vrSettings.useHeadTrackPrediction);
        }
      } else if (par1GuiButton.id == 200) {
        this.mc.vrSettings.saveOptions();
        this.mc.displayGuiScreen(this.parentGuiScreen);
      } else if (par1GuiButton.id == 201) {
        this.mc.vrSettings.useHeadTracking = true;
        if (this.mc.headTracker instanceof MCOculus) {
          this.mc.vrSettings.useHeadTrackPrediction = true;
          this.mc.vrSettings.headTrackPredictionTimeSecs = 0f;
          mc.headTracker.setPrediction(
              this.mc.vrSettings.headTrackPredictionTimeSecs,
              this.mc.vrSettings.useHeadTrackPrediction);
        }
        this.mc.vrSettings.setHeadTrackSensitivity(1.0f);
        this.reinit = true;
      } else if (par1GuiButton.id == 202) {
        if (vrRenderer != null) vrRenderer.startCalibration();
      } else if (par1GuiButton.id == 203) // Mode Change
      {
        this.mc.vrSettings.headTrackerPluginID = pluginModeChangeutton.getSelectedID();
        this.mc.vrSettings.saveOptions();
        this.mc.headTracker =
            PluginManager.configureOrientation(this.mc.vrSettings.headTrackerPluginID);
        this.reinit = true;
      }
    }
  }
 @Override
 protected String[] getTooltipLines(String displayString, int buttonId) {
   EnumOptions e = EnumOptions.getEnumOptions(buttonId);
   if (e != null)
     switch (e) {
       case HEAD_TRACKING:
         return new String[] {
           "If head tracking should be enabled or not",
           "  OFF: No head tracking",
           "  ON: Head tracking enabled",
           "  Recommended: ON"
         };
       case HEAD_TRACK_PREDICTION:
         return new String[] {
           "For the Oculus Rift, enable Prediction?",
           " OFF: Prediction disabled",
           " ON:  Prediction enabled",
           " Recommended value: ON to reduce latency"
         };
       case HEAD_TRACK_SENSITIVITY:
         return new String[] {
           "In-game camera orientation multiplied by this value.",
           "  Recommended value: 1.0",
           "NOTE: Will be locked at 1.0 if the Orientation render",
           "mode is set to 'Quaternion'."
         };
       case HEAD_TRACK_PREDICTION_TIME:
         return new String[] {
           "Number of seconds to predict motion. Higher values will",
           "enhance the perceived precision of slow movements, but ",
           "cause issues with sudden movements. Auto attempts to",
           "dynamically set the value based on previous frame time.",
           "  Recommended value: AUTO (set to 0)"
         };
       default:
         return null;
     }
   else
     switch (buttonId) {
       case 201:
         return new String[] {"Resets all values on this screen to their defaults"};
       case 202:
         return new String[] {
           "Starts calibration of the Oculus Rift headset",
           "  Press this button while facing forward.",
           "  Then, look to the left.",
           "  Then, look to the right.",
           "  Then, look up."
         };
       default:
         return null;
     }
 }
  public boolean getOptionOrdinalValue(EnumOptions par1EnumOptions) {
    switch (EnumOptionsHelper.enumOptionsMappingHelperArray[par1EnumOptions.ordinal()]) {
      case 1:
        return this.invertMouse;

      case 2:
        return this.viewBobbing;

      case 3:
        return this.anaglyph;

      case 4:
        return this.advancedOpengl;

      case 5:
        return this.ambientOcclusion;

      case 6:
        return this.clouds;

      case 7:
        return this.chatColours;

      case 8:
        return this.chatLinks;

      case 9:
        return this.chatLinksPrompt;

      case 10:
        return this.serverTextures;

      case 11:
        return this.snooperEnabled;

      case 12:
        return this.fullScreen;

      case 13:
        return this.enableVsync;

      case 14:
        return this.showCape;

      case 15:
        return this.field_85185_A;

      default:
        return false;
    }
  }
Beispiel #10
0
  /**
   * Fired when a control is clicked. This is the equivalent of
   * ActionListener.actionPerformed(ActionEvent e).
   */
  protected void actionPerformed(GuiButton par1GuiButton) {
    if (par1GuiButton.enabled) {
      if (par1GuiButton.id < 100 && par1GuiButton instanceof GuiSmallButton) {
        this.field_73890_c.setOptionValue(((GuiSmallButton) par1GuiButton).returnEnumOptions(), 1);
        par1GuiButton.displayString =
            this.field_73890_c.getKeyBinding(EnumOptions.getEnumOptions(par1GuiButton.id));
      }

      if (par1GuiButton.id == 200) {
        this.mc.gameSettings.saveOptions();
        this.mc.displayGuiScreen(this.field_73889_b);
      }
    }
  }
Beispiel #11
0
  /** Adds the buttons (and other controls) to the screen in question. */
  public void initGui() {
    StringTranslate var1 = StringTranslate.getInstance();
    int var2 = 0;
    this.field_73888_d = var1.translateKey("options.chat.title");
    EnumOptions[] var3 = field_73891_a;
    int var4 = var3.length;

    for (int var5 = 0; var5 < var4; ++var5) {
      EnumOptions var6 = var3[var5];

      if (var6.getEnumFloat()) {
        this.controlList.add(
            new GuiSlider(
                var6.returnEnumOrdinal(),
                this.width / 2 - 155 + var2 % 2 * 160,
                this.height / 6 + 24 * (var2 >> 1),
                var6,
                this.field_73890_c.getKeyBinding(var6),
                this.field_73890_c.getOptionFloatValue(var6)));
      } else {
        this.controlList.add(
            new GuiSmallButton(
                var6.returnEnumOrdinal(),
                this.width / 2 - 155 + var2 % 2 * 160,
                this.height / 6 + 24 * (var2 >> 1),
                var6,
                this.field_73890_c.getKeyBinding(var6)));
      }

      ++var2;
    }

    this.controlList.add(
        new GuiButton(
            200, this.width / 2 - 100, this.height / 6 + 168, var1.translateKey("gui.done")));
  }
 protected void actionPerformed(GuiButton guibutton) {
   if (!guibutton.enabled) {
     return;
   }
   if (guibutton.id < 100 && (guibutton instanceof GuiSmallButton)) {
     guiGameSettings.setOptionValue(((GuiSmallButton) guibutton).returnEnumOptions(), 1);
     guibutton.displayString =
         guiGameSettings.getKeyBinding(EnumOptions.getEnumOptions(guibutton.id));
   }
   if (guibutton.id == 200) {
     mc.gameSettings.saveOptions();
     mc.displayGuiScreen(field_22110_h);
   }
   ScaledResolution scaledresolution =
       new ScaledResolution(mc.gameSettings, mc.displayWidth, mc.displayHeight);
   int i = scaledresolution.getScaledWidth();
   int j = scaledresolution.getScaledHeight();
   setWorldAndResolution(mc, i, j);
 }
  /**
   * Fired when a control is clicked. This is the equivalent of
   * ActionListener.actionPerformed(ActionEvent e).
   */
  protected void actionPerformed(GuiButton var1) {
    if (var1.enabled) {
      if (var1.id < 100 && var1 instanceof GuiSmallButton) {
        this.settings.setOptionValue(((GuiSmallButton) var1).returnEnumOptions(), 1);
        var1.displayString = this.settings.getKeyBinding(EnumOptions.getEnumOptions(var1.id));
      }

      if (var1.id == 200) {
        this.mc.gameSettings.saveOptions();
        this.mc.displayGuiScreen(this.prevScreen);
      }

      if (var1.id != EnumOptions.CLOUD_HEIGHT.ordinal()) {
        ScaledResolution var2 =
            new ScaledResolution(this.mc.gameSettings, this.mc.displayWidth, this.mc.displayHeight);
        int var3 = var2.getScaledWidth();
        int var4 = var2.getScaledHeight();
        this.setWorldAndResolution(this.mc, var3, var4);
      }
    }
  }
Beispiel #14
0
  /** Gets a key binding. */
  public String getKeyBinding(EnumOptions par1EnumOptions) {
    String var2 = I18n.getString(par1EnumOptions.getEnumString()) + ": ";

    if (par1EnumOptions.getEnumFloat()) {
      float var5 = this.getOptionFloatValue(par1EnumOptions);
      return par1EnumOptions == EnumOptions.SENSITIVITY
          ? (var5 == 0.0F
              ? var2 + I18n.getString("options.sensitivity.min")
              : (var5 == 1.0F
                  ? var2 + I18n.getString("options.sensitivity.max")
                  : var2 + (int) (var5 * 200.0F) + "%"))
          : (par1EnumOptions == EnumOptions.FOV
              ? (var5 == 0.0F
                  ? var2 + I18n.getString("options.fov.min")
                  : (var5 == 1.0F
                      ? var2 + I18n.getString("options.fov.max")
                      : var2 + (int) (70.0F + var5 * 40.0F)))
              : (par1EnumOptions == EnumOptions.GAMMA
                  ? (var5 == 0.0F
                      ? var2 + I18n.getString("options.gamma.min")
                      : (var5 == 1.0F
                          ? var2 + I18n.getString("options.gamma.max")
                          : var2 + "+" + (int) (var5 * 100.0F) + "%"))
                  : (par1EnumOptions == EnumOptions.CHAT_OPACITY
                      ? var2 + (int) (var5 * 90.0F + 10.0F) + "%"
                      : (par1EnumOptions == EnumOptions.CHAT_HEIGHT_UNFOCUSED
                          ? var2 + GuiNewChat.func_96130_b(var5) + "px"
                          : (par1EnumOptions == EnumOptions.CHAT_HEIGHT_FOCUSED
                              ? var2 + GuiNewChat.func_96130_b(var5) + "px"
                              : (par1EnumOptions == EnumOptions.CHAT_WIDTH
                                  ? var2 + GuiNewChat.func_96128_a(var5) + "px"
                                  : (var5 == 0.0F
                                      ? var2 + I18n.getString("options.off")
                                      : var2 + (int) (var5 * 100.0F) + "%")))))));
    } else if (par1EnumOptions.getEnumBoolean()) {
      boolean var4 = this.getOptionOrdinalValue(par1EnumOptions);
      return var4 ? var2 + I18n.getString("options.on") : var2 + I18n.getString("options.off");
    } else if (par1EnumOptions == EnumOptions.RENDER_DISTANCE) {
      return var2 + getTranslation(RENDER_DISTANCES, this.renderDistance);
    } else if (par1EnumOptions == EnumOptions.DIFFICULTY) {
      return var2 + getTranslation(DIFFICULTIES, this.difficulty);
    } else if (par1EnumOptions == EnumOptions.GUI_SCALE) {
      return var2 + getTranslation(GUISCALES, this.guiScale);
    } else if (par1EnumOptions == EnumOptions.CHAT_VISIBILITY) {
      return var2 + getTranslation(CHAT_VISIBILITIES, this.chatVisibility);
    } else if (par1EnumOptions == EnumOptions.PARTICLES) {
      return var2 + getTranslation(PARTICLES, this.particleSetting);
    } else if (par1EnumOptions == EnumOptions.FRAMERATE_LIMIT) {
      return var2 + getTranslation(LIMIT_FRAMERATES, this.limitFramerate);
    } else if (par1EnumOptions == EnumOptions.AMBIENT_OCCLUSION) {
      return var2 + getTranslation(AMBIENT_OCCLUSIONS, this.ambientOcclusion);
    } else if (par1EnumOptions == EnumOptions.GRAPHICS) {
      if (this.fancyGraphics) {
        return var2 + I18n.getString("options.graphics.fancy");
      } else {
        String var3 = "options.graphics.fast";
        return var2 + I18n.getString("options.graphics.fast");
      }
    } else {
      return var2;
    }
  }
  /** Adds the buttons (and other controls) to the screen in question. */
  public void initGui() {
    StringTranslate stringTranslate = StringTranslate.getInstance();
    this.buttonList.clear();
    //        this.buttonList.add(new GuiSmallButtonEx(EnumOptions.USE_VR.returnEnumOrdinal(),
    // this.width / 2 - 78, this.height / 6 - 14, EnumOptions.USE_VR,
    // this.guivrSettings.getKeyBinding(EnumOptions.USE_VR)));
    this.buttonList.add(
        new GuiButtonEx(202, this.width / 2 - 100, this.height / 6 + 128, "Recalibrate..."));
    this.buttonList.add(
        new GuiButtonEx(201, this.width / 2 - 100, this.height / 6 + 148, "Reset To Defaults"));
    this.buttonList.add(
        new GuiButtonEx(
            200,
            this.width / 2 - 100,
            this.height / 6 + 168,
            stringTranslate.translateKey("gui.done")));
    EnumOptions[] buttons = calibrationOptions;

    for (int var12 = 2; var12 < buttons.length + 2; ++var12) {
      EnumOptions var8 = buttons[var12 - 2];
      int width = this.width / 2 - 155 + var12 % 2 * 160;
      int height = this.height / 6 + 21 * (var12 / 2) - 10;

      if (var8.getEnumFloat()) {
        float minValue = 0.0f;
        float maxValue = 1.0f;
        float increment = 0.01f;

        if (var8 == EnumOptions.HUD_SCALE) {
          minValue = 0.5f;
          maxValue = 1.5f;
          increment = 0.01f;
        }
        if (var8 == EnumOptions.HUD_DISTANCE) {
          minValue = 0.5f;
          maxValue = 3.0f;
          increment = 0.02f;
        }

        this.buttonList.add(
            new GuiSliderEx(
                var8.returnEnumOrdinal(),
                width,
                height,
                var8,
                this.guivrSettings.getKeyBinding(var8),
                minValue,
                maxValue,
                increment,
                this.guivrSettings.getOptionFloatValue(var8)));
      } else {
        this.buttonList.add(
            new GuiSmallButtonEx(
                var8.returnEnumOrdinal(),
                width,
                height,
                var8,
                this.guivrSettings.getKeyBinding(var8)));
      }
    }
  }
  /** Adds the buttons (and other controls) to the screen in question. */
  public void initGui() {
    StringTranslate stringTranslate = StringTranslate.getInstance();
    this.buttonList.clear();
    this.buttonList.add(
        new GuiButtonEx(
            200,
            this.width / 2 - 100,
            this.height / 6 + 168,
            stringTranslate.translateKey("gui.done")));
    this.buttonList.add(
        new GuiButtonEx(201, this.width / 2 - 100, this.height / 6 + 148, "Reset To Defaults"));
    this.buttonList.add(
        new GuiButtonEx(202, this.width / 2 - 100, this.height / 6 + 128, "Recalibrate..."));
    pluginModeChangeutton =
        new PluginModeChangeButton(
            203,
            this.width / 2 - 78,
            this.height / 6 - 14,
            (List<IBasePlugin>) (List<?>) PluginManager.thePluginManager.orientPlugins,
            this.guivrSettings.headTrackerPluginID);
    this.buttonList.add(pluginModeChangeutton);
    EnumOptions[] var10 = null;
    if (this.mc.headTracker instanceof MCHydra) var10 = hydraHeadOrientationOptions;
    else var10 = oculusHeadOrientationOptions;

    int var11 = var10.length;

    for (int var12 = 2; var12 < var11 + 2; ++var12) {
      EnumOptions var8 = var10[var12 - 2];
      int width = this.width / 2 - 155 + var12 % 2 * 160;
      int height = this.height / 6 + 21 * (var12 / 2) - 10;

      if (var8.getEnumFloat()) {
        float minValue = 0.0f;
        float maxValue = 1.0f;
        float increment = 0.001f;

        if (var8 == EnumOptions.HEAD_TRACK_SENSITIVITY) {
          minValue = 0.5f;
          maxValue = 3.0f;
          increment = 0.01f;
        } else if (var8 == EnumOptions.HEAD_TRACK_PREDICTION_TIME) {
          minValue = 0.000f;
          maxValue = 0.100f;
          increment = 0.001f;
        }

        GuiSliderEx slider =
            new GuiSliderEx(
                var8.returnEnumOrdinal(),
                width,
                height,
                var8,
                this.guivrSettings.getKeyBinding(var8),
                minValue,
                maxValue,
                increment,
                this.guivrSettings.getOptionFloatValue(var8));
        slider.setEventHandler(this);
        slider.enabled = getEnabledState(var8);
        this.buttonList.add(slider);
      } else {
        this.buttonList.add(
            new GuiSmallButtonEx(
                var8.returnEnumOrdinal(),
                width,
                height,
                var8,
                this.guivrSettings.getKeyBinding(var8)));
      }
    }
  }