View difference between Paste ID: sSprBkir and Dfgc6z0T

 local versionMajor = "2"
 local versionMinor = "5"
 
 
 local component = require("component")
 local gpu = component.gpu
 local event = require("event")
 local ser = require("serialization")
 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