function calculation(minValue, maxValue, value, numberOfSteps, sliderDirection)
  numberOfSteps = math.max(numberOfSteps, 1)
  value = math.min(math.max(value, minValue), maxValue)
  local leftOffset = 24.0
  local v = 168.0 * (value - minValue)/(maxValue - minValue)
  local blockOffset = 168.0 / numberOfSteps
  local blockSize = { x = math.floor(168.0/numberOfSteps), y=0.0, z=63.0 }
  
  local activeBlock = 0
  
  -- local glowVisible = ( v >= 0.0)
  -- if (sliderDirection == 1) then
    -- glowVisible = ( v >= 0.0)
  -- end
  
  local barInactiveVisible = true
  local boxInactiveLeftVisible = true
  local boxInactiveRightVisible = true
  local barInactiveStartPosX = leftOffset
  local barInactiveEndPosX = leftOffset
  local barInactivePos = { x=leftOffset, y=0.0, z=0.0 }
  local inactiveBarSize = { x=0.0, y=0.0, z=0.0 }
  local inactiveBoxLeftPos = { x=leftOffset, y=0.0, z=0.0 }
  local inactiveBoxRightPos = { x=0.0, y=0.0, z=0.0 }
  local inactiveBoxLeftSize = { x=0.0, y=0.0, z=0.0 }
  local inactiveBoxRightSize = { x=0.0, y=0.0, z=0.0 }
  local cursorPosition = { x=0.0, y=0.0, z=0.0 }
  local inactiveBarGlowPos = { x=0.0, y=0.0, z=0.0 }
  local inactiveBarGlowSize = { x=0.0, y=0.0, z=0.0 }
  
  activeBlock = math.floor(v/blockOffset) + 1
  if (activeBlock > numberOfSteps) then
    activeBlock = numberOfSteps
  end
  
  if (numberOfSteps == activeBlock) then
    boxInactiveRightVisible = false
  end
    
  if (sliderDirection == 0) then
    barInactiveEndPosX = math.floor(leftOffset + activeBlock * blockOffset)
    inactiveBarSize = { x = barInactiveEndPosX-barInactiveStartPosX, y=0.0, z=63.0 }
    cursorPosition = { x = barInactiveEndPosX-19.0, y=0.0, z=0.0 }
    inactiveBarGlowPos = { x = 24.0, y=0.0, z=24.0 }
    inactiveBarGlowSize = { x = barInactiveEndPosX - barInactiveStartPosX - 1.0, y=0.0, z=20.0 }
  else
    local center = math.floor(numberOfSteps / 2);
    
    if ( value >= (maxValue+minValue)/2.0 ) then
      barInactiveStartPosX = math.floor(leftOffset + center * blockOffset)
      barInactiveEndPosX = math.floor(leftOffset + activeBlock * blockOffset)
      cursorPosition = { x = barInactiveEndPosX-19.0, y=0.0, z=0.0 }
    else -- ( value < (maxValue+minValue)/2.0 )
      barInactiveEndPosX = math.floor(leftOffset + (center+1) * blockOffset)
      if (activeBlock == 0) then
        barInactiveStartPosX = math.floor(leftOffset + (activeBlock) * blockOffset)
      else
        barInactiveStartPosX = math.floor(leftOffset + (activeBlock-1) * blockOffset)
      end
      cursorPosition = { x = barInactiveStartPosX-14.0, y=0.0, z=0.0 }
    end
    
    if (activeBlock == 1) then
      boxInactiveLeftVisible = false
    end
    if (activeBlock == center + 1) then
      cursorPosition = { x = 91.0, y=0.0, z=0.0 }
    end
    
    barInactivePos = { x = barInactiveStartPosX, y=0.0, z=0.0 }
    inactiveBarSize = { x = barInactiveEndPosX-barInactiveStartPosX, y=0.0, z=63.0 }
    inactiveBoxLeftSize = { x = barInactiveStartPosX - leftOffset, y=0.0, z=63.0 }
    inactiveBarGlowPos = { x = barInactiveStartPosX, y=0.0, z=24.0 }
    inactiveBarGlowSize = { x = barInactiveEndPosX - barInactiveStartPosX - 1.0, y=0.0, z=20.0 }
  end
  
  inactiveBoxRightPos = { x = barInactiveEndPosX, y=0.0, z=0.0 }
  inactiveBoxRightSize = { x = leftOffset+168.0-barInactiveEndPosX, y=0.0, z=63.0 }
    
  if (activeBlock == 0) then
    glowPosition = { x = leftOffset + activeBlock * blockOffset, y=0.0, z=0.0 }
  else
    glowPosition = { x = leftOffset + (activeBlock-1) * blockOffset, y=0.0, z=0.0 }
  end
  
  
  
  return blockSize, barInactivePos, inactiveBarSize, inactiveBoxLeftPos, inactiveBoxRightPos, inactiveBoxLeftSize, inactiveBoxRightSize,
    barInactiveVisible, boxInactiveLeftVisible, boxInactiveRightVisible, cursorPosition, glowPosition, inactiveBarGlowPos, inactiveBarGlowSize--, glowVisible
end




function calculateBlocksVisibility(editMode, numberOfSteps)
  numberOfSteps = math.max(numberOfSteps, 1)
  local block1Visible = editMode
  local block2Visible = editMode and 2 <= numberOfSteps
  local block3Visible = editMode and 3 <= numberOfSteps
  local block4Visible = editMode and 4 <= numberOfSteps
  local block5Visible = editMode and 5 <= numberOfSteps
  local block6Visible = editMode and 6 <= numberOfSteps
  local block7Visible = editMode and 7 <= numberOfSteps
  local block8Visible = editMode and 8 <= numberOfSteps
  local block9Visible = editMode and 9 <= numberOfSteps
  local block10Visible = editMode and 10 <= numberOfSteps
  local block11Visible = editMode and 11 <= numberOfSteps
  local block12Visible = editMode and 12 <= numberOfSteps
  local block13Visible = editMode and 13 <= numberOfSteps
  local block14Visible = editMode and 14 <= numberOfSteps
  local block15Visible = editMode and 15 <= numberOfSteps
  local block16Visible = editMode and 16 <= numberOfSteps
  local block17Visible = editMode and 17 <= numberOfSteps
  local block18Visible = editMode and 18 <= numberOfSteps
  local block19Visible = editMode and 19 <= numberOfSteps
  local block20Visible = editMode and 20 <= numberOfSteps
  local block21Visible = editMode and 21 <= numberOfSteps

  return block1Visible, block2Visible, block3Visible, block4Visible, block5Visible, block6Visible, block7Visible, block8Visible, block9Visible, block10Visible, 
      block11Visible, block12Visible, block13Visible, block14Visible, block15Visible, block16Visible, block17Visible, block18Visible, block19Visible, block20Visible, block21Visible
end

function calculateBlocksPositions(numberOfSteps)
  numberOfSteps = math.max(numberOfSteps, 1)
  local blockOffset = 168.0 / numberOfSteps
  local blockPosition1 = { x=24.0, y=0.0, z=0.0 }
  local blockPosition2 = { x=24.0 + 1.0 * blockOffset, y=0.0, z=0.0 }
  local blockPosition3 = { x=24.0 + 2.0 * blockOffset, y=0.0, z=0.0 }
  local blockPosition4 = { x=24.0 + 3.0 * blockOffset, y=0.0, z=0.0 }
  local blockPosition5 = { x=24.0 + 4.0 * blockOffset, y=0.0, z=0.0 }
  local blockPosition6 = { x=24.0 + 5.0 * blockOffset, y=0.0, z=0.0 }
  local blockPosition7 = { x=24.0 + 6.0 * blockOffset, y=0.0, z=0.0 }
  local blockPosition8 = { x=24.0 + 7.0 * blockOffset, y=0.0, z=0.0 }
  local blockPosition9 = { x=24.0 + 8.0 * blockOffset, y=0.0, z=0.0 }
  local blockPosition10 = { x=24.0 + 9.0 * blockOffset, y=0.0, z=0.0 }
  local blockPosition11 = { x=24.0 + 10.0 * blockOffset, y=0.0, z=0.0 }
  local blockPosition12 = { x=24.0 + 11.0 * blockOffset, y=0.0, z=0.0 }
  local blockPosition13 = { x=24.0 + 12.0 * blockOffset, y=0.0, z=0.0 }
  local blockPosition14 = { x=24.0 + 13.0 * blockOffset, y=0.0, z=0.0 }
  local blockPosition15 = { x=24.0 + 14.0 * blockOffset, y=0.0, z=0.0 }
  local blockPosition16 = { x=24.0 + 15.0 * blockOffset, y=0.0, z=0.0 }
  local blockPosition17 = { x=24.0 + 16.0 * blockOffset, y=0.0, z=0.0 }
  local blockPosition18 = { x=24.0 + 17.0 * blockOffset, y=0.0, z=0.0 }
  local blockPosition19 = { x=24.0 + 18.0 * blockOffset, y=0.0, z=0.0 }
  local blockPosition20 = { x=24.0 + 19.0 * blockOffset, y=0.0, z=0.0 }
  local blockPosition21 = { x=24.0 + 20.0 * blockOffset, y=0.0, z=0.0 }

  return blockPosition1, blockPosition2, blockPosition3, blockPosition4, blockPosition5, blockPosition6, blockPosition7, blockPosition8, blockPosition9, blockPosition10, 
      blockPosition11, blockPosition12, blockPosition13, blockPosition14, blockPosition15, blockPosition16, blockPosition17, blockPosition18, blockPosition19, blockPosition20, blockPosition21
end


function calculateBlocks(minValue, maxValue, value, numberOfSteps, sliderDirection)
  numberOfSteps = math.max(numberOfSteps, 1)
  local v = 168.0 * (value - minValue)/(maxValue - minValue)
  local blockOffset = 168.0 / numberOfSteps
  
  local block1Active = false
  local block2Active = false
  local block3Active = false
  local block4Active = false
  local block5Active = false
  local block6Active = false
  local block7Active = false
  local block8Active = false
  local block9Active = false
  local block10Active = false
  local block11Active = false
  local block12Active = false
  local block13Active = false
  local block14Active = false
  local block15Active = false
  local block16Active = false
  local block17Active = false
  local block18Active = false
  local block19Active = false
  local block20Active = false
  local block21Active = false
  
  if (sliderDirection == 0) then
    block1Active = ( v >= 0.0 )
    block2Active = ( v > 1.0 * blockOffset )
    block3Active = ( v > 2.0 * blockOffset )
    block4Active = ( v > 3.0 * blockOffset )
    block5Active = ( v > 4.0 * blockOffset )
    block6Active = ( v > 5.0 * blockOffset )
    block7Active = ( v > 6.0 * blockOffset )
    block8Active = ( v > 7.0 * blockOffset )
    block9Active = ( v > 8.0 * blockOffset )
    block10Active = ( v > 9.0 * blockOffset )
    block11Active = ( v > 10.0 * blockOffset )
    block12Active = ( v > 11.0 * blockOffset )
    block13Active = ( v > 12.0 * blockOffset )
    block14Active = ( v > 13.0 * blockOffset )
    block15Active = ( v > 14.0 * blockOffset )
    block16Active = ( v > 15.0 * blockOffset )
    block17Active = ( v > 16.0 * blockOffset )
    block18Active = ( v > 17.0 * blockOffset )
    block19Active = ( v > 18.0 * blockOffset )
    block20Active = ( v > 19.0 * blockOffset )
    block21Active = ( v > 20.0 * blockOffset )
  else
    local activeBlock = math.floor(v/blockOffset) + 1
    local centerBlock = math.floor(numberOfSteps/2 + 1)
    block1Active = (1 >= activeBlock)
    block2Active = (2 == centerBlock) or ((2 < centerBlock) and (2 >= activeBlock) or (2 > centerBlock) and (2 <= activeBlock))
    block3Active = (3 == centerBlock) or ((3 < centerBlock) and (3 >= activeBlock) or (3 > centerBlock) and (3 <= activeBlock))
    block4Active = (4 == centerBlock) or ((4 < centerBlock) and (4 >= activeBlock) or (4 > centerBlock) and (4 <= activeBlock))
    block5Active = (5 == centerBlock) or ((5 < centerBlock) and (5 >= activeBlock) or (5 > centerBlock) and (5 <= activeBlock))
    block6Active = (6 == centerBlock) or ((6 < centerBlock) and (6 >= activeBlock) or (6 > centerBlock) and (6 <= activeBlock))
    block7Active = (7 == centerBlock) or ((7 < centerBlock) and (7 >= activeBlock) or (7 > centerBlock) and (7 <= activeBlock))
    block8Active = (8 == centerBlock) or ((8 < centerBlock) and (8 >= activeBlock) or (8 > centerBlock) and (8 <= activeBlock))
    block9Active = (9 == centerBlock) or ((9 < centerBlock) and (9 >= activeBlock) or (9 > centerBlock) and (9 <= activeBlock))
    block10Active = (10 == centerBlock) or ((10 < centerBlock) and (10 >= activeBlock) or (10 > centerBlock) and (10 <= activeBlock))
    block11Active = (11 == centerBlock) or ((11 < centerBlock) and (11 >= activeBlock) or (11 > centerBlock) and (11 <= activeBlock))
    block12Active = (12 == centerBlock) or ((12 < centerBlock) and (12 >= activeBlock) or (12 > centerBlock) and (12 <= activeBlock))
    block13Active = (13 == centerBlock) or ((13 < centerBlock) and (13 >= activeBlock) or (13 > centerBlock) and (13 <= activeBlock))
    block14Active = (14 == centerBlock) or ((14 < centerBlock) and (14 >= activeBlock) or (14 > centerBlock) and (14 <= activeBlock))
    block15Active = (15 == centerBlock) or ((15 < centerBlock) and (15 >= activeBlock) or (15 > centerBlock) and (15 <= activeBlock))
    block16Active = (16 == centerBlock) or ((16 < centerBlock) and (16 >= activeBlock) or (16 > centerBlock) and (16 <= activeBlock))
    block17Active = (17 == centerBlock) or ((17 < centerBlock) and (17 >= activeBlock) or (17 > centerBlock) and (17 <= activeBlock))
    block18Active = (18 == centerBlock) or ((18 < centerBlock) and (18 >= activeBlock) or (18 > centerBlock) and (18 <= activeBlock))
    block19Active = (19 == centerBlock) or ((19 < centerBlock) and (19 >= activeBlock) or (19 > centerBlock) and (19 <= activeBlock))
    block20Active = (20 == centerBlock) or ((20 < centerBlock) and (20 >= activeBlock) or (20 > centerBlock) and (20 <= activeBlock))
    block21Active = (21 == centerBlock) or ((21 < centerBlock) and (21 >= activeBlock) or (21 > centerBlock) and (21 <= activeBlock))
  end
  
  return block1Active, block2Active, block3Active, block4Active, block5Active, block6Active, block7Active, block8Active, block9Active, block10Active,
  block11Active, block12Active, block13Active, block14Active, block15Active, block16Active, block17Active, block18Active, block19Active, block20Active, block21Active
end





-- returns true, if slider edit mode (selected state) should be toggled (on controller release)
function sliderControllerInputFunction( keyCode, pressed, pressedPrev, param )
    local result = (keyCode == KeyCodes.KEY_PRESS and pressedPrev and not pressed)

    return result
end

-- returns true, if slider should change its value (controller rotate, and active edit mode)
function sliderControllerInputChangeValueFunction( keyCode, pressed, pressedPrev, param, editMode )
    
    if not editMode then
        return false, false
    end
    
    local increase = (keyCode == KeyCodes.KEY_RIGHT)
    local decrease = (keyCode == KeyCodes.KEY_LEFT)
    
    return increase, decrease

end

-- return new slider value by absolute touch coordinates
function sliderTouchInputSetValueFunction( posX, minValue, maxValue )
    -- map [minValue,maxValue] to [newMin,newMax] with some slack at the interval boundaries
    local delta = 28.0 * (maxValue - minValue) / 144.0
    local newMin = minValue - delta
    local newMax = maxValue + delta
    -- touch position range is in [-1,1]; map to [newMin,newMax] with some slack at the interval boundaries
    local v = newMin + ((posX + 1.0)/2.0) * (newMax - newMin)
    if v < minValue then
        return minValue
    elseif v > maxValue then
        return maxValue
    end
    
    return v

end

-- return min or max slider value depending on x offset direction
function sliderTouchInputSetMinMaxValueFunction( offsetX, minValue, maxValue )

    if offsetX < 0 then
        return minValue
    else
        return maxValue
    end

end
-- return slider value change by relative touch coordinate change
function sliderTouchInputChangeValueFunction( dragOffsetX, minValue, maxValue )

    -- map [minValue,maxValue] to [newMin,newMax] with some slack at the interval boundaries
    local delta = 28.0 * (maxValue - minValue) / 144.0
    local newMin = minValue - delta
    local newMax = maxValue + delta
    
    -- touch position offset range is in [-2,2]; map the maximum offset (2) to newMax - newMin to get a value range offset
    -- the sensitivity of the value change can be adjusted by the dragOffsetX factor
    local v = (2.0 * dragOffsetX) / 2.0 * (newMax - newMin)
    
    return v

end

-- returns startEdit, endEdit flags; this is more robust than a "toggle" flag
-- (accidentally starting edit mode twice shouldn't turn it off)
function sliderTouchInputToggleEditFunction( down, event )
    
    local startEdit = (event == ETouchEvent.Start) and down
    local endEdit = (event == ETouchEvent.End) and not down

    return startEdit, endEdit
end