Useful and useless scripts

HowTo run multiple Lua scripts in a Conky

2011-02-18T14:25:00.000-08:00

Hello,

Here is a little HOWTO for running more than one Lua script at the same time.

1. Method for two scripts with Conky objects

This can be done for two scripts with the two functions of Conky : lua_draw_hook_pre and lua_draw_hook_post

lua_load /home/wlourf/lua/scriptA.lua
lua_draw_hook_pre functionA

lua_load /home/wlourf/lua/scriptB.lua
lua_draw_hook_post functionB

lua_draw_hook_pre is called before Conky parse the TEXT section and lua_draw_hook_post is called after the Conky parse the TEXT section. So effects are not very nice because the two calls are not synchronized.

2. Method with a Lua script for 2 or more scripts

Now, here is an example for 2 scripts, but you can modify it for three, four ... scripts :
Save the two scripts (scriptA.lua with conky_functionA() and scriptB.lua with conky_functionB() in the same folder : /home/wlourf/multi/ for my example :
Create a third script loadAll.lua, and paste that :

package.path = "/home/wlourf/multi/?.lua"
require 'scriptA' --for scriptA.lua ".lua" is not required here
require 'scriptB'

function conky_main()
     conky_functionA()
     conky_functionB()
end

and in the conkyrc, call the conky_main function with lua_draw_hook_pre or lua_draw_hook_post, like this :

lua_draw_hook_post main

3. With some variables

Now, sometimes, we need to use the same parameters in more than one script (colours, x and y position ...). So we have to write them in the conky_main() function so they can be used in the functions conky_functionA() and conky_functionB()

To avoid memory leaks, we have to declare the variables in local, so these variables will be available only for the conky_main() function, then we have to "pass" them to the functions, like that :

function conky_main()
    local varX = 25
    local varY = 50
    conky_functionA(varX,varY)
    conky_functionB(varX,varY)
end

and in the functions :

function conky_functionA(varX,varY)
table_config ={...,
     x=varX,
     y=varY,..
}
end

Ok, passing functions from the conky_main() function to other functions can be boring when we have a lot of parameters. The easiest way to pass the parameters is to group them into a table and to pass the table :

function conky_main()
    local table_param={
        varX = 25,
        varY = 50
    }
    conky_functionA(table_param)
    conky_functionB(table_param)
end

and in the functions :

function conky_functionA(t)
table_config ={...,
    x=t.varX, 
    y=t.varY, ...
}
end

t.varX is the variable varX from the table t, it can be written t.["varX"]

That's all. I hope this little HowTo will help you to use multiple Lua scripts. This is my own way to manage multiple scripts, it can be done with others methods dofile, loadfile or instances !

Happy Conkying ;-)

Box widget

2011-01-27T13:15:00.000-08:00

Back to basics with Lua and Cairo! This widget draws only a customizable box. It is inspired from Londonali's Background script.

The script can be downloaded on deviantArt : here.

As usual, the widget uses a table to get the parameters : boxes_settings

The minimum setup is an empty table :

local boxes_settings={
 {},
}

This one draws a box with the default parameters : same size of the conky window, white background with opacity set to 50 %.

Parameters for positioning the box are x, y, w and h, relatives to the top-left corner of the Conky's window.
The same box as above but with a shorter height:

local boxes_settings={
 {h=130},
}

Another box with the 4 parameters :

local boxes_settings={
 {x=3,y=35,h=95,w=85},
}

It's quite easy to use more than one box :

local boxes_settings={
 {x=3,y=35,h=95,w=85},
 {x=92,y=35,h=95,w=117},
}

Tha Lua API for Conky can get some informations about Conky's window, for example, to get the window's height or width, use conky_window.height or conky_window.width in the Lua scripts :

local boxes_settings={
 {x=3,h=25,w=conky_window.width-6},
 {x=3,y=35,h=95,w=85},
 {x=92,y=35,h=95,w=117},
}

So, with the above code, when the Conky's window increases, the top box is still nice :

Each corner of a box can be set individually in a table {shape,radius}
The four corners are join into a table named corners:

corners={ {shape-top-left,radius-top-left},
 {shape-top-right,radius-top-right},
 {shape-bottom-left,radius-bottom-left},   
 {shape-bottom-right,radius-bottom-right}
 }

Available shapes are : "curve", "circle" and "line"

If the corners table has less than 4 elements, the last element is used for missing elements:
Box with one corner defined:

{w=400,h=120, corners={ {"circle",40} } }

The boxes can be draw with only a border if the border parameter is greater than zero :

Some dashes can be added to the border if the dash parameter is greater than zero:

The box can be rotated around his top-left corner with the angle parameter :

The rotation can be arround the x axis or the y axis with the skew_x and skew_y parameters :

An interesting feature of Cairo is the compositing operator :
In this script, the compositing operator is called with the operator parameter, and the available arguments are "clear", "source", "over", "in", "out", "atop", "dest", "dest_over", "dest_in", "dest_out", "dest_atop", "xor", "add", "saturate". Default is "over".

NOTE : in your conkyrc, you need the parameter

own_window_argb_visual yes

Let's start with theses two boxes :

     {x=10,y=10,w=150,h=90, },
 {x=50,y=20,w=60,h=150, corners={{ "curve",10}} },

for this output :

The "clear" operator :

     {x=10,y=10,w=150,h=90, },
 {x=50,y=20,w=60,h=150, corners={{ "curve",10}} , operator="clear" },

The "out" operator :

     {x=10,y=10,w=150,h=90, },
 {x=50,y=20,w=60,h=150, corners={{ "curve",10}} , operator="out" },

The "add" operator :

     {x=10,y=10,w=150,h=90, },
 {x=50,y=20,w=60,h=150, corners={{ "curve",10}} , operator="add" },

and so on ...

Last part of the boxes are the colour, colours are set in the colour tables.
Each "table colour" contains one or more tables which defines the colours of a gradient :
table={P,C,A}
P = position inside the linear gradient (0 = start of the gradient, 1= end of the gradient)
C = hexadecimal colour
A = alpha (opacity) of colour (0=invisible,1=opacity 100%)

For example, for a single colour table:

colour={{0,0x0000ff,1}}

for a 2-colours table :

colour={
{0,0x0000ff,1},
{1,0xff00ff,1}
}

for a 3-colours table:

colour={
{0,0x0000ff,1},
{0.5,0xff00ff,1},
{1,0xff00ff,1}
}

The output of this box :

     {x=10,y=10,w=250,h=90, colour={ {0,0xFFFF00,1} } }

is a yellow rectangle :

The output of this box

   {x=10,y=10,w=250,h=90, colour={ {0,0xFFFF00,1}, {1,0xFF0000,1}  } }

is a yellow rectangle again because we haven't set up the gradient to use.

Gradients are defined with one of this parameters linear_gradient or radial_gradient

linear_gradient - table with the coordinates of two points to define a linear gradient,
              points are relative to top-left corner of the box, (not the conky's window)
              {x1,y1,x2,y2}
radial_gradient - table with the coordinates of two circle to define a radial gradient,
              points are relative to top-left corner of the box, (not the conky window)
              {x1,y1,r1,x2,y2,r2} (r=radius)

This code :

     {x=10,y=10,w=250,h=100,
 colour={ {0,0xFFFF00,1}, {1,0xFF0000,1}} ,
 linear_gradient={0,0,0,100}  }

gives this output:

This code :

     {x=10,y=10,w=250,h=100,
 colour={ {0,0xFFFF00,1}, {1,0xFF0000,1}} ,
 linear_gradient={0,0,0,50}  }

gives this output:

This code :

     {x=10,y=10,w=250,h=100,
 colour={ {0,0xFFFF00,1}, {0.5,0xFF0000,1}} ,
 linear_gradient={0,0,0,50}  }

gives this output:

This code, with a radial gradient :

     {x=10,y=10,w=250,h=90,
 colour={ {0,0xFFFF00,1}, {1,0xFF0000,1}} ,
 radial_gradient={0,0,0,0,0,90}  }

gives this output :

This code:

     {x=10,y=110,w=300,h=10,
 colour={ {0,0x0000FF,0}, {0.5,0x00FF00,1}, {1,0x0000FF,0},} ,
 radial_gradient={0,5,0,0,5,300}  }

gives this output :

Other parameters added recently, while writing this note :
scale_x and scale_y to rescale the box, useful for drawing elipses
draw_me : if set to false, box is not drawn (default = true or 1)
it can be used with a conky string, if the string returns 1, the box is drawn :
example : "${if_empty ${wireless_essid wlan0}}${else}1$endif",

Some examples of amazing setup :

     {x=300,y=70,w=250,h=100,
    linear_gradient={0,80,0,100},
    colour={{0,0x000000,1},{0.5,0xFFFFFF,1}},
    },

    {x=200,y=70,w=100,h=100,
    radial_gradient={100,100,0,100,100,20},
    colour={{0.5,0xFFFFFF,1},{1,0x000000,1}},
    },

    {x=200,y=170,w=100,h=100,
    linear_gradient={80,0,100,0},
    colour={{0.5,0xFFFFFF,1},{0,0x000000,1}},
     },     
    {x=200,y=270,w=100,h=100,
    radial_gradient={100,0,0,100,0,20},
    colour={{0.5,0xFFFFFF,1},{1,0x000000,1}},
    },
    {x=300,y=270,w=250,h=100,
    linear_gradient={0,0,0,20},
    colour={{1,0x000000,1},{0.5,0xFFFFFF,1}},
    },        
    {x=290,y=160,h=120,
    corners={{"circle",10}},
    operator="clear"  }

for this output :

A button :

 local gradient = { {0,0x858585,1}, {1,0x000000,1}}
local table_settings={
 
 {w=200,h=200,
 colour=gradient,
 linear_gradient= {0,0,0,200}  },
 
 {x=10,y=10,w=180,h=180,
 corners={ {"circle",90} },
 colour=gradient ,
 linear_gradient= {180,180,10,10}  },
 
 {x=20,y=20,w=160,h=160,
 corners={ {"circle",80} },
 colour=gradient ,
 linear_gradient= {20,20,160,160}  },

}

for this output :

If you create some nice conkys with this widget, or any other, feel free to post a link in the comments ;-)

Memory Leaks in Conky/Lua/Cairo

2011-01-13T14:45:00.000-08:00

A user named "Creamy Goodness" of Nokia N900 phone uses conky on his phone and this phone does not have much memory. He looked at my scripts a little closer and gave me some pointers to reduce memory leaks :

1. Avoid global variables.
If you don't specify local in front of a variable, the variable is set to global. When conky runs the script, the global variable is set but it is not destroy at the end of the script (even if you set the variable to nil). At each loop a variable is created so memory usage increase !

But, it can be very interesting to have global variables with conky because each time a Lua script is called (ie at every update of the conky), the variable is still in memory and you can use it. This is the way I do when I draw graphs : the script start with an empty table and at each loop a new element popup the values in the table. Not very efficient but it works.

2. Declare variables in local
It's a good habit to declare variables in local, even in a local function, so they are destroyed when the script exits. I'm not sure but a local variable outside a function is OK too.

3. Don't forget "cairo_pattern_destroy"
When creating patterns, dont' forget to destroy them when the drawing is finished with cairo_pattern_destroy(pat) and of course destroy contexts and surfaces with cairo_destroy(cr) and cairo_surface_destroy(cs).

4. Use strict.lua to check use of undeclared variables
The script strict.lua can be found here or here or in the Lua5.1 package.
Creamy Godness made a modified version of this script to print a warning when it finds undeclared variables :

--
-- strict.lua
-- checks uses of undeclared global variables
-- All global variables must be 'declared' through a regular assignment
-- (even assigning nil will do) in a main chunk before being used
-- anywhere or assigned to inside a function.
--
-- From Lua distribution (etc/strict.lua)
--

local getinfo, error, rawset, rawget = debug.getinfo, error, rawset, rawget

local mt = getmetatable(_G)
if mt == nil then
mt = {}
setmetatable(_G, mt)
end

mt.__declared = {}

local function what ()
local d = getinfo(3, "S")
return d and d.what or "C"
end

mt.__newindex = function (t, n, v)
if not mt.__declared[n] then
 local w = what()
 if w ~= "main" and w ~= "C" then
   print("assign to undeclared variable '"..n.."'")
 end
 mt.__declared[n] = true
end
rawset(t, n, v)
end

mt.__index = function (t, n)
if not mt.__declared[n] and what() ~= "C" then
 print("variable '"..n.."' is not declared")
end
return rawget(t, n)
end

To use it, simply call the script in the script you want to check with

require 'strict'

if both scripts are in the same folder.

5. Workaround
You can use a cron job to run a script that will killall conky and restarts your conkys.

6. Further reading :
Lua documentation : Detecting Undefined Variables
The conky for the phone with the comments of Creamy Goodness, on Ubuntu Forums or on Mameo.org
Memory Leaks with Cairo and imlib2 on londonali's blog.

Graph Widget

2010-10-31T05:22:00.000-07:00

After some months, here is a new widget.
This one draw graphs like *_graph variables in conky (cpugraph, downspeedgraph, ...) but with some amazing options.

The widget use a lot of parameters but only three are mandatory, others are optional. If they are missing, default values are used.

Link to download on deviantArt : here

As usual, settings are made through tables :

graph_settings={
 {table_setting for ring1},
 {table_setting for ring2},
 {table_setting for ring3},
}

For each table, the 3 mandatory parameters are name, arg and max.

In a conky, you write: ${cpu cpu1}, In the script, you will write :

graph_settings={
 {
 name="cpu",
 arg="cpu1",
 max=100,
 --(max is set to 100 because maximum value of $cpu is 100% but you can set it to 50% if you want)
 }
}

For my next examples, I will use this table :

graph_settings={
 {
 name="time",
 arg="%S",
 max=60,
 }
}

and update_interval 1 in conkyrc.

This simple table will draw this kind of graph in the bottom-left corner of the conky window:

You can see a gradient on the background and a gradient on the graph itself.

The default size of the graph is 100x20 pixels but we can change the size and position with width, height, x and y parameters.
x and y are the bottom-left corner of the graph, they are relative to the top-left corner of the conky window

Let zoom in the graph for the next screenshots :

 graph_settings={
     {
     name="time",
     arg="%S",
     max=60,
     width=250,
     height=75,
     x=20,
     y=200,
     },
      }

On the above image, the width is set to 250 pixels, it means , with a conky update of 1 s, that the graph duration is 250 seconds. (each triangle is for one minute)

The same graph with update_interval 0.5 will display half the previous one.

By default, the graph displays one value per pixel, but we can change that with the nb_values parameter : it sets the number of values to display

 graph_settings={
     {
     name="time",
     arg="%S",
     max=60,
     width=250,
     height=75,
     nb_values=60,
     },
      }

Here, we display 60 values, with update_interval 1, it display values for one minute :

Ok, theses triangle are boring, let play with a cpu graph :

 graph_settings={
     {
     name="cpu",
     arg="",
     max=100,
     width=250,
     height=75,
     nb_values=60,
     },
      }

With the maximum value set to 100% (max=100), this graph is not useful :

For a better view, we can use the autoscale parameter, if set to true true, the script calculate the maximum value to use (and do not use the max parameter)

 graph_settings={
     {
     name="cpu",
     arg="",
     max=100,
     width=250,
     height=75,
     nb_values=60,
     autoscale=true,
     },
      }

Others ways to change the layout of the output are angle, skew_x and skew_y parameters
For angle :

   graph_settings={
     {
     name="cpu",
     arg="",
     max=100,
     width=250,
     height=75,
     nb_values=60,
     autoscale=true,
     x=50,
     angle=-35,
     },
      }

For skew_x :

 graph_settings={
     {
     name="cpu",
     arg="",
     max=100,
     width=250,
     height=75,
     nb_values=60,
     autoscale=true,
     x=175,
     skew_x=-15,
     },
      }

For skew_y :

 graph_settings={
     {
     name="cpu",
     arg="",
     max=100,
     width=250,
     height=75,
     nb_values=60,
     autoscale=true,
     skew_y=-15,
     },
      }

For both skew_x and skew_y :

 graph_settings={
     {
     name="cpu",
     arg="",
     max=100,
     width=250,
     height=75,
     nb_values=60,
     autoscale=true,
     x=175,
     skew_y=-25,
     skew_x=-15,
     },
      }

Another parameter is inverse, if set to true, the graph is drawn from right to left

Now, some parameters to change the output of the graph :
background set to false to not display the background :

 graph_settings={
     {
     name="cpu",
     arg="",
     max=100,
     width=250,
     height=75,
     nb_values=60,
     autoscale=true,
     background=false,
     },
      }

foreground set to false to not display the graph! (Wait, you will see that is useful soon !):

 graph_settings={
     {
     name="cpu",
     arg="",
     max=100,
     width=250,
     height=75,
     nb_values=60,
     autoscale=true,
     foreground=false,
     },
      }

But ... we can add a border to the graph with fg_bd_size. If set to zero, no border is drawn

 graph_settings={
     {
     name="cpu",
     arg="",
     max=100,
     width=250,
     height=75,
     nb_values=60,
     autoscale=true,
     foreground=false,
     fg_bd_size=5,
     },
      }

And a border can be added to the background with bg_bd_size

 graph_settings={
     {
     name="cpu",
     arg="",
     max=100,
     width=250,
     height=75,
     nb_values=60,
     autoscale=true,
     fg_bd_size=2,
     bg_bd_size=2,
     },
      }

with foreground back to true, the default value, we can have that :

Now have a look on the colours.
Each colours for background, foreground, background_border, graph border are set in theses parameters :
bg_colour, fg_colour, bg_bd_colour and fg_bd_colour.

For example, for a single colour table:

bg_colour={{0,0x0000ff,1}}

for a 2-colours table :

bg_colour={
 {0,0x0000ff,1},
 {1,0xff00ff,1}
 }

for a 3-colours table:

bg_colour={
 {0,0x0000ff,1},
 {0.5,0xff00ff,1},
 {1,0xff00ff,1}
 }

and so on ...

Each "table colour" above contains one or more tables which defines the colours of a gradient :
table={P,C,A}
P = position inside the linear gradient (0 = start of the gradient, 1= end of the gradient)
C = hexadecimal colour
A = alpha (opacity) of colour (0=invisible,1=opacity 100%)

Some examples with the background only :

As the gradient is linear, I add an orientation parameter, for the four colours :
bg_orientation, bg_bd_orientation, fg_orientation and fg_bd_orientation.
The values of the parameter are the starting point of the gradient, like in this picture :

and, in use :

On the above image, the difference between nw and ww is not obvious but if we decrease the width of the graph, the effect is more visible, like this, for the 8 possible values : "nn","ne","ee","se","ss","sw","ww","nw" :

Stop playing now, try to draw a real graph with some gradients :

 graph_settings={
     {
     name="cpu",
     arg="",
     max=100,
     width=250,
     height=75,
     nb_values=100,
     autoscale=true,
     bg_bd_size=1,
     fg_bd_size=3,
     bg_colour = {{0,0xFFFFFF,1}},
     bg_bd_colour = { {0,0x00000,1}},       

     fg_colour = { {0,0xFF0000,1},
                     {0.66,0xFFFF00,1},
                     {1,0x00FF00,1},
                   },
     fg_bd_colour = { {0,0x000000,1}},       
     },
      }

Another one:

 graph_settings={
     {
     name="cpu",
     arg="",
     max=100,
     width=250,
     height=75,
     nb_values=100,
     autoscale=true,
     bg_bd_size=0,
     fg_bd_size=0,
     bg_colour = { {0,0x00000,1},
             {0.5,0xFFFFFF,1},
             {1,0x00000,1}},

     fg_colour = { {0,0x000000,1},
         {0.5,0x0000FF,0.5},
         {1,0x000000,1}},

     },
      }

One more :

 graph_settings={
     {
     name="cpu",
     arg="",
     max=100,
     width=250,
     height=75,
     nb_values=100,
     autoscale=true,
     bg_bd_size=2,
     fg_bd_size=0,
     bg_colour = { {0,0x00000,0},
             {0.5,0xFFFFFF,1},
             {1,0x00000,0}},

     bg_bd_colour = { {0,0x00000,0},
             {0.5,0x000000,1},
             {1,0x00000,0}},

     fg_colour = { {0,0x000000,0},
         {0.5,0xFF0000,0.5},
         {1,0x000000,0}},

     bg_bd_orientation="ww",
     bg_orientation="ww",
     fg_orientation="ww",                
     },
      }

Again :

 graph_settings={
     {
     name="cpu",
     arg="",
     max=100,
     width=250,
     height=75,
     nb_values=100,
     autoscale=true,
     bg_bd_size=0,
     fg_bd_size=3,

     fg_bd_colour = { {0,0x000000,1},
                     {.75,0x00000,0},
                     },

     foreground=false,
     background=false
     },
      }

Now, we will draw more that one graph. Remember, the script can draw as many graph as you want! So, to draw overlaping graphs, we first draw the main graph with the background on it and then we add others graphs, like this, for a quad core cpu :


 graph_settings={
     {
     name="cpu",
     arg="cpu1",
     max=100,
     width=250,
     height=75,
     nb_values=100,
     fg_bd_size=1,
     bg_colour={{0,0xeeeeee,0.5}},
     fg_bd_colour = { {0,0xFF0000,1}, },
     foreground=false,
     },
     {
     name="cpu",
     arg="cpu2",
     max=100,
     width=250,
     height=75,
     nb_values=100,
     fg_bd_size=1,
     fg_bd_colour = { {0,0x00FF00,1}, },
     background=false,
     foreground=false,
     },
     {
     name="cpu",
     arg="cpu3",
     max=100,
     width=250,
     height=75,
     nb_values=100,
     fg_bd_size=1,
     fg_bd_colour = { {0,0x0000FF,1}, },
     background=false,
     foreground=false,
     },    
     {
     name="cpu",
     arg="cpu4",
     max=100,
     width=250,
     height=75,
     nb_values=100,
     fg_bd_size=1,
     fg_bd_colour = { {0,0xFFFF00,1}, },
     background=false,
     foreground=false,
     },    
      }

While running avidemux :

One of the nice feature in conky is transparancy :

That's all for today !

A new website about Conky is starting here. It's name is Conky PitStop and you will fine some Conky's addicts on it. I'm working on the french translation, if anyone is interested to join, drop me a note!
There are also translation ion german and spanish but more languages can be added.

Rings + Sectors Widget

2010-08-08T06:37:00.000-07:00

Another widget, after the bar cut into blocks, here is a circle cut into sectors.
This widget use a lot of parameters but only 3 parameters are mandatory, others are optional. If they are missing, default values are used.

Link to download on deviantArt : here

As usual, settings are made through tables :


rings_settings={
{table_setting for ring1},
{table_setting for ring2},
{table_setting for ring3},
}

The 3 mandatory parameters are name, arg and max.

In a conky, you write: ${cpu cpu1}, In the script, you will write :

rings_settings={
{
name="cpu",
arg="cpu1",
max=100,
--(max is set to 100 because maximum value of $cpu is 100% but you can set it to 50% if you want)
}
}

This simple table will draw this kind of circle in the center of the conky window (the radius will be a quarter of the conky's window width):

Defaults colours used in the script have to be used with a dark background.
You can set the colour of the conky window with

own_window_colour 000000
own_window_transparent no

Position and appearance can be changed with xc, yc, thickness and radius.

    {
name="cpu",
arg="cpu0",
max=100,
xc=100,
yc=100,
thickness=20,
radius=60
},

Number of sectors is set with sectors.

    {
name="time",
arg="%S",
max=60,
sectors=50,
radius=90
},

If you look at the first circle above, you will see a gap at the top of the ring, it's because the script draw only sectors, and the parameter gap_sectors is set to 1 by default. So the gap_sectors parameter set the space in pixels between two sectors :

    {
name="time",
arg="%S",
max=60,
sectors=5,
thickness=20,
radius=75,
gap_sectors=5
},

There is two way to close a sector, this is done with the cap parameter.
cap="p" for parallel (default value)
cap="r" for radial
See picture :

    {
name="time",
arg="%S",
max=60,
sectors=5,
thickness=30,
radius=75,
xc=500,
yc=85,
gap_sectors=15,
cap="r"
},

Another way to change the shape of a ring is to change the angles with start_angle and end_angle.
Values are in degrees and default values are :
start_angle=0
end_angle=360
end_angle has to be greater than start_angle but both can be negatives

    {
name="time",
arg="%S",
max=60,
sectors=6,
thickness=30,
radius=75,
xc=500,
yc=85,
start_angle=45,
end_angle=315
},

Of course, arcs can be inversed with inverse_arc parameter (default value is false).
If inverse_arc=true arc will be anticlockwise.

    {
name="time",
arg="%S",
max=60,
sectors=12,
thickness=30,
radius=75,
xc=500,
yc=85,
gap_sectors=10,
inverse_arc=true
},

Another parameter used to change the shape is the border_size parameter. Default is set to zero (i.e. "no border").

    {
name="time",
arg="%S",
max=60,
sectors=6,
thickness=30,
radius=75,
xc=500,
yc=85,
gap_sectors=10,
border_size=5
},

Next paramater is fill_sector, default value is false.
If set to true, each sector will be completely filled (like in the next picture)
Of course, this parameter is inoperate with sectors=1

    {
name="time",
arg="%S",
max=60,
sectors=12,
thickness=30,
radius=75,
xc=300,
yc=85,
gap_sectors=10,
fill_sector=true,
},

I forgot these two parameters background and foreground which can be useful sometimes. If set to false, background or foreground are not drawn.

    {
name="time",
arg="%S",
max=60,
sectors=6,
thickness=30,
radius=75,
xc=300,
yc=85,
gap_sectors=10,
border_size=2,
background=false
},

Well, I think I didn't forgot anything. I think I will add more parameters in the future...

Now, I will explain the colours parameters.
Each colours for background, foreground and border are set in theses parameters :
bg_colour1, fg_colour1 and bd_colour1
For example, for a single colour table:
bg_colour1={{0,0x0000ff,1}}
for a 2-colours table :

bg_colour1={
{0,0x0000ff,1},
{1,0xff00ff,1}
}

for a 3-colours table:

bg_colour1={
{0,0x0000ff,1},
{0.5,0xff00ff,1},
{1,0xff00ff,1}
}

and so on ...

Each "table colour" above contains one or more tables which defines the colours of a gradient :
table={P,C,A}
P = position inside the gradient (0 = internal radius, 1= external radius)
C = hexadecimal colour
A = alpha (opacity) of colour (0=invisible,1=opacity 100%)

With 5 colours for background and 3 colours for foreground :

    {
name="time",
arg="%S",
max=60,
sectors=10,
thickness=40,
radius=75,
xc=500,
yc=85,
gap_sectors=5,
bg_colour1={{0,0xFF6600,0.5},{0.25,0xFFFF00,1},{0.5,0xdddddd,1},{0.75,0X99CCFF,1},{1,0X0000FF,0.5}},
fg_colour1={{0,0xFF6600,0.5},{0.5,0xFF0000,1},{1,0x0000FF,0.5}},
},

Another example :

    {
name="time",
arg="%S",
max=60,
sectors=10,
thickness=40,
radius=75,
xc=500,
yc=85,
end_angle=270,
gap_sectors=5,
fg_colour1={{0,0xFFff00,0.8},{0.5,0xFF0000,0.8},{1,0xffff00,0.8}},
bd_colour1={{0,0xFF0000,0.8},{0.5,0xFFff00,0.8},{1,0xff0000,0.8}},
background=false,
border_size=2,
},

With the previous setup, each sectors have the same color.
But, for each colour (background, foreground and border), a gradient can be created with fg_colour2, bg_colour2 and bd_colour2 parameters.
This is the most interesting part of this script, if we have two colours

fg_colour1={{P1,colour1,alpha1}}
fg_colour2={{P2,0xcolour2,alpha2}}

For each sector a colour will be calculated with the "gradient" from P1 to P2, for each red, green and blue composantes from colour1 to colour2 and from alpha1 to alpha2.

Some examples in picture for a better understanding 8-)

Two tables with same colours and same alpha but with P1 and P2 differents : this has no effects because colours and alpha are the same.

Two differents colours with same alpha:

Two colours, same colours and differents alpha :

Two colours, differents colours and differents alpha :

Now, just start a new rings with 2 colours (a 2-colours table):

If I change the first parameter of the yellow colour which is the starting position of the gradient, we got that :

Adding a second 2-colours table bg_colour2 with the same blue

   bg_colour1={{0,0xffff00,1},{1,0xff0000,1}},
bg_colour2={{0,0x0000ff,1},{1,0x0000ff,1}},

and with a 2-colours table with two differents colours

   bg_colour1={{0,0xffff00,1},{1,0xff0000,1}},
bg_colour2={{0,0x0000ff,1},{1,0x00ffff,1}},

With 3 colours :

    bg_colour1={{0,0x0000ff,1},{0.5,0xffffff,1},{1,0xff0000,1}},
 bg_colour2={{0,0xff0000,1},{0.5,0xffffff,1},{1,0x0000ff,1}},

Tweaking with alpha parameters :

   bg_colour1={{0,0x000000,0},{0.5,0xffffff,1},{1,0x000000,0}},
bg_colour2={{0,0xff0000,1},{0.5,0xffffff,1},{1,0xff0000,1}},

Playing with alpha parameters and position parameters :

   bg_colour1={{0,0x000000,0},{0.5,0xffffff,1},{1,0x000000,0}},
bg_colour2={{0.49,0xff0000,1},{0.5,0xffffff,1},{0.51,0xff0000,1}},

or this one :

   bg_colour1={{0.49,0xffffff,0},{0.5,0xffffff,1},{0.51,0xffffff,0}},
bg_colour2={{0,0xffffff,0},{0.5,0xffffff,1},{1,0xffffff,0}},

As you can see, tweaking with colours, positions and alpha parameters are endless !

Two of my favorites rings :
This one to display CPU temperature and fan speed :

    {
name="exec",
arg="sensors | grep 'CPU Temp' | cut -c15-16",
max=60,
xc=100,
yc=100,
radius=90,
thickness=20,
start_angle=-120,
end_angle=120,
sectors=20,
bg_colour1={{0,0x999999,0},{0.5,0x999999,1}, {1,0x999999,0}},
fg_colour1={{0,0XffFF00,0},{0.5,0xffFF00,1}, {1,0xffFF00,0}},
fg_colour2={{0,0XFF0000,0},{0.5,0xFF0000,1}, {1,0xFF0000,0}},
},

{
name="exec",
arg="sensors | grep 'CPU Fan' | cut -c12-16",
max=1500,
xc=100,
yc=100,
radius=70,
thickness=20,
start_angle=-120,  
end_angle=120,
sectors=20,
bg_colour1={{0,0x999999,0},{0.5,0x999999,1}, {1,0x999999,0}},
fg_colour1={{0,0XFFFF00,0},{0.5,0xFFFF00,1}, {1,0xFFFF00,0}},
fg_colour2={{0,0XFF0000,0},{0.5,0xFF0000,1}, {1,0xFF0000,0}},
bd_colour1={{0,0X00FF00,1},{0.5,0x00FF00,1}, {1,0x00FF00,1}},
},

With a text widget :

And this one, made of two vertical rings of 180 degrees. Each ring has colours inverted.


{

name="fs_used_perc",
arg="/home",
max=50,
xc=350,
yc=150,
radius=90,
thickness=30,
start_angle=0,
end_angle=180,
inverse_arc=false,
border_size=0,
sectors=50,
gap_sectors=-1,
fill_sector=true,
bg_colour1={{0,0X111111,1},{0.5,0x111111,1}, {1,0x888888,1}},
bg_colour2={{0,0X888888,1},{0.5,0x888888,1}, {1,0x111111,1}},

fg_colour1={{0,0XFF4500,1},{0.5,0xFF4500,1}, {1,0xFFFFFF,1}},
fg_colour2={{0,0XFFFFFF,1},{0.5,0xFFFFFF,1}, {1,0xFF4500,1}},

bd_colour1={{0,0X00FF00,1},{0.5,0x00FF00,1}, {1,0x00FF00,1}},
},       

{

name="",
arg=conky_parse("${fs_used_perc /home}")-50,
max=50,
xc=350,
yc=150,
radius=90,
thickness=30,
start_angle=180,   
end_angle=360,
sectors=50,
gap_sectors=-1,
fill_sector=true,
bg_colour2={{0,0X111111,1},{0.5,0x111111,1}, {1,0x888888,1}},
bg_colour1={{0,0X999999,1},{0.5,0x888888,1}, {1,0x111111,1}},

fg_colour2={{0,0XFF4500,1},{0.5,0xFF4500,1}, {1,0xFFFFFF,1}},
fg_colour1={{0,0XFFFFFF,1},{0.5,0xFFFFFF,1}, {1,0xFF4500,1}},

bd_colour1={{0,0X00FF00,1},{0.5,0x00FF00,1}, {1,0x00FF00,1}},
},

Note the use of conky_parse in the second ring. This ring has to start at 50 but the script doesn't have the min parameter, so I have to "translate" the starting point at 50 and set the max to 100-50=50.
And I use gap_sectors=-1 to draw a plain circle.
In this picture, left ring is for a zero-value,

The same with the default value for gap_sectors, gap_sectors=1

That's all for the moment !

Edit :
The widget in real use :

A palette of differents rings :

Bargraph widget

2010-07-14T14:00:00.000-07:00

This is a big update of the bargraph widget I wrote some weeks ago.

The script can be downloaded on my deviantArt page : here

The settings are now made through a table bars_settings and I add some news effects.
The bars_settings contains as many bars as you want:


bars_settings={
{settings for bar 1 here},
{settings for bar 2 here},
{settings for bar 3 here},
...
}

In this script, 3 parameters are madatory : name, arg and max

In a conky, you write: ${cpu cpu1}

In the script, you will write

bars_settings={
{
name="cpu",
arg="cpu1",
max=100,
--(max is set to 100 because maximum value of $cpu is 100%)
}
}

This 3 parameters will draw a single bar with 10 blocks in the middle of the conky window :

Of course, you can place the bar with x and y parameters, the dot (x,y) is the red dot in this image :

Line caps can be changed with cap parameter, values can be :
b for line cap "butt" (the default value)
s for line Cap "square"
r for line Cap "round"

Code for the second bar in the above picture :

{
name="cpu",
arg="cpu1",
max=100,
cap="s",
x=150,
y=200,
},

Some transformation can be added :
angle is the angle of rotation of the bar (0 is a vertical bar)
skew_x to skew around x axis
skew_y to skew around y axis

{
name="cpu",
arg="cpu1",
max=100,
x=100,
y=220,
angle=90,
},
{
name="cpu",
arg="cpu1",
max=100,
x=150,
y=200,
skew_x=-10
},

{
name="cpu",
arg="cpu1",
max=100,
x=200,
y=200,
skew_y=15
},

The shape and number of blocks can be set with
blocks : number of blocks (default = 10)
width : width of a block (default = 20 pixels)
height : height of a block (default = 10 pixels)
space : space betwwen two blocks (default = 2 pixels)

As you can see, a block is filled or empty, except for the special case where blocks=1, the bar will have a single block and this block will be partially filled.
Also a numerical value can be passed to the script (instead of a conky variable), with name="" and arg=30, second table bellow :

{
name="cpu",
arg="cpu1",
max=100,
angle=90,
blocks=1,
height=200,
width=10,
space=10,
x=10,
y=300
},

{
name="",
arg=30,
max=100,
angle=90,
blocks=1,
height=200,
width=10,
space=10,
x=10,
y=320
},

Also a bar can be ... a circle (well I know this is not clever !) with the angle_bar parameter.
With angle_bar, the parameter width is not used :

{
name="",
arg="50",
max=100,
angle=90,
blocks=20,
height=10,
space=1,
angle_bar=45,
},

and a radius can be applied like this:

{
name="",
arg="50",
max=100,
angle=90,
blocks=20,
height=10,
space=1,
angle_bar=45,
radius=50,
x=20,
y=200,
},

The red dot is the (x,y) dot :

Of course, some transformation can also be used, like skew_x and skew_y

{
name="",
arg="50",
max=100,
angle=90,
blocks=10,
height=5,
space=5,
angle_bar=45,
radius=50,
x=20,
y=400,
skew_y=20,
skew_x=20,
},

Let put some colours !
In this script, colors are defined in tables with two elements, coulour and alpha (opacity) :

{colour,alpha}

As you've noticed, there is actually two colours, one for the background (when a block is OFF), and when a block is "ON", call it foreground.
The names of the parameters are bg_colour and fg_colour.

{
name="",
arg="50",
max=100,
angle=90,
bg_colour={0x3300FF,0.7},
fg_colour={0xFF0033,0.7},
x=200,y=200
},
{
name="",
arg="50",
max=100,
bg_colour={0x0033FF,0},
fg_colour={0x00FF00,0.7},
blocks=1,
height=100,
x=200,y=300
},

The verical block has no background because alpha is set to 0.

Theses colours are "flat" isn't it ? So I add colours to create "LED" effects, each blocks is now define with is colour and a second colour (if desired)
The names of the parameters are bg_led and fg_led.

Theses parameters have no effect unless they are used with the led_effect parameter. Possible values are :
r for rounded effect in the middle of the block
a for parallel effect
e for perpendicular effect

{
name="",
arg="50",
max=100,
bg_colour={0x00ff00,0},
fg_colour={0xFF0000,0},
led_effect="r",
bg_led={0x00ff00,1},
fg_led={0xFF0000,1},
x=200,y=200
},
{
name="",
arg="50",
max=100,
bg_colour={0x00ff00,0},
fg_colour={0xFF0000,0},
led_effect="e",
bg_led={0x00ff00,1},
fg_led={0xFF0000,1},
x=250,y=200
},
{
name="",
arg="50",
max=100,
bg_colour={0x00ff00,0},
fg_colour={0xFF0000,0},
led_effect="a",
bg_led={0x00ff00,1},
fg_led={0xFF0000,1},
x=300,y=200
},

I used same colors for fg and bg led and fg and bg colour but with differents alpha.
Here's the same with different colours and same alpha :

{
name="",
arg="50",
max=100,
bg_colour={0xffff00,1},
fg_colour={0xffff00,1},
led_effect="r",
bg_led={0xff0000,1},
fg_led={0x0000ff,1},
x=200,y=200
},
{
name="",
arg="50",
max=100,
bg_colour={0xffff00,1},
fg_colour={0xffff00,1},
led_effect="e",
bg_led={0x0000660,1},
fg_led={0x660066,1},
x=250,y=200
},
{
name="",
arg="50",
max=100,
bg_colour={0xffff00,1},
fg_colour={0xffff00,1},
led_effect="a",
bg_led ={0x0000ff,1},
fg_led ={0xff0000,1},
x=300,y=200
},>

A third colour : with a threshold alarm, the color of a block can change if value is over threshold.
Colour can be defined with alarm_colour

{
name="",
arg="80",
max=100,
alarm=70,
bg_colour={0x00ff00,0.5},
fg_colour={0x00ff00,1},
alarm_colour={0xff0000,1},
x=200,y=200,
blocks=10,
cap="r",
angle=90,
},

Led effect can also be applied on alarm color with alarm_led.
In this example, led effect is applied only on the alarm values:

{
name="",
arg="80",
max=100,
alarm=70,
bg_colour={0x00ff00,0.5},
fg_colour={0x00ff00,1},
alarm_colour={0xff0000,0},
alarm_led={0xff0000,1},
led_effect="r",
x=200,y=200,
blocks=10,
cap="r",
angle=90,
},

Another interesting parameter is smooth.
This one create a gradient from bottom (with fg_colour) to top (with alarm_colour) of the bar.
Default value is false and when used, led_effect is inoperate

{
name="",
arg=20,
max=100,
alarm=80,
bg_colour={0x00ff00,0.25},
fg_colour={0x00ff00,1},
alarm_colour={0xff0000,1},
smooth=true,
led_effect="r",
x=200,y=200,
blocks=10,
cap="r",
angle=90,
},
{
name="",
arg=50,
max=100,
alarm=80,
bg_colour={0x00ff00,0.25},
fg_colour={0x00ff00,1},
alarm_colour={0xff0000,1},
smooth=true,
led_effect="r",
x=200,y=250,
blocks=10,
cap="r",
angle=90,
},
{
name="",
arg=95,
max=100,
alarm=80,
bg_colour={0x00ff00,0.25},
fg_colour={0x00ff00,1},
alarm_colour={0xff0000,1},
smooth=true,
led_effect="r",
x=200,y=300,
blocks=10,
cap="r",
angle=90,
},

But if you think that 2 colours are not enough for a gradient, you can add some colours with mid_colour.
mid_colour is a table containing one or more sub-table of three values.
Example:

mid_colour= {{0.5,0xFF0000,1}}
mid_colour= {{0.25,0xFF0000,1},
{0.75,0x00FF00,1}}

First line will add some red with opacity of 1 at 50 % in the gradient
Second line will add some red at 25% and some green at 75%.

{
name="",
arg=20,
max=100,
alarm=80,
bg_colour={0x00ff00,0.25},
fg_colour={0x00ff00,1},
alarm_colour={0xff0000,1},
mid_colour={{0.25,0xffff00,1},
 {0.5,0x00ffff,1},
 {0.75,0xffff00,1}
 },
smooth=true,
x=20,y=200,
blocks=20,
height=20,width=20,
angle=90,
},
{
name="",
arg=50,
max=100,
alarm=80,
bg_colour={0x00ff00,0.25},
fg_colour={0x00ff00,1},
alarm_colour={0xff0000,1},
mid_colour={{0.25,0xffff00,1},
 {0.5,0x00ffff,1},
 {0.75,0xffff00,1}
 },
smooth=true,
x=20,y=222,
blocks=20,
height=20,width=20,
angle=90,
},
{
name="",
arg=95,
max=100,
alarm=80,
bg_colour={0x00ff00,0.25},
fg_colour={0x00ff00,1},
alarm_colour={0xff0000,1},
mid_colour={{0.25,0xffff00,1},
 {0.5,0x00ffff,1},
 {0.75,0xffff00,1}
 },
smooth=true,
x=20,y=244,
blocks=20,
height=20,width=20,
angle=90,
},
{
name="",
arg=77,
max=100,
alarm=80,
bg_colour={0x00ff00,0.25},
fg_colour={0x00ff00,1},
alarm_colour={0xff0000,1},
mid_colour={{0.25,0xffff00,1},
 {0.5,0x00ffff,1},
 {0.75,0xffff00,1}
 },
smooth=true,
x=10,y=256,
blocks=1,
height=438,width=20,
angle=90,
},

Finally, reflection can be added with (only for bars) :
reflection_alpha set the alpha at the beginning of the reflection (ends with alpha=0)
reflection_length set the length of the reflection, a percentage of the original bar (values 0 to 1)
reflection_scale set the scale of the reflection, a percentage of the original bar (values 0 to 1)

{
name="",
arg=50,
max=100,
alarm=80,
bg_colour={0xff00ff,0.5},
fg_colour={0x00ff00,1},
alarm_colour={0xff0000,1},
mid_colour={{0.25,0xffff00,1},
 {0.5,0x00ffff,1},
 {0.75,0xffff00,1}
 },
x=120,y=300,
blocks=10,
height=20,width=20,
reflection_alpha=0.5,
smooth=true,
},
{
name="",
arg=50,
max=100,
alarm=80,
bg_colour={0xff00ff,0.5},
fg_colour={0x00ff00,1},
alarm_colour={0xff0000,1},
mid_colour={{0.25,0xffff00,1},
 {0.5,0x00ffff,1},
 {0.75,0xffff00,1}
 },
x=150,y=300,
blocks=10,
height=20,width=20,
reflection_alpha=0.5,
reflection_length=0.5,
smooth=true
},
{
name="",
arg=020,
max=100,
alarm=80,
bg_colour={0xff00ff,0.5},
fg_colour={0x00ff00,1},
alarm_colour={0xff0000,1},
mid_colour={{0.25,0xffff00,1},
 {0.5,0x00ffff,1},
 {0.75,0xffff00,1}
 },
x=180,y=300,
blocks=10,
height=20,width=20,
reflection_alpha=0.5,
reflection_scale=0.5,
smooth=true
},

Last parameter is the position of the bar's reflection (reflection), it has four parameters b,t,l,r for bottom, top, left and right but theses parameters are always relative to a verical bar.
The next 2 bars have reflection="r" but the second has angle=90

{
name="",
arg=50,
max=100,
alarm=80,
bg_colour={0xff00ff,0.5},
fg_colour={0x00ff00,1},
alarm_colour={0xff0000,1},
x=150,y=300,
blocks=10,
height=20,width=20,
reflection_alpha=0.8,
smooth=true,
reflection="r",
},

{
name="",
arg=50,
max=100,
alarm=80,
bg_colour={0xff00ff,0.5},
fg_colour={0x00ff00,1},
alarm_colour={0xff0000,1},
x=220,y=300,
blocks=10,
height=20,width=20,
reflection_alpha=0.8,
smooth=true,
reflection="r",
angle=90
},

And now, some amazing setups :

{
name="",
arg=80,
max=100,
bg_colour={0x0000ff,0.5},
fg_colour={0x00ff00,1},
mid_colour={{0.25,0xFFFF00,1},{0.5,0xFFFFFF,1},{0.75,0xFF0000,1}},
x=25,y=300,
blocks=50,
space=1,
height=10,width=10,
angle=90,
smooth = true,
},

{
name="",
arg=80,
max=100,
bg_colour={0x0000ff,0.5},
fg_colour={0x00ff00,1},
mid_colour={{0.25,0xFFFF00,1},{0.5,0xFFFFFF,1},{0.75,0xFF0000,1}},
x=25,y=300,
blocks=50,
space=1,
height=10,width=0,
angle=90,
smooth = true,
cap="r",
},

{
name="",
arg=70,
max=100,
bg_colour={0xff00ff,0},
fg_colour={0x00ff00,0},
bg_led={0xff00ff,0.5},
fg_led={0x00ff00,1},
led_effect="r",
x=25,y=300,
blocks=10,
space=5,
height=50,width=40,
angle=90,
cap="r",
},

{
name="",
arg=70,
max=100,
bg_colour={0x00ffff,0},
fg_colour={0x00ffff,0},
bg_led={0xff0000,0.5},
fg_led={0xffff00,1},
led_effect="r",
x=50,y=300,
blocks=10,
space=1,
height=50,width=40,
angle=90,
cap="r",
},

{
name="",
arg=70,
max=100,
alarm=50,
bg_colour={0x00ff33,0},
fg_colour={0xffff00,0},
alarm_colour={0xFF0000,0},
bg_led={0x00ff33,0.5},
fg_led={0xffff00,1},
alarm_led={0xFF0000,1},
blocks=10,
space=1,
height=30,width=40,
angle=90,
cap="b",
angle_bar=45,
led_effect="a"
},

{
name="",
arg=70,
max=100,
alarm=50,
bg_colour={0x00ff33,0},
fg_colour={0xffff00,0},
alarm_colour={0xFF0000,0},
bg_led={0x00ff33,0.5},
fg_led={0xffff00,1},
alarm_led={0xFF0000,1},
blocks=10,
height=30,width=40,
angle=90-45/2,
cap="r",
angle_bar=45,
led_effect="a",
radius=30,
skew_y=25
}

{
name="",
arg=70,
max=100,
bg_colour={0x00ff33,0},
fg_colour={0xffff00,0},
bg_led={0x00ff33,0.5},
fg_led={0xffff00,1},
blocks=20,
y=300,
height=10,width=40,
angle=90,
led_effect="r",
reflection_alpha=1,
reflection="r"
},

{
name="",
arg=70,
max=100,
bg_colour={0x00ff33,0},
fg_colour={0xffff00,0},
bg_led={0x00ff33,0.5},
fg_led={0xffff00,1},
led_effect="r",
blocks=20,
y=300,
height=10,width=40,
angle=90,
led_effect="e",
reflection_alpha=1,
reflection="r",
space=0,
skew_x=15,
},

Enjoy ;-)

PS : a big setup with the text widget (too many effects in this one, I agree):

Text widget, Part 2

2010-06-26T02:09:00.000-07:00

I finnaly add some effects to the text widget.
The reflection and the "skew".

All these effects are based upon the cairo.Matrix transform

Let start with a simple text displaying hour with a 3-colours and linear gradient:


   text_settings={
  {
  text=conky_parse("${time %H:%M:%S}"),
  font_name="Rasheeq",
  x=50,  
  y=50,
  font_size=50,
  colour={{0,0xFF0000,1},{0.5,0xFFFF00,1},{1,0x00FF00,1}},
  orientation="nn",
  },  
   }

The output :

Now, I add some reflection :

  {
  text=conky_parse("${time %H:%M:%S}"),
  font_name="Rasheeq",
  x=50,  
  y=50,
  font_size=50,
  colour={{0,0xFF0000,1},{0.5,0xFFFF00,1},{1,0x00FF00,1}},
  orientation="nn",
  reflection_alpha=1,
  },

The reflection start with an opacity of 1 (reflection_alpha=1) and ends with a opacity of 0.

But the reflection can start with an opacity less than 1 (reflection_alpha=0.5 here) :


  {
  text=conky_parse("${time %H:%M:%S}"),
  font_name="Rasheeq",
  x=50,  
  y=50,
  font_size=50,
  colour={{0,0xFF0000,1},{0.5,0xFFFF00,1},{1,0x00FF00,1}},
  orientation="nn",
  reflection_alpha=0.5,
  },

With the abvoe parameters, reflection ends at the end of the text size, but it can end before with reflection_length=0.5, it means 50% of the full height of the text


  {
  text=conky_parse("${time %H:%M:%S}"),
  font_name="Rasheeq",
  x=50,  
  y=50,
  font_size=50,
  colour={{0,0xFF0000,1},{0.5,0xFFFF00,1},{1,0x00FF00,1}},
  orientation="nn",
  reflection_alpha=0.5,
  reflection_length=0.5,
  },

The reflection length can be scaled, a scale of 1 (default value) means the same size of the text, a scale bigger than one means that the reflection is higher of the text:


  {
  text=conky_parse("${time %H:%M:%S}"),
  font_name="Rasheeq",
  x=50,  
  y=50,
  font_size=50,
  colour={{0,0xFF0000,1},{0.5,0xFFFF00,1},{1,0x00FF00,1}},
  orientation="nn",
  reflection_alpha=0.5,
  reflection_scale=2,
  },

The skew parameter around x axis (I'm not sure of the units for that !):

  {
  text=conky_parse("${time %H:%M:%S}"),
  font_name="Rasheeq",
  x=50,  
  y=50,
  font_size=50,
  colour={{0,0xFF0000,1},{0.5,0xFFFF00,1},{1,0x00FF00,1}},
  orientation="nn",
  skew_x=20,
  },

The skew parameter around y axis

  {
  text=conky_parse("${time %H:%M:%S}"),
  font_name="Rasheeq",
  x=50,  
  y=50,
  font_size=50,
  colour={{0,0xFF0000,1},{0.5,0xFFFF00,1},{1,0x00FF00,1}},
  orientation="nn",
  skew_y=20,
  },

We can combine both

  {
  text=conky_parse("${time %H:%M:%S}"),
  font_name="Rasheeq",
  x=50,  
  y=50,
  font_size=50,
  colour={{0,0xFF0000,1},{0.5,0xFFFF00,1},{1,0x00FF00,1}},
  orientation="nn",
  skew_y=-20,
  skew_x=-50,
  },

Unfortunately, we can't have a real perspective with cairo .

Finally, we can combine reflection and skew:

  {
  text=conky_parse("${time %H:%M:%S}"),
  font_name="Rasheeq",
  x=50,  
  y=900,
  font_size=50,
  colour={{0,0xFF0000,1},{0.5,0xFFFF00,1},{1,0x00FF00,1}},
  orientation="nn",
  skew_y=-20,
  skew_x=-10,
  reflection_alpha=0.5,
  },

Links to the updated script :
In English on ubuntu forums : here
French link (copy/paste) : here

And, an example of real life use combined with the piechart widget:

Text Widget

2010-06-14T13:16:00.000-07:00

Hello !

Here is a new widget, it only displays text but with some parameters set in the text_settings table, effects can be nice as you will see in pictures below.

Links to the script on deviantArt : here

A little reminder : tables in Lua

In Lua, tables (arrays) are written like that :

table={a,b,c} --this one has 3 elements

elements can be named, like this :

table={num1=a,number2=b,element3=c}

But an element in a table can be a table, like this :

table={num1=a,table2={A,B,C},element3=c} --second element is a table of 3 elements

or like this :

table={text="my text",
colour={
    {0.00,0xFF0000,0.5},
    {0.50,0x00FF00,1},
    {1.00,0x0000FF,0.5},
    },
}

Colours tables

The last table above is an example of colour table defined in this script to obtain a gradient effect. Table colour contains 1 or more tables which defines colors of the gradient : {P,C,A} :
P = position of gradient (0 = beginning of text, 1= end of text)
C = hexadecimal colour
A = alpha (opacity) of color (0=invisible,1=opacity 100%)
Examples :
for a plain color :

{{1,0x00FF00,0.5}}

for a gradient with two colours

{{0,0x00FF00,0.5},{1,0x000033,1}}

{{0.5,0x00FF00,1},{1,0x000033,1}} -with this one, gradient will start in the middle (P=0.5) of the text

for a gradient with three colours

{{0,0x00FF00,0.5},{0.5,0x000033,1},{1,0x440033,1}}

and so on ...

It sounds complicated but with a little practice there is no problem ! If you understand nothing, don't panic, examples with pictures are coming soon !

NB : Tables Tutorial in Lua wiki

Radial gradient
For this script, I also use a table to define a radial gradient, if needed:

radial={0,0,0,0,300,370}

Radial gradients are defined with two circles (start circle and stop circle) and the radial table contains these elements:

x center of circle 1,
y center of circle 1,
radius of circle 1,
x center of circle 2,
y center of circle 2,
radius of circle 2,

Here again, examples below will help you !

Orientation for linear gradient
In case of linear gradient, "orientation" defines the starting point of the gradient, default is "ww"
There are 8 available starting points : "nw","nn","ne","ee","se","ss","sw","ww"
(n for north, w for west ...)
Theses 8 points are the 4 corners + the 4 middles of text's outline
so a gradient "nn" will go from "nn" to "ss" (top to bottom, parallele to text)
a gradient "nw" will go from "nw" to "se" (left-top corner to right-bottom corner)

Setting the widget
Let start with the funny things !
the text_settings table needs at least one table like this :

text_settings={{
text="my text",     --text to display
x=20,                --x coordinate of first letter
y=20,                --y coordinate of first letter
},
}

To display more than one text, add a table in the text_settings table :

text_settings={
{--display a text on coordinates 20,20
text="unformatted text",
x=20,
y=20,
},

{--display a text on coordinates 20,40, with selected font and size, true and bold
text="bold and italic text",
x=20,
y=40,
font_name="Verdana",
font_size=18,
italic=true,
bold=true,
},
}

The output (nothing extraorinary) :

Adding some colors :

        {--display a text on coordinates 20,20, in plain colour
text="Plain Color",
x=20,
y=50,
font_name="Clarendon",
font_size=50,
colour={{0,0xFF0000,1}}
},

A plain color with with a little gradient on opacity (see the two table in colour table):

        {
text="Opacity Gradient",
x=20,
y=100,
font_name="Clarendon",
font_size=50,
colour={{0,0xFF0000,1},
{1,0xFF0000,0.1}}
},

A 2-colours gradient effect :

         {
text="2 colors Gradients",
x=20,
y=150,
font_name="Clarendon",
font_size=50,
colour={{0,0xFF0000,1},
{1,0xFFFF00,1}}
},

A 3-colours gradient effect :

         {
text="3 colors Gradients",
x=20,
y=200,
font_name="Clarendon",
font_size=50,
colour={{0,0xFF0000,1},
{0.5,0xFFFF00,1},
{1,0x0000FF,1}},
},

Mix-up of 5 colors and opacity gradients

         {
text="5 colors Gradient and opacity",
x=20,
y=250,
font_name="Clarendon",
font_size=50,
colour={
{0.00,    0xFF0000,0},
{0.25,    0xFFFF00,1},
{0.5,    0xFFFFFF,1},
{0.75,    0xFFFF00,1},
{1.0,    0xFF0000,0}},
},

A 3-colours vertical gradient (orientation="nn") :

         {
text="3 colors vertical Gradient",
x=20,
y=300,
font_name="Clarendon",
font_size=50,
colour={
{0.00,    0xFF0000,0},
{0.5,    0xFFFFFF,1},
{1.0,    0xFF0000,0}},
orientation="nn"
},

In the examples above, you can see the x and y parameters which defines the starting point of the text, but text can be aligned (vertical or horizontal) with the parameters h_align and v_align.
This example with radial gradient use it :

         {
text="radial gradient",
x=400,
y=350,
font_name="Clarendon",
font_size="48",
colour={
        {0.8,0xF0FFF0,1},
        {1.00,0xF0F0FF,0.1},
        },
   h_align="c",
   radial={0,300,0,0,300,370}
},

or this one :

         {
text="another radial gradient",
x=400,
y=400,
font_name="Clarendon",
font_size="48",
colour={
        {0.98,    0xFFFF00,1},
        {0.99,    0xFF0000,1},
        {1.00,    0xFF00FF,1},
        },
   h_align="c",
   v_align="m",
radial={0,-1000,0,0,-1000,1020}

},

Apply some angles on text:

        {--display a text with a 30° angle
text="text at 30 degrees",
x=50,
y=600,
colour={{0,0xFFFF00,1},{0.5,0x0000FF,1},{1,0xFFFF00,1}},
angle=-30,
font_name="ubuntu-title",
font_size=32,
},
{--display a vertical text
text="vertical text",
x=30,
y=450,
colour={{0         ,0xFF0000,1},
        {0.25    ,0xFFFF00,1},
        {0.50    ,0x00FF00,1},
        {0.75    ,0x00FFFF,1},
        {1         ,0x0000FF,1}
        },
angle=-90,
font_name="ubuntu-title",
font_size=32,
orientation="nw",
h_align="r"
},

And how to display conky variables ? Simply use the conky_parse() function like this :

         {--display a text with some conly variables
--use two dots to concatenate texts
text="text with some conky, cpu=" .. conky_parse("${cpu}") .. " %",
x=20,
y=660,
colour={{0,0xFFFF00,1},{0.5,0xFF0000,1},{1,0xFFFF00,1}},
font_name="Purisa",
bold=true,
font_size=38
},

Well, I think I show all the available options in this script.
But now we can combine some of them to have nices effects with low-cpu usage:
Text with shadow : draw twice the text but with a little offset on x and y :

        {
text=conky_parse('text with shadow #1'),
x=300,
y=500,
font_name="Clarendon",
font_size=50,
colour={{1,0xFF0000,0.75},
        },
   orientation="ww",
},

  {
text=conky_parse('text with shadow #1'),
x=298,
y=498,
font_name="Clarendon",
font_size=50,
colour={{0,0xFFFF00,1}},
    orientation="ww",
},

Blur effect : display text 3 times but with opacity<0.5>

Focus effect : repeat text 3 times with x and y offsets and at the focus point set opacity for 1 of the 3 texts to 1.0 and to 0.0 for the two others texts.

--focus effect
 {--afficher un texte aux coordonées 20,20
text='focus effect #1',
x=300,
y=600,
font_name="Clarendon",
font_size=50,
colour={{0.00,0x00FFFF,0},
        {0.50,0x00FFFF,1},
        {1.00,0x00FFFF,0},
        },
   orientation="ww",
},
 {
text='focus effect #1',
x=300,
y=599,
font_name="Clarendon",
font_size=50,
colour={{0.00,0x00FFFF,0.5},
        {0.50,0x00FFFF,0},
        {1.00,0x00FFFF,0.5},
        },
   orientation="ww",
},
 {
text='focus effect #1',
x=300,
y=601,
font_name="Clarendon",
font_size=50,
colour={{0.00,0x00FFFF,0.5},
        {0.50,0x00FFFF,0},
        {1.00,0x00FFFF,0.5},
        },
   orientation="ww",
},

Another one :



--focus effect 2
 {
text='focus effect #2',
x=300,
y=720,
font_name="Clarendon",
font_size=50,
colour={{0.00,0x00FFFF,1},
        {1,0x00FFFF,0},
        },
},
 {
text='focus effect #2',
x=299,
y=719,
font_name="Clarendon",
font_size=50,
colour={{0.00,0x00FFFF,0},
        {1,0x00FFFF,0.25},
        },
},
 {
text='focus effect #2',
x=301,
y=721,
font_name="Clarendon",
font_size=50,
colour={{0.00,0x00FFFF,0},
        {1,0x00FFFF,0.25},       
        },
},
}

In a real life desktop, with vertical text, blur and focus effects !(wallpaper here ), click to enlarge

De Text widget

Happy conkying ;-)

PS : While writing this note, I think about new effects like reflection or perspective, maybe I will add them soon ... it's done and it's here

Calendar box

2010-05-14T15:06:00.000-07:00

Hello !

Here is a new calendar fully customizable, nothing special in it, just nices effects created with the couple Lua/Cairo. Also, I choose a "settings table" to pass parameters to the script, so if a parameter is missing, a default parameter is used. Only 4 parameters are mandatory.

You can download the script from Ubuntu forums here and you need conky 1.8.0 or higher.

Set up the conkyrc
You need theses two lines in your conkyrc :

own_window_transparent yes
own_window_argb_visual yes

If you want the calendar in your language system, you have to add $time in TEXT section

$time

and if you want to hide this time, use, for example :

use_xft yes
xftalpha 0

Set up the lua script
At the beggining of the script, there is a table called cal_settings which contains the parameters for one or more calendars :


--for one calendar
cal_settings={
 { x=12,
  y=12,
  font="Japan",
  font_size=14
 },
}


--for two calendars
cal_settings={
 { x=12,
  y=12,
  font="Japan",
  font_size=14
 },
 { x=120,
  y=120,
  font="Japan",
  font_size=16
 },
}

So, the 4 mandatory parameters are : x, y, font, font_size. With the first example, the output is classical :

The red numbers are for bank holidays (May is a good month for that in France !) and blue number is for today.
The bank holidays and reminders stuffs are stored in a text file called at the beginnning of the script :

calendar_file= "/home/wlourf/scripts/calendar-box/calendar.txt"

the format of this text file is

#format of in this text file
#MMDD;N;TEXT
#MMDD = month day
#N    = 0 or 1 (1 to display colours of bank holidays)
#TEXT = Text to display

0501;1;May Day
0508;1;Armistice 1945
0513;1;Ascension
0524;1;Pentecost Monday
0612;0;Mom's Birthday

Now, the others parameters that can be put in the cal_settings table...
With this ones, numbers are displayed with two digits and numbers of others months are hidden :


 x=36,
 y=12,
 font="Verdana",
 font_size=20,
 two_digits=true,
 display_others_days=false,

Theses ones format the month and the days with two letters

 month_format="%B %Y",
 days_number=2

For time formatting , see http://www.lua.org/pil/22.1.html, time can be displayed with "%B - %H:%M"

Month can be put around the calendar with l/r/b or t,
Days can be put on top or on bottom of the calendar with b or t
To display a month different from current month, use month_offset

 month_position="l",
 month_offset=-1,
 days_position="b",

numbers can be right/left or center aligned

 days_position="t",
 two_digits=false,
 alignment="r",

Now, just put some colors, they are set in tables inside the cal_settings table. Formats are:
-for boxes:

 {colour1, colour2, alpha1,alpha2,border1,border2,alpha border1,alpha border2}

-for texts:

 {colour1, colour2, alpha1,alpha2}

Colours use gradients, it's why there are two colors to set for each format.
Theses parameters set the color of boxes and texts

 alignment="c",
 border=0,
 colBox = {0xFF0000,0x0000FF,0,1,0x0000FF,0x00FFFF,0.5,0.5},
 colBoxText  ={0x000000,0x0000FF,1,0},

Others colours for text are for month, days (letters), today (number), bank holiday (number) , other month number, like this:


 month_offset=0,
 month_position="b",
 colBox = {0xFF0000,0x0000FF,0,0.5,0x0000FF,0x00FFFF,0.5,0.5}, --box color
 colBoxText  ={0x000000,0x000000,1,0.5},    --color of numbers
 colBoxTextTD = {0x0000FF,0x0000FF,1,1},    --color of today
 colBoxTextBH = {0x00FF00,0x00FF00,1,1},    --color of bank holiday
 display_others_days=true,
 colBoxTextOM = {0xCCCCCC,0x0000FF,1,0},    --color of numbers for other month
 colDaysText  ={0xFF0000,0x000000,1,1},     --color of days (Monday ...)
 colMonthText  = {0xFF0000,0x000000,0,1},   --color of month

On the above image, the color for today's box was not defined, so the script use the inversed colors of a standard box. The others parameters for the boxes are:

 border=0.5,
 colBox = {0xFF0000,0x0000FF,0,0,0x0000FF,0x00FFFF,0.5,0.5}, --color of standard box, alpha = 0 here
 colDays = {0xFF00FF,0x0000FF,1,1,0x0000FF,0x00FF00,1,1},    --color of boxes "Days" (Monday ...)
 colMonth = {0x00FF00,0x0000FF,1,1,0x0000FF,0x00FF00,1,1},   --color of box "Month"
 colBoxTD  = {0xFF0000,0xFF0000,0,1,0xFF00FF,0x00FF00,1,1},  --color of box "Today"
 colBoxBH  = {0xFF0000,0xFF0000,1,1,0xFF00FF,0x00FF00,1,1},  --color of box "Bank holiday"

Parameters to change the shape of the boxes :

 hpadding=5,  --horizontal space beetween border and text (default=2 pixels)
 vpadding=5,  --vertical space beetween border and text (default=2 pixels)
 border=0.5,  --border size (default=0 pixels)
 gap=5,   --space betwwen 2 boxes (default=2 pixels)
 radius=5,  --radius of corners (default=0 pixels)

Parameters to change the gradient effect :

 orientation ="ww", -- possibles values = nn, ne,ee,se,ss,sw,ww,nw

To have a radial gradient :

 orientation ="nw", -- possibles values = nn, ne,ee,se,ss,sw,ww,nw
 gradient=0.25,  --  default linear(=0) or radial gradient percentage (0-1) of box side

I also add a reminder box : this one displays text info from calendar.txt file, parameters are :

 display_info_box=true, --display info box (default=false)
 colInfo = {0xFF0000,0x0000FF,0,1,0x0000FF,0x00FFFF,0.5,0.5}, --color info Box
 colInfoText = {0x000000,0xFFFFFF,1,1},  --color text of info box
 info_position="b",  --position of info box, possibles values are t/b/l/r, (default=b)
 display_empty_info_box=true, --if no info to display , display or not info the box

The info box can also display first line of a text file generated by a script. For example, this line in the conkyrc get the Saint of the day in file /tmp/info.txt - thanks chepioq ;-):

${execi 3600 wget http://fetedujour.fr/api/text  -O - -o /dev/null | awk '{print $6}' | sed 's/.$//' > /tmp/info.txt}

And this parameter in the lua script :

 file_info="/tmp/info.txt",

will read info in /tmp/info.txt instead of calendar.txt

That's all for this script !

Some updates
Openbox's shortcuts script :
Keyboard shortcuts without commands are no more displayed.
Long command lines are shortened in the dispay to fit the column width.
In keyboard section, when a command string hold the full path to the executable, it keeps only the name of the executable itself.
It's here

Pie Chart widget:
The parameters are now set in a table and I add the type_arc parameter, it can be set to "l" for linear or "r" for radial.
"r" gives the same result as before :

"l" gives that (a ring) :

It's here

Radio Box Widget

2010-04-27T13:10:00.000-07:00

I like to listen to radio when I am working on my computer. Usually, I listen to FIP radio, the track information played by this radio are very cools and smooths (example for one day : here) but of course I don't use their ugly player or their information popup ...

Guess what, I want to display the tracks I'm listening on my desktop in a conky ;-)
But as there are more radios than "FIP radio" and because the script was not difficult to write, the conky came more "universal" (sorry, a big word for a little thing).
You need conky 1.8.0 because the script use cairo_text_extents_t structure for text alignment.

The script can be downloaded from ubuntu forums : here.

First, I said I don't want a ugly player, so I use vlc with the http interface, like this :

vlc --intf=http http://www.tv-radio.com/station/fip_mp3/fip_mp3-128k.m3u

there are others interfaces or others methods to hide a player but I like vlc!

I can control volume with my keyboard or with my browser at this address :

http://localhost:8080/

The conky itself doesn't get the track information. This is done by a bash script, (I made one for FIP here but for others radios, you have to work a little bit ...) which write the information in a text file.
So, the conky needs only this text file in input with at least one of the lines bellow (order doesn't matter):


radio:__FIP radio__
artist:Sonny Rollins
title:Come, Gone
album:Way out West
label:Contemporary
year:1957
cover:/tmp/radio-cover

I will call this file : /tmp/radio.txt

In the conkyrc, as usual, call the Lua script :


lua_load ~/scripts/radio-box.lua
lua_draw_hook_post main_radio_box /tmp/radio.txt
TEXT
${execi 15 ~/scripts/generate-track-information.sh}

You can see that the main_radio_box function needs one parameter : the track information file generated by the generate-track-information.sh.
In fact, the function can have 17 parameters but only the first one is mandatory.

If you run the script with only the first parameter, you get that :

useless, isn't it ?

Now, let's add some parameters on the main function :
The x, y coordinates of the top-left corner, to move the box :

lua_draw_hook_post main_radio_box /tmp/radio.txt 100 25

The font and the font size, to change the display :

lua_draw_hook_post main_radio_box /tmp/radio.txt 10 10 Purisa 15

The informations to display, in the form ATBLYR where :

A=Artist
T=Track
B=Album
L=Label
Y=Year
R=Radio

Example :

lua_draw_hook_post main_radio_box /tmp/radio.txt 10 10 Japan 15 RATBLY

Here you can see that the box auto-fit the text, both in height and width.

The cover.
If your script get the cover, you can display it, just set the path in the file /tmp/radio.txt. To display, the cover use 1, other caracter to not display.

lua_draw_hook_post main_radio_box /tmp/radio.txt 10 10 Japan 15 RATBLY 1

If there is less text to dispaly, the cover will resize to the height of the text frame, like this

lua_draw_hook_post main_radio_box /tmp/radio.txt 10 10 Japan 15 ATB 1

The border size :
(In a reel conky, you should write all the parameters on one single line)

lua_draw_hook_post main_radio_box /tmp/radio.txt 10 10 Japan 15 ATBY
         1 7

The radius of the corners:

lua_draw_hook_post main_radio_box /tmp/radio.txt 10 10 Japan 15 ATBY
         1 3 15

lua_draw_hook_post main_radio_box /tmp/radio.txt 10 10 Japan 15 ATB
         1 0 0

Bye, Sonny...

The gap between the two frames:

lua_draw_hook_post main_radio_box /tmp/radio.txt 10 10 Japan 15 ATB
         1 3 3 60

The light effect source, possibles values are :

nw : Nord-West (default)
nn : North-North
ne : North-East
ee : East-East
se : South-East
ss : South-South
sw : South-West
ww : West-West

Example for North-North :

lua_draw_hook_post main_radio_box /tmp/radio.txt 10 10 Japan 15 ATB
         1 3 3 10 nn

The colors of the frame (it's a linear gradient but if the two values are the same, there is no more gradient):

lua_draw_hook_post main_radio_box /tmp/radio.txt 10 10 Japan 15 ATB
         1 3 3 10 ee 
         FF0000  FFFF00 1 1

The colors of the text :

lua_draw_hook_post main_radio_box /tmp/radio.txt 10 10 Japan 15
         ATB 1 3 3 10 ee 
         F00F00 FCFFC0 1 1 00FF00 00FFFF 1 1

The colors of the border (the same of the main frame if they are not defined, but inversed)

lua_draw_hook_post main_radio_box /tmp/radio.txt 10 10 Japan 15 ATB
         1 5 5 10 sw 
         CCCCCC 000000 1 1 FFFF00 FFFFFF 1 1 000000 DDDDDD 1 1

More classical :

lua_draw_hook_post main_radio_box /tmp/radio.txt 10 10 Japan 15 ATB
         1 2 0 10 ww 
         CCCCCC CCCCCC 1 1 000000 000000 1 1 000000 000000 1 1

While writing this note I add parameters for transparancy:

lua_draw_hook_post main_radio_box /tmp/radio.txt 10 10 Japan 15 ATBLY
         1 5 5 10 nw 
         000000 FFFFFF 0.3 0.3 FF0000 FF0000 0.5 0.5 000000 000000 1 0.2

I think I will add some effects on the cover if I can in the future.

Pie Chart & Ring Widget

2010-04-09T05:34:00.000-07:00

Edit: v1.1 15/05/2010, widget can now draw a ring, see at bottom.

Here is another widget for Conky... it's a pie-chart fully customizable. For example, for the circle in the above picture : it's a file system (yes it is!), each sector is proportional to the size of a disk, and two colors are used to draw a sector (one for used space, and one for free space).

It can be downloaded from Ubuntu forums here.

You need Conky 1.8.0 to use it.
To call it in a Lua script, you have to set parameters in a table:

pie_settings= { table1, table2 ...}

Each table has is own parameters, only one is mandatory, it's tableV, a table containing the values to display.

Example of tableV, of course, in real life, table is created by the script :

 -- table of labels and values 
    {{label1,conky_variable,conky_argument,convert to Go-Mo-Ko units (true/false) or unit}, ...}
 -- all the values are at maximum values in this example
 -- last parameter set to true means that the script 
    will convert the values in Go, Mo ...
 local k=1024*1024*1024
 tableV={{"/","",  k*50, k*50,true},
  {"/home","", k*500, k*500,true},
  {"/data","", k*1000, k*1000,true},
  {"stuff","", k*10, k*10,true}
  },

The Lua file contains a script which use the output of df command, because this widget was made with the disks spaces in mind, but it can be use with any other value, like this (but it's not the purpose of the script, so we won't use it):

 tableV={{"cpu0","cpu", "cpu0",100,"%"},
  {"cpu1","cpu", "cpu1",100,"%"},
  {"fan","", "${exec sensors | grep 'CPU Fan' | cut -c13-16}", 2000," rpm"},
  {"sys","", "${exec sensors | grep 'Sys Temp' | cut -c15-17}", 100,"°C"}   
 },

Examples of tablebg and tablefg (background and foreground colors):

 tablebg={{0xFFFFFF,0.5},
  {0xFFFFFF,0.5},
  {0xFFFFFF,0.5},
  {0xFFFFFF,0.5}
  },
 tablefg={{0xFF0000,1},
  {0x00FF00,1},
  {0x0000FF,1},
  {0xFFFF00,1}
  },

With the above parameters and these ones :

 xc=conky_window.width/2,
 yc=conky_window.height/2,
 int_radius=0,
 radius=100,
 first_angle=0,
 last_angle=360,
 proportional=true,
 gradient_effect=false,
 show_text=true,
 line_lgth=30,
 line_space=20,
 line_width=1,
 extend_line=true,
 txt_font="FreeSans",
 font_size=12,
 font_color=nil,
 font_alpha=1,
 txt_offset=1,
 txt_format="&m",
 nb_decimals=0,

we obtain this simple kind of chart

If the number of values in a colors table is less than the number of sectors, like that :

 tablefg={{0xFF0000,1},
  {0xFFFF00,1}},

colors restart at the end of the table :

Now, if we change the second parameter of tableV, the value for each sector, we change the way the graph is displayed.

 local k=1024*1024*1024
 tableV={{"/",  .25*k*50, k*50,true},
  {"/home", .50*k*500, k*500,true},
  {"/data", .75*k*1000, k*1000,true},
  {"stuff", .90*k*10, k*10,true}
  },

This is what I wanted to display on my desktop : the amount of used space on my external or internal drives and the proportion of each drive in the full file system. Like the big arc on first picture, I have to clean some disks ...

Now, have a look to more interestings parameters ;-)
With int_radius=50, (internal radius)

For the angles, (O° is North and angles go clockwise),

 first_angle=-45
 last_angle=180

Back to full circle and proportional parameter:

 first_angle=0,
 last_angle=360,
 proportional=false,

Back to proportional=true and adding some gradient and hiding text

 proportional=true,
 gradient_effect=true,
 show_text=false,

By the way, here is an interesting script to toggle the text (or others flags) when the conky is running.
In the Lua script :

 local file = io.open("/tmp/flag-conky","r")
 io.close()
 show_text=(file == nil)

And a bash script associated with a keyboard shortcut:

 #!/bin/bash
 flag="/tmp/flag-conky"
 if [ -f $flag ]; then
  rm $flag
 else
  echo > $flag
 fi

The lines options

 line_lgth=100
 line_width=4

line_space can be usefull when labels are too close:

--for the second arc (yellow and blue labels are separated)
 first_angle=0,
 last_angle=90,
 line_space=20,

Last parameter for lines is extend_line which will extend the horizontal line if the text is too long, with extend_line=true on the second arc :

The text options
txt_font and font_size are obvious.
font_color and font_alpha create a linear gradient. To keep text color the same color of the line, set font_color=nil
txt_offset is the space between the line and the text
nb_decimals is the number of decimals for the numbers ;-)
With

 txt_font="FreeSans",
 font_size=12,
 font_color=0xFFFFFF,
 font_alpha=0.75,
 txt_offset=1,
 nb_decimals=1,

The last parameter txt_format is the string for formating texts. Some tags can be used :


 -- &l for label (the first value of tableV)
 -- &v for value (the second value of tableV)
 -- &m for max value (the third value of tableV)
 -- &o for occupied percentage (ie tableV[2]/tableV[3])
 -- &f for free percentage (ie tableV[3] - tableV[2]/tableV[3])
 -- &n for free value (non-occupied) (ie tableV[3] - tableV[2])

With

 txt_format="&l &m, free &f",
 nb_decimals=0,

That's all ;-)

Edit : a last example (code is here ):

Edit for version 1.1, I added the parameter type_arc. If type arc is "r" (the default value) values are displayed on a radial way as before :

but if type_arc="l" (l for linear) then values are dispayed like rings :

Square to Rounded image with Lua/imlib

2010-04-07T09:31:00.000-07:00

I wanted to display Moon and Earth pictures on my conky but the only images I found where squares images with a black background and the Moon or the Earth in the middle.
So to display the image correctly in the conky, I had to set transparency of the background of the original image. Well, I've done that with imlib and post the resulting script here (or in french here).

I also post the script to get Earth or Moon images from this site :
http://www.fourmilab.ch/earthview/expert.html

Of course the images are updated every hour so the night area is reflecting the reality !
And of course again, there are a few parameters to set the latitude, longitude and so on ...

If you are inspired, you can have some amazing conkys like this one :

or that:

I also updated the clock and the calendar wheel (this one is now a widget and it is more easy to use it).
And I discover that the widgets can be called with the dofile() function in the Lua script. No more need to copy/paste the widget but to use a line like this :
dofile("/home/wlourf/calendar/calendar.lua")

Automatic logout for kids

2010-03-31T12:45:00.000-07:00

I have a little problem with my little kid : when he plays on computer, I have to tell him at least 10 times to stop when his time is up !
So I wrote this conky (to use in Gnome) that will display remaining time and logout the session !
And after that, if he tries to login again, the session will run only 30 seconds ;-)

Of course, it's for a small kid who doesn't know commands like "killall conky" or tricks like that !

First, create a hidden folder in the kid session :
mkdir ~/.logout/

and create the next 3 files in the folder:
the conkyrc-logout


double_buffer yes
no_buffers yes

#own_window yes
own_window_type desktop
own_window_transparent yes
own_window_hints undecorate,sticky,skip_taskbar,skip_pager,below

border_inner_margin 0
border_outer_margin 0

# X font when Xft is disabled, you can pick one with program xfontsel
font 7x13

# Use Xft?
use_xft yes


# Xft font when Xft is enabled
xftfont monospace-18

# Text alpha when using Xft
xftalpha 0.5

# Draw shades?
draw_shades yes

# Stippled borders?
stippled_borders 0

# Default colors and also border colors
default_color yellow
default_shade_color blue

alignment br
gap_x 1
gap_y 1

# Add spaces to keep things from moving about?  This only affects certain objects.
use_spacer right

# Subtract file system buffers from used memory?
no_buffers yes

TEXT
Stop in ${exec ~/.logout/time_left.sh}

The script time_left.sh which send remaining time to the conky :


#! /bin/bash

#st in seconds
st=$(~/.logout/read_time.sh)

RUNTIME=$((st))
SECOND=$((RUNTIME%60))
MINUTE=$((RUNTIME/60%60))
HOUR=$((RUNTIME/3600))

if [ "$SECOND" -lt 10 ]; then

SECOND="0$SECOND"
fi
if [ "$MINUTE" -lt 10 ]; then
 MINUTE="0$MINUTE"
fi
if [ "$HOUR" -lt 10 ]; then
 HOUR="0$HOUR"
fi

echo $HOUR":"$MINUTE":"$SECOND
if [ "$RUNTIME" -lt 0 ]; then
 gnome-session-save --force-logout
fi

The script read_time.sh which read remaining time and save it in a file .counter.txt
The default time for a day is one hour (3600 secondes) on line 4.


#! /bin/bash

log=~/.logout/.counter.txt
duration=3600

if [ ! -f $log ]; then
echo "no file"
echo $(date +%Y%m%d)";"$duration > $log
fi

today=$(date +%Y%m%d)

reste=-1
line=`tail $log`

xday=$(echo $line | cut -d";" -f1)
if [ $xday -eq $today ]; then
reste=$(echo $line | cut -d";" -f2)
hasdate=true
if [ $reste -lt 0 ]; then
 reste=30
fi
reste=$((reste-1))
else
reste=$duree
fi
echo $today";"$reste > $log

echo $reste

To run it at startup, add this line in gnome startup:
conky -c ~/.logout/conkyrc-logout

Voilà ! I'm sure there is other to do that, but I like the display of the remaining time...
Make sure the paths are OK for in the three files and don't forget to make the scripts executables

The script in french here.

Smiley Widget

2010-03-19T23:36:00.001-07:00

Here is a new widget which can give at least four informations if you can read it, which is not really easy at first glance.
Each eye and the smile can be linked to a conky variable or not and color can change.
The code for the script can be downloaded on ubuntu forum or on CH forum (or in french here).

Parameters are explained in the Lua script, but there is a short example :


draw_smiley(200,175,120,4,0xFFFF00,false,true,false,
  "downspeedf", "wlan0",1000, false,
  "upspeedf", "wlan0",100, false,
  "wireless_link_qual_perc","wlan0",100,false,
  "acpitemp","",80,
  -0.5)

And the function with named arguments

function draw_smiley(xc,yc,radius1,shadow_size,color0,compo_r,compo_g,compo_b,
  le_name,le_arg,le_max,le_inv,
  re_name,re_arg,re_max,re_inv,
  mouth_name,mouth_arg,mouth_max,mouth_inv,
  color_name,color_arg,color_max,
  rotation)

From last to first :
-last line :rotation is the angle in radian of rotation of the smiley
-lines 2 to 5 are where we choose values to display. On line 2, it will display the download speed of wlan0, the value need to be in percent so we have to set the max value (1000 in my case). The last parameters will inverse the value if needed, ie. if value is 80%, it will draw a 20% value.
- first line : xc, yc, radius1 are for positionning the smiley in the conky window
- first line : shadow_size will draw a shadow ;-)
- first line : color0, compo_r, compo_g, compo_b are parameters for having color changing, for the example above:
0xFFFF00,false,true,false,
with
"acpitemp","",80,
The color will change between 0 and 80, at zero, color will be 0xFFFF00 (yellow) and when $acpitemp will increase, green composante will be affected, so when 80°C is reached, the color will be 0xFF0000 (red).

Last warnings :
Fixed values can be used instead of conky variables with name="" and arg=value (80% in this case): "",80,100,false,

If you call more than one widget : xc, yc and rotation are RELATIVES to previous widget.

Voilà!

How to display Openbox's Shortcuts

2010-03-10T13:56:00.000-08:00

I am an Openbox + Ubuntu user but sometimes, I can't remember some shortcuts. So I wrote a script to display the shorcuts (keyboard+mouse) from rc.xml in a conky window, and this window is called with a shortcut (!) only when I need it, it's a kind of help window :-)

Maybe this kind of script already exist but I didn't find it .

All the scripts can be downloaded from ubuntu forums.
In french, it's here on ubuntu-fr forum.

First I need a conkyrc template.
The python script will read this file and write shortcuts at the end of this file but in a new file.
The only thing to do in this file is to choose your colors for display.
The name of the file is conky_template.

Second, the python script shortcuts.py read the openbox's rc.xml file.
There are some parameters to set at the beginning of the script :



#full path and name of the rc.xml file
rc_path_file="/home/ll/.config/openbox/rc.xml"
#template of conkyrc to use
conkytemplate_path_file ="/home/wlourf/scripts/raccourcis/conky_template"

#column width (Ms = souris, Kb= clavier)
lgColMs=50
lgColKb=40

#Number of lines per Column (Ms = souris, Kb= clavier)
nbLnMs=30
nbLnKb=30

#in "Keyboard" array, "appliFirst" will display application name before shorcut
appliFirst=True

#END OF THE PARAMETERS !

Third, a little bash script launcher.sh needed to run the python script and to call conky. Don't forget to make it executable.

And, for finish, in rc.xml, two shortcuts to run launcher.sh with parameters :


<command>/home/wlourf/scripts/raccourcis/launcher.sh /tmp/conky_kb k</command>

<command>/home/wlourf/scripts/raccourcis/launcher.sh /tmp/conky_ms m</command>

Voilà, when I call the script, the conky display the above image for the keyboard or this one for the mouse :

Today I also updated the audio_spectrum script : it can display the bargraph widget in a circular way, like this :

And a short video :

Bleeding heart ...

2010-03-01T14:27:00.000-08:00

I made this amazing heart with a Lua script. The verticals lines are linked to some conky variables (cpu, download speed ...).
It's up to the user to choose the shape he wants to draw, for example a breathing heart :

Well, I am not specially interesting by hearts but I tried to adhere to the theme of the conky contest of this month : Saint Valentine's Day/Massacre. So, if you like this script, you can vote for it on the conky blog here.

A last video made with the same script :

All the stuff can be downloaded from the ubuntu forum : here. There is also an HOWTO if you want to draw your own shapes!

I think, I will stop with this moving stuff for a while !

Happy Conkying ! And if someone can explain me the difference between "bleeding" and "bloody" ...

Audio Spectrum Analyser / Equalizer

2010-02-28T12:55:00.000-08:00

As you can see on this video, we can make some funny things with conky. (With recordmydesktop, I don't have a nice sound, and sound is not synchro to the video, sorry for that).
After drawing some bargraphs with Lua, I tried to draw an audio spectrum. This has nothing to do with Conky or Lua but all the work was already done for a screenlet named Impulse for gnome ().

This screenlet use a C library and some python bindings for drawing the spectrum. The main work to port this to conky was to translate drawing from python to lua and it was quiet easy.
I tried to make lua bindings for the C library but I didn't managed because I don't know C ! Even after reading this HowTo.

How the conky works ?
conkyrc load the Lua script and run the main function in Lua. This function create a pipe to the python binding linked to the C library at first run of the conky. After that, the Lua script read the values returned by python and draw the equalizer.
Also, I included the bargraph widget in the lua script so the spectrum can be more colorized ;-)

Bargraph widget

2010-02-28T04:25:00.000-08:00

The version 2.0 of the bargraph is located here : I add more effects and it is more easy to configure with a table of settings :-)

While looking at an old hifi system with green and red equalizer, I tried to do the same with cairo. But with the powerful of cairo, we can do more than simple bar graph. So I wrote this script, really simple to use even if there are 20 parameters to set. But as you can see on the picture, the effects are well rendering!

22. Feb 2020:
I just updated the widget so it can receives not only conky stats but also numeric values.
For use with conky stat :

equalizer('cpu', 'cpu0', ...

for use with numeric values:

equalizer('', my_value, ...

I'have done that because I wanted to retain previous values from conky stats in order to display a progressing graph like on this video :

It's absolutely useless, isn't it !

The code for the video is on the crunbang forum.

28 Feb. 2010:
I renamed the widget from 'equalizer' to 'bargraph'

Last version can be downloaded from ubuntu forums : here

Happy conkying!

Links Index !

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

This page is the reference points for all the little scripts for Conky I posted around.
It will make life easier for people using theses scripts when they're looking for latest versions.

Recents updated scripts are on top!
First link is the link to the download page, second link is the link to the presentation page in this blog

Text widget (v1.42 - 09/02/2011) blog
Box widget (v1.1 - 27/01/2011) blog
Bargraph widget (v2.1 - 07/01/2011) blog
Pie Chart widget (v1.3 - 07/01/2011) blog
Graph widget (v1.1 - 07/01/2011) blog
Rings + Sectors Widget (v1.1 - 07/01/2011) blog
Calendar box (v1.0 - 14/05/2010) blog
Openbox's shortcuts (v1.2 - 02/05/2010)
Radio box widget (v1.0 - 27/04/2010)
SquareToRound Script (v1.0 - 07/04/2010) with scripts for Moon and Earth pictures
Calendar Wheel (v1.4.1 - 07/04/2010)
Shaded Clock (v1.2 - 06/04/2010)
Automatic logout for kids (v1.0 - 31/03/2010)
Smiley widget (v1.0 - 19/03/2010)
Audio Spectrum Analyser/Equalizer (v1.2 - 10/03/2010)
Bleeding Heart (v1.0 - 26/02/2010)
Photo Album Stack (v1.1 -31/01/2010) with scripts for deviantArt

How to get pictures from RSS feeds from deviantArt (get_deviation_search.sh v1.0)

2010-02-02T09:54:00.000-08:00

Each time you make a research on deviantArt web site (or when you browse a category) a RSS feed is generated.
For example, to see the newest deviations in the fractal category, the rss feed generated at the bottom of the page is http://backend.deviantart.com/rss.xml?q=in%3Adigitalart/fractals%20sort%3Atime&type=deviation.

For my Photo Album script, I wanted to download/save pictures from the RSS feed to my hard drive.
Well, I wrote something and it works but it certainly can be improve!

I call this script : get_deviation_search.sh and it should be run with at least three arguments:
1st arg : folder where to save the pictures
2nd arg : delay (in minutes) for repeating the script (0 is for a single run)
3rd arg and following : urls of the rss feed to follow
and more parameters can be set inside the script


#example for photomanipulations, fractals categories and research for "conky"

./get_deviation_search.sh /home/wlourf/deviant 5 http://backend.deviantart.com/rss.xml?q=in%3Adigitalart/fractals%20sort%3Atime\&type=deviation http://backend.deviantart.com/rss.xml?q=in%3Adigitalart/photomanip%20sort%3Atime\&type=deviation http://backend.deviantart.com/rss.xml?q=in%3Adigitalart/fractals%20sort%3Atime\&type=deviation http://backend.deviantart.com/rss.xml?q=sort%3Atime%20conky\&type=deviation

IMPORTANT : In the RSS feed the symbol & has to replace by \& elsewhere it won't work

This script can also be downloaded here

En français (soyons fous) :
Ce script permet de télécharger les images des liens RSS générés sur les pages des résultats de recherche sur deviantArt.
Il fonctionne avec 3 arguments minimum :
1: le dossier où enregistrer les images
2: le temps à attendre entre chaque boucle (0 pour une seule boucle)
3 et suivants : liens RSS (Dans ces liens il faut remplacer & par /&)

The script :


#! /bin/bash
#This script get pictures from RSS feed from deviantArt website and save them to hard disk
#
# by wlourf http://u-scripts.blogspot.com/
# v1.0 - 02 Feb. 2010
#
#1st arg : folder where to save the pictures
#2nd arg : delay (in minutes) for repetaing the script (0 is for a single run)
#3rd arg and following : urls of the rss feed to follow

#some paramaters are set here
file1=/tmp/get_deviant_rss.txt
file2=/tmp/get_liste.txt
#display filename even if it is not saved (ie saved previously)
display_files_not_saved=false
#if script running in gnome_terminal, right click on the file can open it
display_files_with_link=true
############################# end ###########################

clear

if [[ $# -lt 3 ]]; then
  echo 'This script needs at least 3 arguments : '
  echo '    - full path of the folder where save the pictures'
  echo '    - run the script every X minutes, 0 for a single run'
  echo '    - one or more RSS feeds to watch (take care to escape the & symbol with \&)'
  exit
fi

folder=$1
repeat=$2
args=$*
rss=${args#$1" "}
rss=${rss#$2" "}
nbUrl=0

if [[ {$folder:-1} != "/" ]]; then
  folder="$folder/"
fi

for url in $rss
do
  ((nbUrl++))
  tabRSS[$nbUrl]=$url
done

nbLoops=0
flag=true
while ( $flag ); do

  echo "-------------------"
  echo "folder = "$folder
  echo "-------------------"
  echo "loop every $repeat minutes"
  echo "-------------------"

  ((nbLoops++))

  mkdir -p $folder
  cd $folder

  for ((u=1 ; u<=$nbUrl ; u++))
  do
    #read one rss feed
    echo "-------------------"
    echo "rss $u/$nbUrl = "${tabRSS[u]}
    GET ${tabRSS[u]} > $file1
    
    #extract the link to the fullview image
    match="medium=\"image\""
    url_line=""

    begin="http"
    end="\" height"

    table=()
    idx=1
    #put the links in a table for better display
    while read line
    do
      if [[ "$line" =~ "${match}" ]]; then
        url_line=$line
        a=$(($(expr "$url_line" : ".*$begin")-${#begin}))
        b=$(($(expr "$url_line" : ".*$end")-$a-${#end}))
        url_link=${url_line:$a:$b}
      table[$idx]=$url_link
      ((idx++))
      fi
    done <  $file1

    #read the table ans save the image if not already saved
    nbLinks=$(($idx-1))
    nbSaved=0
    for ((a=1 ; a<=$nbLinks ; a++))
    do
      link=${table[a]}
      img_name=$(expr match "$link" '.*\(/.*\)')
      img_name=${img_name:1}
      txt="loop $nbLoops - url $u - $a/$nbLinks"
      if ($display_files_with_link) then
        strFile="file://"$folder$img_name
      else
        strFile=$img_name
      fi
      if [ -f "$img_name" ]; then
        if ($display_files_not_saved) then
          echo  $txt" - *** "$strFile" *** already saved"
        fi
      else
        echo  $txt" - "$strFile
        wget  -q $link
        ((nbSaved++))
      fi

    done
    echo
    echo "$nbSaved/$nbLinks pictures saved for loop number $nbLoops and rss= $url"
    echo "-------------------"
    echo
  done
  
  if [[ $repeat -eq "0" ]]; then 
    flag=false
  fi

  nows=$(date +%s)
  waitto=$(($nows+$repeat*60))
  sl=$(($waitto-$nows))
  echo "Wait $((sl/60)) minutes till :"
  date --date "$sl sec"

  sleep $sl
done

echo
echo "Finish! after $nbLoops loop(s)"



How to get random pictures from deviantArt (get_deviation.sh v1.0)
2010-01-31T03:47:00.000-08:00
As I was a bit boring to see always the sames pictures from my hard drive with my conky script "Photo Album Stack", I tried to get some other pictures from the web.

Picasa as an interesting Slideshow tool.
If you open just this page in a browser (epiphany for example), you have to set the folder of the cache
/home/wlourf/.gnome2/epiphany/mozilla/epiphany/Cache in the script and that's it.
But pictures on Picasa are not really interesting, isn't it?

DeviantArt has also a random tool but whithout slideshow, so you have to click to display images ...
I wrote this script (get_deviation.sh) that go to the random page and save the image (in fullsize) to the hard disk. This one can be improved because regular expressions are not my favorite toy!
Next, I will try to do the same for pictures from one single category.

Before running the script you have to set the folder variable in it.

This script can also be downloaded here.


In a few days, I will post the last version of the Photo Album Script which will run with this script.

En français (soyons fous)!
Ceci est un script qui enregistre des images aléatoires du site deviantArt sur son PC. Pour être utilisé, il faut paramétrer la variable folder au début du script.

The script : get_deviation.sh

#! /bin/bash
#This script get a random image from deviant art website and save it to hard disk!
#
# by wlourf http://u-scripts.blogspot.com/
# v1.0 - 31 Jan. 2010
#
#argument 1 (optional) is the path+filename where to save the image
#if argument 1 is not present, image will be saved in $folder
#
#other paramaters are set here
file1=/tmp/get_random.txt
file2=/tmp/get_image.txt
folder=~/deviant

############################# end ###########################

#get a random url
GET http://www.deviantart.com/random/deviation > $file1

#extract the link to the deviation page
match="<input type="\" name="\" value="\" begin="http" end="\">"

a=$(($(expr "$url_line" : ".*$begin")-${#begin}))
b=$(($(expr "$url_line" : ".*$end")-$a-${#end}))

url_page=${url_line:$a:$b}

#echo "deviation--> "$url_page

#get the deviation page
GET $url_page > $file2

#extract the link to the fullview image
match="fullview"
url_line=""

while read line
do
  if [[ "$line" =~ "${match}" ]]; then
    url_line=$line
    break
  fi
done <  $file2

begin="src\":\""
end="\"},\"smallview"

b=$(($(expr "$url_line" : ".*$end")-${#end}))
url2=${url_line:0:$b}

a=$(($(expr "$url2" : ".*$begin")))
url_img=${url2:$a}

#save image to hard disk if url ok 
if [[ $url_img != "" ]]; then
  cd $folder
  if [[ $1 != "" ]]; then
    wget $url_img -O $1
  else
    wget $url_img
  fi
fi 


If you want the script to run in a loop, just write in another script:

while true
do
  ./get_deviation.sh
done



Calendar wheel
2010-01-19T13:20:00.000-08:00

Well, as I explore the conky a little bit deeper, I am very amazing of things we can draw with some lines of codes.
Last week I tried the Conky Contest of the Month with this "Calendar Wheel". We were only two guys to participate (too bad) but you can vote for my calendar if you like the conky I will now explain !! Edit: I won coool !

This script simply draw a circular calendar on the left side of the screen (I didn't try on the right side as text alignment is not easy with cairo).

The most difficult part of this script was to rotate the dates because cairo doesn't allow that: the trick was to draw each date on a separate image, rotate the image and then render the rotated image on the screen.
Customization can be done with colors, height and width and some text can be added (depending on the date) on the left side of the arc.

This is what I've done for the contest (and for learning myself Lua) !

After that, I added some improvements in version 1.1 :
- today's date can now be set anywere in the arc (not on only the horizontal line) : yoffset
- today's date can now have an offset (positive or negative) : xoffset
- the main thing is that the calendar is draw only at the start of the conky and when the date change (i.e. the calendar is saved in a PNG file and this is this file that will be displayed in the conky) or if the PNG file is deleted : so the conky become really really fast  ...

And in version 1.2, the calendar can be drawn on the right side of the conky.

The script can be downloaded from ubuntu forums here.

Edit : how to set date in local language:
Here is what I've done for having dates according to my locale settings:
It your conkyrc, in the TEXT section, write
${time}
If you want to hide this date , 
use_xft yes
xftalpha 0
default_color 000000
It seems it works only for the black color .
I didn' manage to do that in Lua only

Happy Conkying !


More screenshots :




There is also a gallery on picasa


Shaded clock widget
2010-01-10T03:32:00.000-08:00

This is my attempt to draw a eye-candy clock using cairo and conky.
I draw some examples on the picture with the parameters used.
Effects are nice but code need to be optimized.

Edit : I updated my "shadowed clock"  to a "clock shaded", (is this more english ?). It's now easy to use because it's a widget that can be cut/paste in a Lua script.
Again, it can be downloaded from ubuntu forums .




Photo Album Stack
2010-01-03T03:37:00.001-08:00

Hi,

This is my first attempt to use lua bindings in conky (> 1.7.2).
This script is based on londonali's Photo Album Script but it can display than more one image at a time and in a more messy way (if configured to).

In the conkyrc, don't forget the blank line after TEXT
To start with an empty photo album, delete the file created by the script :

rm /tmp/img.png & conky -c ~/scripts/conkyrc-album-stack &

Some improvments made in version 1.1 :
- little images are no more enlarged
- the filename of the image can be written in the frame or/and elsewhere in the conky.
- gray shadow on the bottom right side of each image can be added
(this is optional but has to be improved : the shadow has to be "blur" and shadows don't work for big pictures)
It can be used with the script get_deviation.sh (see this post) or any other script that get a random image from the web.


The scripts can be downloaded from ubuntu forums.

Another screenshot :


En français, soyons fous! Ce script affiche des images de son disque dur sur votre conky dans une façon un peu bordélique. Les dernières modifications sont :
- les petites images ne sont plus agrandies
- le nom de l'image peut être affiché dans le cadre ou n'importe où dans la fenêtre du conky
- une sorte d'ombre peut être ajoutée mais ceci devra être amélioré (il n'y a pas d'effet de flou et ça ne fonctionne pas bien pour les grandes images)
- le script peut être utilisé avec un autre script qui génère des images aléatoires comme get_deviation.sh que j'ai posté il y a quelques jours


Happy conkying!