lua conky

-------------------------------------------------------------------------------
--
--                            conky shi lua script
--
-------------------------------------------------------------------------------

require 'cairo'

-------------------------------------------------------------------------------
---------------------------------shared vars-----------------------------------
-------------------------------------------------------------------------------

-- placement vars
----------------------------
local pcmt = {
    border_gap = 50,
    vertical_gap = {103.5,105},
    wall_image_width = 844
}
local colomn_width = (1920 - pcmt.wall_image_width)/2 - pcmt.border_gap

-- color setup
----------------------------
local white_color = 0xa0a0a0
local back_color = 0x161616
local gray_color = 0x404040
--local main_color = 0x146056
--local main_color = 0x0f6537
local main_color = 0x169281

-- cairo settings
----------------------------
local extents = cairo_text_extents_t:create()

local font = "Play"
local main_font_size = 24
local font_face=CAIRO_FONT_WEIGHT_BOLD
local font_slant=CAIRO_FONT_SLANT_NORMAL

local line_width=1
local line_cap=CAIRO_LINE_CAP_BUTT
local fill_rule=CAIRO_FILL_RULE_EVEN_ODD

local main_text_height = 0

--shared elements size
----------------------------
local main_bar = {
    width = 6,
    height = 17,
    ang = 0,
    gap = 12
}

local main_up_bar = {
    width = 17,
    height = 6,
    ang = 0,
    gap = 21
}

local main_chart_bar = {
    width = 6,
    height = 35,
    gap = 9
}

local main_corner = {
    width = 40,
    height = 20,
    line = 5,
    gap = 10,
    num = 10
}


-------------------------------------------------------------------------------
-----------------------cairo image drawing functions---------------------------
-------------------------------------------------------------------------------

-------------------------------------------------------------------------------
--                             feather image
-------------------------------------------------------------------------------

function draw_feather(coord,scale_factor)

    --orinal image size 512x512
    ----------------------------
    scale_factor = scale_factor or {1,1}

    cairo_save(cr)
    cairo_translate (cr, coord.x, coord.y)
    cairo_scale (cr, scale_factor[1], scale_factor[2])

    local m1 = cairo_matrix_t:create()
    cairo_matrix_init (m1,18.69,0,0,18.69,-2742,-7251)
    cairo_transform(cr, m1)

    cairo_set_line_width (cr, 1)

    ----------------------------
    cairo_move_to (cr,152,409.6)
    cairo_rel_curve_to (cr,-4.7,-5.5,4.2,-14.6,10.1,-17.4)
    cairo_rel_curve_to (cr,15.3,-7.3,11.2,1.8,5.9,4.5)
    cairo_rel_curve_to (cr,-4.6,2.3,-6.6,5.3,-8.5,8.2)
    cairo_rel_curve_to (cr,-1.1,1.7,-3.9,2.9,-6.9,2.8)
    cairo_fill (cr)

    cairo_move_to (cr,151,408.7)
    cairo_rel_curve_to (cr,-1.3,-0.7,-2,-1.8,-2.7,-2.9)
    cairo_rel_line_to (cr,2,0.6)
    cairo_rel_curve_to (cr,-0.7,-1.1,-1.1,-2.3,-1.4,-3.4)
    cairo_rel_line_to (cr,3.4,2.2)
    cairo_fill (cr)

    cairo_move_to (cr,152.8,404.9)
    cairo_rel_curve_to (cr,-1.5,3,-2.5,6.1,-3,9.2)
    cairo_stroke (cr)

    ----------------------------
    cairo_set_source_rgba (cr,rgb_to_r_g_b(back_color,1))

    cairo_move_to (cr,170.7,397.4)
    cairo_rel_line_to (cr,-6.5,-0.2)
    cairo_rel_line_to (cr,4.6,1.6)

    cairo_move_to (cr,173.4,394.5)
    cairo_rel_line_to (cr,-6.4,1.5)
    cairo_rel_line_to (cr,4.9,0.4)

    cairo_move_to (cr,161.6,409.3)
    cairo_rel_line_to (cr,-4.5,-4.8)
    cairo_rel_line_to (cr,2.1,4.4)

    cairo_move_to (cr,157.4,411)
    cairo_rel_line_to (cr,-1.5,-6.4)
    cairo_rel_line_to (cr,-0.4,4.9)

    cairo_move_to (cr,164.2,390.1)
    cairo_rel_line_to (cr,-4.6,4.8)
    cairo_rel_line_to (cr,2.1,-4.4)

    cairo_move_to (cr,157.8,391.9)
    cairo_rel_line_to (cr,-1.6,6.4)
    cairo_rel_line_to (cr,-0.3,-4.8)

    cairo_move_to (cr,173.1,389.2)
    cairo_rel_line_to (cr,-6.3,1.9)
    cairo_rel_line_to (cr,4.1,-2.8)
    cairo_fill (cr)

    cairo_move_to (cr,150.9,414.1)
    cairo_rel_curve_to (cr,1.7,-10.5,7.2,-17.8,16,-21.3)
    cairo_stroke (cr)

    ----------------------------
    cairo_restore(cr)
end

-------------------------------------------------------------------------------
--                              stamp image
-------------------------------------------------------------------------------

function draw_stamp(coord, color)

    -- stamp size settings
    ----------------------------
    local base_length = 12
    local w = 8
    local h = 6

    -- base length = 12
    ----------------------------
    local function draw_border(num)
        for i=1,num do
            cairo_rel_line_to (cr,3,0)
            cairo_rel_curve_to (cr,1,3,5,3,6,0)
            cairo_rel_line_to (cr,3,0)
        end
        cairo_rotate (cr, math.pi/2)
    end

    cairo_save(cr)
    cairo_set_source_rgba (cr,rgb_to_r_g_b(color,1))
    cairo_translate (cr, coord.x, coord.y)

    -- border
    ----------------------------
    cairo_move_to (cr,0,0)
    local size = {w,h,w,h}

    for i=1,4 do
        draw_border(size[i])
    end
    cairo_close_path (cr)

    local border_width = 8
    cairo_rectangle (cr,border_width,border_width, w*base_length-2*border_width, h*base_length-2*border_width)

    -- draw シ
    ----------------------------
    cairo_move_to (cr,34.74,49.02)
    cairo_rel_curve_to (cr,12.09,-5.76,26.48,-17.17,40.38,-28.91)
    cairo_rel_curve_to (cr,-8.24,16.39,-20.22,25.17,-34.22,32.95)
    cairo_rel_curve_to (cr,-0.96,1.05,-0.76,4.36,-5.2,2.67)
    cairo_rel_curve_to (cr,-4.02,-1.82,-7.25,-9.33,-0.96,-6.71)
    cairo_close_path (cr)

    cairo_move_to (cr,25.31,28.86)
    cairo_rel_curve_to (cr,5.24,0.97,12.07,0.57,13.96,4.46)
    cairo_rel_curve_to (cr,0.61,2.82,0.12,4.88,-3.49,4.77)
    cairo_rel_curve_to (cr,-3.18,-4.07,-6.83,-6.65,-10.47,-9.23)
    cairo_close_path (cr)

    cairo_move_to (cr,32.62,17.13)
    cairo_rel_curve_to (cr,0.85,-0.56,11.07,5.72,11.5,7.38)
    cairo_rel_curve_to (cr,2.78,-0.29,4.56,-1.44,3.69,-4.88)
    cairo_rel_curve_to (cr,-2.77,-3.76,-8.82,-3.34,-15.19,-2.5)
    cairo_close_path (cr)

    cairo_fill (cr)

    ----------------------------
    cairo_restore(cr)

    return {w = w*base_length, h = h*base_length}
end

-------------------------------------------------------------------------------
--                            envelope image
-------------------------------------------------------------------------------

function draw_envelope(coord, scale_factor, letter)

    --orinal image size 100x100
    ----------------------------
    scale_factor = scale_factor or {1,1}

    cairo_save(cr)
    cairo_translate (cr, coord.x, coord.y)
    cairo_scale (cr, scale_factor[1], scale_factor[2])

    -- envelope
    ----------------------------
    cairo_move_to (cr,30.13,54.64)
    cairo_rel_line_to (cr,23.01,-31.71)
    cairo_rel_line_to (cr,30.42,21.8)
    cairo_rel_line_to (cr,9.78,-7.29)
    cairo_rel_curve_to (cr,1.33,-1.3,1.21,-2.61,0,-3.96)
    cairo_rel_line_to (cr,-42.07,-31.228)
    cairo_rel_curve_to (cr,-0.8,-0.525,-1.48,-0.41,-2.1,-0.016)
    cairo_rel_line_to (cr,-42.951,32.234)
    cairo_rel_curve_to (cr,-0.437,0.75,-0.539,1.48,0,2.14)
    cairo_close_path (cr)

    cairo_move_to (cr,71.68,60.2)
    cairo_rel_curve_to (cr,-1.4,1.2,-0.8,2.36,0,3.47)
    cairo_rel_line_to (cr,23.59,28.38)
    cairo_rel_curve_to (cr,2.01,2.3,3.11,1.2,4.11,0)
    cairo_rel_line_to (cr,0,-48.14)
    cairo_rel_curve_to (cr,-1.3,-2.18,-2.4,-1.69,-3.52,-1.09)
    cairo_close_path (cr)

    cairo_move_to (cr,28.87,60.2)
    cairo_rel_curve_to (cr,1.42,1.2,0.75,2.36,0,3.47)
    cairo_rel_line_to (cr,-23.604,28.39)
    cairo_rel_curve_to (cr,-2.009,2.28,-3.081,1.21,-4.11,0)
    cairo_rel_line_to (cr,-0.039,-48.15)
    cairo_rel_curve_to (cr,1.334,-2.18,2.453,-1.69,3.563,-1.09)
    cairo_close_path (cr)

    cairo_move_to (cr,50.22,77.56)
    cairo_rel_line_to (cr,14.44,-11.03)
    cairo_rel_curve_to (cr,0.86,-0.62,1.71,-0.87,2.81,0)
    cairo_rel_line_to (cr,23.35,28.01)
    cairo_rel_curve_to (cr,0.55,2.75,-0.54,3.2,-2.05,3.55)
    cairo_rel_line_to (cr,-77.63,-0.06)
    cairo_rel_curve_to (cr,-1.451,-0.34,-2.48,-0.9,-1.671,-3.33)
    cairo_rel_line_to (cr,23.271,-28)
    cairo_rel_curve_to (cr,1.06,-0.84,2.12,-0.72,3.18,0)
    cairo_close_path (cr)

    cairo_fill (cr)

    -- letters
    ----------------------------
    cairo_rotate (cr, -math.pi/3.25)
    cairo_set_font_size (cr, 20)
    draw_text_by_right({x = 2, y = 80}, letter)

    ----------------------------
    cairo_restore(cr)

    return {w = 100*scale_factor[1], h = 100*scale_factor[2]}
end


-------------------------------------------------------------------------------
----------------------------support functions----------------------------------
-------------------------------------------------------------------------------

-------------------------------------------------------------------------------
--                 converts color in hexa to decimal
-------------------------------------------------------------------------------

function rgb_to_r_g_b(colour, alpha)
    return ((colour / 0x10000) % 0x100) / 255., ((colour / 0x100) % 0x100) / 255., (colour % 0x100) / 255., alpha
end

-------------------------------------------------------------------------------
--                          make copy of table
-------------------------------------------------------------------------------

function table_copy(t)
  local new_t = {}
  for k,v in pairs(t) do new_t[k] = v end
  return new_t
end

-------------------------------------------------------------------------------
--              converts conky disk i/o measure to kilobytes
-------------------------------------------------------------------------------

function convert_to_k(value)

    local res = string.gsub(value, '%a', '')

    if string.match(value, "KiB") then
        return res*1000
    elseif string.match(value, "MiB") then
        return res*1000000
    else
        return 0
    end

end

-------------------------------------------------------------------------------
--                split text and digits in conky measure
-------------------------------------------------------------------------------

function split_text(value)
    return string.match(value, "[%d%.]+"), string.match(value, "%a+")
end

-------------------------------------------------------------------------------
--                        get CLI command output
-------------------------------------------------------------------------------

function read_CLI(command)
    local file = io.popen(command)
    local output = file:read("*a")
    file:close()
    return output
end

-------------------------------------------------------------------------------
--                          cut text length
-------------------------------------------------------------------------------

function cut_text(text, width)

        cairo_text_extents(cr, "...", extents)
        local dot_length = extents.width

        cairo_text_extents(cr, text, extents)

        if extents.width > width then
            while extents.width + dot_length > width do
                text = string.sub(text, 1, #text-1)
                cairo_text_extents(cr, text, extents)
            end
            return text.."..."
        else
            return text
        end
end

-------------------------------------------------------------------------------
--                         draw text aligned by center
-------------------------------------------------------------------------------

function draw_text_by_center(coord, text)

    cairo_text_extents(cr, text, extents)
    cairo_move_to (cr, coord.x - (extents.width/2 + extents.x_bearing), coord.y - (extents.height/2 + extents.y_bearing))
    cairo_show_text (cr, text)
end

-------------------------------------------------------------------------------
--                         draw text aligned by right
-------------------------------------------------------------------------------

function draw_text_by_right(coord, text)

    cairo_text_extents(cr, text, extents)
    cairo_move_to (cr, coord.x-(extents.width + extents.x_bearing),coord.y)
    cairo_show_text (cr, text)
end

-------------------------------------------------------------------------------
--                       draw text aligned by width
-------------------------------------------------------------------------------

function draw_text_by_wide(coord, width, text)

    cairo_text_extents(cr, text, extents)
    local text_gap = (width - extents.width-extents.x_bearing)/(#text - 1)
    local gap = 0

    for i=1,#text do
        c = string.sub(text, i, i)
        cairo_move_to (cr,coord.x + gap, coord.y)
        cairo_show_text (cr, c)

        cairo_text_extents(cr, c, extents)
        gap = gap + text_gap + extents.width + extents.x_bearing
        -- !!! WALKAROUND for space character width only for font size=24 !!!
        if c == " " then
            gap = gap + 6
        end
    end
end

-------------------------------------------------------------------------------
--                     draw two labels aligned by wide
-------------------------------------------------------------------------------

function draw_double_text(coord, width, text1, text2, second_color)

    cairo_text_extents(cr, text2, extents)
    cairo_move_to (cr, coord.x, coord.y)
    cairo_show_text (cr, text1)
    if second_color ~=nil then
        cairo_set_source_rgba (cr, rgb_to_r_g_b(second_color,1))
    end
    cairo_move_to (cr, coord.x + width-extents.width - extents.x_bearing, coord.y)
    cairo_show_text (cr, text2)
end

-------------------------------------------------------------------------------
--                  draw progress bar with dash style
-------------------------------------------------------------------------------

function draw_dash_bar(coord, bar, progress, width)

    local add_w = bar.height*math.atan(bar.ang)
    local num = math.floor((width - bar.width - add_w)/(bar.gap)) + 1
    local gap = (width - bar.width - add_w)/(num - 1)
    local color_point = math.ceil(progress*num)

    local strt = {0, color_point}
    local fin = {color_point-1, num - 1}
    local color = {main_color, gray_color}

    for k=1,2 do
        cairo_set_source_rgba (cr,rgb_to_r_g_b(color[k],1))

        for i=strt[k], fin[k] do
            cairo_move_to (cr,coord.x+i*gap,coord.y+bar.height)
            cairo_rel_line_to(cr, add_w, -bar.height)
            cairo_rel_line_to(cr, bar.width, 0)
            cairo_rel_line_to(cr, -add_w, bar.height)
            cairo_close_path (cr)
        end
        cairo_fill (cr)
    end
end

-------------------------------------------------------------------------------
--                   vertical corners style indicator
-------------------------------------------------------------------------------

local function draw_corner_graph(coord, corner, progress)

    local color_point = math.ceil(progress*corner.num)
    local start = {0, color_point}
    local fin = {color_point - 1,corner.num - 1}
    local color = {main_color, gray_color}

    for k=1,2 do

        cairo_set_source_rgba (cr,rgb_to_r_g_b(color[k],1))
        for i=start[k], fin[k] do
            cairo_move_to (cr,coord.x,coord.y - i*corner.gap)
            cairo_rel_line_to (cr, corner.width/2, -corner.height)
            cairo_rel_line_to (cr, corner.width/2, corner.height)
            cairo_rel_line_to (cr, -corner.line, 0)
            cairo_rel_line_to (cr, -corner.width/2+corner.line, -corner.height + corner.line)
            cairo_rel_line_to (cr, -corner.width/2+corner.line, corner.height - corner.line)
            cairo_close_path (cr)
        end
        cairo_fill (cr)
    end
end

-------------------------------------------------------------------------------
--                       initializate new graph chart
-------------------------------------------------------------------------------

function new_graph(history_size)

    -- initializate new table for chart
    ----------------------------
    local history_table = {}
    for i=0, history_size-1 do history_table[i] = 0 end

    -- calculate chart table and draw full chart info
    ----------------------------
    return function (coord, chart, value, maxm, text)

        local history_size = #history_table + 1
        local zero_height = 4
        local chart_maxm = maxm

        -- insert current value in table
        ----------------------------
        local cc = updates % history_size
        history_table[cc] = value

        --find maximum in table if it's need
        ----------------------------
        if chart.scale then
            --minimum value to scale
            chart_maxm = 40
            for i,v in ipairs(history_table) do
                if v > chart_maxm then chart_maxm = v end
            end
        end

        -- draw chart
        ----------------------------
        for i=1, history_size do
            local c_bar_h = (chart.bar.height-zero_height) * history_table[(cc+i) % history_size] / chart_maxm
            cairo_move_to (cr,coord.x + chart.bar.width/2 + (i-1)*chart.bar.gap, coord.y)
            cairo_rel_line_to(cr, 0, -zero_height)
            cairo_rel_line_to(cr, 0, -c_bar_h)
        end

        cairo_set_line_width (cr, chart.bar.width)
        cairo_stroke (cr)

        --draw bar
        ----------------------------
        local prog_bar_coord = {
            x = coord.x,
            y = coord.y - chart.bar.height - chart.sign_gap - chart.up_bar.height
        }
        local prog_bar_width = (history_size-1)*chart.bar.gap + chart.bar.width
        local prog = value/maxm

        draw_dash_bar(prog_bar_coord, chart.up_bar, prog, prog_bar_width)

        --draw sign
        ----------------------------
        cairo_set_source_rgba (cr,rgb_to_r_g_b(gray_color,1))

        local sign_coord = {
            x = coord.x-chart.bar.width/2,
            y = prog_bar_coord.y-chart.sign_gap
        }
        draw_double_text(sign_coord, prog_bar_width, text.left, text.right)
    end
end


-------------------------------------------------------------------------------
----------------------------main elements functions----------------------------
-------------------------------------------------------------------------------

-------------------------------------------------------------------------------
--               draw date and system updates available
-------------------------------------------------------------------------------

function draw_date(coord)

    -- get date
    ----------------------------
    local day = os.date("%d")
    local month = string.upper(os.date("%B"))
    local weekday = tonumber(os.date("%u"))
    local year = os.date("%Y")

    -- element settings
    ----------------------------
    local total_width = colomn_width - 10
    local graph_gap = 30
    local line_gap = 10
    local day_gap_table = {8,15,6,8}
    local day_gap = day_gap_table[math.floor(day/10) + 1]

    -- image settings
    ----------------------------
    local image_size = {512,512}
    local scale_factor = {0.08,0.11}

    -- day
    ----------------------------
    cairo_set_source_rgba (cr,rgb_to_r_g_b(gray_color,1))

    cairo_set_font_size (cr, 126)
    cairo_text_extents(cr, day, extents)
    local day_height = extents.height
    local day_width = extents.width + 2

    cairo_move_to (cr, coord.x - day_gap, coord.y + day_height)
    cairo_show_text (cr, day)

    -- month and year sign
    ----------------------------
    local graph_width = total_width - day_width - graph_gap
    cairo_set_font_size (cr, main_font_size)

    local month_coord = {
        x = coord.x + total_width - graph_width,
        y = coord.y + main_text_height
    }
    draw_double_text(month_coord, graph_width, month,year)

    -- system updates
    ----------------------------
    local sign_coord = {
        x = coord.x,
        y = month_coord.y + day_height + line_gap+main_text_height
    }

    -- check updates with interval
    ----------------------------
    if updates % 150 == 0 or updates == 1 then
        -- global var
        sys_upd = string.match(string.match(read_CLI("apt-get --just-print upgrade"), "%d+%supgraded"), "%d+")
    end
    draw_double_text(sign_coord, day_width, sys_upd, "UPDATES")

    sign_coord.x = month_coord.x
    draw_double_text(sign_coord, graph_width, "RARING","RINGTAIL")

    -- weekday indikator
    ----------------------------
    local image_width = image_size[1]*scale_factor[1]
    local image_gap = (graph_width - image_width)/6
    local graph_gap_v = day_height - image_size[2]*scale_factor[2] + 3

    for i=0, 6 do
        local color = i+1 == weekday and main_color or gray_color
        cairo_set_source_rgba (cr,rgb_to_r_g_b(color, 1))

        local image_coord = {
            x = month_coord.x + i*image_gap - 3,
            y = coord.y + graph_gap_v
        }
        draw_feather (image_coord, scale_factor)
    end

    -- full height
    ----------------------------
    return line_gap + day_height + 2*main_text_height

end

-------------------------------------------------------------------------------
--                     draw cpu ram swap indicators
-------------------------------------------------------------------------------

function draw_cpu(coord)

    -- element settings
    ----------------------------
    local total_width = colomn_width - 10
    local first_line_gap = 25
    local line_gap = 40
    ----------------------------
    local bar = table_copy(main_bar)

    -- monitor settings
    ----------------------------
    local perc_command = {"${memperc}","${swapperc}"}
    local command = {"${mem}","${swap}"}

    -- cpu graph settings
    ----------------------------
    local corner = table_copy(main_corner)
    local graph_height = (corner.num-1)*corner.gap+corner.height
    local graph_place_gap = (total_width-corner.width)/7

    -- sign and full bar size
    ----------------------------
    local sign_width = corner.width + graph_place_gap
    local bar_graph_width = total_width - 2*graph_place_gap

    -- start level will show while several first conky updates
    ----------------------------
    local prog = 0

    --cpu indicators
    ----------------------------
    for i=1,8 do
        local cpu_us = tonumber(conky_parse("${cpu cpu"..i.."}"))
        if cpu_us ~= nil then prog = cpu_us/100 end

        graph_coord = {
            x = coord.x + (i-1)*graph_place_gap,
            y = coord.y + graph_height
        }
        draw_corner_graph(graph_coord, corner, prog)
    end

    -- ram and swap indicator
    ----------------------------
    for i=1,2 do
        local mem_perc = tonumber(conky_parse(perc_command[i]))
        local mem = string.gsub(conky_parse(command[i]), " ", "")

        if mem == "0B" or mem == nil then
            mem = "0.00MiB"
            prog = 0
        else
            prog = mem_perc/100
        end

        local bar_coord = {
            x = coord.x,
            y = coord.y + graph_height + first_line_gap + (i-1)*line_gap
        }
        draw_dash_bar(bar_coord, bar, prog, bar_graph_width)

        local sign_coord = {
            x = coord.x + total_width-sign_width,
            y = bar_coord.y + bar.height
        }
        draw_double_text(sign_coord, sign_width, split_text(mem))
    end

    -- full height
    ----------------------------
    return graph_height+first_line_gap+line_gap+main_text_height

end

-------------------------------------------------------------------------------
--                                draw disk usage
-------------------------------------------------------------------------------

function draw_disk(coord)

    -- element settings
    local total_width = colomn_width - 10
    local sign_width = 75
    local bar_graph_width = colomn_width - sign_width - 30
    local line_gap = 40
    ----------------------------
    local bar = table_copy(main_bar)

    --disks settings
    ----------------------------
    local disks = {"/", "/home", "/opt", "/mnt/media"}
    local labels = {"ROOT", "HOME", "OPT", "MEDIA"}

    --disks indicators
    ----------------------------
    local bar_coord = {
        x = coord.x + total_width - bar_graph_width,
        y = coord.y
    }

    for i=1,4 do

        -- get disks usage
        ----------------------------
        local disk_us_perc = tonumber(conky_parse("${fs_used_perc "..disks[i].."}"))
        local prog = disk_us_perc/100

        -- draw disk usage chart
        ----------------------------
        draw_dash_bar(bar_coord, bar, prog, bar_graph_width)

        cairo_move_to (cr, coord.x, bar_coord.y+bar.height)
        cairo_show_text (cr, labels[i])
        --draw_text_by_wide({x=coord.x,y=bar_coord.y+bar.height}, sign_width, labels[i])

        bar_coord.y = bar_coord.y + line_gap
    end

    -- full height
    ----------------------------
    return 3*line_gap + main_text_height

end

-------------------------------------------------------------------------------
--                 draw history chart for disk activity
-------------------------------------------------------------------------------

function draw_disk_charts(coord)

    -- element settings
    ----------------------------
    local total_width = colomn_width - 10
    local chart = {
        bar = table_copy(main_chart_bar),
        up_bar = table_copy(main_up_bar),
        scale = true,
        sign_gap = 8
    }
    ----------------------------
    local between_charts_gap = 15
    local between_charts_gap_vert = 20
    local chart_height = chart.bar.height+chart.sign_gap*2+chart.up_bar.height+main_text_height
    local val = 0

    -- width tettings
    ----------------------------
    chart.width = (total_width - between_charts_gap_vert)/2
    local chart_size = math.floor((chart.width - 2*chart.bar.width)/(chart.bar.gap))+1
    chart.bar.gap = (chart.width-2*chart.bar.width)/(chart_size-1)

    ----------------------------
    local command = {}
    local label = {}
    local maxm = {}

    --ssd chart settings
    ----------------------------
    command[1] = {"${diskio_read /dev/sdb}","${diskio_write /dev/sdb}"}
    label[1] = "SSD"
    maxm[1] = {400000000,400000000}

    --hdd chart settings
    ----------------------------
    command[2] = {"${diskio_read /dev/sdc}","${diskio_write /dev/sdc}"}
    label[2] = "HDD"
    maxm[2] = {125000000,125000000}

    --initializate standalone function for each chart
    ----------------------------
    if updates == 1 then
        disk_graph = {}
        for i=1, 4 do disk_graph[i] = new_graph(chart_size) end
    end

    -- draw charts and signs
    ----------------------------
    for i=1, 2 do
        for j=1, 2 do

            --get current value
            ----------------------------
            local value = conky_parse(command[i][j])
            local val = tonumber(convert_to_k(value))
            if val > maxm[i][j] then val = maxm[i][j] end

            -- draw chart
            ----------------------------
            cairo_set_source_rgba (cr,rgb_to_r_g_b(gray_color,1))

            local chart_coord = {
                x = coord.x + (i-1)*(chart.width + between_charts_gap_vert),
                y = coord.y + j*chart_height + between_charts_gap*(j-1)
            }
            local chart_text = {
                left = label[i],
                right = string.gsub(value, " ", "")
            }

            disk_graph[j+2*(i-1)](chart_coord, chart, val, maxm[i][j], chart_text)
        end
    end

    -- full height
    ----------------------------
    return 2*chart_height + between_charts_gap

end

-------------------------------------------------------------------------------
--              draw history chart for network activity
-------------------------------------------------------------------------------

function draw_net_charts(coord)

    -- element settings
    ----------------------------
    local total_width = colomn_width - 10
    local chart = {
        bar = table_copy(main_chart_bar),
        up_bar = table_copy(main_up_bar),
        scale = false,
        sign_gap = 8
    }
    ----------------------------
    local between_charts_gap = 15
    local chart_height = chart.bar.height+chart.sign_gap*2+chart.up_bar.height+main_text_height
    local val = 0

    --net chart settings
    ----------------------------
    local command = {"${upspeedf wlan0}","${upspeed wlan0}","${downspeedf wlan0}","${downspeed wlan0}"}
    local label = "NET"
    local maxm = {80,650}

    -- image settings
    ----------------------------
    local scale_factor = {0.85,0.75}
    local letter = {"UP","DN"}

    --draw image
    ----------------------------
    cairo_set_source_rgba (cr,rgb_to_r_g_b(gray_color,1))
    local total_height = chart_height*2+between_charts_gap
    local image_coord = {
        x = coord.x - 5,
        y = coord.y
    }
    local image_size = draw_envelope(image_coord, scale_factor, letter[1])
    image_coord.y = coord.y + total_height - image_size.h + 2
    draw_envelope(image_coord, scale_factor, letter[2])

    -- width tettings
    ----------------------------
    chart.width = total_width - image_size.w - 20
    local chart_size = math.floor((chart.width - 2*chart.bar.width)/(chart.bar.gap)) + 1
    chart.bar.gap = (chart.width - 2*chart.bar.width)/(chart_size - 1)

    --initializate standalone function for each chart
    ----------------------------
    if updates == 1 then
        net_graph = {}
        for i=1, 2 do net_graph[i] = new_graph(chart_size) end
    end

    -- draw charts and signs
    ----------------------------
    for j=1, 2 do

        --get current value
        ----------------------------
        val = tonumber(conky_parse(command[2*j-1]))
        if val > maxm[j] then val = maxm[j] end

        -- draw chart
        ----------------------------
        local chart_coord = {
            x = coord.x + total_width - chart.width,
            y = coord.y + chart_height*j + between_charts_gap*(j-1)
        }
        local chart_text = {
            left = label,
            right = string.gsub(conky_parse(command[j*2]), " ","")
        }

        net_graph[j](chart_coord, chart, val, maxm[j], chart_text)
    end

    -- full height
    ----------------------------
    return total_height

end

-------------------------------------------------------------------------------
--                            draw torrents graph
-------------------------------------------------------------------------------

function draw_torrent(coord)

    -- !!! Transmission should have at least one torrent !!!
    -- I'm too lazy to make proper exception for blank torrent list

    -- element settings
    ----------------------------
    local line_gap = 40
    local first_line_gap = 25
    local total_width = colomn_width - 10
    local label_width = 70
    ----------------------------
    local bar = table_copy(main_bar)

    -- progress indicator settings
    ----------------------------
    local corner = table_copy(main_corner)
    local graph_num = 8
    local graph_place_gap = (total_width-corner.width)/(graph_num-1)
    local graph_height = (corner.num-1)*corner.gap+corner.height

    -- sign and full bar size
    ----------------------------
    local sign_width = corner.width + graph_place_gap
    local bar_graph_width = total_width - 2*graph_place_gap

    -- speed limits in kilobyte
    ----------------------------
    local download_max = 600
    local upload_max = 55

    -- check if transmission started
    ----------------------------
    if read_CLI("pidof -x transmission-gtk") ~= "" then

        -- get torrents list
        ----------------------------
        local output = read_CLI("transmission-remote -l")
        local status_pos = string.find(output, "Status")
        output = string.gsub(output,"Up & Down","Downloading")

        local torrent_list = {}
        local last_line = ""
        local seed_num = 0
        local dnld_num = 0

        for line in string.gmatch(output, "[^\n]+") do

            last_line = line
            torrent_list[#torrent_list + 1] =  {
                prog = string.match(line, "%d+%%"),
                status = string.match(string.sub(line, status_pos), "%a+")
            }

            if torrent_list[#torrent_list].status == "Seeding" then
                seed_num = seed_num + 1
            elseif torrent_list[#torrent_list].status == "Downloading" then
                dnld_num = dnld_num + 1
            end
        end

        --get total speed value from last line
        ----------------------------
        local sum = {}
        for pat in string.gmatch(last_line,"[%d+%.]+") do
            sum[#sum + 1] = pat
        end

        --sort torrent
        ----------------------------
        local function sort_torrent(a,b)
            return a.status == "Downloading" and b.status ~= "Downloading" or a.status =="Stopped" and b.status ~= "Stopped" and b.status ~= "Downloading"
        end

        table.remove(torrent_list, 1)
        table.remove(torrent_list, #torrent_list)
        table.sort(torrent_list, sort_torrent)

        --check torrent num
        ----------------------------
        if graph_num > #torrent_list then graph_num = #torrent_list end

        --draw torrents progress indicators
        ----------------------------
        cairo_set_source_rgba (cr,rgb_to_r_g_b(gray_color,1))

        for i=1, graph_num do
            local val = string.match(torrent_list[i].prog,"%d+")
            local prog = val/100
            local graph_coord = {
                x = coord.x + (i-1)*graph_place_gap,
                y = coord.y + graph_height
            }
            draw_corner_graph(graph_coord, corner, prog)
        end

        --draw active torrents num and speed
        ----------------------------
        local bar_prog = {
            sum[2]/upload_max,
            sum[3]/download_max
        }
        local label = {"SEED", "DNLD"}
        local nums = {seed_num, dnld_num}

        for i=1, 2 do

            --torrent speed bar
            ----------------------------
            if bar_prog[i] > 1 then bar_prog[i] = 1 end

            local bar_coord = {
                x = coord.x,
                y = coord.y+graph_height+first_line_gap+(i-1)*line_gap
            }
            draw_dash_bar(bar_coord, bar, bar_prog[i], bar_graph_width)

            --labels
            ----------------------------
            local sign_coord = {
                x = coord.x + total_width - sign_width,
                y = bar_coord.y+bar.height
            }
            draw_text_by_wide(sign_coord, label_width, label[i])

            -- active torrent num
            ----------------------------
            sign_coord = {
                x = coord.x+total_width,
                y = bar_coord.y+bar.height
            }
            draw_text_by_right(sign_coord, nums[i])
        end

    else
        --draw message if transmission not running
        ----------------------------
        cairo_set_source_rgba (cr, rgb_to_r_g_b(main_color,1))
        cairo_set_font_size (cr, 32)

        local label_coord = {
            x = coord.x + (total_width)/2,
            y = coord.y + graph_height/2
        }
        draw_text_by_center(label_coord, "TRANSMISSION")
        label_coord.y = label_coord.y + (first_line_gap + line_gap + main_text_height + graph_height)/2
        draw_text_by_center(label_coord, "IS NOT RUNNING")

        cairo_set_font_size (cr, main_font_size)
    end

    -- full height
    ----------------------------
    return graph_height+first_line_gap+line_gap+main_text_height

end

-------------------------------------------------------------------------------
--                          draw temperature graph
-------------------------------------------------------------------------------

function draw_temp(coord)

    -- element settings
    ----------------------------
    local total_width = colomn_width - 10
    local label_width = 55
    local bar = table_copy(main_bar)
    local line_gap = 40
    local bar_gap = 75
    local bar_graph_width = total_width - bar_gap - 60

    --temperature settings
    ----------------------------
    local labels = {"CPU","HDD","GPU"}
    local temp_text = {"","","-- - "}
    local temp = {0,0,0}
    local k = {100,60,100}
    local alert_temp = {75,42,80}

    -- get cpu temperature
    ----------------------------
    temp[1] = tonumber(conky_parse("${acpitemp}"))

    --get hdd temperature
    ----------------------------
    temp[2] = tonumber(read_CLI("user-hddtemp /dev/sdc | cut -c35-36"))

    -- get nvidia card temperature if it's acrive
    ----------------------------
    local nvidia_on = string.find(read_CLI("cat /proc/acpi/bbswitch"), "ON")
    if nvidia_on ~= nil then
        temp[3] = tonumber(read_CLI("optirun nvidia-settings -c :8 -q gpucoretemp -t"))
    end

    -- draw temperature graph
    ----------------------------
    local bar_coord = {
        x = coord.x + bar_gap,
        y = coord.y
    }

    for i=1,3 do
        -- temperature bar
        ----------------------------
        local prog = temp[i]/k[i]
        draw_dash_bar(bar_coord, bar, prog, bar_graph_width)

        -- temperature labels
        ----------------------------
        local label_coord = {
            x = coord.x,
            y = bar_coord.y+bar.height
        }
        draw_text_by_wide(label_coord, label_width, labels[i])

        -- temperature value
        ----------------------------
        if temp[i] ~= 0 then temp_text[i] = temp[i].."°" end
        local temp_color = temp[i] > alert_temp[i] and main_color or gray_color
        local value_coord = {
            x = coord.x + total_width,
            y = bar_coord.y + bar.height
        }

        cairo_set_source_rgba (cr,rgb_to_r_g_b(temp_color,1))
        draw_text_by_right(value_coord, temp_text[i])

        ----------------------------
        bar_coord.y = bar_coord.y+line_gap
    end

    -- full height
    ----------------------------
    return 2*line_gap+main_text_height
end

-------------------------------------------------------------------------------
--                          draw top process
-------------------------------------------------------------------------------

function draw_top(coord)

    -- element settings
    ----------------------------
    local line_gap = 35
    local line_num = 5
    local upd_per_top = 4

    -- top settings
    ----------------------------
    local command = {
        {"${top name ", "${top cpu "};
        {"${top_mem name ", "${top_mem mem "}
    }
    local alert_perc = {15,20}

    -- image settings
    ----------------------------
    local image_colors = {gray_color, main_color}

    -- switch between cpu and ram top
    ----------------------------
    local k = math.floor((updates % (2*upd_per_top)) / upd_per_top) + 1

    -- image
    ----------------------------
    local total_height = (line_num - 1)*line_gap + main_text_height

    local image_coord = {
        x = coord.x,
        y = coord.y
    }
    local image_size = draw_stamp(image_coord, image_colors[k % 2 + 1])

    image_coord.y = image_coord.y+total_height-image_size.h
    draw_stamp(image_coord, image_colors[(k+1) % 2 + 1])

    -- width settings
    ----------------------------
    local total_width = colomn_width - 10
    local image_gap = image_size.w + 25
    local line_width = total_width - image_gap
    local name_width = line_width - 80

    -- top process
    ----------------------------
    for i = 1, line_num do

        -- get top info
        ----------------------------
        local proc_name = string.upper(conky_parse(command[k][1]..i.."}"))
        local proc_perc = conky_parse(command[k][2]..i.."}")

        -- print info
        ----------------------------
        proc_name = cut_text(proc_name,name_width)

        if updates > 5 then
            local text_color = tonumber(proc_perc) >= alert_perc[k] and main_color or gray_color
            cairo_set_source_rgba (cr,rgb_to_r_g_b(text_color,1))

            local line_coord = {
                x = coord.x + image_gap,
                y = coord.y + (i-1)*line_gap+main_text_height
            }
            draw_double_text(line_coord, line_width, proc_name, proc_perc)
        end
    end

    -- full height
    ----------------------------
    return total_height

end

-------------------------------------------------------------------------------
---------------------------------main script-----------------------------------
-------------------------------------------------------------------------------

function conky_main()

    ----------------------------
    -- initialization cairo
    ----------------------------
    if conky_window == nil then return end
    local cs = cairo_xlib_surface_create(conky_window.display, conky_window.drawable, conky_window.visual, conky_window.width, conky_window.height)
    cr = cairo_create(cs)

    -- some cairo settings
    ----------------------------
    cairo_set_font_size (cr, main_font_size)
    cairo_select_font_face (cr, font, font_slant, font_face)

    cairo_text_extents(cr, "TEXT", extents)
    main_text_height = extents.height
    main_bar.height = extents.height

    cairo_set_line_width (cr, line_width)
    cairo_set_line_cap (cr, line_cap)
    cairo_set_fill_rule (cr, fill_rule)

    ----------------------------
    --main elements
    ----------------------------

    --update counter
    ----------------------------
    updates = tonumber(conky_parse('${updates}'))

    -- element settings
    ----------------------------
    local el_height = 0
    --local el_height_sum = {0,0}
    local draw_element = {}
    local el_coord = {
        x = pcmt.border_gap+5,
        y = pcmt.border_gap
    }

    -- element placement in two colomns
    ----------------------------
    local strt = {1, 5}
    local fin = {4, 8}

    draw_element[1] = draw_date
    draw_element[2] = draw_cpu
    draw_element[3] = draw_top
    draw_element[4] = draw_disk
    draw_element[5] = draw_torrent
    draw_element[6] = draw_net_charts
    draw_element[7] = draw_temp
    draw_element[8] = draw_disk_charts

    -- draw elements
    ----------------------------
    for k = 1,2 do
        for i = strt[k], fin[k] do
            el_height = draw_element[i](el_coord)
            el_coord.y = el_coord.y + el_height + pcmt.vertical_gap[k]
            --el_height_sum[k] = el_height_sum[k] + el_height
        end
        el_coord.x = 1920 - colomn_width - pcmt.border_gap + 5
        el_coord.y = pcmt.border_gap
    end

    ----------------------------
    --temporary debag elements
    ----------------------------

    -- calculate vertical gaps between elements
    ----------------------------
    --print((1030 - el_height_sum[1] - 2*pcmt.border_gap)/3, (1030 - el_height_sum[2] - 2*pcmt.border_gap)/3)
    --print(conky_window.width)

    -- placemend grid
    ----------------------------
--[[
    cairo_set_source_rgba (cr,rgb_to_r_g_b(white_color,1))
    cairo_set_line_width (cr, 1)

    cairo_move_to (cr, pcmt.border_gap, 0)
    cairo_rel_line_to(cr, 0, conky_window.height)
    cairo_move_to (cr, pcmt.border_gap + colomn_width, 0)
    cairo_rel_line_to(cr, 0, conky_window.height)
    cairo_move_to (cr, conky_window.width - pcmt.border_gap, 0)
    cairo_rel_line_to(cr, 0, conky_window.height)
    cairo_move_to (cr, conky_window.width - pcmt.border_gap - colomn_width, 0)
    cairo_rel_line_to(cr, 0, conky_window.height)
    ----------------------------
    cairo_move_to (cr, 0, pcmt.border_gap)
    cairo_rel_line_to(cr, conky_window.width, 0)
    cairo_move_to (cr, 0, conky_window.height)
    cairo_rel_line_to(cr, conky_window.width, 0)
    cairo_move_to (cr, 0, conky_window.height - pcmt.border_gap)
    cairo_rel_line_to(cr, conky_window.width, 0)

    cairo_stroke (cr)
-- ]]
    ----------------------------
    -- destroy cairo
    ----------------------------
    cairo_destroy(cr)
    cairo_surface_destroy(cs)
    cr=nil
end