HOW TO : using lua scripts in conky (Page 1 of 3)

that is very peachy Mr Peachy! great how-to which will doubtlessly be useful to many a Conky-warrior.

thanks rhowaldt, hopefully someone will find it useful!

and if im being too simplistic or not explaining things as full enough to make sense let me know!

Last edited by mrpeachy (2012-01-17 20:31:04)

part 4 -- drawing other things

there are a few things that cairo can draw other than lines
namely:
    1. rectangles
    2. arcs (and circles)
    3. curves

rectangles

we could use lines as in the triangle to draw ourselves a rectangle, but cairo has the ability to draw rectangles built in
so might as well use it

cairo_rectangle (cr, x, y, width, height)

the x,y coordinates are the top left corner of the rectangle

just like our triangle we can set up our shape like so

--settings
line_width=5
top_left_x=20
top_left_y=20
rec_width=100
rec_height=50
red=1
green=0
blue=0
alpha=1
--draw it
cairo_set_line_width (cr,line_width)
cairo_rectangle (cr,top_left_x,top_left_y,rec_width,rec_height)
cairo_set_source_rgba (cr,red,green,blue,alpha)

then use stroke to draw the outline

cairo_stroke (cr)

or

cairo_fill (cr)

to fill it in

or if you want the rectangle filled with one color and line in a different colors
we would first fill with cairo_fill_preserve, then set our second color and draw our line with cairo_stroke

--settings
line_width=5
top_left_x=20
top_left_y=20
rec_width=100
rec_height=50
fill_red=1
fill_green=1
fill_blue=1
fill_alpha=1
line_red=1
line_green=0
line_blue=0
line_alpha=1
--draw it
cairo_set_line_width (cr,line_width)
cairo_rectangle (cr,top_left_x,top_left_y,rec_width,rec_height)
cairo_set_source_rgba (cr,fill_red,fill_green,fill_blue,fill_alpha)
cairo_fill_preserve (cr)
cairo_set_source_rgba (cr,line_red,line_green,line_blue,line_alpha)
cairo_stroke (cr)

NOTE
with rectangles there is no point in setting line_cap like we did for lines as there are no "loose ends" to the rectangle
there is also no need to use cairo_close_path, as it is closed automatically
however setting how the lines join will affect the look of the rectangle when we use cairo_stroke

cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND)
cairo_stroke (cr)

will give rounded corners for example

line width, line join type and end cap type do not affect the fill command

2. arc and circles
there are 2 commands for arcs

cairo_arc (cr,center_x,center_y,radius,start_angle,end_angle)
and
cairo_arc_negative (cr,center_x,center_y,radius,start_angle,end_angle)

cairo_arc draws the arc clockwise while cairo_arc_negative draws the arc anticlockwise

the first obstacle to drawing arcs is that you need to enter your start and end angles in radians rather than degrees.
so we need to know how to convert between the two

radians=degrees*(pi/180)

lua has a number of built in math functions and one of them, math.pi, gives you the value of pi

the other quirk about using the arc drawing command is that angle 0 isn't the top of the circle as you would expect

rather angle 0 is the rightmost point in the circle (which i would call 90 degrees)

these things don't matter if we only want to draw a complete circle, we just need the following

center_x=100
center_y=100
radius=50
start_angle=0
end_angle=2*math.pi--same thing as 360 degrees
cairo_arc (cr,center_x,center_y,radius,start_angle,end_angle)
cairo_stroke (cr)

NOTE
whenever you use stroke to draw something you need to set a line_width.
also with stroke, if you are going to see line ends then altering the line cap type will affect those ends.
the other setting that can affect stroke is the line join type if creating a path from multiple elements
arcs along with curves and lines can be all put together to form a single path

in the example above you will also need to set color and alpha as before.

Change cairo_stroke to cairo_fill to fill the circle in
or use the previously described method for fill and line.
I wont necessarily put these setup lines, or all the available options, into code examples from now on.

BUT if we dont want a full circle then we need to worry about radians and setting angles
to get an 1/4 circle, from the topmost point of the circle,clockwise to the rightmost point, we can do several things...
my code would look like this

center_x=100
center_y=100
radius=50
start_angle=0
end_angle=90
cairo_arc (cr,center_x,center_y,radius,(start_angle-90)*(math.pi/180),(end_angle-90)*(math.pi/180))
cairo_stroke (cr)

since i only want to enter angles as degrees i can put the conversion calculations into the arc command
eg (start_angle-90)*(math.pi/180)

first i want the top of my circe to be 0 degrees (or 360 if you like)
so i have to compensate for the arc command quirk by subtracting 90 degrees from the value i set

then i need to convert to radians by multiplying by (math.pi/180)

cairo_stroke to get the line

this in the code:

cairo_close_path (cr)
cairo_stroke (cr)

will result in a straight line drawn from the end of the arc back to the beginning
and cairo_fill (cr) instead of cairo_stroke would result in a filled in bump with a flat bottom

here is cairo_stroke without close_path, cairo_stroke with close path and cairo_fill

using arc or arc_negative
so if you give cairo_arc a start angle of 270 and an end angle of 90 you get the top half of a circle
you could also set start=270, end=450 (360+90) and get the same things
or start=-90, end=90 and get the same thing

if you give cairo_arc_negatove a start angle of 270 and an end angle of 90 you get the bottom half of a circle

this can be important for drawing paths, as you want your path to be a continuous progression
(imagine drawing a line on some paper but not allowed to lift the pen).  Also remember that using the close_path
or fill commands (which close the path automatically) you draw a line from where you ended to where you started.  You can get unexpected fill and stroke results if you piece together your path in a non continuous manner.

The other time you may want to use are or arc negative is to make a ring meter go one way or another
while you could achieve the effect just using, for example, arc (which naturally draws in a clockwise direction) for both, you have to think a bit harder about the math to get the ring going in the opposite direction

3 curves
i'll leave curves for another time
they can be quite tricky to set up and use

Last edited by mrpeachy (2012-01-18 20:25:41)

it could just be that i'm not explaining things very well

well i am certainly not a real programmer, i just know what i need to know and if i dont know then i try and find out

and you are welcome

i added a little to the end of part 4, and here is part 5

PART 5 - making some indicators

make a cpu indicator bar

we made a line that changes length according to the reading of cpu% from conky

but to make that a bit more interesting we will make a vertical indicator bar to show cpu
the bar will have a colored background and a different colored indicator
it will also be resizable through settings and placeable

so where to start?

first we need to think about the order of operations
in lua with cairo, things drawn lower down in the script will be drawn over the top of things drawn above

so we are going to have a colored background, which will need to be behind the indicator, so we need to draw the background first.

we are going to define some settings
1.  where we want the indicator to be
2. how big we want the indicator
3. the colors for our background and indicator

so our setting section might look like this

--SETTINGS FOR CPU INDICATOR BAR
bar_bottom_left_x= 50
bar_bottom_left_y= 200
bar_width= 30
bar_height= 100
--set bar background colors, 1,0,0,1 = fully opaque red
bar_bg_red=1
bar_bg_green=0
bar_bg_blue=0
bar_bg_alpha=1
--set indicator colors, 1,1,1,1 = fully opaque white
bar_in_red=1
bar_in_green=1
bar_in_blue=1
bar_in_alpha=1

we want unique names so that there is no chance of names being duplicated elsewhere in the script and overwriting our settings (i  usually have my string names tell me something about the information kept in the string).  it can be a pain to type long string names over and over again but worse when you run the script and it doesnt work as expected because a string has been ovewritten

drawing the background is then pretty simple, we will used a filled in rectangle
the only thing to note is that by asking for the bottom coordinates, when we come to set the height of the rectangle, our height will be negative (because we are drawing up!)

we are using the rectangle function, so we dont need to specify an end cap type and we are using fill so we dont need to specify line join type or line width

--draw background
cairo_set_source_rgba (cr,bar_bg_red,bar_bg_green,bar_bg_blue,bar_bg_alpha)
cairo_rectangle (cr,bar_bottom_left_x,bar_bottom_left_y,bar_width,-bar_height)
cairo_fill (cr)

so we have a red rectangle, now we need to think about making the indicator bar
first we need to get our reading into a string

value=tonumber(conky_parse("${cpu}"))

we are going to use the string value to affect the height of the indicator bar,
but we have a further complication in that we want out to be able to set indicator size in our settings part
so we need some math!

if we wanted out indicator to be 100 pixels high we would just be able to substitute cpu reading for height, as cpu will give us numbers between 0 and 100

but say we wanted our indicator to be 200 pixels high or only 50 pixels high, we need to scale up or down our cpu readings so that the indicator bar grows and shrinks in the right proportions

we know our maximum value for cpu is going to be 100
we need to divide the height we want by this maximum value to get the scale right
if we set bar_height=200
and max_value=100
then
scale=bar_height/max_value

scale = 2, so that for every increase of 1 in cpu % reading the bar will move an additional 2 pixels up
so at a cpu % of 100 the bar will be 200 pixels long, which is what we want

so

indicator_height=scale*value

and this is the number we plug into our rectangle drawing command

all together for the indicator

--draw indicator
cairo_set_source_rgba (cr,bar_in_red,bar_in_green,bar_in_blue,bar_in_alpha)--set indicator color
value=tonumber(conky_parse("${cpu}"))
max_value=100
scale=bar_height/max_value
indicator_height=scale*value
cairo_rectangle (cr,bar_bottom_left_x,bar_bottom_left_y,bar_width,-indicator_height)
cairo_fill (cr)

and you have a working cpu indicator bar

NOW what you could do is copy this code chunk over and over again, edit the settings and assign a different conky object to each instance for as many bars as you want
set up some text to label each bar and your done.
HOWEVER there is a better and easier way to get multiple bars than copying and pasting code
we can turn our indicator bar drawing code into a function
but more about functions in a later part!

making a cpu indicator circle meter
im picking cpu as my object of choice for no other reason than it is the one that changes the most
so you get to see your handy work in action

making a circle meter is very similar to the bar, except we are using the output of cpu% from conky to change the angles passed to the arc drawing command

we will have a ring meter with a background ring one color and an indicator ring of a different color
we will make the ring sizable through settings
we will have the ring show 0 cpu at the top and then as cpu increases the indicator bar will increase in size clockwise around the ring until at 100% it makes a complete circle and ends back at the top

we are going clockwise, so we will use cairo_arc
unlike the rectangle, we will be using cairo_stroke to draw our meter
so caro_set_line_width must be set which will give us the width of our indicator lines
setting the line cap type will have an effect on what the meter looks like
but we are not joining any lines so there is no point setting line join type

first you need to think about what kind of setting you want

a reminder of how we draw an arc

cairo_arc (cr,center_x,center_y,radius,start_angle,end_angle)

--SETTINGS
--rings size
ring_center_x=200
ring_center_y=200
ring_radius=50
ring_width=20
--colors
--set background colors, 1,0,0,1 = fully opaque red
ring_bg_red=1
ring_bg_green=0
ring_bg_blue=0
ring_bg_alpha=1
--set indicator colors, 1,1,1,1 = fully opaque white
ring_in_red=1
ring_in_green=1
ring_in_blue=1
ring_in_alpha=1
--indicator value settings
value=conky_parse("${cpu}")
max_value=100

just as the rectangle, go ahead and draw the background ring like so

--draw background
cairo_set_line_width (cr,ring_width)
cairo_set_source_rgba (cr,ring_bg_red,ring_bg_green,ring_bg_blue,ring_bg_alpha)
cairo_arc (cr,ring_center_x,ring_center_y,ring_radius,0,2*math.pi)
cairo_stroke (cr)

NOTE about line_width
line width when we are drawing a circle or arc works the same way as a straight line
half the line width is drawn to one side of the base line, one half of the line width is drawn to the other side
so if you set a radius of 50 pixels and a line width of 20 pixels, then from the center point of the circle to the inner edge of the line will only be 40 pixels
and it will be 60 pixels to the outer edge of the circle

we have a red background circle
now we have to work out how to apply the cpu% number held in the string "value" to making the indicator line move.

in this case it is the arc's end angle that will be changing relative to cpu%

again we need a bit of math to get the indicator arc moving in the right proportion

degrees=360
scale=degrees/max_value--ie for every 1% increase in cpu% the arc should move an additional 3.6 degrees
end_angle=value*scale

or i could just write

end_angle=value*(360/max_value)

now we can plug everything into the arc drawing command like so

--draw indicator
cairo_set_line_width (cr,ring_width)
end_angle=value*(360/max_value)
cairo_set_source_rgba (cr,ring_in_red,ring_in_green,ring_in_blue,ring_in_alpha)
cairo_arc (cr,ring_center_x,ring_center_y,ring_radius,0,(end_angle-90)*(math.pi/180))
cairo_stroke (cr)

HUH???
if you try the above code you will notice that something doesn't quite seem right
i thought i would put this in to take a look at what to do when things go wrong

the first thing i tried was adding a print line to the code like this:

--draw indicator
cairo_set_line_width (cr,ring_width)
end_angle=value*(360/max_value)
print (end_angle)
cairo_set_source_rgba (cr,ring_in_red,ring_in_green,ring_in_blue,ring_in_alpha)
cairo_arc (cr,ring_center_x,ring_center_y,ring_radius,0,(end_angle-90)*(math.pi/180))
cairo_stroke (cr)

was i calculating something wrong??
so i took a look at the terminal and watched what end_angle was being calculated as
i also went to the conkyrc and put in ${cpu} under TEXT so i could watch cpu at the same time
(i could have just put "print (value, end_angle)" and gotten both value in the terminal i suppose)

but it looked as if the calculations were giving me the correct result, so it must be something in the cairo_arc command itself that was going wrong

cairo_arc (cr,ring_center_x,ring_center_y,ring_radius,0,(end_angle-90)*(math.pi/180))

it was the start angle, which i had left at 0
i hadn't compensated for the arc command quirk so actually my 0 line was 90 degrees further around my circle than i thought it was!

a quick modification later:

cairo_set_line_width (cr,ring_width)
end_angle=value*(360/max_value)
--print (end_angle)
cairo_set_source_rgba (cr,ring_in_red,ring_in_green,ring_in_blue,ring_in_alpha)
cairo_arc (cr,ring_center_x,ring_center_y,ring_radius,(-90)*(math.pi/180),(end_angle-90)*(math.pi/180))
cairo_stroke (cr)

and we have a circle meter

Last edited by mrpeachy (2012-01-19 01:04:11)

Well I ve tried to implement the v9000 but with no luck, maybe not enough persistence....
I think after this series of howto I need to get back to the v9000 script and make it work!!!

Thank you for your work....

PART 6 - some more drawing calculations and if statements

so we have our bar indicator
ive moved the value setting and max_value setting up into the settings part of the code
and put "bar_" in front of each just to keep to my naming convention

--SETTINGS FOR CPU INDICATOR BAR
bar_bottom_left_x= 750
bar_bottom_left_y= 200
bar_width= 30
bar_height= 100
bar_value=tonumber(conky_parse("${cpu}"))
bar_max_value=100
--set bar background colors, 1,0,0,1 = fully opaque red
bar_bg_red=1
bar_bg_green=0
bar_bg_blue=0
bar_bg_alpha=1
--set indicator colors, 1,1,1,1 = fully opaque white
bar_in_red=1
bar_in_green=1
bar_in_blue=1
bar_in_alpha=1
--END OF SETTINGS

--DRAW BAR INDICATOR
--draw background
cairo_set_source_rgba (cr,bar_bg_red,bar_bg_green,bar_bg_blue,bar_bg_alpha)
cairo_rectangle (cr,bar_bottom_left_x,bar_bottom_left_y,bar_width,-bar_height)
cairo_fill (cr)
--draw indicator
cairo_set_source_rgba (cr,bar_in_red,bar_in_green,bar_in_blue,bar_in_alpha)--set indicator color
scale=bar_height/bar_max_value
indicator_height=scale*bar_value
cairo_rectangle (cr,bar_bottom_left_x,bar_bottom_left_y,bar_width,-indicator_height)
cairo_fill (cr)

but we want to jazz it up a bit and add a few additional features
1. we want the ability to draw a border around our indicator
- we want the border to be optional
- we want the ability to set the border color and border line thickness
2. we want the ability to set an "alarm" value for the bar so that:
- when the value we feed the bar bar reaches or goes past a certain point the bar changes to a different color
- we want to be able to specify the alarm value and the color the bar changes to

1 - adding an border
in our settings section we need some new options

bar_border=1 --set 1 for border or 0 for no border
--set border color rgba
border_red=0
border_green=1
border_blue=1
border_alpha=1
--set border thickness
border_width=10

 
i tend to use number switches for options like this, 1=yes i want it, 0=no i dont but you could just as well use text answers

bar_border="yes" --set "yes" for border or "no" for no border

 
the downside is that "Yes" is not the same as "yes" when we come to use a comparison later on

this case specificity can be overcome by using the in built commands string.upper() or string.lower() but that would be a topic for another time
for now we will use either 1 or 0

another aspect of the border is that it shouldn't cover up any part of the indicator bar
and there are actually several ways i can think of achieving the desired border

we could draw a filled in rectangle behind the indicator background rectangle
our "border" rectangle would be larger than the indicator rectangles, so you would see its edges sticking out around the edges of the indicator

or we could use the rectangle command with cairo_stroke so that we only draw the lines and dont fill it in

or we could draw individual lines

each of these methods has some positives and negatives
but lets go with drawing a rectangle with cairo_stroke

the tricky part here is how line_width is applied when drawing the rectangle

all 3 of these rectangles have been set a width of 60 and a height of 40
the difference you see is that they have line widths of 1,10 and 20 respectively

we need to compensate for the encroachment of the border into the middle of our rectangle

this is how i would do it

first we need to set the x and y coordinates for our border relative to bar_bottom_left_x and bar_bottom_left_y so that when we want to move our bar around we only need to edit bar_bottom_left_x and bar_bottom_left_y and all other strings change automatically  in relation to those settings

border_bottom_left_x=bar_bottom_left_x-(border_width/2)--we [u]subtract[/u] because we are going to the [u]left[/u]
border_bottom_left_y=bar_bottom_left_y+(border_width/2)--we [u]add[/u] because we are going [u]down[/u]

this starts our border rectangle to the left and lower than we start our bar to compensate for line_width
but now we also have to make the border rectangle wider and bigger than our bar rectangle so that it surrounds the bar rectangle

brec_width=bar_width+border_width
brec_height=bar_height+border_width

NOTE
when i was writing the above lines, i thought that since i had named the width and length strings for the indicator rectangles bar_width and bar_height that i would call the width and height strings for the border rectangle border_width and border_height (even had these typed out).
BUT i realised that i couldnt use "border_width" because i have already used it to name the string that holds the value of line_width for the border, so i had to come up with something else

and we can set up our border and plug those strings into the rectangle drawing command like so

cairo_set_source_rgba (cr,border_red,border_green,border_blue,border_alpha)
cairo_set_line_width (cr,border_width)
border_bottom_left_x=bar_bottom_left_x-(border_width/2)
border_bottom_left_y=bar_bottom_left_y+(border_width/2)
brec_width=bar_width+border_width
brec_height=bar_height+border_width--remember that we need to make the value of brec_height negative at some point because we are drawing up
cairo_rectangle (cr,border_bottom_left_x,border_bottom_left_y,brec_width,-brec_height)--we will set brec_height negative in this line
cairo_stroke (cr)

where should we put this code?
since we have done our calculations correctly, the border shouldnt interfere with our indicator, so you could have this code in several places, before we draw the background, affter the background and before the indicator or after the indicator.

so we have a border but we havn't used the setting "bar_border" to allow us to optionally have the border or not.
to do that we need an if statement

IF STATEMENTS
for example:

if bar_border==1 then
--border drawing code
end

this is the simplest form of the if statement
if we set bar_border=1 in our settings then the border is drawn
or more specifically, if the string "bar_border" has a value of 1 then everything between then and end is done

if we set bar_border to 0 (or if bar_border is set to anything other than 1 in this case) then the border doesn't get drawn (anything between then and end is skipped)

EVERY IF NEEDS AN END
you could also say that every if needs a then, but depending on how you set up your statement, there can be multiple thens within it

NOTE
we need a double equals sign (==) when we are making a comparison
other options for comparisons are:
> greater than
>= greater than or equal to
< less than
<= less than or equal to
~= not equal to

we'll get to a more complicated if later on

Last edited by mrpeachy (2012-01-19 03:07:43)

{hand up in the back}  Yuuuu hooooo!!!!

Commenting code is always a blessing to us newer than new coders so I have a question:

Is this "no space" comment necessary like shown

if updates>5 then
--##############################
print ("hello world")
--##############################
end-- if updates>5

or can it be spaced or tabbed?

if updates>5 then
--     ##############################
print ("hello world")
--     ##############################
end                  -- if updates>5

It may sound silly to a coder but - I'm not one.

Last edited by Sector11 (2012-01-19 20:18:31)

PART 7 -  adding our alarm color change feature and looking at more complex if statements

we were jazzing up our bar meter
we added an optional border as feature 1

and we are going to have the bar change color for feature 2

to get the color change we i'll need to add a few more settings!
most likely if you are going to set an alarm color, you'll think of red (as i did)
so we would have to re-color our background bar also (which is also currently red)
im feeling a little lazy so im going to go for some shorter string names, particularly for all the reds green blue and alphas coming up

--set alarm value, this is the value at which bar color will change
alarm_value=80
--set alarm bar color, 1,0,0,1 = red fully opaque
ar,ag,ab,aa=1,0,0,1

we already have a base bar color
so we want the bar to be our base color unless the cpu% reading equals or goes above 80%

we are going to be using another IF to get the colors to change
as with most code, there are multiple ways we could go about doing things
lets first remind ourselves of the code that is drawing the indicator part of the bar
it is that part that we will be editing as it is that part which will change color

cairo_set_source_rgba (cr,bar_in_red,bar_in_green,bar_in_blue,bar_in_alpha)--set indicator color
scale=bar_height/bar_max_value
indicator_height=scale*bar_value
cairo_rectangle (cr,bar_bottom_left_x,bar_bottom_left_y,bar_width,-indicator_height)
cairo_fill (cr)

to apply our if statement to colors we could do the following:
remember, "bar_value" is the name of the string holds the value of cpu%
and we set "alarm_value" above to 80

if bar_value<alarm_value then
cairo_set_source_rgba (cr,bar_in_red,bar_in_green,bar_in_blue,bar_in_alpha)
else
cairo_set_source_rgba (cr,ar,ag,ab,aa)
end

hopefully it should be quite self explanatory what is going on in the above code
if the string named "bar_value" has a value of less than 80 then the color is set to the base indicator color (which we have set to white in settings)
-all code between then and else is done
if the value of "bar_value" is not less than 80 (ie equal to or greater than 80) then color is set to the alarm color
-all the code between then and else is skipped and everything between else and end is done

this would have also worked

if bar_value>=80 then
cairo_set_source_rgba (cr,ar,ag,ab,aa)
else
cairo_set_source_rgba (cr,bar_in_red,bar_in_green,bar_in_blue,bar_in_alpha)
end

how do we know its working?
we think that we have our code right and we expect that if our cpu% gets to 80% or more that our bar color will change from white to red
but its always a good idea to check that things are working the way we expect.

We could do something on the computer that would drive the actual cpu% reading up to 80 or above
but there is an easier way
in our settings we have the line that sets the value of bar_value

bar_value=tonumber(conky_parse("${cpu}"))

just edit that line and "hard code" bar_value to a test value like this

bar_value=80--tonumber(conky_parse("${cpu}"))

i dont like to completely replace the line with our test value as it simply harder to reinstate the line afterwards
with the test value in place and the rest of the line commented out, once we are sure our feature is working
we just delete the test value and the comments and everything is back to being operational

now we like the color change, and we want to implement another color change
we want the bar to be one color when cpu% is low, say green up to 50%
then we want the color to change to a different color, yellow for example, between 50% and 80%
then if our reading gets to 80 or over it goes to red

so back to the settings
we already have our alarm (or high cpu usage) value and color

--set value for first color change, low cpu usage to mid cpu usage
mid_value=50
--set "low" cpu usage color and alpha, ie bar color below 50% - 0,1,0,1=fully opaque green
lr,lg,lb,la=0,1,0,1
--set "mid" cpu usage color, between 50 and 79 - 1,1,0,1=fully opaque yellow
mr,mg,mb,ma=1,1,0,1

while we could reuse our base bar color settings, and just change the numbers to green or yellow

bar_in_red=1
bar_in_green=1
bar_in_blue=1
bar_in_alpha=1

since we are making some significant changes to how our colors are working i would just go ahead and delete them and replace them with the new low mid and alarm values
i tend to like to stick to a single naming convention also which helps me to remember what i have named strings (and maybe because of some mild OCD))
but again, thats just me, you can call your string whatever you want to!

so now we need to think about how to set up our if statement
when cpu is between 0 and 49 we want green
when cpu is between 50 and 79 we want yellow
and when cpu is 80 or above we want red

so lets put them into a statement

if bar_value>=mid_value then --ie if value is greater or equal to 50
cairo_set_source_rgba (cr,mr,mg,mb,ma)--yellow (mid color)
elseif bar_value>=alarm_value then --ie if bar_value is greater or equal to 80
cairo_set_source_rgba (cr,ar,ag,ab,aa)--red (alarm color)
else
cairo_set_source_rgba (cr,lr,lg,lb,la)--green (low color)
end

we use an elseif, because it is no longer an either or situation, there are 3 possibilities we need to sort out

test the setup by setting bar_value to some test value
we set
bar_value=49 and we get a green bar, and it is green for any number below 50
we set
bar_value=50 and we get a yellow bar
then try
bar_value=80 and the bar is still yellow! and it is yellow all the way up to 100

our statement seems entirely logical, but this is one of the pitfalls you can get stuck in
to understand it we need to think about how our if statement works and we can see that the problem is in the order of our comparisons

if bar_value>=mid_value then --ie if value is greater or equal to 50
cairo_set_source_rgba (cr,mr,mg,mb,ma)--yellow (mid color)

this first line does indeed match any number from 50 to 100 and so any cpu vale from 50 to 100 will result in a yellow bar.

the script comes to the line, takes the value of "bar_value" calculates if it is greater or equal to the value of mid_value
if it passes the comparison, the script runs the corresponding code and then its done with the if statement

only if bar_vale is less than 50 then the first comparison will fail and the script will move on to the next comparison
but of course this comparison will fail also as if a value is not greater or equal to 50 then it wont be greater or equal to 80

once past the if and the following elseif the script automatically runs the code following else which doesnt require a comparison
again there are plenty of ways we can fix this
we can try and reorder our comparisons like so

if bar_value>=alarm_value then --ie if value is greater or equal to 80
cairo_set_source_rgba (cr,ar,ag,ab,aa)--red (alarm color)
elseif bar_value>=mid_value then --ie if bar_value is greater or equal to 50
cairo_set_source_rgba (cr,mr,mg,mb,ma)--yellow (mid color)
else
cairo_set_source_rgba (cr,lr,lg,lb,la)--green (low color)
end

take a value of say 90
check 1) is 90 greater or equal to 80?
yes -> pass the first comparison and run the code to set color to red
done!

set a value of 60
check 1) is 60 greater or equal to 80?
no -> fail the first comparison, move onto the next
check 2) is 60 greater or equal to 50?
yes -> pass the second comparison and run the code to set color to yellow
done!

set a value of 48
check 1) is 48 greater or equal to 80?
no -> fail the first comparison, move onto the next
check 2) is 48 greater or equal to 50?
no -> fail the second comparison, move onto the next
no more checks, run code following else and set color to green
done!

Last edited by mrpeachy (2012-01-20 00:10:45)

PART 9 – sending information to functions

I left off after describing how to send indicator bar setup information from the main conky (conky_main) function to a separate function called indicator_bar which takes the information sent to it and draws a bar indicator based on those settings

we did this in conky_main

indicator_bar(100,100,30,100,tonumber(conky_parse("${cpu}")),100,0.5,0.5,0.5,1,1,0,1,1,1,10,50,0,1,0,1,1,1,0,1,80,1,0,0,1)

putting all our settings right into the function call

while this way works just fine there are some drawbacks to doing it this way

first of all its just hard to keep track of what each number means
and second its easy to miss something out (or miss out a comma which are necessary to seperate values)
as I described earlier a missed entry (or comma) when sending information this way will lead to your script giving an error

i prefer to define my strings, and then duplicate each string name in the function call
for example using the multiply function it would look like this

number=16
result=multiply(number)

now we dont have to touch our function call change the number we are sending to the function, we only need change the value we are assigning to the string called "number"

so for our indicator bar setup we would just take the settings lines we already have, and add the call at the end

--SETTINGS FOR INDICATOR BAR
bar_bottom_left_x= 100
bar_bottom_left_y= 100
bar_width= 30
bar_height= 100
bar_value=tonumber(conky_parse("${cpu}"))
bar_max_value=100
--set bar background colors, 0.5,0.5,0.5,1 = fully opaque grey
bar_bg_red=0.5
bar_bg_green=0.5
bar_bg_blue=0.5
bar_bg_alpha=1
--bar border settings
bar_border=1 --set 1 for border or 0 for no border
--set border color rgba
border_red=0
border_green=1
border_blue=1
border_alpha=1
--set border thickness
border_width=10
--color change
--set value for first color change, low cpu usage to mid cpu usage
mid_value=50
--set "low" cpu usage color and alpha, ie bar color below 50% - 0,1,0,1=fully opaque green
lr,lg,lb,la=0,1,0,1
--set "mid" cpu usage color, between 50 and 79 - 1,1,0,1=fully opaque yellow
mr,mg,mb,ma=1,1,0,1
--set alarm value, this is the value at which bar color will change
alarm_value=80
--set alarm bar color, 1,0,0,1 = red fully opaque
ar,ag,ab,aa=1,0,0,1
--end of settings, call drawing function
[b]indicator_bar(bar_bottom_left_x,bar_bottom_left_y,bar_width,bar_height,bar_value,bar_max_value,bar_bg_red,bar_bg_green,bar_bg_blue,bar_bg_alpha,bar_border,border_red,border_green,border_blue,border_alpha,border_width,mid_value,lr,lg,lb,la,mr,mg,mb,ma,alarm_value,ar,ag,ab,aa)[/b]

you set values to all your strings and each string matches each entry in the function call list so that the values are transfered directly between the two

writing your code this spells out everything nice and simply which allows easy entry of settings

you dont have to remember what numbers mean what, you dont have to worry about commas and you are less likely to miss out a value (you would have to delete a whole setting line to do that)

the down side to this is that it takes a lot more lines of code this way.

ANOTHER WAY
you can do something half way between these two methods mentioned so far which takes advantage of the fact that lua doesnt mind having its code split onto multipl lines AS LONG AS the information is bounded either by curved brackets () when sending info to functions or curly brackets {} when defining a table

take the rectangle drawing command

cairo_rectangle (cr,50,50,50,-100)

this is just like the function we made, except you dont see the rectangle drawing code anywhere in the script (it's a built in function).

we call the function "cairo_rectangle" and send it the information it needs inside curved brackets ()

BUT once the curved brackets are opened (the opening bracket has to be on the same line as the function call) we can then split up our entries on to seperate lines

cairo_rectangle (cr,
50,
50,
50,
-100)

we have to make sure that we have still have commas seperating the entries
but entering data this way has the advantage that we can write comments on each line and everything still works

cairo_rectangle (cr,
50,--rectangle x position
50,--rectangle y position
50,--rectangle width
-100--rectangle height
)

we could do this just the same with out indicator bar function
you can see below i have split some entries onto seperate lines but kept others together on the same line where it makes sense

indicator_bar(
750,400,--position x,y
30,--bar width
100,--bar height
tonumber(conky_parse("${cpu}")),--value to send bar
100,--max value
0.5,0.5,0.5,1,--bar background color rgba - grey
1,--want border, 1=yes,0=no
0,1,1,1,--border color rgba - light blue
10,--border width
50,--mid value, point of first color change
0,1,0,1,--low cpu% color rgba - green
1,1,0,1,--mid cpu% color rgba - yellow
80,--alarm value, point of second color change
1,0,0,1--alarm color rgba - red
)

A MORE COMPLEX USE OF FUNCTIONS
the functions i have given as examples are pretty straightforward
set up the function, call it and give it the info it needs, the function outputs something for example a number or some graphics

but the use of functions can be more complex

here is an example
we are going to have our main conky function, and two additional functions :
one function is going to be for drawing arcs
the second function will convert degrees into radians and adjust for the cairo_arc quirk so that 0 degrees is the top of the circle

our angle conversion function might look like this

function arad(degrees)
--compensate for cairo_arc quirk
degrees=degrees-90
--convert degrees to radians
radians=degrees*(math.pi/180)
--return angle
return radians
end--function arad

NOTE this line
degrees=degrees-90
i do this quite often, as others do in their scripts

im taking the value of the string "degrees" as it was set inside ()
subtracting 90 from it but putting the result of that operation into a string also called "degrees"

as mentioned earlier, strings of the same name overwrite each other
and the second instance of a string called "degrees" will indeed overwrite the first instance BUT not until the original "degrees" string is used in the calculation

as long as you know that you will no longer need the value held in the first "degrees" string after using it in, for example, a calculation then reusing the string name just makes it so that you dont have to keep thinking u new string names!

The arc drawing function might look like this
ill use nice short string names here

mx will be for middle x position
my will be for middle y position
rad for radius
sa for start angle
ea for end angle
(i will be giving angles in degrees when i call the function)

i want all my circles to be white with a line thickness of 1, so im going to set color,alpha and line_width in the function itself

function circle(mx,my,rad,sa,ea)
cairo_set_source_rgba (cr,1,1,1,1)
cairo_set_line_width (cr,1)
cairo_arc (cr,mx,my,rad,arad(sa),arad(ea))
cairo_stroke (cr)
end--function circle

the important line to note is this one
cairo_arc (cr,mx,my,rad,arad(sa),arad(ea))

i can use the arad function inside the cairo_arc command to convert the degree values we send "circle" into adjusted radian values to use with cairo_arc

then last of all we have our conky_main function

function conky_main ()
--conky function setup lines
--##########################
circle(100,100,50,90,270)
--##########################
--cony function close out lines
end-- of conky main

if we think about the flow of information, we send "circle" the information in the function call inside "conky_main"

cirlce recieves the list of values and sets its list of strings to those vales in order

it uses the strings my,mx and rad directly but it ships out sa and ea to "arad"

arad recieves the value of sa, puts that value into a string called degrees and converts the value to adjusted radians and sends this new value back to "circle" where is is used as the start value directly in the cairo_arc command

then arad receives the value of ea and returns the result directly into cairo_arc

the chain of functions using functions could keep hoing for as many functions as you could write
and you can of course use as many functions within any other function as you want

next part will introduce tables

Last edited by mrpeachy (2012-01-21 20:15:15)