--- /dev/null
+--
+-- Conky Lua scripting example
+--
+-- Copyright (c) 2009 Brenden Matthews, all rights reserved.
+--
+-- This program is free software: you can redistribute it and/or modify
+-- it under the terms of the GNU General Public License as published by
+-- the Free Software Foundation, either version 3 of the License, or
+-- (at your option) any later version.
+--
+
+function components_to_colour(r, g, b)
+ -- Take the RGB components r, g, b, and return an RGB integer
+ return ((math.floor(r + 0.5) * 0x10000) + (math.floor(g + 0.5) * 0x100) + math.floor(b + 0.5)) % 0xffffff -- no bit shifting operator in Lua afaik
+end
+
+function colour_to_components(colour)
+ -- Take the RGB components r, g, b, and return an RGB integer
+ return (colour / 0x10000) % 0x100, (colour / 0x100) % 0x100, colour % 0x100
+end
+
+function conky_top_colour(value, default_colour, lower_thresh, upper_thresh)
+ --[[
+ This function returns a colour based on a threshold, by adding more of
+ the red component and reducing the other components. ``value'' is the
+ value we're checking the thresholds against, ``default_colour'' is the
+ original colour (before adjusting), and the ``lower_thresh'' and
+ ``upper_thresh'' parameters are the low and high values for which we
+ start applying redness.
+ ]]
+ local r, g, b = colour_to_components(default_colour)
+ local colour = 0
+ if value ~= nil and (value - lower_thresh) > 0 then
+ if value > upper_thresh then value = upper_thresh end
+ local perc = (value - lower_thresh) / (upper_thresh - lower_thresh)
+ if perc > 1 then perc = 1 end
+ -- add some redness, depending on where ``value'' lies within the
+ -- threshhold range
+ r = r + perc * (0xff - r)
+ b = b - perc * b
+ g = g - perc * g
+ end
+ colour = components_to_colour(r, g, b)
+ return string.format("${color #%06x}", colour)
+end
+
+-- parses the output from top and calls the colour function
+function conky_top_cpu_colour(arg)
+ -- input is the top var number we want to use
+ local str = conky_parse(string.format('${top name %i}${top cpu %i}${top mem %i}', tonumber(arg), tonumber(arg), tonumber(arg)))
+ local cpu = tonumber(string.match(str, '(%d+%.%d+)'))
+ return conky_top_colour(cpu, 0xd3d3d3, 25, 70) .. str
+end
+
+function conky_top_mem_colour(arg)
+ -- input is the top var number we want to use
+ local str = conky_parse(string.format('${top_mem name %i}${top_mem mem_res %i} ${top_mem mem_vsize %i}', tonumber(arg), tonumber(arg), tonumber(arg)))
+ local mem = tonumber(string.match(str, '%w+%s+(%d+%.%d+)%w%s%s'))
+ -- tweak the last 3 parameters to your liking
+ -- my machine has ~8GiB of ram, so an upper thresh of 15% seemed appropriate
+ return conky_top_colour(mem, 0xd3d3d3, 10, 24) .. str
+end
+
+function conky_top_io_colour(arg)
+ -- input is the top var number we want to use
+ local str = conky_parse(string.format('${top_io name %i}${top_io io_read %i} ${top_io io_write %i} ${top_io io_perc %i}', tonumber(arg), tonumber(arg), tonumber(arg), tonumber(arg)))
+ local ioR,ioW = string.match(str, '%w+%s+(%d+%.*%d*%w)%s+(%d+%.*%d*%w)%s+')
+ local tot = conky_parse("${to_bytes "..ioR.."}") + conky_parse("${to_bytes "..ioW.."}") --these can be bytes or mb :(
+ -- tweak the last 3 parameters to your liking
+ -- my machine has ~8GiB of ram, so an upper thresh of 15% seemed appropriate
+ str = string.gsub(str," 0B", " 0.00B")
+ return conky_top_colour(tot, 0xd3d3d3, 100, 200) .. str
+end
+
+function colour_transition(start, stop, position)
+ --[[
+ Transition from one colour to another based on the value of
+ ``position'', which should be a number between 0 and 1.
+ ]]
+ local rs, gs, bs = colour_to_components(start) -- start components
+ local re, ge, be = colour_to_components(stop) -- end components
+ local function tr(s, e, p)
+ return e + (e - s) * p
+ end
+ local rr, gr, br = tr(rs, re, position), tr(gs, ge, position), tr(bs, be, position) -- result components
+ return components_to_colour(rr, gr, br)
+end
+
+function get_timezone_offset()
+ -- returns the number of seconds of timezone offset
+ local tz = tonumber(os.date('%z'))
+ local tzh = math.floor(tz / 100 + 0.5)
+ local tzm = math.abs(tz) % 100 / 60.
+ if tzh < 0 then tzm = -tzm end
+ return (tzh + tzm) * 3600
+end
+
+function julian_to_unix(J)
+ -- converts a julian date into unit time
+ return (J - 2440588) * 86400
+end
+
+function get_julian_now()
+ -- returns the current time in julian date format
+ local now = os.time()
+ return now / 86400. + 2440588
+end
+
+function calculate_sunrise_sunset(latitude, longitude)
+ --[[
+ This function returns the unix timestamps in the local time for sunrise and
+ sunset times, according to ``latitude'' and ``longitude''. For the
+ latitude, north is positive and south is negative. For the longitude, west
+ is negative, and east is positive. You can usually determine the lat/long
+ for your location from Wikipedia or using some mapping tool.
+
+ In my case (Calgary, AB) the lat/long are 51.045 and -114.057222
+
+ Reference: http://en.wikipedia.org/wiki/Sunrise_equation
+ ]]
+
+ -- Negate longitude, west is positive and east is negative
+ longitude = -longitude
+
+ -- Calculate current Julian Cycle
+ local n = math.floor(get_julian_now() - 2451545 - 0.0009 - longitude / 360 + 0.5)
+
+ -- Approximate Solar Noon
+ local Js = 2451545 + 0.0009 + longitude / 360 + n
+
+ -- Solar Mean Anomaly
+ local M = (357.5291 + 0.98560028 * (Js - 2451545)) % 360
+
+ -- Equation of Center
+ local C = (1.9148 * math.deg(math.sin(math.rad(M)))) + (0.0200 * math.deg(math.sin(math.rad(2 * M)))) + (0.0003 * math.deg(math.sin(math.rad(3 * M))))
+
+ -- Ecliptic Longitude
+ local lam = (M + 102.9372 + C + 180) % 360
+
+ -- Solar Transit
+ local Jt = Js + (0.0053 * math.deg(math.sin(math.rad(M)))) - (0.0069 * math.deg(math.sin(math.rad(2 * lam))))
+
+ -- Declination of the Sun
+ local delta = math.deg(math.asin(math.sin(math.rad(lam)) * math.sin(math.rad(23.45))))
+
+ -- Hour Angle
+ local w = math.deg(math.acos((math.sin(math.rad(-0.83)) - math.sin(math.rad(delta)) * math.sin(math.rad(latitude))) / (math.cos(math.rad(latitude)) * math.cos(math.rad(delta)))))
+
+ local J_set = 2451545 + 0.0009 + ((w + longitude)/360 + n + (0.0053 * math.deg(math.sin(math.rad(M)))) - (0.0069 * math.deg(math.sin(math.rad(2 * lam)))))
+ local J_rise = Jt - (J_set - Jt)
+
+
+ local rising_t, setting_t = julian_to_unix(J_rise), julian_to_unix(J_set)
+
+ -- apply timezone offset
+ local tz_offset = get_timezone_offset()
+ rising_t = rising_t + tz_offset
+ setting_t = setting_t + tz_offset
+
+ return rising_t, setting_t
+end
+
+local last_sunrise_set_check = 0
+local sunrise, sunset = 0
+
+function conky_datey(latitude, longitude, change)
+ --[[
+ Returns a colour at or between day_sky and night_sky (see below) depending on the
+ time of day. You must provide the ``latitude'' and ``longitude''
+ parameters for your location (see the comments for
+ calculate_sunrise_sunset() above for more info). The ``change'' parameter
+ is the number of hours we want to start and have a transition, so a value
+ of 1 will mean the transition starts 30 minutes before, and ends 30 minutes
+ after.
+ ]]
+ local function to_hours(t)
+ return tonumber(os.date('%k', t)) + (tonumber(os.date('%M', t)) / 60) + (tonumber(os.date('%S', t)) / 3600)
+ end
+ if last_sunrise_set_check < os.time() - 86400 then
+ sunrise, sunset = calculate_sunrise_sunset(tonumber(latitude), tonumber(longitude))
+ -- convert unix times into hours
+ sunrise, sunset = to_hours(sunrise), to_hours(sunset)
+ end
+ local day_sky = 0x6698FF -- colour to use during daytime
+ local night_sky = 0x342D7E -- colour to use during nighttime
+ local hour = to_hours(os.time())
+ if hour > sunrise + change / 2 and hour < sunset - change / 2 then
+ -- midday
+ sky = day_sky
+ elseif hour > sunset + change / 2 or hour < sunrise - change / 2 then
+ -- midnight
+ sky = night_sky
+ elseif hour > sunset - change / 2 then
+ -- sunset time
+ sky = colour_transition(day_sky, night_sky, (hour - sunset - change / 2) / change)
+ elseif hour < sunrise + change / 2 then
+ -- sunrise time
+ sky = colour_transition(night_sky, day_sky, (hour - sunrise - change / 2) / change)
+ end
+ return string.format('${color #%6x}', sky)
+end
+
+require 'imlib2'
+
projects / monky / blobdiff