path: root/share/extensions/nicechart.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#  nicechart.py
#
#  Copyright 2011-2016
#  
#  Christoph Sterz 
#  Florian Weber
#  Maren Hachmann
#  
#  This program is free software; you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation; either version 3 of the License, or
#  (at your option) any later version.
#  
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#  
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software
#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
#  MA 02110-1301, USA.
#  

# TODO / Ideas: 
# allow negative values for bar charts
# show values for stacked bar charts
# don't create a new layer for each chart, but a normal group
# correct bar height for stacked bars (it's only half as high as it should be, double)
# adjust position of heading
# use aliasing workaround for stacked bars (e.g. let the rectangles overlap)

# Example CSV file contents:
'''
Month;1978;1979;1980;1981
January;2;1,3;0.1;2.3
February;6.5;2.4;1.2;6.1
March;7.4;6.7;7.9;4.7
April;7.7;6.4;8.2;8.9
May;10.9;11.7;18.7;11.1
June;12.6;14.2;14.7;14.7
July;16.5;15.5;17.5;15.1
August;15.9;15.4;14.6;16.6
September;14;14.5;13.2;15.3
October;11.9;13.9;11.5;9.2
November;6.7;8.5;7;6.6
December;6.4;2.2;6.3;3.5
'''
# The extension creates one chart for a single value column in one go,
# e.g. chart all temperatures for all months of the year 1978 into one chart.
# (for this, select column 0 for labels and column 1 for values).
# "1978" etc. can be used as heading (Need not be numeric. If not used delete the heading line.)
# Month names can be used as labels
# Values can be shown, in addition to labels (doesn't work with stacked bar charts)
# Values can contain commas as decimal separator, as long as delimiter isn't comma
# Negative values are not yet supported.


import re
import sys
import math
import inkex

from simplestyle import *

#www.sapdesignguild.org/goodies/diagram_guidelines/color_palettes.html#mss
COLOUR_TABLE = {
  "red": ["#460101", "#980101", "#d40000", "#f44800", "#fb8b00", "#eec73e", "#d9bb7a", "#fdd99b"],
  "blue": ["#000442", "#0F1781", "#252FB7", "#3A45E1", "#656DDE", "#8A91EC"],
  "gray": ["#222222", "#444444", "#666666", "#888888", "#aaaaaa", "#cccccc", "#eeeeee"],
  "contrast": ["#0000FF", "#FF0000", "#00FF00", "#CF9100", "#FF00FF", "#00FFFF"],
  "sap": ["#f8d753", "#5c9746", "#3e75a7", "#7a653e", "#e1662a", "#74796f", "#c4384f",
          "#fff8a3", "#a9cc8f", "#b2c8d9", "#bea37a", "#f3aa79", "#b5b5a9", "#e6a5a5"]
}

def get_color_scheme(name="default"):
    return COLOUR_TABLE.get(name.lower(), COLOUR_TABLE['red'])


class NiceChart(inkex.Effect):
    """
    Inkscape extension that can draw pie charts and bar charts 
    (stacked, single, horizontally or vertically) 
    with optional drop shadow, from a csv file or from pasted text
    """
    
    def __init__(self):
        """
        Constructor.
        Defines the "--what" option of a script.
        """
        # Call the base class constructor.
        inkex.Effect.__init__(self)
        
        # Define string option "--what" with "-w" shortcut and default chart values.
        self.OptionParser.add_option('-w', '--what', action='store',
              type='string', dest='what', default='22,11,67',
              help='Chart Values')
            
        # Define string option "--type" with "-t" shortcut.
        self.OptionParser.add_option("-t", "--type", action="store",
              type="string", dest="type", default='',
              help="Chart Type")
        
        # Define bool option "--blur" with "-b" shortcut.
        self.OptionParser.add_option("-b", "--blur", action="store",
              type="inkbool", dest="blur", default='True',
              help="Blur Type")
        
        # Define string option "--file" with "-f" shortcut.
        self.OptionParser.add_option("-f", "--filename", action="store",
              type="string", dest="filename", default='',
              help="Name of File")
        
        # Define string option "--input_type" with "-i" shortcut.
        self.OptionParser.add_option("-i", "--input_type", action="store",
              type="string", dest="input_type", default='file',
              help="Chart Type")
        
        # Define string option "--delimiter" with "-d" shortcut.
        self.OptionParser.add_option("-d", "--delimiter", action="store",
              type="string", dest="csv_delimiter", default=';',
              help="delimiter")
              
        # Define string option "--colors" with "-c" shortcut.
        self.OptionParser.add_option("-c", "--colors", action="store",
              type="string", dest="colors", default='default',
              help="color-scheme")

        # Define string option "--colors_override"
        self.OptionParser.add_option("", "--colors_override", action="store",
              type="string", dest="colors_override", default='',
              help="color-scheme-override")
        

        self.OptionParser.add_option("", "--reverse_colors", action="store",
              type="inkbool", dest="reverse_colors", default='False',
              help="reverse color-scheme")
        
        self.OptionParser.add_option("-k", "--col_key", action="store",
              type="int", dest="col_key", default='0',
              help="column that contains the keys")
        
        
        self.OptionParser.add_option("-v", "--col_val", action="store",
              type="int", dest="col_val", default='1',
              help="column that contains the values")
              
        self.OptionParser.add_option("", "--encoding", action="store",
              type="string", dest="encoding", default='utf-8',
              help="encoding of the CSV file, e.g. utf-8")
        
        self.OptionParser.add_option("", "--headings", action="store",
              type="inkbool", dest="headings", default='False',
              help="the first line of the CSV file consists of headings for the columns")
              
        self.OptionParser.add_option("-r", "--rotate", action="store",
              type="inkbool", dest="rotate", default='False',
              help="Draw barchart horizontally")
            
        self.OptionParser.add_option("-W", "--bar-width", action="store",
            type="int", dest="bar_width", default='10',
            help="width of bars")
        
        self.OptionParser.add_option("-p", "--pie-radius", action="store",
            type="int", dest="pie_radius", default='100',
            help="radius of pie-charts")
            
        self.OptionParser.add_option("-H", "--bar-height", action="store",
            type="int", dest="bar_height", default='100',
            help="height of bars")
            
        self.OptionParser.add_option("-O", "--bar-offset", action="store",
            type="int", dest="bar_offset", default='5',
            help="distance between bars")
            
        self.OptionParser.add_option("", "--stroke-width", action="store",
            type="float", dest="stroke_width", default='1')
            
        self.OptionParser.add_option("-o", "--text-offset", action="store",
            type="int", dest="text_offset", default='5',
            help="distance between bar and descriptions")
        
        self.OptionParser.add_option("", "--heading-offset", action="store",
            type="int", dest="heading_offset", default='50',
            help="distance between chart and chart title")
        
        self.OptionParser.add_option("", "--segment-overlap", action="store",
            type="inkbool", dest="segment_overlap", default='False',
            help="work around aliasing effects by letting pie chart segments overlap")
            
        self.OptionParser.add_option("-F", "--font", action="store",
            type="string", dest="font", default='sans-serif',
            help="font of description")
            
        self.OptionParser.add_option("-S", "--font-size", action="store",
            type="int", dest="font_size", default='10',
            help="font size of description")
        
        self.OptionParser.add_option("-C", "--font-color", action="store",
            type="string", dest="font_color", default='black',
            help="font color of description")
        #Dummy:
        self.OptionParser.add_option("","--input_sections")

        self.OptionParser.add_option("-V", "--show_values", action="store",
            type="inkbool", dest="show_values", default='False',
            help="Show values in chart")
    
    def effect(self):
        """
        Effect behaviour.
        Overrides base class' method and inserts a nice looking chart into SVG document.
        """
        # Get script's "--what" option value and process the data type --- i concess the if term is a little bit of magic
        what = self.options.what
        keys = []
        values = []
        orig_values = []
        keys_present = True
        pie_abs = False
        cnt = 0
        csv_file_name = self.options.filename
        csv_delimiter = self.options.csv_delimiter
        input_type = self.options.input_type
        col_key = self.options.col_key
        col_val = self.options.col_val
        show_values = self.options.show_values
        encoding = self.options.encoding.strip() or 'utf-8'
        headings = self.options.headings
        heading_offset = self.options.heading_offset
        
        if input_type == "\"file\"":
            csv_file = open(csv_file_name, "r")
            
            for linenum, line in enumerate(csv_file):
                value = line.decode(encoding).split(csv_delimiter)
                #make sure that there is at least one value (someone may want to use it as description)
                if len(value) >= 1:
                    # allow to parse headings as strings
                    if linenum == 0 and headings:
                        heading = value[col_val]
                    else:
                        keys.append(value[col_key])
                        # replace comma decimal separator from file by colon, 
                        # to avoid file editing for people whose programs output
                        # values with comma
                        values.append(float(value[col_val].replace(",",".")))
            csv_file.close()
            
        elif input_type == "\"direct_input\"":
            what = re.findall("([A-Z|a-z|0-9]+:[0-9]+\.?[0-9]*)", what)
            for value in what:
                value = value.split(":")
                keys.append(value[0])
                values.append(float(value[1]))

        # warn about negative values (not yet supported)
        for value in values:
            if value < 0:
              inkex.errormsg("Negative values are currently not supported!")
              return

        # Get script's "--type" option value.
        charttype = self.options.type

        if charttype == "pie_abs":
            pie_abs = True
            charttype = "pie"

        # Get access to main SVG document element and get its dimensions.
        svg = self.document.getroot()
        
        # Get the page attibutes:
        width  = self.getUnittouu(svg.get('width'))
        height = self.getUnittouu(svg.attrib['height'])
        
        # Create a new layer.
        layer = inkex.etree.SubElement(svg, 'g')
        layer.set(inkex.addNS('label', 'inkscape'), 'Chart-Layer: %s' % (what))
        layer.set(inkex.addNS('groupmode', 'inkscape'), 'layer')
        
        # Check if a drop shadow should be drawn:
        draw_blur = self.options.blur
        
        if draw_blur:
            # Get defs of Document
            defs = self.xpathSingle('/svg:svg//svg:defs')
            if defs == None:
                defs = inkex.etree.SubElement(self.document.getroot(), inkex.addNS('defs', 'svg'))
            
            # Create new Filter
            filt = inkex.etree.SubElement(defs,inkex.addNS('filter', 'svg'))
            filtId = self.uniqueId('filter')
            self.filtId = 'filter:url(#%s);' % filtId
            for k, v in [('id', filtId), ('height', "3"),
                         ('width', "3"),
                         ('x', '-0.5'), ('y', '-0.5')]:
                filt.set(k, v)
            
            # Append Gaussian Blur to that Filter
            fe = inkex.etree.SubElement(filt, inkex.addNS('feGaussianBlur', 'svg'))
            fe.set('stdDeviation', "1.1")
        
        # Set Default Colors
        self.options.colors_override.strip()
        if len(self.options.colors_override) > 0:
            colors = self.options.colors_override
        else:
            colors = self.options.colors

        if colors[0].isalpha():
            colors = get_color_scheme(colors)
        else:
            colors = re.findall("(#[0-9a-fA-F]{6})", colors)
            #to be sure we create a fallback:
            if len(colors) == 0:
                colors = get_color_scheme()
        
        color_count = len(colors)
        
        if self.options.reverse_colors:
            colors.reverse()
        
        # Those values should be self-explanatory:
        bar_height = self.options.bar_height
        bar_width = self.options.bar_width
        bar_offset = self.options.bar_offset
        # offset of the description in stacked-bar-charts:
        # stacked_bar_text_offset=self.options.stacked_bar_text_offset
        text_offset = self.options.text_offset
        # prevents ugly aliasing effects between pie chart segments by overlapping
        segment_overlap = self.options.segment_overlap
        
        # get font
        font = self.options.font
        font_size = self.options.font_size
        font_color = self.options.font_color
        
        # get rotation
        rotate = self.options.rotate
        
        pie_radius = self.options.pie_radius
        stroke_width = self.options.stroke_width

        if charttype == "bar":
        #########
        ###BAR###
        #########
            
            # iterate all values, use offset to draw the bars in different places
            offset = 0
            color = 0
            
            # Normalize the bars to the largest value
            try:
                value_max = max(values)
            except ValueError:
                value_max = 0.0

            for x in range(len(values)):
                orig_values.append(values[x])
                values[x] = (values[x]/value_max) * bar_height

            # Draw Single bars with their shadows
            for value in values:
                
                # draw drop shadow, if necessary
                if draw_blur:
                    # Create shadow element
                    shadow = inkex.etree.Element(inkex.addNS("rect", "svg"))
                    # Set chart position to center of document. Make it horizontal or vertical
                    if not rotate:
                        shadow.set('x', str(width/2 + offset + 1))
                        shadow.set('y', str(height/2 - int(value) + 1))
                        shadow.set("width", str(bar_width))
                        shadow.set("height", str(int(value)))
                    else:
                        shadow.set('y', str(width/2 + offset + 1))
                        shadow.set('x', str(height/2 + 1))
                        shadow.set("height", str(bar_width))
                        shadow.set("width", str(int(value)))
                        
                    # Set shadow blur (connect to filter object in xml path)
                    shadow.set("style", "filter:url(#filter)")
                
                # Create rectangle element
                rect = inkex.etree.Element(inkex.addNS('rect', 'svg'))
                
                # Set chart position to center of document.
                if not rotate:
                    rect.set('x', str(width/2 + offset))
                    rect.set('y', str(height/2 - int(value)))
                    rect.set("width", str(bar_width))
                    rect.set("height", str(int(value)))
                else:
                    rect.set('y', str(width/2 + offset))
                    rect.set('x', str(height/2))
                    rect.set("height", str(bar_width))
                    rect.set("width", str(int(value)))
                    
                rect.set("style", "fill:" + colors[color % color_count])
                
                # If keys are given, create text elements
                if keys_present:
                    text = inkex.etree.Element(inkex.addNS('text', 'svg'))
                    if not rotate: #=vertical
                        text.set("transform", "matrix(0,-1,1,0,0,0)")
                        #y after rotation:
                        text.set("x", "-" + str(height/2 + text_offset)) 
                        #x after rotation:
                        text.set("y", str(width/2 + offset + bar_width/2 + font_size/3))
                    else: #=horizontal
                        text.set("y", str(width/2 + offset + bar_width/2 + font_size/3))
                        text.set("x", str(height/2 - text_offset))
                    
                    text.set("style", "font-size:" + str(font_size)\
                           + "px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:"\
                           + font + ";-inkscape-font-specification:Bitstream Charter;text-align:end;text-anchor:end;fill:"\
                           + font_color)

                    text.text = keys[cnt]

                # Increase Offset and Color
                #offset=offset+bar_width+bar_offset
                color = (color + 1) % 8
                # Connect elements together.
                if draw_blur:
                    layer.append(shadow)
                layer.append(rect)
                if keys_present:
                    layer.append(text)
                    
                if show_values:
                    vtext = inkex.etree.Element(inkex.addNS('text', 'svg'))
                    if not rotate: #=vertical
                        vtext.set("transform", "matrix(0,-1,1,0,0,0)")
                        #y after rotation:
                        vtext.set("x", "-"+str(height/2+text_offset-value-text_offset-text_offset)) 
                        #x after rotation:
                        vtext.set("y", str(width/2+offset+bar_width/2+font_size/3))
                    else: #=horizontal
                        vtext.set("y", str(width/2+offset+bar_width/2+font_size/3))
                        vtext.set("x", str(height/2-text_offset+value+text_offset+text_offset))

                    vtext.set("style", "font-size:"+str(font_size)\
                            + "px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:"\
                            + font + ";-inkscape-font-specification:Bitstream Charter;text-align:start;text-anchor:start;fill:"\
                            + font_color)

                    vtext.text = str(int(orig_values[cnt]))
                    layer.append(vtext)
                
                cnt = cnt+1
                offset = offset + bar_width + bar_offset
            
            # set x position for heading line
            if not rotate:
                heading_x = width/2 # TODO: adjust
            else:
                heading_x = width/2 # TODO: adjust

                
        elif charttype == "pie":
        #########
        ###PIE###
        #########
            # Iterate all values to draw the different slices
            color = 0
            
            # Create the shadow first (if it should be created):
            if draw_blur:
                shadow = inkex.etree.Element(inkex.addNS("circle", "svg"))
                shadow.set('cx', str(width/2))
                shadow.set('cy', str(height/2))
                shadow.set('r', str(pie_radius))
                shadow.set("style", "filter:url(#filter);fill:#000000")
                layer.append(shadow)
            
            
            # Add a grey background circle with a light stroke
            background = inkex.etree.Element(inkex.addNS("circle", "svg"))
            background.set("cx", str(width/2))
            background.set("cy", str(height/2))
            background.set("r", str(pie_radius))
            background.set("style", "stroke:#ececec;fill:#f9f9f9")
            layer.append(background)
            
            #create value sum in order to divide the slices
            try:
                valuesum = sum(values)
                
            except ValueError:
                valuesum = 0

            if pie_abs:
                valuesum = 100

            num_values = len(values)

            # Set an offsetangle
            offset = 0
            
            # Draw single slices
            for i in range(num_values):
                value = values[i]
                # Calculate the PI-angles for start and end
                angle = (2*3.141592) / valuesum * float(value)
                start = offset
                end = offset + angle
                
                # proper overlapping
                if segment_overlap:
                    if i != num_values-1:
                        end += 0.09 # add a 5° overlap
                    if i == 0:
                        start -= 0.09 # let the first element overlap into the other direction

                #then add the slice
                pieslice = inkex.etree.Element(inkex.addNS("path", "svg"))
                pieslice.set(inkex.addNS('type', 'sodipodi'), 'arc')
                pieslice.set(inkex.addNS('cx', 'sodipodi'), str(width/2))
                pieslice.set(inkex.addNS('cy', 'sodipodi'), str(height/2))
                pieslice.set(inkex.addNS('rx', 'sodipodi'), str(pie_radius))
                pieslice.set(inkex.addNS('ry', 'sodipodi'), str(pie_radius))
                pieslice.set(inkex.addNS('start', 'sodipodi'), str(start))
                pieslice.set(inkex.addNS('end', 'sodipodi'), str(end))
                pieslice.set("style", "fill:"+ colors[color % color_count] + ";stroke:none;fill-opacity:1")
                
                #If text is given, draw short paths and add the text
                if keys_present:
                    path = inkex.etree.Element(inkex.addNS("path", "svg"))
                    path.set("d", "m " 
                                + str((width/2) + pie_radius * math.cos(angle/2 + offset)) + "," 
                                + str((height/2) + pie_radius * math.sin(angle/2 + offset)) + " " 
                                + str((text_offset - 2) * math.cos(angle/2 + offset)) + "," 
                                + str((text_offset - 2) * math.sin(angle/2 + offset)))
                    
                    path.set("style", "fill:none;stroke:" 
                                    + font_color + ";stroke-width:" + str(stroke_width) 
                                    + "px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1")
                    layer.append(path)
                    text = inkex.etree.Element(inkex.addNS('text', 'svg'))
                    text.set("x", str((width/2) + (pie_radius + text_offset) * math.cos(angle/2 + offset)))
                    text.set("y", str((height/2) + (pie_radius + text_offset) * math.sin(angle/2 + offset) + font_size/3))
                    textstyle = "font-size:" + str(font_size) \
                                + "px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:" \
                                + font + ";-inkscape-font-specification:Bitstream Charter;fill:" + font_color 
                    # check if it is right or left of the Pie
                    if math.cos(angle/2 + offset) > 0:
                        text.set("style", textstyle)
                    else:
                        text.set("style", textstyle + ";text-align:end;text-anchor:end")
                    text.text = keys[cnt]
                    if show_values:
                        text.text = text.text + "(" + str(values[cnt])

                        if pie_abs:
                            text.text = text.text + " %"
                        
                        text.text = text.text + ")"
                    
                    cnt = cnt + 1
                    layer.append(text)
                
                # increase the rotation-offset and the colorcycle-position
                offset = offset + angle
                color = (color + 1) % 8
                
                # append the objects to the extension-layer
                layer.append(pieslice)
                
            # set x position for heading line
            heading_x = width/2 - pie_radius # TODO: adjust
                
        elif charttype == "stbar":
        #################
        ###STACKED BAR###
        #################
            # Iterate over all values to draw the different slices
            color = 0
            
            #create value sum in order to divide the bars
            try:
                valuesum = sum(values)
            except ValueError:
                valuesum = 0.0

            for value in values:
                valuesum = valuesum + float(value)
            
            # Init offset
            offset = 0
            
            if draw_blur:
                # Create rectangle element
                shadow = inkex.etree.Element(inkex.addNS("rect", "svg"))
                # Set chart position to center of document.
                if not rotate:
                    shadow.set('x', str(width/2))
                    shadow.set('y', str(height/2 - bar_height/2)) 
                else:
                    shadow.set('x', str(width/2))
                    shadow.set('y', str(height/2))
                # Set rectangle properties
                if not rotate:
                    shadow.set("width", str(bar_width))
                    shadow.set("height", str(bar_height/2))
                else:
                    shadow.set("width",str(bar_height/2))
                    shadow.set("height", str(bar_width))
                # Set shadow blur (connect to filter object in xml path)
                shadow.set("style", "filter:url(#filter)")
                layer.append(shadow)
            
            i = 0
            # Draw Single bars
            for value in values:
                
                # Calculate the individual heights normalized on 100units
                normedvalue = (bar_height / valuesum) * float(value)
                
                # Create rectangle element
                rect = inkex.etree.Element(inkex.addNS('rect', 'svg'))
                
                # Set chart position to center of document.
                if not rotate:
                    rect.set('x', str(width / 2 ))
                    rect.set('y', str(height / 2 - offset - normedvalue))
                else:
                    rect.set('x', str(width / 2 + offset ))
                    rect.set('y', str(height / 2 ))
                # Set rectangle properties
                if not rotate:
                    rect.set("width", str(bar_width))
                    rect.set("height", str(normedvalue))
                else:
                    rect.set("height", str(bar_width))
                    rect.set("width", str(normedvalue))
                rect.set("style", "fill:" + colors[color % color_count])
                
                #If text is given, draw short paths and add the text
                # TODO: apply overlap workaround for visible gaps in between
                if keys_present:
                    if not rotate:
                        path = inkex.etree.Element(inkex.addNS("path", "svg"))
                        path.set("d","m " + str((width + bar_width)/2) + ","
                                    + str(height/2 - offset - (normedvalue / 2)) + " "
                                    + str(bar_width/2 + text_offset) + ",0")
                        path.set("style", "fill:none;stroke:" + font_color
                                        + ";stroke-width:" + str(stroke_width)
                                        + "px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1")
                        layer.append(path)
                        text = inkex.etree.Element(inkex.addNS('text', 'svg'))
                        text.set("x", str(width/2 + bar_width + text_offset + 1))
                        text.set("y", str(height/ 2 - offset + font_size/3 - (normedvalue/2)))
                        text.set("style", "font-size:" + str(font_size)
                                 + "px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:"
                                 + font + ";-inkscape-font-specification:Bitstream Charter;fill:" + font_color)
                        text.text = keys[cnt]
                        cnt = cnt + 1
                        layer.append(text)
                    else:
                        path = inkex.etree.Element(inkex.addNS("path", "svg"))
                        path.set("d","m " + str((width)/2 + offset + normedvalue/2) + ","
                                    + str(height / 2 + bar_width/2) + " 0," 
                                    + str(bar_width/2 + (font_size * i) + text_offset)) #line
                        path.set("style", "fill:none;stroke:" + font_color
                                 + ";stroke-width:" + str(stroke_width)
                                 + "px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1")
                        layer.append(path)
                        text = inkex.etree.Element(inkex.addNS('text', 'svg'))
                        text.set("x", str((width)/2 + offset + normedvalue/2 - font_size/3))
                        text.set("y", str((height/2) + bar_width + (font_size * (i + 1)) + text_offset))
                        text.set("style", "font-size:" + str(font_size) 
                                        + "px;font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-family:"
                                        + font + ";-inkscape-font-specification:Bitstream Charter;fill:" + font_color)
                        text.text = keys[color]
                        layer.append(text)
                
                # Increase Offset and Color
                offset = offset + normedvalue
                color = (color + 1) % 8
                
                # Draw rectangle
                layer.append(rect)
                i += 1
            
            # set x position for heading line
            if not rotate:
                heading_x = width/2 + offset + normedvalue # TODO: adjust
            else:
                heading_x = width/2 + offset + normedvalue # TODO: adjust
                
        if headings and input_type == "\"file\"":
            headingtext = inkex.etree.Element(inkex.addNS('text', 'svg'))
            headingtext.set("y", str(height/2 + heading_offset))
            headingtext.set("x", str(heading_x))
            headingtext.set("style", "font-size:" + str(font_size + 4)\
                    + "px;font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-family:"\
                    + font + ";-inkscape-font-specification:Bitstream Charter;text-align:end;text-anchor:end;fill:"\
                    + font_color)

            headingtext.text = heading
            layer.append(headingtext)
    
    def getUnittouu(self, param):
        try:
            return inkex.unittouu(param)
        except AttributeError:
            return self.unittouu(param)

if __name__ == '__main__':
    # Create effect instance and apply it.
    effect = NiceChart()
    effect.affect()