widget

--  Copyright Thomas Bogue 2013
--  This program is free software: you can redistribute it and/or modify
--  it under the terms of the GNU Lesser General Public License as published by
--  the Free Software Foundation, either version 3 of the License, or
--  (at your option) any later version.

--  This program is distributed in the hope that it will be useful,
--  but WITHOUT ANY WARRANTY; without even the implied warranty of
--  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--  GNU Lesser General Public License for more details.

--  You should have received a copy of the GNU Lesser General Public License
--  along with this program.  If not, see <http://www.gnu.org/licenses/>.

monitor=nil
defaultButtonBackground=colors.blue
defaultButtonForeground=colors.white
terminalBackground=colors.black
defaultSliderForeground=colors.white
defaultSliderBackground=colors.gray
defaultFlagMonitorForeground=colors.white
defaultProgressBarForeground=colors.white
defaultProgressBarBackground=colors.gray
redrawNeeded=false

function version()
  return "widget library v1.1"
end

local function nop()
end

function getMonitor()
  return monitor
end

function setMonitor(m)
  monitor=m
end

function getDefaultMonitor()
  --print("searching for advanced monitor...")
  facings={"top","bottom","right","left","front","back"}
  for key,facing in pairs(facings) do
    mon=peripheral.wrap(facing)
    --print("looking for an advanced monitor " .. facing .. " " .. tostring(mon))
    if (mon~=nil) then
      --print("peripheral found")
      if (mon.setTextColor~=nil) then
        --print("monitor found on ".. facing)
        return mon
      end
    end
  end
  --print("no advanced monitor found.  Is this an advanced computer?")
  if (term.isColor()) then
    print("using the terminal as an advanced computer")
    return(term)
  else
    error("no advanced monitor or advanced computer found.  This program requires advanced interface hardward.  Please install either an advanced computer or an advanced monitor",0)
  end
end

function newWidget()
  widget={}
  widget.draw=nop -- draw(widget)
  widget.onClick=nop -- onClick(widget,x,y)
  widget.onResize=nop -- onResize(widget)
  widget.hWeight=1
  widget.vWeight=1
  widget.width=nil
  widget.height=nil
  widget.x1=nil
  widget.y1=nil
  widget.x2=nil
  widget.y2=nil

  function widget.size(widget)
    if (monitor==nil) then
      monitor=getDefaultMonitor()
    end
    widget.width,widget.height=monitor.getSize()
    widget.x1=1
    widget.y1=1
    widget.x2=widget.width
    widget.y2=widget.height
    widget.onResize(widget)
    widget.sized=true
  end

  function widget.run(widget)
    if (widget==null) then
      error("invalid call to member function widget:run.  Did you type widget.run instead?",2)
    end
    if (widget.sized==true) then
    else
      widget:size()
    end
    monitor.setBackgroundColor(terminalBackground)
    monitor.clear()
    widget:draw()
    widget.quit=false
    while not widget.quit do
      if (monitor==term) then
        event,side,x,y=os.pullEvent("mouse_click")
      else
        event,side,x,y=os.pullEvent("monitor_touch")
      end
      widget:processEvent(event,side,x,y)
    end
    monitor.setBackgroundColor(terminalBackground)
    monitor.clear()
  end

  function widget.processEvent(widget,event,side,x,y)
    if (event=="monitor_touch" or event=="mouse_click") then
      widget:onClick(x,y)
      if (redrawNeeded) then
        monitor.setBackgroundColor(terminalBackground)
        monitor.clear()
        widget:draw()
      end
    end
  end

  return(widget)
end

function newContainer()
  container=newWidget()
  container.children={}
  container.vSpacingWeight=.1
  container.hSpacingWeight=.1

  function container.draw(container)
    for key,child in pairs(container.children) do
      child:draw()
    end
  end

  function container.onClick(container,x,y)
    for key,child in pairs(container.children) do
      if x>=child.x1 and x<=child.x2 and y>=child.y1 and y<=child.y2 then
        child:onClick(x,y)
      end
    end
  end

  function container.resizeChildren(container)
    for key,child in pairs(container.children) do
      child:onResize()
    end
  end

  container.onResize=resizeChildren

  function container.add(container,widget)
    if (widget==nil) then
      error("attempt to add nil widget to a container.  Did you perhaps type row.add when you meant row:add?  Or column.add when you meant column:add?",2)
    end
    container.children[#container.children+1]=widget
  end

  return(container)
end

function newButton(label)
  button=newWidget()
  button.label=label
  button.backgroundColor=defaultButtonBackground
  button.foregroundColor=defaultButtonForeground
  button.labelX=nil
  button.labelY=nil

  function button.drawFull(button)
    button.labelX=math.floor((button.x1+button.x2-button.label:len())/2)
    button.labelY=(button.y1+button.y2)/2
    monitor.setBackgroundColor(button.backgroundColor)
    monitor.setTextColor(button.foregroundColor)
    for x=button.x1,button.x2 do
      for y=button.y1,button.y2 do
        monitor.setCursorPos(x,y)
        monitor.write(" ")
      end
    end
    monitor.setCursorPos(button.labelX,button.labelY)
    monitor.write(button.label)
  end

  function button.drawOutline(button)
    button.labelX=math.floor((button.x1+button.x2-button.label:len())/2)
    button.labelY=(button.y1+button.y2)/2
    monitor.setBackgroundColor(button.backgroundColor)
    for x=button.x1,button.x2 do
      monitor.setCursorPos(x,button.y1)
      monitor.write(" ")
      monitor.setCursorPos(x,button.y2)
      monitor.write(" ")
    end
    for y=button.y1+1,button.y2-1 do
      monitor.setCursorPos(button.x1,y)
      monitor.write(" ")
      monitor.setCursorPos(button.x2,y)
      monitor.write(" ")
    end
    monitor.setBackgroundColor(terminalBackground)
    for x=button.x1+1,button.x2-1 do
      for y=button.y1+1,button.y2-1 do
        monitor.setCursorPos(x,y)
        monitor.write(" ")
      end
    end
    monitor.setTextColor(button.foregroundColor)
    monitor.setCursorPos(button.labelX,button.labelY)
    monitor.write(button.label)
  end

  function button.blink(button)
    button:drawOutline()
    os.sleep(.1)
    button:draw()
  end

  button.draw=button.drawFull
  return(button)
end

function newRow()
  row=newContainer()

  function row.onResize(row)
    totalWeight=row.hSpacingWeight*(#row.children-1)
    for key,child in pairs(row.children) do
      totalWeight=totalWeight+child.hWeight
    end
    widths={}
    totalWidgetWidth=0
    for key,child in pairs(row.children) do
      widths[key]=math.floor(row.width*child.hWeight/totalWeight)
      totalWidgetWidth=totalWidgetWidth+widths[key]
    end
    remainingWidth=row.width-totalWidgetWidth
    if (#row.children>=1) then
      separatorWidth=1
    else
      separatorWidth=math.floor(remainingWidth/(#row.children-1))
    end
    currentPosition=row.x1 + math.floor((row.width-totalWidgetWidth-separatorWidth*(#row.children-1))/2)
    for key,child in pairs(row.children) do
      child.x1=currentPosition
      child.y1=row.y1
      currentPosition=currentPosition+widths[key]-1
      child.x2=currentPosition
      child.y2=row.y2
      currentPosition=currentPosition+separatorWidth+1
      child.width=widths[key]
      child.height=row.height
    end
    row:resizeChildren()
  end

  return(row)
end

function newColumn()
  column=newContainer()

  function column.onResize(column)
    totalWeight=column.vSpacingWeight*(#column.children-1)
    for key,child in pairs(column.children) do
      totalWeight=totalWeight+child.vWeight
    end
    widths={}
    totalWidgetWidth=0
    for key,child in pairs(column.children) do
      widths[key]=math.floor(column.height*child.vWeight/totalWeight)
      totalWidgetWidth=totalWidgetWidth+widths[key]
    end
    remainingWidth=column.height-totalWidgetWidth
    if (#column.children>=1) then
      separatorWidth=1
    else
      separatorWidth=math.floor(remainingWidth/(#column.children-1))
    end
    currentPosition=column.y1 + math.floor((column.height-totalWidgetWidth-separatorWidth*(#column.children-1))/2)
    for key,child in pairs(column.children) do
      child.x1=column.x1
      child.y1=currentPosition
      currentPosition=currentPosition+widths[key]-1
      child.x2=column.x2
      child.y2=currentPosition
      child.width=column.width
      child.height=widths[key]
      currentPosition=currentPosition+separatorWidth+1
    end
    column:resizeChildren()
  end

  return(column)
end

function newToggleButton(label)
  button=newButton(label)
  function button.toggle(button)
    button.state=not button.state
    button:draw()
  end

  function button.draw(button)
    if button.state then
      button:drawFull()
    else
      button:drawOutline()
    end
  end

  button.onClick=button.toggle
  button.state=false
  return(button)
end

function newLabel(text)
  label=newWidget()
  label.text=text
  label.textColor=defaultButtonForeground
  function label.draw(label)
    leftMargin=math.floor((label.width-label.text:len())/2)
    rightMargin=label.width-label.text:len()-leftMargin
    y=math.floor((label.y1+label.y2)/2)
    paddedText=string.rep(" ",leftMargin)..label.text..string.rep(" ",rightMargin)
    monitor.setTextColor(label.textColor)
    monitor.setCursorPos(label.x1,y)
    monitor.write(paddedText)
  end

  return(label)
end

function newSlider(min,max)
  slider=newWidget()
  slider.min=min
  slider.max=max
  slider.value=min
  slider.left=nil
  slider.foregroundColor=defaultSliderForeground
  slider.backgroundColor=defaultSliderBackground

  function slider.draw(slider)
    range=slider.max-slider.min+1
    slider.left=math.floor((slider.x1+slider.x2-range)/2)
    margin=slider.left-slider.x1
    y=math.floor((slider.y1+slider.y2)/2)
    left=slider.value-slider.min+1
    right=slider.max-slider.value
    monitor.setCursorPos(slider.x1,y)
    monitor.setBackgroundColor(terminalBackground)
    monitor.write(string.rep(" ",margin))
    monitor.setBackgroundColor(slider.foregroundColor)
    monitor.write(string.rep(" ",left))
    monitor.setBackgroundColor(slider.backgroundColor)
    monitor.write(string.rep(" ",right))
    monitor.setBackgroundColor(terminalBackground)
    monitor.setTextColor(slider.foregroundColor)
    tag=" "..tostring(slider.value*25)
    roomleft=slider.width-margin-range-tag:len()
    if (roomleft>=0) then
      monitor.write(tag..string.rep(" ",slider.width-margin-tag:len()-range))
    end
  end

  function slider.onClick(slider,x,y)
    slider.value=x-slider.left+slider.min
    if (slider.value<slider.min) then
      slider.value=slider.min
    else
      if (slider.value>slider.max) then
        slider.value=slider.max
      end
    end
    slider:draw()
  end

  slider.adjust=slider.onClick
  return(slider)
end

function newFlagMonitor(side) -- signal display widget
  flag=newWidget()
  flag.side=side
  flag.flags=0
  flag.sized=false
  flag.foregroundColor=defaultFlagMonitorForeground

  function flag.get(flag,n)
    x=bit.blshift(1,n-1)
    y=bit.band(flag.flags,x)
    z=(y~=0)
    return z
  end

  function flag.set(flag,n,value)
    if (value==nil) then
      value=true
    end
    if (value) then
      flag.flags=bit.bor(flag.flags,bit.blshift(1,n-1))
    else
      flag.flags=bit.band(flag.flags,bit.bnot(bit.blshift(1,n-1)))
    end
    flag:transmit()
  end

  function flag.clear(flag,n)
    flag.flags=bit.band(flag.flags,bit.bnot(bit.blshift(1,n-1)))
    flag:transmit()
  end

  function flag.toggle(flag,n)
    flag.flags=bit.bxor(flag.flags,bit.blshift(1,n-1))
    flag:transmit()
  end

  function flag.transmit(flag)
    --print("transmitting " .. flag.flags .. " to " .. flag.side)
    redstone.setBundledOutput(flag.side,flag.flags)
    flag:draw()
  end

  function flag.draw(flag)
    if ( not flag.sized ) then
      return
    end
    ylocal=math.floor((flag.y1+flag.y2)/2)
    xlocal=math.floor((flag.x1+flag.x2-8)/2)
    monitor.setCursorPos(xlocal,ylocal)
    for i=1,16 do
      color=bit.blshift(1,i-1)
      if (flag:get(i)) then
        monitor.setBackgroundColor(color)
        monitor.setTextColor(flag.foregroundColor)
        monitor.write(" ")
      else
        monitor.setBackgroundColor(terminalBackground)
        monitor.setTextColor(color)
        monitor.write(".")
      end
      if (i==8) then
        monitor.setCursorPos(xlocal,ylocal+1)
      end
    end
  end

  function flag.onResize(flag)
    flag.sized=true
  end

  return(flag)
end

function newChooser(choice,options)
  chooser=newButton(choice)
  chooser.options=options

  function chooser.choose(chooser)
    if (chooser.tab==nil) then
      chooser:formTab()
    end
    chooser.tab:run()
    redrawNeeded=true
  end

  function chooser.buttonOnClick(button)
    button:blink()
    button.chooser.label=button.label
    button.chooser.tab.quit=true
  end

  function chooser.formTab(chooser)
    chooser.tab=newRow()
    width,height=monitor.getSize()
    buttonsPerColumn=math.floor(height/4)
    numButtons=#(chooser.options)
    numColumns=math.ceil(numButtons/buttonsPerColumn)
    columnNum=1
    rowNum=1
    currentColumn=newColumn()
    for key,option in pairs(chooser.options) do
      if (rowNum>buttonsPerColumn) then
        rowNum=1
        columnNum=columnNum+1
        chooser.tab:add(currentColumn)
        currentColumn=newColumn()
      end
      choiceButton=newButton(option)
      choiceButton.vWeight=.3
      choiceButton.chooser=chooser
      choiceButton.onClick=chooser.buttonOnClick
      currentColumn:add(choiceButton)
      rowNum=rowNum+1
    end
    chooser.tab:add(currentColumn)
  end

  chooser.onClick=chooser.choose
  chooser.tab=nil
  return(chooser)
end

function newProgressBar(max)
  bar=newWidget()
  if (max==nil) then
    bar.max=1.0
  else
    bar.max=max
  end
  bar.value=0
  bar.foreground=defaultProgressBarForeground
  bar.background=defaultProgressBarBackground

  function bar.draw(bar)
    y=math.floor((bar.y1+bar.y2)/2)
    xOn=math.floor(bar.width*bar.value/bar.max)
    xOff=bar.width-xOn
    monitor.setBackgroundColor(bar.foreground)
    monitor.setCursorPos(bar.x1,y)
    monitor.write(string.rep(" ",xOn))
    monitor.setBackgroundColor(bar.background)
    monitor.write(string.rep(" ",xOff))
  end

  function bar.setValue(bar,value)
    bar.value=value
    bar:draw()
  end

  function bar.getValue(bar)
    return(bar.value)
  end

  return(bar)
end