rtl_circuit 0.7 → 0.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee25e08cf291db2381c60746dd1d654d4931bd0742cdd12f1f85b55b4065f694
-  data.tar.gz: 6a39ac68ccf30ff37ab674dad83ff74686fe81d6e3cf6e1c8b1cca5d0d88c384
+  metadata.gz: 0a185b02649b8dccfde92ceddba567e41a0a0bd3996142e4d44390316be24873
+  data.tar.gz: 96085d10887cbe7d99b531ce56ab4a403d15a3da700d62baf064d216c7ea8925
 SHA512:
-  metadata.gz: c5af6786663be64b4ff0dff83e240732a48ba17e0980ae7585f7a8d8967f107a81cf106608049829330f6aa094fd777bf9c26543595501ee469b4015ed6eecd2
-  data.tar.gz: 6b633468fc83534bd1164ded8ed001154d378a37c4f37aecde60ec04b14c1ea5cdc762f21565f7291b09dd88eb070a89a7ed811a749a2463c10d905c0a815142
+  metadata.gz: afeef2e5c8b2a67b07f557bdc54f4bc76859d13f3898d3b88c15f4da41aae688207d6dc91b295eb6f19178cfc13b62b142957edc4311d4e0f2158e059b066d80
+  data.tar.gz: 6380f0c3470dda41a4cbca67520a947e71c7d96abe64c31b5549dad90e9a7dda3cd49b7e336c054004b8ca7fbc8d846f890159cf0daf969a8278cef097660f35

data/lib/rtl/canvas.rb

@@ -0,0 +1,49 @@
+
+class Canvas < Gtk::DrawingArea
+  attr_accessor :running
+  def initialize
+    super()
+
+    @running=false
+    set_size_request(800,100)
+    signal_connect('draw') do
+      redraw @graph
+    end
+  end
+
+  def clear cr
+    cr.set_source_rgb(0.1, 0.1, 0.1)
+    cr.paint
+  end
+
+  def redraw graph=nil,zoom_factor=1,shift=Vector.new(0,0)
+    @graph=graph
+    cr = window.create_cairo_context
+    cr.set_line_width(0.8)
+
+    w = allocation.width
+    h = allocation.height
+
+    cr.translate(w/2, h/2)
+
+    clear cr
+
+    if graph
+      cr.set_source_rgb(0.4, 0.4, 0.4)
+      @graph.edges.each do |edge|
+        n1,n2=edge.source,edge.sink
+        cr.move_to(shift.x + n1.x*zoom_factor,shift.y + n1.y*zoom_factor)
+        cr.line_to(shift.x + n2.x*zoom_factor,shift.y + n2.y*zoom_factor)
+        cr.stroke
+      end
+
+      cr.set_source_rgb(0.9, 0.5, 0.2)
+      @graph.nodes.each do |node|
+        cr.arc(shift.x+node.x*zoom_factor, shift.y+node.y*zoom_factor, 10*zoom_factor, 0, 2.0 * Math::PI)
+        cr.fill_preserve()
+        cr.stroke
+      end
+    end
+
+  end
+end

data/lib/rtl/circuit.rb

@@ -8,7 +8,7 @@ module RTL
     attr_accessor :father
     attr_accessor :signals
     attr_accessor :properties
-
+    attr_accessor :color
     @@id=-1
 
     def initialize name=nil

data/lib/rtl/def_gates.svg

@@ -0,0 +1,99 @@
+<defs>
+    <symbol id="and2">
+      <path d="M 10 2
+               l 19 0
+               A 13 13 0 1 1 29 28
+               l -19 0
+               z
+               M 0  6 l 10 0
+               M 0 24 l 10 0
+               M 42 15 L 60 15"
+            fill="transparent"
+            stroke="black"/>
+    </symbol>
+
+    <symbol id="nand2">
+      <path d="M 10 2
+               l 19 0
+               A 13 13 0 1 1 29 28
+               l -19 0
+               z
+               M 0  6 l 10 0
+               M 0 24 l 10 0
+               M 42 15 A 4 4 0 0 0 50 15
+               M 42 15 A 4 4 0 0 1 50 15
+
+               M 50 15 L 60 15"
+            fill="transparent"
+            stroke="black"/>
+    </symbol>
+
+    <symbol id="or2">
+      <path d="M 10 2
+               l 13.484 0
+               A 26 26 0 0 1 46 15
+               A 26 26 0 0 1 23.484 28
+               L 10 28
+               A 26 26 0 0 0 10 2
+               M 0  6 l 11.5 0
+               M 0 24 l 11.5 0
+               M 46 15 L 60 15
+               "
+              stroke-linecap="round"
+            fill="transparent"
+            stroke="black"/>
+    </symbol>
+
+    <symbol id="nor2">
+      <path d="M 10 2
+               l 13.484 0
+               A 26 26 0 0 1 46 15
+               A 26 26 0 0 1 23.484 28
+               L 10 28
+               A 26 26 0 0 0 10 2
+               M 0  6 l 11.5 0
+               M 0 24 l 11.5 0
+               M 54 15 L 60 15
+               M 46 15 A 4 4 0 0 0 54 15
+               M 46 15 A 4 4 0 0 1 54 15
+
+               "
+              stroke-linecap="round"
+            fill="transparent"
+            stroke="black"/>
+    </symbol>
+
+    <symbol id="xor2">
+      <path d="M 10 2
+               l 13.484 0
+               A 26 26 0 0 1 46 15
+               A 26 26 0 0 1 23.484 28
+               L 10 28
+               A 26 26 0 0 0 10 2
+               M 0  6 l 12 0
+               M 0 24 l 12 0
+               M 46 15 L 60 15
+               M 6 2 A 26 26 0 0 1 6 28
+               "
+            stroke-linecap="round"
+            fill="transparent"
+            stroke="black"/>
+    </symbol>
+
+    <symbol id="not">
+      <path d="M 10 2
+               L 32.516 15
+               L 10 28
+               Z
+               M 33 15 A 4 4 0 0 0 41 15
+               M 33 15 A 4 4 0 0 1 41 15
+               M 41 15 L 60 15
+               M 0 15 L 10 15
+               "
+            stroke-linecap="round"
+            fill="transparent"
+            stroke="black"/>
+    </symbol>
+
+
+  </defs>

data/lib/rtl/fdgd.rb

@@ -0,0 +1,110 @@
+require_relative 'graph'
+require_relative 'vector'
+
+
+  class Fdgd
+
+    attr_accessor :graph
+    attr_accessor :stop
+
+    def initialize graph=nil
+      puts "FDGD: force-directed graph drawer"
+      @graph=graph
+      @l0=80
+      @c1=30
+      @epsilon=10
+      @damping=0.92
+      @timestep=0.1
+      @stop=false
+    end
+
+    def dist a,b
+      Math.sqrt((a.x - b.x)**2 + (a.y - b.y)**2)
+    end
+
+    def angle a,b
+      if dist(a,b)!=0
+        if b.x > a.x
+          angle = Math.asin((b.y-a.y)/dist(a,b))
+        else
+          angle = Math::PI - Math.asin((b.y-a.y)/dist(a,b))
+        end
+      else
+        angle =0
+      end
+      return angle
+    end
+
+    def coulomb_repulsion a,b
+      angle = angle(a,b)
+      dab = dist(a,b)
+      c= -0.2*(a.radius*b.radius)/Math.sqrt(dab)
+      [c*Math.cos(angle),c*Math.sin(angle)]
+    end
+
+    def sign_minus(a,b)
+      a>b ? 1 : -1
+    end
+
+    def hooke_attraction a,b #,c1=10#,l0=40
+      angle = angle(a,b)
+      dab = dist(a,b)
+      c = @c1*Math.log((dab-@l0).abs)*sign_minus(dab,@l0)
+      [c*Math.cos(angle),c*Math.sin(angle)]
+    end
+
+    def run iter=2
+      if @graph
+        Thread.new do
+          step = 0
+          total_kinetic_energy=1000
+          next_pos={}
+          next_speed={}
+          until total_kinetic_energy < @epsilon or step==iter do
+
+            step+=1
+            total_kinetic_energy = 0
+
+            for node in graph.nodes
+              net_force = Vector.new(0, 0)
+
+              for other in graph.nodes-[node]
+                rep = coulomb_repulsion( node, other)
+                net_force += rep
+              end
+
+              for edge in graph.edges.select{|e| e.source==node or e.sink==node}
+                other = edge.sink==node ? edge.source : edge.sink
+                attr = hooke_attraction(node, other) #, c1=30,@l0)
+                net_force += attr
+              end
+
+              # without damping, it moves forever
+              speed = (node.speed + net_force.scale(@timestep)).scale(@damping)
+              next_pos[node.id]   = node.pos + speed.scale(@timestep)
+              next_speed[node.id] = speed
+              total_kinetic_energy += node.radius * speed.squared
+            end
+
+            #puts total_kinetic_energy
+            yield if block_given?
+            #update nodes position
+            for node in graph.nodes
+              unless node.fixed.x
+                node.pos.x = next_pos[node.id].x
+                node.speed.x = next_speed[node.id].x
+              end
+              unless node.fixed.y
+                node.pos.y = next_pos[node.id].y
+                node.speed.y = next_speed[node.id].y
+              end
+            end
+            break if @stop
+          end
+          puts "algorithm end"
+          puts "reached epsilon" if total_kinetic_energy < @epsilon
+          puts "reached max iterations" if step==iter
+        end #thread
+      end
+    end
+  end

data/lib/rtl/graph.rb

@@ -0,0 +1,156 @@
+require_relative 'vector'
+require_relative 'json_parser'
+
+class Node
+  attr_accessor :id,:pos,:dims,:speed,:fixed,:radius
+  def initialize params={}
+    puts "creating node #{params}"
+    @id    =params["id"]
+    @radius=params["radius"] || rand(5..10)
+    @pos   =Vector.new *params["pos"]
+    @speed =Vector.new *(params["speed"] || [0,0])
+    @fixed =Vector.new *(params["fixed"] || [false,false])
+    @dims  =Vector.new *(params["dims"]  || [10,5])
+  end
+
+  def x=(v)
+    @pos[0]=v
+  end
+
+  def y=(v)
+    @pos[1]=v
+  end
+
+  def x
+    @pos.first
+  end
+
+  def y
+    @pos.last
+  end
+
+  def print_info
+    pp "node #{@id} : pos=#{@pos},dims=#{@dims},v=#{@velocity}"
+  end
+end
+
+class Edge
+  attr_accessor :source,:sink
+  def initialize params={}
+    unless params.empty?
+      @source=params["source"]
+      @sink  =params["sink"]
+      puts "creating edge #{@source.id}-->#{@sink.id}"
+    end
+  end
+end
+
+class Graph
+
+  attr_accessor :nodes,:id,:edges,:map
+
+  def initialize id=nil,nodes=[],edges=[]
+    @id=id
+    @nodes,@edges=nodes,edges
+  end
+
+  def self.read_file filename
+    Parser.new.parse filename
+  end
+
+  def write_file filename
+    json=Code.new
+    json << "{"
+    json.indent=2
+    json << "\"id\" : \"#{id}\","
+    json << "\"nodes\" : ["
+    json.indent=4
+    nodes.each{|node| json << json_node(node)}
+    json.indent=2
+    json << "],"
+    json << "\"edges\" : ["
+    json.indent=4
+    edges.each{|edge| json << json_edge(edge)}
+    json.indent=2
+    json << "]"
+    json.indent=0
+    json << "}"
+    code=json.finalize
+    code.gsub!(/\,\s*\]/,']')
+    json=Code.new(code)
+    json.save_as filename
+  end
+
+  def json_node node
+    fixed=node.fixed.to_s
+    "{\"id\":\"#{node.id}\",\"pos\":#{node.pos.to_s},\"speed\":#{node.speed.to_s},\"fixed\":#{fixed}},"
+  end
+
+  def json_edge edge
+    "{\"source\":\"#{edge.source.id}\",\"sink\":\"#{edge.sink.id}\"},"
+  end
+
+  def self.random(nbVertex,maxNbEdgesPerVertex=2)
+    nodes=(1..nbVertex).map{|i|
+      h={
+        "id" => "#{i}",
+        "pos"=> [rand(1000),rand(1000)]
+      }
+      Node.new(h)
+    }
+    edges=[]
+    nodes.each_with_index do |node,idx|
+      nb_edges=rand(0..maxNbEdgesPerVertex)
+      nb_edges.times do
+        edge=Edge.new
+        edge.source=node
+        edge.sink=sink=nodes.sample
+        (edges << edge) unless nodes.index(sink)==idx
+      end
+    end
+    Graph.new("g",nodes,edges)
+  end
+
+  def shuffle range=0..800
+    @nodes.each do |node|
+      nx,ny=rand(range),rand(range)
+      node.pos=Vector.new(nx,ny)
+    end
+  end
+
+  def print_info
+    puts "graph info".center(40,"=")
+    puts "#vertices".ljust(30,'.')+nodes.size.to_s
+    puts "#edges".ljust(30,'.')+edges.size.to_s
+
+    puts "nodes".center(40,'-')
+    nodes.each do |node|
+      puts "#{node.id.ljust(10)} #{node.pos.x} #{node.pos.y}"
+    end
+    puts "edges".center(40,'-')
+    edges.each do |edge|
+      puts "#{edge.source.id} --> #{edge.sink.id}"
+    end
+  end
+
+  def self.rand_between min,max
+    (min..max).to_a.sample
+  end
+
+  def self.random_pos(maxx=800,maxy=600)
+    x,y=maxx/2,maxy/2
+    [self.rand_between(-x,x),self.rand_between(-y,y)]
+  end
+
+  def each_vertex &block
+    @nodes.each do |node|
+      yield node
+    end
+  end
+
+  def each_edge &block
+    @edges.each do |edge|
+      yield edge
+    end
+  end
+end

data/lib/rtl/json_parser.rb

@@ -0,0 +1,49 @@
+require "json"
+
+require_relative 'graph'
+
+class Parser
+  def parse filename
+    puts "parsing '#{filename}'"
+    json=JSON.parse(IO.read(filename))
+    gen_graph json
+  end
+
+  def gen_graph json
+    @sym={}
+    graph=Graph.new
+    json.each do |key,val|
+      case key
+      when "id"
+        graph.id=val
+      when "nodes"
+        graph.nodes=gen_nodes(val)
+      when "edges"
+        graph.edges=gen_edges(val)
+      end
+    end
+    return graph
+  end
+
+  def gen_nodes json
+    json.map{|j| gen_node(j)}
+  end
+
+  def gen_node json
+    node=Node.new(json)
+    @sym[node.id]=node
+    node
+  end
+
+  def gen_edges json
+    json.map{|j| gen_edge(j)}
+  end
+
+  def gen_edge json
+    a=json.map{|k,v| {k => @sym[v]}}
+    Edge.new(a.inject(:merge))
+  end
+
+end
+
+#pp Parser.new.parse("line.sexp")

data/lib/rtl/placer.rb

@@ -0,0 +1,179 @@
+require_relative "fdgd"
+require_relative 'code'
+
+module RTL
+
+  class Placer
+
+    attr_accessor :circuit
+
+    def place circuit
+      puts "placing '#{circuit.name}'"
+      @circuit=circuit
+      puts "creating p&r graph"
+      nodes=gen_pnr_nodes(circuit)
+      edges=gen_pnr_edges(circuit)
+      graph=Graph.new(circuit.name,nodes,edges)
+      graph.print_info
+      drawer=Fdgd.new(graph)
+      drawer.run 100
+      puts "final placement".center(40,'=')
+      graph.write_file "#{circuit.name}.json"
+      gen_svg graph
+    end
+
+
+    def gen_pnr_nodes circuit
+      nodes=[]
+      @sym={} # internal references for p&r
+      @map={} # link to RTL::Circuit objects
+      circuit.inputs.each_with_index do |port,idx|
+        id=port.object_id.to_s
+        dy=600.0/circuit.inputs.size
+        params={"id"    => id,
+                "pos"   => [10,idx*dy],
+                "fixed" => [true,false],
+        }
+        nodes << node=Node.new(params)
+        @sym[id]=node
+        @map[node]=port
+      end
+      circuit.outputs.each_with_index do |port,idx|
+        id=port.object_id.to_s
+        dy=600.0/circuit.outputs.size
+        params={"id"    => id,
+                "pos"   => [500,dy*idx],
+                "fixed" => [true,false],
+        }
+        nodes << node=Node.new(params)
+        @sym[id]=node
+        @map[node]=port
+      end
+      circuit.signals.each do |port|
+        id=port.object_id.to_s
+        params={"id"    => id,
+                "pos"   => [rand(600),rand(600)]
+        }
+        nodes << node=Node.new(params)
+        @sym[id]=node
+        @map[node]=port
+      end
+      circuit.components.each do |comp|
+        id=comp.object_id.to_s
+        params={"id"    => id,
+                "pos"   => [rand(300),rand(300)],
+        }
+        nodes << node=Node.new(params)
+        @sym[id]=node
+        @map[node]=comp
+      end
+      nodes
+    end
+
+    def gen_pnr_edges circuit
+      edges=[]
+      circuit.inputs.each do |input|
+        input.fanout.each do |wire|
+          psource=wire.source
+          if psource.circuit==circuit #psink is a port of current circuit
+            source=psource
+          else
+            source=psource.circuit # one of the components
+          end
+          psink=wire.sink
+          if psink.circuit==circuit #psink is a port of current circuit
+            sink=psink
+          else
+            sink=psink.circuit # one of the components
+          end
+          id_source=source.object_id.to_s
+          id_sink  =sink.object_id.to_s
+          node_source=@sym[id_source]
+          node_sink=@sym[id_sink]
+          params={"source"    => node_source,
+                  "sink"      => node_sink
+          }
+          edges << Edge.new(params)
+        end
+      end
+      circuit.signals.each do |sig|
+        sig.fanout.each do |wire|
+          psource=wire.source
+          if psource.circuit==circuit #psink is a port of current circuit
+            source=psource
+          else
+            source=psource.circuit # one of the components
+          end
+          psink=wire.sink
+          if psink.circuit==circuit #psink is a port of current circuit
+            sink=psink
+          else
+            sink=psink.circuit # one of the components
+          end
+          id_source=source.object_id.to_s
+          id_sink  =sink.object_id.to_s
+          node_source=@sym[id_source]
+          node_sink=@sym[id_sink]
+          params={"source"    => node_source,
+                  "sink"      => node_sink
+          }
+          edges << Edge.new(params)
+        end
+      end
+      circuit.components.each do |comp|
+        comp.outputs.each do |output|
+          output.fanout.each do |wire|
+            psource=wire.source
+            if psource.circuit==circuit #psink is a port of current circuit
+              source=psource
+            else
+              source=psource.circuit # one of the components
+            end
+            psink=wire.sink
+            if psink.circuit==circuit #psink is a port of current circuit
+              sink=psink
+            else
+              sink=psink.circuit # one of the components
+            end
+            id_source=source.object_id.to_s
+            id_sink  =sink.object_id.to_s
+            node_source=@sym[id_source]
+            node_sink=@sym[id_sink]
+            params={"source"    => node_source,
+                    "sink"      => node_sink
+            }
+            edges << Edge.new(params)
+          end
+        end
+      end
+      edges
+    end
+
+    SVG_ELEMENT={
+        "and"  => "and2",
+        "nand" => "nand2",
+        "or"   => "or2",
+        "nor"  => "nor2",
+        "xor"  => "xor2",
+        "not"  => "not",
+    }
+    def gen_svg graph
+      svg=Code.new
+      svg << "<svg width=\"600\" height=\"300\""
+      svg << "     xmlns=\"http://www.w3.org/2000/svg\""
+      svg << "     xmlns:xlink=\"http://www.w3.org/1999/xlink\">"
+      svg << IO.read("/home/jcll/JCLL/dev/EDA-ESL/rtl/lib/rtl/def_gates.svg")
+      graph.nodes.each do |node|
+        circuit=@map[node]
+        klass=circuit.class.to_s.split("::").last.downcase
+        element=SVG_ELEMENT[klass] || "not"
+        pos=node.pos
+        x,y=pos.x,pos.y
+        svg << "<use xlink:href=\"##{element}\"  x=\"#{x}\" y=\"#{y}\"/>"
+      end
+      svg << "</svg>"
+      filename="#{circuit.name}_pnr.svg"
+      svg.save_as filename
+    end
+  end
+end

data/lib/rtl/printer.rb

@@ -12,7 +12,7 @@ module RTL
       circuit.components.each do |comp|
         inputs_dot ="{"+comp.ports[:in].collect{|e| "<#{e.name}>#{e.name}"}.join("|")+"}"
         outputs_dot="{"+comp.ports[:out].collect{|e| "<#{e.name}>#{e.name}"}.join("|")+"}"
-        p color=circuit.color
+        color=circuit.color
         dot << "#{comp.iname}[ shape=record; style=filled ; color=#{color} ; label=\"{ #{inputs_dot}| #{comp.name} | #{outputs_dot} }\"];"
       end
       circuit.ports[:in].each do |p|

data/lib/rtl/vector.rb

@@ -0,0 +1,66 @@
+class Vector
+  def initialize x=nil,y=nil
+    @array=[x,y]
+  end
+
+  def x
+    return @array[0]
+  end
+
+  def y
+    return @array[1]
+  end
+
+  def x=(v)
+    @array[0]=v
+  end
+
+  def y=(v)
+    @array[1]=v
+  end
+
+  def first
+    @array.first
+  end
+
+  def last
+    @array.last
+  end
+
+  def [](idx)
+    @array[idx]
+  end
+
+  def []=(idx,val)
+    @array[idx]=val
+  end
+
+  def +(other)
+    res=Vector.new
+    @array.each_with_index do |e,i|
+      res[i]=e + other[i]
+    end
+    return res
+  end
+
+  def scale int
+    res=Vector.new
+    @array.each_with_index do |e,i|
+      res[i]=e*int
+    end
+    return res
+  end
+
+  def squared
+    res=0
+    @array.each do |e|
+      res+=e*e
+    end
+    return res
+  end
+
+  def to_s
+    "[#{@array.join(',')}]"
+  end
+
+end

data/lib/rtl/viewer.rb

@@ -0,0 +1,267 @@
+require 'gtk3'
+
+require_relative 'fdgd'
+require_relative 'canvas'
+
+class Viewer < Gtk::Window
+
+  def initialize args={} # I want to show it's possible to pass some args
+    super()              # mandatory parenthesis ! otherwise : wrong arguments: Gtk::Window#initialize({})
+    set_title 'jcll_3'
+    set_default_size 900,600
+    set_border_width 10
+    set_window_position :center
+    set_destroy_callback
+
+    @algorithm=Fdgd.new
+    @zoom_factor=1
+    @shift=Vector.new(0,0)
+
+    hbox = Gtk::Box.new(:horizontal, spacing=6)
+    add hbox
+    @canvas = Canvas.new
+    hbox.pack_start(@canvas,:expand=>true,:fill=> true)
+    #...instead of :
+    # hbox.add canvas
+
+    vbox   = Gtk::Box.new(:vertical,spacing=6)
+    hbox.add vbox
+
+    button = Gtk::Button.new(label:"open")
+    button.signal_connect("clicked"){on_open_clicked(button)}
+    vbox.pack_start(button,:expand => false, :fill => false, :padding => 0)
+
+    button = Gtk::Button.new(label:"random graph")
+    button.signal_connect("clicked"){on_random_clicked(button)}
+    vbox.pack_start(button,:expand => false, :fill => false, :padding => 0)
+
+    label = Gtk::Label.new("number of nodes : ")
+
+    vbox.pack_start(label,:expand => false, :fill => false, :padding => 0)
+
+    spinner = Gtk::SpinButton.new(1,100,1)
+    spinner.value= @nb_value || 20
+    spinner.signal_connect("value-changed"){on_spin_changed(spinner)}
+    vbox.pack_start(spinner,:expand => false, :fill => false, :padding => 0)
+
+    button = Gtk::Button.new(:label => "run")
+    button.signal_connect("clicked"){on_run_clicked(button)}
+    vbox.pack_start(button,:expand => false, :fill => false, :padding => 0)
+
+    button = Gtk::Button.new(:label => "stop")
+    button.signal_connect("clicked"){on_stop_clicked(button)}
+    vbox.pack_start(button,:expand => false, :fill => false, :padding => 0)
+
+    button = Gtk::Button.new(:label => "step")
+    button.signal_connect("clicked"){on_step_clicked(button)}
+    vbox.pack_start(button,:expand => false, :fill => false, :padding => 0)
+
+    button = Gtk::Button.new(:label => "shuffle")
+    button.signal_connect("clicked"){on_shuffle_clicked(button)}
+    vbox.pack_start(button,:expand => false, :fill => false, :padding => 0)
+
+    button = Gtk::Button.new(:label => "center")
+    button.signal_connect("clicked"){on_center_clicked(button)}
+    vbox.pack_start(button,:expand => false, :fill => false, :padding => 0)
+
+    button = Gtk::Button.new(:label => "zoom+")
+    button.signal_connect("clicked"){on_zoom_clicked(button)}
+    vbox.pack_start(button,:expand => false, :fill => false, :padding => 0)
+
+    button = Gtk::Button.new(:label => "zoom-")
+    button.signal_connect("clicked"){on_unzoom_clicked(button)}
+    vbox.pack_start(button,:expand => false, :fill => false, :padding => 0)
+
+    button = Gtk::Button.new(:label => "zoom fit")
+    button.signal_connect("clicked"){on_fit_clicked(button)}
+    vbox.pack_start(button,:expand => false, :fill => false, :padding => 0)
+
+    button = Gtk::Button.new(:label => "save")
+    button.signal_connect("clicked"){on_save_clicked(button)}
+    vbox.pack_start(button,:expand => false, :fill => false, :padding => 0)
+
+    button = Gtk::Button.new(:label => "quit")
+    button.signal_connect("clicked"){on_quit_clicked(button)}
+    vbox.pack_start(button,:expand => false, :fill => false, :padding => 0)
+    show_all
+  end
+
+  def on_open_clicked button
+    puts '"open" button was clicked'
+    dialog=Gtk::FileChooserDialog.new(
+             :title => "choose",
+             :parent => self,
+             :action => Gtk::FileChooserAction::OPEN,
+				     :buttons => [[Gtk::Stock::OPEN, Gtk::ResponseType::ACCEPT],
+				                  [Gtk::Stock::CANCEL, Gtk::ResponseType::CANCEL]])
+    filter_json = Gtk::FileFilter.new
+    filter_json.name = "json filter"
+    filter_json.add_pattern("*.json")
+    dialog.add_filter(filter_json)
+
+    dialog.show_all
+
+    case dialog.run
+    when Gtk::ResponseType::ACCEPT
+      puts "filename = #{dialog.filename}"
+      #puts "uri = #{dialog.uri}"
+      @graph=Graph.read_file dialog.filename
+      puts @graph
+      @canvas.redraw @graph
+      set_title @graph.id
+      dialog.destroy
+    else
+      dialog.destroy
+    end
+  end
+
+  def on_random_clicked button
+    puts 'button "random" clicked'
+    set_title "random"
+    @graph=Graph.random(@nb_nodes || 20)
+    @canvas.running=true
+    @canvas.redraw @graph,@zoom_factor,@shift
+  end
+
+  def on_spin_changed spinbutton
+    value=spinbutton.value
+    puts "spin button modified #{value}"
+    @nb_nodes=value.to_i
+    @graph=Graph.random(value.to_i)
+    @canvas.running=true
+    @canvas.redraw @graph
+  end
+
+  def on_run_clicked button
+    puts 'button "run" clicked'
+    @canvas.running=true
+    @algorithm.stop=false
+    @algorithm.graph=@graph
+    @algorithm.run(iter=1000){@canvas.redraw @graph,@zoom_factor,@shift}
+  end
+
+  def on_stop_clicked button
+    puts 'button "stop" clicked'
+    @algorithm.stop=true
+  end
+
+  def on_step_clicked button
+    puts 'button "step" clicked'
+    @algorithm.run(iter=1){@canvas.redraw @graph,@zoom_factor,@shift}
+  end
+
+  def on_shuffle_clicked button
+    puts 'button "shuffle" clicked'
+    if @graph
+      @graph.shuffle
+      @canvas.redraw @graph,@zoom_factor,@shift
+    end
+  end
+
+  def on_center_clicked button
+    puts 'button "center" clicked'
+    if @graph
+      compute_shift get_enclosing_rect
+      @canvas.redraw @graph,@zoom_factor,@shift
+    end
+  end
+
+  def on_zoom_clicked button
+    puts 'button "zoom" clicked'
+    if @graph
+      @zoom_factor*=1.2
+      @canvas.redraw @graph,@zoom_factor,@shift
+    end
+  end
+
+  def on_unzoom_clicked button
+    puts 'button "unzoom" clicked'
+    if @graph
+      @zoom_factor/=1.2
+      @canvas.redraw @graph,@zoom_factor,@shift
+    end
+  end
+
+  def on_fit_clicked button
+    puts 'button "fit" clicked'
+    if @graph
+      compute_zoom_and_shift
+      @canvas.redraw @graph,@zoom_factor,@shift
+    end
+  end
+
+  def get_enclosing_rect
+    min_x=@graph.nodes.min_by{|node| node.x}.x
+    min_y=@graph.nodes.min_by{|node| node.y}.y
+    max_x=@graph.nodes.max_by{|node| node.x}.x
+    max_y=@graph.nodes.max_by{|node| node.y}.y
+    [Vector.new(min_x,min_y),Vector.new(max_x,max_y)]
+  end
+
+  def compute_zoom_and_shift
+    enclosing_rect=get_enclosing_rect()
+    compute_zoom(enclosing_rect)
+    compute_shift(enclosing_rect)
+  end
+
+  def compute_zoom enclosing_rect
+    min_x=enclosing_rect.first.x
+    min_y=enclosing_rect.first.y
+    max_x=enclosing_rect.last.x
+    max_y=enclosing_rect.last.y
+
+    graph_size=[(max_x-min_x).abs,(max_y-min_y).abs]
+    canvas_size=[@canvas.allocation.width,@canvas.allocation.height]
+    ratios=[(canvas_size.first.to_f)/graph_size.first,(canvas_size.last.to_f)/graph_size.last]
+    @zoom_factor=ratios.min*0.8
+    puts "zoom=#{@zoom_factor}"
+  end
+
+  def compute_shift enclosing_rect
+    rect_center_x=(enclosing_rect.first.x+enclosing_rect.last.x)/2.0
+    rect_center_y=(enclosing_rect.first.y+enclosing_rect.last.y)/2.0
+    @shift=Vector.new(-rect_center_x,-rect_center_y)
+  end
+
+  def on_save_clicked button
+    puts 'button "save" clicked'
+
+    dialog=Gtk::FileChooserDialog.new(
+             :title => "choose",
+             :parent => self,
+             :action => Gtk::FileChooserAction::SAVE,
+				     :buttons => [[Gtk::Stock::SAVE, Gtk::ResponseType::ACCEPT],
+				                  [Gtk::Stock::CANCEL, Gtk::ResponseType::CANCEL]])
+    filter_sexp = Gtk::FileFilter.new
+    filter_sexp.name = "s-expr filter"
+    filter_sexp.add_pattern("*.sexp")
+    filter_sexp.add_pattern("*.sxp")
+    dialog.add_filter(filter_sexp)
+
+    dialog.show_all
+
+    case dialog.run
+    when Gtk::ResponseType::ACCEPT
+      puts "filename = #{dialog.filename}"
+      #puts "uri = #{dialog.uri}"
+      @graph.id=File.basename(dialog.filename,'.sexp')
+      @graph.write_file dialog.filename
+      dialog.destroy
+    else
+      dialog.destroy
+    end
+  end
+
+  def on_quit_clicked button
+    puts "Closing application"
+    Gtk.main_quit
+  end
+
+  def set_destroy_callback
+    signal_connect("destroy"){Gtk.main_quit}
+  end
+
+end
+
+window=Viewer.new
+Gtk.main

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rtl_circuit
 version: !ruby/object:Gem::Version
-  version: '0.7'
+  version: 0.7.4
 platform: ruby
 authors:
 - Jean-Christophe Le Lann
@@ -17,10 +17,18 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/rtl.rb
+- lib/rtl/canvas.rb
 - lib/rtl/circuit.rb
 - lib/rtl/code.rb
+- lib/rtl/def_gates.svg
+- lib/rtl/fdgd.rb
+- lib/rtl/graph.rb
+- lib/rtl/json_parser.rb
 - lib/rtl/library.rb
+- lib/rtl/placer.rb
 - lib/rtl/printer.rb
+- lib/rtl/vector.rb
+- lib/rtl/viewer.rb
 - tests/json/testing_json.rb
 - tests/pnr/pnr_0.rb
 - tests/pnr/pnr_1.rb