--- /dev/null
+#!/usr/bin/env python
+
+# This file is part of LilyPond, the GNU music typesetter.
+#
+# Copyright (C) 2012 Joe Neeman <joeneeman@gmail.com>
+#
+# LilyPond 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.
+#
+# LilyPond 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 LilyPond. If not, see <http://www.gnu.org/licenses/>.
+
+# A GTK+ program for debugging skylines. The program reads a sequence
+# of line segments from stdin (one line segment per line of stdin, in the format
+# '(x1, y1) (x2, y2)'). A skyline is terminated by an empty line, which
+# causes the skyline to be displayed on the screen.
+
+from threading import Thread
+from math import isinf
+import gtk
+import gobject
+import goocanvas
+import sys
+import re
+
+class GtkSkylineCanvas (goocanvas.Canvas):
+ """A Canvas for displaying skylines."""
+ def __init__ (self):
+ super (GtkSkylineCanvas, self).__init__ ()
+ self.connect ('size-allocate', GtkSkylineCanvas.rescale)
+ self.x_min = float ('inf')
+ self.x_max = float ('-inf')
+ self.y_min = float ('inf')
+ self.y_max = float ('-inf')
+
+ self.colors = ('black', 'red', 'green', 'blue', 'maroon', 'olive', 'teal')
+ self.cur_color_index = 0
+
+ def rescale (self, allocation):
+ width = (self.x_max - self.x_min + 1) * 1.1
+ height = (self.y_max - self.y_min + 1) * 1.1
+ if width <= 0 or height <= 0:
+ return
+
+ scale_x = allocation.width / width
+ scale_y = allocation.height / height
+ scale = min (scale_x, scale_y)
+ self.set_scale (scale)
+
+ center_x = (self.x_max + self.x_min) / 2
+ center_y = (self.y_max + self.y_min) / 2
+ actual_width = allocation.width / scale
+ actual_height = allocation.height / scale
+ actual_min_x = center_x - actual_width / 2
+ actual_max_x = center_x + actual_width / 2
+ actual_min_y = center_y - actual_height / 2
+ actual_max_y = center_y + actual_height / 2
+
+ self.set_bounds (actual_min_x, actual_min_y, actual_max_x, actual_max_y)
+ self.scroll_to (actual_min_x, actual_min_y)
+
+ def add_skyline (self, lines):
+ """Adds a skyline to the current canvas, in a new color.
+
+ The canvas will be rescaled, if necessary, to make room for the
+ new skyline."""
+ # Flip vertically, because goocanvas thinks higher numbers are
+ # further down, while lilypond thinks they're further up.
+ lines = [(x1, -y1, x2, -y2) for (x1, y1, x2, y2) in lines]
+
+ color = self.colors[self.cur_color_index]
+ self.cur_color_index = (self.cur_color_index + 1) % len (self.colors)
+
+ # Update the bounding box of the skylines.
+ x_vals = [s[0] for s in lines] + [s[2] for s in lines]
+ y_vals = [s[1] for s in lines] + [s[3] for s in lines]
+ self.x_min = min ([self.x_min] + x_vals)
+ self.x_max = max ([self.x_max] + x_vals)
+ self.y_min = min ([self.y_min] + y_vals)
+ self.y_max = max ([self.y_max] + y_vals)
+
+ # Add the lines to the canvas.
+ root = self.get_root_item ()
+ for (x1, y1, x2, y2) in lines:
+ goocanvas.polyline_new_line (root, x1, y1, x2, y2,
+ stroke_color=color,
+ line_width=0.05)
+ self.rescale (self.get_allocation ())
+
+# We want to run the gtk main loop in a separate thread so that
+# the main thread can be responsible for reading stdin.
+class SkylineWindowThread (Thread):
+ """A thread that runs a Gtk.Window displaying a skyline."""
+
+ def run (self):
+ gtk.gdk.threads_init ()
+ self.window = None
+ self.canvas = None
+ gtk.main ()
+
+ # This should only be called from the Gtk main loop.
+ def _destroy_window (self, window):
+ sys.exit (0)
+
+ # This should only be called from the Gtk main loop.
+ def _setup_window (self):
+ if self.window is None:
+ self.window = gtk.Window ()
+ self.canvas = GtkSkylineCanvas ()
+ self.window.add (self.canvas)
+ self.window.connect ("destroy", self._destroy_window)
+ self.window.show_all ()
+
+ # This should only be called from the Gtk main loop.
+ def _add_skyline (self, lines):
+ self._setup_window ()
+ self.canvas.add_skyline (lines)
+
+ def add_skyline (self, lines):
+ # Copy the lines, just in case someone modifies them.
+ gobject.idle_add (self._add_skyline, list (lines))
+
+thread = SkylineWindowThread ()
+thread.setDaemon (True)
+thread.start ()
+
+def lines(infile):
+ line = infile.readline()
+ while len(line) > 0:
+ yield line[:-1]
+ line = infile.readline()
+
+point_re_str = r'\(([a-z.0-9-]*) *,([a-z0-9.-]*)\)'
+line_re_str = point_re_str + r' +' + point_re_str
+line_re = re.compile (line_re_str)
+
+# The main loop just reads lines from stdin and feeds them to the
+# display.
+current_skyline = []
+for line in lines(sys.stdin):
+ if not line:
+ thread.add_skyline(current_skyline)
+ current_skyline = []
+ continue
+
+ m = re.search (line_re, line)
+ if m is None:
+ print('line did not match')
+ else:
+ pts = map(float, m.groups())
+ if not any(map(isinf, pts)):
+ current_skyline.append(pts)
projects / lilypond.git / blobdiff