View difference between Paste ID: Ud2uTjLa and dNVfNyLY

 -- Code edited by TheMartinWheeler (TheShinyTuxedo) on 6/1/2012
 -- Code update by Bystander on  8/28/2011
 ------------------------------------------------------------------------------------------------------------
 POLL_DELAY = 25     -- Sleep time after each poll (beware of number below 25)
 POLL_FAMILY = "kb"  -- The device polling will take place on.  Prefered to not be on macroed device.
 KB_EVENTS = true    -- If you don't have a logitech keyboard, make this false/nil or comment out
 -- LHC_EVENTS = true   -- if you don't have a logitech left handed controller, make this false/nil or comment out
 ------------------------------------------------------------------------------------------------------------
 
 DEVICE = "kb"
 color = 1
 speed = 25  -- this should alwasy be equal or larger than POLL_DELAY
 disco = 0
 BLUE = 255
 DIRECTION = 1
 
 function _onActivation(event, arg, family)
 --
 -- ADD ANY START UP ROUTINES HERE
 --
 --    POLL:setMKeyModifier( "default", "mb5", "mb4", "lhc" )  -- Allows the use of Modifiers to change M pages
 
 	ctDiscoColors = CoThread:new(discoColors)
 end
 
 function _OnEvent(event, arg, family)
 --
 -- ADD EVENT FUNCTIONALITY HERE
 --
 
 	if (event == "G_PRESSED" and arg == 1 and GetMKeyState(DEVICE) == 1) then
 		if color == 1 then
 			color = 2
 			ctDiscoColors:stop()	-- stops randomColors if it was running()
 			SetBacklightColor(255, 0, 0, DEVICE) -- Red
 			OutputLogMessage("RED\n")
 		elseif color == 2 then
 			color = 3
 			SetBacklightColor(0, 0, 255, DEVICE) -- Blue
 			OutputLogMessage("BLUE\n")
 		elseif color == 3 then
 			color = 4
 			SetBacklightColor(255, 0, 255, DEVICE) -- Purple
 			OutputLogMessage("PURPLE\n")
 		elseif color == 4 then
 			color = 1
 			ctDiscoColors:start()	-- starts discoColors
 			OutputLogMessage("DISCO\n")
 		end
 	end
 
 	if (event == "G_PRESSED" and arg == 3 and disco == 1) then
 		speed = speed-25
 		if speed < POLL_DELAY 	then	-- if speed is 0 or less, the program will not reliquish control
 			speed = POLL_DELAY
 		end
 	end
 
 	if (event == "G_PRESSED" and arg == 6 and disco == 1) then
 		speed = speed+25
 	end
 
 	ctDiscoColors:run() -- this will run discoColors as long as it hasn't finished or been stopped with :stop()
 end
 
 function discoColors(ct)
 	while true do
 		disco = 1
 
 		if BLUE == 255 and DIRECTION == 0 then
 			DIRECTION = 1
 		elseif BLUE == 1 and DIRECTION == 1 then
-			DIRECTION == 0
+			DIRECTION = 0
 		end
 
 
 		if DIRECTION == 1
 			SetBacklightColor(0, 0, BLUE, DEVICE) -- BLUE
 			BLUE = BLUE - 1
 			ct:sleep(speed)
 		elseif DIRECTION == 0
 			SetBacklightColor(0, 0, BLUE, DEVICE) -- BLUE
 			BLUE = BLUE + 1
 			ct:sleep(speed)
 		end
 
 		if color ~= 1 then	  -- if color == 1 it will continue to loop as before
 			disco = 0
 			break
 		end
 	end
 end
 
 --------------------------------------------------------------------------------------------------------
 --------------------------------------------------------------------------------------------------------
 --
 --                             NOTHING BELOW HERE NEEDS TO BE ALTERED
 --
 --------------------------------------------------------------------------------------------------------
 --------------------------------------------------------------------------------------------------------
 -- function Type(v)  -- returns what type of object v is.  It works with my objects as well
 -- function log(...) -- MessageLogOutput(...)
 --------------------------------------------------------------------------------------------------------
 --------------------------------------------------------------------------------------------------------
 -- function CoThread:new(f)      f - function(coThread,...)   coThread is the controlling CoThread
 -- function CoThread:recreate()  kill existing coroutine and recreate
 -- function CoThread:create()    creates coroutine
 -- function CoThread:isDead()    true if coroutine is dead or nil/false
 -- function CoThread:run(...)    run coroutine with variables don't include mt
 -- function CoThread:kill()      kill coroutine
 -- function CoThread:yield()     use in function(coThread,...) to yield
 -- function CoThread:sleep(Milliseconds) use in function(coThread,...) to sleep for Milliseconds
 -- function CoThread:start()     does the same thing as recreate()
 -- function CoThread:stop()      does the same thing as kill()
 -- function CoThread:isFinished() same as isDead()
 --------------------------------------------------------------------------------------------------------
 --------------------------------------------------------------------------------------------------------
 -- function Poll:new(family, delay)         delay is sleep time between polls
 -- function Poll:run(event, arg, family)    handles events and performs the polling as long as it's running
 -- function Poll:setMKeyModifier( m1, m2, m3, family )  Allows the use of Modifiers to change M pages
 -- function Poll:start()                    turn on polling
 -- function Poll:stop()                     stop polling
 --      function Poll:_press()                  NOT TO BE USED
 --      function Poll:release()                 NOT TO BE USED
 --      function Poll:setMKeyState(MKeyState)   NOT TO BE USED
 ------------------------------------------------------------------------------------------------------------
 
 function OnEvent(event, arg, family)
 -- POLLING INITIATED HERE
     _GetRunningTime = GetRunningTime()
     if event == "PROFILE_ACTIVATED" then
         ClearLog()
         POLL = Poll:new(POLL_FAMILY, POLL_DELAY)
         POLL:start()
         _onActivation(event, arg, family)
     else
 -- POLLING ROUTINES BELOW
         POLL:run(event,arg,family)
 	    _GetRunningTime = GetRunningTime()
         _OnEvent(event, arg, family)  -- Runs myOnEvent to compartmentalize
     end
 end
 
 function log(...)
     if ... == nil then
         error("log(...) cannot display nil\n",2)
     end
     OutputLogMessage(...)
 end
 
 function Type(v)
     if type(v) == "table" then
         if v.Type ~= nil then
             return v.Type
         elseif v.type ~= nil then
             return v.type
         end
     end
     return type(v)
 end
 
 ------------------------------------------------------------------------------------------------------------
 -- function Poll:new(family, delay)         delay is sleep time between polls
 -- function Poll:run(event, arg, family)    handles events and performs the polling as long as it's running
 -- function Poll:setMKeyModifier( m1, m2, m3, family )  Allows the use of Modifiers to change M pages
 -- function Poll:start()                    turn on polling
 -- function Poll:stop()                     stop polling
 --      function Poll:_press()                   NOT TO BE USED
 --      function Poll:release()                 NOT TO BE USED
 --      function Poll:setMKeyState(MKeyState)   NOT TO BE USED
 ------------------------------------------------------------------------------------------------------------
 
 Poll = {}
 Poll.__index = Poll
 Poll.__newindex = function(table, key, value)
     for k,v in pairs(table) do
         if k == key then
             rawset(table,key,value) return
         end
     end
     error("'" .. key .. "' is not a member of Poll.", 2)
 end
 
 function Poll:new(family, delay)
     local self = {}
 
     self.delay = delay or 50
     if family ~= "kb" and family ~= "lhc" then
         error("Poll:new() - 'pFamily' must be 'kb' or 'lhc'", 2)
     end
     self.pFamily = family
     self.presses = 0
     self.running = false
     self.runMKeyModifier = false
     self.MKeyModifier = { nil, nil, nil }   -- "default" or Modifiers. i.e. "lshift", "ctrl"
     self.modFamily = ""
     self.Type = "Poll"
 
     setmetatable(self, Poll)
 
     return self
 end
 
 --------------------------------------------------------------------------------------------
 --  Poll:setMKeyModifier( m1, m2, m3, family )
 --  Sets what modifiers will change you to the associated M page of the device on family
 --  "shift", "ctrl", "alt", "lshift", "lctrl", "lalt"... are all modifiers
 --  "default" is the page that will be set when none of the listed modifiers are pressed
 --  "" will cause a page to be ignored.
 --  I.E. - Poll:setMKeyModifier( "default", "shift", "ctrl", "lhc" )
 --  will set the default page to m1, shift will change you to m2, ctrl to m3 on a left hand controler
 --------------------------------------------------------------------------------------------
 function Poll:setMKeyModifier( m1, m2, m3, family )
     self.runMKeyModifier = true
     self.MKeyModifier[1] = m1
     self.MKeyModifier[2] = m2
     self.MKeyModifier[3] = m3
     if family ~= "kb" and family ~= "lhc" then  error("Poll:setMKeyModifier() family - needs to be 'kb' or 'lhc'",2) end
     self.modFamily = family
 end
 
 function Poll:start()
     self.running = true
     self:setMKeyState()
 end
 
 function Poll:stop()
     self.running = false
 end
 
 function Poll:_press()
     if self.running then
         self.presses = self.presses + 1
     end
 end
 
 function Poll:release()
     if self.running then
         self.presses = self.presses - 1
     end
 end
 
 function Poll:setMKeyState()
     if self.runMKeyModifier then
         local default = nil
         local i = 1
         local modMKeyState = nil
 
         for i = 1, 3, 1 do
             if self.MKeyModifier[i] == "default" then
                 default = i
             elseif self.MKeyModifier[i] == "" then
                 -- do nothing
             elseif string.find(self.MKeyModifier[i],"mb%d") then
                 local iMB = tonumber(string.sub(self.MKeyModifier[i],3))
                 if IsMouseButtonPressed(iMB) then
                     modMKeyState = i
                 end
             elseif IsModifierPressed(self.MKeyModifier[i]) then
                 modMKeyState = i
             end
         end
         if modMKeyState == nil then
             modMKeyState = default
         end
         if modMKeyState ~= nil then
             if self.pFamily == self.modFamily then
                 SetMKeyState(modMKeyState, self.pFamily)
                 return
             elseif GetMKeyState(self.modFamily) ~= modMKeyState then
                 SetMKeyState(modMKeyState, self.modFamily)
             end
         end
     end
     SetMKeyState( GetMKeyState(self.pFamily), self.pFamily )
 end
 
 function Poll:run(event, arg, family)
     if self.running and self.pFamily == family then
         if event == "M_PRESSED" then
             self:_press()
         elseif event == "M_RELEASED" then
             if self.presses == 1 then
                 self:setMKeyState()
                 Sleep(self.delay)
             end
             self:release()
         end
     end
 end
 
 --------------------------------------------------------------------------------------------------------
 -- function CoThread:new(f)      f - function(coThread,...)   coThread is the controlling CoThread
 -- function CoThread:recreate()  kill existing coroutine and recreate
 -- function CoThread:create()    creates coroutine
 -- function CoThread:isDead()    true if coroutine is dead or nil/false
 -- function CoThread:run(...)    run coroutine with variables don't include mt
 -- function CoThread:kill()      kill coroutine
 -- function CoThread:yield()     use in function(coThread,...) to yield
 -- function CoThread:sleep(Milliseconds) use in function(coThread,...) to sleep for Milliseconds
 -- function CoThread:start()     does the same thing as recreate()
 -- function CoThread:stop()      does the same thing as kill()
 -- function CoThread:isFinished() same as isDead()
 --------------------------------------------------------------------------------------------------------
 
 CoThread = {}
 CoThread.__index = CoThread
 
 function CoThread:new(f) -- f - function(MultiThread)
 	local self = {}
 
 	if type(f) ~= "function" then
 		error("A function is needed",2)
 	end
     self.func = f
     self.co = nil
     self.sleepUntilTimeStamp = nil
     self.Type = "CoThread"
 
 	setmetatable(self, CoThread)
 	return self
 end
 
 function CoThread:recreate()
     self:kill()
     self.co = coroutine.create(self.func)
 end
 
 function CoThread:create()
     self.co = coroutine.create(self.func)
 end
 
 function CoThread:isDead()
     if self.co == nil then
         return true
 	elseif coroutine.status(self.co) == "dead" then
         self.co = nil
 		return true
 	else
         return false
     end
 end
 
 function CoThread:run(...)
 	if self:isDead() then
         return
     end
     if self.sleepUntilTimeStamp ~= nil then
         if _GetRunningTime < self.sleepUntilTimeStamp then
             return
         else
             self.sleepUntilTimeStamp = nil
         end
     end
     coroutine.resume(self.co, self, ...)
 end
 
 function CoThread:kill()
     self.co = nil       -- lua automatically deallocated
     self.sleepUntilTimeStamp = nil
 end
 
 function CoThread:yield()
     coroutine.yield()
 end
 
 function CoThread:sleep(Milliseconds)
     self.sleepUntilTimeStamp = _GetRunningTime + Milliseconds
 
     coroutine.yield()
 end
 
 function CoThread:start()
     self:recreate()
 end
 
 function CoThread:stop()
     self:kill()
 end
 
 function CoThread:isFinished()
     return self:isDead()
 end