------------------- Configuration -------------------
local InterfaceAPIVersion = 2.3
-----------------------------------------------------
local DefaultTheme = {
  Window = {},
  Button = {},
  Selection = {},
  Combobox = {},
  Graph = {},
  Label = {},
  Textbox = {},
  Checkbox = {},
  Rectangle = {},
  Listbox = {}
}

local function DefineInterfaceComponents()
  function interface_s.Components.Window:new(x, y, Width, Height, Movable, theme)
    local obj= {}
    obj.Type = "Window"

    obj.AllowResize = true
    obj.AlwaysFocused = false
    obj.IsMovable = Movable
    obj.MinWidth = 16
    obj.MinHeight = 16
    obj.Theme = theme
    obj.X = x
    obj.Y = y
    obj.Width = Width
    obj.Height = Height

    obj.OnShow = nil
    obj.OnHide = nil
    obj.OnDraw = nil
    obj.OnEndDraw = nil
    obj.OnMove = nil

    obj.Focused=false
    obj.Items = {}
    obj.MoveStartX = -1
    obj.MoveStartY = -1
    obj.IsMoving = false
    obj.IsShowing = true
    obj.IsResizing = false
    obj.ResizeStartX = 1
    obj.ResizeStartY = 1
    obj.ResizeStartWidth = 1
    obj.ResizeStartHeight = 1
    obj.ResizeLastWidth =0
    obj.ResizeLastHeight=0  
    obj.SizeOfHeader = 8  
    function obj:Draw(IsFocused,mx,my)
      self.Focused=IsFocused or self.AlwaysFocused
      if self.OnDraw ~= nil then
        if self.OnDraw(IsFocused,mx,my) == true then
          return
        end
      end
      if self.Focused == true then
        gfx.fillRect(self.X, self.Y, self.Width,self.Height, gfx.getColors(self.Theme.BackColor))
        gfx.drawRect(self.X, self.Y, self.Width,self.Height, gfx.getColors(self.Theme.BorderColor))
        if self.IsMovable then
          gfx.fillRect(self.X, self.Y, self.Width,self.SizeOfHeader, gfx.getColors(self.Theme.HeaderColor))
        end
        if self.AllowResize==true then
          gfx.fillRect(self.X+self.Width-6, self.Y+self.Height-6, 6,6, gfx.getColors(self.Theme.BorderColor))
        end
      else
        gfx.fillRect(self.X, self.Y, self.Width,self.Height, gfx.getColors(self.Theme.UnfocusedBackColor))
        gfx.drawRect(self.X, self.Y, self.Width,self.Height, gfx.getColors(self.Theme.UnfocusedBorderColor))
        if self.AllowResize==true then
          gfx.fillRect(self.X+self.Width-6, self.Y+self.Height-6, 6,6, gfx.getColors(self.Theme.UnfocusedBorderColor))
        end
        if self.IsMovable then
          gfx.fillRect(self.X, self.Y, self.Width,self.SizeOfHeader, gfx.getColors(self.Theme.UnfocusedHeaderColor))
        end
      end
      for i=#self.Items,0,-1 do
        if (self.Items[i]~=nil) and (self.Items[i].IsShowing==true) then
          self.Items[i]:Draw(self.Focused,self.X,self.Y,mx-self.X,my-self.Y)
        end
      end
      if self.OnEndDraw ~= nil then
        if self.OnEndDraw(IsFocused,mx,my) == true then
          return
        end
      end
    end 
    function obj:Show()
      self.IsShowing = true
      if self.OnShow ~= nil then
         self.OnShow(self)
      end
    end
    function obj:Hide()
      self.IsShowing = false
      if self.OnHide ~= nil then
         self.OnHide(self)
      end
    end
    function obj:Resize(ws,hs)
      if ws < self.MinWidth then
        ws=self.MinWidth
      end
      if hs < self.MinHeight then
        hs=self.MinHeight
      end
      self.ResizeLastHeight = self.Height
      self.ResizeLastWidth = self.Width
      self.Height = hs
      self.Width = ws
      hs = self.Height-self.ResizeLastHeight
      ws = self.Width-self.ResizeLastWidth
      for i=0,#self.Items do
        if self.Items[i]~=nil then
          if self.Items[i].Anchor.Top==true and self.Items[i].Anchor.Bottom==true then
            self.Items[i].Height = self.Items[i].Height + hs
          end
          if self.Items[i].Anchor.Top==false and self.Items[i].Anchor.Bottom==true then
            self.Items[i].Y = self.Items[i].Y + hs
          end
          if self.Items[i].Anchor.Left==true and self.Items[i].Anchor.Right==true then
            self.Items[i].Width = self.Items[i].Width + ws
          end
          if self.Items[i].Anchor.Left==false and self.Items[i].Anchor.Right==true then
            self.Items[i].X = self.Items[i].X + ws
          end
        end
      end
    end
    function obj:AddComponent(component)
      self.Items[#self.Items+1] = component
      component.Base = self
    end
    function obj:GetComponentIndex(obj2)
      for i=0, #self.Items do
        if self.Items[i] == obj2 then
          return i
        end
      end
      return -1
    end
    function obj:focusComponent(obj2)
      local index = self:GetComponentIndex(obj2)
      for i=index, 1,-1 do
        self.Items[i] = self.Items[i-1] 
      end
      self.Items[0] = obj2
    end
    function obj:KeyPress(char, code, mod, evt)
      for i=0,#self.Items do
        if (self.Items[i]~=nil) and (self.Items[i].IsShowing==true) and (self.Items[i].KeyPress~=nil) then
          if self.Items[i]:KeyPress(char, code, mod, evt) then
            return true
          end
        end
      end
    end
    function obj:Click(x,y,e,b,w)
      if (self.IsMovable) and (e==3) and (self.IsMoving) then
        self.X = self.X - self.MoveStartX + x
        self.Y = self.Y - self.MoveStartY + y
        if self.OnMove~=nil then
          self.OnMove(self.X,self.Y)
        end
        self.MoveStartX = x
        self.MoveStartY = y
      else
        if (self.IsMovable) and (e==2) and (self.IsMoving) then
          self.IsMoving = false
        end
      end
      if self.IsResizing== false then
        for i=0,#self.Items do
          if (self.Items[i]~=nil) and (self.Items[i].IsShowing==true) then
            if self.Items[i]:Click(x-self.X,y-self.Y,e,b,w) then
              return true
            end
          end
        end
      end
      if (x>self.X) and (x<self.X+self.Width) and (y>self.Y) and (y<self.Y+self.Height) then
        if self.Focused then
          if self.AllowResize==true and self.IsResizing==false and e==1 and x>self.X+self.Width-8 and x<self.X+self.Width and y>self.Y+self.Height-self.SizeOfHeader and y<self.Y+self.Height then
            self.IsResizing=true
            self.ResizeStartX = x
            self.ResizeStartY = y
            self.ResizeStartWidth = self.Width
            self.ResizeStartHeight = self.Height
            return true
          end
          if (self.IsMovable) and (y>self.Y) and (y<self.Y+self.SizeOfHeader) and (e==1) then
            self.MoveStartX = x
            self.MoveStartY = y
            self.IsMoving = true
          end
          if self.IsResizing==false then
            return true
          end
        else
          if e==1 then
            return true
          end
        end
      else
        if (self.IsMovable) and (e==3) and (self.IsMoving)then
          self.X = self.X - self.MoveStartX + x
          self.Y = self.Y - self.MoveStartY + y
          self.MoveStartX = x
          self.MoveStartY = y
          return true
        end
        if IsResizing==false then
          return false
        end
      end
      if self.IsResizing==true and e==3 then
        self:Resize(self.ResizeStartWidth-self.ResizeStartX+x,self.ResizeStartHeight-self.ResizeStartY+y)
        return true
      end
      if self.IsResizing==true and e==2 then
        self.IsResizing = false
        return true
      end
    end
    setmetatable(obj, self)
    self.__index = self;
    return obj
  end

  function interface_s.Components.Button:new(x, y, Width, Height, text, theme)
    local obj= {}
    obj.Type = "Button"
    obj.X = x
    obj.Y = y
    obj.Width = Width
    obj.Height = Height
    obj.Focused=false
    obj.Theme = theme
    obj.IsShowing = true
    obj.Text = text
    
    obj.OnPressed = nil
    obj.OnDraw = nil
    obj.OnEndDraw = nil
    obj.ClickHelper = interface_s.ComponentsHelpers.Click:new()
    obj.HintText = ""
    obj.HintHelper = nil
    obj.Anchor = {Top = false,Bottom=false,Left=false,Right=false}
    function obj:Draw(IsFocused, baseX, baseY,x,y)
      self.Focused=IsFocused
      if self.OnDraw ~= nil then
        if self.OnDraw(IsFocused,self.X+baseX,self.Y+baseY,x,y) == true then
          return
        end
      end
      local tw, th = gfx.textSize(self.Text)
      if IsFocused == true then
        if (x>self.X) and (x<self.X+self.Width) and (y>self.Y) and (y<self.Y+self.Height) then
          if self.ClickHelper.IsHold then
            gfx.fillRect(self.X+baseX, self.Y+baseY, self.Width,self.Height, gfx.getColors(self.Theme.PressedBackColor))
            gfx.drawText(self.X+baseX+(self.Width-tw)/2, self.Y+baseY + (self.Height-th)/2+1, self.Text, gfx.getColors(self.Theme.PressedTextColor))
          else
            gfx.fillRect(self.X+baseX, self.Y+baseY, self.Width,self.Height, gfx.getColors(self.Theme.MouseOverColor))
            gfx.drawText(self.X+baseX+(self.Width-tw)/2, self.Y+baseY + (self.Height-th)/2+1, self.Text, gfx.getColors(self.Theme.TextColor))
            if self.HintHelper~=nil then
              self.HintHelper:MouseOver(x+baseX,y+baseY,self.HintText)
            end
          end
        else
          if self.HintHelper~=nil then
            self.HintHelper:Reset()
          end
          gfx.fillRect(self.X+baseX, self.Y+baseY, self.Width,self.Height, gfx.getColors(self.Theme.BackColor))
          gfx.drawText(self.X+baseX+(self.Width-tw)/2, self.Y+baseY + (self.Height-th)/2+1, self.Text, gfx.getColors(self.Theme.TextColor))
        end
        gfx.drawRect(self.X+baseX, self.Y+baseY, self.Width,self.Height, gfx.getColors(self.Theme.BorderColor))
      else
        if self.HintHelper~=nil then
          self.HintHelper:Reset()
        end
        if (x>self.X) and (x<self.X+self.Width) and (y>self.Y) and (y<self.Y+self.Height) then
          if self.ClickHelper.IsHold then
            gfx.fillRect(self.X+baseX, self.Y+baseY, self.Width,self.Height, gfx.getColors(self.Theme.PressedBackColor))
            gfx.drawText(self.X+baseX+(self.Width-tw)/2, self.Y+baseY + (self.Height-th)/2+1, self.Text, gfx.getColors(self.Theme.PressedTextColor))
          else
            gfx.fillRect(self.X+baseX, self.Y+baseY, self.Width,self.Height, gfx.getColors(self.Theme.UnfocusedMouseOverColor))
            gfx.drawText(self.X+baseX+(self.Width-tw)/2, self.Y+baseY + (self.Height-th)/2+1, self.Text, gfx.getColors(self.Theme.UnfocusedTextColor))
          end
        else
          gfx.fillRect(self.X+baseX, self.Y+baseY, self.Width,self.Height, gfx.getColors(self.Theme.UnfocusedBackColor))
          gfx.drawText(self.X+baseX+(self.Width-tw)/2, self.Y+baseY + (self.Height-th)/2+1, self.Text, gfx.getColors(self.Theme.UnfocusedTextColor))
        end
        gfx.drawRect(self.X+baseX, self.Y+baseY, self.Width,self.Height, gfx.getColors(self.Theme.UnfocusedBorderColor))
      end
      if self.OnEndDraw ~= nil then
        if self.OnEndDraw(IsFocused,self.X+baseX,self.Y+baseY,x,y) == true then
          return
        end
      end
    end 
    function obj:Show()
      self.IsShowing = true
    end
    function obj:Hide()
      self.IsShowing = false
    end
    function obj:Click(x,y,e,b)
      self.ClickHelper.OnPress = self.OnPressed
      self.ClickHelper:ProcessClick(self.Width,self.Height,self.X,self.Y,x,y,e,b)
    end
    function obj:AddHint(text)
      self.HintText = text
      self.HintHelper = interface_s.ComponentsHelpers.Hint:new()
    end
    setmetatable(obj, self)
    self.__index = self;
    return obj
  end

  function interface_s.Components.Selection:new(x, y, theme)
    local obj= {}
    obj.X = x
    obj.Y = y
    obj.Focused=false
    obj.Theme = theme
    obj.IsShowing = true
    obj.IsPointSet = false
    obj.FirstPointX = -1
    obj.FirstPointY = -1
    obj.IsFinished = false
    obj.EndPointX = -1
    obj.EndPointY = -1
    obj.OnSelectionStart = nil
    obj.OnSelected = nil
    obj.OnSelectionAborted = nil
    obj.V2EndWidth = -1
    obj.V2EndHeight = -1
    obj.V2StartX = -1
    obj.V2StartY = -1
    function obj:Draw(IsFocused,x,y)
      self.Focused = IsFocused
      if IsFocused then
        if (self.IsPointSet) and (self.IsFinished==false) then
          local arg11 = -1
          local arg12 = -1
          local arg21 = -1
          local arg22 = -1
          if self.FirstPointX-x>=0 then
            arg11 = x
            arg12 = self.FirstPointX-x
          else
            arg11 = self.FirstPointX
            arg12 = x-self.FirstPointX
          end
          if self.FirstPointY - y>=0 then
            arg21 = y
            arg22 = self.FirstPointY - y
          else
            arg21 = self.FirstPointY
            arg22 = y-self.FirstPointY
          end
          if (self.IsFinished==false) and (self.IsPointSet==true)  then
            self.V2EndWidth = arg12
            self.V2EndHeight = arg22
            self.V2StartX = arg11
            self.V2StartY = arg21
          end
          gfx.fillRect(arg11, arg21, arg12,arg22, gfx.getColors(self.Theme.BackColor))
          gfx.drawRect(arg11, arg21, arg12,arg22, gfx.getColors(self.Theme.BorderColor))
        end
      else
        self.IsPointSet = false
      end
    end 
    function obj:Show()
      self.IsShowing = true
    end
    function obj:Hide()
      self.IsShowing = false
    end
    function obj:Click(x,y,e,b)
      if (e==1) and (self.IsPointSet==false) and (b==1) then
        self.IsPointSet = true
        self.FirstPointX = x
        self.FirstPointY = y
        if self.OnSelectionStart ~= nil then
          self.OnSelectionStart(self.FirstPointX,self.FirstPointY)
        end
        return true
      else if (e==2) and (self.IsPointSet==true) and (b==1) and (self.IsFinished == false) then
        self.IsFinished = true
        self.EndPointX = x
        self.EndPointY = y
        if self.OnSelected ~= nil then
          self.OnSelected(self.FirstPointX,self.FirstPointY,self.EndPointX,self.EndPointY, self.V2StartX, self.V2StartY, self.V2EndWidth,self.V2EndHeight)
        end
        return true
        end
        if (self.IsPointSet==true) and (b~=1) and (self.IsFinished==false) then
          self.IsPointSet=false
          if self.OnSelectionAborted ~= nil then
            self.OnSelectionAborted()
          end
        end
      end
    end
    setmetatable(obj, self)
    self.__index = self;
    return obj
  end

  function interface_s.Components.SelectionMover:new(x, y,w,h, theme)
    local obj= {}
    obj.X = x
    obj.Y = y
    obj.Focused=false
    obj.Theme = theme
    obj.IsShowing = true
    obj.Width = w
    obj.Height = h
    obj.OnMovement = nil
    obj.OnAbort = nil
    obj.OnDone = nil
    obj.MoveStartX = -1
    obj.MoveStartY = -1
    obj.NewPosX = -1
    obj.NewPosY = -1
    obj.IsMoving = false
    obj.SumDX = 0
    obj.SumDY = 0
    obj.IsMoved = false
    function obj:Draw(IsFocused,x,y)
      self.Focused = IsFocused
      if IsFocused then
        gfx.fillRect(self.X, self.Y, self.Width,self.Height, gfx.getColors(self.Theme.BackColor))
        gfx.drawRect(self.X, self.Y, self.Width,self.Height, gfx.getColors(self.Theme.BorderColor))
      else
        gfx.fillRect(self.X, self.Y, self.Width,self.Height, gfx.getColors(self.Theme.BackColor))
        gfx.drawRect(self.X, self.Y, self.Width,self.Height, gfx.getColors(self.Theme.BorderColor))
      end
    end 
    function obj:Show()
      self.IsShowing = true
    end
    function obj:Hide()
      self.IsShowing = false
    end
    function obj:Click(x,y,e,b)
      if (e==1) and (b==4) then
        if self.OnAbort ~= nil then
          self.OnAbort(self.SumDX,self.SumDY)
        end
      end
      if (e==3) and (self.IsMoving) then
        if self.OnMovement ~= nil then
          self.OnMovement(-self.MoveStartX + x,- self.MoveStartY + y)
        end
        if (-self.MoveStartX + x ~= 0) and (- self.MoveStartY + y ~= 0) then
          self.IsMoved = true
        end
        self.SumDX = self.SumDX - self.MoveStartX + x
        self.SumDY = self.SumDY - self.MoveStartY + y
        self.X = self.X - self.MoveStartX + x
        self.Y = self.Y - self.MoveStartY + y
        self.MoveStartX = x
        self.MoveStartY = y

      else
        if (e==2) and (self.IsMoving) then
          if self.IsMoved == false then
            if self.OnDone ~= nil then
              self.OnDone(self.SumDX,self.SumDY)
            end
          end
          self.IsMoving = false
        end
      end
      if (x>self.X) and (x<self.X+self.Width) and (y>self.Y) and (y<self.Y+self.Height) then
        if self.Focused then
          if (y>self.Y) and (y<self.Y+self.Height) and (e==1) then
            self.MoveStartX = x
            self.MoveStartY = y
            self.IsMoving = true
          end
          if (e==1) and (b==1) then
            self.IsMoved = false
          end
          return true
        end
      else
        return true
      end
    end
    setmetatable(obj, self)
    self.__index = self;
    return obj
  end

  function interface_s.Components.Combobox:new(x, y,w,h,i, theme)
    local obj= {}
    obj.Type = "Combobox"
    obj.X = x
    obj.Y = y
    obj.Focused=false
    obj.Theme = theme
    obj.IsShowing = true
    obj.Width = w
    obj.Height = h
    obj.Anchor = {Top = false,Bottom=false,Left=false,Right=false}
    obj.Items = i
    obj.IsItemsShown = false
    obj.Base = nil
    obj.SelectedIndex=0
    obj.OnItemSelected = nil
    obj.DropClickHelper = interface_s.ComponentsHelpers.Click:new()
      obj.DropClickHelper.OnPress = function()
          if obj.IsItemsShown==false then
            obj.Base:focusComponent(obj)
            obj.IsItemsShown = true
          end
        end
    obj.ItemClickHelper = interface_s.ComponentsHelpers.Click:new()
      obj.ItemClickHelper.OnHold = function() return true end
      obj.ItemClickHelper.OnFirstClick = function() return true end
      obj.ItemClickHelper.OnPress = function(x,y)
          local i = y-obj.Y-obj.Height
          obj.SelectedIndex=math.floor(i/14)
          if obj.OnItemSelected~= nil then
            obj.OnItemSelected(obj.SelectedIndex,obj.Items[obj.SelectedIndex+1])
          end
          obj.IsItemsShown = false
          interface_s.RemoveOnClickAction(obj)
          return true
        end
      obj.ItemClickHelper.OnMissClick = function(x,y)
        obj.IsItemsShown = false
        interface_s.RemoveOnClickAction(obj)
        return true
      end
    function obj:Draw(IsFocused, baseX, baseY,x,y)
      self.Focused = IsFocused
      if IsFocused then
        gfx.drawRect(self.X+baseX,self.Y+baseY,self.Width,self.Height,gfx.getColors(self.Theme.BorderColor))
        if self.SelectedIndex>=0 then
          gfx.drawText(self.X+baseX+5,self.Y+baseY+3, self.Items[self.SelectedIndex+1], gfx.getColors(self.Theme.TextColor))
        end
        if self.IsItemsShown==true then
          gfx.fillRect(self.X+self.Width-self.Height+baseX, self.Y+baseY, self.Height,self.Height, gfx.getColors(self.Theme.ButtonPressedBackColor))
        else
          if x>self.X+self.Width-self.Height and x<self.X+self.Width and y>self.Y and y<self.Y+self.Height then
            gfx.fillRect(self.X+self.Width-self.Height+baseX, self.Y+baseY, self.Height,self.Height, gfx.getColors(self.Theme.ButtonMouseOverBackColor))
          else
            gfx.fillRect(self.X+self.Width-self.Height+baseX, self.Y+baseY, self.Height,self.Height, gfx.getColors(self.Theme.ButtonBackColor))
          end
        end
        gfx.drawRect(self.X+self.Width-self.Height+baseX, self.Y+baseY, self.Height,self.Height, gfx.getColors(self.Theme.BorderColor))
        if self.IsItemsShown==true then
          gfx.fillRect(self.X+baseX,self.Y+baseY+self. Height,self.Width,#self.Items*14,gfx.getColors(self.Theme.BackColor))
          for i=0,#self.Items-1 do
            if x>self.X and x<self.X+self.Width and y>self.Y+i*14+self.Height and y<self.Y+i*14+self.Height+15 then
              gfx.fillRect(self.X+baseX,self.Y+baseY+i*14+self.Height,self.Width,14+1,gfx.getColors(self.Theme.ButtonMouseOverBackColor))
            end
            gfx.drawRect(self.X+baseX,self.Y+baseY+i*14+self.Height,self.Width,14+1,gfx.getColors(self.Theme.BorderColor))
            gfx.drawText(self.X+baseX+5,self.Y+baseY+i*14+3+self.Height, self.Items[i+1],gfx.getColors(self.Theme.TextColor))
          end
        end
      else
        obj.IsItemsShown = false
        gfx.drawRect(self.X+baseX,self.Y+baseY,self.Width,self.Height,gfx.getColors(self.Theme.UnfocusedBorderColor))
        if self.SelectedIndex>=0 then
          gfx.drawText(self.X+baseX+5,self.Y+baseY+3, self.Items[self.SelectedIndex+1],gfx.getColors(self.Theme.UnfocusedTextColor))
        end
        if x>self.X+self.Width-self.Height and x<self.X+self.Width and y>self.Y and y<self.Y+self.Height then
          gfx.fillRect(self.X+self.Width-self.Height+baseX, self.Y+baseY, self.Height,self.Height, gfx.getColors(self.Theme.UnfocusedButtonMouseOverBackColor))
        else
          gfx.fillRect(self.X+self.Width-self.Height+baseX, self.Y+baseY, self.Height,self.Height,gfx.getColors(self.Theme.UnfocusedButtonBackColor))
        end
        gfx.drawRect(self.X+self.Width-self.Height+baseX, self.Y+baseY, self.Height,self.Height, gfx.getColors(self.Theme.UnfocusedBorderColor))
      end
    end 
    function obj:Show()
      self.IsShowing = true
    end
    function obj:Hide()
      self.IsShowing = false
    end
    function obj:Click(x,y,e,b)
      if self.IsItemsShown==true then
        return self.ItemClickHelper:ProcessClick(self.Width,#self.Items*14,self.X,self.Y+self.Height,x,y,e,b)
      end
      return self.DropClickHelper:ProcessClick(self.Height,self.Height,self.X+self.Width-self.Height,self.Y,x,y,e,b)
    end
    setmetatable(obj, self)
    self.__index = self;
    return obj
  end

  function interface_s.Components.Graph:new(x, y,w,h, theme)
    local obj= {}
    obj.Type = "Graph"
    obj.X = x
    obj.Y = y
    obj.Focused=false
    obj.Theme = theme
    obj.IsShowing = true
    obj.Width = w
    obj.Height = h
    obj.PointX = {} 
    obj.PointY = {} 
    obj.Base = nil
    obj.MaxValue = 0
    obj.NewMaxValue = 0
    obj.MinValue = 0
    obj.NewMinValue = 0
    obj.UpdateSpeed = 20
    obj.UpdateCounter = 0
    obj.GetValue = nil
    obj.ZeroHeight = 0
    obj.Anchor = {Top = false,Bottom=false,Left=false,Right=false}
    function obj:Draw(IsFocused, baseX, baseY,x,y)
      if self.UpdateCounter>self.UpdateSpeed then
        if self.GetValue ~= nil then
          self:AddPoint(self.GetValue())
        end
        self.UpdateCounter=0
      end
      self.UpdateCounter=self.UpdateCounter+1
      self.Focused = IsFocused
      if IsFocused==true then
        gfx.fillRect(self.X+baseX,self.Y+baseY,self.Width,self.Height,gfx.getColors(self.Theme.BackColor))
        gfx.drawRect(self.X+baseX,self.Y+baseY,self.Width,self.Height,gfx.getColors(self.Theme.BorderColor))
        gfx.drawText(self.X+baseX,self.Y+baseY-10,"Max: "..self.MaxValue,gfx.getColors(self.Theme.TextColor))
        gfx.drawText(self.X+baseX+100,self.Y+baseY-10,"Min: "..self.MinValue,gfx.getColors(self.Theme.TextColor))
      else
        gfx.fillRect(self.X+baseX,self.Y+baseY,self.Width,self.Height,gfx.getColors(self.Theme.UnfocusedBackColor))
        gfx.drawRect(self.X+baseX,self.Y+baseY,self.Width,self.Height,gfx.getColors(self.Theme.UnfocusedBorderColor))
        gfx.drawText(self.X+baseX,self.Y+baseY-10,"Max: "..self.MaxValue,gfx.getColors(self.Theme.UnfocusedTextColor))
        gfx.drawText(self.X+baseX+100,self.Y+baseY-10,"Min: "..self.MinValue,gfx.getColors(self.Theme.UnfocusedTextColor))
      end
      self.NewMaxValue = 0
      self.NewMinValue = 0
      if self.PointX[#self.PointX] ~= nil then
        local v = self.PointX[#self.PointX]-self.Width+1
        if v>0 then
          for i=v,#self.PointY do
            self.PointY[i-v]=self.PointY[i]
            self.PointX[i-v]=self.PointX[i]-v
          end
          for i=#self.PointY-v,#self.PointY do
            self.PointY[i]=nil
            self.PointX[i]=nil
          end
        end
      end
      for i=2, #self.PointX do
        if self.PointX[i]<self.Width-1 then
          if self.NewMaxValue < self.PointY[i] then
            self.NewMaxValue = self.PointY[i]
          else
            if self.NewMinValue>self.PointY[i] then
              self.NewMinValue = self.PointY[i]
            end
          end
          if self.MaxValue < self.PointY[i] then
            self.MaxValue = self.PointY[i]
          else
            if self.MinValue>self.PointY[i] then
              self.MinValue = self.PointY[i]
            end
          end
          local x1 = self.PointX[i]+self.X+baseX
          local y1 = (self.Height-((self.PointY[i]+math.abs( self.MinValue ))/(self.MaxValue+math.abs( self.MinValue )))*(self.Height-3))+self.Y+baseY-2
          local x2 = self.PointX[i-1]+self.X+baseX
          local y2 = (self.Height-((self.PointY[i-1]+math.abs( self.MinValue ))/(self.MaxValue+math.abs( self.MinValue )))*(self.Height-3))+self.Y+baseY-2
          if y1==y1 and y2==y2 then
            if IsFocused==true then    
              gfx.drawLine(x1,y1,x2,y2,gfx.getColors(self.Theme.GraphColor))
            else
              gfx.drawLine(x1,y1,x2,y2,gfx.getColors(self.Theme.UnfocusedGraphColor))
            end
          end
        end
      end
      if self.PointY[1]~=nil then
        if self.NewMaxValue < self.PointY[1] then
          self.NewMaxValue = self.PointY[1]
        else
          if self.NewMinValue>self.PointY[1] then
            self.NewMinValue = self.PointY[1]
          end
        end
        if self.MaxValue < self.PointY[1] then
          self.MaxValue = self.PointY[1]
        else
          if self.MinValue>self.PointY[1] then
            self.MinValue = self.PointY[1]
          end
        end
        self.ZeroHeight = (self.Height-((math.abs( self.MinValue ))/(self.MaxValue+math.abs( self.MinValue )))*(self.Height-3))+self.Y+baseY-2
        if self.ZeroHeight == self.ZeroHeight then
          if IsFocused== true then
            gfx.drawLine(self.X+baseX,self.ZeroHeight,self.X+baseX+self.Width-1,self.ZeroHeight,gfx.getColors(self.Theme.ZeroLine))
          else
            gfx.drawLine(self.X+baseX,self.ZeroHeight,self.X+baseX+self.Width-1,self.ZeroHeight,gfx.getColors(self.Theme.UnfocusedZeroLine))
          end
        end
      end
      self.MaxValue = self.NewMaxValue
      self.MinValue = self.NewMinValue
    end 
    function obj:Show()
      self.IsShowing = true
    end
    function obj:Hide()
      self.IsShowing = false
    end
    function obj:AddPoint(v) 
      if v~= nil then
      if #self.PointY==0 then
        self.PointY[1]=v
        self.PointX[1]=1
      else
        if #self.PointY+1 < self.Width-1 then
        self.PointY[#self.PointY+1]=v
        self.PointX[#self.PointX+1]=self.PointX[#self.PointX]+1
        else
          for i=2,#self.PointY do
            self.PointY[i-1]=self.PointY[i]
            self.PointX[i-1]=self.PointX[i]-1
          end
          self.PointY[#self.PointY]=v
          self.PointX[#self.PointX]=self.PointX[#self.PointX]
        end
      end
      end
    end
    function obj:ClearPoints() 
        self.PointY = {}
        self.PointX = {}
    end
    function obj:Click(x,y,e,b)
      if (x>self.X+self.Width-self.Height) and (x<self.X+self.Width) and (y>self.Y) and (y<self.Y+self.Height) then
        return true
      end
    end
    setmetatable(obj, self)
    self.__index = self;
    return obj
  end

  function interface_s.Components.Label:new(x, y, t, theme)
    local obj= {}
    obj.Type = "Label"
    obj.X = x
    obj.Y = y
    obj.Focused=false
    obj.Theme = theme
    obj.IsShowing = true
    obj.Text = t
    obj.Base = nil
    obj.Anchor = {Top = false,Bottom=false,Left=false,Right=false}
    obj.OnMouseEvent = nil
    obj.HintText = ""
    obj.HintHelper = nil
    function obj:Draw(IsFocused, baseX, baseY,x,y)
      self.Focused = IsFocused
      if IsFocused==true then
        gfx.drawText(self.X+baseX,self.Y+baseY,self.Text,gfx.getColors(self.Theme.TextColor))
        local tw, th = gfx.textSize(self.Text)
        if (x>self.X) and (x<self.X+tw) and (y>self.Y) and (y<self.Y+th) then
          if self.HintHelper~=nil then
            self.HintHelper:MouseOver(x+baseX,y+baseY,self.HintText)
          end
        else
          if self.HintHelper~=nil then
            self.HintHelper:Reset()
          end
        end
        
      else
        if self.HintHelper~=nil then
          self.HintHelper:Reset()
        end
        gfx.drawText(self.X+baseX,self.Y+baseY,self.Text,gfx.getColors(self.Theme.UnfocusedTextColor))
      end
    end 
    function obj:Show()
      self.IsShowing = true
    end
    function obj:Hide()
      self.IsShowing = false
    end
    function obj:Click(x,y,e,b,w)
      if self.OnMouseEvent~=nil then
        self.OnMouseEvent(x,y,e,b,w)
      end
    end
    function obj:AddHint(text)
      self.HintText = text
      self.HintHelper = interface_s.ComponentsHelpers.Hint:new()
    end
    setmetatable(obj, self)
    self.__index = self;
    return obj
  end

  function interface_s.Components.Textbox:new(x, y, w, h, theme)
    local obj= {}
    obj.Type = "Textbox"
    obj.X = x
    obj.Y = y
    obj.Focused=false
    obj.Theme = theme
    obj.IsShowing = true
    obj.Width = w
    obj.Height = h
    obj.Text = ""
    obj.Base = nil
    obj.Anchor = {Top = false,Bottom=false,Left=false,Right=false}
    obj.IsActive = false
    obj.MaxTextLength = 10
    obj.PointerIndex = 0
    obj.PointerBlinkStep =0
    obj.OnTextChanged = nil
    obj.ClickHelper = interface_s.ComponentsHelpers.Click:new()
    obj.ClickHelper.OnPress = function()
        obj.IsActive = true
      end
    obj.ClickHelper.OnMissClick = function()
        obj.IsActive = false
      end
    function obj:Draw(IsFocused, baseX, baseY,x,y)
      self.Focused = IsFocused
      gfx.fillRect(self.X+baseX,self.Y+baseY,self.Width,self.Height,gfx.getColors(self.Theme.BackColor))
      if self.IsActive==true then
        gfx.drawRect(self.X+baseX,self.Y+baseY,self.Width,self.Height,gfx.getColors(self.Theme.BorderColor))
        self.PointerBlinkStep = self.PointerBlinkStep + 1
        if self.PointerBlinkStep > 30 then
          self.PointerBlinkStep=0
        end
        if self.PointerBlinkStep > 15 then
          local x = gfx.textSize(string.sub(self.Text, 0,self.PointerIndex) )
          gfx.drawLine(x+self.X+baseX+1,self.Y+baseY+4, x+self.X+baseX+1, self.Y+baseY+self.Height-4,gfx.getColors(self.Theme.PointerColor)) 
        end
      else
        gfx.drawRect(self.X+baseX,self.Y+baseY,self.Width,self.Height,gfx.getColors(self.Theme.UnfocusedBorderColor))
      end
      local x, y = gfx.textSize(string.sub(self.Text, 0,self.PointerIndex) )
      if IsFocused==true then
        gfx.drawText(self.X+baseX+2,self.Y+baseY+(self.Height-y+3)/2,self.Text,gfx.getColors(self.Theme.TextColor))
      else
        gfx.drawText(self.X+baseX+2,self.Y+baseY+(self.Height-y+3)/2,self.Text,gfx.getColors(self.Theme.UnfocusedTextColor))
      end
    end 
    function obj:Show()
      self.IsShowing = true
    end
    function obj:Hide()
      self.IsShowing = false
    end
    function obj:Click(x,y,e,b)
      self.ClickHelper:ProcessClick(self.Width,self.Height,self.X,self.Y,x,y,e,b)
    end
    function obj:KeyPress(char, code, mod, evt)
      if self.IsActive==true then
        if evt==1 then
          if code==8 and self.PointerIndex>0 then
            self.PointerIndex=self.PointerIndex-1
            self.Text=string.sub(self.Text,0,self.PointerIndex)..string.sub(self.Text,self.PointerIndex+2)
            if self.OnTextChanged~=nil then
              self.OnTextChanged(self.Text)
            end
          elseif code==127 and self.PointerIndex~=string.len(self.Text) then
            self.PointerIndex=self.PointerIndex
            self.Text=string.sub(self.Text,0,self.PointerIndex)..string.sub(self.Text,self.PointerIndex+2)
            if self.OnTextChanged~=nil then
              self.OnTextChanged(self.Text)
            end
          elseif code==275 and string.len(self.Text)>=self.PointerIndex+1 then
            self.PointerIndex=self.PointerIndex+1
          elseif code==276 and self.PointerIndex>0 then
            self.PointerIndex=self.PointerIndex-1
          else
            if string.len(self.Text)<=self.MaxTextLength and code>31 and code<127 then
              self.PointerIndex=self.PointerIndex+1
              self.Text=string.sub(self.Text,0,self.PointerIndex-1)..char..string.sub(self.Text,self.PointerIndex)
              if self.OnTextChanged~=nil then
                self.OnTextChanged(self.Text)
              end
            end
          end
        end
        return true
      end
    end
    setmetatable(obj, self)
    self.__index = self;
    return obj
  end

  function interface_s.Components.Checkbox:new(x, y, s, t, theme)
    local obj= {}
    obj.Type = "Checkbox"
    obj.X = x
    obj.Y = y
    obj.Focused=false
    obj.Theme = theme
    obj.IsShowing = true
    obj.Size = s
    obj.Text = t
    obj.Base = nil
    obj.Checked = false
    obj.OnStateChanged = nil
    obj.Anchor = {Top = false,Bottom=false,Left=false,Right=false}
    obj.ClickHelper = interface_s.ComponentsHelpers.Click:new()
    obj.ClickHelper.OnPress = function()
        if obj.Checked==true then
          obj.Checked = false
        else
          obj.Checked = true
        end
        if obj.OnStateChanged~=nil then
          obj.OnStateChanged(obj.Checked)
        end
      end
    function obj:Draw(IsFocused, baseX, baseY,x,y)
      self.Focused = IsFocused
      local x, y = gfx.textSize(self.Text)
      if IsFocused==true then
        gfx.drawRect(self.X+baseX,self.Y+baseY,self.Size,self.Size,gfx.getColors(self.Theme.BorderColor))
        if self.Checked==true then
          gfx.fillRect(self.X+baseX+3,self.Y+baseY+3,self.Size-6,self.Size-6,gfx.getColors(self.Theme.CheckColor))
        end
        gfx.drawText(self.X+baseX+self.Size+4,self.Y+baseY+(self.Size-y)/2+1,self.Text,gfx.getColors(self.Theme.TextColor))
      else
        gfx.drawRect(self.X+baseX,self.Y+baseY,self.Size,self.Size,gfx.getColors(self.Theme.UnfocusedBorderColor))
        if self.Checked==true then
          gfx.fillRect(self.X+baseX+3,self.Y+baseY+3,self.Size-6,self.Size-6,gfx.getColors(self.Theme.UnfocusedCheckColor))
        end
        gfx.drawText(self.X+baseX+self.Size+4,self.Y+baseY+(self.Size-y)/2+1,self.Text,gfx.getColors(self.Theme.UnfocusedCheckColor))
      end
    end 
    function obj:Show()
      self.IsShowing = true
    end
    function obj:Hide()
      self.IsShowing = false
    end
    function obj:Click(x,y,e,b)
      return self.ClickHelper:ProcessClick(self.Size,self.Size,self.X,self.Y,x,y,e,b)
    end
    setmetatable(obj, self)
    self.__index = self;
    return obj
  end


  function interface_s.Components.Listbox:new(x, y, w, h, theme)
    local obj= {}
    obj.Type = "Listbox"
    obj.X = x
    obj.Y = y
    obj.Focused=false
    obj.Theme = theme
    obj.IsShowing = true
    obj.Width = w
    obj.Height = h
    
    obj.OnItemSelected = nil

    obj.ItemsColsCount = 1
    obj.ItemsColsPadding = {0}
    obj.Base = nil
    obj.Items = {}
    obj.Anchor = {Top = false,Bottom=false,Left=false,Right=false}
    obj.IsActive = false
    obj.ScrollStartItemIndex = 1
    obj.SelectedIndex = 1
    obj.ItemClickHelper = interface_s.ComponentsHelpers.Click:new()
    obj.ItemClickHelper.OnPress = function(x,y)
        obj.SelectedIndex=math.floor((y-obj.Y)/11)+obj.ScrollStartItemIndex-1
        if obj.OnItemSelected~= nil then
          obj.OnItemSelected(obj.SelectedIndex,obj.Items[obj.SelectedIndex])
        end
        return true
    end
    function obj:Draw(IsFocused, baseX, baseY,x,y)
      self.Focused = IsFocused
      gfx.fillRect(self.X+baseX,self.Y+baseY,self.Width,self.Height,gfx.getColors(self.Theme.BackColor))
      gfx.drawRect(self.X+baseX,self.Y+baseY,self.Width,self.Height,gfx.getColors(self.Theme.BorderColor))
      local endindex = math.floor(self.Height/11)+self.ScrollStartItemIndex-1
      if table.getn(self.Items)<math.floor(self.Height/11) then
        endindex = table.getn(self.Items)
      end
      for i=self.ScrollStartItemIndex, endindex do
        if IsFocused then
          if self.SelectedIndex==i-1 then
            gfx.fillRect(self.X+baseX+2,self.Y+baseY+(i-self.ScrollStartItemIndex)*11+2,self.Width-4,10,gfx.getColors(self.Theme.SelectionColor))
            if self.ItemsColsCount==1 then
              gfx.drawText(self.X+baseX+3,self.Y+baseY+3+(i-self.ScrollStartItemIndex)*11,self.Items[i],gfx.getColors(self.Theme.SelectionTextColor))
            else
              for j=1, self.ItemsColsCount do
                gfx.drawText(self.X+baseX+3+self.ItemsColsPadding[j],self.Y+baseY+3+(i-self.ScrollStartItemIndex)*11,self.Items[i][j],gfx.getColors(self.Theme.SelectionTextColor))
              end
            end
          else
            if self.ItemsColsCount==1 then
              gfx.drawText(self.X+baseX+3,self.Y+baseY+3+(i-self.ScrollStartItemIndex)*11,self.Items[i],gfx.getColors(self.Theme.TextColor))
            else
              for j=1, self.ItemsColsCount do
                gfx.drawText(self.X+baseX+3+self.ItemsColsPadding[j],self.Y+baseY+3+(i-self.ScrollStartItemIndex)*11,self.Items[i][j],gfx.getColors(self.Theme.TextColor))
              end
            end
          end
          if x>self.X+3 and x<self.X+self.Width and y>self.Y+(i-self.ScrollStartItemIndex)*11 and y<self.Y+(i-self.ScrollStartItemIndex)*11+11 then
            gfx.fillRect(self.X+baseX+1,self.Y+baseY+(i-self.ScrollStartItemIndex)*11,self.Width-2,12,gfx.getColors(self.Theme.MouseOverColor))
          end
      else -- unfocused
        if self.SelectedIndex==i-1 then
          gfx.fillRect(self.X+baseX+2,self.Y+baseY+(i-self.ScrollStartItemIndex)*11+2,self.Width-4,10,gfx.getColors(self.Theme.UnfocusedSelectionColor))
          if self.ItemsColsCount==1 then
            gfx.drawText(self.X+baseX+3,self.Y+baseY+3+(i-self.ScrollStartItemIndex)*11,self.Items[i],gfx.getColors(self.Theme.UnfocusedSelectionTextColor))
          else
            for j=1, self.ItemsColsCount do
              gfx.drawText(self.X+baseX+3+self.ItemsColsPadding[j],self.Y+baseY+3+(i-self.ScrollStartItemIndex)*11,self.Items[i][j],gfx.getColors(self.Theme.UnfocusedSelectionTextColor))
            end
          end
        else
          if self.ItemsColsCount==1 then
            gfx.drawText(self.X+baseX+3,self.Y+baseY+3+(i-self.ScrollStartItemIndex)*11,self.Items[i],gfx.getColors(self.Theme.UnfocusedTextColor))
          else
            for j=1, self.ItemsColsCount do
              gfx.drawText(self.X+baseX+3+self.ItemsColsPadding[j],self.Y+baseY+3+(i-self.ScrollStartItemIndex)*11,self.Items[i][j],gfx.getColors(self.Theme.UnfocusedTextColor))
            end
          end
        end
        if x>self.X+3 and x<self.X+self.Width and y>self.Y+(i-self.ScrollStartItemIndex)*11 and y<self.Y+(i-self.ScrollStartItemIndex)*11+11 then
          gfx.fillRect(self.X+baseX+1,self.Y+baseY+(i-self.ScrollStartItemIndex)*11,self.Width-2,12,gfx.getColors(self.Theme.UnfocusedMouseOverColor))
        end
      end
    end
    end 
    function obj:Show()
      self.IsShowing = true
    end
    function obj:Hide()
      self.IsShowing = false
    end
    function obj:Click(x,y,e,b,w)
      if w==1 and self.ScrollStartItemIndex<table.getn(self.Items)-math.floor( self.Height/11 )+1 then
        self.ScrollStartItemIndex=self.ScrollStartItemIndex+1
        return true
      elseif w==-1 and self.ScrollStartItemIndex>1 then
        self.ScrollStartItemIndex=self.ScrollStartItemIndex-1
        return true
      end
      return self.ItemClickHelper:ProcessClick(self.Width,(#self.Items-self.ScrollStartItemIndex+1)*11,self.X,self.Y,x,y,e,b)
    end
    function obj:KeyPress(char, code, mod, evt)
    end
    setmetatable(obj, self)
    self.__index = self;
    return obj
  end

  function interface_s.Components.Rectangle:new(x, y, w,h, theme)
    local obj= {}
    obj.Type = "Rectangle"
    obj.X = x
    obj.Y = y
    obj.Width = w
    obj.Height = h
    obj.Focused=false
    obj.Theme = theme
    obj.IsShowing = true
    obj.Text = t
    obj.Base = nil
    obj.Anchor = {Top = false,Bottom=false,Left=false,Right=false}
    function obj:Draw(IsFocused, baseX, baseY,x,y)
      self.Focused = IsFocused
      if IsFocused==true then
        gfx.fillRect(self.X+baseX,self.Y+baseY,self.Width,self.Height,gfx.getColors(self.Theme.BackColor))
        gfx.drawRect(self.X+baseX,self.Y+baseY,self.Width,self.Height,gfx.getColors(self.Theme.BorderColor))
      else
        gfx.fillRect(self.X+baseX,self.Y+baseY,self.Width,self.Height,gfx.getColors(self.Theme.UnfocusedBackColor))
        gfx.drawRect(self.X+baseX,self.Y+baseY,self.Width,self.Height,gfx.getColors(self.Theme.UnfocusedBorderColor))
      end
    end 
    function obj:Show()
      self.IsShowing = true
    end
    function obj:Hide()
      self.IsShowing = false
    end
    function obj:Click(x,y,e,b)
    end
    setmetatable(obj, self)
    self.__index = self;
    return obj
  end

  function interface_s.ComponentsHelpers.Click:new(x, y)
    local obj= {}
    obj.IsFirstClick = false
    obj.IsHold = false
    obj.OnPress = nil
    obj.OnHold = nil
    obj.OnFirstClick = nil
    obj.OnMissClick = nil
    function obj:ProcessClick(width,height,x,y,clickX,clickY,e,b)
      if (clickX>x) and (clickX<x+width) and (clickY>y) and (clickY<y+height) and (self.IsFirstClick==false) and (e==1) and (b==1) then
        self.IsFirstClick=true
        if self.OnFirstClick ~= nil then
          return self.OnFirstClick(clickX,clickY)
        else
          return true
        end
      else
        if (clickX>x) and (clickX<x+width) and (clickY>y) and (clickY<y+height) and (self.IsFirstClick==true) and (e==3) and (b==1) then
          self.IsHold = true
          if self.OnHold~= nil then
            return self.OnHold(clickX,clickY)
          else
            return true
          end
        else
          if (clickX>x) and (clickX<x+width) and (clickY>y) and (clickY<y+height) and (self.IsFirstClick==true) and (self.IsHold==true) and (e==2) and (b==1) then
            self.IsHold = false
            self.IsFirstClick = false   
            if self.OnPress~= nil then
              return self.OnPress(clickX,clickY)
            else
              return true
            end
          else
            self.IsHold = false
            self.IsFirstClick = false
            if self.OnMissClick~= nil then
              return self.OnMissClick(clickX,clickY)
            end
          end
        end
      end 
    end
    setmetatable(obj, self)
    self.__index = self;
    return obj
  end
  function interface_s.ComponentsHelpers.Hint:new()
    local obj= {}
    obj.HintFrames = 0
    obj.Window = interface_s.Components.Window:new(0, 0, 0, 12,false, DefaultTheme.Window)
    obj.Label = interface_s.Components.Label:new(5,2,"",DefaultTheme.Label)
    obj.Window:AddComponent(obj.Label)
    obj.Window.AllowResize = false
    obj.Window.AlwaysFocused = true
    function obj:MouseOver(x,y,text)
      if text~="" then
        self.HintFrames = self.HintFrames + 1
        if self.HintFrames>40 then
          local w,h = gfx.textSize(text)
          self.Window.X = x
          self.Window.Y = y+12
          self.Window.Width = w+10
          self.Label.Text = text
          self.Window:Draw(true,x,y)
        end
      end
    end
    function obj:Reset()
      self.HintFrames = 0
    end
    setmetatable(obj, self)
    self.__index = self;
    return obj
  end
end
local function DefineAPI()
  interface_s.Components.Window = {}
  interface_s.Components.Button = {}
  interface_s.Components.Selection = {}
  interface_s.Components.SelectionMover = {}
  interface_s.Components.Combobox = {}
  interface_s.Components.Graph = {}
  interface_s.Components.Label = {}
  interface_s.Components.Textbox = {}
  interface_s.Components.Checkbox = {}
  interface_s.Components.Listbox = {}
  interface_s.Components.Rectangle = {}
  interface_s.ComponentsHelpers.Click = {}
  interface_s.ComponentsHelpers.Hint = {}
  
  interface_s.AddOnClickAction = function(func)
    for i=#interface_s.OnClick+1,1,-1 do
      interface_s.OnClick[i]=interface_s.OnClick[i-1]
    end
    if type(func) == "function" then
      interface_s.OnClick[0]={}
      interface_s.OnClick[0].Click = func
    else
      interface_s.OnClick[0] = func
    end
  end

  interface_s.RemoveOnClickAction = function(func)
    local index = interface_s.GetOnClickActionIndex(func)
    if index~=-1 then
      for i=index, #interface_s.OnClick-1 do
        interface_s.OnClick[i]=interface_s.OnClick[i+1]
      end
      interface_s.OnClick[#interface_s.OnClick] = nil
    end
  end

  interface_s.GetOnClickActionIndex=function(obj)
    if type(obj) == "function" then
      for i=0, #interface_s.OnClick do
        if interface_s.OnClick[i].Click == obj then
          return i
        end
      end
    else
      for i=0, #interface_s.OnClick do
        if interface_s.OnClick[i] == obj then
          return i
        end
      end
    end
    return -1
  end

  interface_s.AddOnStepAction = function(func)
    for i=#interface_s.OnStep+1,1,-1 do
      interface_s.OnStep[i]=interface_s.OnStep[i-1]
    end
    interface_s.OnStep[0] = func
  end

  interface_s.RemoveOnStepAction = function(func)
    local index = interface_s.GetOnStepActionIndex(func)
    if index~=-1 then
      for i=index, #interface_s.OnStep-1 do
        interface_s.OnStep[i]=interface_s.OnStep[i+1]
      end
      interface_s.OnStep[#interface_s.OnStep] = nil
    end
  end

  interface_s.GetOnStepActionIndex=function(obj)
    for i=0, #interface_s.OnStep do
      if interface_s.OnStep[i] == obj then
        return i
      end
    end
    return -1
  end

  interface_s.AddKeyPressAction = function(func)
    for i=#interface_s.OnKeyPress+1,1,-1 do
      interface_s.OnKeyPress[i]=interface_s.OnKeyPress[i-1]
    end
    if type(func) == "function" then
      interface_s.OnKeyPress[0]={}
      interface_s.OnKeyPress[0].KeyPress = func
    else
      interface_s.OnKeyPress[0] = func
    end
  end

  interface_s.RemoveKeyPressAction = function(func)
    local index = interface_s.GetOnKeyPressActionIndex(func)
    if index~=-1 then
      for i=index, #interface_s.OnKeyPress-1 do
        interface_s.OnKeyPress[i]=interface_s.OnKeyPress[i+1]
      end
      interface_s.OnKeyPress[#interface_s.OnKeyPress] = nil
    end
  end

  interface_s.GetOnKeyPressActionIndex=function(obj)
    if type(obj) == "function" then
      for i=0, #interface_s.OnKeyPress do
        if interface_s.OnKeyPress[i].KeyPress == obj then
          return i
        end
      end
    else
      for i=0, #interface_s.OnKeyPress do
        if interface_s.OnKeyPress[i] == obj then
          return i
        end
      end
    end
    return -1
  end
  interface_s.AddLeftWindow=function(obj) 
    for i=#interface_s.windows+1,1,-1 do
      interface_s.windows[i]=interface_s.windows[i-1]
    end
    interface_s.windows[0]=obj
  end
  
  interface_s.addComponent=function(obj) 
    interface_s.AddLeftWindow(obj) 
  end
  
  interface_s.GetComponentIndex=function(obj)
    for i=0, #interface_s.windows do
      if interface_s.windows[i] == obj then
        return i
      end
    end
    return -1
  end
  
  interface_s.RemoveComponent=function(obj) 
    local index = interface_s.GetComponentIndex(obj)
    if index~=-1 then
      for i=index, #interface_s.windows-1 do
        interface_s.windows[i]=interface_s.windows[i+1]
      end
      interface_s.windows[#interface_s.windows] = nil
    end
  end
  
  interface_s.focusComponent = function(index)
    local temp= interface_s.windows[index] 
    for i=index, 1,-1 do
      interface_s.windows[i] = interface_s.windows[i-1] 
    end
    interface_s.windows[0] = temp
  end

  interface_s.step = function()
    if interface_s.OnStep[0] ~= nil then
      for i=0,#interface_s.OnStep do
        if interface_s.OnStep[i] then
          interface_s.OnStep[i](tpt.mousex,tpt.mousey)
        end
      end
    end
    for i=#interface_s.windows, 0,-1 do
      if (interface_s.windows[i] ~= nil) and (interface_s.windows[i].IsShowing==true) then
        if i==0 then
          interface_s.windows[i]:Draw(true,tpt.mousex,tpt.mousey)
        else
          interface_s.windows[i]:Draw(false,tpt.mousex,tpt.mousey) 
        end
      end
    end
  end

  interface_s.click = function(mousex, mousey, button, event,wheel)
    if interface_s.OnClick[0] ~= nil then
      local f = false
      for i=0,#interface_s.OnClick do
        if interface_s.OnClick[i].Base~=nil then
          if interface_s.OnClick[i]:Click(mousex-interface_s.OnClick[i].Base.X , mousey-interface_s.OnClick[i].Base.Y , event, button,wheel) then
            f=true
          end
        else
          if interface_s.OnClick[i].Click(mousex, mousey, event, button,wheel) then
            f=true
          end
        end
      end
      if f==true then
        return false
      end
    end
    for i=0,#interface_s.windows do
      if interface_s.windows[i] == nil then
        interface_s.RemoveComponent(interface_s.windows[i])
        break
      end
      if (interface_s.windows ~= nil) then
        if interface_s.windows[i]:Click(mousex , mousey , event, button,wheel) then
          if (interface_s.windows[i]~=nil) and (interface_s.windows[i].IsShowing~=nil) and (interface_s.windows[i].IsShowing==true) then
            interface_s.focusComponent(i) 
            return false
          end
        end 
      end
    end
  end

  interface_s.key = function(char, code, mod, evt)
    local f = false
    if interface_s.windows[0] ~= nil then
      if interface_s.windows[0]:KeyPress(char, code, mod, evt) then
        f = true
      end
    end
    if interface_s.OnKeyPress[0] ~= nil then
      for i=0,#interface_s.OnKeyPress do
        if interface_s.OnKeyPress[i].Base~=nil then
          if interface_s.OnKeyPress[i]:KeyPress(char, code, mod, evt) then
            f=true
          end
        end
      end
    end
    if interface_s.BlockKeyboard == true or f==true then
      return false
    end
  end
  tpt.register_step(interface_s.step)
  tpt.register_mouseclick(interface_s.click)
  tpt.register_keypress(interface_s.key)
end

local function InitIntefaceAPI()
  if interface_s == nil then
    interface_s = {
      Version = InterfaceAPIVersion,
      Components = {},
      ComponentsHelpers = {},
      windows = {},
      step = nil,
      click = nil,
      key = nil,
      addLeft = nil,
      addComponent = nil,
      GetComponentIndex = nil,
      RemoveComponent = nil,
      focusComponent = nil,
      BlockKeyboard = false,
      OnClick = {},
      OnKeyPress = {},
      OnStep = {}
    }
    DefineAPI()
    DefineInterfaceComponents()
  else
    if interface_s.Version<InterfaceAPIVersion then
      tpt.unregister_step(interface_s.step)
      tpt.unregister_mouseclick(interface_s.click)
      tpt.unregister_keypress(interface_s.key)
      interface_s = {
        Version = InterfaceAPIVersion,
        Components = {},
        ComponentsHelpers = {},
        windows = interface_s.windows,
        step = nil,
        click = nil,
        key = nil,
        addLeft = nil,
        addComponent = nil,
        GetComponentIndex = nil,
        RemoveComponent = nil,
        focusComponent = nil,
        BlockKeyboard = interface_s.BlockKeyboard,
        OnClick = interface_s.OnClick or {},
        OnKeyPress = interface_s.OnKeyPress or {},
        OnStep = interface_s.OnStep or {}
      }
      DefineAPI()
      DefineInterfaceComponents()
    end
  end
end

InitIntefaceAPI()

--=================================================================--
--                       THEME START                               --
--=================================================================--
DefaultTheme.Window.BackColor = gfx.getHexColor(0,0,0,255)
DefaultTheme.Window.UnfocusedBackColor = gfx.getHexColor(0,0,0,255)
DefaultTheme.Window.BorderColor = gfx.getHexColor(255,255,255,255)
DefaultTheme.Window.UnfocusedBorderColor = gfx.getHexColor(150,150,150,255)
DefaultTheme.Window.HeaderColor = gfx.getHexColor(150,150,255,255)
DefaultTheme.Window.UnfocusedHeaderColor = gfx.getHexColor(32,32,55,255)

DefaultTheme.Button.BackColor = gfx.getHexColor(0,0,0,0)
DefaultTheme.Button.UnfocusedBackColor = gfx.getHexColor(0,0,0,0)
DefaultTheme.Button.PressedBackColor = gfx.getHexColor(240,240,240,255)
DefaultTheme.Button.BorderColor = gfx.getHexColor(255,255,255,255)
DefaultTheme.Button.UnfocusedBorderColor = gfx.getHexColor(150,150,150,255)
DefaultTheme.Button.MouseOverColor = gfx.getHexColor(255,255,255,128)
DefaultTheme.Button.UnfocusedMouseOverColor = gfx.getHexColor(150,150,150,128)
DefaultTheme.Button.TextColor = gfx.getHexColor(255,255,255,255)
DefaultTheme.Button.UnfocusedTextColor = gfx.getHexColor(150,150,150,255)
DefaultTheme.Button.PressedTextColor = gfx.getHexColor(0,0,0,255)

DefaultTheme.Selection.BackColor = gfx.getHexColor(140,140,200,100)
DefaultTheme.Selection.BorderColor = gfx.getHexColor(140,140,200,255)

DefaultTheme.Combobox.BackColor = gfx.getHexColor(0,0,0,255)
DefaultTheme.Combobox.UnfocusedBackColor = gfx.getHexColor(0,0,0,255)
DefaultTheme.Combobox.BorderColor = gfx.getHexColor(255,255,255,255)
DefaultTheme.Combobox.UnfocusedBorderColor = gfx.getHexColor(150,150,150,255)
DefaultTheme.Combobox.TextColor = gfx.getHexColor(255,255,255,255)
DefaultTheme.Combobox.UnfocusedTextColor = gfx.getHexColor(150,150,150,255)
DefaultTheme.Combobox.ButtonBackColor = gfx.getHexColor(0,0,0,255)
DefaultTheme.Combobox.ButtonPressedBackColor = gfx.getHexColor(255,255,255,255)
DefaultTheme.Combobox.ButtonMouseOverBackColor = gfx.getHexColor(150,150,150,128)
DefaultTheme.Combobox.UnfocusedButtonBackColor = gfx.getHexColor(0,0,0,255)
DefaultTheme.Combobox.UnfocusedButtonMouseOverBackColor = gfx.getHexColor(150,150,150,128)

DefaultTheme.Graph.BackColor = gfx.getHexColor(0,0,0,255)
DefaultTheme.Graph.BorderColor = gfx.getHexColor(255,255,255,255)
DefaultTheme.Graph.UnfocusedBackColor = gfx.getHexColor(0,0,0,255)
DefaultTheme.Graph.UnfocusedBorderColor = gfx.getHexColor(150,150,150,255)
DefaultTheme.Graph.TextColor = gfx.getHexColor(255,255,255,255)
DefaultTheme.Graph.UnfocusedTextColor = gfx.getHexColor(150,150,150,255)
DefaultTheme.Graph.GraphColor = gfx.getHexColor(255,100,100,255)
DefaultTheme.Graph.UnfocusedGraphColor = gfx.getHexColor(100,30,30,255)
DefaultTheme.Graph.ZeroLine = gfx.getHexColor(255,200,200,255)
DefaultTheme.Graph.UnfocusedZeroLine = gfx.getHexColor(100,80,80,255)

DefaultTheme.Label.TextColor = gfx.getHexColor(255,255,255,255)
DefaultTheme.Label.UnfocusedTextColor = gfx.getHexColor(150,150,150,255)

DefaultTheme.Textbox.BackColor = gfx.getHexColor(0,0,0,255)
DefaultTheme.Textbox.BorderColor = gfx.getHexColor(255,200,200,255)
DefaultTheme.Textbox.TextColor = gfx.getHexColor(255,255,255,255)
DefaultTheme.Textbox.UnfocusedTextColor = gfx.getHexColor(150,150,150,255)
DefaultTheme.Textbox.PointerColor = gfx.getHexColor(255,255,255,255)
DefaultTheme.Textbox.UnfocusedBorderColor = gfx.getHexColor(200,200,200,255)

DefaultTheme.Checkbox.BorderColor = gfx.getHexColor(255,255,255,255)
DefaultTheme.Checkbox.UnfocusedBorderColor = gfx.getHexColor(150,150,150,255)
DefaultTheme.Checkbox.CheckColor = gfx.getHexColor(255,255,255,255)
DefaultTheme.Checkbox.UnfocusedCheckColor = gfx.getHexColor(150,150,150,255)
DefaultTheme.Checkbox.TextColor = gfx.getHexColor(255,255,255,255)
DefaultTheme.Checkbox.UnfocusedTextColor = gfx.getHexColor(150,150,150,255)

DefaultTheme.Rectangle.BackColor = gfx.getHexColor(0,0,0,255)
DefaultTheme.Rectangle.BorderColor = gfx.getHexColor(255,255,255,255)
DefaultTheme.Rectangle.UnfocusedBackColor = gfx.getHexColor(0,0,0,255)
DefaultTheme.Rectangle.UnfocusedBorderColor = gfx.getHexColor(150,150,150,255)

DefaultTheme.Listbox.BackColor = gfx.getHexColor(0,0,0,255)
DefaultTheme.Listbox.BorderColor = gfx.getHexColor(255,255,255,255)
DefaultTheme.Listbox.SelectionColor = gfx.getHexColor(255,255,255,255)
DefaultTheme.Listbox.SelectionTextColor = gfx.getHexColor(0,0,0,255)
DefaultTheme.Listbox.TextColor = gfx.getHexColor(255,255,255,255)
DefaultTheme.Listbox.MouseOverColor = gfx.getHexColor(255,255,255,50)
DefaultTheme.Listbox.UnfocusedBackColor = gfx.getHexColor(0,0,0,255)
DefaultTheme.Listbox.UnfocusedBorderColor = gfx.getHexColor(150,150,150,255)
DefaultTheme.Listbox.UnfocusedSelectionColor = gfx.getHexColor(150,150,150,255)
DefaultTheme.Listbox.UnfocusedSelectionTextColor = gfx.getHexColor(0,0,0,255)
DefaultTheme.Listbox.UnfocusedTextColor = gfx.getHexColor(150,150,150,255)
DefaultTheme.Listbox.UnfocusedMouseOverColor = gfx.getHexColor(150,150,150,50)
--=================================================================--
--                         THEME END                               --
--=================================================================--
--=================================================================--
--                    CODE IS BELOW THIS LINE                      --
--=================================================================--

function Timer(func)
  local endtime = nil
  local IsStarted = false
  local time = {0,0,0,0}

  local MainWindow = interface_s.Components.Window:new(40, 40, 86, 25,true, DefaultTheme.Window)
  MainWindow.AllowResize = false
  MainWindow.AlwaysFocused = true

  local TimeLabel = interface_s.Components.Label:new(5,12,"00:00",DefaultTheme.Label)
  TimeLabel:AddHint("Use scroll to change time")

  local TimeToLabel=function()
    TimeLabel.Text = time[1]..time[2]..":"..time[3]..time[4]
  end

  TimeToLabel()

  local ChangeValue = function(var, w, i)
    var[i] = var[i] + w
    if i==1 or i==3 then
      if var[i]<0 then
        var[i] = 0
      else
        if var[i]>5 then
          var[i] = 5
        end
      end
    else
      if var[i]<0 then
        var[i] = 0
      else
        if var[i]>9 then
          var[i] = 9
        end
      end
    end
  end
  TimeLabel.OnMouseEvent = function(x,y,e,b,w)
    if y>=11 and y<=20 then
      if x>=4 and x<=10 then
        ChangeValue(time,w,1)
        TimeToLabel()
      else
        if x>=11 and x<=14 then
          ChangeValue(time,w,2)
          TimeToLabel()
        else
          if x>=20 and x<=25 then
            ChangeValue(time,w,3)
            TimeToLabel()
          else
            if x>=26 and x<= 31 then
              ChangeValue(time,w,4)
              TimeToLabel()
            end
          end
        end
      end
    end
  end


  local onstep = nil

  onstep = function()
    if endtime-os.time() < 0 or endtime-os.time() == 0 then
      IsStarted = false
      interface_s.RemoveOnStepAction(onstep)
      if func == nil then
        tpt.set_pause(1)
      else
        func()
      end
    end
    TimeLabel.Text = os.date("%M:%S",endtime-os.time())
  end

  local StartButton = interface_s.Components.Button:new(35, 10, 12, 12, "S", DefaultTheme.Button)
  StartButton:AddHint("Start/Resume timer")
  StartButton.OnPressed = function() 
    if IsStarted == false then
      IsStarted = true
      endtime = os.time()+time[4]+time[3]*10+time[2]*60+time[1]*600
      interface_s.AddOnStepAction(onstep)
    end
  end

  local PauseButton = interface_s.Components.Button:new(52, 10, 12, 12, "P", DefaultTheme.Button)
  PauseButton:AddHint("Pause timer")
  PauseButton.OnPressed = function() 
    if IsStarted == true then
      IsStarted = false
      interface_s.RemoveOnStepAction(onstep)
      local currenttime = os.time()
      local s = os.date("%S",endtime-currenttime)
      local m = os.date("%M",endtime-currenttime)
      if string.len(s) == 2 then
        time[4]=string.sub(s,2,2)
        time[3]=string.sub(s,1,1)
      else
        time[4]=string.sub(s,2,2)
        time[3]=0
      end
      if string.len(m) == 2 then
        time[2]=string.sub(m,2,2)
        time[1]=string.sub(m,1,1)
      else
        time[2]=string.sub(m,2,2)
        time[1]=0
      end
      TimeToLabel()
    end
  end

  local ResetButton = interface_s.Components.Button:new(69, 10, 12, 12, "R", DefaultTheme.Button)
  ResetButton:AddHint("Reset timer")
  ResetButton.OnPressed = function()
    if IsStarted == true then
      IsStarted = false
      interface_s.RemoveOnStepAction(onstep)
    end
    time = {0,0,0,0}
    TimeToLabel()
  end

  local Exit = interface_s.Components.Button:new(78, 0, 8, 8,"x", DefaultTheme.Button)
  Exit.OnPressed = (function()
    if IsStarted == true then
      IsStarted = false
      interface_s.RemoveOnStepAction(onstep)
    end
    interface_s.RemoveComponent(MainWindow)
  end)

  MainWindow:AddComponent(TimeLabel)
  MainWindow:AddComponent(StartButton)
  MainWindow:AddComponent(PauseButton)
  MainWindow:AddComponent(ResetButton)
  MainWindow:AddComponent(Exit)

  interface_s.addComponent(MainWindow)
end
--=================================================================--
--                    CODE IS ABOVE THIS LINE                      --
--=================================================================--