API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Aug 7th, 2013
121
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Lua 68.29 KB | None | 0 0
raw download clone embed print report
  1.  
  2. --# SpecFuncs
  3. function angleOfPoint( pt )
  4.    local x, y = pt.x, pt.y
  5.    local radian = math.atan2(y,x)
  6.    local angle = radian*180/math.pi
  7.    if angle < 0 then angle = 360 + angle elseif angle > 360 then angle = 0 + (angle-360) end
  8.    return angle
  9. end
  10.  
  11. function round(n)
  12.     if n < math.floor(n)+0.5 then
  13.         return math.floor(n)
  14.     elseif n > math.ceil(n)-0.5 then
  15.         return math.ceil(n)
  16.     else
  17.         return math.ceil(n)
  18.     end
  19. end
  20.  
  21. function clamp(x, min, max)
  22.     return math.max(min, math.min(max, x))
  23. end
  24.  
  25. function split(inputstr, sep)
  26.         local t={}
  27.         local i=1
  28.         for str in string.gmatch(inputstr, "([^"..sep.."]+)") do
  29.                 t[i] = str
  30.                 i = i + 1
  31.         end
  32.         return t
  33. end
  34.  
  35. Lines = class()
  36.  
  37.  
  38. function Lines:init(pos1,pos2,strok,col)
  39.     self.m = mesh()
  40.     local c = col or 255
  41.     self.p = (pos1+pos2)
  42.     self.pl = (pos1-pos2)
  43.     self.dir = self.pl:normalize()
  44.     self.len = self.pl:len()
  45.     self.strok = strok
  46.     self.p = self.p/2
  47.     self.r = self.m:addRect(self.p.x,self.p.y,self.len,strok,angleOfPoint(self.dir)/57.3)
  48.     self.m:setColors(c,c,c,255)
  49. end
  50.  
  51. function Lines:setPos(pos1,pos2)
  52.     self.p = (pos1+pos2)
  53.     self.pl = (pos1-pos2)
  54.     self.dir = self.pl:normalize()
  55.     self.len = self.pl:len()
  56.     self.p = self.p/2
  57.     self.m:setRect(self.r,self.p.x,self.p.y,self.len,self.strok,angleOfPoint(self.dir)/57.3)
  58. end
  59.  
  60.  
  61. function Lines:draw()
  62.     self.m:draw()
  63. end
  64.  
  65. function Lines:touched(touch)
  66.     -- Codea does not automatically call this method
  67. end
  68.  
  69. Tblines = class()
  70.  
  71. function Tblines:init(v,col,width)
  72.     self.m = mesh()
  73.     self.r = {}
  74.     self.width = width
  75.     local c = col or 255
  76.     for i=2,#v do
  77.             self.p = (v[i]+v[i-1])
  78.             self.p2 = (v[i]-v[i-1])
  79.             self.dir = self.p2:normalize()
  80.             self.len = self.p2:len()
  81.             self.p = self.p/2
  82.        
  83.             local img = image(self.len*2,width*2)
  84.             setContext(img)
  85.                 pushStyle()
  86.                     strokeWidth(width*2)
  87.                     lineCapMode(ROUND)
  88.                     line(0,width,self.len*2,width)
  89.                 popStyle()
  90.             setContext()
  91.             self.r[i] = self.m:addRect(self.p.x,self.p.y,self.len+width,
  92.             width,angleOfPoint(self.dir)/57.3)
  93.             self.m.texture = img  
  94.             self.m:setColors(c,c,c,255)
  95.        
  96.     end
  97. end
  98.  
  99. function Tblines:setCol(col)
  100.     self.m:setColors(col.r,col.g,col.b,col.a or 255)
  101. end
  102.  
  103. function Tblines:setPos(v)
  104.     for i=2,#v do
  105.         self.p = (v[i]+v[i-1])
  106.         self.p2 = (v[i]-v[i-1])
  107.         self.dir = self.p2:normalize()
  108.         self.len = self.p2:len()+self.width
  109.         self.p = self.p/2
  110.         self.m:setRect(self.r[i],self.p.x,self.p.y,self.len,self.width,angleOfPoint(self.dir)/57.3)
  111.     end
  112. end
  113.  
  114. function Tblines:draw()
  115.     self.m:draw()
  116. end
  117.  
  118. function Tblines:touched(touch)
  119.     -- Codea does not automatically call this method
  120. end
  121.  
  122. function roundRect(x,y,w,h,r)
  123.     pushStyle()
  124.     local eM = ellipseMode() -- The previous mode, this is so not to disrupt other ellipses
  125.     local rM = rectMode()
  126.     if rectMode() == CORNERS then
  127.         w = (w - x)
  128.         h = (h - y)
  129.     elseif rectMode() == CENTER then
  130.         x = x - w / 2
  131.         y = y - h / 2
  132.     elseif rectMode() == RADIUS then
  133.         x = x - w
  134.         y = y - h
  135.         w = w * 2
  136.         h = h * 2
  137.     end
  138.     ellipseMode(RADIUS)
  139.     rectMode(CORNER)
  140.     clip(x, y + r, w, h - r * 2); rect(x, y, w, h) -- Left and Right
  141.     clip(x + r, y, w - r * 2, h); rect(x, y, w, h) -- Top and Bottom
  142.     strokeWidth(strokeWidth() - 1) -- Necessary because without it the ellipse looks too big
  143.     clip(x, y, r, r); ellipse(x + r - 1, y + r - 1, r) -- Bottom Left
  144.     clip(x, y + h - r, r, r); ellipse(x + r - 1, y + h - r + 1, r) -- Top Left
  145.     clip(x + w - r, y, r, r); ellipse(x + w - r + 1, y + r - 1, r) -- Bottom Right
  146.     clip(x + w - r, y + h - r, r, r); ellipse(x + w - r + 1, y + h - r + 1, r) -- Top
  147.     strokeWidth(strokeWidth() + 1) -- Make everything normal again
  148.     clip()
  149.     ellipseMode(eM)
  150.     rectMode(rM)
  151.     popStyle()
  152. end
  153.  
  154.  
  155. --# Main
  156. -- toolbar
  157.  
  158. -- Use this function to perform your initial setup
  159. function setup()
  160.     displayMode(FULLSCREEN)
  161.     frame = Frame(vec2(WIDTH/1.5,HEIGHT/1.7),vec2(600,450),"Colour Window",150)
  162.     frame:isCloseable(true)
  163.     --Button command: Button(Position,Size,Text,Colour,BorderWidth,CallBack)
  164.     var1 = "Press Me"
  165.     sizevar = 10
  166.     btn = Button(vec2(WIDTH/2,HEIGHT/2-20),vec2(100,45),var1,
  167.     color(252, 7, 139, 255),function() sizevar = math.random(0,40) end,true)
  168.     --btn:strokeCol(color(220,220,220,255))
  169.     btn:addParent(frame)
  170.     btn2 = Button(vec2(WIDTH/2,HEIGHT/2+28),vec2(100,45),var1,
  171.     color(251, 83, 7, 255),function()
  172.         alpha = 255
  173.     end)
  174.     btn2:addParent(frame)
  175.     var = 3
  176.     --Slider command: Slider(Position,Size,StartValue,EndValue,Value)
  177.     sldr = Slider(vec2(WIDTH/2,300),vec2(150,15),10,500,var,"Slider:")
  178.     sldr:addParent(frame)
  179.     sldr:isVisible(true)
  180.     var2 = 0
  181.     --Toggle command: Toggle(Position,Size,Value) , Toggle Value: Toggle:getValue()
  182.     tog = Toggle(vec2(WIDTH/2,HEIGHT/2+100),vec2(75,30),var2)
  183.     tog:addParent(frame)
  184.     --Dial command: Dial(Position,Size,StartVal,EndVal,Value) , Dial Value: Dial:getValue()
  185.     dial = Dial(vec2(WIDTH/2,HEIGHT/2+180),65,0,20,10)
  186.     dial:addParent(frame)
  187.     dial:setFloat(0)
  188.     --Drop Down Menu command: DMenu(Position,Size) , DMenu item: DMenu:addItem(Name,Callback)
  189.     dropd = DMenu(vec2(WIDTH/2+200,HEIGHT/2-30),vec2(150,30),"Rect Colour")
  190.     dropd:addParent(frame)
  191.     dropd:addItem("Orange",function() colour = color(255,100,0) end)
  192.     dropd:addItem("Yellow",function() colour = color(255,255,0) end)
  193.     dropd:addItem("Red",function() colour = color(255,0,0) end)
  194.     dropd:addItem("Green",function() colour = color(0,255,0) end)
  195.     dropd:addItem("Cyan",function() colour = color(0,255,255) end)
  196.     dropd:addItem("Blue",function() colour = color(0,0,255) end)
  197.     dropd:addItem("Purple",function() colour = color(200,0,255) end)
  198.     dropd:addItem("Pink",function() colour = color(255,0,220) end)
  199.     dropd:addItem("Black",function() colour = color(0,0,0) end)
  200.     dropd:addItem("White",function() colour = color(255,255,255) end)
  201.        
  202.     var3 = 0
  203.     --Radio Button command: Radio(Position,Size) , Radio Value (On/Off): Radio:getValue()
  204.     rad = Radio(vec2(WIDTH/2+320,HEIGHT/2+230),30,"Radio Button",var3)
  205.     rad:addParent(frame)
  206.     --Colour Picker command: Colour(Position) , Colour Value: Colour:getValue()
  207.     col = Colour(vec2(WIDTH/2+200,HEIGHT/2+100))
  208.     col:addParent(frame)
  209.     colour = color(255,255,255,255)
  210.     scolour = color(255,255,255,255)
  211.     --Combo Box (Combox) command: Combox(Position,Size)
  212.     --Combox item: Combox:addItem(name,callback)
  213.     combobox = Combox(vec2(WIDTH/2+375,HEIGHT/2+20),vec2(130,300),"Colour Combo Box")
  214.     combobox:addParent(frame)
  215.     combobox:addItem("Orange",function() scolour = color(255,100,0) end)
  216.     combobox:addItem("Yellow",function() scolour = color(255,255,0) end)
  217.     combobox:addItem("Red",function() scolour = color(255,0,0) end)
  218.     combobox:addItem("Green",function() scolour = color(0,255,0) end)
  219.     combobox:addItem("Cyan",function() scolour = color(0,255,255) end)
  220.     combobox:addItem("Blue",function() scolour = color(0,0,255) end)
  221.     combobox:addItem("Purple",function() scolour = color(200,0,255) end)
  222.     combobox:addItem("Pink",function() scolour = color(255,0,220) end)
  223.     combobox:addItem("Black",function() scolour = color(0,0,0) end)
  224.     combobox:addItem("White",function() scolour = color(255,255,255) end)
  225.        
  226.    
  227.     textbox = TextBox(vec2(WIDTH/2+200,HEIGHT/2-130),vec2(140,30),color(0,0,0),15,"Testing Text","Label")
  228.     textbox:addParent(frame)
  229.     textbox:setMode(CENTER)
  230.          
  231.     progvar = 57
  232.     --Progress Bar (Progbar) command: Progbar(Position,Size,Value,ColourA,ColourB)
  233.     --Set Progress Bar start value: Progbar:setStart(Number)
  234.     --Set Progress Bar end value: Progbar:setEnd(Number)
  235.     progb = Progbar(vec2(WIDTH/2+200,300),vec2(125,15),progvar,color(100,100,100,255),
  236.     color(255,50,50,150),"Alpha Progress Bar")
  237.     progb:addParent(frame)
  238.     progb:setStart(0)
  239.     progb:setEnd(255)
  240.     alpha = 0
  241. end
  242.  
  243. function keyboard(k)
  244.     textbox:keyboard(k)
  245. end
  246.  
  247. function touched(t)
  248.     frame:touched(t)
  249.     btn:touched(t)
  250.     sldr:touched(t)
  251.     tog:touched(t)
  252.     dial:touched(t)
  253.     dropd:touched(t)
  254.     rad:touched(t)
  255.     col:touched(t)
  256.     combobox:touched(t)
  257.     btn2:touched(t)
  258.     textbox:touched(t)
  259. end
  260. -- This function gets called once every frame
  261. function draw()
  262.     -- This sets a dark background color
  263.     background(40, 40, 50,255)
  264.     -- Do your drawing here
  265.     pushStyle()
  266.     fill(255)
  267.     text("FPS: "..1/DeltaTime,100,100)
  268.     popStyle()
  269.     if col:isTouching() then
  270.         colour = col:getValue()
  271.     end
  272.     if col:isTouchingAlpha() then
  273.         alpha = col.alpha
  274.     end
  275.    
  276.     if sldr:isMoving() then
  277.         colour.a = sldr:getValue()*40
  278.     end
  279.     pushStyle()
  280.     strokeWidth(5)
  281.     stroke(scolour.r,scolour.g,scolour.b,rad:getValue()*255)
  282.     fill(colour.r,colour.g,colour.b,alpha*tog:getValue())
  283.     rect(WIDTH/2+150,200,60+dial:getValue()*4+sizevar,60+dial:getValue()*4+sizevar)
  284.     popStyle()
  285.     frame:draw()
  286.     btn:draw()
  287.     sldr:draw()
  288.     tog:draw()
  289.     dial:draw()
  290.     progb:draw()
  291.     progb:setValue(alpha)
  292.     dropd:draw()
  293.     rad:draw()
  294.     btn2:draw()
  295.     col:draw()
  296.     combobox:draw()
  297.     textbox:draw()
  298. end
  299.  
  300. --# Frame
  301. Frame = class()
  302.  
  303. function Frame:init(pos,size,txt,grey)
  304.     self.pos = pos
  305.     self.size = size
  306.     self.oldscl = vec2()
  307.     self.oldpos = vec2()
  308.     self.scl = size
  309.     self.spos = vec2()
  310.     self.txt = txt
  311.     self.grey = grey
  312.     self.closeable = false
  313.     self.moveable = true
  314.     self.m = mesh()
  315.     self.r = self.m:addRect(pos.x,pos.y,size.x,size.y)
  316.     local img = image(size.x,size.y)
  317.     setContext(img)
  318.         pushStyle()
  319.         fill(255,255)
  320.         roundRect(0,0,size.x,size.y,10)
  321.         popStyle()
  322.     setContext()
  323.     self.m.texture = img
  324.     self.m:setColors(grey,grey,grey,255)
  325.  
  326.     self.t = mesh()
  327.     self.tr = self.t:addRect(pos.x,pos.y+size.y/2-20,size.x,40)
  328.     local img = image(size.x,40)
  329.     setContext(img)
  330.         pushStyle()
  331.         fill(170,255)
  332.         roundRect(0,-40,size.x,80,10)
  333.         textMode(CORNER)
  334.         fontSize(15)
  335.         fill(0)
  336.         text(self.txt,15,10)
  337.         popStyle()
  338.     setContext()
  339.     self.t.texture = img
  340.     self.t:setColors(grey,grey,grey,255)
  341.     self.holding = nil
  342.     self.hpos = vec2()
  343.     self.state = "open"
  344.     self.oc = false
  345.     self.children = {}
  346. end
  347.  
  348. function Frame:isCloseable(bool)
  349.     self.closeable = bool
  350. end
  351.  
  352. function Frame:isMoveable(bool)
  353.     if bool == true or bool == false then
  354.         self.moveable = bool
  355.     end
  356. end
  357.  
  358. function Frame:getPos()
  359.     return self.pos
  360. end
  361.  
  362. function Frame:isHolding()
  363.     return self.holding ~= nil
  364. end
  365.  
  366. function Frame:draw()
  367.     local pos = self.pos
  368.     local size = self.size
  369.     if self.holdingscl then
  370.         self.size = self.scl
  371.         self.t:setRect(self.tr,pos.x,pos.y+size.y/2-20,size.x,40)
  372.         self.m:setRect(self.r,pos.x,pos.y,size.x,size.y)
  373.     end
  374.     local t = self.holding
  375.     if t ~= nil then
  376.         self.pos = vec2(t.x,t.y)+self.hpos
  377.         pos = self.pos
  378.         self.t:setRect(self.tr,pos.x,pos.y+size.y/2-20,size.x,40)
  379.         self.m:setRect(self.r,pos.x,pos.y,size.x,size.y)
  380.     end
  381.     if self.state == "open" then
  382.         self.m:draw()
  383.     end
  384.     self.t:draw()
  385.     if self.closeable then
  386.     pushStyle()
  387.     strokeWidth(6)
  388.     if self.minimizing then
  389.         stroke(150)
  390.     else
  391.         stroke(255)
  392.     end
  393.     line(pos.x+size.x/2-35,pos.y+size.y/2-20,pos.x+size.x/2-20,pos.y+size.y/2-20)
  394.     popStyle()
  395.     end
  396. end
  397.  
  398. function Frame:addChild(ch)
  399.     table.insert(self.children,ch)
  400. end
  401.  
  402. function Frame:getChildren()
  403.     return self.children
  404. end
  405.  
  406. function Frame:touched(t)
  407.     local p,s = self.pos,self.size
  408.     local p2,s2 = vec2(p.x,p.y+s.y*0.45),vec2(s.x,(s.y/2)*0.2)
  409.     if self.moveable and t.state == BEGAN and t.x < p.x+s.x/2 and t.x > p.x-s.x/2 and t.y < p2.y+s2.y/2 and t.y > p2.y-s2.y/2 then
  410.         self.holding = t
  411.         self.hpos = self.pos-vec2(t.x,t.y)
  412.     elseif t.state == MOVING and self.holding ~= nil then
  413.         self.holding = t
  414.     elseif t.state == ENDED and self.holding ~= nil then
  415.         self.holding = nil
  416.     end
  417.     if t.state == BEGAN and self.closeable and t.x < p.x+s.x/2-5 and t.x > p.x+s.x/2-40 and t.y > p.y+s.y/2-35 and t.y < p.y+s.y/2 then
  418.         self.minimizing = true
  419.     end
  420.     if t.state == ENDED and self.minimizing == true then
  421.         if self.state == "open" then
  422.             for k,v in pairs(self.children) do
  423.                 v:isVisible(false)
  424.             end
  425.             self.state = "closed"
  426.         elseif self.state == "closed" then
  427.             for k,v in pairs(self.children) do
  428.                 v:isVisible(true)
  429.                 v.pos = self.pos-v.ppos
  430.             end
  431.             self.state = "open"
  432.         end
  433.         self.minimizing = false
  434.     end
  435. end
  436.  
  437. --# Button
  438. Button = class()
  439.  
  440. function Button:init(pos,size,txt,col,callback,...)
  441.     if ... then
  442.         if ... == true then
  443.             self.invert = ...
  444.         else
  445.             self.invert = color(...,...,...,255)
  446.         end
  447.     else
  448.         self.invert = false
  449.     end
  450.     -- you can accept and set parameters here
  451.     self.m = mesh()
  452.     self.r = self.m:addRect(pos.x,pos.y,size.x,size.y)
  453.     self.m:setColors(col)
  454.    
  455.     self.t = mesh()
  456.     self.tr = self.t:addRect(pos.x,pos.y,size.x,size.y)
  457.     self.oldcol = col
  458.     self.col = color(col.r-50,col.g-50,col.b-50)
  459.     if self.invert then
  460.         self.t.shader = shader("Basic:Invert")    
  461.     end
  462.     self.txtt = image(size.x,size.y)
  463.     setContext(self.txtt)
  464.         pushStyle()
  465.         font("AmericanTypewriter-Bold")
  466.         fontSize(15)
  467.         textAlign(CENTER)
  468.         if self.invert == true then
  469.             fill(self.oldcol)
  470.         elseif self.invert ~= false then
  471.             fill(self.invert)
  472.         else
  473.             fill(50,255)
  474.         end
  475.         textWrapWidth(size.x)
  476.         text(txt,size.x/2,size.y/2)
  477.         popStyle()
  478.     setContext()
  479.     self.t.texture = self.txtt
  480.    
  481.    
  482.     self.pos = pos
  483.     self.txt = txt
  484.     self.holding = 0
  485.     self.cb = callback
  486.    
  487.     self.size = size
  488.     strok = 5
  489.     self.strok = strok
  490.     if strok ~= nil then
  491.         self.v = {}
  492.         self.v[1] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2)
  493.         self.v[2] =  vec2(self.pos.x+self.size.x/2,self.pos.y+self.size.y/2)
  494.         self.v[3] =  vec2(self.pos.x+self.size.x/2,self.pos.y-self.size.y/2)
  495.         self.v[4] =  vec2(self.pos.x-self.size.x/2,self.pos.y-self.size.y/2)
  496.         self.v[5] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2)
  497.     end
  498.     self.lines = Tblines(self.v,220,5)
  499.     self.oldpos = self.pos
  500.     self.ppos = vec2()
  501.     self.parent = nil
  502.     self.viscol = color(0,0,0,0)
  503.     self.visible = true
  504.     self.strokcol = color(220,220,220,255)
  505. end
  506.  
  507. function Button:isVisible(bool)
  508.     if bool == false then
  509.         self.visible = false
  510.     elseif bool == true then
  511.         self.visible = true
  512.     end
  513. end
  514.  
  515. function Button:strokeCol(col)
  516.     self.lines:setCol(col)
  517.     self.strokcol = col
  518. end
  519.  
  520. function Button:setAlpha(a)
  521.     self.m:setColors(self.oldcol.r,self.oldcol.g,self.oldcol.b,a)
  522.     self.t:setColors(255,255,255,a)
  523.     self.lines:setCol(color(self.strokcol.r,self.strokcol.g,self.strokcol.b,a))
  524. end
  525.  
  526. function Button:visible()
  527.     return self.visible
  528. end
  529.  
  530. function Button:addParent(par)
  531.     if par ~= nil then
  532.         self.parent = par
  533.         self.ppos = par:getPos()-self.oldpos
  534.         par:addChild(self)
  535.     end
  536. end
  537.  
  538. function Button:setPos(pos)
  539.     --self.pos = pos
  540.     self.v[1] =  vec2(pos.x-self.size.x/2,pos.y+self.size.y/2)
  541.     self.v[2] =  vec2(pos.x+self.size.x/2,pos.y+self.size.y/2)
  542.     self.v[3] =  vec2(pos.x+self.size.x/2,pos.y-self.size.y/2)
  543.     self.v[4] =  vec2(pos.x-self.size.x/2,pos.y-self.size.y/2)
  544.     self.v[5] =  vec2(pos.x-self.size.x/2,pos.y+self.size.y/2)
  545.     self.m:setRect(self.r,pos.x,pos.y,self.size.x,self.size.y)
  546.     self.t:setRect(self.tr,pos.x,pos.y,self.size.x,self.size.y)
  547.     self.lines:setPos(self.v)
  548. end
  549.  
  550. function Button:draw()
  551.     if self.parent then
  552.         if self.parent:isHolding() then
  553.             self.pos = self.parent:getPos()-self.ppos
  554.             self.v[1] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2)
  555.             self.v[2] =  vec2(self.pos.x+self.size.x/2,self.pos.y+self.size.y/2)
  556.             self.v[3] =  vec2(self.pos.x+self.size.x/2,self.pos.y-self.size.y/2)
  557.             self.v[4] =  vec2(self.pos.x-self.size.x/2,self.pos.y-self.size.y/2)
  558.             self.v[5] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2)
  559.             self.m:setRect(self.r,self.pos.x,self.pos.y,self.size.x,self.size.y)
  560.             self.t:setRect(self.tr,self.pos.x,self.pos.y,self.size.x,self.size.y)
  561.             self.lines:setPos(self.v)
  562.         end
  563.     end
  564.     if self.visible == false then return end
  565.     self.m:draw()
  566.     self.t:draw()
  567.     self.lines:draw()
  568.    
  569. end
  570.  
  571. function Button:touched(t)
  572.     if self.visible == false then return end
  573.     if t.state == BEGAN and t.x < (self.pos.x+self.size.x/2) and t.x >  (self.pos.x-self.size.x/2)
  574.     and t.y >  (self.pos.y-self.size.y/2) and t.y < (self.pos.y+self.size.y/2) then
  575.         self.m:setColors(self.col)
  576.         self.cb()
  577.         self.holding = 1
  578.     end
  579.    
  580.     if t.state == ENDED and self.holding == 1 then
  581.         self.m:setColors(self.oldcol)
  582.         self.holding = 0
  583.     end
  584. end
  585.  
  586.  
  587.  
  588. --# Slider
  589. Slider = class()
  590.  
  591. function Slider:init(pos,size,startval,endval,value,...)
  592.     if ... then
  593.         self.label = ...
  594.     end
  595.     self.pos = pos
  596.     self.ballpos = vec2(pos.x-size.x/2+((value-startval)/(endval-startval))*size.x,pos.y)
  597.     self.val = clamp(value,startval,endval)
  598.     self.size = size
  599.     self.endval = endval
  600.     self.startval = startval
  601.     self.m = mesh()
  602.     self.r = self.m:addRect(pos.x,pos.y,size.x,size.y)
  603.     self.m:setColors(120,120,120,255)
  604.     self.col = color(120,120,120,255)
  605.     self.t = mesh()
  606.     self.ballsize = size:len()/6
  607.     self.ballsize = clamp(self.ballsize,size.y+5,40)
  608.     self.lball = self.ballpos - pos
  609.     self.tr = self.t:addRect(pos.x,pos.y,self.ballsize,self.ballsize)
  610.     self.t.texture = readImage("Documents:slider")
  611.     self.t:setColors(255,255,255,255)
  612.     self.holding = 0
  613.     self.oldpos = self.pos
  614.     self.ppos = vec2()
  615.     self.parent = nil
  616.     self.prevval = 0
  617.     self.viscol = color(0,0,0,0)
  618.     self.oldcol = self.col
  619.     self.visible = true
  620.     self.fillcol = color(0,0,0,255)
  621.     self.showval = true
  622. end
  623.  
  624. function Slider:setLabel(txt)
  625.     self.label = txt or ""
  626. end
  627.  
  628. function Slider:isVisible(bool)
  629.     if bool == false then
  630.         self.visible = false
  631.     elseif bool == true then
  632.         self.visible = true
  633.     end
  634. end
  635.  
  636. function Slider:showValue(bool)
  637.     if bool == false then
  638.         self.showval = false
  639.     elseif bool == true then
  640.         self.showval = true
  641.     end
  642. end
  643.  
  644. function Slider:setColour(col)
  645.     self.m:setColors(col.r,col.g,col.b,col.a or 255)
  646.     self.oldcol = col
  647.     self.t:setColors(255,255,255,col.a)
  648. end
  649.  
  650. function Slider:setPos(pos)
  651.     self.pos = pos
  652.     local p,s = self.pos,self.size
  653.     local value,startval,endval = self.val,self.startval,self.endval
  654.     self.m:setRect(self.r,self.pos.x,self.pos.y,self.size.x,self.size.y)
  655.     self.ballpos = vec2(p.x-s.x/2+((value-startval)/
  656.             (endval-startval))*s.x,p.y)
  657.     self.t:setRect(self.tr,self.ballpos.x,self.ballpos.y,self.ballsize,self.ballsize)        
  658. end
  659.  
  660. function Slider:addParent(par)
  661.     if par ~= nil then
  662.         self.parent = par
  663.         self.ppos = par:getPos()-self.oldpos
  664.         par:addChild(self)
  665.     end
  666. end
  667.  
  668. function Slider:draw()
  669.    
  670.     local pos,size,value,startval,endval = self.pos,self.size,self.val,
  671.             self.startval,self.endval
  672.     if self.parent then
  673.         if self.parent:isHolding() then
  674.             self.pos = self.parent:getPos()-self.ppos
  675.             self.m:setRect(self.r,self.pos.x,self.pos.y,self.size.x,self.size.y)
  676.             self.ballpos = vec2(pos.x-size.x/2+((value-startval)/
  677.             (endval-startval))*size.x,pos.y)
  678.         end
  679.     end
  680.     local size = self.size
  681.     local pos = self.pos
  682.     self.ballpos.x = clamp(self.ballpos.x,pos.x-size.x/2,pos.x+size.x/2)
  683.     self.ballpos.y = pos.y
  684.     if self.visible == false then return end
  685.     self.m:draw()
  686.     self.t:setRect(self.tr,self.ballpos.x,self.ballpos.y,self.ballsize,self.ballsize)
  687.     self.t:draw()
  688.     pushStyle()
  689.     fill(self.fillcol.r,self.fillcol.g,self.fillcol.b,self.fillcol.a)
  690.     fontSize(13)
  691.     textWrapWidth(self.size.x)
  692.     if type(self.val) == "number" and self.showval then
  693.         self.val = clamp(self.val,self.startval,self.endval)
  694.         self.val = round(self.val)
  695.         if self.val ~= nil then
  696.             text("Value: "..self.val,self.pos.x,self.pos.y-self.size.y/2-10)
  697.         else
  698.             text("Value: ",self.pos.x,self.pos.y-self.size.y/2-10)
  699.         end
  700.     end
  701.     popStyle()
  702.     if self.label then
  703.         pushStyle()
  704.             textMode(CORNER)
  705.             fontSize(15)
  706.             fill(self.fillcol.r,self.fillcol.g,self.fillcol.b,self.fillcol.a)
  707.             text(self.label,pos.x-size.x/2,pos.y+size.y/2+4)
  708.         popStyle()
  709.     end
  710. end
  711.  
  712. function Slider:isMoving()
  713.     local val = self.changed
  714.     self.changed = false
  715.     return val
  716. end
  717.  
  718. function Slider:getValue()
  719.     if self.val ~= nil and type(self.val) == "number" then
  720.         --return clamp(self.val,self.startval,self.endval)
  721.         return round(self.val)
  722.     end
  723. end
  724.  
  725. function Slider:touched(t)
  726.     if self.visible == false then return end
  727.     if t.state == BEGAN and self.holding == 0 and vec2(t.x,t.y):dist(self.ballpos) < self.size:len()/8 then
  728.         self.holding = 1
  729.     end
  730.     if self.holding == 1 then
  731.         self.ballpos = vec2(clamp(t.x,self.pos.x-self.size.x/2,self.pos.x+self.size.x/2),self.pos.y)
  732.         self.lball = self.pos-self.ballpos+vec2(self.size.x/2,0)
  733.         self.lball.x = self.size.x-self.lball.x
  734.         self.lball.x = math.max(self.lball.x,1)
  735.     --self.val = ((self.endval-self.startval)/2+(self.endval-
  736.     --self.startval)*(self.ballpos.x-self.pos.x)/self.size.x+self.startval)
  737.         self.val = (self.endval-self.startval)*((self.lball.x/self.size.x))+self.startval
  738.         if round(self.val) ~= self.prevval then
  739.             self.changed = true
  740.         else
  741.             self.changed = false
  742.         end
  743.         self.prevval = round(self.val)
  744.     end
  745.     if t.state == ENDED then
  746.         self.holding = 0
  747.     end
  748. end
  749.  
  750. --# TextBox
  751. TextBox = class()
  752.  
  753. function TextBox:init(pos,size,col,fontsize,txt,...)
  754.     if ... then self.label = ... end
  755.     self.pos = pos
  756.     self.size = size
  757.     self.fontsize = clamp(fontsize,5,size.y/1.5)
  758.     self.m = mesh()
  759.     self.r = self.m:addRect(pos.x,pos.y,size.x,size.y)
  760.     self.m:setColors(200,200,200)
  761.     self.col = col
  762.     self.oldcol = col
  763.     self.txt = txt
  764.     self.startertxt = txt
  765.     self.v = {}
  766.     self.v[1] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2)
  767.     self.v[2] =  vec2(self.pos.x+self.size.x/2,self.pos.y+self.size.y/2)
  768.     self.v[3] =  vec2(self.pos.x+self.size.x/2,self.pos.y-self.size.y/2)
  769.     self.v[4] =  vec2(self.pos.x-self.size.x/2,self.pos.y-self.size.y/2)
  770.     self.v[5] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2)
  771.     self.lines = Tblines(self.v,170,5)
  772.     self.oldpos = self.pos
  773.     self.ppos = vec2()
  774.     self.parent = nil
  775.     self.entered = false
  776.     self.mode = CORNER
  777.     self.editing = false
  778.     self.viscol = color(0,0,0,0)
  779.     self.visible = true
  780.     self.strokcol = color(170,255)
  781. end
  782.  
  783. function TextBox:setMode(mode)
  784.     self.mode = mode
  785. end
  786.  
  787. function TextBox:setDimensions(pos,size)
  788.     self.pos = pos
  789.     pushStyle()
  790.     fontSize(self.fontsize)
  791.     textMode(self.mode)
  792.     textWrapWidth(size.x)
  793.     local w,h = textSize(self.txt)
  794.     if h < size.y then
  795.         self.size = size
  796.     end
  797.     self.size.x = clamp(self.size.x,5,self.size.x+1)
  798.     popStyle()
  799.     self.v[1] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2)
  800.     self.v[2] =  vec2(self.pos.x+self.size.x/2,self.pos.y+self.size.y/2)
  801.     self.v[3] =  vec2(self.pos.x+self.size.x/2,self.pos.y-self.size.y/2)
  802.     self.v[4] =  vec2(self.pos.x-self.size.x/2,self.pos.y-self.size.y/2)
  803.     self.v[5] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2)
  804.     self.lines:setPos(self.v)
  805.     self.m:setRect(self.r,self.pos.x,self.pos.y,self.size.x,self.size.y)
  806. end
  807.  
  808. function TextBox:getDimensions()
  809.     local tbl = {}
  810.     tbl.size = self.size
  811.     tbl.pos = self.pos
  812.     return tbl
  813. end
  814.  
  815. function TextBox:setFont(fontsize)
  816.     self.fontsize = fontsize
  817. end
  818.  
  819. function TextBox:startTyping()
  820.     self.editing = true showKeyboard()
  821. end
  822.  
  823. function TextBox:isTyping()
  824.     return self.editing
  825. end
  826.  
  827. function TextBox:isFinished()
  828.     local se = self.entered
  829.     self.entered = false
  830.     return se
  831. end
  832.  
  833. function TextBox:setAlpha(a)
  834.     self.lines:setCol(color(self.strokcol.r,self.strokcol.g,self.strokcol.b,a))
  835.     self.m:setColors(200,200,200,a)
  836. end
  837.  
  838. function TextBox:strokeCol(col)
  839.     self.lines:setCol(col)
  840.     self.strokcol = col
  841. end
  842.  
  843. function TextBox:isVisible(bool)
  844.     if bool == false then
  845.         self.visible = false
  846.     elseif bool == true then
  847.         self.visible = true
  848.     end
  849. end
  850.  
  851. function TextBox:visible()
  852.     return self.visible
  853. end
  854.  
  855. function TextBox:addParent(par)
  856.     if par ~= nil then
  857.         self.parent = par
  858.         self.ppos = par:getPos()-self.oldpos
  859.         par:addChild(self)
  860.     end
  861. end
  862.  
  863.  
  864. function TextBox:setText(txt)
  865.     self.txt = txt
  866. end
  867.  
  868. function TextBox:getText()
  869.     return self.txt
  870. end
  871.  
  872. function TextBox:draw()
  873.  
  874.     if self.parent then
  875.         if self.parent:isHolding() then
  876.             self.pos = self.parent:getPos()-self.ppos
  877.             self.v[1] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2)
  878.             self.v[2] =  vec2(self.pos.x+self.size.x/2,self.pos.y+self.size.y/2)
  879.             self.v[3] =  vec2(self.pos.x+self.size.x/2,self.pos.y-self.size.y/2)
  880.             self.v[4] =  vec2(self.pos.x-self.size.x/2,self.pos.y-self.size.y/2)
  881.             self.v[5] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2)
  882.             self.lines:setPos(self.v)
  883.             self.m:setRect(self.r,self.pos.x,self.pos.y,self.size.x,self.size.y)
  884.         end
  885.     end  
  886.     if self.visible == false then return end
  887.     self.m:draw()
  888.     self.lines:draw()
  889.     local p,s = self.pos,self.size
  890.     pushStyle()
  891.         textWrapWidth(s.x)
  892.         textMode(self.mode)
  893.         if self.fontsize ~= nil then
  894.             fontSize(self.fontsize)
  895.         end
  896.         if self.editing then
  897.             fill(self.col.r,self.col.g,self.col.b,math.sin(ElapsedTime*10)*100+155)
  898.         else
  899.             fill(self.col)
  900.         end
  901.         if self.mode == CORNER then
  902.             text(self.txt,p.x-s.x/2+4,p.y-self.fontsize/2)
  903.         else
  904.             text(self.txt,p.x,p.y)
  905.         end
  906.         textMode(CORNER)
  907.         if self.label then
  908.             fill(0,255)
  909.             text(self.label,p.x-s.x/2+2,p.y+s.y/2+5)
  910.         end
  911.     popStyle()
  912.     if isKeyboardShowing() == false and self.editing == true then
  913.         self.editing = false
  914.         self.entered = true
  915.         if self.txt == self.startertxt then
  916.             self.txt = ""
  917.         end
  918.     end
  919. end
  920.  
  921.  
  922. function TextBox:touched(t)
  923.     if self.visible == false then return end
  924.     local p,s = self.pos,self.size
  925.     if t.x > p.x-s.x/2 and t.x < p.x+s.x/2 and t.y < p.y+s.y/2 and t.y > p.y-s.y/2 then
  926.         if t.state == BEGAN and self.editing == false then
  927.             if self.txt == self.startertxt then
  928.                 self.txt = ""
  929.             end
  930.             self.editing = true showKeyboard()
  931.         elseif t.state == BEGAN and self.editing == true then
  932.             self.editing = false hideKeyboard()
  933.             self.entered = true
  934.         end
  935.     end
  936. end
  937.  
  938. function TextBox:keyboard(k)
  939.     if k == "\n" then
  940.         self.editing = false
  941.         hideKeyboard()
  942.         self.entered = true
  943.         if self.txt == self.startertxt then
  944.             self.txt = ""
  945.         end
  946.         return
  947.     end
  948.     self.txt = self.txt..k
  949.     if self.txt == self.startertxt or string.sub(self.txt,1,self.txt:len()-1) == self.startertxt then
  950.         self.txt = k or ""
  951.     end
  952.     if k == BACKSPACE then
  953.         self.txt = string.sub(self.txt,1,self.txt:len()-1)
  954.     end
  955. end
  956.  
  957. --# Toggle
  958. Toggle = class()
  959.  
  960. function Toggle:init(pos,size,value,...)
  961.     if ... then
  962.         self.label = ...
  963.     end
  964.     self.val = value
  965.     self.nval = value
  966.     self.dir = 0
  967.     self.size = size
  968.     self.pos = pos
  969.     self.tpos = vec2(pos.x-size.x/4,pos.y)
  970.     self.m = mesh()
  971.     self.r = self.m:addRect(pos.x,pos.y,size.x,size.y)
  972.     self.m:setColors(170,170,170,255)
  973.     self.t = mesh()
  974.     self.t.texture = readImage("Documents:slider")
  975.     self.tr = self.t:addRect(self.tpos.x,self.tpos.y,size.x/4,size.y)
  976.     self.t:setColors(100,100,100,255)
  977.         self.v = {}
  978.         self.v[1] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2)
  979.         self.v[2] =  vec2(self.pos.x+self.size.x/2,self.pos.y+self.size.y/2)
  980.         self.v[3] =  vec2(self.pos.x+self.size.x/2,self.pos.y-self.size.y/2)
  981.         self.v[4] =  vec2(self.pos.x-self.size.x/2,self.pos.y-self.size.y/2)
  982.         self.v[5] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2)
  983.         self.lines = Tblines(self.v,220,5)
  984.     self.oldpos = self.pos
  985.     self.ppos = vec2()
  986.     self.parent = nil
  987.     self.viscol = color(0,0,0,0)
  988.     self.oldcol = color(170,170,170,255)
  989.     self.visible = true
  990.     self.strokcol = color(220,220,220,255)
  991. end
  992.  
  993. function Toggle:isVisible(bool)
  994.     if bool == false then
  995.         self.visible = false
  996.     elseif bool == true then
  997.         self.visible = true
  998.     end
  999. end
  1000.  
  1001.  
  1002.  
  1003. function Toggle:strokeCol(col)
  1004.     self.lines:setColour(col)
  1005.     self.strokcol = col
  1006. end
  1007.  
  1008. function Toggle:addParent(par)
  1009.     if par ~= nil then
  1010.         self.parent = par
  1011.         self.ppos = par:getPos()-self.oldpos
  1012.         par:addChild(self)
  1013.     end
  1014. end
  1015.  
  1016.  
  1017. function Toggle:draw()
  1018.    
  1019.     if self.parent then
  1020.         if self.parent:isHolding() then
  1021.             self.pos = self.parent:getPos()-self.ppos
  1022.             self.v[1] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2)
  1023.             self.v[2] =  vec2(self.pos.x+self.size.x/2,self.pos.y+self.size.y/2)
  1024.             self.v[3] =  vec2(self.pos.x+self.size.x/2,self.pos.y-self.size.y/2)
  1025.             self.v[4] =  vec2(self.pos.x-self.size.x/2,self.pos.y-self.size.y/2)
  1026.             self.v[5] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2)
  1027.             self.lines:setPos(self.v)
  1028.             self.m:setRect(self.r,self.pos.x,self.pos.y,self.size.x,self.size.y)
  1029.         end
  1030.     end    
  1031.     if self.val == 1 and self.nval == 0 then
  1032.         self.dir = -0.1
  1033.     elseif self.val == 0 and self.nval == 1 then
  1034.         self.dir = 0.1
  1035.     end
  1036.    
  1037.    
  1038.     if self.dir == -0.1 and self.val > self.nval then
  1039.         self.val = self.val + self.dir
  1040.     elseif self.dir == 0.1 and self.val < self.nval then
  1041.         self.val = self.val + self.dir
  1042.     end
  1043.     if self.val < 0 then self.val = 0 elseif self.val > 1 then self.val = 1 end
  1044.     self.t:setRect(self.tr,self.pos.x-self.size.x/4+(self.size.x/2)*self.val,
  1045.     self.pos.y,self.size.x/1.7,self.size.y+10)
  1046.     if self.visible == false then return end
  1047.     self.m:draw()
  1048.    
  1049.     self.tpos = vec2(self.pos.x-self.size.x/4+(self.size.x/2)*self.val,self.pos.y)
  1050.     pushStyle()
  1051.     fill(0,150,0)
  1052.     text("1",self.pos.x-self.size.x/4,self.pos.y)
  1053.     fill(150,0,0)
  1054.     text("0",self.pos.x+self.size.x/4,self.pos.y)
  1055.     --[[rect(self.pos.x-self.size.x/2,self.pos.y-self.size.y/2,
  1056.     (self.tpos.x-self.size.x/4)-(self.pos.x-self.size.x/2),self.size.y)
  1057.     rect(self.tpos.x+self.size.x/4,self.pos.y-self.size.y/2,
  1058.     (self.pos.x+self.size.x/2)-(self.tpos.x+self.size.x/4),self.size.y)]]
  1059.     popStyle()
  1060.     self.t:draw()
  1061.     self.lines:draw()
  1062.     if self.label then
  1063.         pushStyle()
  1064.             fill(255)
  1065.             fontSize(15)
  1066.             textMode(CORNER)
  1067.             text(self.label,self.pos.x-self.size.x/2,self.pos.y+self.size.y/2+2)
  1068.         popStyle()
  1069.     end
  1070. end
  1071.  
  1072. function Toggle:getValue()
  1073.     return self.val
  1074. end
  1075.  
  1076. function Toggle:touched(t)
  1077.     if self.visible == false then return end
  1078.     local size = self.size
  1079.     local pos = self.pos
  1080.     if t.state == BEGAN and t.x > pos.x-size.x/2 and t.x < pos.x+size.x/2 and t.y > pos.y-size.y/2 and t.y < pos.y+size.y/2 then
  1081.         if self.val == 1 then
  1082.             self.nval = 0
  1083.            
  1084.         end
  1085.         if self.val == 0 then
  1086.             self.nval = 1
  1087.            
  1088.         end
  1089.     end
  1090. end
  1091.  
  1092. --# Dial
  1093. Dial = class()
  1094.  
  1095. function Dial:init(pos,size,startval,endval,value)
  1096.     self.pos = pos
  1097.     self.size = size
  1098.     self.eval = endval
  1099.     self.sval = startval
  1100.     self.val = value
  1101.     self.m = mesh()
  1102.     self.m.texture = readImage("Documents:whitecircle")
  1103.     self.r = self.m:addRect(pos.x,pos.y,size,size)
  1104.     self.m:setColors(170,170,170,255)
  1105.     self.holding = 0
  1106.     self.tp = pos
  1107.     self.float = 0
  1108.     self.hl = Lines(pos,pos,3,220)
  1109.     self.lines = {}
  1110.     local num = endval-startval
  1111.     self.num = num
  1112.  
  1113.     self.txt = image(size,size)
  1114.     self.t = mesh()
  1115.     self.tr = self.t:addRect(pos.x,pos.y,size+35,size+35)
  1116.     for i=0,20 do
  1117.         local mth = ((math.pi*2)/20-((math.pi/20)/(20/2)))*i
  1118.         local p1 = vec2(math.sin(mth)*size/3.5,
  1119.             math.cos(mth)*size/3.5)
  1120.         local p2 = vec2(math.sin(mth)*(size/3.2),
  1121.             math.cos(mth)*(size/3.2))
  1122.         local p3 = vec2(math.sin(mth)*(self.size/2-4),
  1123.         math.cos(mth)*(self.size/2-4))
  1124.         setContext(self.txt)
  1125.             pushStyle()
  1126.                 strokeWidth(2)
  1127.                 stroke(255, 255, 255, 255)
  1128.                 fill(255,255)
  1129.                 fontSize(5)
  1130.                 text(self.sval+((self.eval-self.sval)/20)*i,p3.x+size/2,p3.y+size/2)
  1131.                 line(p1.x+size/2,p1.y+size/2,p2.x+size/2,p2.y+size/2)
  1132.             popStyle()
  1133.         setContext()        
  1134.     end
  1135.     self.t.texture = self.txt
  1136.     self.oldpos = self.pos
  1137.     self.ppos = vec2()
  1138.     self.parent = nil
  1139.     self.viscol = color(0,0,0,0)
  1140.     self.oldcol = color(170,170,170,255)
  1141.     self.fillcol = color(0,0,0,255)
  1142.     self.visible = true
  1143.     self.strokcol = color(220,220,220,255)
  1144. end
  1145.  
  1146. function Dial:isVisible(bool)
  1147.     if bool == false then
  1148.         self.visible = false
  1149.     elseif bool == true then
  1150.         self.visible = true
  1151.     end
  1152. end
  1153.  
  1154. function Dial:addParent(par)
  1155.     if par ~= nil then
  1156.         self.parent = par
  1157.         self.ppos = par:getPos()-self.oldpos
  1158.         par:addChild(self)
  1159.     end
  1160. end
  1161.  
  1162.  
  1163. function Dial:setFloat(n)
  1164.         if n == 1 then
  1165.             self.float = 1
  1166.         elseif n == 0 then
  1167.             self.float = 0
  1168.         else
  1169.             return
  1170.         end
  1171. end
  1172.  
  1173. function Dial:draw()
  1174.     local num = self.num
  1175.     local pos,size = self.pos,self.size
  1176.     if self.parent then
  1177.         if self.parent:isHolding() then
  1178.             self.pos = self.parent:getPos()-self.ppos
  1179.             self.m:setRect(self.r,self.pos.x,self.pos.y,self.size,self.size)
  1180.             self.t:setRect(self.tr,self.pos.x,self.pos.y,self.size+35,self.size+35)
  1181.         end
  1182.     end    
  1183.     if self.visible == false then return end
  1184.     self.m:draw()
  1185.     self.t:draw()
  1186.        
  1187.     pushStyle()
  1188.     fontSize(13)
  1189.     if self.holding == 1 then
  1190.         pushStyle()
  1191.         strokeWidth(3)
  1192.         stroke(255,255)
  1193.         fill(255,0)
  1194.         ellipse(self.pos.x,self.pos.y,self.size/2)
  1195.         ellipse(self.tp.x,self.tp.y,self.size/3)
  1196.         popStyle()
  1197.         self.hl:setPos(self.pos,self.tp)
  1198.         self.hl:draw()
  1199.         local vl
  1200.         local vr
  1201.         if self.float == 0 then
  1202.             vl = (360/(self.num+1))
  1203.             vr = clamp((self.num)-math.floor(angleOfPoint((self.tp-self.pos
  1204.         ):rotate(-math.pi/2))/vl-self.sval),self.sval,self.eval)
  1205.         elseif self.float == 1 then
  1206.             vl = (360/(self.num))
  1207.             vr = clamp((self.num)-math.floor((angleOfPoint((self.tp-self.pos
  1208.         ):rotate(-math.pi/2))/vl-self.sval)*100)/100,self.sval,self.eval)
  1209.             if vr < self.sval+0.1 then
  1210.                 vr = self.sval
  1211.             end
  1212.         end
  1213.         self.val = vr
  1214.     end
  1215.     fill(self.fillcol)
  1216.     text(self.val,self.pos.x,self.pos.y)
  1217.     popStyle()
  1218. end
  1219.  
  1220. function Dial:getValue()
  1221.     return self.val
  1222. end
  1223.  
  1224. function Dial:touched(t)
  1225.     if self.visible == false then return end
  1226.     local tp = vec2(t.x,t.y)
  1227.     if t.state == BEGAN and tp:dist(self.pos) < self.size/2 then
  1228.         self.holding = 1
  1229.         self.tp = tp
  1230.     end
  1231.     if t.state == MOVING then
  1232.         self.tp = tp
  1233.     end
  1234.     if t.state == ENDED then
  1235.         self.tp = self.pos
  1236.         self.holding = 0
  1237.     end
  1238. end
  1239.  
  1240. --# DMenu
  1241. DMenu = class()
  1242.  
  1243. function DMenu:init(pos,size,...)
  1244.     if ... then
  1245.         self.label = ...
  1246.     end
  1247.     self.pos = pos
  1248.     self.size = size
  1249.     self.items = {}
  1250.     self.m = mesh()
  1251.     self.r = self.m:addRect(pos.x,pos.y,size.x,size.y)
  1252.     self.m:setColors(200,200,200,200)
  1253.     self.t = mesh()
  1254.     self.tr = self.t:addRect(pos.x,pos.y,size.x,size.y)
  1255.     self.t:setColors(50,50,50,150)
  1256.     self.expanded = 0
  1257.     self.int = 0
  1258.     self.selected = nil
  1259.     self.snum = 0
  1260.     self.intv = 255/(size.y/2)
  1261.    
  1262.     self.v = {}
  1263.     self.v[1] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2)
  1264.     self.v[2] =  vec2(self.pos.x+self.size.x/2,self.pos.y+self.size.y/2)
  1265.     self.v[3] =  vec2(self.pos.x+self.size.x/2,self.pos.y-self.size.y/2)
  1266.     self.v[4] =  vec2(self.pos.x-self.size.x/2,self.pos.y-self.size.y/2)
  1267.     self.v[5] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2)
  1268.     self.lines = Tblines(self.v,220,5)
  1269.    
  1270.     self.oldpos = self.pos
  1271.     self.ppos = vec2()
  1272.     self.parent = nil
  1273.     self.viscol = color(0,0,0,0)
  1274.     self.oldcol = color(200,200,200,255)
  1275.     self.visible = true
  1276.     self.strokcol = color(220,220,220,255)
  1277. end
  1278.  
  1279. function DMenu:isVisible(bool)
  1280.     if bool == false then
  1281.         self.visible = false
  1282.     elseif bool == true then
  1283.         self.visible = true
  1284.     end
  1285. end
  1286.  
  1287.  
  1288. function DMenu:strokeCol(col)
  1289.     self.lines:setColour(col)
  1290.     self.strokcol = col
  1291. end
  1292.  
  1293. function DMenu:addParent(par)
  1294.     if par ~= nil then
  1295.         self.parent = par
  1296.         self.ppos = par:getPos()-self.oldpos
  1297.         par:addChild(self)
  1298.     end
  1299. end
  1300.  
  1301. function DMenu:addItem(txt,callback)
  1302.     table.insert(self.items,{txt,callback})
  1303. end
  1304.  
  1305. function DMenu:draw()
  1306.     local p,s = self.pos,self.size
  1307.     local num = #self.items
  1308.     if self.parent then
  1309.         if self.parent:isHolding() then
  1310.             self.pos = self.parent:getPos()-self.ppos
  1311.             self.v[1] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2)
  1312.             self.v[2] =  vec2(self.pos.x+self.size.x/2,self.pos.y+self.size.y/2)
  1313.             self.v[3] =  vec2(self.pos.x+self.size.x/2,self.pos.y-self.size.y/2)
  1314.             self.v[4] =  vec2(self.pos.x-self.size.x/2,self.pos.y-self.size.y/2)
  1315.             self.v[5] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2)
  1316.             self.lines:setPos(self.v)
  1317.             self.m:setRect(self.r,self.pos.x,self.pos.y,self.size.x,self.size.y)
  1318.             p = self.pos
  1319.             s = self.size
  1320.             if self.expanded == 1 then
  1321.                 self.t:setRect(self.tr,p.x,p.y-s.y/2-num*(s.y/2),s.x,num*s.y)
  1322.             end
  1323.         end
  1324.     end    
  1325.     if self.visible == false then return end
  1326.     self.m:draw()
  1327.     self.t:draw()
  1328.    
  1329.     if self.expanded == 1 then
  1330.         if self.int < s.y/2 then
  1331.             self.int = self.int + 1
  1332.         end
  1333.        
  1334.         for i=1,num do
  1335.             local txt = self.items[i][1]
  1336.             local int = clamp(i*self.int*2,s.y,(s.y)*num)
  1337.             pushStyle()
  1338.             fill(self.intv*self.int,self.intv*self.int)
  1339.             text(txt,p.x,p.y-int)
  1340.             popStyle()
  1341.         end
  1342.         self.t:setRect(self.tr,p.x,p.y-s.y/2-
  1343.         clamp(num*self.int*(2.3/2),0,num*(s.y/2)),s.x,
  1344.         clamp(num*self.int*2.3,0,num*(s.y/2)*2))
  1345.     elseif self.expanded == 0 then
  1346.         if self.int > 0 then
  1347.             self.int = self.int - 1
  1348.         end
  1349.         for i=1,num do
  1350.             local txt = self.items[i][1]
  1351.             local int = clamp(i*self.int*2,s.y,(s.y)*num)
  1352.             pushStyle()
  1353.             fill(self.intv*self.int,self.intv*self.int)
  1354.             text(txt,p.x,p.y-int)
  1355.             popStyle()
  1356.         end
  1357.         self.t:setRect(self.tr,p.x,p.y-s.y/2-num*self.int,s.x,num*self.int*2)
  1358.     end
  1359.     if self.selected ~= nil then
  1360.        
  1361.         if self.expanded == 1 and self.snum ~= 0 and
  1362.             self.int > ((s.y/2)/#self.items)*(self.snum-1) then
  1363.                 pushStyle()
  1364.                     fill(200,100)
  1365.                     rect(p.x-s.x/2,p.y-self.snum*s.y-s.y/2,s.x,s.y)
  1366.                 popStyle()
  1367.             end
  1368.         pushStyle()
  1369.             fill(0,255)
  1370.             text(self.selected[1],p.x,p.y)
  1371.         popStyle()
  1372.     elseif self.label then
  1373.         pushStyle()
  1374.             fill(0,255)
  1375.             font("AmericanTypewriter")
  1376.             text(self.label,p.x,p.y)
  1377.         popStyle()
  1378.     end
  1379.     self.lines:draw()
  1380. end
  1381.  
  1382. function DMenu:touched(t)
  1383.     if self.visible == false then return end
  1384.     local p = self.pos
  1385.     local s = self.size
  1386.     if t.state == BEGAN and t.x < p.x+s.x/2 and t.x > p.x-s.x/2 and t.y < p.y+s.y/2 and t.y > p.y-s.y/2 then
  1387.         if self.expanded == 1 then
  1388.             self.expanded = 0
  1389.         elseif self.expanded == 0 then
  1390.             self.expanded = 1
  1391.         end
  1392.     end
  1393.     for i=1,#self.items do
  1394.         if t.state == BEGAN and self.expanded == 1 then
  1395.             if t.x < p.x+s.x/2 and t.x > p.x-s.x/2 and t.y > p.y-i*s.y-s.y/2 and t.y < p.y-
  1396.             i*s.y+s.y/2 then
  1397.                 self.selected = self.items[i]
  1398.                 self.snum = i
  1399.                 self.items[i][2]()
  1400.             end
  1401.         end
  1402.     end
  1403.            
  1404. end
  1405.  
  1406. --# ComboxImg
  1407. ComboxImg = class()
  1408.  
  1409. function ComboxImg:init(pos,size,imgsize,...)
  1410.     if ... then
  1411.         self.label = ...
  1412.     end
  1413.     self.pos = pos
  1414.     self.size = size
  1415.     self.m = mesh()
  1416.     self.r = self.m:addRect(pos.x,pos.y,size.x,size.y)
  1417.    
  1418.     self.vp = image(size.x,size.y)
  1419.     self.m.texture = self.vp
  1420.    
  1421.     self.moving = 1
  1422.     self.oldm = 0
  1423.    
  1424.     self.selected = {}
  1425.     self.snum = 0
  1426.     self.scrl = 0
  1427.     self.img = self.vp
  1428.    
  1429.     self.id = 0
  1430.     self.itemh = imgsize
  1431.     self.items = {}
  1432.     self.imesh = {}
  1433.     self.imeshr = {}
  1434.     self.v = {}
  1435.     self.v[1] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2)
  1436.     self.v[2] =  vec2(self.pos.x+self.size.x/2,self.pos.y+self.size.y/2)
  1437.     self.v[3] =  vec2(self.pos.x+self.size.x/2,self.pos.y-self.size.y/2)
  1438.     self.v[4] =  vec2(self.pos.x-self.size.x/2,self.pos.y-self.size.y/2)
  1439.     self.v[5] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2)
  1440.     self.lines = Tblines(self.v,220,5)
  1441.     self.oldpos = self.pos
  1442.     self.ppos = vec2()
  1443.     self.snum2 = {0}
  1444.     self.mov = 0
  1445.    
  1446.     self.parent = nil
  1447.     self.numitems = 0
  1448.     self.viscol = color(0,0,0,0)
  1449.     self.oldcol = color(255, 255, 255, 255)
  1450.     self.visible = true
  1451.     self.strokcol = color(220,220,220,255)
  1452. end
  1453.  
  1454. function ComboxImg:isVisible(bool)
  1455.     if bool == false then
  1456.         self.visible = false
  1457.     elseif bool == true then
  1458.         self.visible = true
  1459.     end
  1460. end
  1461.  
  1462.  
  1463. function ComboxImg:strokeCol(col)
  1464.     self.lines:setCol(col)
  1465.     self.strokcol = col
  1466. end
  1467.  
  1468. function ComboxImg:addParent(par)
  1469.     if par ~= nil then
  1470.         self.parent = par
  1471.         self.ppos = par:getPos()-self.oldpos
  1472.         par:addChild(self)
  1473.     end
  1474. end
  1475.  
  1476. function ComboxImg:addItem(img,callback)
  1477.     local p,s = self.pos,self.size
  1478.     self.numitems = self.numitems + 1
  1479.     self.id = self.id + 1
  1480.     table.insert(self.items,{name,callback})
  1481.     self.imesh[self.id] = mesh()
  1482.     self.imeshr[self.id] = self.imesh[self.id]:addRect(p.x,p.y,s.x,self.itemh)
  1483.     self.imesh[self.id].texture = img
  1484.     self.imesh[self.id]:draw()
  1485. end
  1486.  
  1487. function ComboxImg:draw()
  1488.     if self.visible == false then return end
  1489.     local p,s = self.pos,self.size
  1490.     if self.parent then
  1491.         if self.parent:isHolding() then
  1492.             self.pos = self.parent:getPos()-self.ppos
  1493.             self.v[1] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2)
  1494.             self.v[2] =  vec2(self.pos.x+self.size.x/2,self.pos.y+self.size.y/2)
  1495.             self.v[3] =  vec2(self.pos.x+self.size.x/2,self.pos.y-self.size.y/2)
  1496.             self.v[4] =  vec2(self.pos.x-self.size.x/2,self.pos.y-self.size.y/2)
  1497.             self.v[5] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2)
  1498.             self.m:setRect(self.r,self.pos.x,self.pos.y,self.size.x,self.size.y)
  1499.             self.lines:setPos(self.v)
  1500.         end
  1501.     end
  1502.     if self.visible == false then return end
  1503.     self.m:draw()          
  1504.     if self.moving == 1 then
  1505.         if self.scrl >= 0 then
  1506.        
  1507.     setContext(self.vp)
  1508.             background(200,255)
  1509.             for i=1,#self.items do
  1510.     self.imesh[i]:setRect(self.imeshr[i],s.x/2,s.y-i*self.itemh+(self.itemh/2)+self.scrl,s.x,self.itemh)
  1511.                 self.imesh[i]:draw()
  1512.                 pushStyle()
  1513.                 fill(80,150)
  1514.                 if self.snum == i then
  1515.                     rect(0,s.y-i*self.itemh+self.scrl,s.x,self.itemh+1)
  1516.                 end
  1517.                 popStyle()
  1518.             end
  1519.     setContext()
  1520.            
  1521.         else
  1522.             self.scrl = 0
  1523.         end
  1524.     end
  1525.     local p,s = self.pos,self.size      
  1526.     self.lines:draw()
  1527.     if self.label then
  1528.         pushStyle()
  1529.             textMode(CORNER)
  1530.             fontSize(15)
  1531.             fill(255,255)
  1532.             text(self.label,p.x-s.x/2,p.y+s.y/2+6)
  1533.         popStyle()
  1534.     end
  1535. end
  1536.  
  1537. function ComboxImg:touched(t)
  1538.     local p,s = self.pos,self.size
  1539.     if self.visible == false then return end
  1540.     if t.state == BEGAN then
  1541.         if t.x < p.x+s.x/2 and t.x > p.x-s.x/2 and t.y > p.y-s.y/2
  1542.         and t.y < p.y+s.y/2 then
  1543.             self.moving = 1
  1544.             self.mov = 0
  1545.             self.oldm = 0
  1546.         else
  1547.             self.moving = 0
  1548.         end
  1549.     end
  1550.     if t.state == MOVING and self.moving == 1 and self.mov == 0 then
  1551.        
  1552.         self.snum = self.snum2[1]  
  1553.         self.oldm = 1
  1554.        
  1555.         self.scrl = self.scrl + t.deltaY
  1556.         if self.scrl < 0.1 then
  1557.             self.scrl = 0
  1558.         elseif self.scrl >= (1-(s.y/(#self.items*self.itemh)))*self.itemh*#self.items then
  1559.             self.scrl =  (1-(s.y/(#self.items*self.itemh)))*self.itemh*#self.items
  1560.         end
  1561.     end
  1562.     if t.state == ENDED and self.moving == 1 and self.mov == 0 then
  1563.         for i=1,#self.items do
  1564.                 if t.x < p.x+s.x/2 and t.x > p.x-s.x/2 and
  1565.                 t.y > p.y+s.y/2-i*self.itemh+self.scrl and t.y < p.y+s.y/2-i*self.itemh+self.itemh+self.scrl then
  1566.                     self.snum = i
  1567.                 end
  1568.             end
  1569.         if self.oldm == 0 then
  1570.             self.snum2[1] = self.snum
  1571.             self.selected = self.items[self.snum]
  1572.             self.items[self.snum][2]()
  1573.         end
  1574.         self.snum = self.snum2[1]
  1575.         self.moving = 1
  1576.         self.mov = 0
  1577.         self.oldm = 0
  1578.     end
  1579. end
  1580.  
  1581. --# Radio
  1582. Radio = class()
  1583.  
  1584. function Radio:init(pos,size,txt,value)
  1585.     self.pos = pos
  1586.     self.size = size
  1587.     self.val = value
  1588.     self.txt = txt
  1589.     self.oldpos = self.pos
  1590.     self.ppos = vec2()
  1591.     self.parent = nil
  1592.     self.viscol = color(0,0,0,0)
  1593.     self.oldcol = color(170,170,170,255)
  1594.     self.alpha = 255
  1595.     self.visible = true
  1596.     self.strokcol = color(220,220,220,255)
  1597. end
  1598.  
  1599. function Radio:isVisible(bool)
  1600.     if bool == false then
  1601.         self.visible = false
  1602.     elseif bool == true then
  1603.         self.visible = true
  1604.     end
  1605. end
  1606.  
  1607.  
  1608. function Radio:addParent(par)
  1609.     if par ~= nil then
  1610.         self.parent = par
  1611.         self.ppos = par:getPos()-self.oldpos
  1612.         par:addChild(self)
  1613.     end
  1614. end
  1615.  
  1616. function Radio:draw()
  1617.     if self.parent then
  1618.         if self.parent:isHolding() then
  1619.             self.pos = self.parent:getPos()-self.ppos
  1620.         end
  1621.     end    
  1622.     if self.visible == false then return end
  1623.     pushStyle()
  1624.         fill(200,self.alpha)
  1625.         stroke(100,self.alpha)
  1626.         strokeWidth(self.size/8)
  1627.         ellipse(self.pos.x,self.pos.y,self.size)
  1628.         fill(50,self.alpha*self.val)
  1629.         strokeWidth(0)
  1630.         ellipse(self.pos.x,self.pos.y,self.size*0.5)
  1631.         textMode(CORNER)
  1632.         fill(50,self.alpha)
  1633.         fontSize(15)
  1634.         text(self.txt,self.pos.x+self.size*0.9,self.pos.y-10)
  1635.     popStyle()
  1636. end
  1637.  
  1638. function Radio:getValue()
  1639.     return self.val
  1640. end
  1641.  
  1642. function Radio:touched(t)
  1643.     if self.visible == false then return end
  1644.     local tpos = vec2(t.x,t.y)
  1645.     if t.state == BEGAN and tpos:dist(self.pos) < self.size then
  1646.         if self.val == 1 then
  1647.             self.val = 0
  1648.         elseif self.val == 0 then
  1649.             self.val = 1
  1650.         end
  1651.     end
  1652. end
  1653.  
  1654. --# Combox
  1655. Combox = class()
  1656.  
  1657. function Combox:init(pos,size,...)
  1658.     if ... then
  1659.         self.label = ...
  1660.     end
  1661.     self.pos = pos
  1662.     self.size = size
  1663.     self.m = mesh()
  1664.     self.r = self.m:addRect(pos.x,pos.y,size.x,size.y)
  1665.    
  1666.     self.vp = image(size.x,size.y)
  1667.     self.m.texture = self.vp
  1668.    
  1669.     self.moving = 1
  1670.     self.oldm = 0
  1671.    
  1672.     self.selected = {}
  1673.     self.snum = 0
  1674.     self.scrl = 0
  1675.     self.img = self.vp
  1676.    
  1677.     self.id = 0
  1678.     self.items = {}
  1679.     self.imesh = {}
  1680.     self.imeshr = {}
  1681.     self.v = {}
  1682.     self.v[1] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2)
  1683.     self.v[2] =  vec2(self.pos.x+self.size.x/2,self.pos.y+self.size.y/2)
  1684.     self.v[3] =  vec2(self.pos.x+self.size.x/2,self.pos.y-self.size.y/2)
  1685.     self.v[4] =  vec2(self.pos.x-self.size.x/2,self.pos.y-self.size.y/2)
  1686.     self.v[5] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2)
  1687.     self.lines = Tblines(self.v,220,5)
  1688.     self.oldpos = self.pos
  1689.     self.ppos = vec2()
  1690.     self.snum2 = {0}
  1691.     self.mov = 0
  1692.    
  1693.     self.parent = nil
  1694.     self.numitems = 0
  1695.     self.viscol = color(0,0,0,0)
  1696.     self.oldcol = color(255, 255, 255, 255)
  1697.     self.visible = true
  1698.     self.strokcol = color(220,220,220,255)
  1699. end
  1700.  
  1701. function Combox:isVisible(bool)
  1702.     if bool == false then
  1703.         self.visible = false
  1704.     elseif bool == true then
  1705.         self.visible = true
  1706.     end
  1707. end
  1708.  
  1709.  
  1710. function Combox:setSelected(name)
  1711.     for k,v in pairs(self.items) do
  1712.         if name == v[1] then
  1713.             self.selected = v
  1714.         end
  1715.     end
  1716. end
  1717.  
  1718. function Combox:strokeCol(col)
  1719.     self.lines:setColour(col)
  1720. end
  1721.  
  1722. function Combox:addParent(par)
  1723.     if par ~= nil then
  1724.         self.parent = par
  1725.         self.ppos = par:getPos()-self.oldpos
  1726.         par:addChild(self)
  1727.     end
  1728. end
  1729.  
  1730. function Combox:addItem(name,callback)
  1731.     local p,s = self.pos,self.size
  1732.     self.numitems = self.numitems + 1
  1733.     self.id = self.id + 1
  1734.     table.insert(self.items,{name,callback})
  1735.     self.imesh[self.id] = mesh()
  1736.     self.imeshr[self.id] =    self.imesh[self.id]:addRect(p.x,p.y,s.x,40)
  1737.     local img = image(s.x,40)
  1738.     setContext(img)
  1739.         pushStyle()
  1740.         if self.id%2 == 1 then
  1741.             background(170,255)
  1742.         end
  1743.         fill(0,255)
  1744.         textWrapWidth(s.x)
  1745.         fontSize(15)
  1746.         text(name,s.x/2,20)
  1747.         stroke(100,255)
  1748.         strokeWidth(2)
  1749.         line(0,0,s.x,0)
  1750.         popStyle()
  1751.     setContext()
  1752.     self.imesh[self.id].texture = img
  1753.     self.imesh[self.id]:draw()
  1754. end
  1755.  
  1756. function Combox:draw()
  1757.     local p,s = self.pos,self.size
  1758.     if self.parent then
  1759.         if self.parent:isHolding() then
  1760.             self.pos = self.parent:getPos()-self.ppos
  1761.             self.v[1] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2)
  1762.             self.v[2] =  vec2(self.pos.x+self.size.x/2,self.pos.y+self.size.y/2)
  1763.             self.v[3] =  vec2(self.pos.x+self.size.x/2,self.pos.y-self.size.y/2)
  1764.             self.v[4] =  vec2(self.pos.x-self.size.x/2,self.pos.y-self.size.y/2)
  1765.             self.v[5] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2)
  1766.             self.m:setRect(self.r,self.pos.x,self.pos.y,self.size.x,self.size.y)
  1767.             self.lines:setPos(self.v)
  1768.         end
  1769.     end
  1770.     if self.visible == false then return end
  1771.     self.m:draw()          
  1772.     if self.moving == 1 then
  1773.         if self.scrl >= 0 then
  1774.        
  1775.     setContext(self.vp)
  1776.             background(200,255)
  1777.             for i=1,#self.items do
  1778.                 self.imesh[i]:setRect(self.imeshr[i],s.x/2,s.y-i*40+20+self.scrl,s.x,40)
  1779.                 self.imesh[i]:draw()
  1780.                 pushStyle()
  1781.                 fill(80,150)
  1782.                 if self.snum == i then
  1783.                     rect(0,s.y-i*40+self.scrl,s.x,41)
  1784.                 end
  1785.                 popStyle()
  1786.             end
  1787.     setContext()
  1788.            
  1789.         else
  1790.             self.scrl = 0
  1791.         end
  1792.     end
  1793.     local p,s = self.pos,self.size      
  1794.     self.lines:draw()
  1795.     if self.label then
  1796.         pushStyle()
  1797.             textMode(CORNER)
  1798.             fontSize(15)
  1799.             fill(255,255)
  1800.             text(self.label,p.x-s.x/2,p.y+s.y/2+6)
  1801.         popStyle()
  1802.     end
  1803. end
  1804.  
  1805. function Combox:touched(t)
  1806.     local p,s = self.pos,self.size
  1807.    
  1808.     if t.state == BEGAN then
  1809.         if t.x < p.x+s.x/2 and t.x > p.x-s.x/2 and t.y > p.y-s.y/2
  1810.         and t.y < p.y+s.y/2 then
  1811.             self.moving = 1
  1812.             self.mov = 0
  1813.             self.oldm = 0
  1814.         else
  1815.             self.moving = 0
  1816.         end
  1817.     end
  1818.     if t.state == MOVING and self.moving == 1 and self.mov == 0 then
  1819.        
  1820.         self.snum = self.snum2[1]  
  1821.         self.oldm = 1
  1822.        
  1823.         self.scrl = self.scrl + t.deltaY
  1824.         if self.scrl < 0.1 then
  1825.             self.scrl = 0
  1826.         elseif self.scrl >= (1-(s.y/(#self.items*40)))*40*#self.items then
  1827.             self.scrl =  (1-(s.y/(#self.items*40)))*40*#self.items
  1828.         end
  1829.     end
  1830.     if t.state == ENDED and self.moving == 1 and self.mov == 0 then
  1831.         for i=1,#self.items do
  1832.                 if t.x < p.x+s.x/2 and t.x > p.x-s.x/2 and
  1833.                 t.y > p.y+s.y/2-i*40+self.scrl and t.y < p.y+s.y/2-i*40+40+self.scrl then
  1834.                     self.snum = i
  1835.                 end
  1836.             end
  1837.         if self.oldm == 0 then
  1838.             self.snum2[1] = self.snum
  1839.             self.selected = self.items[self.snum]
  1840.             if self.items[self.snum] ~= nil then
  1841.                 self.items[self.snum][2]()
  1842.             end
  1843.         end
  1844.         self.snum = self.snum2[1]
  1845.         self.moving = 1
  1846.         self.mov = 0
  1847.         self.oldm = 0
  1848.     end
  1849. end
  1850.  
  1851. --# Colour
  1852. Colour = class()
  1853.  
  1854. function Colour:init(pos)
  1855.     self.pos = pos
  1856.     self.size = vec2(150,100)
  1857.     self.m = mesh()
  1858.     self.r = self.m:addRect(pos.x,pos.y,self.size.x,self.size.y)
  1859.     self.col = color(255,255)
  1860.     self.v = {}
  1861.     self.v[1] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2)
  1862.     self.v[2] =  vec2(self.pos.x+self.size.x/2,self.pos.y+self.size.y/2)
  1863.     self.v[3] =  vec2(self.pos.x+self.size.x/2,self.pos.y-self.size.y/2)
  1864.     self.v[4] =  vec2(self.pos.x-self.size.x/2,self.pos.y-self.size.y/2)
  1865.     self.v[5] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2)
  1866.    
  1867.    
  1868.     self.v2 = {}
  1869.     self.v2[1] =  vec2(self.pos.x-self.size.x/2,self.pos.y-self.size.y/2-50)
  1870.     self.v2[2] =  vec2(self.pos.x+self.size.x/2,self.pos.y-self.size.y/2-50)
  1871.     self.v2[3] =  vec2(self.pos.x+self.size.x/2,self.pos.y-self.size.y/2-20)
  1872.     self.v2[4] =  vec2(self.pos.x-self.size.x/2,self.pos.y-self.size.y/2-20)
  1873.     self.v2[5] =  vec2(self.pos.x-self.size.x/2,self.pos.y-self.size.y/2-50)
  1874.    
  1875.     self.v3 = {}
  1876.     self.v3[1] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2+40)
  1877.     self.v3[2] =  vec2(self.pos.x+self.size.x/2,self.pos.y+self.size.y/2+40)
  1878.     self.v3[3] =  vec2(self.pos.x+self.size.x/2,self.pos.y+self.size.y/2+10)
  1879.     self.v3[4] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2+10)
  1880.     self.v3[5] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2+40)
  1881.    
  1882.     self.lines = Tblines(self.v,220,5)
  1883.     self.lines2 = Tblines(self.v2,220,5)
  1884.     self.lines3 = Tblines(self.v3,220,5)
  1885.    
  1886.     self.prevcol = color(0,0,0,0)
  1887.     self.changed = false
  1888.     self.oldpos = self.pos
  1889.     self.ppos = vec2()
  1890.     self.alpha = 255
  1891.     self.parent = nil
  1892.     self.touching = false
  1893.     self.touchingt = false
  1894.     self.touchingb = false
  1895.     self.img = readImage("Documents:colour")
  1896.     self.m.texture = self.img
  1897.     self.b = mesh()
  1898.     self.br = self.b:addRect(pos.x,pos.y-self.size.y/2-35,self.size.x,30)
  1899.     self.imgt = readImage("Documents:gradient")
  1900.     self.b.texture = self.imgt
  1901.     self.imga = readImage("Documents:alphabar")
  1902.     self.a = mesh()
  1903.     self.ar = self.a:addRect(pos.x,pos.y+self.size.y/2+25,self.size.x,30)
  1904.     self.a.texture = self.imga
  1905.     self.t = nil
  1906.     self.tx = 10^10
  1907.     self.ty = 10^10
  1908.     self.bo = color()
  1909.     self.hold = vec2(self.size.x/1.5,0)
  1910.     self.hold2 = vec2(self.size.x,0)
  1911.     self.viscol = color(0,0,0,0)
  1912.     self.oldcol = color(255, 255, 255, 255)
  1913.     self.visible = true
  1914.     self.strokcol = color(220,220,220,255)
  1915. end
  1916.  
  1917. function Colour:isVisible(bool)
  1918.     if bool == false then
  1919.         self.visible = false
  1920.     elseif bool == true then
  1921.         self.visible = true
  1922.     end
  1923. end
  1924.  
  1925.  
  1926. function Colour:strokeCol(col)
  1927.     self.lines:setColour(col)
  1928. end
  1929.  
  1930. function Colour:isMoving()
  1931.     local var = self.changed
  1932.     self.changed = false
  1933.     return var
  1934. end
  1935.  
  1936. function Colour:isTouchingAlpha()
  1937.     return self.touchingb
  1938. end
  1939.  
  1940. function Colour:addParent(par)
  1941.     if par ~= nil then
  1942.         self.parent = par
  1943.         self.ppos = par:getPos()-self.oldpos
  1944.         par:addChild(self)
  1945.     end
  1946. end
  1947.  
  1948.  
  1949. function Colour:draw()
  1950.     if self.parent then
  1951.         if self.parent:isHolding() then
  1952.             self.pos = self.parent:getPos()-self.ppos
  1953.             self.v[1] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2)
  1954.             self.v[2] =  vec2(self.pos.x+self.size.x/2,self.pos.y+self.size.y/2)
  1955.             self.v[3] =  vec2(self.pos.x+self.size.x/2,self.pos.y-self.size.y/2)
  1956.             self.v[4] =  vec2(self.pos.x-self.size.x/2,self.pos.y-self.size.y/2)
  1957.             self.v[5] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2)
  1958.            
  1959.             self.v2[1] =  vec2(self.pos.x-self.size.x/2,self.pos.y-self.size.y/2-50)
  1960.             self.v2[2] =  vec2(self.pos.x+self.size.x/2,self.pos.y-self.size.y/2-50)
  1961.             self.v2[3] =  vec2(self.pos.x+self.size.x/2,self.pos.y-self.size.y/2-20)
  1962.             self.v2[4] =  vec2(self.pos.x-self.size.x/2,self.pos.y-self.size.y/2-20)
  1963.             self.v2[5] =  vec2(self.pos.x-self.size.x/2,self.pos.y-self.size.y/2-50)
  1964.            
  1965.             self.v3[1] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2+40)
  1966.             self.v3[2] =  vec2(self.pos.x+self.size.x/2,self.pos.y+self.size.y/2+40)
  1967.             self.v3[3] =  vec2(self.pos.x+self.size.x/2,self.pos.y+self.size.y/2+10)
  1968.             self.v3[4] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2+10)
  1969.             self.v3[5] =  vec2(self.pos.x-self.size.x/2,self.pos.y+self.size.y/2+40)
  1970.             self.lines:setPos(self.v)
  1971.             self.lines2:setPos(self.v2)
  1972.             self.lines3:setPos(self.v3)
  1973.             self.m:setRect(self.r,self.pos.x,self.pos.y,self.size.x,self.size.y)
  1974.             self.b:setRect(self.br,self.pos.x,self.pos.y-self.size.y/2-35,self.size.x,30)
  1975.             self.a:setRect(self.ar,self.pos.x,self.pos.y+self.size.y/2+25,self.size.x,30)
  1976.         end
  1977.     end
  1978.     if self.visible == false then return end
  1979.     self.b:draw()  
  1980.     self.m:draw()
  1981.     sprite("Documents:alphabd",self.pos.x,self.pos.y+self.size.y/2+25,self.size.x,30)
  1982.     self.a:draw()
  1983.     self.lines:draw()
  1984.     self.lines2:draw()
  1985.     self.lines3:draw()
  1986.     pushStyle()
  1987.         strokeWidth(5)
  1988.         stroke(220,255)
  1989.         fill(255)
  1990.         fontSize(14)
  1991.     text("R:"..math.ceil(self.col.r),self.pos.x-self.size.x/2+self.size.x/7,self.pos.y-self.size.y/2-10)
  1992.     text("G:"..math.ceil(self.col.g),self.pos.x-self.size.x/2+(self.size.x/2),self.pos.y-self.size.y/2-10)
  1993.     text("B:"..math.ceil(self.col.b),self.pos.x-self.size.x/2+(self.size.x/4)*3.5,self.pos.y-self.size.y/2-10)
  1994.     textMode(CORNER)
  1995.     text("Alpha:"..self.alpha,self.pos.x-self.size.x/2,self.pos.y+self.size.y/2+43)
  1996.     popStyle()
  1997.     local p,s = self.pos,self.size
  1998.     if self.t ~= nil then
  1999.         self.tx = clamp(self.t.x,p.x-s.x/2,p.x+s.x/2)-p.x
  2000.         self.ty = clamp(self.t.y,p.y-s.y/2,p.y+s.y/2)-p.y
  2001.         if self.t.state == ENDED then
  2002.             self.t = nil
  2003.         end
  2004.     end
  2005.     pushStyle()
  2006.     stroke(255)
  2007.     strokeWidth(2.5)
  2008.     fill(0,0)
  2009.     ellipse(p.x+self.tx,p.y+self.ty,15)
  2010.     --lineCapMode(SQUARE)
  2011.     --line(p.x-s.x/2+self.hold.x*1.5,p.y-s.y/2-50,p.x-s.x/2+self.hold.x*1.5,p.y-s.y/2-20)
  2012.     rect(p.x-s.x/2+self.hold.x*1.5-4.5,p.y-s.y/2-50,6,30)
  2013.     rect(p.x-s.x/2+self.hold2.x-4.5,p.y+s.y/2+10,6,30)
  2014.     popStyle()
  2015. end
  2016.  
  2017. function Colour:getValue()
  2018.     return color(self.col.r,self.col.g,self.col.b,self.alpha)
  2019. end
  2020.  
  2021. function Colour:getAlpha()
  2022.     return self.alpha
  2023. end
  2024.  
  2025. function Colour:isTouching()
  2026.     return self.touching or self.touchingt
  2027. end
  2028.  
  2029. function Colour:touched(t)
  2030.     if self.visible == false then return end
  2031.     local p,s = self.pos,self.size
  2032.     if t.state == BEGAN and t.x < p.x+s.x/2 and t.x > p.x-s.x/2 and t.y < p.y+s.y/2 and t.y > p.y-s.y/2 then
  2033.         self.t = t
  2034.         local ps = self.pos-self.size*0.5
  2035.         local nps = self.pos+self.size*0.5
  2036.         local tp = vec2(t.x,t.y)
  2037.         tp.x = clamp(t.x,ps.x,nps.x)
  2038.         tp.y = clamp(t.y,ps.y,nps.y)
  2039.         local x,y = tp.x-ps.x,tp.y-ps.y
  2040.         x = clamp(x,1,self.img.width)
  2041.         y = clamp(y,1,self.img.height)
  2042.         self.col.r,self.col.g,self.col.b = self.img:get(x*(self.img.width/self.size.x),y*(self.img.height/self.size.y))
  2043.         if self.prevcol ~= self.col then self.changed = true end
  2044.         self.prevcol = self.col
  2045.         self.touching = true
  2046.         for i=1,100 do
  2047.             for j=1,20 do
  2048.                 self.imgt:set(i,j,(self.col.r/100)*i,(self.col.g/100)*i,(self.col.b/100)*i)
  2049.             end
  2050.         end
  2051.         self.a:setColors(self.col)
  2052.         self.b.texture = self.imgt
  2053.     end
  2054.     if t.state == MOVING and self.touching == true then
  2055.         self.t = t
  2056.         local ps = self.pos-self.size*0.5
  2057.         local nps = self.pos+self.size*0.5
  2058.         local tp = vec2(t.x,t.y)
  2059.         tp.x = clamp(t.x,ps.x,nps.x)
  2060.         tp.y = clamp(t.y,ps.y,nps.y)
  2061.         local x,y = tp.x-ps.x,tp.y-ps.y
  2062.         x = clamp(x,1,self.img.width)
  2063.         y = clamp(y,1,self.img.height)
  2064.         self.col.r,self.col.g,self.col.b = self.img:get(
  2065.         x*(self.img.width/self.size.x),y*(self.img.height/self.size.y))
  2066.         if self.prevcol ~= self.col then self.changed = true end
  2067.         self.prevcol = self.col
  2068.         self.a:setColors(self.col)
  2069.         for i=1,100 do
  2070.             for j=1,20 do
  2071.                 self.imgt:set(i,j,(self.col.r/100)*i,(self.col.g/100)*i,(self.col.b/100)*i)
  2072.             end
  2073.         end
  2074.         self.b.texture = self.imgt
  2075.     end
  2076.     if t.state == ENDED and self.touching then
  2077.         self.b.texture = self.imgt
  2078.         self.touching = false
  2079.         self.t = t
  2080.     end
  2081.     if t.state == BEGAN and t.x < p.x+s.x/2 and t.x > p.x-s.x/2 and t.y < p.y-s.y/2-20 and t.y > p.y-s.y/2-50 then
  2082.         self.touchingt = true
  2083.         local psx = p.x-s.x/2
  2084.         local npsx = p.x+s.x/2
  2085.         local tp = vec2(t.x,t.y)
  2086.         tp.x = clamp(t.x,psx,npsx)
  2087.         local x = tp.x-psx
  2088.         x = clamp(x*(self.imgt.width/self.size.x),2,self.imgt.width)
  2089.         if x > 1 and x <= self.size.x then
  2090.             self.bo.r,self.bo.g,self.bo.b = self.imgt:get(x,10)
  2091.             self.hold = vec2(x,15)
  2092.             self.col = self.bo
  2093.             self.a:setColors(self.col)
  2094.         end
  2095.     end
  2096.     if t.state == MOVING and self.touchingt then
  2097.         local psx = p.x-s.x/2
  2098.         local npsx = p.x+s.x/2
  2099.         local tp = vec2(t.x,t.y)
  2100.         tp.x = clamp(t.x,psx,npsx)
  2101.         local x = tp.x-psx
  2102.         x = clamp(x*(self.imgt.width/self.size.x),2,self.imgt.width)
  2103.         if x > 1 and x <= self.size.x then
  2104.             self.hold = vec2(x,15)
  2105.             self.col.r,self.col.g,self.col.b = self.imgt:get(x,10)
  2106.             self.a:setColors(self.col)
  2107.         end
  2108.     end
  2109.     if t.state == ENDED and self.touchingt then
  2110.         self.touchingt = nil
  2111.     end
  2112.    
  2113.    
  2114.     if t.state == BEGAN and t.x < p.x+s.x/2 and t.x > p.x-s.x/2 and t.y > p.y+s.y/2+10 and t.y < p.y+s.y/2+40 then
  2115.         self.touchingb = true
  2116.         local psx = p.x-s.x/2
  2117.         local npsx = p.x+s.x/2
  2118.         local tp = vec2(t.x,t.y)
  2119.         tp.x = clamp(t.x,psx,npsx)
  2120.         local x = tp.x-psx
  2121.         x = clamp(x*(self.imga.width/self.size.x),2,self.imga.width)
  2122.         if x > 1 and x <= self.size.x then
  2123.             self.hold2 = vec2(x,15)
  2124.             local r,g,b
  2125.             r,g,b,self.alpha = self.imga:get(x,10)
  2126.         end
  2127.     end
  2128.     if t.state == MOVING and self.touchingb then
  2129.         local psx = p.x-s.x/2
  2130.         local npsx = p.x+s.x/2
  2131.         local tp = vec2(t.x,t.y)
  2132.         tp.x = clamp(t.x,psx,npsx)
  2133.         local x = tp.x-psx
  2134.         x = clamp(x*(self.imga.width/self.size.x),2,self.imga.width)
  2135.         if x > 1 and x <= self.size.x then
  2136.             self.hold2 = vec2(x,15)
  2137.             local r,g,b
  2138.             r,g,b,self.alpha = self.imga:get(x,10)
  2139.             if self.alpha == 3 then self.alpha = 0 end
  2140.         end
  2141.     end
  2142.     if t.state == ENDED and self.touchingb then
  2143.         local psx = p.x-s.x/2
  2144.         local npsx = p.x+s.x/2
  2145.         local tp = vec2(t.x,t.y)
  2146.         tp.x = clamp(t.x,psx,npsx)
  2147.         local x = tp.x-psx
  2148.         x = clamp(x*(self.imga.width/self.size.x),2,self.imga.width)
  2149.         if x > 1 and x <= self.size.x then
  2150.             self.hold2 = vec2(x,15)
  2151.             local r,g,b
  2152.             r,g,b,self.alpha = self.imga:get(x,10)
  2153.             if self.alpha == 3 then self.alpha = 0 end
  2154.         end
  2155.         self.touchingb = nil
  2156.     end
  2157. end
  2158.  
  2159. --# Progbar
  2160. Progbar = class()
  2161.  
  2162. function Progbar:init(pos,size,value,col1,col2,...)
  2163.     self.pos = pos
  2164.     self.size = size
  2165.     self.cola = col1
  2166.     local colalp = col1.a or 255
  2167.     self.colb = col2
  2168.     self.colba = col2.a or 255
  2169.     if ... then
  2170.         self.label = ...
  2171.     end
  2172.     self.startval = 0
  2173.     self.endval = 100
  2174.     self.val = value
  2175.     self.m = mesh()
  2176.     self.r = self.m:addRect(pos.x,pos.y,size.x,size.y)
  2177.     self.m:setColors(col1.r,col1.g,col1.b,colalp)
  2178.     self.oldpos = self.pos
  2179.     self.ppos = vec2()
  2180.     self.parent = nil
  2181.     self.viscol = color(0,0,0,0)
  2182.     self.oldcol = col1
  2183.     self.alpha = 255
  2184.     self.fillcol = col2
  2185.     self.visible = true
  2186.     self.strokcol = color(220,220,220,255)
  2187. end
  2188.  
  2189. function Progbar:isVisible(bool)
  2190.     if bool == false then
  2191.         self.visible = false
  2192.     elseif bool == true then
  2193.         self.visible = true
  2194.     end
  2195. end
  2196.  
  2197.  
  2198. function Progbar:addParent(par)
  2199.     if par ~= nil then
  2200.         self.parent = par
  2201.         self.ppos = par:getPos()-self.oldpos
  2202.         par:addChild(self)
  2203.     end
  2204. end
  2205.  
  2206.  
  2207. function Progbar:setStart(x)
  2208.     self.startval = x
  2209. end
  2210.  
  2211. function Progbar:setEnd(x)
  2212.     self.endval = x
  2213. end
  2214.  
  2215. function Progbar:setValue(x)
  2216.     self.val = x
  2217. end
  2218.  
  2219. function Progbar:draw()
  2220.     self.val = clamp(self.val,self.startval,self.endval)
  2221.     if self.parent then
  2222.         if self.parent:isHolding() then
  2223.             self.pos = self.parent:getPos()-self.ppos
  2224.         end
  2225.     end
  2226.     if self.visible == false then return end
  2227.     local p,s = self.pos,self.size
  2228.     self.m:setRect(self.r,p.x,p.y,s.x,s.y)
  2229.     self.m:draw()
  2230.     pushStyle()
  2231.         fill(self.fillcol.r,self.fillcol.g,self.fillcol.b,self.alpha)
  2232.         rect(p.x-s.x/2,p.y-s.y/2,self.val*(s.x/(self.endval-self.startval))-(s.x/(self.endval-self.startval))*self.startval,s.y)
  2233.         fill(255,self.alpha)
  2234.         fontSize(13)
  2235.         text(self.val,p.x,p.y+1)
  2236.         fill(255,self.alpha)
  2237.         if self.label then
  2238.             textMode(CORNER)
  2239.             text(self.label,p.x-s.x/2,p.y+s.y/2+2)
  2240.         end
  2241.     popStyle()
  2242. end
  2243.  
  2244. function Progbar:touched(touch)
  2245.     -- Codea does not automatically call this method
  2246. end
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!