tkar 0.63

data/examples/dial.rb

@@ -0,0 +1,172 @@
+#!/usr/bin/env ruby
+
+# based on the 24hr_clock example from the tkruby demos
+
+# run like this: ruby dial.rb | tkar
+
+# Do the housekeeping associated with each step in the animation
+def draw s, delay = nil
+  puts s # note if s is array, it is joined with "\n"
+  if delay
+    puts "wait #{delay}"
+  end
+  puts "update"
+  $stdout.flush
+end
+
+# Output the shape def for a circle
+def circle radius, foreground, background
+  coords = [-radius, -radius, radius, radius]
+  "oval#{coords.join(",")},fc:#{foreground},oc:#{background}"
+end
+
+# Output the shape def for a clock hand
+def hand length, width, offset, color
+  coords = [
+    0, -offset,
+    width, -offset-width,
+    width, -length+width,
+    0, -length,
+    -width, -length+width,
+    -width, -offset-width
+  ]
+  "poly#{coords.join(",")},fc:#{color},oc:#{color}"
+end
+
+def mark radius, length, width, color, font = nil, offset = nil, text = nil
+  coords = [radius-length, 0, radius, 0]
+  
+  s = "line#{coords.join(",")},wi:#{width},fc:#{color}"
+  
+  if text
+    s << " text#{radius+offset},0,anchor:center,justify:center,text:#{text}"
+    s << ",fc:#{color},font:#{font}"
+  end
+
+  return s
+end
+
+def pie radius, extent, start, color
+  "arc0,0,#{radius},#{radius},extent:#{extent},start:#{start},style:pieslice," +
+    "fill:#{color}"
+end
+
+# Parameters for this drawing
+
+size              = 200
+radius            = size*0.9
+cdot_size         = 5
+cdot_color        = 'black'
+hour_hand_color   = 'black'
+minute_hand_color = 'gray25'
+second_hand_color = 'gray50'
+face_color        = "white"
+
+mark_font     = "-*-Helvetica-Bold-R-Normal--*-100-*-*-*-*-*-*"
+mark_width    = 3
+mark_color    = 'black'
+submark_color = 'gray50'
+
+hour_hand_len   = 0.55*size
+minute_hand_len = 0.85*size
+second_hand_len = 0.88*size
+
+hour_hand_width   = 1.8*cdot_size
+minute_hand_width = 1.0*cdot_size
+second_hand_width = 0.4*cdot_size
+
+# Draw the shapes
+
+draw %{
+
+  # window setup
+  
+  title dial example
+  background gray90
+  width #{2*size + 20}
+  height #{2*size + 20}
+  zoom 1.0
+
+  # shape definitions (most are not parametrized because they do not need
+  # to change shape or color dynamically or have individual configuration
+  # other than position and rotation)
+  
+  shape face #{circle(radius, face_color, "black")}
+
+  shape cdot #{circle(cdot_size, cdot_color, cdot_color)}
+
+  shape hour_hand #{
+    hand(hour_hand_len, hour_hand_width, cdot_size*0.5, hour_hand_color)
+  }
+
+  shape minute_hand #{
+    hand(minute_hand_len, minute_hand_width, cdot_size*0.5, minute_hand_color)
+  }
+
+  shape second_hand #{
+    hand(second_hand_len, second_hand_width, cdot_size*0.5, second_hand_color)
+  }
+  
+  shape mark #{
+    mark(radius, radius*0.025, mark_width, submark_color)
+  }
+  
+  # params: *0 is text
+  shape labelled_mark #{
+    mark(radius, radius*0.05, mark_width, mark_color,
+         mark_font, radius*0.1, "*0")
+  }
+  
+  # params: *0 is extent angle, *1 is start angle, *2 is color
+  shape pie #{
+    pie(radius, "*0", "*1", "*2")
+  }
+
+  # Add some objects
+  
+  #   shape         ID    flags   layer   x   y   rot   params...
+  #--------------------------------------------------------------
+
+  add face          1     -       10      0   0   0
+  add cdot          2     -       20      0   0   0
+  add hour_hand     3     -       15      0   0   0
+  add minute_hand   4     -       16      0   0   0
+  add second_hand   5     -       17      0   0   0
+  add pie           6     -       12      0   0   0     15  75   red
+  add pie           7     -       12      0   0   0     67 -72   green
+  add pie           8     -       12      0   0   0     17 187   blue
+}
+
+draw %{
+  # move the view to the right place to see object #1
+  view_id 1
+}
+
+mark_strs = (0..11).map do |i|
+  "add mark   #{100+i}     -       14      0   0  #{30*i+15}"
+end
+
+draw mark_strs
+
+labelled_mark_strs = (0..11).map do |i|
+  "add labelled_mark #{200+i}     -       14      0   0   #{30*i-90}   #{i*2}"
+end
+
+draw labelled_mark_strs
+
+# Animate!
+
+1_000_000.times do |i|
+  h = i*0.001
+  draw %{
+    rot 3 #{h}
+    rot 4 #{60*h}
+    rot 5 #{60*60*h}
+#    param 201 0 #{i}
+#    param 8 0 #{i%100}
+#    param 7 2 ##{s="%06x"%(i*32)}
+  }
+end
+
+$stderr.puts "Press Enter to finish"
+gets

data/examples/mkgrid.rb

@@ -0,0 +1,58 @@
+# mkgrid -- generate grid code for a tkar shape file
+#
+# To see what the grid looks like by itself:
+#
+#   ruby mkgrid.rb | tkar --radians --persist
+#
+# (The --radians is because this is designed to be used from
+# code that uses radians for angles. The --persist is because
+# this is just some static objects, not an animation, so it will
+# close after drawing without the persist option.)
+#
+# To use with other code, run like this:
+#
+#   ruby mkgrid > grid.shp
+#
+# Then, add a line like this to your shape file:
+#
+#   load grid.shp
+#
+# It doesn't really matter what part of the file you put the line in.
+# Near the top is ok.
+#
+# Make sure grid.shp is in the same dir as the shape file, or enter the
+# relative path.
+#
+# Adjust the parameters as needed: xmin, interval, mark_font, etc.
+#
+# You can disable the grid by commenting the "load grid.shp" line in
+# the shape file (insert a # character at the beginning of the line)
+#
+# Note: if you are using this without simulink, remember to use the --radians
+# option to tkar, otherwise it will look funny!
+
+mark_font = "-*-Helvetica-Bold-R-Normal--*-90-*-*-*-*-*-*"
+
+puts "shape grid_line line0,0,*0,0,wi:0.1,fc:black"
+puts "shape mark text0,0,anchor:sw,justify:center,text:*0,fc:red,font:#{mark_font}"
+puts
+
+id = 12000 # high enough not to interfere (hacky!)
+r = Math::PI/2 # when called from the tkar simulink block, tkar uses radians
+
+xmin = -2000; xmax = 2000; xmid = 0
+ymin = -2000; ymax = 2000; ymid = 0
+interval = 100
+
+xlen = xmax - xmin
+ylen = ymax - ymin
+
+(xmin..xmax).step(interval) do |x|
+    puts "add grid_line #{id+=1} - 0 #{x} #{ymin} #{r} #{ylen}"
+    puts "add mark      #{id+=1} - 0 #{x} #{ymid} 0    #{x}"
+end
+
+(ymin..ymax).step(interval) do |y|
+    puts "add grid_line #{id+=1} - 0 #{xmin} #{y} 0 #{xlen}"
+    puts "add mark      #{id+=1} - 0 #{xmid} #{y} 0 #{y}"
+end

data/examples/ps.rb

@@ -0,0 +1,47 @@
+# Visualization of cpu usage from ps output. Run like this:
+#
+# ruby ps.rb | tkar
+#
+# If you don't see the pids, scroll down.
+
+$stdout.sync = true
+
+puts %{
+title Process Status
+height 600
+width 600
+bg white
+update
+
+shape bar \
+  poly0,0,50,0,50,*0,0,*0,oc:black,width:2,fc:*2 \
+  text25,20,anchor:c,justify:center,width:50,text:*1,fc:black
+
+#     SHAPE_NAME      ID  FLAGS   LAYER     X     Y    R  PARAMS...
+add   bar             1      -     100     50   550    0  0 unknown blue
+add   bar             2      -     100    150   550    0  0 unknown blue
+add   bar             3      -     100    250   550    0  0 unknown blue
+add   bar             4      -     100    350   550    0  0 unknown blue
+add   bar             5      -     100    450   550    0  0 unknown blue
+update
+}
+
+PS_FIELDS   = "pcpu,pmem,s,time,pid,cmd"
+TOP_CPU_CMD = "ps -A --sort=-pcpu -o cputime,#{PS_FIELDS} | head -n 6"
+
+loop do
+  s = `#{TOP_CPU_CMD}`
+  a = s.map {|l| l[/[0-9:]*\s+(\S+)/, 1]}.map {|t| Float(t) rescue nil}.compact
+  b = s.map {|l| l[30,5]}.map {|t| Integer(t) rescue nil}.compact
+  i = 1
+  a.zip(b) do |pcpu, pid|
+    puts "param #{i} 1 #{pid}"
+    puts "param #{i} 0 -#{pcpu*5}"
+    i += 1
+    $stderr.puts [pcpu, pid].inspect
+  end
+  puts "update"
+  
+  sleep 1
+end
+

data/examples/rotate

@@ -0,0 +1,26 @@
+# Rotation is not a built-in operation in TkCanvas, but it is in tkar.
+# Run like:
+# 
+# cat rotate | tkar
+
+shape box poly0,0,10,0,10,10,0,10,fc:green,oc:red
+
+add box 3 - 4 50 20 0
+update
+
+wait 1.0
+rot 3 45
+update
+
+wait 1.0
+rot 3 90
+update
+
+wait 1.0
+rot 3 135
+update
+
+wait 1.0
+rot 3 180
+update
+

data/examples/s

@@ -0,0 +1,3 @@
+shape box rect*0,*0,*1,*1
+add box 1 - 5 10 10 0 
+update

data/examples/sample

@@ -0,0 +1,14 @@
+# This sample is written directly in the tkar protocol, rather
+# than generated by another program. Usually, you don't do this
+# directly, since it would be very tedious to enter all the
+# movement commands. To run it:
+#
+# cat sample | tkar --persist
+#
+# Note that you can drag the boxes around and see the commands on stdout.
+
+shape box rect50,50,0,0 rect5,5,10,10
+add box 3 - 4 10 10 0
+shape box2 rect10,10,0,1
+add box2 4 - 4 100 10 0
+

data/examples/sample.rb

@@ -0,0 +1,98 @@
+#!/usr/bin/env ruby
+
+# A sample of many of the TkCanvas features usable in tkar.
+#
+# Run like:
+#
+#  ruby sample.rb | tkar
+#
+# Not that if you click and drag on things, you can see the commands in the
+# stdout. If your program is listening to that stream, it can feedback into
+# the animation.
+
+puts %{
+title Strange bits of stuff: Tkar demo
+background gray95
+height 600
+width 600
+
+shape box polybox50,50,fc:*1,oc:*0  polybox5,5,fc:*0,oc:*1  \
+oval30,-30,60,-60,fc:white,oc:gray
+
+shape box2 polybox10,10,fc:*0,oc:*1
+
+shape cone arc*0,*1,*2,*2,fc:yellow,oc:black,extent:30,start:-15,style:pieslice
+
+shape thang polybox40,60,fc:*0,oc:*1,wi:5 \
+ polybox*2,10,fc:*1,oc:red,da:48,wi:3 \
+ cone20,40,60 \
+ line20,40,80,40,fc:purple,da:44
+
+shape radar \
+ cone0,0,*0 \
+ cone20,0,*0,style:chord \
+ cone40,0,*0,style:chord \
+ line0,0,-20,-20,*1,0,*1,*1,0,-60,arrow:last,arrowshape:10+8+6,\
+smooth:true,wi:2,fc:0x609000
+
+shape blob \
+ poly0,0,10,0,20,5,15,30,-3,6,-20,40,-15,-10,5,5,smooth:true,oc:red,fc:0 \
+ text0,50,anchor:c,justify:center,width:40,text:*0,fc:0 \
+ image25,50,anchor:c,image:home.gif
+
+add box 3 - 4 210 210 0 0xff0000 0x00ff00
+add box2 4 - 4 300 210 0 0x0000ff 0x00ff00
+update
+}
+
+$stdout.flush; sleep 1
+
+puts %{
+del 4
+update
+}
+
+$stdout.flush; sleep 1
+
+puts %{
+move 3 165 150
+param 3 0 0xffffff
+param 3 1 blue
+add box2 1 - 2 280 220 25 orange cyan
+add thang 2 - 3 200 200 45 magenta green 80
+add radar 6 - 5 360 360 25 60 -40
+add blob 7 - 6 140 280 0
+param 7 0 This is some text
+update
+}
+
+$stdout.flush; sleep 1
+
+45.step(3600,5) do |i|
+  xy = 200 + i/15.0
+  puts %{
+  rot 2 #{i}
+  move 2 #{xy} #{xy}
+  param 2 2 #{80-(i/30.0)}
+  rot 1 #{-i}
+  param 6 0 #{60+i%40}
+  param 6 1 #{-20-i%80}
+  update
+  }
+  $stdout.flush; #sleep 0.02
+end
+
+500.times do |i|
+  puts %{
+  scale 3 #{1.0 + 0.005 * Math::sin(i/100.0)} 1.0
+  update
+  }
+end
+
+$stdout.flush; sleep 1
+
+puts "done"
+$stdout.flush
+
+$stderr.puts "Press enter to finish."
+gets

data/examples/sample2

@@ -0,0 +1,48 @@
+# A very simple animation. Run like this:
+#
+# cat sample2 | tkar --persist
+
+# Global settings for the window
+title sample2
+height 500
+width 500
+bg azure1
+
+# -------------------------------------------------------------------------
+# Shape definitions
+shape box2 poly0,0,50,0,50,20,0,20,fc:red,oc:blue
+
+# -------------------------------------------------------------------------
+# Add some shapes
+# -------------------------------------------------------------------------
+#     SHAPE_NAME      ID  FLAGS   LAYER     X     Y   R    PARAMS...
+
+add   box2             1      -     100    10    10   0
+
+# -------------------------------------------------------------------------
+# draw them
+update
+
+# -------------------------------------------------------------------------
+# animate
+
+wait 1.0
+move 1 20 20
+rot 1 10
+update
+
+wait 1.0
+move 1 30 30
+rot 1 20
+update
+
+wait 1.0
+move 1 40 40
+rot 1 30
+update
+
+wait 1.0
+move 1 50 50
+rot 1 40
+update
+