content: package me.earth.earthhack.impl.modules.client.pingbypass.guis;
  
  import com.google.common.base.Predicate;
  import com.google.common.base.Predicates;
  import me.earth.earthhack.api.setting.settings.StringSetting;
  import net.minecraft.client.Minecraft;
  import net.minecraft.client.gui.*;
  import net.minecraft.client.renderer.BufferBuilder;
  import net.minecraft.client.renderer.GlStateManager;
  import net.minecraft.client.renderer.Tessellator;
  import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
  import net.minecraft.util.ChatAllowedCharacters;
  import net.minecraft.util.math.MathHelper;
  
  /**
   * Minecraft made {@link GuiTextField} very hard to extend so this is mostly the code from there with the exception of {@link #drawTextBox()}.
   */
  public class GuiPasswordField extends Gui
  {
      private final int id;
      private final FontRenderer fontRenderer;
      public int x;
      public int y;
      /** The width of this text field. */
      public int width;
      public int height;
      /** Has the current text being edited on the textbox. */
      private String text = "";
      private int maxStringLength = 32;
      private int cursorCounter;
      private boolean enableBackgroundDrawing = true;
      /** if true the textbox can lose focus by clicking elsewhere on the screen */
      private boolean canLoseFocus = true;
      /** If this value is true along with isEnabled, keyTyped will process the keys. */
      private boolean isFocused;
      /** If this value is true along with isFocused, keyTyped will process the keys. */
      private boolean isEnabled = true;
      /** The current character index that should be used as start of the rendered text. */
      private int lineScrollOffset;
      private int cursorPosition;
      /** other selection position, maybe the same as the cursor */
      private int selectionEnd;
      private int enabledColor = 14737632;
      private int disabledColor = 7368816;
      /** True if this textbox is visible */
      private boolean visible = true;
      private GuiPageButtonList.GuiResponder guiResponder;
      /** Called to check if the text is valid */
      private Predicate<String> validator = Predicates.alwaysTrue();
  
      public GuiPasswordField(int componentId, FontRenderer fontrendererObj, int x, int y, int par5Width, int par6Height)
      {
          this.id = componentId;
          this.fontRenderer = fontrendererObj;
          this.x = x;
          this.y = y;
          this.width = par5Width;
          this.height = par6Height;
      }
  
      /**
       * Sets the GuiResponder associated with this text box.
       */
      public void setGuiResponder(GuiPageButtonList.GuiResponder guiResponderIn)
      {
          this.guiResponder = guiResponderIn;
      }
  
      /**
       * Increments the cursor counter
       */
      public void updateCursorCounter()
      {
          ++this.cursorCounter;
      }
  
      /**
       * Sets the text of the textbox, and moves the cursor to the end.
       */
      public void setText(String textIn)
      {
          if (this.validator.apply(textIn))
          {
              if (textIn.length() > this.maxStringLength)
              {
                  text = textIn.substring(0, this.maxStringLength);
              }
              else
              {
                  text = textIn;
              }
  
              this.setCursorPositionEnd();
          }
      }
  
      /**
       * Returns the contents of the textbox
       */
      public String getText()
      {
          return text;
      }
  
      /**
       * returns the text between the cursor and selectionEnd
       */
      public String getSelectedText()
      {
          int i = this.cursorPosition < this.selectionEnd ? this.cursorPosition : this.selectionEnd;
          int j = this.cursorPosition < this.selectionEnd ? this.selectionEnd : this.cursorPosition;
          return text.substring(i, j);
      }
  
      public void setValidator(Predicate<String> theValidator)
      {
          this.validator = theValidator;
      }
  
      /**
       * Adds the given text after the cursor, or replaces the currently selected text if there is a selection.
       */
      public void writeText(String textToWrite)
      {
          String s = "";
          String s1 = ChatAllowedCharacters.filterAllowedCharacters(textToWrite);
          int i = this.cursorPosition < this.selectionEnd ? this.cursorPosition : this.selectionEnd;
          int j = this.cursorPosition < this.selectionEnd ? this.selectionEnd : this.cursorPosition;
          int k = this.maxStringLength - text.length() - (i - j);
  
          if (!text.isEmpty())
          {
              s = s + text.substring(0, i);
          }
  
          int l;
  
          if (k < s1.length())
          {
              s = s + s1.substring(0, k);
              l = k;
          }
          else
          {
              s = s + s1;
              l = s1.length();
          }
  
          if (!text.isEmpty() && j < text.length())
          {
              s = s + text.substring(j);
          }
  
          if (this.validator.apply(s))
          {
              text = s;
              this.moveCursorBy(i - this.selectionEnd + l);
              this.setResponderEntryValue(this.id, text);
          }
      }
  
      /**
       * Notifies this text box's {@linkplain GuiPageButtonList.GuiResponder responder} that the text has changed.
       */
      public void setResponderEntryValue(int idIn, String textIn)
      {
          if (this.guiResponder != null)
          {
              this.guiResponder.setEntryValue(idIn, textIn);
          }
      }
  
      /**
       * Deletes the given number of words from the current cursor's position, unless there is currently a selection, in
       * which case the selection is deleted instead.
       */
      public void deleteWords(int num)
      {
          if (!text.isEmpty())
          {
              if (this.selectionEnd != this.cursorPosition)
              {
                  this.writeText("");
              }
              else
              {
                  this.deleteFromCursor(this.getNthWordFromCursor(num) - this.cursorPosition);
              }
          }
      }
  
      /**
       * Deletes the given number of characters from the current cursor's position, unless there is currently a selection,
       * in which case the selection is deleted instead.
       */
      public void deleteFromCursor(int num)
      {
          if (!text.isEmpty())
          {
              if (this.selectionEnd != this.cursorPosition)
              {
                  this.writeText("");
              }
              else
              {
                  boolean flag = num < 0;
                  int i = flag ? this.cursorPosition + num : this.cursorPosition;
                  int j = flag ? this.cursorPosition : this.cursorPosition + num;
                  String s = "";
  
                  if (i >= 0)
                  {
                      s = text.substring(0, i);
                  }
  
                  if (j < text.length())
                  {
                      s = s + text.substring(j);
                  }
  
                  if (this.validator.apply(s))
                  {
                      text = s;
  
                      if (flag)
                      {
                          this.moveCursorBy(num);
                      }
  
                      this.setResponderEntryValue(this.id, text);
                  }
              }
          }
      }
  
      public int getId()
      {
          return this.id;
      }
  
      /**
       * Gets the starting index of the word at the specified number of words away from the cursor position.
       */
      public int getNthWordFromCursor(int numWords)
      {
          return this.getNthWordFromPos(numWords, this.getCursorPosition());
      }
  
      /**
       * Gets the starting index of the word at a distance of the specified number of words away from the given position.
       */
      public int getNthWordFromPos(int n, int pos)
      {
          return this.getNthWordFromPosWS(n, pos, true);
      }
  
      /**
       * Like getNthWordFromPos (which wraps this), but adds option for skipping consecutive spaces
       */
      public int getNthWordFromPosWS(int n, int pos, boolean skipWs)
      {
          int i = pos;
          boolean flag = n < 0;
          int j = Math.abs(n);
  
          for (int k = 0; k < j; ++k)
          {
              if (!flag)
              {
                  int l = text.length();
                  i = text.indexOf(32, i);
  
                  if (i == -1)
                  {
                      i = l;
                  }
                  else
                  {
                      while (skipWs && i < l && text.charAt(i) == ' ')
                      {
                          ++i;
                      }
                  }
              }
              else
              {
                  while (skipWs && i > 0 && text.charAt(i - 1) == ' ')
                  {
                      --i;
                  }
  
                  while (i > 0 && text.charAt(i - 1) != ' ')
                  {
                      --i;
                  }
              }
          }
  
          return i;
      }
  
      /**
       * Moves the text cursor by a specified number of characters and clears the selection
       */
      public void moveCursorBy(int num)
      {
          this.setCursorPosition(this.selectionEnd + num);
      }
  
      /**
       * Sets the current position of the cursor.
       */
      public void setCursorPosition(int pos)
      {
          this.cursorPosition = pos;
          int i = text.length();
          this.cursorPosition = MathHelper.clamp(this.cursorPosition, 0, i);
          this.setSelectionPos(this.cursorPosition);
      }
  
      /**
       * Moves the cursor to the very start of this text box.
       */
      public void setCursorPositionZero()
      {
          this.setCursorPosition(0);
      }
  
      /**
       * Moves the cursor to the very end of this text box.
       */
      public void setCursorPositionEnd()
      {
          this.setCursorPosition(text.length());
      }
  
      /**
       * Call this method from your GuiScreen to process the keys into the textbox
       */
      public boolean textboxKeyTyped(char typedChar, int keyCode)
      {
          if (!this.isFocused)
          {
              return false;
          }
          else if (GuiScreen.isKeyComboCtrlA(keyCode))
          {
              this.setCursorPositionEnd();
              this.setSelectionPos(0);
              return true;
          }
          else if (GuiScreen.isKeyComboCtrlC(keyCode))
          {
              GuiScreen.setClipboardString(this.getSelectedText());
              return true;
          }
          else if (GuiScreen.isKeyComboCtrlV(keyCode))
          {
              if (this.isEnabled)
              {
                  this.writeText(GuiScreen.getClipboardString());
              }
  
              return true;
          }
          else if (GuiScreen.isKeyComboCtrlX(keyCode))
          {
              GuiScreen.setClipboardString(this.getSelectedText());
  
              if (this.isEnabled)
              {
                  this.writeText("");
              }
  
              return true;
          }
          else
          {
              switch (keyCode)
              {
                  case 14:
  
                      if (GuiScreen.isCtrlKeyDown())
                      {
                          if (this.isEnabled)
                          {
                              this.deleteWords(-1);
                          }
                      }
                      else if (this.isEnabled)
                      {
                          this.deleteFromCursor(-1);
                      }
  
                      return true;
                  case 199:
  
                      if (GuiScreen.isShiftKeyDown())
                      {
                          this.setSelectionPos(0);
                      }
                      else
                      {
                          this.setCursorPositionZero();
                      }
  
                      return true;
                  case 203:
  
                      if (GuiScreen.isShiftKeyDown())
                      {
                          if (GuiScreen.isCtrlKeyDown())
                          {
                              this.setSelectionPos(this.getNthWordFromPos(-1, this.getSelectionEnd()));
                          }
                          else
                          {
                              this.setSelectionPos(this.getSelectionEnd() - 1);
                          }
                      }
                      else if (GuiScreen.isCtrlKeyDown())
                      {
                          this.setCursorPosition(this.getNthWordFromCursor(-1));
                      }
                      else
                      {
                          this.moveCursorBy(-1);
                      }
  
                      return true;
                  case 205:
  
                      if (GuiScreen.isShiftKeyDown())
                      {
                          if (GuiScreen.isCtrlKeyDown())
                          {
                              this.setSelectionPos(this.getNthWordFromPos(1, this.getSelectionEnd()));
                          }
                          else
                          {
                              this.setSelectionPos(this.getSelectionEnd() + 1);
                          }
                      }
                      else if (GuiScreen.isCtrlKeyDown())
                      {
                          this.setCursorPosition(this.getNthWordFromCursor(1));
                      }
                      else
                      {
                          this.moveCursorBy(1);
                      }
  
                      return true;
                  case 207:
  
                      if (GuiScreen.isShiftKeyDown())
                      {
                          this.setSelectionPos(text.length());
                      }
                      else
                      {
                          this.setCursorPositionEnd();
                      }
  
                      return true;
                  case 211:
  
                      if (GuiScreen.isCtrlKeyDown())
                      {
                          if (this.isEnabled)
                          {
                              this.deleteWords(1);
                          }
                      }
                      else if (this.isEnabled)
                      {
                          this.deleteFromCursor(1);
                      }
  
                      return true;
                  default:
  
                      if (ChatAllowedCharacters.isAllowedCharacter(typedChar))
                      {
                          if (this.isEnabled)
                          {
                              this.writeText(Character.toString(typedChar));
                          }
  
                          return true;
                      }
                      else
                      {
                          return false;
                      }
              }
          }
      }
  
      /**
       * Called when mouse is clicked, regardless as to whether it is over this button or not.
       */
      public boolean mouseClicked(int mouseX, int mouseY, int mouseButton)
      {
          boolean flag = mouseX >= this.x && mouseX < this.x + this.width && mouseY >= this.y && mouseY < this.y + this.height;
  
          if (this.canLoseFocus)
          {
              this.setFocused(flag);
          }
  
          if (this.isFocused && flag && mouseButton == 0)
          {
              int i = mouseX - this.x;
  
              if (this.enableBackgroundDrawing)
              {
                  i -= 4;
              }
  
              String s = this.fontRenderer.trimStringToWidth(text.substring(this.lineScrollOffset), this.getWidth());
              this.setCursorPosition(this.fontRenderer.trimStringToWidth(s, i).length() + this.lineScrollOffset);
              return true;
          }
          else
          {
              return false;
          }
      }
  
      /**
       * Draws the textbox
       */
      public void drawTextBox()
      {
          if (this.getVisible())
          {
              if (this.getEnableBackgroundDrawing())
              {
                  drawRect(this.x - 1, this.y - 1, this.x + this.width + 1, this.y + this.height + 1, -6250336);
                  drawRect(this.x, this.y, this.x + this.width, this.y + this.height, -16777216);
              }
  
              int i = this.isEnabled ? this.enabledColor : this.disabledColor;
              int j = this.cursorPosition - this.lineScrollOffset;
              int k = this.selectionEnd - this.lineScrollOffset;
              String text = StringSetting.censor(this.text);
              String s = this.fontRenderer.trimStringToWidth(text.substring(this.lineScrollOffset), this.getWidth());
              boolean flag = j >= 0 && j <= s.length();
              boolean flag1 = this.isFocused && this.cursorCounter / 6 % 2 == 0 && flag;
              int l = this.enableBackgroundDrawing ? this.x + 4 : this.x;
              int i1 = this.enableBackgroundDrawing ? this.y + (this.height - 8) / 2 : this.y;
              int j1 = l;
  
              if (k > s.length())
              {
                  k = s.length();
              }
  
              if (!s.isEmpty())
              {
                  String s1 = flag ? s.substring(0, j) : s;
                  j1 = this.fontRenderer.drawStringWithShadow(s1, (float)l, (float)i1, i);
              }
  
              boolean flag2 = this.cursorPosition < text.length() || text.length() >= this.getMaxStringLength();
              int k1 = j1;
  
              if (!flag)
              {
                  k1 = j > 0 ? l + this.width : l;
              }
              else if (flag2)
              {
                  k1 = j1 - 1;
                  --j1;
              }
  
              if (!s.isEmpty() && flag && j < s.length())
              {
                  j1 = this.fontRenderer.drawStringWithShadow(s.substring(j), (float)j1, (float)i1, i);
              }
  
              if (flag1)
              {
                  if (flag2)
                  {
                      Gui.drawRect(k1, i1 - 1, k1 + 1, i1 + 1 + this.fontRenderer.FONT_HEIGHT, -3092272);
                  }
                  else
                  {
                      this.fontRenderer.drawStringWithShadow("_", (float)k1, (float)i1, i);
                  }
              }
  
              if (k != j)
              {
                  int l1 = l + this.fontRenderer.getStringWidth(s.substring(0, k));
                  this.drawSelectionBox(k1, i1 - 1, l1 - 1, i1 + 1 + this.fontRenderer.FONT_HEIGHT);
              }
          }
      }
  
      /**
       * Draws the blue selection box.
       */
      private void drawSelectionBox(int startX, int startY, int endX, int endY)
      {
          if (startX < endX)
          {
              int i = startX;
              startX = endX;
              endX = i;
          }
  
          if (startY < endY)
          {
              int j = startY;
              startY = endY;
              endY = j;
          }
  
          if (endX > this.x + this.width)
          {
              endX = this.x + this.width;
          }
  
          if (startX > this.x + this.width)
          {
              startX = this.x + this.width;
          }
  
          Tessellator tessellator = Tessellator.getInstance();
          BufferBuilder bufferbuilder = tessellator.getBuffer();
          GlStateManager.color(0.0F, 0.0F, 255.0F, 255.0F);
          GlStateManager.disableTexture2D();
          GlStateManager.enableColorLogic();
          GlStateManager.colorLogicOp(GlStateManager.LogicOp.OR_REVERSE);
          bufferbuilder.begin(7, DefaultVertexFormats.POSITION);
          bufferbuilder.pos(startX, endY, 0.0D).endVertex();
          bufferbuilder.pos(endX, endY, 0.0D).endVertex();
          bufferbuilder.pos(endX, startY, 0.0D).endVertex();
          bufferbuilder.pos(startX, startY, 0.0D).endVertex();
          tessellator.draw();
          GlStateManager.disableColorLogic();
          GlStateManager.enableTexture2D();
      }
  
      /**
       * Sets the maximum length for the text in this text box. If the current text is longer than this length, the
       * current text will be trimmed.
       */
      public void setMaxStringLength(int length)
      {
          this.maxStringLength = length;
  
          if (text.length() > length)
          {
              text = text.substring(0, length);
          }
      }
  
      /**
       * returns the maximum number of character that can be contained in this textbox
       */
      public int getMaxStringLength()
      {
          return this.maxStringLength;
      }
  
      /**
       * returns the current position of the cursor
       */
      public int getCursorPosition()
      {
          return this.cursorPosition;
      }
  
      /**
       * Gets whether the background and outline of this text box should be drawn (true if so).
       */
      public boolean getEnableBackgroundDrawing()
      {
          return this.enableBackgroundDrawing;
      }
  
      /**
       * Sets whether or not the background and outline of this text box should be drawn.
       */
      public void setEnableBackgroundDrawing(boolean enableBackgroundDrawingIn)
      {
          this.enableBackgroundDrawing = enableBackgroundDrawingIn;
      }
  
      /**
       * Sets the color to use when drawing this text box's text. A different color is used if this text box is disabled.
       */
      public void setTextColor(int color)
      {
          this.enabledColor = color;
      }
  
      /**
       * Sets the color to use for text in this text box when this text box is disabled.
       */
      public void setDisabledTextColour(int color)
      {
          this.disabledColor = color;
      }
  
      /**
       * Sets focus to this gui element
       */
      public void setFocused(boolean isFocusedIn)
      {
          if (isFocusedIn && !this.isFocused)
          {
              this.cursorCounter = 0;
          }
  
          this.isFocused = isFocusedIn;
  
          if (Minecraft.getMinecraft().currentScreen != null)
          {
              Minecraft.getMinecraft().currentScreen.setFocused(isFocusedIn);
          }
      }
  
      /**
       * Getter for the focused field
       */
      public boolean isFocused()
      {
          return this.isFocused;
      }
  
      /**
       * Sets whether this text box is enabled. Disabled text boxes cannot be typed in.
       */
      public void setEnabled(boolean enabled)
      {
          this.isEnabled = enabled;
      }
  
      /**
       * the side of the selection that is not the cursor, may be the same as the cursor
       */
      public int getSelectionEnd()
      {
          return this.selectionEnd;
      }
  
      /**
       * returns the width of the textbox depending on if background drawing is enabled
       */
      public int getWidth()
      {
          return this.getEnableBackgroundDrawing() ? this.width - 8 : this.width;
      }
  
      /**
       * Sets the position of the selection anchor (the selection anchor and the cursor position mark the edges of the
       * selection). If the anchor is set beyond the bounds of the current text, it will be put back inside.
       */
      public void setSelectionPos(int position)
      {
          int i = text.length();
  
          if (position > i)
          {
              position = i;
          }
  
          if (position < 0)
          {
              position = 0;
          }
  
          this.selectionEnd = position;
  
          if (this.fontRenderer != null)
          {
              if (this.lineScrollOffset > i)
              {
                  this.lineScrollOffset = i;
              }
  
              int j = this.getWidth();
              String s = this.fontRenderer.trimStringToWidth(text.substring(this.lineScrollOffset), j);
              int k = s.length() + this.lineScrollOffset;
  
              if (position == this.lineScrollOffset)
              {
                  this.lineScrollOffset -= this.fontRenderer.trimStringToWidth(text, j, true).length();
              }
  
              if (position > k)
              {
                  this.lineScrollOffset += position - k;
              }
              else if (position <= this.lineScrollOffset)
              {
                  this.lineScrollOffset -= this.lineScrollOffset - position;
              }
  
              this.lineScrollOffset = MathHelper.clamp(this.lineScrollOffset, 0, i);
          }
      }
  
      /**
       * Sets whether this text box loses focus when something other than it is clicked.
       */
      public void setCanLoseFocus(boolean canLoseFocusIn)
      {
          this.canLoseFocus = canLoseFocusIn;
      }
  
      /**
       * returns true if this textbox is visible
       */
      public boolean getVisible()
      {
          return this.visible;
      }
  
      /**
       * Sets whether or not this textbox is visible
       */
      public void setVisible(boolean isVisible)
      {
          this.visible = isVisible;
      }
  }
  