Man Linux: Main Page and Category List


       wicked - a lua library for dynamic widgets in awesome




       wicked is a library, written in lua, for easy creation and management
       of dynamic awesome statusbar widgets, from the rc.lua configuration


       To use wicked, put require("wicked") at the top of your rc.lua, from
       then on, create your widgets as normal and call wicked.register() to
       register them to wicked.

       wicked.register(widget, widget_type, format, update_interval,
       data_field, padding)


       Use the widget created by widget for this argument.


       Enter one of the possible widget type functions or a customised one
       here, see the WIDGET TYPES section.


       Format can be either a string argument where $1,$2,$3,etc. will be
       replaced by their respective values, or a function called with the
       arguments (widget, arguments), arguments being a table of the values
       otherwise inserted into the string, if it is a function, its return
       value will be used to populate the widget. Note that some widget types
       might not need or use this parameter.


       The amount of seconds it waits between updating this widget, defaults
       to 1.


       If you want to feed the data into a graph or progressbar, put the bar
       or plot name you want to use in here.


       To prevent widgets jumping about your statusbar all the time, you can
       specify a padding value here, the number given here represents the
       minimum amount of digits that the widget’s output has to contain (ie
       specifying 2 padds values under 10 with one zero, specifying 3 padds
       values under 100 with one zero and values under 10 with two zeros, etc)
       If the widget type supports it, you can specify a table with different
       numbers, the first number being the padding for the first value the
       type would return, the second number for the second value, etc.


       The following functions are also provided by wicked.

       wicked.unregister(widget, keep)

       Unregister all updates associated with a widget. Keep is optional
       (defaults to false), and if true, the widget will only be suspended,
       ready to be reactivated by the activate function later.


       Suspend all widget updates, useful if you are running in low-power mode
       and want to save battery for a while.


       Restarts all widgets that were suspended either from wicked.suspend(),
       or by calling wicked.unregister() with keep=true. Widget is optional,
       if given, only that widget will be activated, defaults to all widgets.


       wicked.register() and wicked.unregister() both return a reg object,
       this contains information about the widget and the updates that should
       be sent to it, you can pass this reg object into regregister after
       unregistering it, and it will be reregistered (or activated if it was
       only suspended).


       Enable caching of the values returned by a custom widget_type. Note
       that all widget_type functions included in wicked already have caching
       enabled by default.


       Widget types consist of functions that take the "format" argument given
       to wicked.register as the first argument, the "padding" argument as the
       second, and return a table of values to insert in the format string,
       creators of custom widget types should note that the format argument
       may be a function as well as a string.

       For backwards compatibility purposes, if a string X is given as
       widget_type, it will use 'wicked.widgets.X' as the widget type.

       The date widget type uses the output of the ‘‘ command to
       populate the widget, if format is given, it will be passed as the
       FORMAT argument to ‘‘.


       The cpu widget type outputs the current cpu usage in percentages,
       calculated over the duration of it’s update_interval. Use $1 inside the
       format string to display the total usage percentage, $2 to show it for
       your first cpu core only, $3 for the second core, etc.


       The memory widget type outputs four things, $1 will be replaced with
       the current memory usage in percentages, $2 will be replaced with the
       total used memory in Mb, $3 with the total amount memory available to
       the system, and $4 with the amount of free memory.


       The swap widget type outputs the same values as the memory widget type,
       about the amount of swap in use/available.


       The mpd widget type outputs the song currently playing on the music
       player daemon, note that the ‘mpc‘ application needs to be installed
       and configured in order to use this.


       The mocp widget type outputs the song currently playing on the mocp
       server. Use $1 inside the format string to display the current song. A
       maxlength can be given to the wicked.register() function which will cut
       the songname in two when exeeded and displays the first and last part.
       A typical functioncall looks like this: wicked.register(mocpwidget,
       'mocp', 'MOC: $1', 1, nil, 50). Here 50 is the max amount of characters
       displayed of $1.


       The fs widget type can display size and usage information about
       currently mounted filesystems, use ${mountpoint datatype} inside the
       format string to display that data, e.g. ${/ avail} displays the free
       space on the partition mounted on /. Available datatypes are 'used',
       'size', 'usep' (Usage in %) and 'avail'.

       The net widget type displays usage information about your networks, in
       the format string, ${interface type} will be replaced with with that
       value, possible types are: rx, tx, up, down. You can suffix the type
       with _b, _kb, _mb or _gb, to display the information in those units.


       The uptime widget type displays information about how long your machine
       has been on (or "up"). Use $1 for the total number of seconds up, $2
       for the number of days, $3 for the number of hours, $4 for the number
       of minutes and $5 for the number of seconds.


       You can create your own custom widgets easily, an example of a widget
       that returns the output of a specific command is:

           mywidget = widget({
               type = 'textbox',
               name = 'mywidget'

           function run_script()
              local filedescriptor = io.popen('')
              local value = filedescriptor:read()

              return {value}

           -- Runs '' every 10 seconds and puts its output into the widget
           wicked.register(mywidget, run_script, "$1", 10)

       As you can see, the type function returns a table of values to insert
       into the format string, the first value in the table will be used in
       place of $1, the second in place of $2, etc.

       If you want to register the same function multiple times, it is a good
       idea to enable caching so that your function is only called once in
       each interval. To do this call the enable_caching function like so:



       You can use a function instead of a string as the format parameter,
       with this, you are able to check the value returned by wicked and
       change the output accordingly. The format function will get the widget
       as its first argument, and a table with the values otherwise inserted
       into the format string as its second argument, and should return the
       text to be used for the widget.

       An example that uses a format function in order to hide the mpd widget
       when there is no song playing:

           mpdwidget = widget({
               type = 'textbox',
               name = 'mpdwidget'

           wicked.register(mpdwidget, wicked.widgets.mpd,
               function (widget, args)
                   if args[1]:find("volume:") == nil then
                       return ' <span color="white">Now Playing:</span> '..args[1]
                       return ''


       Put these snippets into your rc.lua (usually located at
       ~/.config/awesome/rc.lua) to see what they do, don’t forget to add the
       widgets to your statusbar.

       A simple 'Now Playing' widget

           mpdwidget = widget({
               type = 'textbox',
               name = 'mpdwidget'

           wicked.register(mpdwidget, wicked.widgets.mpd,
               ' <span color="white">Now Playing:</span> $1')

       A memory usage monitor, with padding

           memwidget = widget({
               type = 'textbox',
               name = 'memwidget'

           wicked.register(memwidget, wicked.widgets.mem,
               ' <span color="white">Memory:</span> $1 ($2Mb/$3Mb)',
               {2, 4, 4})

       A filesystem usage indicator

           fswidget = widget({
               type = 'textbox',
               name = 'fswidget'

           wicked.register(fswidget, wicked.widgets.fs,
               ' <span color="white">FS:</span> ${/ used}/${/ size} (${/ usep} used)', 120)

       A network interface monitor (for eth0)

           netwidget = widget({
               type = 'textbox',
               name = 'netwidget'

               ' <span color="white">NET</span>: ${eth0 down} / ${eth0 up} [ ${eth0 rx} // ${eth0 tx} ]')


       awesome(1) awesomerc(5)


       Lucas de Vries <[1]>