The Peachy Blog

2011-07-08T13:48:00.000-07:00

Weather in conky

Although conkyForecast is an excellent script, (and should be the first step for anyone who wants weather in their conky) when I recently reformatted and lost all my conkyForecast files I wasn't too keen on going through the weather.com registration again.

So I've been looking at alternate ways of getting weather, particularly getting pretty icons. One was is here
http://crunchbanglinux.org/forums/post/104686/#p104686
look a few posts down for the code, although seeing as it is specific to my local weather station for the weather and the images, it probably wont work for you.

also out of this i had a way of drawing rounded corner boxes which I have further developed in various background scripts.

With the weather there is also time and date and system info. Everything is generated in a Lua script. Not only do I find it easier, I find it is lighter on resources than running code from the conkyrc.

An example of that is here

http://crunchbanglinux.org/forums/post/115451/#p115451

2011-07-08T13:38:00.000-07:00

Conky system monitor

I wanted to get as much information about my system onto the screen using lua and conky. This is what I came up with

from this post
http://crunchbanglinux.org/forums/post/102809/#p102809

These setups are pretty complex and require some other things to be running such as vnstat.

2011-07-08T13:20:00.000-07:00

NEW UPADTES! amazing!

Lua calendar

I think this is the most up to date code for the lua calendar
http://crunchbanglinux.org/forums/post/110725/#p110725

The standard way to get calendars in conky is by cal followed by some complicated regex to make the current day show up in a different color. Other than that you don't have much control over the layout and you have to use a mono font otherwise everything is out of line.

This calendar can use any font you like and still keep aligned. You can also control many other aspects of the calendar layout.

2010-12-26T22:18:00.001-08:00

Mayan calendar

UPDATE
I made the calendar much more readable by adding text labels around the rings like so:

I've just been cleaning up the code and found a couple of errors that have been corrected. You can find the code for the above here.

--Original post below-----------------------

I have been thinking about setting up a "year clock" using multiple rings showing progress in the year, month, day, hour, and minute. I had come up with some designs like so:

In this case the largest circle is the year and the dot on the circle is where we are in the year. The next largest circle is the month and the dot where we are in the month and so on. I had set it up so that everything moved in increments of 1 second. The right side shows what the set up would look like on midnight of December 31st. The nice thing about this clock is that it will never look the same twice in a year. However, it isn't exactly easy to read :)

Next I tried this:

Which uses similar mechanics as the clock above, but as you can see the rings are marked with information. Each circle rotated so that the current date/time was at the top of the ring. Unfortunately this clock proved to be extremely cpu intensive (it was actually pushing my cpu to 100%). I reoriented the circles to this:

But there was no was this script was going to be viable. But I liked the look of the above, with the rings within rings.

Then later I had the idea to try something else and this is what I came up with:

This is when things started looking very Mayan :)
In the above calendar clock, year is the innermost circle and instead of having the circles move I had indicators move around the circles. I also went on to add some system info indicators like so:

The code for the above is here.

Sector11 has also made some cool looking additions to the calendar part. You can see that here. I have a nice Mayan symbol dingbat font that may well be used in conjunction with my circlewriting script to add some glyphs to the calendar also.

2010-12-26T22:11:00.000-08:00

I posted a perspective bar set up some time ago, and thought I would revisit a 3D approach. This is what I ended up with.

The bar rises and falls in relation to whatever conky output you feed it. The script can be found here.

It took a crash refresher course in basic trigonometry to get everything working and I can't guarantee that if you try the script it will work. The bar looks as I wanted it to, but I was hoping to be able to define simple coordinates and have multiple bars generated that all fitted together.

This didn't work out in this script as I the math I was using wasn't calculating the right perspectives for subsequent bars.

2010-12-26T22:02:00.000-08:00

Updates, I have a couple of things that I've been working on recently.

First there is a amalgamated circle generating and circlewriting lua script.
It can do things like this:

And this is a little more complicated (obviously you can get whatever colors you want for rings and text I was just feeling monochrome when I made these.)

The intertwining effect is made by making different bits of the circle at different points in the lua script. In lua the later instances of cairo graphics are drawn above any earlier instances.

The script can be found here on the crunchbang Linux forum (where you can see a more colorful use of the script. It can also generate bars that can be placed and rotated freely.

Splitting text into individual letters

2010-10-14T22:12:00.000-07:00

One Lua trick that I use a lot is taking a string and splitting it up into individual characters which then get stored in a table.

I used this approach for my circle writing function and many other functions. This is how it's done.

You need the following function in the Lua script above the main function. I did not write this function and I cant remember exactly where I got it from but whoever did write it has my thanks!

function string:split(delimiter)
local result = { }
local from = 1
local delim_from, delim_to = string.find( self, delimiter, from )
while delim_from do
table.insert( result, string.sub( self, from , delim_from-1 ) )
from = delim_to + 1
delim_from, delim_to = string.find( self, delimiter, from )
end
table.insert( result, string.sub( self, from ) )
return result
end

These are the lines that split up the text...

text="text"
print (text) --> text

sub=string.gsub(text, ".", "%1|")
-- the above inserts "|" after every character
print (sub) --> t|e|x|t|

split=string.split(sub, "|")
-- the above splits the string whenever a "|" occurs and also deletes the "|"
the resulting split up characters are stored in a table called split in this case

slen=string.len(text)
-- slen is the length of the original text,
so will be the number of entries in that table "split"

so that:
split[1] = "t"
split[2] = "e"
split[3] = "x"
split[4] = "t"

now I can deal with each character individually.
I could give each character a different font, or a different color
or, in the case of my square font conky below, convert each character to the square font.

Square text conky

2010-10-14T21:56:00.001-07:00

I had an idea for a conky. I wanted it to be extremely compact and involve text in different orientations. This is what I ended up with!

The problem was that I spent a long time looking for a square font. I found several fonts that I liked but when I came to rotate them and put rotated letters next to regularly orientated letters I found that none of the fonts were actually square. Non were the same width as height.

So I decided to make my own font using the Lua script. I had done something similar in my ascii text lua; a function that read each letter of the text I wanted displayed and converted the letter into ascii.

In this case I created my own square font out of the webdings font. With webdings a "g" gave me a solid color square, while "c" gave me a black square with a color outline. I simply constructed my letters using those blocks like so:

if letter=="T" then
font="webdings"
acrosst=across
downt=down
rotate=rotate*math.pi/180
cairo_translate (cr, acrosst, downt)
cairo_rotate (cr, rotate)
cairo_select_font_face (cr, font, CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
cairo_set_font_size (cr, fontsize);
cairo_set_source_rgba (cr, red, green, blue, alpha);
cairo_move_to (cr, 0, 0);
cairo_show_text (cr, "ggggg")
ldown=fontsize
cairo_move_to (cr, 0, ldown);
cairo_show_text (cr, "ccgcc")
ldown=fontsize+ldown
cairo_move_to (cr, 0, ldown);
cairo_show_text (cr, "ccgcc")
ldown=fontsize+ldown
cairo_move_to (cr, 0, ldown);
cairo_show_text (cr, "ccgcc")
ldown=fontsize+ldown
cairo_move_to (cr, 0, ldown);
cairo_show_text (cr, "ccgcc")
cairo_rotate (cr, -1*rotate)
cairo_translate (cr, -1*acrosst, -1*downt)
end

I actually really like the look of the resulting square "font". And everything fitted nicely together with no gaps :)

Go here to take a look at the code via the link. This is another really long script, mainly because of the letter conversion function. Originally I set up the function converting lowercase letters into upper case letters of the square font. But I didn't like the way they looked, so I re-wrote the letter conversion function to include converting uppercase letters to a different version of the square font.

I just used the lua command string.upper to make everything uppercase and fed it to the conversion function. I never bothered to delete the lowercase conversion lines :)

Final Fantsy VII

2010-10-14T21:26:00.000-07:00

I am a big final fantasy 7 fan, so when rabidofx posted a FF7 themed conky, I immediately thought of the potential to turn the FF7 bottom combat panel into a conky display.

And this is what I eventually came up with!

I have tried to be as faithful as I can to the FF7 panel while still allowing the conky to function as a source of information.

It still needs some work and the script needs a good cleanup and improvements to make it more user friendly. You can get the code here at conky-pitstop! Or here on the crunchbanglinux forum. While your on the forum check out rabidfox's post directly above. He has modified ADcomps Adeskbar to look like materia slots (very nice!).

So why does it take 2200 lines of lua code to produce my FF7 panel conky?
Well 3 reasons... first because it's just a little messy. A lot of copying and pasting went on and I'm sure that I could comb through it an eliminate a large number of supurflouous lines :)

Second drawing in lua with the cairo library takes a lot of lines. To draw the blue shaded rectangles required this:

sa=5
sd=5
rh=120
rw=280
red=1
green=1
blue=1
alpha=1
pat = cairo_pattern_create_linear (sa, sd, rh, rw)
cairo_pattern_add_color_stop_rgba (pat, 0, red-1, green-1, blue, alpha)
cairo_pattern_add_color_stop_rgba (pat, 1, red-1, green-1, blue-1, alpha)
cairo_set_source (cr, pat)
cairo_rectangle (cr, sa, sd, rw, rh)
cairo_fill (cr)

I could have used less lines and specified the positions and colors etc in the actual pattern and drawing lines, but this way is just so much easier for fine tuning. I set the colors up like this becasue I kept forgetting which number represented what in the cairo_set_pattern lines! :)

The grey border around the blue was also line intensive.

Reason 3, and perhaps the main reason for the length of the script is the way you have to use cairo to display text. And if you look closely you will see that every piece of text has a black "shadow" ...which is simply the same piece of text, colored black and printed behind and offset a little.

font="Acknowledge TT (BRK)"
text=topl1
fsize=20
red=0
green=0
blue=0
alpha=1
across=32
down=22
cairo_select_font_face (cr, font, CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
cairo_set_font_size (cr, fsize);
cairo_set_source_rgba (cr, red, green, blue, alpha);
cairo_move_to (cr, across, down);
cairo_show_text (cr, text)
red=0.8
green=0.8
blue=0.8
alpha=1
across=across-2
down=down-2
cairo_set_source_rgba (cr, red, green, blue, alpha);
cairo_move_to (cr, across, down);
cairo_show_text (cr, text)

So I had to set the font, set the font size, set the red, green, blue and alpha, set the position, write the font, fontsize and color setup lines, move cairo to the coordinates and then tell it to diaplay the text. That gave me the shadow, then I had to change the color and position, set up the text drawing variables and draw the main text.

I kept this format throughout the script, so i could easily change colors and positions without wading through a sea of setup lines.

2010-09-11T21:23:00.000-07:00

Here is my latest conky configuration

conkybar!

and this is what it looks like currently:

Nothing out of the ordinary in terms of content over many other conkyrc generated displays.

But with a few differences.

The first thing is that every is generated in a lua script. The second is that those black triangles at the top are clickable buttons. Here is how this setup functions.

A while ago on the crunchbanglinux website a poster by the name of jpope had a wallpaper that had a large power button right in the middle of the screen. Here is the post:
http://crunchbanglinux.org/forums/post/45907/#p45907

ADcomp had written a python script to place a button on the desktop that would launch a command or script. The button could be placed anywhere and you could make your own icons for it to use and it could execute any command when you click it. It was all set up in the script.

I thought that was pretty cool and I stored it in the back of my mind.

Then recently I started looking into the file io function of lua, the ability to open files in the lua script, read their contents and store that as strings which could be manipulated in the script. I had been working on some bash scripts using curl to download information from webpages, then editing the html to pull out specific pieces of information.

I had been using the conky_parse command in lua to execute the bash scripts via conky, but I was trying to bring some of the operations into the native lua language to make the scripts run a little lighter cpu wise.

However, once I started playing around with the file io commands I realised that I could affect the whole lua script by having the script "watching" a text file and then editing the file, initially via a terminal command.

something like this:
$ touch /tmp/setw.txt; echo "1" > /tmp/setw.txt

the touch command creates the file then the > writes a "1" into the file.
a similar command could then easily ovewrite the "1" with a "2"

so if i had the Lua script watching that file I could put the output into a string and use the string as a basis for an if statement.

These are the lines that watch the text files in the lua script

wread = io.open("/home/mcdowall/conkyset/wset.txt", "r")
wset = wread:read("*lines")

I've changed the names and moved the files out of /tmp so they are persistant.

So now a simple:

if wset=="1" then
--display one thing--
end

if wset=="2" then
--display something else--
end

gives me interactive control over the script.

I then remembered the button script I had seen, and after some searching (and asking) I had the link to the script.

take a look at this entry on the ubuntu conky thread for more infomation on how the interaction works.
http://ubuntuforums.org/showpost.php?p=9826304&postcount=13840

The actual lua script can be found here. It is still very much a work in progress.
http://ubuntuforums.org/showpost.php?p=9830734&postcount=13855

The fact that everything has to be constructed in lua was itself a challenge. Lua doesn't have all the goodies pre-programmed into it like the objects you can get in a conkyrc by putting in the right command

The calendars were tricky. I saw londonali1010's post on lua calendars here
http://mylittledesktop.blogspot.com/2009/10/argh-my-first-snag-with-my-lovely.html

I looked over her code and borrowed a couple of lines (for calculating start day), but went about contructing the calendar in a very different way. The result was a calendar that looked very similar to the one available through a conkyrc. I'm still trying to perfect the day indicator however.

The biggest limitation to using Lua to construct a complete conky output is how it handles displaying text. It takes a lot of lines to get the tables you see in my output, far more than if I were to do the same thing in a straight conkyrc.

Anyway, I'm still working on the content of the conky but I am happy how the mechanics have worked out!

As it stands right now this setup is no more cpu draining than my regular all conkyrc setup. And when I have all the sections rolled up (except system monitor so that I can see the cpu usage) it runs much lighter. When a section is "rolled up" or inactive the lua script does not have to do any of the calculations or rendering for that section.

2010-08-29T22:00:00.001-07:00

Animated text conky.
Here is a concept for a conky that I have been thinking about for a while.

having the text in conky appear as if it were being typed.

The idea came a while back when I was thinking about how to get a better scroll function in conky, and I was working on a matrix rain themed conky. I thought it would be cool if you could get text in conky to appear like the text that appeared on Neo's computer in the movie.

I just hadn't done anything about it till now.

Thanks go to iggykoopa of the crunchbanglinux forum for his help with coding. Other wise the script would be very difficult to change. Now you can set up the script to display any text you like, when you like and where you like. It's still a bit tricky as you have to work out your timings for each section of text to appear, pause and vanish.

I have set it up so that you get the impression that a program is runing inside of conky, scanning your system and fetching the information.

You can get the code on the crunchbang linux forum here.

2010-07-31T20:21:00.000-07:00

My latest conky plots the position of the sun throughout the day. The Lua script also calculates and displays the sun's altitude and azimuth as it changes throughout the day. I had to get to grips with some equations and also get to grips with how to do those calculations in Lua.

The conky has 2 scripts that make it work.
Firstly there is a bash script that uses the curl function to access a webpage. Then using grep, awk and sed I extracted key astronomical data from the page.

The Lua script is then fed the data via conky and uses the numbers to perform all the necessary calculations. I also display a range of data in the conky via the Lua script.

The figure is all based on equations which are in turn based on the data I gathered. The figure shows a very accurate representation of the position of the sun relative to the horizon.

You can get the code for the bash and Lua script on the crunchbang linux website here.

If you are interested in using this conky then be sure to read my post as you will have to make some changes to the scripts regarding geographical location.

2010-07-31T19:48:00.000-07:00

Here is a new conky/lua setup from me.

This is based on a wallpaper created by the ever talented gutterslob which he posted on the crunchbang linux website here.

This was posted back in March and I said at the time that it would make a great conky but I never went any further than that. Then recently I saw someone else on the crunchbang site post a screenshot using the wallpaper and, as I had some time to kill, I started making a conky display based upon it.

This is how it turned out (everything is labeled in the picture)

The code is on the crunchbang website here.
The code is ugly, overlong, overcomplicated and far from user friendly. The Lua script is an amalgamation of bits of previous lua scripts with modifications but I have yet to go through the code and clean it up.

There are some innovations. I think my clock turned out quite nicely and I haven't seen a clock like that before. I also liked the idea of a wordless/numberless figure (which this is)

Also my upspeed and downspeed bars, while seemingly simple, display speed as a percentage of total possible speed (determined via speed testing). The lua script can differentiate between bytes, kilobytes and megabytes per second (that is output by the conky object upspeed for example) and calculate speed in a single unit which makes this possible.

2010-03-16T08:56:00.000-07:00

I haven't been very active conky wise lately and it looks like I won't be able to spend much time in the future on conky/Lua tinkering either.

I have projects that are going to be keeping me busy. But hopefully I will have a few hours here and there to play!

I've still got lots of good ideas about things to do with Lua/cairo scripts, but as the scripts get more complicated they also take longer to write and test.

I guess I'm entering a mostly retired state as far as conky goes.

2010-03-06T20:09:00.001-08:00

Numbers to text conversion functions.
Code available on the crunchbanglinux forum here.

I have written 3 functions for converting various numbers to text representations.
The first function converts any regular 3 digit or lower number into words, so that:
19 becomes "nineteen" and 487 becomes "four hundred and eighty seven"
I have used this function in the third line in the image above to convert the output of $cpu to words.

The second function converts number dates into text, as in the first line in the image above.

The third converts time data to words as in the middle line above. This function takes into account all the changes that occur with displaying the time as words. For example at 6:01, the function will output "one minute past six". At 6:02 it will be "two minutes past six". At 6:00 it will show "six o'clock" etc. You can choose between having seconds represented or not.

I intend to use these functions with my circlewriting functions to create a text only, non-linear display along the lines of this:

here is what it looks like when its working:

2010-03-01T11:36:00.000-08:00

UPDATE. I have made the perspective drawing function configurable and posted the code on the crunchbanglinux website here. The code there displays the following graphic.

Because everything is based off of equations (which are themselves based off just a few key pieces of data), you can easily use the settings to alter the look of the bars like so:

In this case the red bar is cpu usage.
The green is memperc.
The blue and yellow bars show the percent used of my hard disk drives.
There is a maximum of 6 bars assignable. For more bars the Lua script would have to altered to add them manually.

ORIGINAL POST

I have also been thinking more about creating more isometric figure drawing functions. I put together this one a little while ago. While it does look cool, it clearly does not reflect any kind of reality of how a 3D shape would look from a fixed perspective (which is what isometric means).

So I thought about trying to create a more realistic looking figure. I knew it would involve the use of perspective, but I had no idea about how to create the effect or the mathematical principles behind perspective.

So I turned to google and one of the first things I came across was this video.
That gave me a basic understanding of how the effect was achieved. But I didn't want to simply draw a figure using fixed coordinates (that would have been far too easy), I wanted to have a isometric figure that could be configured through settings.

I had to rapidly re-aquaint myself with the mathematics of triangles!

This is what I ended up with. It takes the output from the previous cpu recording and averaging function.

The largest, whitest bar is current cpu usage, then the next bar is 1 minute, then 5, 15, 30 and 60 minute averages. The darker bars are all low because the conky had not been running for long before I too this screenshot.

You could feed each bar anything you wanted, the first could be current CPU followed by memperc etc. Currently (and for the foreseeable future) to add or remove bars is a manual process. Perhaps someone with more mathematics and coding skill than me could "automate" the drawing process with "for i=numberofbars do".

2010-03-01T11:25:00.000-08:00

A poster by the name of dbro posted a conky config on the crunchbanglinux forum that had an interesting idea about recording data over time and then displaying the data as averages for a period of time via bars.

I took a look at his Lua script but I couldnt work out how it worked :)
I also thought his bars were confusing. I think it was partlly because of the way he was using the Lua script with conky. He wasn't using cairo to display the bars but parsing the Lua script and then creating bars via the $hr conky object.

I liked the idea of being able to compare computer usage now, to avergae usage over a set time period, so I took dbro's idea and applied my own logic and code to achieve this end. This is what I came up with:

The code is here on the crunchbanglinux website. Here you can alse read a little about the evolution of this script and in dbro's post below he sets out a less intensive way to achieve the same result. I have yet to try and implement dbro's method but the cogs are turning as to how I would apply it.

2010-02-27T12:16:00.000-08:00

Another, and most likely the last, variation on my valentine flower Lua script and a final entry in the conky of the month competition on the conky blog.

The biggest change here is the use of shading to the flower petals. Also I changed the shapes that were transformed by the output of the various conky objects so that there is no overlap. I think these changes have added quite a bit of eye-candy value to this conky and the effect was quite simple to apply.

The hearts were also drawn with cairo in the Lua script and shaded to match the flowers. Luckily I had a heart shape already on file from my first flower conky. I tweaked it a bit for shape, inspired by a wallpaper I found here.

I made an option to change the number of petals for each flower, but I didn't factor in how this would affect the shading. As a result changing the number of petals alters the shading effect. This should be easily fixed however if I feel like working on the script some more.

As ever, the code is posted on the crunchbanglinux forum here.

2010-02-25T10:32:00.001-08:00

Text Blur and shadow.

Here is a simple script to add a blur like effect to text and numbers.
It can also be used to make shadows for text.

Here is a comparison of the blur effect in use and text without the effect.

The effect works by taking multiple instances of the same text, making them mostly transparent and then overlaying them with a slight offset for each instance. In this case I am displaying the text at various points around a very small circle.

Like so:

The blur effect uses a much smaller circle and calculates transparency by the number of instances of the text you want.

You can get the code from my post on the crunchbanglinux forum here.

2010-02-24T08:31:00.000-08:00

I took my line graph Lua script, tweaked it a bit and produced the above.
The FSY "heartbeat" blip shows the filesystem used percent, then 1/4 of fsys used.

The MEM goes up to current memory use, stays there for two cycles then goes back to zero.

You can get the code here.

2010-02-23T18:27:00.000-08:00

I was having some trouble with getting the line graph working properly. In fact a few hours were spent getting frustrated with the lua script because it wasn't doing what I wanted it to do!

But then I had a breakthrough and after that it was pretty straightforward :)
This is what the current script is capable of displaying.

In fact the first figure was what I had been after for a while. I wanted my graph to resemble an electroencephalogram.

I'm sure there is more that can be done from this basis so I may well be posting updates in the future.

You can get the code from my post in the crunchbanglinux forum here. You can also watch a short clip of an earlier form of this script in action.

The problem was the transfer of information from the data generating function to the figure drawing function. The problem was that you can only transfer data held in strings. In the data function I was generating a table something like this:

table={}
n=10
for i=1,n do
table[i]=i
end

This would give me a table with 10 entries, the entries being the numbers 1 to 10.
If i did this:

print (table[i])

I would get this output in the terminal:

1
2
3
4
5
6
7
8
9
10

Which has been fine so far, but the table I was using was much more complicated than this and I just couldn't get things working by simply transferring the string "table[i]" to the figure drawing function. What I really needed was to transfer the whole table to the drawing function.

The breakthrough was the use of this command:
string=table.concat(table, ":")

What this does is to take a table and turn it into a string, in this case, each entry in the table will be seperated from the next by a ":" in the string. So our example table from above, print (string) would output the following:
1:2:3:4:5:6:7:8:9:10

I could then take the string, pass it to the drawing function and use the split string function to turn it back into a table. Then I could work from the table to achieve the figure.

2010-02-23T08:20:00.000-08:00

In response to a question asked about vertical graphs on the ubuntu conky thread, I thought that the script I had come up with for bar graphs could be easily modified to give vertical bars. And it was pretty easy.

Then I thought about how I could apply a gradient effect along the bar graph, like you can get in a regular conkyrc, and that wasn't too hard either. So now the script can output graphs like this:

The code to do this has been posted on my original crunchbang linux forum post.

Alternate graphs.

The standard graph outputs from conky are rather uninspiring, so thought I would try and put together some alternatives. The above screenshot is displaying cpu usage over time. Usage is displayed as both a negative and positive value at each point, so you get this kind of "waveform".

You can get the code on the crunchbanglinux forum here.

In the scrip there is a setting that can produce 3 types of graph, the up and down as above, only up or only down as below.

Another improvement over the regular graphs is that you can change which direction the graph moves in.

Other configurables include:

colors
total height
bar width
spacing
gridlines on or off

I am also working on a line graph, but have run into a few problems, and I havnt got it working how I want it yet. But it may not be possible to do what I want either :)
This is what it currently looks like:

I think this graph has a lot of potential however!
See subsequent blog entries for developments.

2010-02-22T11:58:00.000-08:00

When to use "for i = do" and a look at drawing with cairo.

I was fiddling with my updated flowers conky, drawing a bumpy circle with cairo to use as the flowers center. Drawing with cairo via a text file isn't the most user friendly thing you can do, but with some experiementation I had worked out a good way to draw a repeating apttern in a cicle using the cairo_curve_to command.

The approach involved defining a set of circles, and then using the mathematics available in Lua to generate plot points.

Like so:
but first I need to set up some variables!
inner=110
outer1=120
outer2=118
outer3=120
The 4 lines above set out the radius of the circles from which I will be calculating my plot points.
varth1=0.53
varth2=0.42
The above 2 lines will be seen in action later.
hori=150
vert=200
These are positional setups.
Now I can do the drawing.

cairo_translate (cr, hori, vert)
cairo_move_to (cr, 0, 0)
I like to use the translate command for positioning figures. The reason for this is that it allows you to assign the figure "local" coordinates of 0,0 so that you can apply rotations to the figures without cauing problems. When using trandlate in a drawing function you always need to translate back at the bottom of the function. In this case I would translate back with:
"cairo_translate (cr, -hori, -vert)

--inner arc from cairo_set_source_rgba (cr, 1, 1, 1, 1);
text_arc=((2*math.pi/24)*(3))
txs1=0+inner*(math.sin(text_arc))
tys1=0-inner*(math.cos(text_arc))
Above I am setting a starting point for our drawing. The first line is calculating radians for points around the circle. In this case I have divided the circle up into 24 pieces and we are getting the radian value for point number 3. Theres no reason I started at 3, thats just how it happened.
I am also using comments to remind me whats what.

--outer arc through bump1
text_arc=((2*math.pi/24)*(3+varth1))
txs2=0+outer1*(math.sin(text_arc))
tys2=0-outer1*(math.cos(text_arc))
This is the "control" point that will determine the extent of the curve.
Take a look here to see how cairo works out its curves (scroll down a little for curves.)

--outer arc to
text_arc=((2*math.pi/24)*(4))
txs3=0+outer2*(math.sin(text_arc))
tys3=0-outer2*(math.cos(text_arc))
cairo_move_to (cr, txs1, tys1)
This is the coodinates of where the curve will finish.

cairo_curve_to (cr, txs1, tys1, txs2, tys2, txs3, tys3)
And above the curve is being drawn. Because I am drawing very simple curves (arcs really but I find the use of curve_to easier and more understandable than arc_to) I am basically getting this effect:

So the above drawing made a curve out, now we will curve back in, from point txs3,tys3 to coordinates txs5,tys5 and that curve will be controlled by point txs4,tys4 as below.

--outer arc through
text_arc=((2*math.pi/24)*(4+varth2))
txs4=0+outer3*(math.sin(text_arc))
tys4=0-outer3*(math.cos(text_arc))
--outer arc to
text_arc=((2*math.pi/24)*(5))
txs5=0+inner*(math.sin(text_arc))
tys5=0-inner*(math.cos(text_arc))
cairo_curve_to (cr, txs3, tys3, txs4, tys4, txs5, tys5)

This gives me one bump like this:

Then originally I did this:
--outer arc through bump2
text_arc=((2*math.pi/24)*(5+varth1))
txs6=0+outer1*(math.sin(text_arc))
tys6=0-outer1*(math.cos(text_arc))
--outer arc to
text_arc=((2*math.pi/24)*(6))
txs7=0+outer2*(math.sin(text_arc))
tys7=0-outer2*(math.cos(text_arc))
cairo_curve_to (cr, txs5, tys5, txs6, tys6, txs7, tys7)
--outer arc through
text_arc=((2*math.pi/24)*(6+varth2))
txs8=0+outer3*(math.sin(text_arc))
tys8=0-outer3*(math.cos(text_arc))
--outer arc to
text_arc=((2*math.pi/24)*(7))
txs9=0+inner*(math.sin(text_arc))
tys9=0-inner*(math.cos(text_arc))
cairo_curve_to (cr, txs7, tys7, txs8, tys8, txs9, tys9)
--outer arc through bump3
text_arc=((2*math.pi/24)*(7+varth1))
txs10=0+outer1*(math.sin(text_arc))
tys10=0-outer1*(math.cos(text_arc))
--outer arc to
text_arc=((2*math.pi/24)*(8))
txs11=0+outer2*(math.sin(text_arc))
tys11=0-outer2*(math.cos(text_arc))
cairo_curve_to (cr, txs9, tys9, txs10, tys10, txs11, tys11)
--outer arc through
text_arc=((2*math.pi/24)*(8+varth2))
txs12=0+outer3*(math.sin(text_arc))
tys12=0-outer3*(math.cos(text_arc))
--outer arc to
text_arc=((2*math.pi/24)*(9))
txs13=0+inner*(math.sin(text_arc))
tys13=0-inner*(math.cos(text_arc))
cairo_curve_to (cr, txs11, tys11, txs12, tys12, txs13, tys13)

etc etc...

Drawing the lines for the curves one by one, out then in, out then in... until I got all the way around, closed the path and filled it in. This was was pretty easy, just copy and paste and edit the numbers. I also pretty much knew that I didn't have to number the strings in order but I did it anyway. For example:
string=1
print (string) --> 1
string=2
print (string) -->2

But I could see that there was an obvious pattern and was a candidate for using the:

"for i = x,y do" command.

So I looked at the first bump I had drawn, assigned i a value of 1 and then edited the values so that the points I was plotting on the circles were expressed via i, point 3 being i+2 and point 4 being i+3. And setting up a string to supply the number of points, substituting the string into the code. What I ended up with is this:

number=12
for i = 1,number do
cairo_set_source_rgba (cr, 1, 1, 1, 1);
--inner arc from
text_arc=((2*math.pi/number)*(i+2))
txs1=0+inner*(math.sin(text_arc))
tys1=0-inner*(math.cos(text_arc))
--outer arc through bump1
text_arc=((2*math.pi/number)*((i+2)+varth1))
txs2=0+outer1*(math.sin(text_arc))
tys2=0-outer1*(math.cos(text_arc))
--outer arc to
text_arc=((2*math.pi/number)*(i+3))
txs3=0+outer2*(math.sin(text_arc))
tys3=0-outer2*(math.cos(text_arc))
cairo_move_to (cr, 0, 0)
cairo_line_to (cr, txs1, tys1)
cairo_curve_to (cr, txs1, tys1, txs2, tys2, txs3, tys3)
--outer arc through
text_arc=((2*math.pi/number)*((i+3)+varth2))
txs4=0+outer3*(math.sin(text_arc))
tys4=0-outer3*(math.cos(text_arc))
--outer arc to
text_arc=((2*math.pi/number)*(i+4))
txs5=0+inner*(math.sin(text_arc))
tys5=0-inner*(math.cos(text_arc))
cairo_curve_to (cr, txs3, tys3, txs4, tys4, txs5, tys5)
end
cairo_close_path (cr)
cairo_fill (cr)

But it wasn't quite so simple. For some reason the shapes of the bumps changed (they were alot more pointy instead of round) and I had to add these lines or the middle of my drawing did not get filled in:
cairo_move_to (cr, 0, 0)
cairo_line_to (cr, txs1, tys1)

But it was quite easy to fiddle with the settings to make the bumps rounded and voila!.

So when you have a repeating pattern, of you want multiple instances of a figure, then it's a good bet that you can cut down the line count by using this technique. You can also affect other things with the "i" term. Achieving a position change from figure to figure you could do something like:

horizontal = 10*i
vertical = 10

in this case you would get a horizontal line of figures, spaced 10 apart.

But you could also do something like:
cairo_set_source_rgba (cr, 1, 1, 1, 0+(i/10)

So if "i" has a range of 1 to 10, the first figure would have an alpha of 0.1 while the tenth figure would have an alpha of 1.

Or you can fit "i" into any number of equations and have it affect any number of variables.

And if you want more figures, just increase the range of "i" without having to add any additional lines of code.

2010-02-19T18:52:00.000-08:00

Three Dimensional Bars! Well, I guess to be more accurate they would be called isometric?
I had been thinking about doing this for a while and it seemed like an obvious idea :)

Anyway, I thought this project would be easy, and to begin with it was. Getting a bar on Lua is pretty easy, then all I would have to do is draw a top and a side and get everything moving correctly. This all happened quickly until I started to look at the lines!

Unfortunately I couldn't simply take the shapes I had drawn to form the "faces" with fill, and overlay them using stroke. The corners stuck out when the line width was increased and the different line unison options in cairo were not going to work. So I had to re-do the lines from scratch, and it took far too may attempts and corrections before I finally got it right.

With this script you can specify:

face color
line color
bar width ("depth" is always set to width/2)
bar height
bar position
wire-frame outline on or off
and font, font size, font color and font position

You can get the code on the crunchbanglinux forum here.

2010-02-18T12:39:00.000-08:00

More ring meter variations.
I have added the ability to draw:

anticlockwise indicator
rounded ends to indicator lines
rounded end borders
and square end borders

You can get the cod on the crunchbanglinux forum here.

2010-02-17T12:59:00.000-08:00

I have improved my circlewriting function significantly! No more annoying fiddling about to get it right, the function puts everything in the right place first time. I have kept the option to fine tune through variables to take into account the variations in fonts. I find this function works best with a monospace font anyway.

There are 2 function:
"circlewriting" writes text across the top of a circle, on the outside.
"circlewritingdown" writes text along the bottom of a circle on the inside.
Like so:

You can get the code for these functions here on the crunchbanglinux forum.

Several of my previous Lua scripts have used predecessors of this function. For those, just delete the old function, put in the new functions and make sure that when you activate the function you are giving it all the right information. In the code in the link above I have made the way that you feed the function data a little easier:

--text must be in quotes
text=" Circle Writing "
--font name must be in quotes
font="White Rabbit"
fontsize=18
radius=80
positionx=100
positiony=150
colorred=1
colorgreen=1
colorblue=1
coloralpha=1
letterposition=0
letterrotation=0
circlewritingdown(cr, text, font, fontsize, radius, positionx, positiony, colorred, colorgreen, colorblue, coloralpha, letterposition, letterrotation)

Information is entered line by line with well described strings.

You can also use this kind of display for "live" information. Here I am using the addzero100 function so that the numbers are always 3 digits, although because now the "text" string length is read automatically, the display will alter itself with altering length of "text".

Here is the text strings that achieved the above:

cpu=tonumber(conky_parse('${cpu}'))
text=(" CPU " .. (addzero100(cpu)) .. "% ")

mem=tonumber(conky_parse('${memperc}'))
text=(" MEMORY " .. (addzero100(mem)) .. "% ")

and for reminder here is the addzero100 function:

function addzero100(num)
if tonumber(num) < 10 then
return "00" .. num
elseif tonumber(num) <100 then
return "0" .. num
else return num
end
end

I have now included the ability to set a start and finish position for the displayed text so that you can achieve results like this:

I have updated my post on the crunchbanglinux forum here. The code there outputs the above image. There is also a brief discussion regarding overcoming the alignment problems that are inherent in this function.

2010-02-17T08:52:00.000-08:00

ANOTHER UPDATE :)

I was looking at the code I had written and the cairo commands to draw the flower shapes clearly had repeating patterns, so I decided to use the old "for i =" trick to make the code smaller. This worked and I managed to cut down the line count quite considerably. Then I realized that having done that I could change the range that i is equal to. The end result is that you can now specify the number of petals for each flower, and the bumpy middle always has 2x the number of petals.

Conky flowers revisited.
Go here to the crunchbang forum for the latest code.

UPDATE - I have updated the code in the post above so that the Lua script has my improved circlewriting function.
UPDATE2 - I wasn't completely happy with the circular middles, they seemed too hard. So I have enabled the option to draw bumpy middles as so:

Some significant changes and some significant improvements.
First the improvements:

flower are placeable independently
flowers can be rotated in place without anything else being effected
flowers can be used with any wallpaper and allow transparency effects and overlap

The third improvement was accomplished by redesigning the flower's color change mechanism. In the original the flower color change "effect" was created by placing a circle that changed size in response to a numerical input behind a flower "cutout" (see my crunchbang post to see what I'm talking about). But with the revisit, each petal moves independently from each other (except they are all fed the same number although it would be possible to have each petal represent a separate data output). Everything is contained within the flower shape.

There are some things I need to work on. The circlewriting function needs work. I think I know how to get it working better, but right now it is far too fiddly, adjusting the "variables" to make everything look right.

Anyway, this is yet another (or an alternative) entry in the conky blog valentine competition.

2010-02-15T17:44:00.000-08:00

Here is another Lua script. For the code and to see it in action go here to my post on the crunchbang forum.

require 'cairo'

I have describe the below function in my full screen lua script. This function is here because at first I was just trying to generate numbers arranged around a circle, and I wanted all the numbers to be 3 digits constantly. When I first wrote the function It was to output numbers around a circle. I suppose I need to re-write this script for the sake of clarity :)
function addzero100(num)
if tonumber(num) <>
return "00" .. num
return "0" .. num
else return num
end
end

The below function is the figure drawing function. This was taken from the circle-writing function I wrote for my valentines flower conky.

function circlewriting(inum, text, ival, font, fsize, radi, horiz, verti, tred, tgreen, tblue, var1, var2)
Above is the function name followed by a long list of strings that the function needs to work.

inum - "length" ie the number of instances that the data will move to. In the above image this number was 10.

text - the actual data that is being represented, in this case cpu usage.

ival - in the below function an array is used to generate the data and in that array we will be using the code line:
for i = 1, tonumber(len_t) do
len_t is the same number as "inum" above. So "i" is all the numbers between 1 and 10.

font - to set the font for the text output
fsize - sets the font size
radi - sets the radius of the circle around which the bars or text will be displayed.
horiz - horizontal, x, position.
verti - vertical, y, position
tred - output red color value
tgreen - output green color value
tblue - oputput blue color value
var1 - variable 1
var2 - variable 2

variables 1 and 2 are used to fine tune the position and orientation of the bars or text around the circle.

deg=360/inum
Above is a quick calculation to work out how many degrees there are between each bar. This will be used for the rotation of each bar.

Now comes the hard math!
text_arc=((2*math.pi/inum)*ival+var1)
txs=0+radi*(math.sin(text_arc))
tys=0-radi*(math.cos(text_arc))
The above 3 lines are equations to work out the positions of each bar around the circle.
As we all know: circumference = 2 x pi x radius
and to calculate coordinates for each point around a circle
x=SIN(degrees x n)*radius
and
y=COS(degrees x n)*radius

Where "n" is the number order of the thing that is being displayed. For example, on a clock face there are the numbers 1 to 12. So to get the x,y position of those numbers, n would be 0 for 12, 1 for 1, 2 for 2 etc.

But Lua only works with radians so the first line is converting degrees to radians.
The next 2 calculate the x and y plot points.

cairo_select_font_face (cr, font, CAIRO_FONT_SLANT_NORMAL,
CAIRO_FONT_WEIGHT_NORMAL);
cairo_set_font_size (cr, 22);
cairo_set_source_rgba (cr, tred, tgreen, tblue, ival/10);
The above lines are setting the font, font size and color.

Below are the lines that generate the bars. I worked out how to apply the rotation to the bars "locally" and position them with the translate command.

First the position is translated into position.
cairo_translate (cr, txs+horiz, tys+verti)
Then the bar is rotated below. You might wonder why I am taking the "deg" string, set earlier, and performing calculations on it to convert degrees into radians, when I have already done that 8 lines earlier when I was calculating the x,y plot points of my bars. The answer is simple... when I first wrote the function for the flowers.lua my math skills re circles were extremely rusty, so instead of trying to work out the x,y equations for myself, I borrowed then from dissecting londonali1010's air clock lua script (found here) without really understanding the math but knowing it worked. So when I implemented the rotation feature I wrote the calculations seperately. A case of historical artifacts. Just another thing to clean up in this script :)
cairo_rotate (cr, (deg*(ival+var2)*(math.pi/180)))
Then the rectangle is drawn at "local" position 0,0.
cairo_rectangle (cr, 0, 0, 20, (text*-1))
cairo_fill (cr)
Then the rotation is reset.
cairo_rotate (cr, ((deg*(ival+var2)*(math.pi/180)*-1)))
And finally the translation point is reset. Remember that all cairo transformations are cumulative so if these reset steps were not done then the next bar would be translated and rotated relative to the first bars position and rotation.
cairo_translate (cr, -1*(txs+horiz), -1*(tys+verti))

Here are the lines that generate the text output. I decided to comment them out as I liked the lookof the bars better. But they can be reinstated easily
--you can reinstate these lines to get a text output around the circle
--cairo_move_to (cr, txs+horiz, tys+verti);
--cairo_rotate (cr, (deg*(ival+var2)*(math.pi/180)))
--cairo_show_text (cr, (addzero100(text)))
--cairo_rotate (cr, ((deg*(ival+var2)*(math.pi/180)*-1)))
end
end
Thats the end of the figure drawing function.
Next comes the data generating function.

function conky_draw_graph()
Above is the name of the function, this is the function we will call in conky.
if conky_window == nil then return end
local cs = cairo_xlib_surface_create(conky_window.display, conky_window.drawable, conky_window.visual, conky_window.width, conky_window.height)
cr = cairo_create(cs)
Above is the "canvas" setup just set out a little differently from how I have done it before.

local updates=tonumber(conky_parse('${updates}'))
if updates==1 then
len_t=10
t1={}
end
The above lines are particularly important. Here we are initializing the variable. Basically we are telling Lua that the string called "t1" is a table. We are also setting the "length" of the figure with len_t. It took me a little figuring out to understand why these lines had to be here and why they were set only when conky update number = 1.
The reason is that if the line "t1={}" were moved below with the rest of the function (which has to start when conky updates >3 to prevent a segmentation fault when using the conky object ${cpu}) then with each cycle, the line:
"if updates> 3 then"
would be true and everything below that line would be performed and the data stored table "t" would be reset each time. We are relying on the data in the table to "remember" the past cpu usage numbers so t1={} can only be set once.
if updates> 3 then
Below is the array that will generate the data and store it in the table.
And here is the all important "i"
for i = 1, tonumber(len_t) do
Here we are saying that "i" is equal to every number from 1 to len_t (set above). So to think about this array more simply we will say that "i"=1
if t1[i+1]==nil then t1[i+1]=0 end
The above line is a error checking line to stop the "tried to call a nil value" error that can cause the script to stop functioning.
t1[i]=t1[i+1]
So when "i"=1 then
t1[1]=t1[2].
As we have seen before, numbers, or strings in square brackets relate to an entry in a table, in this case table "t1". This doesnt make much sense until we get to the next couple of lines:
if i==len_t then
t1[len_t]=tonumber(conky_parse('${cpu}'))
end
So when "i" = the upper limit of its range, len_t (which in this case is 10) then t1[10]=current cpu usage. Now everything else is set because
t1[9]=t1[10]
t1[8]=t1[9]
t1[7]=t1[8]
to
t1[1]=t1[2]

Now you might think that if everything equals everything else then why isn't t1[1] to t1[10] all the same number? What you need to think about here is how the Lua script is working with conky. Say you have your conkyrc set to update every second, then every second the Lua script is run from the top, so actually the example I gave above about how the table is set up is the wrong way round.

Because the script lines are performed in order from top to bottom here is what is happening: (or this is how it makes sense to me)

on the first pass at time 1:
t1[10]=cpu usage at time 1

then on the next pass at time 2
t1[9]=t1[10] *but* this is the t1[10] from the previous pass where t1[10]=cpu at time 1
because t1[9] is set every so slightly before t1[10] is reset to equal cpu usage at time 2

and so on it goes so that
t1[10] = current cpu usage at time t
t1[9] = cpu usage at t-1
t1[8] = cpu usage at t-2
t1[7] = cpu usage at t-3
etc...

--circlewriting (inum, text, ival, font, fsize, radi, horiz, verti, tred, tgreen, tblue, var1, var2)
Above I am reminding myself of all the variable i need to send the circlewriting function and below I have called the function with all of the relevant info.
circlewriting(len_t, t1[i], i, "Mono", 22, 40, 200, 200, 0, 0, 0, -0.25, 0)
Below we are ending the part of the function that began "if updates> 3 then" It is important to put the call to the figure writing function above this end.
end
Below we are freeing some memory, althoug in action I havnt noticed any difference from when I use these lines to when I do not use these lines.
cairo_destroy(cr)
cairo_surface_destroy(cs)
end
And then we close the function.
end
I will probably revisit this explanation again soon to go over some parts more thoroughly.

2010-02-14T20:01:00.000-08:00

This approach has the advantage of being much more compact and using less functions. I will be feeding the variables straight into the drawing function. The lua is to create bars and circle charts like so.

You can get the whole code here on the crunchbang forum.

Here is the code lines in question:
The first line of the function that draws the bars is:
function draw_bar(co, width, height, across, down, bgr, bgg, bgb, bga, inr, ing, inb, ina, lw, lr, lg, lb, la, rotate)
you can see the name of the function followed by a long list of strings. These are all the strings that will be set later when the function is called. Here is a description of each string:

co = conky object data to display
width = how wide the rectangle will be
height = how tall the rectangle will be
across = x position
down = y position
bgr = red component of background color
bgg =green component of background color
bgb = blue component of background color
bga = alpha component of background color
inr = red component of indicator color
ing = green component of indicator color
inb = blue component of indicator color
ina = alpha component of indicator color
lw = width of the boundary line
lr = red component of line color
lg = green component of line color
lb = blue component of line color
la = alpha component of line color
rotate = rotation in degrees that you want applied to the bar

pretty straightforward variables, and I tried to make it so that you could more or less work out what the string names meant. Now here is the line when the function is called:
draw_bar(cpu, 150, 20, 75, 50, 0, 1, 0, 0.5, 0, 1, 0, 1, 10, 1, 0, 0, 0.5, 0)
Each value is passed up to the draw_bar function.
So that:
co=cpu
width=150
length=20
across=75
down=50
...etc etc.

Then you can call the same function again but feed it a different set of information like so:
draw_bar(mem, 150, 40, 250, 30, 0, 0, 1, 0.5, 0, 0, 1, 1, 20, 0, 1, 0, 0.5, 0)

Not as user friendly as the settings table approach but far less code and alot less complicated. Another important aspect to this approach is that it is more like a "tool" that can be used in a Lua script that contains multiple elements. All you need is the figure drawing function above the function that you will be calling in conky, then if you want a bar or circle meter in your setup, call the function with a single line setup.

2010-02-14T12:57:00.000-08:00

I knew it could be done more easily.
Thanks to the coding skills of wlourf, the code to generate the moving bars/moving dots lua (here) is now significantly shorter! Here is wlourf first post on the crunchbang forum.

I knew it was possible and I knew it would involve the technique that wlourf used. I just haven't gotten to grips with the workings of arrays!

And here is a simplified code that generates the moving dot conky as I did before:

require 'cairo'
function dotdraw(cr, num, inum, length, hori, vert, width, height, dotsize, dotr, dotg, dotb, dota)
cairo_set_source_rgba (cr, dotr, dotg, dotb, dota)
modnum=(num*(height/100))
cairo_arc(cr, ((width*inum)+hori), (vert-modnum), dotsize, 0,2*math.pi)
cairo_close_path(cr)
cairo_fill (cr)
end

function conky_draw_graph()
if conky_window == nil then return end
local cs = cairo_xlib_surface_create(conky_window.display, conky_window.drawable, conky_window.visual, conky_window.width, conky_window.height)
cr = cairo_create(cs)
local updates=tonumber(conky_parse('${updates}'))
if updates==1 then
len_t=20
t1={}
end
if updates> 3 then
for i = 1, tonumber(len_t) do
if t1[i+1]==nil then t1[i+1]=0 end
t1[i]=t1[i+1]
if i==len_t then
t1[len_t]=tonumber(conky_parse('${cpu}'))
end
--dotdraw(cr, num, inum, length, hori, vert, width, height, dotsize, dotr, dotg, dotb, dota)
dotdraw(cr, t1[i], i, len_t, 10, 200, 10, 200, 3, 0, 0, 0, 1)
end
cairo_destroy(cr)
cairo_surface_destroy(cs)
end
end

Just a few hundred lines shorter! And using the array you can have a graph as long as you want without increasing the size of the code. All you have to do is change a variable.

Also important, in addition to the use of an array to generate the data, is that the graph drawing function (dotdraw at the top) is separated from the data generating function (conky_draw_graph). This means that the data can be fed easily into as many different kinds of drawing functions as you can think of to represent it. I can think of a number of ways of presenting "graph" like data and now all i have to do is create the drawing function and feed it the data.

In addition this method seemed ideal to apply to creating a text scroll function.
Here is the result:

The code and a video clip are posted on the crunchbang forum here (it is still a work in progress).
I have never liked the native scroll function in conky because it is not continuous. If you have a scroll length of 100 say, then it will scroll your message but then follow it up with 100 empty spaces. Unfortunately this lua scroll has its drawbacks too. Principally that the information is static as it moves across, cpu usage will not change and time will not update, until the strings are generated for the next pass.

However, I think this scroll would be ideal for such things as time and date and to display the titles of music tracks.

I'm certainly going to be seeing what interesting formats I can come up with!

2010-02-11T21:10:00.000-08:00

These two graphs both display cpu usage over time. The blue graph came first and then I modified the Lua script to generate the dot chart. I had been thinking of tackling an animated bar chart for a while and decided that I should just give it a go. But it wasn't easy!

Just to conceptualize how it was going to work in the beginning took a while...
I had to think of a way to capture cpu usage information at one particular time, store that information and display it somehow while capturing new information every cycle and linking that all together to get the illusion of a moving chart.

I had (with the help of the crunchbanglinux forum) found a way to implement a timer in lua:

local updates=conky_parse('${updates}')
update_num=tonumber(updates)
local timer=(update_num % 4)+1

Parse conky to get the updates number then using the line above, every time the updates number is divisible cleanly by 4 (ie no remainder) then timer =1 (without the +1 it would equal 0)
The result is that the timer counts 1,2,3,4,1,2,3,4,1,2,3,4 etc etc. This was the basis for the animation.

I started with trying a 4 bar graph and after a little figuring out I got to the point where i could get the bars set and moving across, but when the timer reset so did the bars. The problem was that I could pass information down the script by referencing strings:
num1=number
num2=num1
num3=num2
num4=num3
But to get the table working i needed this:
A->B->C->D->a->b->c->d
B->C->D->a->b->c->d->A
C->D->a->b->c->d->A->B
D->a->b->c->d->A->B->C

So that I get a full cycle, so that the next step I can reset back top the beginning. But going from dABC which existed at the bottom of the script back to the top for ABCD, I had to take the information for ABC (from dABC) and move it up the script so that ABC in ABCD is the same ABC from dABC. That makes sense right?

So I needed a function. Functions are how you move information from the bottom of the script to the top!

Anyway. Look here at the code on the crunchbang forum and you will see what I ended up with. The script is pretty long. The reason for this is that, as you can see from the above example, for a 4 step animation you actually need 8 steps, each step containing 4 bits of information. So for 4 steps you need 32 bits of information.

I ended up with a 10 step graph which needed 200 bits of information. If i wanted a 20 step graph then that is 20x2x20=800 bits of info.

If anyone has an easier way then I would be only too glad to hear it!

The other drawback with the graph drawing function, as I have written it, is that you can only feed it one set of information. Unlike other functions where you can feed it say cpu info and settings and also feed it memperc information and settings and get 2 outputs. This function you cant do that...something just doesn't work. It would be easy enough to copy the function, and change its name, then call the newly named function with different information in the conky display function. However, it is also the case that there arent many other conky outputs that are suited to a graph.

Downspeed and upspeed graphs can be generated by conky, and could be generated from my graph drawing script... but extra steps would need to be taken to adjust for the changing units... B to KiB to MiB.

Maybe I'll find a more compact way of doing this... although running this script, total "resting" cpu usage on my system is around the 2's or 3's so it is hardly intensive even for it's size.

2010-02-10T13:25:00.000-08:00

Hot on the heels of my custom bars lua comes another script for drawing bars and rings. And after figuring out most of what goes into making a settings table work with cairo in a lua script... I decided to go with another approach.

Instead of setting up a settings table at the beginning of the script, then parsing the table with one function and feeding the parsed information into another function which converts the table values into local strings... I went with defining the values when calling the draw function. It maybe isn't as user friendly as the settings table way but in less than half the lines of my custom bars lua I have created a script that can generate the same bars and also generate ring meters.

Also I think the way that I have set up the code will make it easier to inset these meters into another Lua script. All it requires is that the meter drawing functions are placed above the function to be called in conky. Then you can use the functions with just a couple of setup lines.

Of course the ring meters are taken from londonali1010's ring meter script here. Many thanks to londonali1010 for all her excellent and inspirational work!

I have also enabled the addition of boundary rings for the ring meters. The outer and inner boundary rings can be set values for width, color and alpha individually.

The code in posted in the crunchbanglinux forum conky config thread here.
I have just updated the code to allow much easier use of rotation with the bars. Bars rotate in place and not relative to 0,0 in the new code.

2010-02-10T09:43:00.000-08:00

Here is the annotated Lua script for my custom bars.

For simplicity I have put in the settings for only 1 bar.

require "cairo"

So first we have the table below.
The table has a format like this:
table={{A1=1,B1=2,C1=3,D1=4},{A2=1,B2=2,C2=3,D2=4},{A3=1,B3=2,C3=3,D3=4}}
but for ease of use and so that the settings can be edited easily the table is split up line by line as follows:
BUT you still have to have all of the brackets (I'm not sure that they have to be curly brackets, but they certainly work.) and all of the commas or you will get an error.
table = {
{
I have used comments throughout the table so that each setting is easily identified. The comments do not interrupt the format of the table.
--conky object for output
co='cpu',
--rectangle width
rw=150,
--rectangle height
rh=50,
--NOTE about width and height. For a bordered rectangle with line width lw (specified below)
--the border is drawn 1/2 lw inside and 1/2 lw outside the boundary of the rectangle, so that
--final width=rw+lw and final height=rh+lw. I did not automate this below as it is possible
--to specify a line width (lw) greater than either width (rw) or height (rh).
--eg if you want a rectangle 200 pixels long and a border line width of 8, then rw=100-8=92
Above is a note about how to set up the heights and widths. If something isn't obvious to anyone who might use the script it's nice to explain things,
--background rectangle color set
bg_red=1,
bg_green=0,
bg_blue=0,
--background rectangle alpha
rab=0.5,
--indicator rectangle color set
in_red=0,
in_green=1,
in_blue=0,
--indicator rectangle alpha
rai=1,
--border line width
lw=40,
--border line color set
l_red=1,
l_green=0,
l_blue=1,
--border line alpha
la=0.2,
--position, x and y
rx=200,
ry=150,
--set rotation in degrees (will require x and y to be reconfigured)
rot=0
},
}
So we have all of the variables set. Each variable will be passed into the various functions and applied to the bars when they are drawn.

There are 2 functions and one sub function in this script. From looking at my last annotated script a function is written and then called below, and then when it is called information is passed up to the function. Here, to see how the information is passed I'll look at the second function first. This is the function that we will be calling in conky:
function conky_draw_shape()
this is the name of the function
local updates=conky_parse('${updates}')
update_num=tonumber(updates)
if update_num > 5 then
if conky_window==nil then return end
local w=conky_window.width
local h=conky_window.height
local cs=cairo_xlib_surface_create(conky_window.display, conky_window.drawable, conky_window.visual, w, h)
cr=cairo_create(cs)
The above should be familiar. It sets the 5 cycle delay and the surface onto which cairo will draw. Next comes a local function. This function called "parse" which takes the table entry "co" (the conky object whose output will be displayed by the bar) and performs the conky_parse command on it.
local function parse(cr,pt)
Here is the local function name and the strings that will be set when the function is used below.
local str=''
local value=0
str=string.format('${%s}',pt['co'])
The pt part is the important part (note that there is nothing important about the term pt, it is just the name of a string and could be anything. Perhaps pt stands for parse table). pt is one of the strings that is set by the parse function from information fed to the function when it is called. Also you should remember 'co' as one of the variables we set in the settings table.
str=conky_parse(str)
value=tonumber(str)
The function is parsing 'co' the conky object, running that through the tonumber command and then storing the information in a string named "value"
if value == nil then value = 0 end
draw_table(cr,pt,value)
The line above is calling the first function in the script, and feeding the function 3 things: cr, pt and value. As we saw the "value" string is generated above and it is that string that will be passed to the draw_table function.
end
Here is the end of the local function. Below is the remaining commands of the "global" function called "draw_shape"
for i in pairs(table) do
parse(cr, table[i])
These 2 lines is where the "magic" happens :) These lines read the contents of the table, and pass each set of variables to the parse function. In this case the letter "i" is extremely important and cannot be substituted. Perhaps "i" stands for "instance" or "index", I don't know exactly. So basically what is being done is that for every set of data ie {A1=1,B1=2,C1=3,D1=4} in the settings table the "parse" function is being called and fed the cr string as well as every string that the set contains ( A1, B1, C1, D1).

As you can see the parse function is being sent 2 things cr and table[i]. Then as we saw the parse function (local function parse(cr,pt)) takes cr and stores it as cr and takes the output of table[i] and stores it as pt. Then in the parse function we see pt['co'] which is the same as "table['co']". So the table is being searched for the string co, and the value of co is being formatted (str=string.format('${%s}',pt['co'])) and stored in the string called "str".

So for the data set "table= {A1=1,B1=2,C1=3,D1=4}"
table['A1']=1
table['B1']=2
table['C1']=3
table['D1']=4

and as in the parse function table[i] = pt[i] so that

table['A1']=1=pt['A1']
table['B1']=2=pt['B1']
table['C1']=3=pt['C1']
table['D1']=4=pt['D1']

I hope that all makes sense.
So to recap...

function draw_shape is generating the strings: cr and table[i]
function parse is being fed cr (but not doing anything with it) and table[i] and renaming table[i] as the string pt.
parse is looking through the string "pt" for the table setting 'co' then parsing and formatting the output and storing it as the string "value".

parse is then feeding the strings "cr", "pt" and the new string "value" up to the function settings_table.
end
end
end

Now we are going back to the point after the settings table (confused yet? :) )
Here we have the first function in the Lua script and we have already seen where the strings cr, pt and value are being fed from.
function draw_table(cr, pt, value)
local width=pt['rw']
local height=pt['rh']
local bgalpha=pt['rab']
local indalpha=pt['rai']
local across=pt['rx']
local down=pt['ry']
local lwide=pt['lw']
local lalpha=pt['la']
local bgcolr=pt['bg_red']
local bgcolg=pt['bg_green']
local bgcolb=pt['bg_blue']
local incolr=pt['in_red']
local incolg=pt['in_green']
local incolb=pt['in_blue']
local lcolr=pt['l_red']
local lcolg=pt['l_green']
local lcolb=pt['l_blue']
local rotate=pt['rot']
Above are a number of lines that are searching the table information (stored in the string pt) for the various bits and pieces of information. Then when the specific bit of information is found, that information is being set as a local string. For example:
local width=pt['rw']
string pt is being searched for the table setting "rw" (rectangle width) and storing the value of this setting in the local string "width".
--indicator calculation
local inum=(((width-lwide)/100)*value)
The above calculation allows the bars to be resized while maintainig the correct proportions of the indicator line.
--set initial rotation
cairo_rotate (cr, rotate*math.pi/180)
Here we are applying the local string rotate (initially set in the settings table as "rot") and performing the rotation, if any.
--background bar
cairo_rectangle (cr, (across+(lwide/2)), (down+(lwide/2)), (width-lwide), (height-lwide))
cairo_set_source_rgba (cr, bgcolr, bgcolg, bgcolb, bgalpha);
cairo_fill (cr)
Above we are drawing the background bar using the local strings we set above. The calculations in the code are to account for the way that the outline of rhe rectangle is drawn. This was explained towards the top of the script.
--indicator bar
cairo_rectangle (cr, (across+(lwide/2)), (down+(lwide/2)), inum, (height-lwide))
cairo_set_source_rgba (cr, incolr, incolg, incolb, indalpha);
cairo_fill (cr)
Above we generate the indicator bar.
--border line
cairo_set_line_width (cr, lwide);
cairo_rectangle (cr, across, down, width, height)
cairo_set_source_rgba (cr, lcolr, lcolg, lcolb, lalpha);
cairo_stroke (cr)
And above we draw the outline, if any.
--resets rotation
cairo_rotate (cr, (rotate*-1)*math.pi/180)
Then we reset rotation.
end
Below you can look through the functions that have been described above, but in the correct order.
function conky_draw_shape()
local updates=conky_parse('${updates}')
update_num=tonumber(updates)
if update_num > 5 then
if conky_window==nil then return end
local w=conky_window.width
local h=conky_window.height
local cs=cairo_xlib_surface_create(conky_window.display, conky_window.drawable, conky_window.visual, w, h)
cr=cairo_create(cs)
local function parse(cr,pt)
local str=''
local value=0
str=string.format('${%s}',pt['co'])
str=conky_parse(str)
value=tonumber(str)
if value == nil then value = 0 end
draw_table(cr,pt,value)
end
for i in pairs(table) do
parse(cr, table[i])
end
end
end
That's the end.
Here is an approach that achieves the same result as a settings table, in that you can achieve multiple outputs from a single instance of a function. But I think that this next approach is easier to implement and considerable shorter code wise. And here is my first take at explaining the use of arrays in a Lua script.

2010-02-09T18:58:00.000-08:00

I thought it was time that I tried to get to grips with calling multiple instances of a function via a settings table. I tried it out with something simple at first, and paying close attention to the ring meters script by londonali1010 as a reference here is the end result:

A script that generates indicator bars. While not groundbreaking I thought it might add to the tools of the conky maker :)

They are fully configurable and you can change:

which output to display
background color and alpha
indicator color and alpha
border color and alpha
size
position
rotation

via a settings table

Go here for the code. I shall probably be making some modifications in the future.
I shall also post an annotated copy of the lua script and do my best to explain how the whole thing works

2010-02-09T17:17:00.000-08:00

Tips for writing Lua scripts and getting them working in conky

Some of these will be very basic.

1. Always launch your conkyrc through the terminal. You will get feedback about errors here that are invaluable for fixing them. More on this later

2. Setup a folder where you are going to keep all of your conky configs and create a conky_start shell script
mine contains the following:

#!/bin/bash
conky -c ~/.conky/.conkyrc_tabletest

You need to make this script executable. I do this through my file manager as I'm not familiar with the terminal commands to do this.

This script will launch the conky I have saved as conkyrc_tabletest in the folder ".conky" in my home directory. Obviously you muct have created a conky before you can try and launch it!

Then launch the conky in the terminal as follows:

$ /home/mcdowall/.conky/conky_start

I have my regular conky config launch on startup, but I always launch a config I'm working on by editing this conky_start file. Just make sure that if you have a conky (or more than 1) running on your system that the conky you are about to launch will not interfere. My everyday conky is set to top_right... so I set a conky I'm working on to open elsewhere.

3. You are going to have to stop and restart the conkyrc *alot*

a command like:

$ killall conky

should do the trick. If your conky quits on you and just disappears always perform the above command. Don't just start it up again or you will get multiple instances on conky running and things will start to slow down.

4. Regarding Lua scripts in general, use the print function to troubleshoot when something isn't working right.

for example I have the following code:

cpunum=conky_parse ('${cpu}')
cpu=tonumber(cpunumber)

but for some reason things aren't working as expected. So put in the print command as so:

cpunum=conky_parse ('${cpu}')
cpu=tonumber(cpunumber)
print (cpu)

If the above code is correct then you will get the output of cpu printed only in the terminal window. Of course if there is something wrong above this point that has broken the script, you won't get anything printed out.

The above code is probably too simple to go wrong, but when you are trying more complicated things, like string editing with gsub or the string:split function or trying to work out some tricky mathematics, the print command is invaluable.

5. Put enough comments into the script so you know whats going on.
When you go back to a script and want to edit something, it's much easier if you have divided your script and functions into descriptive sections with comments. -- before text makes the text a comment.

6. Try and use descriptive names to your strings.
As above, when you come back to look at a script, a string names cpu_num gives you a good clue about what the string is about... while something more arbitrary like "a18" doesn't.

Terminal Output

Sometimes the terminal output is very helpful, sometimes it's not. I would say the most common thing I see in the terminal is this:

Conky: llua_do_call: function conky_draw_shape execution failed: attempt to call a nil value

This happens particularly because I don't have enough end's in my scripts. I should get into the habit of writing my scripts out properly like this:

function
if x==y then
...................return z
..............else
...................return a
.............end
end
(ignore the ... thats just so the format is preserved!)
But I don't.

Another thing about the above error is that if you go to your Lua script and edit the script so that you think you have corrected the error, many times when you save the Lua script the terminal just keeps on repeating the error making you think that it isn't fixed. When you get the attempt to call a nil value error it is a good idea to issue the killall conky command. Then restart the conkyrc.

But before you restart, scroll back through the error messages and look at the lines just after the conkyrc was launched... this is where the terminal will tell you why it's giving the errors. For example:

mcdowall@mcdowall-desktop:~$ /home/mcdowall/.conky/conky_start
Conky: llua_load: /home/mcdowall/lua/table.lua:176: 'end' expected (to close 'function' at line 151) near ''
Conky: forked to background, pid is 16955
mcdowall@mcdowall-desktop:~$
Conky: desktop window (87) is root window
Conky: window type - desktop
Conky: drawing to created window (0x2c00001)
Conky: drawing to double buffer
Conky: llua_do_call: function conky_draw_shape execution failed: attempt to call a nil value

and we see:
Conky: llua_load: /home/mcdowall/lua/table.lua:176: 'end' expected (to close 'function' at line 151) near '

eof = end of function which means that indeed there is a missing end ( 'end' expected).

Go to the line in question (here it's telling us that the function which begins on line 151 should have an end on line 176) and fix the problem and try again.

mcdowall@mcdowall-desktop:~$ /home/mcdowall/.conky/conky_start
Conky: llua_load: /home/mcdowall/lua/table.lua:92: '}' expected (to close '{' at line 76) near 'in_blue'

this error is because of a missing comma on line 76.

So the terminal is invaluable!

Sometimes the helpful part of the error gets repeated in the terminal, and usually when this happens, fixing the problem in the Lua script and saving the script are enough to get past it.

2010-02-09T08:42:00.000-08:00

I was reading through the crunchbanglinux forum and there was a thread here that began as a question about vector graphics formats but went onto become a discussion of guitar amp schematics. I looked at the linked schematics and I immediately saw the potential to use the scematic, or at least part of it, for the basis of a conky setup!

And here it is...

I recreated the schematic with cairo and then placed the various graphs bars and text outputs around it. I used the conkyrc to generate the upspeed and downspeed graphs and the memory usage bar. Everything else was made in lua. I took alot of the code from my full screen conky setup here. In the screen.lua I had already worked on formatting many of the conky object outputs, and I needed the same approach here so that I could be as faithful to the original schematic as possible.

The lua script is rather long so it's probably best that I link to my crunchbang forum post that contains the code here.

2010-02-07T15:45:00.000-08:00

Here is an annotated copy of my screen.lua

First off, this Lua uses more than 1 function. I can still only call a single function in conky, but in that function (called conky_draw_it below) I can use other functions.

This first 2 functions are simple enough, but show an important principal of using functions. What these functions do is to add zeros to numbers. So that percentages are always 3 digits so that when cpu usage is 5 % then 005 is displayed. Similarly time in hours, for example, is always 2 digits so that 2am is displayed as 02. This is important otherwise the changing number of digits will move everything around or overlap.
function addzero100(num)
The (num) part is important. This is a string that will be set later when the function is used. Here is an example of how this function will be called "cairo_show_text (cr, (addzero100(swap)));" As you can see the place of (num) has been taken by (swap) when the function is used. The information stored in the string "swap" is given to the addzero100 function and is stored as "num". Then the function operates on the information stored in "num" and returns the result in the place of (addzero100(swap)). So if the information is "swap" was 8 (ie 8% of swap was in used) then 008 will be displayed.
if tonumber(num)
return "00" .. num
So if a number can have 3 digits, but has only a 1 digit value, 2 zeros are added.
elseif tonumber(num)
return "0" .. num
Otherwise if it has a 2 digit value 1 zero is added
else
return num
Otherwise if it has a 3 digit value nothing is added. The function below shold be self explanatory. :)
end
end
function addzero10(num)
if tonumber(num)
return "0" .. num
else
return num
end
end

Here is another function. I found this here. It performs a very useful function in that it takes a string and splits it up into bits and puts the bits into a table. I'm a little hazy about how it works, but it works.
function string:split(delimiter)
local result = { }
local from = 1
local delim_from, delim_to = string.find( self, delimiter, from )
while delim_from do
table.insert( result, string.sub( self, from , delim_from-1 ) )
from = delim_to + 1
delim_from, delim_to = string.find( self, delimiter, from )
end
table.insert( result, string.sub( self, from ) )
return result
end
Ok, here we get to the function that contains all the stuff that I want displayed. This function will be using the functions above. Note that you cant use a function until it has been written... meaning that the function you are going to use must be above the function in which you want to use it.
function conky_draw_it()
local updates=conky_parse('${updates}')
update_num=tonumber(updates)
if update_num > 5 then
if conky_window==nil then return end
local w=conky_window.width
local h=conky_window.height
local cs=cairo_xlib_surface_create(conky_window.display, conky_window.drawable, conky_window.visual, w, h)
cr=cairo_create(cs)
The above sets the delay and the "canvas".
--sets font, font size and color
cairo_select_font_face (cr, "White Rabbit", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
cairo_set_font_size (cr, 200);
cairo_set_source_rgba (cr, 1, 1, 1, 1);
In this case I initially wanted to use the same font, font size and color for all the text so I set that all up above.
--this section generates numbers only uptime ddhhmm
This section takes the output of the conky object ${uptime} which would normally be, for example, "1d 3h 25m 12s" and turns it into "010325" (no seconds)
local uptime=conky_parse("${uptime}")
utdcalc=string.gsub(uptime, "[%d ]", "")
string.gsub was anew Lua command for me. The above takes the string "uptime" finds all numerical digits and spaces and replaces them with nothing... ie it deletes them. This is what is being looked for: "[%d ]". %d means any digit, and when placed in [] it finds digits and spaces. It would be different if the search was for "%d ". Without the [] it is now searching for a digit followed by a space only. The end result is 1d 3h 25m 12s -> dhms. This will be used in an if command below.
utime=string.split(uptime, "%a ")
Above I'm using the string split function as defined earlier in the script. As you can see, I am feeding the split string function 2 things... a string (uptime) and a search object "%a ". %a matches any letter. I am searching for a letter followed by a space. So it takes "1d 3h 25m 12s" and turns it into:
1
3
25
12
so that:
utime[1] = 1 (days)
utime[2] = 3 (hours)
utime[3] = 25 (minutes)
utime[4]= 12 (seconds)
if utdcalc=="hms" then
If uptime is less than 24 hours there will be no days in the output and therefore the following will be set as strings...
utd="00"
uth=addzero10(utime[1])
utm=addzero10(utime[2])
Also here we are using the addzero10 function, so that 3 (hours) -> 03
else
If there is a day component to uptime then "utdcalc" will not be "hms" (it will be dhms), so instead the following strings will be set.
utd=addzero10(utime[1])
uth=addzero10(utime[2])
utm=addzero10(utime[3])
end
Kernel, Down speed and Up speed uses a similar process as used for uptime; a combination of string.gsub and string.split.
--this section prints number only kernel information
local kernel1=conky_parse("${kernel}")
kernel=string.gsub(kernel1, "[%a .-]", "")
--this section formats downspeed
local downspeed=conky_parse("${downspeed}")
downnum=string.gsub(downspeed, "[%a ]", "")
dwnspcalc=string.split(downnum, "%p")
dwnumunit1=string.gsub(downspeed, "[%p%d]", "")
dwnumunit=string.gsub(dwnumunit1, "iB", "")
if dwnumunit=="M" then
dspmb=string.gsub(downnum, ".$", "")
dsnum=(math.random(5,20))/100
Here is a feature of the conky that I implimented later on. math.random(5,20) generates a random number between 5 and 20 every cycle. I used this number divided by 100 in the line below to adjust the aplha of the text cairo displays.
cairo_set_source_rgba (cr, 1, 1, 1, dsnum);
.................................................^ here is the random number string dsnum
cairo_move_to (cr, 784, 800);
cairo_show_text (cr, (dspmb) .. (dwnumunit));
else
dsnum=(math.random(5,20))/100
cairo_set_source_rgba (cr, 1, 1, 1, dsnum);
cairo_move_to (cr, 784, 800);
cairo_show_text (cr, (addzero100(dwnspcalc[1]) .. dwnumunit));
end
--this section formats upspeed
local upspeed=conky_parse("${upspeed}")
upnum=string.gsub(upspeed, "[%a ]", "")
upspcalc=string.split(upnum, "%p")
upumunit1=string.gsub(upspeed, "[%p%d]", "")
upumunit=string.gsub(upumunit1, "iB", "")
Below is the section that formats the name of the top process, as measured by cpu usage so that only the first 4 characters of the name are displayed, as I only had space for 4 characters in the conky. This one gave me some trouble as when you use the string:split function, the search criteria used to delineate the splits is deleted when the string is split. But I discovered a string.gsub trick below that solved the problem.
--this section formats top process
local topproc1=conky_parse("${top name 1}")
topproc=string.gsub(topproc1, "[%p]", "")
First I removed all the punctuation characters. %p matches all punctuation.
top1=string.upper(topproc)
Then I put all the text into uppercase
top2=string.gsub(top1, "%a", "%1-")
Abpve is the gsub trick... it matches all letters (%a) and puts a hyphen (-) between them. So that CONKY becomes C-O-N-K-Y-
top=string.split(top2, "%p")
I was then able to split the string based on punctuation and turn the resulted split into a table.

Time outputs below use Lua os.date rather than conky_parse('${time}')
--this section formats time outputs
--hours
hrs=os.date("%H")
--minutes
min=os.date("%M")
--seconds
sec=os.date("%S")
--year
yr=os.date("%y")
--month
mnt=os.date("%m")
--day
day=os.date("%d")

Below are all the common conky outputs to parse
--this sectiion formats common conky outputs
--cpu
local cpunum=conky_parse("${cpu}")
cpu=tonumber(cpunum)
--mem
local memnum=conky_parse("${memperc}")
mem=tonumber(memnum)
--hdd
local hddnum=conky_parse("${fs_used_perc /}")
hdd=tonumber(hddnum)
--swap
local swapnum=conky_parse("${swapperc}")
swap=tonumber(swapnum)

Below is the section that displays all of the above pieces through cairo.
--prints text
--uptime
utmnum=(math.random(5,20))/100
Above is the random alpha generator in use again.
cairo_set_source_rgba (cr, 1, 1, 1, utmnum);
cairo_move_to (cr, 261, 480);
cairo_show_text (cr, (utd .. uth .. utm))
--kernel
knum=(math.random(5,20))/100
cairo_set_source_rgba (cr, 1, 1, 1, knum);
cairo_move_to (cr, 0, 800);
cairo_show_text (cr, (kernel))
--upspeed
upsdnum=(math.random(5,20))/100
cairo_set_source_rgba (cr, 1, 1, 1, upsdnum);
cairo_move_to (cr, 261, 320);
cairo_show_text (cr, (addzero100(upspcalc[1]) .. upumunit));
--top process
tpnum=(math.random(5,20))/100
cairo_set_source_rgba (cr, 1, 1, 1, tpnum);
cairo_move_to (cr, 0, 640);
cairo_show_text (cr, (top[1]) .. (top[2]) .. (top[3]) .. (top[4]));
Above is how to print the first 4 characters from the name of the top process. In cairo a space followed by 2 periods and then another space, such as above, basically means print next to. So that if the top process is conky, top[1]=C, top[2]=O, top[3]=N and top[4]=K and cairo is told to display this as "CONK"
--time hours
thnum=(math.random(5,20))/100
cairo_set_source_rgba (cr, 1, 1, 1, thnum);
cairo_move_to (cr, 0, 160);
cairo_show_text (cr, (hrs));
--swapperc
swnum=(math.random(5,20))/100
cairo_set_source_rgba (cr, 1, 1, 1, swnum);
cairo_move_to (cr, 261, 160);
cairo_show_text (cr, (addzero100(swap)));
--month
monnum=(math.random(5,20))/100
cairo_set_source_rgba (cr, 1, 1, 1, monnum);
cairo_move_to (cr, 653, 160);
cairo_show_text (cr, (mnt));
--cpu
cnum=(math.random(5,20))/100
cairo_set_source_rgba (cr, 1, 1, 1, cnum);
cairo_move_to (cr, 915, 160);
cairo_show_text (cr, (addzero100(cpu)));
--time minutes
cairo_set_source_rgba (cr, 1, 1, 1, thnum);
cairo_move_to (cr, 0, 320);
cairo_show_text (cr, (min));
--day
cairo_set_source_rgba (cr, 1, 1, 1, monnum);
cairo_move_to (cr, 784, 320);
cairo_show_text (cr, (day));
--year 20
yrnum=(math.random(5,20))/100
cairo_set_source_rgba (cr, 1, 1, 1, yrnum);
cairo_move_to (cr, 1043, 320);
cairo_show_text (cr, "20");
--time seconds
cairo_set_source_rgba (cr, 1, 1, 1, thnum);
cairo_move_to (cr, 0, 480);
cairo_show_text (cr, (sec));
--year 10
cairo_set_source_rgba (cr, 1, 1, 1, yrnum);
cairo_move_to (cr, 1043, 480);
cairo_show_text (cr, (yr));
--hdd used
hdnum=(math.random(5,20))/100
cairo_set_source_rgba (cr, 1, 1, 1, hdnum);
cairo_move_to (cr, 522, 640);
cairo_show_text (cr, (addzero100(hdd)));
--memory
mnum=(math.random(5,20))/100
cairo_set_source_rgba (cr, 1, 1, 1, mnum);
cairo_move_to (cr, 915, 640);
cairo_show_text (cr, (addzero100(mem)));
ebd
end
And that is that Lua!
For more information you can go here and look at another annotated script that deals with the use of a settings table and uses multiple functions.

2010-02-07T15:37:00.000-08:00

This Lua conky went a bit further than the RGB lines.
Heres the Lua:
EDIT - I've been wondering about the validity of some of the lines in this code.
in particular the instances of

for index,today in pairs(utime) do
end

When I was first writing the code it seemed that I couldn't get the tables working without putting this in but then I began thinking that there is nothing between the do and the end, so what exactly is it doing? I just used the print function both before and after the line and got the same result. Consider those lines deleted! All part of the learning experience :)

Go to my post in the crunchbanglinux website for the code here.

An annotated version of this script is here.

2010-02-07T10:22:00.000-08:00

Here is my line lua script again, but I'll tell you what everything means this time (at least as best as I understand it).

require 'cairo'
This calls in the cairo library. Cairo is the vector graphics application that will be used to display anything you want displayed.

function conky_draw_lines()
This is the name of my function. In conky I call "draw_line". This function contains everything that is going to be displayed in conky

local updates=conky_parse('${updates}')
Conky_parse is what makes the whole thing work. Here we tell Lua to perform the conky ${updates} object. The first " updates" is a string (or maybe it's technically a variable, which holds a string, but for simplicity I'm going to call it a string). You may wonder what the "local" means, and I have to say I'm a bit hazy on the use of local as opposed to global strings (global string would be just updates=conky_parse('${updates}') ) . From the Lua documents it's to do with visibility.
Lua uses strings to hold information and in this case updates holds the output of conky_parse('${updates}')

update_num=tonumber(updates)
The (updates) is the same as the updates string from the line above. The "tonumber" part tells Lua to read the information stored in the string "updates" and turn it into a "readable" output. This output is stored in the update_num string.

if update_num > 5 then
This part looks at the information stored in the "update_num" string and asks if the number is greater than 5. If it is then the lines below are performed.
The reason for this is:
"if you are using the 'cpu' function, it will cause a segmentation fault if it tries to draw a ring straight away. Generally, a value of 5s is long enough, so if you update Conky every 1s, use update_num > 5 in that if statement (the default). If you only update Conky every 2s, you should change it to update_num > 3; conversely if you update Conky every 0.5s, you should use update_num > 10". From londonali1010's rings Lua.

if conky_window==nil then return end
Not to sure why this one is needed... I would assume that if your trying to run a Lua script in conky then there will always be a conky window. Most likely this prevents something from going wrong.

local w=conky_window.width
local h=conky_window.height
local cs=cairo_xlib_surface_create(conky_window.display, conky_window.drawable, conky_window.visual, w, h)
cr=cairo_create(cs)
This section sets up the surface onto which cairo will draw. It sets the "canvas" to the height and width of the conky window. I just put this into my functions at the beginning. I can't say that I fully understand all the terms :) .

cairo_select_font_face (cr, "White Rabbit", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
Here we are getting into the cairo drawing part of the script. A cairo function in Lua will always start with "cairo". Following the cairo function are the variables for that function in brackets. The first variable is always cr. In this line I am setting the font with which I shall be displaying text later. The cairo documentation about the options for fonts here.

cairo_set_font_size (cr, 12.0);
This sets the font size to 12.

--Line 1 settings
A double hyphyn -- denotes a comment in Lua. This lets you write things into the script to designate sections and help to remind you of things.

local a_arg=conky_parse('${cpu}')
local a_thick=10
local a_red=1
local a_green=0
local a_blue=0
local a_alpha=1
local a_start=10
--line 1 settings end
Here I am setting up strings that will be used below. They will all be used to set the parameters of the lines that will be drawn. The reason to do this is so that the settings for a function can be defined in one area instead of looking through the cairo code and trying to change parameters. a_arg stores the information from the conky abject I'm parsing. This info will be later read by tonumber as above. a_thick sets line thickness, a_red, a_green and a_blue sets the color parameters. a_alpha sets the transparency and a_start sets where I want my line to start.
NOTE about color - cairo uses a system of red, green, blue to set color. Each color is a number from 0 to 1. Many other applications that define colors, GIMP, for example uses an RGB system that sets each color a number from 0 to 255. I typically used GIMP to find out the numbers for my colors. So when I take my RGB numbers I have to divide them by 255. You can do this calculation directly in the Lua script itself if you like... e.g. a_red=100/255.

local a_num=tonumber(a_arg)
tonumber reads a_arg and stores the output in a_num.

--line 1 background
another comment, telling me that the next section will set the background lines

cairo_set_source_rgba (cr, a_red, a_green, a_blue, 0.5);
here you can see the strings that we defined above being placed into a cairo function, in this case we are setting the color for the background line. the 0.5 is the alpha value I shall use for this line. This 0.5 gives the background line a 50% transparency.

cairo_set_line_width (cr, a_thick);
here line width is being set via the string a_thick.

cairo_move_to (cr, a_start, a_start);
the cairo_move_to sets the starting position for any drawing function of cairo. In this case my start position is set by the a_start string. The variables for the cairo_move_to are (cr, x-position, y-position). x and y position are in pixels (x is horizontal and y is vertical). In conky 0,0 is the top left corner of the window. 100, 100 moves 100 pixels across and 100 pixels down.

cairo_rel_line_to (cr, 100, 100);
cairo_rel_line tells cairo to draw a line to the coordinates given. The "rel" part stands for relative and means that the coordinates are plotted relative to the start position set by cairo_move_to. cairo_line_to would draw a line starting from cairo_move_to but the end coordinates are relative to 0,0 instead.

cairo_stroke (cr);
cairo_stroke tells cairo to actually display the line that we have defined above.

--line 1 indicator
cairo_set_source_rgba (cr, a_red, a_green, a_blue, a_alpha);
cairo_set_line_width (cr, a_thick);
cairo_move_to (cr, a_start, a_thick);
cairo_rel_line_to (cr, a_num, a_num);
cairo_stroke (cr);
This sets up the "indicator" line. Unlike the background line, which always has a set length, the length of the "indicator" line is set by the string a_num (which holds the output of the conky object ${cpu}). Therefore this line is directly proportional to current cpu usage and as max cpu usage is 100%, at 100% the indicator line will completely cover the background line. The string a_alpha is also used to define the transparecy of the indicator line.

--line 1 title
cairo_set_source_rgba (cr, a_red, a_green, a_blue, a_alpha);
cairo_move_to (cr, a_start+a_thick, a_thick);
Above we set the color and start position for the title text for the line. To get the position right there is a calculation to set the x coordinate "a_start+a_thick".

cairo_rotate (cr, 45*math.pi/180)
This is one of the avaialble transformations in cairo. The rotate function in cairo works on radians (who knows why degrees aren't the unit of choice, but I guess there is a reason.) Anyway the calculation "45*math.pi/180" converts 45 degrees to radians. The "math." part tells Lua to read pi as the number pi.

cairo_show_text (cr, "CPU");
This part tells cairo to display the text "CPU" and due to the above rotation function, the text is rotated 45 degrees clockwise, to sit along side the indicator bar.

cairo_rotate (cr, -45*math.pi/180)
this part is important if anything else is coming in the function (such as subsequent bars). Transformation functions in cairo are relative, in that everything below the above "rotate" command will be rotated. So in this line we rotate cairo's "reference" back to normal.

end
This first end closes the if update_num > 5 then from the beginning of the function
end
This second end closes the function. I am always getting tripped up by having either too few or too many ends.

And that's it! You have yourself a function. Here are a few basic tips that help me work with Lua and conky. And you can go here and take a look at a more complicated script that I have annotated.

2010-02-07T09:52:00.000-08:00

Getting started with Lua and Cairo.

I have no programming background, and hadn't written a single script before a couple of months ago when I installed crunchbang linux on my computer. I began writing simple shell script in bash to get some things working in conky (using the exec and execi conky functions). Mostly my scripts were just if x=y then z elif etc etc etc. I also learnt how to use sed grep and awk functions which proved very useful for a number of aplications such as here. This conky takes the html code from a page in the crunchbanglinux site and extracts the information, displaying the active topics on the forum in conky.

Calling scripts in conky with execpi is fine, except that if you need to call the script every second or so, cpu usage gets too high to justify.

So the solution is Lua scripts and Cairo. All the functions of conky plus the ability to perform calculations and complex functions in the same place while minimising cpu usage.

But, it was certainly a daunting prospect and at first, looking at some of the Lua scripts I had come across, it seemed like too big of an undertaking. But then I just decided that I would have have a go anyway!

So I turned to google with such inquiries as "How to get started with lua cairo".
One of the first pages I came to was this.

Th advice by londonali1010 on that page was very helpful. In particular this:
"The easiest way to start is to modify someone else's work, just to get used to the syntax. Just find a script you like and start tweaking. Maybe change colours or shapes, placement of objects, or combine elements from different scripts."

I took this advice and downloaded the rings lua script. And I looked through it. In conjunction to this I read through the Cairo tutorial.

I managed to decipher some of the Lua script and applied the parts I understood to a script myself. This is what I came up with...

and heres the script below: for simplicity I have only included 1 bar.

bars.lua
require 'cairo'
function conky_draw_lines()
local updates=conky_parse('${updates}')
update_num=tonumber(updates)
if update_num > 5 then
if conky_window==nil then return end
local w=conky_window.width
local h=conky_window.height
local cs=cairo_xlib_surface_create(conky_window.display, conky_window.drawable, conky_window.visual, w, h)
cr=cairo_create(cs)
cairo_select_font_face (cr, "White Rabbit", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
cairo_set_font_size (cr, 12.0);

--Line 1 settings
local a_arg=conky_parse('${cpu}')
local a_thick=10
local a_red=1
local a_green=0
local a_blue=0
local a_alpha=1
local a_start=10
--line 1 settings end
local a_num=tonumber(a_arg)
--line 1 background
cairo_set_source_rgba (cr, a_red, a_green, a_blue, 0.5);
cairo_set_line_width (cr, a_thick);
cairo_move_to (cr, a_start, a_start);
cairo_rel_line_to (cr, 100, 100);
cairo_stroke (cr);
--line 1 indicator
cairo_set_source_rgba (cr, a_red, a_green, a_blue, a_alpha);
cairo_set_line_width (cr, a_thick);
cairo_move_to (cr, a_start, a_thick);
cairo_rel_line_to (cr, a_num, a_num);
cairo_stroke (cr);
--line 1 title
cairo_set_source_rgba (cr, a_red, a_green, a_blue, a_alpha);
cairo_move_to (cr, a_start+a_thick, a_thick);
cairo_rotate (cr, 45*math.pi/180)
cairo_show_text (cr, "CPU");
cairo_rotate (cr, -45*math.pi/180)
end
end

My first Lua Cairo thing. Go here and I'll talk you through it line by line.

2010-02-06T21:28:00.000-08:00

conkyrc_flower

##############################################
# Settings
##############################################
max_specials 10000
max_user_text 150000
background yes
use_xft yes
xftfont mono:size=12
xftalpha 1
update_interval 1
total_run_times 0
own_window yes
own_window_transparent yes
own_window_type desktop
own_window_hints undecorated,below,sticky,skip_taskbar,skip_pager
double_buffer yes
minimum_size 600, 640
maximum_width 600
draw_shades no
draw_outline no
draw_borders no
draw_graph_borders yes
default_color white
default_shade_color black
default_outline_color white
alignment top_right
gap_x 10
gap_y 40
no_buffers yes
uppercase no
cpu_avg_samples 2
override_utf8_locale yes
default_color 000000
color1 735046

lua_load /home/mcdowall/lua/flower.lua
lua_draw_hook_pre draw_flower

TEXT
${goto 239}${voffset 270}${font clockfaces:size=90}Q

I found that i had to have this empty space in the conky rc so that the lua graphics would all be displayed.

2010-02-06T21:23:00.000-08:00

flower.lua
--[[valentine flowers by mrpeachy (2010)]]
require 'cairo'
function string:split(delimiter)
local result = { }
local from = 1
local delim_from, delim_to = string.find( self, delimiter, from )
while delim_from do
table.insert( result, string.sub( self, from , delim_from-1 ) )
from = delim_to + 1
delim_from, delim_to = string.find( self, delimiter, from )
end
table.insert( result, string.sub( self, from ) )
return result
end

function circlewriting(text, char, font, fsize, radi, horiz, verti, tred, tgreen, tblue, talpha, variable)
local textcut=string.gsub(text, ".", "%1@@@")
texttable=string.split(textcut, "@@@")
for i=1,char do
--calculations
deg=360/((char-1)*2)
text_arc=(2*math.pi/((char-1)*2)*(i)+variable)
txs=1+radi*(math.sin(text_arc))
tys=1-radi*(math.cos(text_arc))
--print (deg)
cairo_select_font_face (cr, font, CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
cairo_set_font_size (cr, fsize);
cairo_set_source_rgba (cr, tred, tgreen, tblue, talpha);
cairo_move_to (cr, txs+horiz, tys+verti);
cairo_rotate (cr, ((270+(deg*(i-1)))*math.pi/180))
cairo_show_text (cr, (texttable[i]))
cairo_rotate (cr, ((-270-(deg*(i-1)))*math.pi/180))
end
end

function conky_draw_flower()
local updates=conky_parse('${updates}')
update_num=tonumber(updates)
if update_num > 5 then
if conky_window==nil then return end
local w=conky_window.width
local h=conky_window.height
local cs=cairo_xlib_surface_create(conky_window.display, conky_window.drawable, conky_window.visual, w, h)
cr=cairo_create(cs)

--FLOWER 1----------------------------------------------------------------------------
--FLOWER 1
--color
f1r=1
f1g=0
f1b=0
--size
cairo_scale (cr, 0.5, 0.5)
--position
cairo_translate (cr, 500, 250)
--draw background circle
circrad=200
circx=100
circy=0
cairo_move_to (cr, 100, 100);
cairo_arc(cr,circx,circy,circrad,0,2*math.pi)
cairo_close_path(cr)
--fill
cairo_set_source_rgba (cr, f1r, f1g, f1b, .5);
cairo_fill (cr);
--draw indicator circle
local fl1num=conky_parse('${cpu}')
fl1=tonumber(fl1num)
circrad=(fl1*1.5)+50
circx=100
circy=0
cairo_move_to (cr, 100, 100);
cairo_arc(cr,circx,circy,circrad,0,2*math.pi)
cairo_close_path(cr)
--fill
cairo_set_source_rgba (cr, 1, 0, 0, .5);
cairo_fill (cr);
--flower shape
cairo_move_to (cr, 100, 100);
cairo_curve_to (cr, 100, 150, 200, 173, 200, 173);
cairo_curve_to (cr, 230, 75, 187, 50, 187, 50);
cairo_curve_to (cr, 230, 75, 300, 0, 300, 0);
cairo_curve_to (cr, 230, -75, 187, -50, 187, -50);
cairo_curve_to (cr, 230, -75, 200, -173, 200, -173);
cairo_curve_to (cr, 100, -150, 100, -100, 100, -100);
cairo_curve_to (cr, 100, -150, 0, -173, 0, -173);
cairo_curve_to (cr, -30, -75, 13, -50, 13, -50);
cairo_curve_to (cr, -30, -75, -100, 0, -100, 0);
cairo_curve_to (cr, -30, 75, 13, 50, 13, 50);
cairo_curve_to (cr, -30, 75, 0, 173, 0, 173);
cairo_curve_to (cr, 100, 150, 100, 100, 100, 100);
cairo_close_path (cr);
--draw circle
circrad=205
circx=100
circy=0
cairo_move_to (cr, 100, 100);
cairo_new_sub_path (cr); cairo_arc(cr,circx,circy,circrad,0,2*math.pi)
cairo_new_sub_path (cr); cairo_close_path(cr)
--fill
cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
cairo_set_source_rgba (cr, 0, 0, 0, 1);
cairo_fill (cr);
--draw center circle
circrad=50
circx=100
circy=0
cairo_move_to (cr, 100, 100);
cairo_arc(cr,circx,circy,circrad,0,2*math.pi)
cairo_close_path(cr)
--fill
cairo_set_source_rgba (cr, 1, 1, 0, 1);
cairo_fill (cr);
--FLOWER 2----------------------------------------------------------------------------
--FLOWER 2
--color
f2r=0
f2g=1
f2b=1
--size
cairo_scale (cr, 1, 1)
--position across then up (translate is relative to last translate position)
cairo_translate (cr, 350, 200)
--draw background circle
circrad=200
circx=100
circy=0
cairo_move_to (cr, 100, 100);
cairo_arc(cr,circx,circy,circrad,0,2*math.pi)
cairo_close_path(cr)
--fill
cairo_set_source_rgba (cr, f2r, f2g, f2b, .5);
cairo_fill (cr);
--draw indicator circle
local fl2num=conky_parse('${memperc}')
fl2=tonumber(fl2num)
circrad=(fl2*1.5)+50
circx=100
circy=0
cairo_move_to (cr, 100, 100);
cairo_arc(cr,circx,circy,circrad,0,2*math.pi)
cairo_close_path(cr)
--fill
cairo_set_source_rgba (cr, f2r, f2g, f2b, .5);
cairo_fill (cr);
--flower shape
cairo_move_to (cr, 100, 100);
cairo_curve_to (cr, 100, 150, 200, 173, 200, 173);
cairo_curve_to (cr, 230, 75, 187, 50, 187, 50);
cairo_curve_to (cr, 230, 75, 300, 0, 300, 0);
cairo_curve_to (cr, 230, -75, 187, -50, 187, -50);
cairo_curve_to (cr, 230, -75, 200, -173, 200, -173);
cairo_curve_to (cr, 100, -150, 100, -100, 100, -100);
cairo_curve_to (cr, 100, -150, 0, -173, 0, -173);
cairo_curve_to (cr, -30, -75, 13, -50, 13, -50);
cairo_curve_to (cr, -30, -75, -100, 0, -100, 0);
cairo_curve_to (cr, -30, 75, 13, 50, 13, 50);
cairo_curve_to (cr, -30, 75, 0, 173, 0, 173);
cairo_curve_to (cr, 100, 150, 100, 100, 100, 100);
cairo_close_path (cr);
--draw circle
circrad=205
circx=100
circy=0
cairo_move_to (cr, 100, 100);
cairo_new_sub_path (cr); cairo_arc(cr,circx,circy,circrad,0,2*math.pi)
cairo_new_sub_path (cr); cairo_close_path(cr)
--fill
cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
cairo_set_source_rgba (cr, 0, 0, 0, 1);
cairo_fill (cr);
--draw center circle
circrad=50
circx=100
circy=0
cairo_move_to (cr, 100, 100);
cairo_arc(cr,circx,circy,circrad,0,2*math.pi)
cairo_close_path(cr)
--fill
cairo_set_source_rgba (cr, 1, 1, 0, 1);
cairo_fill (cr);
--FLOWER 3----------------------------------------------------------------------------
--FLOWER 3
--color
f3r=0.6
f3g=0.0
f3b=1
--size
cairo_scale (cr, 1, 1)
--position across then up (translate is relative to last translate position)
cairo_translate (cr, -700, 0)
--draw background circle
circrad=200
circx=100
circy=0
cairo_move_to (cr, 100, 100);
cairo_arc(cr,circx,circy,circrad,0,2*math.pi)
cairo_close_path(cr)
--fill
cairo_set_source_rgba (cr, f3r, f3g, f3b, .5);
cairo_fill (cr);
--draw indicator circle
local fl3num=conky_parse('${fs_used_perc /}')
fl3=tonumber(fl3num)
circrad=(fl3*1.5)+50
circx=100
circy=0
cairo_move_to (cr, 100, 100);
cairo_arc(cr,circx,circy,circrad,0,2*math.pi)
cairo_close_path(cr)
--fill
cairo_set_source_rgba (cr, f3r, f3g, f3b, .5);
cairo_fill (cr);
--flower shape
cairo_move_to (cr, 100, 100);
cairo_curve_to (cr, 100, 150, 200, 173, 200, 173);
cairo_curve_to (cr, 230, 75, 187, 50, 187, 50);
cairo_curve_to (cr, 230, 75, 300, 0, 300, 0);
cairo_curve_to (cr, 230, -75, 187, -50, 187, -50);
cairo_curve_to (cr, 230, -75, 200, -173, 200, -173);
cairo_curve_to (cr, 100, -150, 100, -100, 100, -100);
cairo_curve_to (cr, 100, -150, 0, -173, 0, -173);
cairo_curve_to (cr, -30, -75, 13, -50, 13, -50);
cairo_curve_to (cr, -30, -75, -100, 0, -100, 0);
cairo_curve_to (cr, -30, 75, 13, 50, 13, 50);
cairo_curve_to (cr, -30, 75, 0, 173, 0, 173);
cairo_curve_to (cr, 100, 150, 100, 100, 100, 100);
cairo_close_path (cr);
--draw circle
circrad=205
circx=100
circy=0
cairo_move_to (cr, 100, 100);
cairo_new_sub_path (cr); cairo_arc(cr,circx,circy,circrad,0,2*math.pi)
cairo_new_sub_path (cr); cairo_close_path(cr)
--fill
cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
cairo_set_source_rgba (cr, 0, 0, 0, 1);
cairo_fill (cr);
--draw center circle
circrad=50
circx=100
circy=0
cairo_move_to (cr, 100, 100);
cairo_arc(cr,circx,circy,circrad,0,2*math.pi)
cairo_close_path(cr)
--fill
cairo_set_source_rgba (cr, 1, 1, 0, 1);
cairo_fill (cr);
--FLOWER 4----------------------------------------------------------------------------
--FLOWER 4
--color
f4r=1
f4g=0
f4b=1
--size
cairo_scale (cr, 1, 1)
--position across then up (translate is relative to last translate position)
cairo_translate (cr, 0, 400)
--draw background circle
circrad=200
circx=100
circy=0
cairo_move_to (cr, 100, 100);
cairo_arc(cr,circx,circy,circrad,0,2*math.pi)
cairo_close_path(cr)
--fill
cairo_set_source_rgba (cr, f4r, f4g, f4b, .5);
cairo_fill (cr);
--draw indicator circle
local fl4num=conky_parse('${swapperc}')
fl4=tonumber(fl4num)
circrad=(fl4*1.5)+50
circx=100
circy=0
cairo_move_to (cr, 100, 100);
cairo_arc(cr,circx,circy,circrad,0,2*math.pi)
cairo_close_path(cr)
--fill
cairo_set_source_rgba (cr, f4r, f4g, f4b, .5);
cairo_fill (cr);
--flower shape
cairo_move_to (cr, 100, 100);
cairo_curve_to (cr, 100, 150, 200, 173, 200, 173);
cairo_curve_to (cr, 230, 75, 187, 50, 187, 50);
cairo_curve_to (cr, 230, 75, 300, 0, 300, 0);
cairo_curve_to (cr, 230, -75, 187, -50, 187, -50);
cairo_curve_to (cr, 230, -75, 200, -173, 200, -173);
cairo_curve_to (cr, 100, -150, 100, -100, 100, -100);
cairo_curve_to (cr, 100, -150, 0, -173, 0, -173);
cairo_curve_to (cr, -30, -75, 13, -50, 13, -50);
cairo_curve_to (cr, -30, -75, -100, 0, -100, 0);
cairo_curve_to (cr, -30, 75, 13, 50, 13, 50);
cairo_curve_to (cr, -30, 75, 0, 173, 0, 173);
cairo_curve_to (cr, 100, 150, 100, 100, 100, 100);
cairo_close_path (cr);
--draw circle
circrad=205
circx=100
circy=0
cairo_move_to (cr, 100, 100);
cairo_new_sub_path (cr); cairo_arc(cr,circx,circy,circrad,0,2*math.pi)
cairo_new_sub_path (cr); cairo_close_path(cr)
--fill
cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
cairo_set_source_rgba (cr, 0, 0, 0, 1);
cairo_fill (cr);
--draw center circle
circrad=50
circx=100
circy=0
cairo_move_to (cr, 100, 100);
cairo_arc(cr,circx,circy,circrad,0,2*math.pi)
cairo_close_path(cr)
cairo_set_source_rgba (cr, 1, 1, 0, 1);
cairo_fill (cr);
--FLOWER 5----------------------------------------------------------------------------
--FLOWER 5
--color
f5r=1
f5g=1
f5b=0
--size
cairo_scale (cr, 1, 1)
--position across then up (translate is relative to last translate position)
cairo_translate (cr, 350, 200)
--draw background circle
circrad=200
circx=100
circy=0
cairo_move_to (cr, 100, 100);
cairo_arc(cr,circx,circy,circrad,0,2*math.pi)
cairo_close_path(cr)
--fill
cairo_set_source_rgba (cr, f5r, f5g, f5b, .5);
cairo_fill (cr);
--draw indicator circle
local fl5num=conky_parse('${cpu}')
fl5=tonumber(fl5num)
circrad=(fl5*1.5)+50
circx=100
circy=0
cairo_move_to (cr, 100, 100);
cairo_arc(cr,circx,circy,circrad,0,2*math.pi)
cairo_close_path(cr)
--fill
cairo_set_source_rgba (cr, f5r, f5g, f5b, .5);
cairo_fill (cr);
--flower shape
cairo_move_to (cr, 100, 100);
cairo_curve_to (cr, 100, 150, 200, 173, 200, 173);
cairo_curve_to (cr, 230, 75, 187, 50, 187, 50);
cairo_curve_to (cr, 230, 75, 300, 0, 300, 0);
cairo_curve_to (cr, 230, -75, 187, -50, 187, -50);
cairo_curve_to (cr, 230, -75, 200, -173, 200, -173);
cairo_curve_to (cr, 100, -150, 100, -100, 100, -100);
cairo_curve_to (cr, 100, -150, 0, -173, 0, -173);
cairo_curve_to (cr, -30, -75, 13, -50, 13, -50);
cairo_curve_to (cr, -30, -75, -100, 0, -100, 0);
cairo_curve_to (cr, -30, 75, 13, 50, 13, 50);
cairo_curve_to (cr, -30, 75, 0, 173, 0, 173);
cairo_curve_to (cr, 100, 150, 100, 100, 100, 100);
cairo_close_path (cr);
--draw circle
circrad=205
circx=100
circy=0
cairo_move_to (cr, 100, 100);
cairo_new_sub_path (cr); cairo_arc(cr,circx,circy,circrad,0,2*math.pi)
cairo_new_sub_path (cr); cairo_close_path(cr)
--fill
cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
cairo_set_source_rgba (cr, 0, 0, 0, 1);
cairo_fill (cr);
--draw center circle
circrad=50
circx=100
circy=0
cairo_move_to (cr, 100, 100);
cairo_arc(cr,circx,circy,circrad,0,2*math.pi)
cairo_close_path(cr)
cairo_set_source_rgba (cr, 1, 1, 0, 1);
cairo_fill (cr);
--FLOWER 6----------------------------------------------------------------------------
--FLOWER 6
--color
f6r=1
f6g=.5
f6b=0
--size
cairo_scale (cr, 1, 1)
--position across then up (translate is relative to last translate position)
cairo_translate (cr, 350, -200)
--draw background circle
circrad=200
circx=100
circy=0
cairo_move_to (cr, 100, 100);
cairo_arc(cr,circx,circy,circrad,0,2*math.pi)
cairo_close_path(cr)
--fill
cairo_set_source_rgba (cr, f6r, f6g, f6b, .5);
cairo_fill (cr);
--draw indicator circle
local fl6num=conky_parse('${cpu}')
fl6=tonumber(fl6num)
circrad=(fl5*1.5)+50
circx=100
circy=0
cairo_move_to (cr, 100, 100);
cairo_arc(cr,circx,circy,circrad,0,2*math.pi)
cairo_close_path(cr)
--fill
cairo_set_source_rgba (cr, f6r, f6g, f6b, .5);
cairo_fill (cr);
--flower shape
cairo_move_to (cr, 100, 100);
cairo_curve_to (cr, 100, 150, 200, 173, 200, 173);
cairo_curve_to (cr, 230, 75, 187, 50, 187, 50);
cairo_curve_to (cr, 230, 75, 300, 0, 300, 0);
cairo_curve_to (cr, 230, -75, 187, -50, 187, -50);
cairo_curve_to (cr, 230, -75, 200, -173, 200, -173);
cairo_curve_to (cr, 100, -150, 100, -100, 100, -100);
cairo_curve_to (cr, 100, -150, 0, -173, 0, -173);
cairo_curve_to (cr, -30, -75, 13, -50, 13, -50);
cairo_curve_to (cr, -30, -75, -100, 0, -100, 0);
cairo_curve_to (cr, -30, 75, 13, 50, 13, 50);
cairo_curve_to (cr, -30, 75, 0, 173, 0, 173);
cairo_curve_to (cr, 100, 150, 100, 100, 100, 100);
cairo_close_path (cr);
--draw circle
circrad=205
circx=100
circy=0
cairo_move_to (cr, 100, 100);
cairo_new_sub_path (cr); cairo_arc(cr,circx,circy,circrad,0,2*math.pi)
cairo_new_sub_path (cr); cairo_close_path(cr)
--fill
cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
cairo_set_source_rgba (cr, 0, 0, 0, 1);
cairo_fill (cr);
--draw center circle
circrad=50
circx=100
circy=0
cairo_move_to (cr, 100, 100);
cairo_arc(cr,circx,circy,circrad,0,2*math.pi)
cairo_close_path(cr)
cairo_set_source_rgba (cr, 1, 1, 0, 1);
cairo_fill (cr);

-----description of variables for circlewriting function
--eg circlewriting(A, B, C, D, E, F, G, H, I, J, K, L)
--A = text to be written, place straight text in quotes.
--B = total number of characters, including spaces and punctuation
--C = font, place font in quotes
--D = font size
--E = radius of the circle
--F = horizontal position
--G = vertical position
--H = color red
--I = color green
--J = color blue
--K = a variable to get the text lined up. I havn't quite figured out how this number is generated!
--but without it the text will no line up correctly. For text along top of circle this number is -ve
--start at about half of B, increasing negative moves text counter clockwise
--circlewriting("TEXT TEXT TEXT", 14, "Mono", 18, 100, 150, 150, 1, 1, 1, 1, -8.16)

--FLOWER 1 TITLE
cairo_translate (cr, -260, -590)
test=circlewriting("PROCESSOR", 9, "White Rabbit", 30, 205, 7, -10, f1r, f1g, f1b, 0.8, -2)
--FLOWER 2 TITLE
cairo_translate (cr, 348, 200)
test=circlewriting("MEMORY", 6, "White Rabbit", 30, 205, 9, -10, f2r, f2g, f2b, 0.8, -2.24)
--FLOWER 3 TITLE
cairo_translate (cr, -698, 0)
test=circlewriting("FILESYSTEM USED", 15, "White Rabbit", 30, 205, 7, -10, f3r, f3g, f3b, 0.8, -8.12)
--FLOWER 4 TITLE
cairo_translate (cr, 0, 400)
test=circlewriting("SWAP PARTITION", 14, "White Rabbit", 30, 205, 7, -11, f4r, f4g, f4b, 0.8, -8.13)
--FLOWER 5 TITLE
cairo_translate (cr, 350, 200)
test=circlewriting("BATTERY", 7, "White Rabbit", 30, 205, 7, -10, f5r, f5g, f5b, 0.8, -8.41)
--FLOWER 6 TITLE
cairo_translate (cr, 350, -200)
test=circlewriting("CONNECTION", 10, "White Rabbit", 30, 205, 7, -10, f6r, f6g, f6b, 0.8, -8.25)
--draw center clock heart
scale=1.75
cairo_set_source_rgba (cr, 255/255, 100/255, 130/255, 1)
cairo_translate (cr, -690, -570)
cairo_move_to (cr, 200*scale, 150*scale);
cairo_curve_to (cr, 210*scale, 90*scale, 290*scale, 90*scale, 300*scale, 150*scale);
cairo_curve_to (cr, 300*scale, 150*scale, 320*scale, 250*scale, 200*scale, 300*scale);
cairo_curve_to (cr, 200*scale, 300*scale, 80*scale, 250*scale, 100*scale, 150*scale);
cairo_curve_to (cr, 110*scale, 90*scale, 190*scale, 90*scale, 200*scale, 150*scale);
cairo_close_path (cr);
cairo_fill (cr)

--clock
local clock_r=85
local xc=350
local yc=390
shadow_width=5
shadow_xoffset=0
shadow_yoffset=2
show_seconds=true
-- Grab time
local hours=os.date("%I")
local mins=os.date("%M")
local secs=os.date("%S")
secs_arc=(2*math.pi/60)*secs
mins_arc=(2*math.pi/60)*mins
hours_arc=(2*math.pi/12)*hours+mins_arc/12

-- Draw hour hand
xh=xc+0.7*clock_r*math.sin(hours_arc)
yh=yc-0.7*clock_r*math.cos(hours_arc)
cairo_move_to(cr,xc,yc)
cairo_line_to(cr,xh,yh)

cairo_set_line_cap(cr,CAIRO_LINE_CAP_ROUND)
cairo_set_line_width(cr,5)
cairo_set_source_rgba(cr,0,0,0,0.5)
cairo_stroke(cr)

-- Draw minute hand
xm=xc+0.9*clock_r*math.sin(mins_arc)
ym=yc-0.9*clock_r*math.cos(mins_arc)
cairo_move_to(cr,xc,yc)
cairo_line_to(cr,xm,ym)

cairo_set_line_width(cr,3)
cairo_stroke(cr)

-- Draw seconds hand
if show_seconds then
xs=xc+0.9*clock_r*math.sin(secs_arc)
ys=yc-0.9*clock_r*math.cos(secs_arc)
cairo_move_to(cr,xc,yc)
cairo_line_to(cr,xs,ys)

cairo_set_line_width(cr,1)
cairo_stroke(cr)
end
end
end

2010-02-06T21:16:00.000-08:00

This blog is a place to refer to regarding conky and lua setups that I have been working on.

Here is an alternative version of my flower conky. Read my blog post here.

Here is a conky setup, inspired by the Conky of the Month competition on the Conky Blog here. I'm not sure about the pink heart... Plus I "cheated" a little as I am actually using a desktop computer with a wired internet connection. That is why the "BATTERY" and "CONNECTION" flowers seem to be non functional ("SWAP" really is 0% which is why that flower doesn't show anything). The code however works just fine when run on a setup that has such things. I just needed 6 conky outputs for the 6 flowers, since I only have the one processor and the one filesystem partition :)

This conky was created almost exclusively through a lua script and it is by far the most complicated script i have written to date. I am particularly pleased with the circle writing function I came up with. Here is the lua script.
In the conky rc you need this.
I set up the clock face in the conkyrc.

This isn't my first attempt at a valentines conky :)
This one has an animated border of hearts. But after I finished the border I wasn't sure what to do with the middle... which ended up going all "goth" on me!

You can see the details here.

The next thing I need to learn about Lua is how to get multiple graphics from a single instance of a function through the use of a settings table. I think I'm most of the way there in understanding how this is done, but I haven't tried it yet.

I would also like to direct your attention to the crunchbanglinux forum.
It was through crunchbang that I first started using conky and you can see, through the conky config thread, how I have developed my ideas and knowledge. You can go to the crunchbanglinux website here and the conky config thread here.

My first conky post is on page 25 here.

And I have the honor of having one of my conky setups on conky hardcore here. :)

And here and here is a short tutorial I have written on getting started with Lua. This tutorial goes through how I wrote my first Lua cairo script for this conky.

Another Lua cairo conky I made is here. And produces this conky. I have annotated the Lua script for this conky here.