View difference between Paste ID: 5Gt85MDp and 6JsWa9Bj

 --  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