xpflow 0.1b

data/lib/xpflow/graph.rb

@@ -0,0 +1,1603 @@
+
+begin
+    require('cairo')  # this is to hide it from bundle.rb
+    $check_cairo = proc {}
+rescue LoadError
+    $check_cairo = proc { raise "Please install cairo for Ruby." }
+end
+
+module Graphing
+
+    class LatexGrapher
+
+        def initialize(flow, opts = {})
+            @flow = flow
+            @opts = opts
+            @indent = 0
+            @text = [ "% flow-latex workflow" ]
+        end
+
+        def self.indent_arrays(array)
+            lines = []
+            array.each do |x|
+                if x.is_a?(String)
+                    lines.push(x)
+                elsif x.is_a?(Array)
+                    x = indent_arrays(x)
+                    arr = x.map { |it| "  " + it }
+                    lines += arr
+                elsif x.nil?
+                    # nop
+                else
+                    raise "What is #{x.class}?"
+                end
+            end
+            return lines
+        end
+
+        def draw()
+            lines = @flow.latex()
+            lines = LatexGrapher.indent_arrays(lines)
+            # puts lines
+            return lines.join("\n")
+        end
+
+
+
+    end
+
+    class TikzGrapher
+
+        attr_reader :nodes
+        attr_reader :coords
+        attr_reader :boxes
+        # and also paths
+
+        def initialize(flow, opts = {})
+            @flow = flow
+            @nodes = {}
+            @coords = {}
+            @links = Hash.new { |h, k| h[k] = [] }
+            @lines = []
+            @styles = {}
+            @boxes = []
+            @joins = []
+            @count = 0
+            @opts = opts
+            @matrix = [ Size.new(0, 0) ]
+        end
+
+        def name
+            "tikz"
+        end
+
+        def transform(p)
+            # transform a given point
+            return p + @matrix.last
+        end
+
+        def tr(p)
+            return transform(p)
+        end
+
+        def push_origin(x, y)
+            # pushes transformation stack and puts origin in p
+            p = transform(Size.new(x, y))
+            begin
+                @matrix.push(p)
+                yield
+            ensure
+                @matrix.pop
+            end
+        end
+
+
+        def option(x)
+            return @opts[x] == true
+        end
+
+        def final?(label)
+            raise if not @nodes.key?(label) and not @coords.key?(label)
+            return @nodes.key?(label)
+        end
+
+        def check_links
+            @links.each do |s, ends|
+                raise if !final?(s) and ends.length > 1
+            end
+        end
+
+        def get_position(label)
+            return @coords[label] if @coords.key?(label)
+            return @nodes[label][:pos] if @nodes.key?(label)
+            raise "Unknown label '#{label}'"
+        end
+
+        def get_path(l1, l2)
+            # gets path l1 -> l2 -> ... -> (final node)
+            path = [ l1, l2 ]
+            while !final?(path.last) do
+                succ = @links[path.last]
+                raise if succ.length > 1
+                path.push(succ.first)
+                raise if path.length > 1000 # in case there is a bug ...
+            end
+            # TODO: remove repetitions on the path?
+            return path
+        end
+
+        def paths
+            check_links()  # check if links are ok
+            list = []
+            @links.each do |s, ends|
+                ends.each do |e|
+                    path = get_path(s, e)
+                    list.push(path)
+                end if final?(s)
+            end
+            return list
+        end
+
+        def text_measurer
+            # by default we don't have it
+            return nil
+        end
+
+        def draw(box = nil)
+            Thread.current[:text_measure] = text_measurer() # TODO: ugly hack!
+            box = @flow.size if box.nil?
+            @flow.tikz(self, Size.ZERO, box)
+
+            els = {
+                :nodes => @nodes,
+                :paths => paths,
+                :coords => @coords,
+                :boxes => @boxes,
+                :positions => {},
+                :lines => @lines,
+                :joins => @joins
+            }
+
+            els[:nodes].each { |label, n| els[:positions][label] = n[:pos] }
+            els[:coords].each { |label, pos| els[:positions][label] = pos }
+
+            return draw_elements(els, box)
+        end
+
+        def draw_elements(els, box)
+            
+            lines = []
+            lines += [ "", "% Special curves", "" ]
+
+            lines += [ "", "% Boxes", "" ]
+            els[:boxes].each do |b|
+                pos, box, opts = b[:pos], b[:box], b[:opts]
+                style = "dashed"
+                if opts[:style]
+                    style = "#{style},#{opts[:style]}"
+                end
+                lines.push("\\draw[#{style}] #{pos} rectangle #{pos + box};")
+            end
+
+            lines += [ "", "% Intermediate nodes", "" ]
+            els[:coords].each do |label, pos|
+                lines.push("\\coordinate (#{label}) at #{pos};")
+            end
+
+            els[:lines].each do |l|
+                coords, opts =  l
+                type = opts[:type]
+                if type == :bezier 
+                    raise "Wrong number of points (should be = 1 mod 3)" if coords.length % 3 != 1
+                    # strictly speaking tikz has no beziers, but it will suffice
+                    lines.push("\\draw[dashed,gray] #{coords.first}  % total #{coords.length} points")
+                    (coords.length / 3).times do |i|
+                        a, b, c = coords[(i*3 + 1)...(i*3 + 4)]
+                        lines.push("    .. controls #{a} and #{b} .. #{c}")
+                    end
+                    lines[-1] = lines[-1] + ";"
+                elsif type == :solid
+                    path = coords.map(&:to_s).join(" -- ")
+                    lines.push("\\draw[solid,#{opts[:style]}] #{path};")
+                else
+                    raise "Unsupported curve of type '#{type}'"
+                end
+            end
+
+            lines += [ "% Final nodes", "" ]
+            els[:nodes].each do |label, n|
+                style, pos, name = n[:style], n[:pos], n[:name]
+                anchor = n[:anchor]
+                # TODO: support anchor
+                # puts n.inspect
+                name = name.gsub('_', '\_')
+
+                style = "" if style == "text"
+                lines.push("\\node[#{style},fill=white] (#{label}) at #{pos} {#{name}};")
+            end
+
+            lines += [ "", "% Links between final nodes", "" ]
+            els[:paths].each do |p|
+                p = p.map { |x| "(#{x})" }.join(" to ")
+                lines.push("\\draw[sequence] #{p};")
+            end
+            
+            lines += [ "", "% Joins", "" ]
+            els[:joins].each do |pts, type|
+                s = pts.map { |x| "(#{x})" }.join(" to ")
+                style = case type
+                    when :plain
+                        ""
+                    when :arrow
+                        "->"
+                    when :arrow_dashed
+                        "dashed,->"
+                    else
+                        raise "Unknown type '#{type}'"
+                end
+                lines.push("\\draw[#{style}] #{s};")
+            end
+
+            lines.push("")
+            return lines.join("\n")
+        end
+
+        def get_label
+            @count += 1
+            return "node-#{@count}"
+        end
+
+        def add_task(name, pos, style = 'task', anchor = nil, size = nil, label = nil)
+            label = get_label() if label.nil?
+            @nodes[label] = { :name => name, :pos => tr(pos), :style => style,
+                :anchor => anchor, :size => size }
+            return label
+        end
+
+        def add_text(name, pos, anchor = "cm", size = 1.0)
+            return add_task(name, pos, 'text', anchor, size)
+        end
+
+        def add_gateway(pos, text); add_task(text, pos, 'gateway'); end
+        def add_start(pos); add_task('', pos, 'start'); end
+        def add_finish(pos); add_task('', pos, 'finish'); end
+
+        def add_coord(pos)
+            label = get_label()
+            @coords[label] = tr(pos)
+            return label
+        end
+
+        def add_box(pos, box, force = false, opts = {})
+            @boxes.push({ :pos => tr(pos), :box => box, :opts => opts }) \
+                if force or option(:boxes) or option(:debug)
+        end
+
+        def add_link(*labels)
+            (1...labels.length).each do |i|
+                @links[labels[i - 1]].push(labels[i])
+            end
+        end
+
+        def add_join(points, type = :plain)
+            points = points.map do |p|
+                p = self.add_coord(p) if p.is_a?(Size)
+                p
+            end
+            @joins.push([ points, type ])
+        end
+
+        def add_line(path, opts = { :style => :solid })
+            @lines.push([ path, opts ])
+        end
+
+        def label_pos(name)
+            return @nodes[name][:pos]
+        end
+
+    end
+
+    class CairoGrapher < TikzGrapher
+
+        WHITE = [ 1, 1, 1 ]
+        BLACK = [ 0, 0, 0 ]
+        LGRAY = [ 0.8, 0.8, 0.8 ]
+        RED = [ 1, 0, 0]
+
+        def initialize(flow, writer, opts = {})
+            super(flow, opts)
+            @writer = writer
+            @ctx = writer.context
+            @dims = writer.size
+            @font_size = 0.35
+        end
+
+        def name
+            "cairo"
+        end
+
+        # rescales Cairo canvas so that it fits the workflow nicely
+
+        def rescale(box)
+            cw, ch = @dims.map(&:to_f)
+            factor = [ cw / box.width, ch / box.height ].min
+            w, h = factor * box.width, factor * box.height
+            @ctx.translate( (cw - w) / 2.0, (ch - h) / 2.0)
+            @ctx.scale(factor, factor)
+            # TODO
+        end
+
+        def background
+            set_white
+            @ctx.rectangle(0, 0, *@dims)
+            @ctx.fill
+        end
+
+        def bbox(box)
+            @ctx.set_line_width(0.005)
+            @ctx.set_dash(0.04)
+            set_black
+            @ctx.rectangle(0, 0, box.width, box.height)
+            @ctx.stroke
+        end
+
+        def set_black
+            @ctx.set_source_rgb(*BLACK)
+        end
+
+        def set_white
+            @ctx.set_source_rgb(*WHITE)
+        end
+
+        def fill_and_stroke(fill = WHITE, stroke = BLACK)
+            unless fill.nil?
+                @ctx.set_source_rgb(*fill)
+                @ctx.fill_preserve
+            end
+            @ctx.set_source_rgb(*stroke)
+            @ctx.stroke
+        end
+
+        def find_pos(pos, extents, anchor)
+            # finds a position according to the extents and anchor
+
+            x_shifts = {
+                'l' => 0.0 - extents.x_bearing,
+                'c' => -extents.width * 0.5 - extents.x_bearing ,
+                'r' => -extents.width - extents.x_bearing
+            }
+
+            y_shifts = {
+                't' => -extents.y_bearing,
+                'm' => -extents.y_bearing - extents.height * 0.5,
+                'b' => -extents.y_bearing - extents.height,
+                'v' => 0.0
+            }
+
+            dy = y_shifts.select { |k, v| anchor.include?(k) }
+            dy = dy.empty? ? y_shifts['m'] : dy.values.first
+
+            dx = x_shifts.select { |k, v| anchor.include?(k) }
+            dx = dx.empty? ? x_shifts['c'] : dx.values.first
+
+            return pos.at(dx, dy)
+        end
+
+        def show_text(text, p)
+            if option(:debug)  # draw bearing and all that typographic stuff
+                @ctx.save
+                @ctx.set_dash(0.03)
+                @ctx.move_to(*p.coords)
+                e = @ctx.text_extents(text)
+                @ctx.rel_line_to(0, e.y_bearing)
+                @ctx.rel_line_to(+e.x_bearing + e.width, 0)
+                @ctx.rel_line_to(0, e.height)
+                @ctx.rel_line_to(-e.x_bearing - e.width, 0)
+                @ctx.close_path
+                fill_and_stroke(nil, BLACK)
+
+                @ctx.set_dash(nil)
+                @ctx.move_to(*p.coords)
+                @ctx.rel_line_to(e.x_bearing + e.width, 0)
+                @ctx.move_to(*p.coords)
+                @ctx.rel_move_to(e.x_bearing, e.y_bearing)
+                @ctx.rel_line_to(0, e.height)
+                fill_and_stroke(nil, RED)
+                
+                @ctx.restore
+            end
+            set_black
+            @ctx.move_to(*p.coords)
+            @ctx.show_text(text)
+            @ctx.stroke
+        end
+
+        def approximate_size(text, size)
+            if size.is_a?(Size)
+                @ctx.set_font_size(@font_size)
+                extents = @ctx.text_extents(text)
+                sx = size.width / extents.width
+                sy = size.height / extents.height
+                return [ sx, sy ].min
+            else
+                size = -size
+                @ctx.set_font_size(@font_size)
+                extents = @ctx.text_extents(text)
+                return size / extents.height
+            end
+        end
+
+        def text_measurer
+            return proc { |text|
+                @ctx.save
+                @ctx.set_font_size(@font_size)
+                ex = @ctx.text_extents(text)
+                @ctx.restore
+                ex
+            }
+        end
+
+        def draw_elements(els, box)
+
+            background()
+            rescale(box)
+            # bbox(box)
+
+            @ctx.select_font_face("Droid Serif",
+                Cairo::FONT_SLANT_NORMAL, Cairo::FONT_WEIGHT_NORMAL)
+            
+            pos = els[:positions]
+
+            set_black
+            @ctx.set_line_width(0.01)
+            @ctx.set_dash(nil)
+
+            els[:paths].each do |path|
+                raise if path.length < 2
+                @ctx.move_to(*pos[path.first].coords)
+                path[1..-1].each do |n|
+                    @ctx.line_to(*pos[n].coords)
+                end
+                @ctx.stroke
+            end
+
+            @ctx.set_dash(0.03)
+            els[:boxes].each do |b|
+                pos, box = b[:pos], b[:box]
+                rect = pos.coords + box.coords
+                @ctx.rectangle(*rect)
+                @ctx.stroke
+            end
+
+            els[:lines].each do |path, style|
+                if style == :bezier or style == { :type => :bezier }
+                    raise "Bezier curve must have >= 4 and % 3 == 1 points!" \
+                        if path.length < 4 or path.length % 3 != 1
+
+                    if option(:debug)
+                        @ctx.save
+                        (path.length / 3).times do |i|
+                            [ 3*i + 1, 3*i + 2 ].each do |j|
+                                r = 0.05
+                                params = path[j].coords + [ r, 0, 6.28 ]
+                                @ctx.set_dash(nil)
+                                @ctx.arc(*params)
+                                fill_and_stroke(RED, RED)
+                            end
+                            @ctx.set_dash(0.03)
+                            @ctx.move_to(*path[3*i + 1].coords)
+                            @ctx.line_to(*path[3*i + 2].coords)
+                            fill_and_stroke(nil, RED)
+                        end
+                        @ctx.restore
+                    end
+
+                    path = path.dup
+                    first = path.shift
+                    @ctx.move_to(*first.coords)
+                    while path.length > 0
+                        
+                        
+                        args = path[0].coords + path[1].coords + path[2].coords
+                        @ctx.curve_to(*args)
+                        path.shift(3)
+                    end
+                    @ctx.stroke
+                else
+                    raise "Unknown style of a line (#{style})!"
+                end
+            end
+
+            @ctx.set_dash(nil)
+            els[:nodes].each do |label, n|
+                @ctx.set_font_size(@font_size)
+                @ctx.set_source_rgb(*BLACK)
+                @ctx.save
+                style = n[:style]
+                position = n[:pos]
+                name = n[:name]
+                anchor = n[:anchor].to_s
+                size = n[:size]
+                anchor = "cm" if anchor.nil? # center, middle
+                size = 1.0 if size.nil?
+                # anchor can contain: l, r, t, b, c, m
+                if style == "start" or style == "finish"
+                    x, y = position.coords
+                    @ctx.set_line_width(style == "start" ? 0.02 : 0.04)
+                    @ctx.arc(x, y, 0.2, 0, 2 * Math::PI)
+                    fill_and_stroke
+                elsif style == "task"
+                    extents = @ctx.text_extents(name)
+                    bw, bh = extents.width + 0.2, extents.height + 0.2
+                    x, y = position.width - bw / 2.0, position.height - bh / 2.0
+                    @ctx.rectangle(x, y, bw, bh)
+                    fill_and_stroke
+                    if option(:debug) # showing middle points of tasks
+                        @ctx.move_to(x + bw * 0.5, y)
+                        @ctx.rel_line_to(0, bh)
+                        @ctx.move_to(x, y + bh * 0.5)
+                        @ctx.rel_line_to(bw, 0)
+                        fill_and_stroke(WHITE, [ 0.7, 0.7, 0.7 ])
+                    end
+                    fill_and_stroke
+                    p = find_pos(position, extents, "cm")
+                    show_text(name, p)
+                elsif style == "text"
+                    size = approximate_size(name, size) if size.is_a?(Size ) or size < 0.0
+                    @ctx.set_font_size(@font_size * size)  # set font size here
+                    p = find_pos(position, @ctx.text_extents(name), anchor)
+                    show_text(name, p)
+                elsif style == "gateway"
+                    x, y = position.coords
+                    @ctx.move_to(x, y)
+                    @ctx.rel_move_to(-0.2, 0)
+                    @ctx.rel_line_to(+0.2, +0.2)
+                    @ctx.rel_line_to(+0.2, -0.2)
+                    @ctx.rel_line_to(-0.2, -0.2)
+                    @ctx.close_path
+                    fill_and_stroke
+                    p = find_pos(position, @ctx.text_extents(name), "cm")
+                    show_text(name, p)
+                else
+                    raise "Unknown style #{style}!"
+                end
+                @ctx.restore
+            end
+
+            @writer.finish
+        end
+
+    end
+
+    class PNGWriter
+
+        attr_reader :size
+        attr_reader :context
+
+        def initialize(filename, size = [ 800, 600 ])
+            $check_cairo.call
+            @filename = filename
+            @size = size.map(&:to_f)
+            @surface = Cairo::ImageSurface.new(Cairo::FORMAT_ARGB32, *@size)
+            @context = Cairo::Context.new(@surface)
+        end
+
+        def finish
+            @surface.write_to_png(@filename)
+        end
+
+    end
+
+    class PDFWriter
+
+        attr_reader :size
+        attr_reader :context
+
+        def initialize(filename, size = [ 800, 600 ])
+            $check_cairo.call
+            @filename = filename
+            @size = size
+            @surface = Cairo::PDFSurface.new(filename, *@size)
+            @context = Cairo::Context.new(@surface)
+        end
+
+        def finish
+            @context.show_page
+        end
+
+    end
+
+    def self.to_pdf(process, filename, opts = {})
+        writer = Graphing::PDFWriter.new(filename)
+        Graphing::CairoGrapher.new(process, writer, opts).draw()
+    end
+
+    def self.to_png(process, filename, opts = {})
+        writer = Graphing::PNGWriter.new(filename)
+        Graphing::CairoGrapher.new(process, writer, opts).draw()
+    end
+
+    def self.to_tikz(process, filename, opts = {})
+        File.open(filename, "w") do |f|
+            f.write(to_text(process, opts))
+        end
+    end
+
+    def self.to_latex(process, filename, opts = {})
+        File.open(filename, "w") do |f|
+            f.write(to_tex(process, opts))
+        end
+    end
+
+    def self.to_text(process, opts = {})
+        return Graphing::TikzGrapher.new(process, opts).draw()
+    end
+
+    def self.to_tex(process, opts = {})
+        process = process.simplify
+        return Graphing::LatexGrapher.new(process, opts).draw()
+    end
+
+    def self.to_file(process, filename, format)
+        m = "to_#{format}".downcase.to_sym
+        raise "Format #{format} unsupported." unless self.respond_to?(m)
+        return self.__send__(m, process, filename)
+    end
+
+
+
+
+    class Size
+
+        attr_reader :width
+        attr_reader :height
+
+        def initialize(w, h)
+            @width = w
+            @height = h
+        end
+
+        def self.flatten(*args)
+            if args.length == 1
+                el = args.first
+                return el if el.is_a?(Size)
+                return Size.new(*el)
+            elsif args.length == 2
+                return Size.new(*args)
+            else
+                raise "What is #{args}?"
+            end
+        end
+
+        def to_s
+            return "(%.6f, %.6f)" % [@width, @height]
+        end
+
+        def self.ZERO
+            return Size.new(0, 0)
+        end
+
+        def +(o)
+            o = Size.flatten(o)
+            return Size.new(@width + o.width, @height + o.height)
+        end
+
+        def -(o)
+            o = Size.flatten(o)
+            return self + [ -o.width, -o.height ]
+        end
+
+        def *(x)
+            return Size.new(@width * x, @height * x)
+        end
+
+        def /(x)
+            x = x.to_f
+            return Size.new(@width / x, @height / x)
+        end
+
+        def at(*args)
+            return self + args.first if args.length == 1
+            return self + args
+        end
+
+        def xproj(y = 0)
+            # project width
+            return Size.new(@width, y)
+        end
+
+        def yproj
+            return Size.new(0, height)
+        end
+
+        def coords
+            return [ @width, @height ]
+        end
+
+        def shrink(scalex, scaley = nil)
+            scaley = scalex if scaley.nil?
+            x = Size.new(@width * scalex, @height * scaley)
+            offset = (self - x) / 2
+            return [ offset, x ]
+        end
+
+        def center
+            return self * 0.5
+        end
+
+        def vh_path(endpoint, height = nil)
+            # creates a path |-| from self to endpoint, returns all 4 points
+            height = (self.height + endpoint.height) * 0.5 if height.nil?
+            return [ self, self.xproj(height), endpoint.xproj(height), endpoint ]
+        end
+
+        def x; @width end
+        def y; @height end
+    end
+
+    class Flow
+
+        def initialize(opts)
+            @opts = standard_opts().merge(default_opts().merge(opts))
+        end
+
+        def size
+            raise 'Error'
+        end
+
+        def simplify
+            return self
+        end
+
+        def default_opts
+            return { }
+        end
+
+        def standard_opts
+            return { 'box' => { :value => false } }
+        end
+
+        def option(name, &block)
+            x = @opts[name.to_s][:value]
+            x = block.call(x) if block_given?
+            return x
+        end
+
+        def has_box?
+            return option(:box, &:to_s) == "true"
+        end
+
+        def draw_common(state, pos, box)
+            state.add_box(pos, box, true) if has_box?
+        end
+
+        def tikz(state, pos, box)
+            draw_common(state, pos, box)
+        end
+
+    end
+
+    class Block < Flow
+
+        def initialize(name, opts = {})
+            super({ :flow => :right }.merge(opts))
+            @name = name
+        end
+
+        def size
+            measurer = Thread.current[:text_measure]
+            if measurer.nil?
+                chars = @name.to_s.split("\\\\").map(&:length).max
+                w = 1 + (chars - 1) * 0.18
+                return Size.new(w, 1)
+            else
+                # we have measurer helper here
+                extents = measurer.call(@name)
+                return Size.new(extents.width, 1)
+            end
+        end
+
+        def tikz(state, pos, box, label = nil)
+            super(state, pos, box)
+            width2 = box.width * 0.5
+            height2 = box.height * 0.5
+            first = state.add_coord(pos + [ 0.0, height2 ])
+            last = state.add_coord(pos + [ box.width, height2 ])
+            node = state.add_task(@name, pos + [ width2, height2 ], 'task', nil, nil, label)
+            if @opts[:flow] == :left
+                state.add_link(last, node)
+                state.add_link(node, first)
+                return [ last, first ]
+            else
+                state.add_link(first, node)
+                state.add_link(node, last)
+                return [ first, last ]    
+            end
+        end
+
+        def latex()
+            opts = { :text => @name }.merge(@opts)
+            return nil if opts[:hide]
+            return [ "\\task {#{opts[:text]}}" ]
+        end
+
+    end
+
+    class GroupFlow < Flow
+
+        def initialize(list, opts = {})
+            super(opts)
+            @list = list
+        end
+
+    end
+
+    class SequenceFlow < GroupFlow
+
+        @@margin = 0.3
+
+        def size
+            if @list.length == 0
+                return Size.new(0.0, 0.0)
+            end
+            sizes = @list.map(&:size)
+            w = sizes.map(&:width).reduce(:+)
+            h = sizes.map(&:height).max
+            w += sizes.length * @@margin
+            return Size.new(w, h)
+        end
+
+        def self.simplify_array(array)
+            # flattens an array of sequences
+            newarray = []
+            newlist = array.each do |it|
+                it = it.simplify
+                if it.is_a?(SequenceFlow)
+                    newarray += it.sequence()
+                else
+                    newarray.push(it)
+                end
+            end
+            return newarray
+        end
+
+        def into_lines
+            # finds nl's inside sequence, and if they exist turns everything into lines
+            lines = []
+            sizes = []
+            line = []
+            @list.each do |item|
+                if item.is_a?(NewLine)
+                    lines.push(line)
+                    sizes.push(item.option(:size, &:to_f))
+                    line = []
+                else
+                    line.push(item)
+                end
+            end
+            lines.push(line) if line != []
+            if lines.length == 1
+                return self
+            else
+                lines = lines.map { |x| SequenceFlow.new(x) }
+                opts = @opts.merge({ 'padding' => { :value => sizes }})
+                return LinesFlow.new(lines, opts)
+            end
+        end
+
+        def simplify
+            array = SequenceFlow.simplify_array(@list)
+            return SequenceFlow.new(array, @opts)
+        end
+
+        def sequence
+            return @list
+        end
+
+        def els_sizes
+            return @list.map(&:size)
+        end
+
+        def tikz(state, pos, box)
+            super
+            first = pos.at(0, box.height * 0.5)
+            last = pos.at(box.width, box.height * 0.5)
+            first = state.add_coord(first)
+            last = state.add_coord(last)
+            if @list.length == 0
+                state.add_link(first, last)
+                return [ first, last ]
+            end
+            s = self.els_sizes
+            sum = s.map(&:width).reduce(:+).to_f
+            m = (box.width - sum) / s.length.to_f
+            m2 = m * 0.5
+            state.add_box(pos, box)
+            
+            # m is a size of every margin
+
+            b, e = nil, nil # first and last node
+            prev = nil
+            offset = m2
+            for el in @list do
+                els = el.size
+                middle = (box.height - els.height) * 0.5
+                start, ending = el.tikz(state, pos.at(offset, middle), els)
+                b = start if b.nil?
+                e = ending
+                state.add_link(prev, start) unless prev.nil? 
+                prev = ending
+                offset += els.width + m
+            end
+            
+            state.add_link(first, b)
+            state.add_link(e, last)
+
+            return [ first, last ]
+        end
+
+        def latex()
+            children = @list.map(&:latex)
+            return [ '\seq' ] + children + [ '\end' ]
+        end
+
+    end
+
+    class LoopFlow < SequenceFlow
+
+        @@hsize = 1.0
+        @@vsize = 1.0
+
+        def initialize(*args)
+            super
+            @breaks = []
+        end
+
+        def size
+            s = super()
+            return s.at(@@vsize, @@hsize)
+        end
+
+        def tikz(state, pos, box)
+            Thread.current[:__loop__] = [] if Thread.current[:__loop__].nil?
+            Thread.current[:__loop__].push(self)
+
+            # state.add_box(pos, box, true)
+
+            finish = pos.at(box.width, box.height * 0.5)
+
+            box = box.at(-@@vsize, -@@hsize)
+            pos = pos.at(0, @@hsize * 0.5)
+
+            # state.add_box(pos, box, true)
+
+            s, e = super(state, pos, box)
+
+            ee = state.get_position(e)
+            ss = state.get_position(s)
+            a = ee.xproj(pos.height)
+            b = ss.xproj(pos.height)
+            state.add_join([ e, a, b, s ], :arrow)
+
+            # TODO: this will only work nicely with one
+            # break
+            @breaks.each do |x|
+                xx = state.get_position(x)
+                a = xx.xproj(pos.height + box.height)
+                b = finish.xproj(pos.height + box.height)
+                state.add_join([x, a, b, finish])
+            end
+
+            ff = state.add_coord(finish)
+
+            state.add_link(e, ff)
+
+            Thread.current[:__loop__].pop()
+
+            return [s, ff]
+        end
+
+        def add_break(label)
+            @breaks.push(label)
+        end
+
+    end
+
+    class BreakLoop < Block
+
+        @@counter = 0
+
+        def tikz(state, pos, box)
+            @@counter += 1
+            label = "break-#{@@counter}"
+            s, e = super(state, pos, box, label)
+            Thread.current[:__loop__].last.add_break(label)
+            return [ s, e ]
+        end
+
+    end
+
+    class SubprocessFlow < SequenceFlow
+        # this one contains a subprocess, with its name
+        # we ask for +2 in height so that we can nicely
+        # fit the name of the process
+
+        def initialize(list, name)
+            super(list)
+            @name = name
+        end
+
+        def size
+            s = super()
+            return s.at(0, 2)
+        end
+
+        def tikz(state, pos, box)
+            s = self.size
+            links = super(state, pos, box)
+            state.add_box(pos, box, true)
+            label = Size.new(box.width, 1)
+            offset, box = label.shrink(0.8, 0.7)
+            state.add_text("#{@name}", pos + offset + box.center, "cm", box)
+            return links
+        end
+    end
+
+    class BoxedFlow < Flow
+
+        def initialize(flow, name, opts = {})
+            super(opts)
+            @flow = flow
+            @name = name
+        end
+
+        def size
+            s = @flow.size
+            return s.at(0, 2)
+        end
+
+        def space
+            space = 0.0
+            space = @opts['space'][:value].to_f if @opts['space']
+            return space
+        end
+
+        def tikz(state, pos, box)
+            itsize = @flow.size
+            diff = box - itsize
+            flowpos = pos + diff * 0.5
+            links = @flow.tikz(state, pos.at(0, 1), Size.new(box.width, itsize.height))
+            
+            pos = pos.at(0, self.space)
+
+            title = state.add_task("{\\Large\\sc{}#{@name}}",
+                pos.at(box.width/2, box.height - 0.5), 'draw', "cm", 1.0)
+
+            m1 = state.get_position(title)
+            c1 = pos.at(box.width/2, box.height - 1)
+            p1 = pos.at(0, box.height - 1 - 0.4)
+            p2 = pos.at(0, box.height - 1)
+            p3 = pos.at(box.width, box.height - 1)
+            p4 = pos.at(box.width, box.height - 1 - 0.4)
+
+            state.add_line([ m1, c1 ], :type => :solid)
+            state.add_line([ p1, p2, p3, p4 ], :type => :solid)
+
+            return links
+        end
+
+    end
+
+    class SplitFlow < GroupFlow
+
+        def initialize(list, text)
+            super(list)
+            @text = text
+            @hjustify = 0.5
+            @vjustify = 0.75
+            @hmargin = 0.0
+            @vmargin = 0.0
+        end
+
+        def split_size
+            sizes = @list.map(&:size)
+            w = sizes.map(&:width).max
+            h = sizes.map(&:height).reduce(:+)
+            return Size.new(w + 2, h).at(@hmargin * 2, @vmargin * 2)
+        end
+
+        def size
+            return split_size
+        end
+
+        def justify(pos, box)
+            s = self.size
+            dx = (box.width - s.width) * 0.5 * (1 - @hjustify)
+            dy = (box.height - s.height) * 0.5 * (1 - @vjustify)
+            pos = pos.at(dx, dy)
+            box = Size.new(box.width - 2*dx, box.height - 2*dy)
+            return [ pos, box ]
+        end
+
+        def margine(pos, box)
+            box = box.at(-2 * @hmargin, -2 * @vmargin)
+            pos = pos.at(@hmargin, @vmargin)
+            return [ pos, box ]
+        end
+
+        def tikz(state, pos, box)
+            # state.add_box(pos, box, true)
+            pos, box = margine(pos, box)
+            # state.add_box(pos, box, true)
+            pos, box = justify(pos, box)
+            # state.add_box(pos, box, true)
+            first = pos.at(0.5, box.height * 0.5)
+            last = pos.at(box.width - 0.5, box.height * 0.5)
+            first = @split = state.add_gateway(first, @text)
+            last = @merge = state.add_gateway(last, @text)
+
+            s = self.split_size
+            pos = pos + [ (box.width - s.width) * 0.5, 0.0 ]
+            offset = (box.height - s.height) * 0.5
+            for el in @list do
+                els = el.size
+                start, ending = el.tikz(state, pos.at(1, offset), Size.new(s.width - 2, els.height))
+                state.add_link(first, start)
+                state.add_link(ending, last)
+                offset += els.height
+            end
+            
+            return [ first, last ]
+        end
+
+    end
+
+    class ParallelFlow < SplitFlow
+
+        def initialize(list)
+            super(list, '+')
+        end
+
+        def latex()
+            children = @list.map(&:latex)
+            return [ '\parallel' ] + children + [ '\end' ]
+        end
+
+    end
+
+    class ForallFlow < SplitFlow
+
+        def initialize(list, opts = {})
+            # TODO
+            opts = { :symbol => '\normalsize{\&}' }.merge(opts)
+            super(list, opts[:symbol])
+        end
+
+        def size
+            s = super()
+            return s.at(0, 2)
+        end
+
+        def tikz(state, pos, box)
+            # state.add_box(pos, box, true)
+            # state.add_box(pos.at(0, 1), box.at(0, -2), true)
+            
+            endings = super(state, pos, box)
+            first, last = endings
+
+            first = state.label_pos(@split)
+            last = state.label_pos(@merge)
+
+            span = (last - first).width
+
+            steps = 2
+
+            (-steps..steps).each do |i|
+                
+                next if i == 0
+
+                x = i.to_f / steps
+                lcorner = first + [ 0, x ]
+                rcorner = last + [ 0, x ]
+                middle = (lcorner + rcorner) / 2
+                
+                c1 = (lcorner + first) / 2
+                c2 = (lcorner + middle) / 2
+                c3 = (rcorner + middle) / 2
+                c4 = (rcorner + last) / 2
+
+                state.add_line([ first, c1, c2, middle, c3, c4, last ], :type => :bezier)
+            end
+
+            return endings
+        end
+
+        def latex()
+            # TODO
+            children = @list.map(&:latex).first[1...-1]
+            return [ '\forall' ] + children + [ '\end' ]
+        end
+
+    end
+
+    class ForeachFlow < ForallFlow
+
+        def initialize(list, opts = {})
+            super(list, :symbol => '\normalsize\textbf{=}')
+        end
+
+        def latex()
+            # TODO
+            children = @list.map(&:latex).first[1...-1]
+            return [ '\foreach' ] + children + [ '\end' ]
+        end
+
+    end
+
+    class SubFlow < Flow
+
+        def initialize(flow)
+            super({ })
+            @flow = flow
+        end
+
+        def size
+            return @flow.size
+        end
+
+        def tikz(state, pos, box)
+            endings = @flow.tikz(state, pos, box)
+            state.add_box(pos, box, true)
+            return endings
+        end
+
+    end
+
+    class NewLine < Flow
+
+        def default_opts
+            return { 'size' => { :value => 0 } }
+        end
+
+        def initialize(opts = {})
+            super(opts)
+        end
+
+    end
+
+    class LinesFlow < GroupFlow
+        ## multiple line flow
+
+        def default_opts
+            return {
+                'padding' => { :value => 0 },
+                'align' => { :value => :left }
+            }
+        end
+
+        def padding
+            pad = option(:padding)
+            if pad.is_a?(Array) # comes from nl's
+                return pad
+            else
+                return [ pad.to_f ] * (@list.length - 1)
+            end
+        end
+
+        def total_padding
+            return self.padding.reduce(:+)
+        end
+
+        def align
+            return option(:align, &:to_sym)
+        end
+
+        def size
+            sizes = @list.map(&:size)
+            w = sizes.map(&:width).max
+            h = sizes.map(&:height).reduce(:+)
+            h += self.total_padding
+            return Size.new(w, h)
+        end
+
+        def tikz(state, pos, box)
+            super
+            w = box.width
+            # state.add_box(pos, box, true)
+            mysize = self.size()
+            offset = (box.height - mysize.height) * 0.5
+            
+            pairs = []
+            links = []
+
+            paddings = self.padding() + [ 0.0 ] # fake padding
+            position_y = pos.height + box.height - offset
+            @list.each_with_index do |flow, idx|
+                half_padding = paddings[idx] * 0.5
+                size = flow.size()
+                position_y -= size.height
+                line_pos = pos.xproj(position_y)
+                if align() == :center
+                    xdelta = (mysize.width - size.width) * 0.5
+                    line_pos = line_pos.at(xdelta, 0)
+                elsif align() == :right
+                    xdelta = (mysize.width - size.width)
+                    line_pos = line_pos.at(xdelta, 0)
+                end
+                line_box = Size.new(size.width, size.height)
+                x = flow.tikz(state, line_pos, line_box)
+                pairs.push(x)
+                links.push(position_y - half_padding)
+                position_y -= paddings[idx]
+            end
+
+            (1...pairs.length).each do |i|
+                pred = pairs[i - 1].last
+                succ = pairs[i].first
+                pos_pred = state.get_position(pred)
+                pos_succ = state.get_position(succ)
+                _, a, b, _ = pos_pred.vh_path(pos_succ, links[i - 1])
+                n1, n2 = [ a, b ].map { |x| state.add_coord(x) }
+                state.add_link(pred, n1, n2, succ)
+            end
+
+            return [pairs.first.first, pairs.last.last]
+        end
+
+
+    end
+
+    class ProcessFlow < Flow
+
+        def initialize(process)
+            super({})
+            @process = process
+        end
+
+        def simplify
+            return ProcessFlow.new(@process.simplify)
+        end
+
+        def size
+            size = @process.size
+            return size.at(2, 0)
+        end
+
+        def tikz(state, pos, box)
+            state.add_box(pos, box)
+            first, last = @process.tikz(state, pos.at(1, 0), box.at(-2, 0))
+            ff = state.get_position(first)
+            ll = state.get_position(last)
+            m = box.height * 0.5
+            start = state.add_start(pos.at(0.5, ff.height))
+            state.add_link(start, first)
+            finish = state.add_finish( (pos + box + [-0.5, 0]).xproj(ll.height))
+            state.add_link(last, finish)
+        end
+
+        def latex()
+            return @process.latex()
+        end
+
+    end
+
+    def self.blockify(it)
+        it = Block.new(it) unless it.is_a?(Flow)
+        return it
+    end
+
+    def self.seq(arr, opts = {})
+        arr = arr.map { |x| blockify(x) }
+        return SequenceFlow.new(arr, opts)
+    end
+
+    def self.box(flow, name, opts = {})
+        flow = blockify(flow)
+        return BoxedFlow.new(flow, name, opts)
+    end
+
+    def self.nl(opts)
+        return NewLine.new(opts)
+    end
+
+    def self.break(name, opts)
+        return BreakLoop.new(name, opts)
+    end
+
+    def self.loop(arr, opts)
+        arr = arr.map { |x| blockify(x) }
+        return LoopFlow.new(arr, opts)
+    end
+
+    def self.par(*arr)
+        arr = arr.map { |x| blockify(x) }
+        return ParallelFlow.new(arr) 
+    end
+
+    def self.lines(arr, opts)
+        arr = arr.map { |x| blockify(x) }
+        return LinesFlow.new(arr, opts)
+    end
+
+    def self.forall(arr, opts)
+        arr = arr.map { |x| blockify(x) }
+        seq = SequenceFlow.new(arr)
+        return ForallFlow.new([ seq ], opts)
+    end
+
+    def self.foreach(arr, opts)
+        arr = arr.map { |x| blockify(x) }
+        seq = SequenceFlow.new(arr)
+        return ForeachFlow.new([ seq ], opts)
+    end
+
+    module DSL
+
+        class Element
+
+            def initialize
+                @list = []
+            end
+
+            def push(x)
+                @list.push(x)
+            end
+
+            def push_many(arr)
+                @list += arr
+            end
+
+
+            def task(name)
+                push(Block.new(name))
+            end
+
+            def seq_tasks(*names)
+                blocks = names.map { |x| Block.new(x) }
+                push(SequenceFlow.new(blocks))
+            end
+
+            def tasks(*names)
+                blocks = names.map { |x| Block.new(x) }
+                push_many(blocks)
+            end
+
+            def sequence(&block)
+                push(Sequence.new.parse(&block))
+            end
+
+            def parallel(&block)
+                push(Parallel.new.parse(&block))
+            end
+
+            def lines(&block)
+                push(Lines.new.parse(&block))
+            end
+
+            def parse(&block)
+                instance_exec(&block)
+                return build()
+            end
+
+            alias seq sequence
+
+        end
+
+        class LineMarker; end
+
+        class Sequence < Element
+
+            def build
+                multiline = @list.any? { |x| x.is_a?(LineMarker) }
+                if multiline
+                    lines = []
+                    curr = []
+                    (@list + [ LineMarker.new ]).each do |x|
+                        if x.is_a?(LineMarker)
+                            lines.push(SequenceFlow.new(curr))
+                            curr = []
+                        else
+                            curr.push(x)
+                        end
+                    end
+                    return LinesFlow.new(lines)
+                else
+                    return SequenceFlow.new(@list)
+                end
+            end
+
+            def newline
+                push(LineMarker.new)
+            end
+
+        end
+
+        class Process < Sequence
+
+            alias seq_build build
+
+            def build
+                return ProcessFlow.new(seq_build)
+            end
+
+        end
+
+        class Parallel < Element
+
+            def build
+                return ParallelFlow.new(@list)
+            end
+
+        end
+
+        class Lines < Element
+
+            def build
+                return LinesFlow.new(@list)
+            end
+
+        end
+
+        def self.workflow(&block)
+            return Process.new.parse(&block)
+        end
+
+    end
+
+end
+
+if $0 == __FILE__
+    if false
+        G = Graphing
+        seq1 = G.seq('D')
+        seq2 = G.seq('E', 'H')
+        par1 = G.par('F', 'G')
+        seq3 = G.seq('C', par1)
+
+        seq3 = G::SubFlow.new(seq3)
+
+        par2 = G.par(seq1, seq2, seq3)
+        main = G.seq('Ale jaja jak berety', 'B', par2)
+        p = G::ProcessFlow.new(main)
+
+        g = G::TikzGrapher.new(p, :boxes => false)
+        puts g.draw()
+    end
+
+    if true
+        DSL = Graphing::DSL
+
+        p = DSL.workflow do
+            task 'cze'
+            parallel do
+                tasks 'Clean', 'Find'
+                seq_tasks 'A', 'B', 'C', 'D'
+                parallel do
+                    seq_tasks 'one', 'two'
+                    task 'wow'
+                end
+            end
+        end
+
+        p = DSL.workflow do
+            parallel do
+                lines do
+                    seq_tasks(*'a b c'.split)
+                    seq_tasks(*'x y'.split)
+                    seq_tasks(*'1 2 3'.split)
+                    parallel do
+                        task 'O rany'
+                        task 'banany'
+                    end
+                end
+                seq_tasks 'Clean', 'Find'
+            end
+        end
+
+        writer = Graphing::PDFWriter.new('/tmp/draw.pdf')
+        g = Graphing::CairoGrapher.new(p, writer, :debug => false)
+        g.draw()
+    end
+
+
+end