local versionMajor = "2"
local versionMinor = "5"


local component = require("component")
local gpu = component.gpu
local event = require("event")
local computer = require("computer")

local screenWidth, screenHeight = gpu.getResolution()

local gui = {}

local colorScreenBackground = 0xC0C0C0
local colorScreenForeground = 0x000000
local colorTopLineBackground = 0x0000FF
local colorTopLineForeground = 0xFFFFFF
local colorBottomLineBackground = 0x0000FF
local colorBottomLineForeground = 0xFFFFFF
local colorFrameBackground = 0xC0C0C0
local colorFrameForeground = 0x000000
local colorButtonBackground = 0x0000FF
local colorButtonForeground = 0xFFFFFF
local colorButtonClickedBackground = 0x00FF00
local colorButtonClickedForeground = 0xFFFFFF
local colorButtonDisabledBackground = 0x000000
local colorButtonDisabledForeground = 0xFFFFFF
local colorTextBackground = 0x000000
local colorTextForeground = 0xFFFF00
local colorInputBackground = 0x0000FF
local colorInputForeground = 0xFFFFFF
local colorProgressBackground = 0x000000
local colorProgressForeground = 0x00FF00
local colorProgressNumberForeground = 0xFFFF00
local colorListBackground = 0x0000FF
local colorListForeground = 0xFFFFFF
local colorListActiveBackground = 0x00FF00
local colorListActiveForeground = 0xFFFF00
local colorListDisabledBackground = 0x000000
local colorListDisabledForeground = 0xFFFF00
local colorVProgressBackground = 0x000000
local colorVProgressForeground = 0x00FF00
local colorVSliderBackground = 0x000000
local colorVSliderForeground = 0x00FF00
local colorChartBackground = 0x000000
local colorChartForeground = 0x00FF00

local displayed = false


function gui.Version()
  return versionMajor .. "." .. versionMinor, versionMajor, versionMinor
end

function gui.checkVersion(major, minor)
  if major > tonumber(versionMajor) then
    compGui = gui.newGui("center", "center", 40, 9, true, nil, 0xFF0000, 0xFFFF00)
    gui.displayGui(compGui)
    gui.newLabel(compGui, "center", 1, "!Wrong Gui version!")
    gui.newLabel(compGui, "center", 3, string.format("Need version %d.%d",major, minor))
    gui.newLabel(compGui, "center", 5, string.format("Installed version is v %d.%d",versionMajor, versionMinor))
    gui.newHLine(compGui, 1, 6, 38)
    gui.newButton(compGui, "center", 7, "exit", gui.exit)
    while true do
      gui.runGui(compGui)
    end
  else
    if minor > tonumber(versionMinor) then
      compGui = gui.newGui("center", "center", 40, 9, true, nil, 0xFF0000, 0xFFFF00)
      gui.displayGui(compGui)
      gui.newLabel(compGui, "center", 1, "!Wrong Gui version!")
      gui.newLabel(compGui, "center", 3, string.format("Need version %d.%d",major, minor))
      gui.newLabel(compGui, "center", 5, string.format("Installed version is v %d.%d",versionMajor, versionMinor))
      gui.newHLine(compGui, 1, 6, 38)
      gui.newButton(compGui, "center", 7, "exit", gui.exit)
      while true do
	gui.runGui(compGui)
      end
    end
  end
end

function gui.clearScreen()
  gpu.setBackground(colorScreenBackground)
  gpu.setForeground(colorScreenForeground)
  gpu.fill(1, 1, screenWidth, screenHeight, " ")

  gpu.setBackground(colorTopLineBackground)
  gpu.setForeground(colorTopLineForeground)
  gpu.fill(1, 1, screenWidth, 1, " ")

  gpu.setBackground(colorBottomLineBackground)
  gpu.setForeground(colorBottomLineForeground)
  gpu.fill(1, screenHeight, screenWidth, 1, " ")
end

function gui.setTop(text)
  gpu.setBackground(colorTopLineBackground)
  gpu.setForeground(colorTopLineForeground)
  gpu.set( (screenWidth / 2) - (string.len(text) / 2), 1, text)
end

function gui.setBottom(text)
  gpu.setBackground(colorBottomLineBackground)
  gpu.setForeground(colorBottomLineForeground)
  gpu.set( (screenWidth / 2) - (string.len(text) / 2), screenHeight, text)
end

local function saveBackground(x,y,w,h)
  local buffer = {}
  for i = x,x + w do
    for j = y,y + h do
      local ch,fc,bc = gpu.get(i,j)
      local tmp = {i,j,ch,fc,bc}
      table.insert(buffer, tmp)
    end
  end
  return buffer
end


local function restoreBackground(buff)
  for k,v in pairs(buff) do
    gpu.setBackground(v[5])
    gpu.setForeground(v[4])
    gpu.set(v[1], v[2], v[3])
  end
end

function gui.closeGui(guiID)
--  print("restoring" .. guiID.num)
--  os.sleep(1)
  restoreBackground(guiID.buffer)
  guiID.new = true
end


-- displays the gui frame, if set or just clears the display area
local function _displayFrame(guiID)
  if guiID.new == true then
--    print("saving" .. guiID.num)
    guiID.buffer = saveBackground(guiID.x, guiID.y, guiID.width, guiID.height)
    guiID.new = false
--    os.sleep(1)
  end
  gpu.setBackground(guiID.bg)
  gpu.setForeground(guiID.fg)
  gpu.fill(guiID.x, guiID.y, guiID.width, guiID.height, " ")
  if guiID.frame == true then
    gpu.fill(guiID.x, guiID.y, 1, guiID.height, "║")
    gpu.fill(guiID.x + guiID.width - 1, guiID.y, 1, guiID.height, "║")
    gpu.fill(guiID.x, guiID.y, guiID.width, 1, "═")
    gpu.fill(guiID.x, guiID.y + guiID.height - 1, guiID.width, 1, "═")
    gpu.set(guiID.x, guiID.y, "╔")
    gpu.set(guiID.x + guiID.width - 1 , guiID.y, "╗")
    gpu.set(guiID.x, guiID.y + guiID.height - 1 , "╚")
    gpu.set(guiID.x + guiID.width - 1 , guiID.y + guiID.height - 1, "╝")
    if guiID.text then
      gpu.set(guiID.x + math.floor((guiID.width/2)) - math.floor((string.len(guiID.text)/2)), guiID.y, guiID.text)
    end
  end
end

-- displays a frame
local function _displayAFrame(guiID, frameID)
  if guiID[frameID].visible == true then
    gpu.setBackground(guiID.bg)
    gpu.setForeground(guiID.fg)
    gpu.fill(guiID[frameID].x, guiID[frameID].y, 1, guiID[frameID].height, "║")
    gpu.fill(guiID[frameID].x + guiID[frameID].width - 1, guiID[frameID].y, 1, guiID[frameID].height, "║")
    gpu.fill(guiID[frameID].x, guiID[frameID].y, guiID[frameID].width, 1, "═")
    gpu.fill(guiID[frameID].x, guiID[frameID].y + guiID[frameID].height - 1, guiID[frameID].width, 1, "═")
    gpu.set(guiID[frameID].x, guiID[frameID].y, "╔")
    gpu.set(guiID[frameID].x + guiID[frameID].width - 1 , guiID[frameID].y, "╗")
    gpu.set(guiID[frameID].x, guiID[frameID].y + guiID[frameID].height - 1 , "╚")
    gpu.set(guiID[frameID].x + guiID[frameID].width - 1 , guiID[frameID].y + guiID[frameID].height - 1, "╝")
    if guiID[frameID].text then
      gpu.set(guiID[frameID].x + math.floor((guiID[frameID].width/2)) - math.floor((string.len(guiID[frameID].text)/2)+1), guiID[frameID].y, "╡" .. guiID[frameID].text .. "┝")
    end
  end
end

--display a horizontal line
local function _displayHLine(guiID, lineID)
  gpu.setBackground(guiID.bg)
  gpu.setForeground(guiID.fg)
  gpu.fill(guiID[lineID].x, guiID[lineID].y, guiID[lineID].width, 1, "═")
end

-- displays a checkbox
local function _displayCheckbox(guiID, checkboxID)
  if guiID[checkboxID].visible == true then
    gpu.setBackground(guiID.bg)
    gpu.setForeground(guiID.fg)
    local x = 0
    x =guiID.x + guiID[checkboxID].x
    if guiID[checkboxID].status == true then
      gpu.set(x, guiID[checkboxID].y, "[√]")
    else
      gpu.set(x, guiID[checkboxID].y, "[ ]")
    end
  end
end

-- displays a radio button
local function _displayRadio(guiID, radioID)
  if guiID[radioID].visible == true then
    gpu.setBackground(guiID.bg)
    gpu.setForeground(guiID.fg)
    local x = 0
    x =guiID.x + guiID[radioID].x
    if guiID[radioID].status == true then
      gpu.set(x, guiID[radioID].y, "(x)")
    else
      gpu.set(x, guiID[radioID].y, "( )")
    end
  end
end

-- displays a label
local function _displayLabel(guiID, labelID)
  if guiID[labelID].visible == true then
    gpu.setBackground(guiID[labelID].bg)
    gpu.setForeground(guiID[labelID].fg)
    local x = 0
    if guiID[labelID].x == "center" then
      x = guiID.x + math.floor((guiID.width / 2)) - math.floor((string.len(guiID[labelID].text)) / 2)
    else
      x =guiID.x + guiID[labelID].x
    end
    gpu.fill(x, guiID[labelID].y, guiID[labelID].l , 1, " ")
    gpu.set(x, guiID[labelID].y, guiID[labelID].text)
  end
end

-- displays a time label
local function _displayTimeLabel(guiID, labelID)
  if guiID[labelID].visible == true then
    gpu.setBackground(guiID[labelID].bg)
    gpu.setForeground(guiID[labelID].fg)
    local x = guiID.x + guiID[labelID].x
    gpu.set(x, guiID[labelID].y, os.date("%H:%M", os.time()))
  end
end

-- displays a date label
local function _displayDateLabel(guiID, labelID)
  if guiID[labelID].visible == true then
    gpu.setBackground(guiID[labelID].bg)
    gpu.setForeground(guiID[labelID].fg)
    local x = guiID.x + guiID[labelID].x
    if guiID[labelID].frm == false then
      gpu.set(x, guiID[labelID].y, os.date("%d/%m/%Y"))
    elseif guiID[labelID].frm == true then
      gpu.set(x, guiID[labelID].y, os.date("%A %d. %B %Y"))
    end
  end
end

local function splitWords(Lines, limit)
    while #Lines[#Lines] > limit do
        Lines[#Lines+1] = Lines[#Lines]:sub(limit+1)
        Lines[#Lines-1] = Lines[#Lines-1]:sub(1,limit)
    end
end

local function wrap(str, limit)
    local Lines, here, limit, found = {}, 1, limit or 72, str:find("(%s+)()(%S+)()")

    if found then
        Lines[1] = string.sub(str,1,found-1)  -- Put the first word of the string in the first index of the table.
    else Lines[1] = str end

    str:gsub("(%s+)()(%S+)()",
        function(sp, st, word, fi)  -- Function gets called once for every space found.
            splitWords(Lines, limit)

            if fi-here > limit then
                here = st
                Lines[#Lines+1] = word                                             -- If at the end of a line, start a new table index...
            else Lines[#Lines] = Lines[#Lines].." "..word end  -- ... otherwise add to the current table index.
        end)

    splitWords(Lines, limit)

    return Lines
end

-- displays a multi line label
local function _displayMultiLineLabel(guiID, labelID)
  if guiID[labelID].visible == true then
    gpu.setBackground(guiID[labelID].bg)
    gpu.setForeground(guiID[labelID].fg)
    gpu.fill(guiID[labelID].x, guiID[labelID].y, guiID[labelID].w, guiID[labelID].h, " ")
    local text = wrap(guiID[labelID].text, guiID[labelID].w)
    for i = 1, #text do
      gpu.set(guiID[labelID].x, guiID[labelID].y + i, text[i])
    end
  end
end

-- displays a button
local function _displayButton(guiID, buttonID)
  if guiID[buttonID].visible == true then
    if guiID[buttonID].active == true then
      gpu.setBackground(colorButtonClickedBackground)
      gpu.setForeground(colorButtonClickedForeground)
    elseif guiID[buttonID].enabled == false then
      gpu.setBackground(colorButtonDisabledBackground)
      gpu.setForeground(colorButtonDisabledForeground)
    else
      gpu.setBackground(colorButtonBackground)
      gpu.setForeground(colorButtonForeground)
    end
    local x = 0
    if guiID[buttonID].x == "center" then
      x = guiID.x + math.floor((guiID.width / 2)) - math.floor((guiID[buttonID].lenght / 2))
    else
      x = guiID.x + guiID[buttonID].x
    end
    gpu.fill(x, guiID[buttonID].y, guiID[buttonID].lenght, 1, " ")
    gpu.set(x, guiID[buttonID].y, guiID[buttonID].text)
  end
end

-- displays a text
local function _displayText(guiID, textID)
  if guiID[textID].visible == true then
    gpu.setBackground(colorTextBackground)
    gpu.setForeground(colorTextForeground)
    local x = 0
    if guiID[textID].x == "center" then
      x = guiID.x + math.floor((guiID.width / 2)) - math.floor((guiID[textID].fieldLenght) / 2)
    else
      x = guiID.x + guiID[textID].x
    end
    gpu.fill(x, guiID[textID].y , guiID[textID].fieldLenght, 1, " ")
    tmpStr = guiID[textID].text
    if guiID[textID].hide == true then
      tmpStr = ""
      for i = 1, string.len(guiID[textID].text) do
	tmpStr = tmpStr .."*"
      end
    end
    gpu.set(x, guiID[textID].y, string.sub(tmpStr, 1, guiID[textID].fieldLenght))
  end
end

-- displays a vertical slider
local function _displayVslider(guiID, sliderID)
  if guiID[sliderID].visible == true then
    gpu.setBackground(colorVSliderBackground)
    gpu.setForeground(colorVSliderForeground)
    local x = 0
    x = guiID.x + guiID[sliderID].x
    gpu.fill(x, guiID[sliderID].y , guiID[sliderID].lenght + 2, 1, " ")
    gpu.setBackground(colorButtonBackground)
    gpu.setForeground(colorButtonForeground)
    gpu.set(x, guiID[sliderID].y, "-")
    gpu.set(x + guiID[sliderID].lenght + 1, guiID[sliderID].y, "+")
    x = x + 1
    local proz = math.floor(100 / guiID[sliderID].max * guiID[sliderID].value)
    if proz > 100 then
      proz = 100
      if guiID[sliderID].func then
	guiID[sliderID].func(guiID, sliderID)
      end
    end
    local pos = math.floor(guiID[sliderID].lenght / 100 * proz)
    gpu.setBackground(colorVSliderForeground)
    gpu.setForeground(colorVSliderBackground)
    gpu.fill(x, guiID[sliderID].y , pos, 1, " ")
    gpu.setBackground(colorVSliderBackground)
    gpu.setForeground(colorVSliderForeground)
    gpu.fill(x + pos, guiID[sliderID].y , guiID[sliderID].lenght - pos, 1, " ")
  end
end

-- displays a progress bar
local function _displayProgress(guiID, progressID)
  if guiID[progressID].visible == true then
    gpu.setBackground(colorProgressForeground)
    gpu.setForeground(colorProgressBackground)
    local x = 0
    if guiID[progressID].x == "center" then
      x = guiID.x + math.floor((guiID.width / 2)) - math.floor((guiID[progressID].lenght) / 2)
    else
      x = guiID.x + guiID[progressID].x
    end
    local proz = math.floor(100 / guiID[progressID].max * guiID[progressID].value)
    if proz > 100 then
      proz = 100
      if guiID[progressID].finished == false and guiID[progressID].func then
	guiID[progressID].func(guiID, progressID)
      end
      guiID[progressID].finished = true
    end
    local pos = math.floor(guiID[progressID].lenght / 100 * proz)
    gpu.fill(x, guiID[progressID].y , pos, 1, " ")
    gpu.setBackground(colorProgressBackground)
    gpu.setForeground(colorProgressForeground)
    gpu.fill(x + pos, guiID[progressID].y , guiID[progressID].lenght - pos, 1, " ")
    gpu.setBackground(guiID.bg)
    gpu.setForeground(guiID.fg)
    if guiID[progressID].displayNumber == true then
      gpu.fill(x, guiID[progressID].y - 1, guiID[progressID].lenght, 1, " ")
      gpu.set(x + (math.floor(guiID[progressID].lenght / 2)) - 1, guiID[progressID].y - 1, proz .. "%")
    end
  end
end

-- displays a vertical progress bar
local function _displayVProgress(guiID, progressID)
  if guiID[progressID].visible == true then
    local x = 0
    if guiID[progressID].x == "center" then
      x = guiID.x + math.floor((guiID.width / 2)) - math.floor((guiID[progressID].lenght) / 2)
    else
      x = guiID.x + guiID[progressID].x
    end
    local proz = math.floor(100 / guiID[progressID].max * guiID[progressID].value)
    if proz > 100 then
      proz = 100
      if guiID[progressID].finished == false and guiID[progressID].func then
	guiID[progressID].func(guiID, progressID)
      end
      guiID[progressID].finished = true
    end
    local pos = math.floor(guiID[progressID].lenght / 100 * proz)
    for i = 1, guiID[progressID].width do
      if guiID[progressID].direction == 0 then
	gpu.setBackground(colorProgressForeground)
	gpu.setForeground(colorProgressBackground)
	gpu.fill(x+i-1, guiID[progressID].y , 1, pos, " ")
	gpu.setBackground(colorProgressBackground)
	gpu.setForeground(colorProgressForeground)
	gpu.fill(x+i-1, guiID[progressID].y + pos, 1, guiID[progressID].lenght - pos, " ")
      end
      if guiID[progressID].direction == 1 then
	gpu.setBackground(colorProgressBackground)
	gpu.setForeground(colorProgressForeground)
	gpu.fill(x+i-1, guiID[progressID].y, 1, guiID[progressID].lenght, " ")
	gpu.setBackground(colorProgressForeground)
	gpu.setForeground(colorProgressBackground)
	gpu.fill(x+i-1, guiID[progressID].y + guiID[progressID].lenght - pos , 1, pos, " ")
      end
    end
  end
end

-- display list
local function _displayList(guiID, listID)
  if guiID[listID].visible == true then
    if guiID[listID].enabled == true then
      gpu.setBackground(colorListBackground)
      gpu.setForeground(colorListForeground)
    else
      gpu.setBackground(colorListDisabledBackground)
      gpu.setForeground(colorListDisabledForeground)
    end
    gpu.fill(guiID[listID].x, guiID[listID].y, guiID[listID].width, guiID[listID].height, " ")
    gpu.fill(guiID[listID].x, guiID[listID].y, guiID[listID].width, 1, "═")
    if guiID[listID].text then
      gpu.set( guiID[listID].x + (guiID[listID].width/2) - (string.len(guiID[listID].text)/2), guiID[listID].y, "╡" .. guiID[listID].text .. "┝")
    end
    if guiID[listID].active + guiID[listID].height - 3 > #guiID[listID].entries then
      l = #guiID[listID].entries
    else
      l = guiID[listID].active + guiID[listID].height - 3
    end
    gpu.fill(guiID[listID].x, guiID[listID].y +guiID[listID].height - 1, guiID[listID].width, 1, "═")
    gpu.set(guiID[listID].x, guiID[listID].y + guiID[listID].height - 1, "[<]")
    gpu.set(guiID[listID].x + guiID[listID].width - 3, guiID[listID].y + guiID[listID].height - 1, "[>]")
    for v = guiID[listID].active, l  do
      if v == guiID[listID].selected then
	gpu.setBackground(colorListActiveBackground)
	gpu.setForeground(colorListActiveForeground)
      else
	if guiID[listID].enabled == true then
	  gpu.setBackground(colorListBackground)
	  gpu.setForeground(colorListForeground)
	else
	  gpu.setBackground(colorListDisabledBackground)
	  gpu.setForeground(colorListDisabledForeground)
	end
      end
      gpu.fill(guiID[listID].x, guiID[listID].y + v - guiID[listID].active + 1, guiID[listID].width, 1 , " ")
      gpu.set(guiID[listID].x + 1, guiID[listID].y + v - guiID[listID].active + 1, guiID[listID].entries[v] )
    end
  end
end

-- displays a chart
local function _displayChart(guiID, chartID)
  if guiID[chartID].visible == true then
    gpu.setBackground(colorChartBackground)
    gpu.setForeground(colorChartForeground)
    for x = 1, #guiID[chartID].data do
	local proz = math.floor(100 / guiID[chartID].max * guiID[chartID].data[x])
	local dotPos = guiID[chartID].height - math.floor( guiID[chartID].height / guiID[chartID].max * guiID[chartID].data[x])
	for y = 1, guiID[chartID].height do
	  if dotPos == y then
	    gpu.setBackground(colorChartForeground)
	  else
	    gpu.setBackground(colorChartBackground)
	  end
	  gpu.set(x + guiID[chartID].x, y + guiID[chartID].y, " ")

	end
    end
  end
end

-- display the gui and all widgets
function gui.displayGui(guiID)

  _displayFrame(guiID)

  for i = 1, #guiID do
    if guiID[i].type == "label" then
      _displayLabel(guiID, i)
    elseif guiID[i].type == "multiLineLabel" then
      _displayMultiLineLabel(guiID, i)
    elseif guiID[i].type == "button" then
      _displayButton(guiID, i)
    elseif guiID[i].type == "text" then
      _displayText(guiID, i)
    elseif guiID[i].type == "progress" then
      _displayProgress(guiID, i)
    elseif guiID[i].type == "vprogress" then
      _displayVProgress(guiID, i)
    elseif guiID[i].type == "list" then
      _displayList(guiID, i)
    elseif guiID[i].type == "frame" then
      _displayAFrame(guiID, i)
    elseif guiID[i].type == "hline" then
      _displayHLine(guiID, i)
    elseif guiID[i].type == "checkbox" then
      _displayCheckbox(guiID, i)
    elseif guiID[i].type == "radio" then
      _displayRadio(guiID, i)
    elseif guiID[i].type == "vslider" then
      _displayVslider(guiID, i)
    elseif guiID[i].type == "chart" then
      _displayChart(guiID, i)
    end
  end
end

function gui.displayWidget(guiID, widgetID)

    if guiID[widgetID].type == "label" then
      _displayLabel(guiID, widgetID)
    elseif guiID[widgetID].type == "multiLineLabel" then
      _displayMultiLineLabel(guiID, widgetID)
    elseif guiID[widgetID].type == "button" then
      _displayButton(guiID, widgetID)
    elseif guiID[widgetID].type == "text" then
      _displayText(guiID, widgetID)
    elseif guiID[widgetID].type == "progress" then
      _displayProgress(guiID, widgetID)
    elseif guiID[widgetID].type == "vprogress" then
      _displayVProgress(guiID, widgetID)
    elseif guiID[widgetID].type == "list" then
      _displayList(guiID, widgetID)
    elseif guiID[widgetID].type == "frame" then
      _displayAFrame(guiID, widgetID)
    elseif guiID[widgetID].type == "hline" then
      _displayHLine(guiID, widgetID)
    elseif guiID[widgetID].type == "checkbox" then
      _displayCheckbox(guiID, widgetID)
    elseif guiID[widgetID].type == "radio" then
      _displayRadio(guiID, widgetID)
    elseif guiID[widgetID].type == "vslider" then
      _displayVslider(guiID, widgetID)
    elseif guiID[widgetID].type == "chart" then
      _displayChart(guiID, widgetID)
    end
end

function gui.exit()
  gpu.setBackground(0x000000)
  gpu.setForeground(0xFFFFFF)
  gpu.fill(1, 1, screenWidth, screenHeight, " ")
  os.exit()
end

local guiCounter = 0
-- need to be called first to setup a new dialog
function gui.newGui(x, y, w, h, frame, text, bg, fg)
  local tmpTable = {}
  tmpTable["type"] = "gui"
  if x == "center" then
    tmpTable["x"] = math.floor((screenWidth / 2) - (w / 2))
  else
    tmpTable["x"] = x
  end
  if y == "center" then
    tmpTable["y"] = math.floor((screenHeight / 2) - (h / 2))
  else
    tmpTable["y"] = y
  end
  tmpTable["bg"] = bg or colorFrameBackground
  tmpTable["fg"] = fg or colorFrameForeground
  tmpTable["width"] = w
  tmpTable["height"] = h
  tmpTable["frame"] = frame
  if text then
    tmpTable["text"] = "╡" .. text .. "┝"
  end
  tmpTable["buffer"] = {}
  tmpTable["num"] = guiCounter
  guiCounter = guiCounter + 1
  tmpTable["new"] = true
  displayed = false
  return tmpTable
end

-- checkbox
function gui.newCheckbox(guiID, x, y, status, func)
  local tmpTable = {}
  tmpTable["type"] = "checkbox"
  tmpTable["status"] = status or false
  tmpTable["y"] = y + guiID.y
  tmpTable["visible"] = true
  tmpTable["enabled"] = true
  tmpTable["x"] = x
  tmpTable["func"] = func
  table.insert(guiID, tmpTable)
  return #guiID
end

-- radio button
function gui.newRadio(guiID, x, y, func)
  local tmpTable = {}
  tmpTable["type"] = "radio"
  tmpTable["status"] = false
  tmpTable["y"] = y + guiID.y
  tmpTable["visible"] = true
  tmpTable["enabled"] = true
  tmpTable["x"] = x
  tmpTable["func"] = func
  table.insert(guiID, tmpTable)
  return #guiID
end

-- label
function gui.newLabel(guiID, x, y, text, bg, fg, l)
  local tmpTable = {}
  tmpTable["type"] = "label"
  tmpTable["y"] = y + guiID.y
  tmpTable["text"] = text
  tmpTable["lenght"] = string.len(text)
  tmpTable["bg"] = bg or guiID.bg
  tmpTable["fg"] = fg or guiID.fg
  tmpTable["visible"] = true
  tmpTable["x"] = x
  tmpTable["l"] = l or string.len(text)
  table.insert(guiID, tmpTable)
  return #guiID
end

-- time label
function gui.newTimeLabel(guiID, x, y, bg, fg)
  local tmpTable = {}
  tmpTable["type"] = "timelabel"
  tmpTable["y"] = y + guiID.y
  tmpTable["bg"] = bg or guiID.bg
  tmpTable["fg"] = fg or guiID.fg
  tmpTable["visible"] = true
  tmpTable["x"] = x
  table.insert(guiID, tmpTable)
  return #guiID
end

-- date label
function gui.newDateLabel(guiID, x, y, bg, fg, frm)
  local tmpTable = {}
  tmpTable["type"] = "datelabel"
  tmpTable["y"] = y + guiID.y
  tmpTable["bg"] = bg or guiID.bg
  tmpTable["fg"] = fg or guiID.fg
  tmpTable["visible"] = true
  tmpTable["x"] = x
  tmpTable["frm"] = frm or false
  table.insert(guiID, tmpTable)
  return #guiID
end

-- multi line label
function gui.newMultiLineLabel(guiID, x, y, w, h, text, bg, fg)
  local tmpTable = {}
  tmpTable["type"] = "multiLineLabel"
  tmpTable["y"] = y + guiID.y
  tmpTable["text"] = text
  tmpTable["bg"] = bg or guiID.bg
  tmpTable["fg"] = fg or guiID.fg
  tmpTable["visible"] = true
  tmpTable["x"] = x + guiID.x
  tmpTable["w"] = w
  tmpTable["h"] = h
  table.insert(guiID, tmpTable)
  return #guiID
end

-- button
function gui.newButton(guiID, x, y, text, func)
  local tmpTable = {}
  tmpTable["type"] = "button"
  tmpTable["y"] = y + guiID.y
  tmpTable["text"] = "[" .. text .. "]"
  tmpTable["lenght"] = string.len(tmpTable.text)
  tmpTable["visible"] = true
  tmpTable["enabled"] = true
  tmpTable["active"] = false
  tmpTable["func"] = func
  tmpTable["x"] = x
  table.insert(guiID, tmpTable)
  return #guiID
end

-- text input field
function gui.newText(guiID, x, y, lenght, text, func, fieldLenght, hide)
  local tmpTable = {}
  tmpTable["type"] = "text"
  tmpTable["x"] = x
  tmpTable["y"] = y + guiID.y
  tmpTable["text"] = text
  tmpTable["lenght"] = lenght
  tmpTable["visible"] = true
  tmpTable["enabled"] = true
  tmpTable["func"] = func
  if fieldLenght then
    tmpTable["fieldLenght"] = fieldLenght
  else
    tmpTable["fieldLenght"] = lenght
  end
  table.insert(guiID, tmpTable)
  tmpTable["hide"] = hide or false
  return #guiID
end

-- progressbar
function gui.newProgress(guiID, x, y, lenght, maxValue, value, func, number)
  local tmpTable = {}
  tmpTable["type"] = "progress"
  tmpTable["x"] = x
  tmpTable["y"] = y + guiID.y
  tmpTable["lenght"] = lenght
  tmpTable["visible"] = true
  tmpTable["enabled"] = true
  tmpTable["max"] = maxValue
  tmpTable["value"] = value
  tmpTable["func"] = func
  tmpTable["finished"] = false
  tmpTable["displayNumber"] = number or false
  table.insert(guiID, tmpTable)
  return #guiID
end

-- vertical progress
function gui.newVProgress(guiID, x, y, lenght, width, maxValue, value, func, direction)
  local tmpTable = {}
  tmpTable["type"] = "vprogress"
  tmpTable["x"] = x
  tmpTable["y"] = y + guiID.y
  tmpTable["lenght"] = lenght
  tmpTable["width"] = width
  tmpTable["visible"] = true
  tmpTable["enabled"] = true
  tmpTable["max"] = maxValue
  tmpTable["value"] = value
  tmpTable["func"] = func
  tmpTable["direction"] = direction or 0
  tmpTable["finished"] = false
  table.insert(guiID, tmpTable)
  return #guiID
end

-- vertical slider
function gui.newVSlider(guiID, x, y, lenght, min, max, value, func)
  local tmpTable = {}
  tmpTable["type"] = "vslider"
  tmpTable["x"] = x
  tmpTable["y"] = y + guiID.y
  tmpTable["lenght"] = lenght
  tmpTable["visible"] = true
  tmpTable["enabled"] = true
  tmpTable["min"] = min
  tmpTable["max"] = max
  tmpTable["value"] = value
  tmpTable["func"] = func
  table.insert(guiID, tmpTable)
  return #guiID
end

-- list
function gui.newList(guiID, x, y, width, height, tab, func, text)
  local tmpTable = {}
  tmpTable["type"] = "list"
  tmpTable["x"] = x + guiID.x
  tmpTable["y"] = y + guiID.y
  tmpTable["width"] = width
  tmpTable["height"] = height
  tmpTable["visible"] = true
  tmpTable["enabled"] = true
  tmpTable["func"] = func
  tmpTable["selected"] = 1
  tmpTable["active"] = 1
  tmpTable["entries"] = tab
  tmpTable["text"] = text
  table.insert(guiID, tmpTable)
  return #guiID
end

--frame
function gui.newFrame(guiID, x, y, width, height, text)
  local tmpTable = {}
  tmpTable["type"] = "frame"
  tmpTable["x"] = x + guiID.x
  tmpTable["y"] = y + guiID.y
  tmpTable["width"] = width
  tmpTable["height"] = height
  tmpTable["visible"] = true
  tmpTable["enabled"] = true
  tmpTable["text"] = text
  table.insert(guiID, tmpTable)
  return #guiID
end

-- hline
function gui.newHLine(guiID, x, y, width)
  local tmpTable = {}
  tmpTable["type"] = "hline"
  tmpTable["x"] = x + guiID.x
  tmpTable["y"] = y + guiID.y
  tmpTable["width"] = width
  tmpTable["visible"] = true
  tmpTable["enabled"] = true
  table.insert(guiID, tmpTable)
  return #guiID
end

-- chart
function gui.newChart(guiID, x, y, minValue, maxValue, data, lenght, height, bg, fg)
  local tmpTable = {}
  tmpTable["type"] = "chart"
  tmpTable["y"] = y + guiID.y
  tmpTable["lenght"] = lenght
  tmpTable["height"] = height
  tmpTable["bg"] = bg or guiID.bg
  tmpTable["fg"] = fg or guiID.fg
  tmpTable["visible"] = true
  tmpTable["x"] = x + guiID.x
  tmpTable["data"] = data
  tmpTable["min"] = minValue
  tmpTable["max"] = maxValue
  table.insert(guiID, tmpTable)
  return #guiID
end

function gui.getSelected(guiID, listID)
  return guiID[listID].selected, guiID[listID].entries[guiID[listID].selected]
end

function gui.setSelected(guiID, listID, selection)
  if selection<= #guiID[listID].entries then
    guiID[listID].selected = selection
    _displayList(guiID, listID)
  end
end

function gui.setMax(guiID, widgetID, maxValue)
  guiID[widgetID].max = maxValue
  _displayProgress(guiID, widgetID)
end

function gui.setChartData(guiID, chartID, data)
  guiID[chartID].data = data
  _displayChart(guiID, chartID)
end

function gui.setValue(guiID, widgetID, value)
  guiID[widgetID].value = value
  if guiID[widgetID].type == "progress" then
    _displayProgress(guiID, widgetID)
  end
  if guiID[widgetID].type == "vprogress" then
    _displayVProgress(guiID, widgetID)
  end
  if guiID[widgetID].type == "vslider" then
    _displayVslider(guiID, widgetID)
  end
end

function gui.resetProgress(guiID, progressID)
  guiID[progressID].finished = false
  _displayProgress(guiID, progressID)
end

-- sets the text of a widget
function gui.setText(guiID, widgetID, text, refresh)
  guiID[widgetID].text = text
  if guiID[widgetID].type == "text" then
    if refresh == nil or refresh == true then
      _displayText(guiID, widgetID)
    end
  end
  if guiID[widgetID].type == "label" then
    if refresh == nil or refresh == true then
      _displayLabel(guiID, widgetID)
    end
  end
  if guiID[widgetID].type == "multiLineLabel" then
    if refresh == nil or refresh == true then
      _displayMultiLineLabel(guiID, widgetID)
    end
  end
--  gui.displayGui(guiID)
end

function gui.getText(guiID, widgetID)
  return guiID[widgetID].text
end

function gui.getCheckboxStatus(guiID, widgetID)
  return guiID[widgetID].status
end

function gui.setEnable(guiID, widgetID, state, refresh)
  guiID[widgetID].enabled = state
  if refresh == nil then
    gui.displayGui(guiID)
  end
  if refresh == true then
    gui.displayWidget(guiID, widgetID)
  end
end

function gui.setPosition(guiID, widgetID, x, y, refresh)
  guiID[widgetID].x = x
  guiID[widgetID].y = y
  if refresh == nil then
    gui.displayGui(guiID)
  end
  if refresh == true then
    gui.displayWidget(guiID, widgetID)
  end
end

function gui.setSize(guiID, widgetID, w, h, refresh)
  guiID[widgetID].width = w
  guiID[widgetID].height = h
  guiID[widgetID].w = w
  guiID[widgetID].h = h
  guiID[widgetID].lenght = w
  if refresh == nil then
    gui.displayGui(guiID)
  end
  if refresh == true then
    gui.displayWidget(guiID, widgetID)
  end
end

function gui.setVisible(guiID, widgetID, state, refresh)
  if state == false then
    guiID[widgetID].visible = state
    guiID[widgetID].enabled = state
  elseif state == true then
    guiID[widgetID].visible = state
  end
  if refresh == nil then
    gui.displayGui(guiID)
  end
  if refresh == true then
    gui.displayWidget(guiID, widgetID)
  end
end

function gui.setBackground(guiID, widgetID, color)
  guiID[widgetID].bg = color
  if guiID[widgetID].type == "label" then
    _displayLabel(guiID, widgetID)
  end
end
function gui.setForeground(guiID, widgetID, color)
  guiID[widgetID].fg = color
  if guiID[widgetID].type == "label" then
    _displayLabel(guiID, widgetID)
  end
end

function gui.clearList(guiID, listID)
  guiID[listID].entries = {}
end

function gui.insertList(guiID, listID, value)
  table.insert(guiID[listID].entries, value)
  _displayList(guiID, listID)
end

function gui.removeList(guiID, listID, entry)
  table.remove(guiID[listID].entries, entry)
  _displayList(guiID, listID)
end

function gui.renameList(guiID, listID, entry, newName)
  guiID[listID].entries[entry] = newName
  _displayList(guiID, listID)
end

function gui.getRadio(guiID)
  for i = 1, #guiID do
    if guiID[i].type == "radio" then
      if guiID[i].status == true then
	return i
      end
    end
  end
  return -1
end

function gui.setRadio(guiID, radioID)
  for i = 1, #guiID do
    if guiID[i].type == "radio" then
      guiID[i].status = false
    end
  end
  guiID[radioID].status = true
  return -1
end

function gui.setCheckbox(guiID, checkboxID, status)
  guiID[checkboxID].status = status
end

local function runInput(guiID, textID)
  local inputText = guiID[textID].text
  gpu.setBackground(colorInputBackground)
  gpu.setForeground(colorInputForeground)

  local x = 0
  if guiID[textID].x == "center" then
    x = guiID.x + math.floor((guiID.width / 2)) - math.floor((guiID[textID].fieldLenght) / 2)
  else
    x =guiID.x + guiID[textID].x
  end

  local loopRunning = true
  while loopRunning == true do
    gpu.fill(x, guiID[textID].y, guiID[textID].fieldLenght, 1, " ")
    tmpStr = inputText
    if guiID[textID].hide == true then
      tmpStr = ""
      for i = 1, string.len(inputText) do
	tmpStr = tmpStr .."*"
      end
    end
    if string.len(tmpStr) + 1 > guiID[textID].fieldLenght then
      tmpStr = string.sub(tmpStr, string.len(tmpStr) - guiID[textID].fieldLenght + 2, string.len(tmpStr))
    end
    gpu.set(x, guiID[textID].y, tmpStr .. "_")
    local e, _, character, code = event.pullMultiple(0.1, "key_down", "touch")
    if e == "key_down" then
      if character == 8 then	-- backspace
	inputText = string.sub(inputText, 1, string.len(inputText) - 1)
      elseif character == 13 then 	-- return
	guiID[textID].text = inputText
	if guiID[textID].func then
	  guiID[textID].func(guiID, textID, inputText)
	end
	loopRunning = false
      elseif character > 31 and character < 128 and string.len(inputText) < guiID[textID].lenght then
	inputText = inputText .. string.char(character)
      end
    elseif e == "touch" then
      if character < x or character > (x + guiID[textID].fieldLenght) or guiID[textID].y ~= code then
	guiID[textID].text = inputText
	_displayText(guiID, textID)
	if guiID[textID].func then
	  guiID[textID].func(guiID, textID, inputText)
	end
	loopRunning = false
	computer.pushSignal("touch", _, character, code)
      end
    end
  end
end


function gui.runGui(guiID)
  if displayed == false then
    displayed = true
    gui.displayGui(guiID)
  end

  -- events with out touch
  for i = 1, #guiID do
    if guiID[i].type == "timelabel" then
      _displayTimeLabel(guiID, i)
    elseif guiID[i].type == "datelabel" then
      _displayDateLabel(guiID, i)
    end
  end

  local ix = 0
  local e, _, x, y, button = event.pull(0.1, "touch")
  if e == nil then
    return false
  end
  for i = 1, #guiID do
    if guiID[i].type == "button" then
      if guiID[i].x == "center" then
	ix = guiID.x + math.floor((guiID.width / 2)) - math.floor((guiID[i].lenght / 2))
      else
	ix = guiID.x + guiID[i].x
      end
      if x >= ix and x < (ix + guiID[i].lenght) and guiID[i].y == y then
	if guiID[i].func and guiID[i].enabled == true then
	  guiID[i].active = true
	  gui.displayGui(guiID)
	  os.sleep(0.05)
	  guiID[i].active = false
	  gui.displayGui(guiID)
	  guiID[i].func(guiID, i)
	end
      end
    elseif guiID[i].type == "timelabel" then
      _displayTimeLabel(guiID, i)
    elseif guiID[i].type == "checkbox" then
      ix = guiID.x + guiID[i].x + 1
      if x == ix and guiID[i].y == y then
	if guiID[i].enabled == true then
	  if guiID[i].status == true then
	    guiID[i].status = false
	  else
	    guiID[i].status = true
	  end
	  if guiID[i].func then
	    guiID[i].func(guiID, i, guiID[i].status)
	  end
	  _displayCheckbox(guiID, i)
	end
      end
    elseif guiID[i].type == "radio" then
      ix = guiID.x + guiID[i].x + 1
      if x == ix and guiID[i].y == y then
	if guiID[i].enabled == true then
	  for c = 1, #guiID do
	    if guiID[c].type == "radio" then
	      guiID[c].status = false
	      if guiID[i].func then
		guiID[i].func(guiID, i, guiID[i].status)
	      end
	      _displayRadio(guiID, c)
	    end
	  end
	  guiID[i].status = true
	  if guiID[i].func then
	    guiID[i].func(guiID, i, guiID[i].status)
	  end
	  _displayRadio(guiID, i)
	end
      end
    elseif guiID[i].type == "text" then
      if guiID[i].x == "center" then
	ix = guiID.x + math.floor((guiID.width / 2)) - math.floor((guiID[i].lenght / 2))
      else
	ix = guiID.x + guiID[i].x
      end
      if x >= ix and x < (ix + guiID[i].fieldLenght) and guiID[i].y == y then
	if guiID[i].enabled == true then
	  runInput(guiID, i)
	end
      end
    elseif guiID[i].type == "list" and guiID[i].enabled == true then
      if x == guiID[i].x +1 and y == guiID[i].y + guiID[i].height - 1 then
	guiID[i].active = guiID[i].active - guiID[i].height + 2
	if guiID[i].active < 1 then
	  guiID[i].active = 1
	end
	gpu.setBackground(colorListActiveBackground)
	gpu.setForeground(colorListActiveForeground)
	gpu.set(guiID[i].x, guiID[i].y + guiID[i].height - 1, "[<]")
	guiID[i].selected = guiID[i].active
--	_displayList(guiID, i)

	if guiID[i].func then
	  gpu.setBackground(colorButtonClickedBackground)
	  gpu.setForeground(colorButtonClickedForeground)
	  gpu.set(guiID[i].x, guiID[i].y + guiID[i].height - 1, "[<]")
	  os.sleep(0.05)
	  gpu.setBackground(colorListBackground)
	  gpu.setForeground(colorListForeground)
	  gpu.set(guiID[i].x, guiID[i].y + guiID[i].height - 1, "[<]")
	  guiID[i].func(guiID, i, guiID[i].selected, guiID[i].entries[guiID[i].selected])
	end
      end
      if x == guiID[i].x + guiID[i].width - 2 and y == guiID[i].y + guiID[i].height - 1 then
	if guiID[i].active + guiID[i].height - 2 < #guiID[i].entries + 1 then
	  guiID[i].active = guiID[i].active + guiID[i].height - 2
	  guiID[i].selected = guiID[i].active
	end
	gpu.setBackground(colorListActiveBackground)
	gpu.setForeground(colorListActiveForeground)
	gpu.set(guiID[i].x + guiID[i].width - 3, guiID[i].y + guiID[i].height - 1, "[>]")
--	_displayList(guiID, i)

	if guiID[i].func then
	  gpu.setBackground(colorButtonClickedBackground)
	  gpu.setForeground(colorButtonClickedForeground)
	  gpu.set(guiID[i].x + guiID[i].width - 3, guiID[i].y + guiID[i].height - 1, "[>]")
	  os.sleep(0.05)
	  gpu.setBackground(colorListBackground)
	  gpu.setForeground(colorListForeground)
	  gpu.set(guiID[i].x + guiID[i].width - 3, guiID[i].y + guiID[i].height - 1, "[>]")
	  guiID[i].func(guiID, i, guiID[i].selected, guiID[i].entries[guiID[i].selected])
	end
      end
      if x > guiID[i].x - 1 and x < guiID[i].x + guiID[i].width and y > guiID[i].y and y < guiID[i].y + guiID[i].height - 1 then
	if guiID[i].active + y - guiID[i].y - 1 <= #guiID[i].entries then
	  guiID[i].selected = guiID[i].active + y - guiID[i].y - 1
--	  _displayList(guiID, i)

	  if guiID[i].func then
	    guiID[i].func(guiID, i, guiID[i].selected, guiID[i].entries[guiID[i].selected])
	  end
	end
      end
	  _displayList(guiID, i)
    elseif guiID[i].type == "chart" and guiID[i].enabled == true then
      _displayChart(guiID, i)
    elseif guiID[i].type == "vslider" and guiID[i].enabled == true then
      ix = guiID.x + guiID[i].x
      if x == ix and y == guiID[i].y and guiID[i].value > guiID[i].min then
	v = guiID[i].value - 1
	gui.setValue(guiID, i, v)
      elseif x == ix + guiID[i].lenght and y == guiID[i].y and guiID[i].value < guiID[i].max then
	v = guiID[i].value + 1
	gui.setValue(guiID, i, v)
      end
      if guiID[i].func then
	guiID[i].func(guiID, i, guiID[i].value)
      end
      _displayVslider(guiID, i)
    end
  end

--  gui.displayGui(guiID)
end

errorGui = gui.newGui("center", "center", 40, 10, true, "ERROR", 0xFF0000, 0xFFFF00)
errorMsgLabel1 = gui.newLabel(errorGui, "center", 3, "")
errorMsgLabel2 = gui.newLabel(errorGui, "center", 4, "")
errorMsgLabel3 = gui.newLabel(errorGui, "center", 5, "")
errorButton = gui.newButton(errorGui, "center", 8, "exit", gui.exit)

function gui.showError(msg1, msg2, msg3)
  gui.displayGui(errorGui)
  gui.setText(errorGui, errorMsgLabel1, msg1 or "")
  gui.setText(errorGui, errorMsgLabel2, msg2 or "")
  gui.setText(errorGui, errorMsgLabel3, msg3 or "")
  while true do
    gui.runGui(errorGui)
  end
  gui.closeGui(errorGui)
end


function gui.checkHardware(comp, msg)
  if component.isAvailable(comp) == false then
    compGui = gui.newGui("center", "center", 40, 8, true, nil, 0xFF0000, 0xFFFF00)
    gui.displayGui(compGui)
    gui.newLabel(compGui, "center", 1, "!Component missing!")
    gui.newLabel(compGui, "center", 3, msg)
    gui.newHLine(compGui, 1, 5, 38)
    gui.newButton(compGui, "center", 6, "exit", gui.exit)
    while true do
      gui.runGui(compGui)
    end
  end
end


local msgRunning = true
function msgCallback()
  msgRunning = false
end

msgGui = gui.newGui("center", "center", 40, 10, true, "Info")
msgLabel1 = gui.newLabel(msgGui, "center", 3, "")
msgLabel2 = gui.newLabel(msgGui, "center", 4, "")
msgLabel3 = gui.newLabel(msgGui, "center", 5, "")
msgButton = gui.newButton(msgGui, "center", 8, "ok", msgCallback)

function gui.showMsg(msg1, msg2, msg3)
  gui.displayGui(msgGui)
  gui.setText(msgGui, msgLabel1, msg1 or "")
  gui.setText(msgGui, msgLabel2, msg2 or "")
  gui.setText(msgGui, msgLabel3, msg3 or "")
  msgRunning = true
  while msgRunning == true do
    gui.runGui(msgGui)
  end
  gui.closeGui(msgGui)
end


local yesNoRunning = true
local yesNoValue = false

local function yesNoCallbackYes()
  yesNoRunning = false
  yesNoValue = true
end
local function yesNoCallbackNo()
  yesNoRunning = false
  yesNoValue = false
end

yesNoGui = gui.newGui("center", "center", 40, 10, true, "Question")
yesNoMsgLabel1 = gui.newLabel(yesNoGui, "center", 3, "")
yesNoMsgLabel2 = gui.newLabel(yesNoGui, "center", 4, "")
yesNoMsgLabel3 = gui.newLabel(yesNoGui, "center", 5, "")
yesNoYesButton = gui.newButton(yesNoGui, 3, 8, "yes", yesNoCallbackYes)
yesNoNoButton = gui.newButton(yesNoGui, 33, 8, "no", yesNoCallbackNo)


function gui.getYesNo(msg1, msg2, msg3)
  yesNoRunning = true
  gui.displayGui(yesNoGui)
  gui.setText(yesNoGui, yesNoMsgLabel1, msg1 or "")
  gui.setText(yesNoGui, yesNoMsgLabel2, msg2 or "")
  gui.setText(yesNoGui, yesNoMsgLabel3, msg3 or "")
  while yesNoRunning == true do
    gui.runGui(yesNoGui)
  end
  gui.closeGui(yesNoGui)
  return yesNoValue
end




-- File handling

function gui.splitString(str, sep)
        local sep, fields = sep or ":", {}
        local pattern = string.format("([^%s]+)", sep)
        str:gsub(pattern, function(c) fields[#fields+1] = c end)
        return fields
end




local function convert( chars, dist, inv )
  return string.char( ( string.byte( chars ) - 32 + ( inv and -dist or dist ) ) % 95 + 32 )
end

function gui.string2key(str)
  tmpTable = {}
  for i = 1, string.len(str) do
    tmpTable[i] = string.byte(str,i)
  end
  while #tmpTable < 5 do
    table.insert(tmpTable,100)
  end
  return tmpTable
end


function gui.crypt(str, k, inv)
  if not k then
    k = {1,2,3,4,5}
  end
  while #k < 5 do
    table.insert(k,100)
  end
  local enc= "";
  for i=1,#str do
    if(#str-k[#k] >= i or not inv)then
      for inc=0,3 do
	if(i%4 == inc)then
	  enc = enc .. convert(string.sub(str,i,i),k[inc+1],inv);
	  break;
	end
      end
    end
  end
  if(not inv)then
    for i=1,k[#k] do
      enc = enc .. string.char(math.random(32,126));
    end
  end
  return enc;
end

--// exportstring( string )
--// returns a "Lua" portable version of the string
function exportstring( s )
	s = string.format( "%q",s )
	-- to replace
	s = string.gsub( s,"\\\n","\\n" )
	s = string.gsub( s,"\r","\\r" )
	s = string.gsub( s,string.char(26),"\"..string.char(26)..\"" )
	return s
end
--// The Save Function
function gui.saveTable(tbl,filename )
	local charS,charE = "   ","\n"
	local file,err
	-- create a pseudo file that writes to a string and return the string
	if not filename then
		file =  { write = function( self,newstr ) self.str = self.str..newstr end, str = "" }
		charS,charE = "",""
	-- write table to tmpfile
	elseif filename == true or filename == 1 then
		charS,charE,file = "","",io.tmpfile()
	-- write table to file
	-- use io.open here rather than io.output, since in windows when clicking on a file opened with io.output will create an error
	else
		file,err = io.open( filename, "w" )
		if err then
		  print ("Gui-lib: Error saving table " .. filename .." -> " .. err)
		  return _,err
		end
	end
	-- initiate variables for save procedure
	local tables,lookup = { tbl },{ [tbl] = 1 }
	file:write( "return {"..charE )
	for idx,t in ipairs( tables ) do
		if filename and filename ~= true and filename ~= 1 then
			file:write( "-- Table: {"..idx.."}"..charE )
		end
		file:write( "{"..charE )
		local thandled = {}
		for i,v in ipairs( t ) do
			thandled[i] = true
			-- escape functions and userdata
			if type( v ) ~= "userdata" then
				-- only handle value
				if type( v ) == "table" then
					if not lookup[v] then
						table.insert( tables, v )
						lookup[v] = #tables
					end
					file:write( charS.."{"..lookup[v].."},"..charE )
				elseif type( v ) == "function" then
					file:write( charS.."loadstring("..exportstring(string.dump( v )).."),"..charE )
				else
					local value =  ( type( v ) == "string" and exportstring( v ) ) or tostring( v )
					file:write(  charS..value..","..charE )
				end
			end
		end
		for i,v in pairs( t ) do
			-- escape functions and userdata
			if (not thandled[i]) and type( v ) ~= "userdata" then
				-- handle index
				if type( i ) == "table" then
					if not lookup[i] then
						table.insert( tables,i )
						lookup[i] = #tables
					end
					file:write( charS.."[{"..lookup[i].."}]=" )
				else
					local index = ( type( i ) == "string" and "["..exportstring( i ).."]" ) or string.format( "[%d]",i )
					file:write( charS..index.."=" )
				end
				-- handle value
				if type( v ) == "table" then
					if not lookup[v] then
						table.insert( tables,v )
						lookup[v] = #tables
					end
					file:write( "{"..lookup[v].."},"..charE )
				elseif type( v ) == "function" then
					file:write( "loadstring("..exportstring(string.dump( v )).."),"..charE )
				else
					local value =  ( type( v ) == "string" and exportstring( v ) ) or tostring( v )
					file:write( value..","..charE )
				end
			end
		end
		file:write( "},"..charE )
	end
	file:write( "}" )
	-- Return Values
	-- return stringtable from string
	if not filename then
		-- set marker for stringtable
		return file.str.."--|"
	-- return stringttable from file
	elseif filename == true or filename == 1 then
		file:seek ( "set" )
		-- no need to close file, it gets closed and removed automatically
		-- set marker for stringtable
		return file:read( "*a" ).."--|"
	-- close file and return 1
	else
		file:close()
		return 1
	end
end

--// The Load Function
function gui.loadTable( sfile )
	local tables, err, _

	-- catch marker for stringtable
	if string.sub( sfile,-3,-1 ) == "--|" then
		tables,err = loadstring( sfile )
	else
		tables,err = loadfile( sfile )
	end
	if err then
	  print("Gui-lib: Error loading table " ..sfile .. " -> " ..err)
	  return _,err
	end
	tables = tables()
	for idx = 1,#tables do
		local tolinkv,tolinki = {},{}
		for i,v in pairs( tables[idx] ) do
			if type( v ) == "table" and tables[v[1]] then
				table.insert( tolinkv,{ i,tables[v[1]] } )
			end
			if type( i ) == "table" and tables[i[1]] then
				table.insert( tolinki,{ i,tables[i[1]] } )
			end
		end
		-- link values, first due to possible changes of indices
		for _,v in ipairs( tolinkv ) do
			tables[idx][v[1]] = v[2]
		end
		-- link indices
		for _,v in ipairs( tolinki ) do
			tables[idx][v[2]],tables[idx][v[1]] =  tables[idx][v[1]],nil
		end
	end
	return tables[1]
end

function gui.sepString(str)
  tmpTable = {}
  for i = 1, string.len(str) do
    tmpTable[i] = string.char(string.byte(str,i))
  end
  return tmpTable
end






return gui