Adding upstream version 2.10.22.upstream/2.10.22upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

2 files changed, 3701 insertions, 0 deletions

diff --git a/tools/performance-log-viewer b/tools/performance-log-viewer
new file mode 100755
index 0000000..2ef7f38
--- /dev/null
+++ b/tools/performance-log-viewer
@@ -0,0 +1,39 @@
+#!/bin/sh
+
+# performance-log-viewer -- GIMP performance log viewer driver
+# Copyright (C) 2018  Ell
+#
+# 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, see <https://www.gnu.org/licenses/>.
+#
+#
+# Usage: performance-log-viewer FILE
+
+if [ "$#" -ne 1 ]; then
+    echo "Usage: $0 FILE"
+
+    exit 1
+fi
+
+tools_dir="$(dirname "$(command -v -- "$0")")"
+file="$1"
+
+< "$file" || exit 1
+
+< "$file"                                              \
+"$tools_dir/performance-log-close-tags.py"           | \
+"$tools_dir/performance-log-progressive-coalesce.py" | \
+"$tools_dir/performance-log-expand.py"               | \
+"$tools_dir/performance-log-coalesce.py"             | \
+"$tools_dir/performance-log-deduce.py"               | \
+"$tools_dir/performance-log-viewer.py"
diff --git a/tools/performance-log-viewer.py b/tools/performance-log-viewer.py
new file mode 100755
index 0000000..8e87eb8
--- /dev/null
+++ b/tools/performance-log-viewer.py
@@ -0,0 +1,3662 @@
+#!/usr/bin/env python3
+
+"""
+performance-log-viewer.py -- GIMP performance log viewer
+Copyright (C) 2018  Ell
+
+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, see <https://www.gnu.org/licenses/>.
+
+
+Usage: performance-log-viewer.py < infile
+"""
+
+import builtins, sys, os, math, statistics, bisect, functools, enum, re, \
+       subprocess
+
+from collections import namedtuple
+from xml.etree   import ElementTree
+
+import gi
+gi.require_version ("Gdk", "3.0")
+gi.require_version ("Gtk", "3.0")
+from gi.repository import GLib, GObject, Gio, Gdk, Gtk, Pango
+
+def compose (head = None, *tail):
+    return (
+        lambda *args, **kwargs: head (compose (*tail) (*args, **kwargs))
+    ) if tail else head or (lambda x: x)
+
+def div (x, y):
+    return x / y     if y     else \
+           +math.inf if x > 0 else \
+           -math.inf if x < 0 else \
+           None
+
+def format_float (x):
+    return "%g" % (round (100 * x) / 100)
+
+def format_percentage (x, digits = 0):
+    return "%%.%df%%%%" % digits % (100 * x)
+
+def format_size (size):
+    return GLib.format_size_full (size, GLib.FormatSizeFlags.IEC_UNITS)
+
+def format_duration (t):
+    return "%02d:%02d:%02d.%02d" % (int (t / 3600),
+                                    int (t / 60) % 60,
+                                    int (t % 60),
+                                    round (100 * t) % 100)
+
+def format_color (color):
+    return "#%02x%02x%02x" % tuple (
+        map (lambda x: min (max (round (255 * x), 0), 255), color)
+    )
+
+def is_bright_color (color):
+    return max (tuple (color)[0:3]) > 0.5
+
+def blend_colors (color1, color2, amount):
+    color1 = tuple (color1)
+    color2 = tuple (color2)
+
+    a1 = color1[-1]
+    a2 = color2[-1]
+
+    a = (1 - amount) * a1 + amount * a2
+
+    return tuple (a and ((1 - amount) * a1 * c1 + amount * a2 * c2) / a
+                  for c1, c2 in zip (color1[:-1], color2[:-1])) + (a,)
+
+def rounded_rectangle (cr, x, y, width, height, radius):
+    radius = min (radius, width / 2, height / 2)
+
+    cr.arc (x + radius, y + radius, radius, -math.pi, -math.pi / 2)
+    cr.rel_line_to (width - 2 * radius, 0)
+
+    cr.arc (x + width - radius, y + radius, radius, -math.pi / 2, 0)
+    cr.rel_line_to (0, height - 2 * radius)
+
+    cr.arc (x + width - radius, y + height - radius, radius, 0, math.pi / 2)
+    cr.rel_line_to (-(width - 2 * radius), 0)
+
+    cr.arc (x + radius, y + height - radius, radius, math.pi / 2, math.pi)
+    cr.rel_line_to (0, -(height - 2 * radius))
+
+    cr.close_path ()
+
+def get_basename (path):
+    match = re.fullmatch (".*[\\\\/](.+?)[\\\\/]?", path)
+
+    return match[1] if match else path
+
+search_path = list (filter (
+    bool,
+    os.environ.get ("PERFORMANCE_LOG_VIEWER_PATH", ".").split (":")
+))
+
+editor_command  = os.environ.get ("PERFORMANCE_LOG_VIEWER_EDITOR",
+                                  "xdg-open {file}")
+editor_command += " &"
+
+def find_file (filename):
+    def lookup (filename):
+        filename = re.sub ("[\\\\/]", GLib.DIR_SEPARATOR_S, filename)
+
+        if GLib.path_is_absolute (filename):
+            file = Gio.File.new_for_path (filename)
+
+            if file.query_exists ():
+                return file
+
+        for path in search_path:
+            rest = filename
+
+            while rest:
+                file = Gio.File.new_for_path (GLib.build_filenamev ((path, rest)))
+
+                if file.query_exists ():
+                    return file
+
+                sep = rest.find (GLib.DIR_SEPARATOR_S)
+
+                rest = rest[sep + 1:] if sep >= 0 else ""
+
+        return None
+
+    if filename not in find_file.cache:
+        find_file.cache[filename] = lookup (filename)
+
+    return find_file.cache[filename]
+
+find_file.cache = {}
+
+def run_editor (file, line):
+    subprocess.call (editor_command.format (file = "\"%s\"" % file.get_path (),
+                                            line = line),
+                     shell = True)
+
+VariableType = namedtuple ("VariableType",
+                           ("parse", "format", "format_numeric"))
+
+var_types = {
+    "boolean": VariableType (
+        parse          = int,
+        format         = compose (str, bool),
+        format_numeric = format_float
+    ),
+
+    "integer": VariableType (
+        parse          = int,
+        format         = format_float,
+        format_numeric = None
+    ),
+
+    "size": VariableType (
+        parse          = int,
+        format         = format_size,
+        format_numeric = None
+    ),
+
+    "size-ratio": VariableType (
+        parse          = lambda x: div (*map (int, x.split ("/"))),
+        format         = format_percentage,
+        format_numeric = None
+    ),
+
+    "int-ratio": VariableType (
+        parse          = lambda x: div (*map (int, x.split (":"))),
+        format         = lambda x: "%g:%g" % (
+                             (0, 0)                     if math.isnan (x) else
+                             (1, 0)                     if x == math.inf  else
+                             (-1, 0)                    if x == -math.inf else
+                             (0, 1)                     if x == 0         else
+                             (round (100 * x) / 100, 1) if abs (x) >  1   else
+                             (1, round (100 / x) / 100)
+                         ),
+        format_numeric = None
+    ),
+
+    "percentage": VariableType (
+        parse          = float,
+        format         = format_percentage,
+        format_numeric = None
+    ),
+
+    "duration": VariableType (
+        parse          = float,
+        format         = format_duration,
+        format_numeric = None
+    ),
+
+    "rate-of-change": VariableType (
+        parse          = float,
+        format         = lambda x: "%s/s" % format_size (x),
+        format_numeric = None
+    )
+}
+var_types = {
+    type: VariableType (
+        parse          = parse,
+        format         = lambda x, f = format: \
+                             f (x) if x is not None else "N/A",
+        format_numeric = lambda x, f = format_numeric or format:
+                             f (x) if x is not None else "N/A"
+    )
+    for type, (parse, format, format_numeric) in var_types.items ()
+}
+
+# Read performance log from STDIN
+log = ElementTree.fromstring (sys.stdin.buffer.read ())
+
+Variable = namedtuple ("Variable", ("type", "desc", "color"))
+Value    = namedtuple ("Value",    ("value", "raw"))
+
+var_colors = [
+    (0.8, 0.4, 0.4),
+    (0.8, 0.6, 0.4),
+    (0.4, 0.8, 0.4),
+    (0.8, 0.8, 0.4),
+    (0.4, 0.4, 0.8),
+    (0.4, 0.8, 0.8),
+    (0.8, 0.4, 0.8),
+    (0.8, 0.8, 0.8)
+]
+
+var_defs = {}
+
+for var in log.find ("var-defs"):
+    color = var_colors[len (var_defs) % len (var_colors)]
+
+    var_defs[var.get ("name")] = Variable (var.get ("type"),
+                                           var.get ("desc"),
+                                           color)
+
+AddressInfo = namedtuple ("AddressInfo", ("id",
+                                          "name",
+                                          "object",
+                                          "symbol",
+                                          "offset",
+                                          "source",
+                                          "line"))
+
+address_map = {}
+
+if log.find ("address-map"):
+    for address in log.find ("address-map").iterfind ("address"):
+        value = int (address.get ("value"), 0)
+
+        object = address.find ("object").text
+        symbol = address.find ("symbol").text
+        base   = address.find ("base").text
+        source = address.find ("source").text
+        line   = address.find ("line").text
+
+        address_map[value] = AddressInfo (
+            id     = int (base, 0) if base else value,
+            name   = symbol or base or hex (value),
+            object = object,
+            symbol = symbol,
+            offset = value - int (base, 0) if base else None,
+            source = source,
+            line   = int (line) if line else None
+        )
+
+class ThreadState (enum.Enum):
+    SUSPENDED = enum.auto ()
+    RUNNING   = enum.auto ()
+
+    def __str__ (self):
+        return {
+            ThreadState.SUSPENDED: "S",
+            ThreadState.RUNNING:   "R"
+        }[self]
+
+Thread = namedtuple ("Thread", ("id", "name", "state", "frames"))
+Frame  = namedtuple ("Frame",  ("id", "address", "info"))
+
+Sample = namedtuple ("Sample", ("t", "vars", "markers", "backtrace"))
+Marker = namedtuple ("Marker", ("id", "t", "description"))
+
+samples     = []
+markers     = []
+last_marker = 0
+
+for element in log.find ("samples"):
+    if element.tag == "sample":
+        sample = Sample (
+            t         = int (element.get ("t")),
+            vars      = {},
+            markers   = markers[last_marker:],
+            backtrace = []
+        )
+
+        for var in element.find ("vars"):
+            sample.vars[var.tag] = Value (
+                value = var_types[var_defs[var.tag].type].parse (var.text) \
+                        if var.text else None,
+                raw   = var.text.strip () if var.text else None
+            )
+
+        if element.find ("backtrace"):
+            for thread in element.find ("backtrace").iterfind ("thread"):
+                id      = thread.get ("id")
+                name    = thread.get ("name")
+                running = thread.get ("running")
+
+                t = Thread (
+                    id     = int (id),
+                    name   = name,
+                    state  = ThreadState.RUNNING if running and int (running) \
+                             else ThreadState.SUSPENDED,
+                    frames = []
+                )
+
+                for frame in thread.iterfind ("frame"):
+                    address = int (frame.get ("address"), 0)
+
+                    info = address_map.get (address, None)
+
+                    if not info:
+                        info = AddressInfo (
+                            id     = address,
+                            name   = hex (address),
+                            object = None,
+                            symbol = None,
+                            offset = None,
+                            source = None,
+                            line   = None
+                        )
+
+                    t.frames.append (Frame (
+                        id      = len (t.frames),
+                        address = address,
+                        info    = info
+                    ))
+
+                sample.backtrace.append (t)
+
+        samples.append (sample)
+
+        last_marker = len (markers)
+    elif element.tag == "marker":
+        marker = Marker (
+            id          = int (element.get ("id")),
+            t           = int (element.get ("t")),
+            description = element.text.strip () if element.text else None
+        )
+
+        markers.append (marker)
+
+if samples:
+    samples[-1].markers.extend (markers[last_marker:])
+
+DELTA_SAME = __builtins__.object ()
+
+def delta_encode (dest, src):
+    if type (dest) == type (src):
+        if dest == src:
+            return DELTA_SAME
+        elif type (dest) == tuple:
+            return tuple (delta_encode (d, s) for d, s in zip (dest, src)) + \
+                   dest[len (src):]
+
+    return dest
+
+def delta_decode (dest, src):
+    if dest == DELTA_SAME:
+        return src
+    elif type (dest) == type (src):
+        if type (dest) == tuple:
+            return tuple (delta_decode (d, s) for d, s in zip (dest, src)) + \
+                   dest[len (src):]
+
+    return dest
+
+class History (GObject.GObject):
+    Source = namedtuple ("HistorySource", ("get", "set"))
+
+    def __init__ (self):
+        GObject.GObject.__init__ (self)
+
+        self.sources = []
+
+        self.state = None
+
+        self.undo_stack = []
+        self.redo_stack = []
+
+        self.blocked         = 0
+        self.n_groups        = 0
+        self.pending_record  = False
+
+    @GObject.Property (type = bool, default = False)
+    def can_undo (self):
+        return bool (self.undo_stack)
+
+    @GObject.Property (type = bool, default = False)
+    def can_redo (self):
+        return bool (self.redo_stack)
+
+    def add_source (self, get, set):
+        self.sources.append (self.Source (get, set))
+
+    def block (self):
+        self.blocked += 1
+
+    def unblock (self):
+        self.blocked -= 1
+
+    def is_blocked (self):
+        return self.blocked > 0
+
+    def start_group (self):
+        self.n_groups += 1
+
+    def end_group (self):
+        self.n_groups -= 1
+
+        if self.n_groups == 0 and self.pending_record:
+            self.record ()
+
+    def record (self):
+        if self.is_blocked ():
+            return
+
+        if self.n_groups == 0:
+            state = tuple (source.get () for source in self.sources)
+
+            if self.state is None:
+                self.state = state
+            else:
+                self.pending_record = False
+
+                delta = delta_encode (self.state, state)
+
+                if delta == DELTA_SAME:
+                    return
+
+                self.undo_stack.append (delta_encode (self.state, state))
+                self.redo_stack = []
+
+                self.state = state
+
+                self.notify ("can-undo")
+                self.notify ("can-redo")
+        else:
+            self.pending_record = True
+
+    def update (self):
+        if self.is_blocked ():
+            return
+
+        if self.n_groups == 0:
+            state = tuple (source.get () for source in self.sources)
+
+            for stack in self.undo_stack, self.redo_stack:
+                if stack:
+                    stack[-1] = delta_encode (delta_decode (stack[-1],
+                                                            self.state),
+                                              state)
+
+            self.state = state
+        else:
+            self.pending_record = True
+
+    def move (self, src, dest):
+        self.block ()
+
+        state = src.pop ()
+
+        for source, substate, prev_substate in \
+            zip (self.sources, self.state, state):
+            if prev_substate != DELTA_SAME:
+                source.set (delta_decode (prev_substate, substate))
+
+        state = delta_decode (state, self.state)
+
+        dest.append (delta_encode (self.state, state))
+
+        self.state = state
+
+        self.notify ("can-undo")
+        self.notify ("can-redo")
+
+        self.unblock ()
+
+    def undo (self):
+        self.move (self.undo_stack, self.redo_stack)
+
+    def redo (self):
+        self.move (self.redo_stack, self.undo_stack)
+
+history = History ()
+
+class SelectionOp (enum.Enum):
+    REPLACE   = enum.auto ()
+    ADD       = enum.auto ()
+    SUBTRACT  = enum.auto ()
+    INTERSECT = enum.auto ()
+    XOR       = enum.auto ()
+
+class Selection (GObject.GObject):
+    __gsignals__ = {
+        "changed":           (GObject.SignalFlags.RUN_FIRST, None, ()),
+        "change-complete":   (GObject.SignalFlags.RUN_FIRST, None, ()),
+        "highlight-changed": (GObject.SignalFlags.RUN_FIRST, None, ())
+    }
+
+    def __init__ (self, iter = ()):
+        GObject.GObject.__init__ (self)
+
+        self.selection  = set (iter)
+        self.highlight  = None
+        self.cursor     = None
+        self.cursor_dir = 0
+
+        self.pending_change_completion = False
+
+    def __eq__ (self, other):
+        return type (self)     == type (other)     and \
+               self.selection  == other.selection  and \
+               self.cursor     == other.cursor     and \
+               self.cursor_dir == other.cursor_dir
+
+    def __str__ (self):
+        n_sel = len (self.selection)
+
+        if n_sel == 0 or n_sel == len (samples):
+            return "All Samples"
+        elif n_sel == 1:
+            i, = self.selection
+
+            return "Sample %d" % i
+        else:
+            sel = list (self.selection)
+
+            sel.sort ()
+
+            if all (sel[i] + 1 == sel[i + 1] for i in range (n_sel - 1)):
+                return "Samples %d–%d" % (sel[0], sel[-1])
+            else:
+                return "%d Samples" % n_sel
+
+    def copy (self):
+        selection = Selection ()
+
+        selection.highlight  = self.highlight
+        selection.cursor     = self.cursor
+        selection.cursor_dir = self.cursor_dir
+        selection.selection  = self.selection.copy ()
+
+        return selection
+
+    def get_effective_selection (self):
+        if self.selection:
+            return self.selection
+        else:
+            return set (range (len (samples)))
+
+    def select (self, selection, op = SelectionOp.REPLACE):
+        if op == SelectionOp.REPLACE:
+            self.selection = selection.copy ()
+        elif op == SelectionOp.ADD:
+            self.selection |= selection
+        elif op == SelectionOp.SUBTRACT:
+            self.selection -= selection
+        elif op == SelectionOp.INTERSECT:
+            self.selection &= selection
+        elif op == SelectionOp.XOR:
+            self.selection.symmetric_difference_update (selection)
+
+        if len (self.selection) == 1:
+            (self.cursor,) = self.selection
+        else:
+            self.cursor = None
+
+        self.cursor_dir = 0
+
+        self.pending_change_completion = True
+
+        self.emit ("changed")
+
+    def select_range (self, first, last, op = SelectionOp.REPLACE):
+        if first > last:
+            temp  = first
+            first = last
+            last  = temp
+
+        first = max (first, 0)
+        last  = min (last, len (samples) - 1)
+
+        if first <= last:
+            self.select (set (range (first, last + 1)), op)
+        else:
+            self.select (set (), op)
+
+    def clear (self):
+        self.select (set ())
+
+    def invert (self):
+        self.select_range (0, len (samples), SelectionOp.XOR)
+
+    def change_complete (self):
+        if self.pending_change_completion:
+            self.pending_change_completion = False
+
+            history.start_group ()
+
+            history.record ()
+
+            self.emit ("change-complete")
+
+            history.end_group ()
+
+    def set_highlight (self, highlight):
+        self.highlight = highlight
+
+        self.emit ("highlight-changed")
+
+    def source_get (self):
+        return self.copy ()
+
+    def source_set (self, selection):
+        self.cursor     = selection.cursor
+        self.cursor_dir = selection.cursor_dir
+        self.selection  = selection.selection.copy ()
+
+        self.emit ("changed")
+        self.emit ("change-complete")
+
+    def add_history_source (self):
+        history.add_source (self.source_get, self.source_set)
+
+selection = Selection ()
+selection.add_history_source ()
+
+class FindSamplesPopover (Gtk.Popover):
+    def __init__ (self, *args, **kwargs):
+        Gtk.Popover.__init__ (self, *args, **kwargs)
+
+        vbox = Gtk.Box (orientation  = Gtk.Orientation.VERTICAL,
+                        border_width = 20,
+                        spacing      = 8)
+        self.add (vbox)
+        vbox.show ()
+
+        entry = Gtk.Entry (width_chars      = 40,
+                           placeholder_text = "Python expression")
+        self.entry = entry
+        vbox.pack_start (entry, False, False, 0)
+        entry.show ()
+
+        entry.connect ("activate", self.find_samples)
+
+        entry.get_buffer ().connect (
+            "notify::text",
+            lambda *args: self.entry.get_style_context ().remove_class ("error")
+        )
+
+        frame = Gtk.Frame (label       = "Selection",
+                           shadow_type = Gtk.ShadowType.NONE)
+        vbox.pack_start (frame, False, False, 8)
+        frame.get_label_widget ().get_style_context ().add_class ("dim-label")
+        frame.show ()
+
+        vbox2 = Gtk.Box (orientation  = Gtk.Orientation.VERTICAL,
+                         border_width = 8,
+                         spacing      = 8)
+        frame.add (vbox2)
+        vbox2.show ()
+
+        self.radios = []
+
+        radio = Gtk.RadioButton.new_with_mnemonic (None, "_Replace")
+        self.radios.append ((radio, SelectionOp.REPLACE))
+        vbox2.pack_start (radio, False, False, 0)
+        radio.show ()
+
+        radio = Gtk.RadioButton.new_with_mnemonic_from_widget (radio, "_Add")
+        self.radios.append ((radio, SelectionOp.ADD))
+        vbox2.pack_start (radio, False, False, 0)
+        radio.show ()
+
+        radio = Gtk.RadioButton.new_with_mnemonic_from_widget (radio, "_Subtract")
+        self.radios.append ((radio, SelectionOp.SUBTRACT))
+        vbox2.pack_start (radio, False, False, 0)
+        radio.show ()
+
+        radio = Gtk.RadioButton.new_with_mnemonic_from_widget (radio, "_Intersect")
+        self.radios.append ((radio, SelectionOp.INTERSECT))
+        vbox2.pack_start (radio, False, False, 0)
+        radio.show ()
+
+        button = Gtk.Button.new_with_mnemonic ("_Find")
+        vbox.pack_start (button, False, False, 0)
+        button.set_halign (Gtk.Align.CENTER)
+        button.show ()
+
+        button.connect ("clicked", self.find_samples)
+
+    def do_hide (self):
+        self.entry.set_text ("")
+        self.entry.get_style_context ().remove_class ("error")
+
+        Gtk.Popover.do_hide (self)
+
+    def find_samples (self, *args):
+        def var_name (var):
+            return var.replace ("-", "_")
+
+        try:
+            f = eval ("lambda thread, function, %s: %s" % (
+                ", ".join (map (var_name, var_defs)),
+                self.entry.get_text ()))
+        except:
+            self.entry.get_style_context ().add_class ("error")
+
+            return
+
+        sel = set ()
+
+        for i in range (len (samples)):
+            try:
+                def match_thread (thread, id, state = None):
+                    return (id is None or                         \
+                            (type (id) == int                 and \
+                             id == thread.id)                 or  \
+                            (type (id) == str                 and \
+                             thread.name                      and \
+                             re.fullmatch (id, thread.name))) and \
+                           (state is None                     or  \
+                            re.fullmatch (state, str (thread.state)))
+
+                def thread (id, state = None):
+                    return any (match_thread (thread, id, state)
+                                for thread in samples[i].backtrace or [])
+
+                def function (name, id = None, state = None):
+                    for thread in samples[i].backtrace or []:
+                        if match_thread (thread, id, state):
+                            for frame in thread.frames:
+                                if re.fullmatch (name, frame.info.name):
+                                    return True
+
+                    return False
+
+                if f (thread, function, **{
+                    var_name (var): value.value
+                    for var, value in samples[i].vars.items ()
+                }):
+                    sel.add (i)
+            except:
+                pass
+
+        op = [op for radio, op in self.radios if radio.get_active ()][0]
+
+        selection.select (sel, op)
+
+        selection.change_complete ()
+
+        self.hide ()
+
+class CellRendererColorToggle (Gtk.CellRendererToggle):
+    padding = 3
+
+    color = GObject.Property (type = Gdk.RGBA, default = Gdk.RGBA (0, 0, 0))
+
+    def do_render (self, cr, widget, background_area, cell_area, flags):
+        state    = widget.get_state_flags ()
+        style    = widget.get_style_context ()
+        fg_color = style.get_color (state)
+        active   = self.get_property ("active")
+        size     = max (min (cell_area.width, cell_area.height) -
+                        2 * self.padding,
+                        0)
+
+        (r, g, b, a) = self.color
+
+        if is_bright_color (fg_color):
+            bg = (0.75 * r, 0.75 * g, 0.75 * b)
+            fg = (r, g, b)
+        else:
+            bg = (r, g, b)
+            fg = (0.75 * r, 0.75 * g, 0.75 * b)
+
+        x = cell_area.x + (cell_area.width  - size) // 2
+        y = cell_area.y + (cell_area.height - size) // 2
+
+        if active:
+            cr.rectangle (x, y, size, size)
+
+            cr.set_source_rgba (*bg)
+            cr.fill ()
+        else:
+            style.save ()
+
+            style.set_state (Gtk.StateFlags (state & ~Gtk.StateFlags.SELECTED))
+            Gtk.render_background (style, cr, x, y, size, size)
+
+            style.restore ()
+
+        cr.rectangle (x, y, size, size)
+
+        cr.set_source_rgb (*fg)
+        cr.set_line_width (2)
+        cr.stroke ()
+
+class VariableSet (Gtk.TreeView):
+    class Store (Gtk.ListStore):
+        NAME   = 0
+        DESC   = 1
+        COLOR  = 2
+        ACTIVE = 3
+
+        def __init__ (self):
+            Gtk.ListStore.__init__ (self, str, str, Gdk.RGBA, bool)
+
+            for var, var_def in var_defs.items ():
+                i = self.append ((var,
+                                  var_def.desc,
+                                  Gdk.RGBA (*var_def.color),
+                                  False))
+
+    def __init__ (self, *args, **kwargs):
+        Gtk.TreeView.__init__ (self, *args, headers_visible = False, **kwargs)
+
+        store = self.Store ()
+        self.store = store
+        self.set_model (store)
+        self.set_tooltip_column (store.DESC)
+
+        col = Gtk.TreeViewColumn ()
+        self.append_column (col)
+
+        cell = CellRendererColorToggle ()
+        col.pack_start (cell, False)
+        col.add_attribute (cell, "active", store.ACTIVE)
+        col.add_attribute (cell, "color", store.COLOR)
+
+        cell.connect ("toggled", self.var_toggled)
+
+        cell = Gtk.CellRendererText ()
+        col.pack_start (cell, True)
+        col.add_attribute (cell, "text", store.NAME)
+
+    def var_toggled (self, cell, path):
+        self.store[path][self.store.ACTIVE] = not cell.get_property ("active")
+
+class SampleGraph (Gtk.DrawingArea):
+    def __init__ (self, model = None, *args, **kwargs):
+        Gtk.DrawingArea.__init__ (self, *args, can_focus = True, **kwargs)
+
+        self.style_widget = Gtk.Entry ()
+
+        self.model = model
+
+        if model:
+            model.connect ("row-changed", lambda *args: self.update ())
+
+            self.update ()
+
+        self.selection = None
+        self.sel       = None
+
+        selection.connect ("changed", self.selection_changed)
+        selection.connect ("highlight-changed",
+                           lambda selection: self.queue_draw ())
+
+        self.add_events (Gdk.EventMask.BUTTON_PRESS_MASK   |
+                         Gdk.EventMask.BUTTON_RELEASE_MASK |
+                         Gdk.EventMask.KEY_PRESS_MASK      |
+                         Gdk.EventMask.KEY_RELEASE_MASK)
+
+        self.selection_changed (selection)
+
+    def sample_to_x (self, i):
+        if not samples:
+            return None
+
+        width     = self.get_allocated_width ()
+        n_samples = max (len (samples), 2)
+
+        return 1 + (width - 3) * i / (n_samples - 1)
+
+    def sample_to_range (self, i):
+        if not samples:
+            return None
+
+        width     = self.get_allocated_width ()
+        n_samples = max (len (samples), 2)
+
+        return (1 + math.floor ((width - 3) * (i - 0.5) / (n_samples - 1)),
+                1 + math.ceil  ((width - 3) * (i + 0.5) / (n_samples - 1)))
+
+    def x_to_sample (self, x):
+        if not samples:
+            return None
+
+        width     = max (self.get_allocated_width (), 4)
+        n_samples = len (samples)
+
+        return round ((n_samples - 1) * (x - 1) / (width - 3))
+
+    def update (self):
+        if not samples or not self.model:
+            return
+
+        self.max_value = 1
+
+        for row in self.model:
+            var_name   = row[self.model.NAME]
+            var_active = row[self.model.ACTIVE]
+
+            if var_active:
+                values = (sample.vars[var_name].value for sample in samples)
+                values = filter (lambda x: x is not None, values)
+                values = filter (math.isfinite,           values)
+
+                try:
+                    self.max_value = max (self.max_value, max (values))
+                except:
+                    pass
+
+        self.queue_draw ()
+
+    def selection_changed (self, selection):
+        if selection.selection:
+            self.sel = list (selection.selection)
+            self.sel.sort ()
+        else:
+            self.sel = None
+
+        self.queue_draw ()
+
+    def do_get_preferred_width (self):
+        return (300, 300)
+
+    def do_get_preferred_height (self):
+        if self.model:
+            return (32, 256)
+        else:
+            return (16, 16)
+
+    def update_selection (self):
+        sel = self.selection.copy ()
+
+        i0 = self.selection_i0
+        i1 = self.selection_i1
+
+        if self.selection_range:
+            swap = i0 > i1
+
+            if swap:
+                temp = i0
+                i0   = i1
+                i1   = temp
+
+            n_samples = len (samples)
+
+            while i0 > 0             and not samples[i0 - 1].markers: i0 -= 1
+            while i1 < n_samples - 1 and not samples[i1 + 1].markers: i1 += 1
+
+            if swap:
+                temp = i0
+                i0   = i1
+                i1   = temp
+
+        sel.select_range (i0, i1, self.selection_op)
+
+        selection.select (sel.selection)
+
+        selection.cursor     = i1
+        selection.cursor_dir = i1 - i0
+
+    def do_button_press_event (self, event):
+        state = event.state & Gdk.ModifierType.MODIFIER_MASK
+
+        self.grab_focus ()
+
+        if event.button == 1:
+            i = self.x_to_sample (event.x)
+
+            if i is None:
+                return False
+
+            self.selection       = selection.copy ()
+            self.selection_i0    = i
+            self.selection_i1    = i
+            self.selection_op    = SelectionOp.REPLACE
+            self.selection_range = event.type != Gdk.EventType.BUTTON_PRESS
+
+            if state == Gdk.ModifierType.SHIFT_MASK:
+                self.selection_op = SelectionOp.ADD
+            elif state == Gdk.ModifierType.CONTROL_MASK:
+                self.selection_op = SelectionOp.SUBTRACT
+            elif state == (Gdk.ModifierType.SHIFT_MASK |
+                           Gdk.ModifierType.CONTROL_MASK):
+                self.selection_op = SelectionOp.INTERSECT
+
+            self.update_selection ()
+
+            self.grab_add ()
+        elif event.button == 3:
+            if state == 0:
+                selection.clear ()
+            elif state == Gdk.ModifierType.CONTROL_MASK:
+                selection.invert ()
+
+            self.grab_add ()
+
+        return True
+
+    def do_button_release_event (self, event):
+        if event.button == 1 or event.button == 3:
+            self.selection = None
+
+            selection.change_complete ()
+
+            self.grab_remove ()
+
+            return True
+
+        return False
+
+    def do_motion_notify_event (self, event):
+        i = self.x_to_sample (event.x)
+
+        selection.set_highlight (i)
+
+        if self.selection and i is not None:
+            self.selection_i1 = i
+
+            self.update_selection ()
+
+            return True
+
+        return False
+
+    def do_leave_notify_event (self, event):
+        selection.set_highlight (None)
+
+        return False
+
+    def do_key_press_event (self, event):
+        if event.keyval == Gdk.KEY_Left    or \
+           event.keyval == Gdk.KEY_Right   or \
+           event.keyval == Gdk.KEY_Home    or \
+           event.keyval == Gdk.KEY_KP_Home or \
+           event.keyval == Gdk.KEY_End     or \
+           event.keyval == Gdk.KEY_KP_End:
+            n_samples = len (samples)
+
+            state = event.state & Gdk.ModifierType.MODIFIER_MASK
+
+            op = SelectionOp.REPLACE
+
+            if state == Gdk.ModifierType.SHIFT_MASK:
+                op = SelectionOp.XOR
+
+            cursor     = selection.cursor
+            cursor_dir = selection.cursor_dir
+
+            if event.keyval == Gdk.KEY_Left or \
+               event.keyval == Gdk.KEY_Home or \
+               event.keyval == Gdk.KEY_KP_Home:
+                if selection.cursor is not None:
+                    if cursor_dir <= 0 or op == SelectionOp.REPLACE:
+                        cursor -= 1
+                else:
+                    cursor = n_samples - 1
+
+                cursor_dir = -1
+            elif event.keyval == Gdk.KEY_Right or \
+                 event.keyval == Gdk.KEY_End   or \
+                 event.keyval == Gdk.KEY_KP_End:
+                if cursor is not None:
+                    if cursor_dir >= 0 or op == SelectionOp.REPLACE:
+                        cursor += 1
+                else:
+                    cursor = 0
+
+                cursor_dir = +1
+
+            if cursor < 0 or cursor >= n_samples:
+                cursor = min (max (cursor, 0), n_samples - 1)
+
+                selection.cursor     = cursor
+                selection.cursor_dir = cursor_dir
+
+                if op != SelectionOp.REPLACE:
+                    return True
+
+            i0 = cursor
+
+            if event.keyval == Gdk.KEY_Home or \
+               event.keyval == Gdk.KEY_KP_Home:
+                cursor = 0
+            elif event.keyval == Gdk.KEY_End or \
+                 event.keyval == Gdk.KEY_KP_End:
+                cursor = n_samples - 1
+
+            if op == SelectionOp.REPLACE:
+                i0 = cursor
+
+            selection.select_range (i0, cursor, op)
+
+            if len (selection.selection) > 1:
+                selection.cursor     = cursor
+                selection.cursor_dir = cursor_dir
+
+            return True
+        elif event.keyval == Gdk.KEY_Escape:
+            selection.select (set ())
+
+            return True
+
+        return False
+
+    def do_key_release_event (self, event):
+        selection.change_complete ()
+
+        return False
+
+    def do_draw (self, cr):
+        state           = self.get_state_flags ()
+        style           = (self.style_widget if self.model else
+                           self).get_style_context ()
+        (width, height) = (self.get_allocated_width  (),
+                           self.get_allocated_height ())
+
+        fg_color        = tuple (style.get_color (state))
+        grid_color      = (*fg_color[:3], 0.25 * fg_color[3])
+        highlight_color = grid_color
+        selection_color = (*fg_color[:3], 0.15 * fg_color[3])
+
+        Gtk.render_background (style, cr, 0, 0, width, height)
+
+        if self.model:
+            max_value = self.max_value
+            vscale    = (height - 4) / max_value
+
+            cr.save ()
+
+            cr.translate (0, height - 2)
+            cr.scale (1, -1)
+
+            first_sample = True
+            has_infinite = False
+
+            for row in self.model:
+                var_name   = row[self.model.NAME]
+                var_active = row[self.model.ACTIVE]
+
+                if var_active:
+                    is_boolean    = var_defs[var_name].type == "boolean"
+                    is_continuous = not is_boolean
+
+                    for i in range (len (samples)):
+                        value = samples[i].vars[var_name].value
+
+                        if value is not None:
+                            first_sample = False
+
+                            if math.isinf (value):
+                                first_sample = True
+                                has_infinite = True
+
+                                value = max_value
+                            elif is_boolean:
+                                value *= max_value
+
+                            y = value * vscale
+
+                            if is_continuous:
+                                x = self.sample_to_x (i)
+
+                                if first_sample:
+                                    cr.move_to (x, y)
+                                else:
+                                    cr.line_to (x, y)
+                            else:
+                                (x0, x1) = self.sample_to_range (i)
+
+                                if first_sample:
+                                    cr.move_to (x0, y)
+                                else:
+                                    cr.line_to (x0, y)
+
+                                cr.line_to (x1, y)
+                        else:
+                            first_sample = True
+
+                    (r, g, b) = var_defs[var_name].color
+
+                    cr.set_source_rgb (r, g, b)
+                    cr.set_line_width (2)
+                    cr.stroke ()
+
+                    if has_infinite:
+                        cr.save ()
+
+                        for i in range (len (samples)):
+                            value = samples[i].vars[var_name].value
+
+                            if value is not None and math.isinf (value):
+                                first_sample = False
+
+                                y = max_value * vscale
+
+                                if is_continuous:
+                                    x = self.sample_to_x (i)
+
+                                    if first_sample:
+                                        cr.move_to (x, y)
+                                    else:
+                                        cr.line_to (x, y)
+                                else:
+                                    (x0, x1) = self.sample_to_range (i)
+
+                                    if first_sample:
+                                        cr.move_to (x0, y)
+                                    else:
+                                        cr.line_to (x0, y)
+
+                                    cr.line_to (x1, y)
+                            else:
+                                first_sample = True
+
+                        cr.set_dash ([6, 6], 0)
+                        cr.stroke ()
+
+                        cr.restore ()
+
+            cr.restore ()
+
+            cr.set_line_width (1)
+
+            cr.set_source_rgba (*grid_color)
+
+            n_hgrid_lines = 4
+            n_vgrid_lines = 1
+
+            for i in range (n_hgrid_lines + 1):
+                cr.move_to (0, round (i * (height - 1) / n_hgrid_lines) + 0.5)
+                cr.rel_line_to (width, 0)
+
+                cr.stroke ()
+
+            for i in range (n_vgrid_lines + 1):
+                cr.move_to (round (i * (width - 1) / n_vgrid_lines) + 0.5, 0)
+                cr.rel_line_to (0, height)
+
+                cr.stroke ()
+        else:
+            for i in range (len (samples)):
+                if samples[i].markers:
+                    (x0, x1) = self.sample_to_range (i)
+
+                    cr.rectangle (x0, 0, x1 - x0, height)
+
+            cr.set_source_rgba (*fg_color)
+            cr.fill ()
+
+        if selection.highlight is not None:
+            (x0, x1) = self.sample_to_range (selection.highlight)
+
+            cr.rectangle (x0, 0, x1 - x0, height)
+
+            (r, g, b, a) = style.get_color (state)
+
+            cr.set_source_rgba (*highlight_color)
+            cr.fill ()
+
+        if self.sel:
+            def draw_selection ():
+                x0 = self.sample_to_range (i0)[0]
+                x1 = self.sample_to_range (i1)[1]
+
+                cr.rectangle (x0, 0, x1 - x0, height)
+
+                (r, g, b, a) = style.get_color (state)
+
+                cr.set_source_rgba (*selection_color)
+                cr.fill ()
+
+            i0 = None
+
+            for i in self.sel:
+                if i0 is None:
+                    i0 = i
+                    i1 = i
+                elif i == i1 + 1:
+                    i1 = i
+                else:
+                    draw_selection ()
+
+                    i0 = i
+                    i1 = i
+
+            if i0 is not None:
+                draw_selection ()
+
+class SampleGraphList (Gtk.Box):
+    Item = namedtuple (
+        "SampleGraphListGraph", ("widget",
+                                 "model",
+                                 "remove_button",
+                                 "move_up_button",
+                                 "move_down_button")
+    )
+
+    def __init__ (self, *args, **kwargs):
+        Gtk.Box.__init__ (self,
+                          *args,
+                          orientation = Gtk.Orientation.VERTICAL,
+                          **kwargs)
+
+        self.items = []
+
+        self.vset_size_group = Gtk.SizeGroup (
+            mode = Gtk.SizeGroupMode.HORIZONTAL
+        )
+
+        hbox = Gtk.Box (orientation = Gtk.Orientation.HORIZONTAL)
+        self.pack_start (hbox, False, False, 0)
+        hbox.show ()
+
+        empty = Gtk.DrawingArea ()
+        hbox.pack_start (empty, False, True, 0)
+        self.vset_size_group.add_widget (empty)
+        empty.show ()
+
+        graph = SampleGraph (has_tooltip = True)
+        hbox.pack_start (graph, True, True, 0)
+        graph.show ()
+
+        graph.connect ("query-tooltip", self.graph_query_tooltip)
+
+        separator = Gtk.Separator (orientation = Gtk.Orientation.HORIZONTAL)
+        self.pack_start (separator, False, False, 0)
+        separator.show ()
+
+        vbox = Gtk.Box (orientation = Gtk.Orientation.VERTICAL)
+        self.items_vbox = vbox
+        self.pack_start (vbox, False, False, 0)
+        vbox.show ()
+
+        self.add_item (0)
+
+    def update_items (self):
+        for widget in self.items_vbox.get_children ():
+            self.items_vbox.remove (widget)
+
+        i = 0
+
+        for item in self.items:
+            if i > 0:
+                separator = Gtk.Separator (
+                    orientation = Gtk.Orientation.HORIZONTAL
+                )
+                self.items_vbox.pack_start (separator, False, False, 0)
+                separator.show ()
+
+            self.items_vbox.pack_start (item.widget, False, False, 0)
+
+            item.remove_button.set_sensitive    (len (self.items) > 1)
+            item.move_up_button.set_sensitive   (i > 0)
+            item.move_down_button.set_sensitive (i < len (self.items) - 1)
+
+            i += 1
+
+    def add_item (self, i):
+        hbox = Gtk.Box (orientation = Gtk.Orientation.HORIZONTAL)
+        hbox.show ()
+
+        vbox = Gtk.Box (orientation = Gtk.Orientation.VERTICAL)
+        hbox.pack_start (vbox, False, True, 0)
+        self.vset_size_group.add_widget (vbox)
+        vbox.show ()
+
+        scroll = Gtk.ScrolledWindow (
+            hscrollbar_policy = Gtk.PolicyType.NEVER,
+            vscrollbar_policy = Gtk.PolicyType.AUTOMATIC
+        )
+        vbox.pack_start (scroll, True, True, 0)
+        scroll.show ()
+
+        vset = VariableSet ()
+        scroll.add (vset)
+        vset.show ()
+
+        buttons = Gtk.ButtonBox (orientation = Gtk.Orientation.HORIZONTAL)
+        vbox.pack_start (buttons, False, False, 0)
+        buttons.set_layout (Gtk.ButtonBoxStyle.EXPAND)
+        buttons.show ()
+
+        button = Gtk.Button.new_from_icon_name ("list-add-symbolic",
+                                                Gtk.IconSize.BUTTON)
+        add_button = button
+        buttons.add (button)
+        button.show ()
+
+        button = Gtk.Button.new_from_icon_name ("list-remove-symbolic",
+                                                Gtk.IconSize.BUTTON)
+        remove_button = button
+        buttons.add (button)
+        button.show ()
+
+        button = Gtk.Button.new_from_icon_name ("go-up-symbolic",
+                                                Gtk.IconSize.BUTTON)
+        move_up_button = button
+        buttons.add (button)
+        button.show ()
+
+        button = Gtk.Button.new_from_icon_name ("go-down-symbolic",
+                                                Gtk.IconSize.BUTTON)
+        move_down_button = button
+        buttons.add (button)
+        button.show ()
+
+        graph = SampleGraph (vset.get_model (), has_tooltip = True)
+        hbox.pack_start (graph, True, True, 0)
+        graph.show ()
+
+        graph.connect ("query-tooltip", self.graph_query_tooltip)
+
+        item = self.Item (
+            widget           = hbox,
+            model            = vset.get_model (),
+            remove_button    = remove_button,
+            move_up_button   = move_up_button,
+            move_down_button = move_down_button
+        )
+        self.items.insert (i, item)
+
+        add_button.connect       ("clicked",
+                                  lambda *args: self.add_item (
+                                                    self.items.index (item) + 1
+                                                ))
+        remove_button.connect    ("clicked",
+                                  lambda *args: self.remove_item (
+                                                    self.items.index (item)
+                                                ))
+        move_up_button.connect   ("clicked",
+                                  lambda *args: self.move_item (
+                                                    self.items.index (item),
+                                                    -1
+                                                ))
+        move_down_button.connect ("clicked",
+                                  lambda *args: self.move_item (
+                                                    self.items.index (item),
+                                                    +1
+                                                ))
+
+        self.update_items ()
+
+    def remove_item (self, i):
+        del self.items[i]
+
+        self.update_items ()
+
+    def move_item (self, i, offset):
+        item = self.items[i]
+        del self.items[i]
+        self.items.insert (i + offset, item)
+
+        self.update_items ()
+
+    def graph_query_tooltip (self, graph, x, y, keyboard_mode, tooltip):
+        if keyboard_mode:
+            return False
+
+        i = graph.x_to_sample (x)
+
+        if i is None or i < 0 or i >= len (samples):
+            return False
+
+        grid = Gtk.Grid (column_spacing = 4)
+        tooltip.set_custom (grid)
+        grid.show ()
+
+        row = 0
+
+        label = Gtk.Label ()
+        grid.attach (label, 0, row, 2, 1)
+        label.set_markup ("<b>Sample %d</b>" % i)
+        label.show ()
+
+        row += 1
+
+        label = Gtk.Label ()
+        grid.attach (label, 0, row, 2, 1)
+        label.set_markup ("<sub>%s</sub>" %
+                          format_duration (samples[i].t / 1000000))
+        label.get_style_context ().add_class ("dim-label")
+        label.show ()
+
+        row += 1
+
+        for item in self.items:
+            model = item.model
+
+            vars = tuple (var[model.NAME] for var in model if var[model.ACTIVE])
+
+            if not vars:
+                continue
+
+            separator = Gtk.Separator (orientation = Gtk.Orientation.HORIZONTAL)
+            grid.attach (separator, 0, row, 2, 1)
+            separator.show ()
+
+            row += 1
+
+            for var in vars:
+                color = format_color (var_defs[var].color)
+
+                label = Gtk.Label (halign = Gtk.Align.START)
+                grid.attach (label, 0, row, 1, 1)
+                label.set_markup (
+                    "<span color=\"%s\"><b>%s</b></span>" % (color, var)
+                )
+                label.show ()
+
+                value = samples[i].vars[var].value
+                text  = var_types[var_defs[var].type].format (value) \
+                        if value is not None else "N/A"
+
+                label = Gtk.Label (label = text, halign = Gtk.Align.END)
+                grid.attach (label, 1, row, 1, 1)
+                label.show ()
+
+                row += 1
+
+        markers = samples[i].markers
+
+        if markers:
+            separator = Gtk.Separator (orientation = Gtk.Orientation.HORIZONTAL)
+            grid.attach (separator, 0, row, 2, 1)
+            separator.show ()
+
+            row += 1
+
+            for marker in markers:
+                label = Gtk.Label (halign = Gtk.Align.START)
+                grid.attach (label, 0, row, 1, 1)
+                label.set_markup ("<b>Marker %d</b>" % (marker.id))
+                label.show ()
+
+                if marker.description:
+                    label = Gtk.Label (marker.description,
+                                       halign = Gtk.Align.END)
+                    grid.attach (label, 1, row, 1, 1)
+                    label.show ()
+
+                row += 1
+
+        return True
+
+class InformationViewer (Gtk.ScrolledWindow):
+    class Store (Gtk.ListStore):
+        NAME  = 0
+        VALUE = 1
+
+        def __init__ (self):
+            Gtk.ListStore.__init__ (self, str, str)
+
+    def __init__ (self, *args, **kwargs):
+        Gtk.ScrolledWindow.__init__ (
+            self,
+            *args,
+            hscrollbar_policy = Gtk.PolicyType.AUTOMATIC,
+            vscrollbar_policy = Gtk.PolicyType.AUTOMATIC,
+            **kwargs
+        )
+
+        vbox = Gtk.Box (orientation  = Gtk.Orientation.VERTICAL,
+                        border_width = 32,
+                        margin_left  = 64,
+                        margin_right = 64,
+                        spacing      = 32)
+        self.add (vbox)
+        vbox.show ()
+
+        def add_element (element):
+            name    = {
+                "params":       "Log Parameters",
+                "gimp-version": "GIMP Version",
+                "env":          "Environment",
+                "gegl-config":  "GEGL Config"
+            }.get (element.tag, element.tag)
+            text    = element.text.strip ()
+            n_items = len (element)
+
+            if not text and n_items == 0:
+                return
+
+            vbox2 = Gtk.Box (orientation = Gtk.Orientation.VERTICAL,
+                             spacing     = 16)
+            vbox.pack_start (vbox2, False, False, 0)
+            vbox2.show ()
+
+            label = Gtk.Label (xalign = 0)
+            vbox2.pack_start (label, False, False, 0)
+            label.set_markup ("<b>%s</b>" % name)
+            label.show ()
+
+            frame = Gtk.Frame (shadow_type = Gtk.ShadowType.IN)
+            vbox2.pack_start (frame, False, False, 0)
+            frame.show ()
+
+            if text:
+                scrolled = Gtk.ScrolledWindow (
+                    hscrollbar_policy = Gtk.PolicyType.AUTOMATIC,
+                    vscrollbar_policy = Gtk.PolicyType.AUTOMATIC,
+                    height_request    = 400
+                )
+                frame.add (scrolled)
+                scrolled.show ()
+
+                text = Gtk.TextView (editable      = False,
+                                     monospace     = True,
+                                     wrap_mode     = Gtk.WrapMode.WORD,
+                                     left_margin   = 16,
+                                     right_margin  = 16,
+                                     top_margin    = 16,
+                                     bottom_margin = 16)
+                scrolled.add (text)
+                text.get_buffer ().set_text (element.text.strip (), -1)
+                text.show ()
+            else:
+                scrolled = Gtk.ScrolledWindow (
+                    hscrollbar_policy = Gtk.PolicyType.AUTOMATIC,
+                    vscrollbar_policy = Gtk.PolicyType.NEVER
+                )
+                frame.add (scrolled)
+                scrolled.show ()
+
+                store = self.Store ()
+
+                for item in element:
+                    store.append ((item.tag, item.text.strip ()))
+
+                tree = Gtk.TreeView (model = store)
+                scrolled.add (tree)
+                tree.show ()
+
+                col = Gtk.TreeViewColumn (title = "Name")
+                tree.append_column (col)
+
+                cell = Gtk.CellRendererText ()
+                col.pack_start (cell, False)
+                col.add_attribute (cell, "text", store.NAME)
+
+                col = Gtk.TreeViewColumn (title = "Value")
+                tree.append_column (col)
+                col.set_alignment (0.5)
+
+                cell = Gtk.CellRendererText (xalign = 1)
+                col.pack_start (cell, False)
+                col.add_attribute (cell, "text", store.VALUE)
+
+        params = log.find ("params")
+
+        if params:
+            add_element (params)
+
+        info = log.find ("info")
+
+        if info:
+            for element in info:
+                add_element (element)
+
+class MarkersViewer (Gtk.ScrolledWindow):
+    class Store (Gtk.ListStore):
+        ID   = 0
+        TIME = 1
+        DESC = 2
+
+        def __init__ (self):
+            Gtk.ListStore.__init__ (self, int, GObject.TYPE_INT64, str)
+
+            for marker in markers:
+                self.append ((marker.id, marker.t, marker.description))
+
+    def __init__ (self, *args, **kwargs):
+        Gtk.Box.__init__ (self,
+                          *args,
+                          hscrollbar_policy = Gtk.PolicyType.AUTOMATIC,
+                          vscrollbar_policy = Gtk.PolicyType.AUTOMATIC,
+                          **kwargs)
+
+        self.needs_update = True
+
+        store = self.Store ()
+        self.store = store
+
+        tree = Gtk.TreeView (model = store)
+        self.tree = tree
+        self.add (tree)
+        tree.show ()
+
+        tree.get_selection ().set_mode (Gtk.SelectionMode.MULTIPLE)
+
+        self.tree_selection_changed_handler = tree.get_selection ().connect (
+            "changed", self.tree_selection_changed
+        )
+
+        col = Gtk.TreeViewColumn (title = "#")
+        tree.append_column (col)
+        col.set_resizable (True)
+
+        cell = Gtk.CellRendererText (xalign = 1)
+        col.pack_start (cell, False)
+        col.add_attribute (cell, "text", store.ID)
+
+        def format_time_col (tree_col, cell, model, iter, col):
+            time = model[iter][col]
+
+            cell.set_property ("text", format_duration (time / 1000000))
+
+        col = Gtk.TreeViewColumn (title = "Time")
+        tree.append_column (col)
+        col.set_resizable (True)
+        col.set_alignment (0.5)
+
+        cell = Gtk.CellRendererText (xalign = 1)
+        col.pack_start (cell, False)
+        col.set_cell_data_func (cell, format_time_col, store.TIME)
+
+        col = Gtk.TreeViewColumn (title = "Description")
+        tree.append_column (col)
+        col.set_resizable (True)
+        col.set_alignment (0.5)
+
+        cell = Gtk.CellRendererText ()
+        col.pack_start (cell, False)
+        col.add_attribute (cell, "text", store.DESC)
+
+        col = Gtk.TreeViewColumn ()
+        tree.append_column (col)
+
+        selection.connect ("change-complete", self.selection_change_complete)
+
+    def update (self):
+        markers = set ()
+
+        if not self.needs_update:
+            return
+
+        self.needs_update = False
+
+        for i in selection.selection:
+            markers.update (marker.id for marker in samples[i].markers)
+
+        tree_sel = self.tree.get_selection ()
+
+        GObject.signal_handler_block (tree_sel,
+                                      self.tree_selection_changed_handler)
+
+        tree_sel.unselect_all ()
+
+        for row in self.store:
+            if row[self.store.ID] in markers:
+                tree_sel.select_iter (row.iter)
+
+        GObject.signal_handler_unblock (tree_sel,
+                                        self.tree_selection_changed_handler)
+
+    def do_map (self):
+        self.update ()
+
+        Gtk.ScrolledWindow.do_map (self)
+
+    def selection_change_complete (self, selection):
+        self.needs_update = True
+
+        if self.get_mapped ():
+            self.update ()
+
+    def tree_selection_changed (self, tree_sel):
+        sel = set ()
+
+        for row in self.store:
+            if tree_sel.iter_is_selected (row.iter):
+                id = row[self.store.ID]
+
+                for i in range (len (samples)):
+                    if any (marker.id == id for marker in samples[i].markers):
+                        sel.add (i)
+
+        selection.select (sel)
+
+        selection.change_complete ()
+
+class VariablesViewer (Gtk.ScrolledWindow):
+    class Store (Gtk.ListStore):
+        NAME        =  0
+        DESC        =  1
+        COLOR       =  2
+        VALUE       =  3
+        RAW         =  4
+        MIN         =  5
+        MAX         =  6
+        MEDIAN      =  7
+        MEAN        =  8
+        STDEV       =  9
+        LAST_COLUMN = 10
+
+        def __init__ (self):
+            n_stats = self.LAST_COLUMN - self.COLOR
+
+            Gtk.ListStore.__init__ (self,
+                                    *((str, str, Gdk.RGBA) + n_stats * (str,)))
+
+            for var, var_def in var_defs.items ():
+                 self.append (((var,
+                                var_def.desc,
+                                Gdk.RGBA (*var_def.color)) +
+                               n_stats * ("",)))
+
+    def __init__ (self, *args, **kwargs):
+        Gtk.Box.__init__ (self,
+                          *args,
+                          hscrollbar_policy = Gtk.PolicyType.AUTOMATIC,
+                          vscrollbar_policy = Gtk.PolicyType.AUTOMATIC,
+                          **kwargs)
+
+        self.needs_update = True
+
+        store = self.Store ()
+        self.store = store
+
+        tree = Gtk.TreeView (model = store)
+        self.add (tree)
+        tree.set_tooltip_column (store.DESC)
+        tree.show ()
+
+        self.single_sample_cols = []
+        self.multi_sample_cols  = []
+
+        col = Gtk.TreeViewColumn (title = "Variable")
+        tree.append_column (col)
+        col.set_resizable (True)
+
+        cell = CellRendererColorToggle (active = True)
+        col.pack_start (cell, False)
+        col.add_attribute (cell, "color", store.COLOR)
+
+        cell = Gtk.CellRendererText ()
+        col.pack_start (cell, False)
+        col.add_attribute (cell, "text", store.NAME)
+
+        def add_value_column (title, column, single_sample):
+            col = Gtk.TreeViewColumn (title = title)
+            tree.append_column (col)
+            col.set_resizable (True)
+            col.set_alignment (0.5)
+
+            cell = Gtk.CellRendererText (xalign = 1)
+            col.pack_start (cell, False)
+            col.add_attribute (cell, "text", column)
+
+            if single_sample:
+                self.single_sample_cols.append (col)
+            else:
+                self.multi_sample_cols.append (col)
+
+        add_value_column ("Value",     store.VALUE,  True)
+        add_value_column ("Raw",       store.RAW,    True)
+        add_value_column ("Min",       store.MIN,    False)
+        add_value_column ("Max",       store.MAX,    False)
+        add_value_column ("Median",    store.MEDIAN, False)
+        add_value_column ("Mean",      store.MEAN,   False)
+        add_value_column ("Std. Dev.", store.STDEV,  False)
+
+        col = Gtk.TreeViewColumn ()
+        tree.append_column (col)
+
+        selection.connect ("change-complete", self.selection_change_complete)
+
+    def update (self):
+        if not self.needs_update:
+            return
+
+        self.needs_update = False
+
+        sel   = selection.get_effective_selection ()
+        n_sel = len (sel)
+
+        if n_sel == 1:
+            i, = sel
+
+            for row in self.store:
+                var_name = row[self.store.NAME]
+
+                var      = samples[i].vars[var_name]
+                var_type = var_types[var_defs[var_name].type]
+
+                row[self.store.VALUE] = var_type.format (var.value)
+                row[self.store.RAW]   = var.raw if var.raw is not None \
+                                        else "N/A"
+        else:
+            for row in self.store:
+                var_name = row[self.store.NAME]
+
+                var_type = var_types[var_defs[var_name].type]
+
+                vals = (samples[i].vars[var_name].value for i in sel)
+                vals = tuple (val for val in vals if val is not None)
+
+                if vals:
+                    min_val = min               (vals)
+                    max_val = max               (vals)
+                    median  = statistics.median (vals)
+                    mean    = statistics.mean   (vals)
+                    stdev   = statistics.pstdev (vals, mean)
+
+                    row[self.store.MIN]    = var_type.format         (min_val)
+                    row[self.store.MAX]    = var_type.format         (max_val)
+                    row[self.store.MEDIAN] = var_type.format         (median)
+                    row[self.store.MEAN]   = var_type.format_numeric (mean)
+                    row[self.store.STDEV]  = var_type.format_numeric (stdev)
+                else:
+                    row[self.store.MIN]    = \
+                    row[self.store.MAX]    = \
+                    row[self.store.MEDIAN] = \
+                    row[self.store.MEAN]   = \
+                    row[self.store.STDEV]  = var_type.format (None)
+
+        for col in self.single_sample_cols: col.set_visible (n_sel == 1)
+        for col in self.multi_sample_cols:  col.set_visible (n_sel > 1)
+
+    def do_map (self):
+        self.update ()
+
+        Gtk.ScrolledWindow.do_map (self)
+
+    def selection_change_complete (self, selection):
+        self.needs_update = True
+
+        if self.get_mapped ():
+            self.update ()
+
+class BacktraceViewer (Gtk.Box):
+    class ThreadStore (Gtk.ListStore):
+        INDEX = 0
+        ID    = 1
+        NAME  = 2
+        STATE = 3
+
+        def __init__ (self):
+            Gtk.ListStore.__init__ (self, int, int, str, str)
+
+    class FrameStore (Gtk.ListStore):
+        ID       = 0
+        ADDRESS  = 1
+        OBJECT   = 2
+        FUNCTION = 3
+        OFFSET   = 4
+        SOURCE   = 5
+        LINE     = 6
+
+        def __init__ (self):
+            Gtk.ListStore.__init__ (self, int, str, str, str, str, str, str)
+
+    class CellRendererViewSource (Gtk.CellRendererPixbuf):
+        file = GObject.Property (type = Gio.File, default = None)
+        line = GObject.Property (type = int,      default = 0)
+
+        def __init__ (self, *args, **kwargs):
+            Gtk.CellRendererPixbuf.__init__ (
+                self,
+                *args,
+                icon_name = "text-x-generic-symbolic",
+                mode      = Gtk.CellRendererMode.ACTIVATABLE,
+                **kwargs)
+
+            self.connect ("notify::file",
+                          lambda *args:
+                              self.set_property ("visible", bool (self.file)))
+
+        def do_activate (self, event, widget, path, *args):
+            if self.file:
+                run_editor (self.file, self.line)
+
+                return True
+
+            return False
+
+    def __init__ (self, *args, **kwargs):
+        Gtk.Box.__init__ (self,
+                          *args,
+                          orientation = Gtk.Orientation.HORIZONTAL,
+                          **kwargs)
+
+        self.needs_update = True
+
+        vbox = Gtk.Box (orientation = Gtk.Orientation.VERTICAL)
+        self.pack_start (vbox, False, False, 0)
+        vbox.show ()
+
+        header = Gtk.HeaderBar (title = "Threads", has_subtitle = False)
+        vbox.pack_start (header, False, False, 0)
+        header.show ()
+
+        scrolled = Gtk.ScrolledWindow (
+            hscrollbar_policy = Gtk.PolicyType.NEVER,
+            vscrollbar_policy = Gtk.PolicyType.AUTOMATIC
+        )
+        vbox.pack_start (scrolled, True, True, 0)
+        scrolled.show ()
+
+        store = self.ThreadStore ()
+        self.thread_store = store
+        store.set_sort_column_id (store.ID, Gtk.SortType.ASCENDING)
+
+        tree = Gtk.TreeView (model = store)
+        self.thread_tree = tree
+        scrolled.add (tree)
+        tree.set_search_column (store.NAME)
+        tree.show ()
+
+        tree.connect ("row-activated", self.threads_row_activated)
+
+        tree.get_selection ().connect ("changed",
+                                       self.threads_selection_changed)
+
+        col = Gtk.TreeViewColumn (title = "ID")
+        tree.append_column (col)
+        col.set_resizable (True)
+
+        cell = Gtk.CellRendererText (xalign = 1)
+        col.pack_start (cell, False)
+        col.add_attribute (cell, "text", self.ThreadStore.ID)
+
+        col = Gtk.TreeViewColumn (title = "Name")
+        tree.append_column (col)
+        col.set_resizable (True)
+
+        cell = Gtk.CellRendererText ()
+        col.pack_start (cell, False)
+        col.add_attribute (cell, "text", self.ThreadStore.NAME)
+
+        col = Gtk.TreeViewColumn (title = "State")
+        tree.append_column (col)
+        col.set_resizable (True)
+
+        cell = Gtk.CellRendererText ()
+        col.pack_start (cell, False)
+        col.add_attribute (cell, "text", self.ThreadStore.STATE)
+
+        separator = Gtk.Separator (orientation = Gtk.Orientation.VERTICAL)
+        self.pack_start (separator, False, False, 0)
+        separator.show ()
+
+        vbox = Gtk.Box (orientation = Gtk.Orientation.VERTICAL)
+        self.pack_start (vbox, True, True, 0)
+        vbox.show ()
+
+        header = Gtk.HeaderBar (title = "Stack", has_subtitle = False)
+        vbox.pack_start (header, False, False, 0)
+        header.show ()
+
+        scrolled = Gtk.ScrolledWindow (
+            hscrollbar_policy = Gtk.PolicyType.AUTOMATIC,
+            vscrollbar_policy = Gtk.PolicyType.AUTOMATIC
+        )
+        vbox.pack_start (scrolled, True, True, 0)
+        scrolled.show ()
+
+        store = self.FrameStore ()
+        self.frame_store = store
+
+        tree = Gtk.TreeView (model = store, has_tooltip = True)
+        scrolled.add (tree)
+        tree.set_search_column (store.FUNCTION)
+        tree.show ()
+
+        tree.connect ("row-activated", self.frames_row_activated)
+        tree.connect ("query-tooltip", self.frames_query_tooltip)
+
+        def format_filename_col (tree_col, cell, model, iter, col):
+            object = model[iter][col]
+
+            cell.set_property ("text", get_basename (object) if object else "")
+
+        self.tooltip_columns = {}
+
+        col = Gtk.TreeViewColumn (title = "#")
+        tree.append_column (col)
+        col.set_resizable (True)
+
+        cell = Gtk.CellRendererText (xalign = 1)
+        col.pack_start (cell, False)
+        col.add_attribute (cell, "text", self.FrameStore.ID)
+
+        col = Gtk.TreeViewColumn (title = "Address")
+        tree.append_column (col)
+        col.set_resizable (True)
+
+        cell = Gtk.CellRendererText (xalign = 1)
+        col.pack_start (cell, False)
+        col.add_attribute (cell, "text", self.FrameStore.ADDRESS)
+
+        col = Gtk.TreeViewColumn (title = "Object")
+        self.tooltip_columns[col] = store.OBJECT
+        tree.append_column (col)
+        col.set_resizable (True)
+
+        cell = Gtk.CellRendererText ()
+        col.pack_start (cell, False)
+        col.set_cell_data_func (cell, format_filename_col, store.OBJECT)
+
+        col = Gtk.TreeViewColumn (title = "Function")
+        tree.append_column (col)
+        col.set_resizable (True)
+
+        cell = Gtk.CellRendererText ()
+        col.pack_start (cell, False)
+        col.add_attribute (cell, "text", self.FrameStore.FUNCTION)
+
+        col = Gtk.TreeViewColumn (title = "Offset")
+        tree.append_column (col)
+        col.set_resizable (True)
+
+        cell = Gtk.CellRendererText (xalign = 1)
+        col.pack_start (cell, False)
+        col.add_attribute (cell, "text", self.FrameStore.OFFSET)
+
+        col = Gtk.TreeViewColumn (title = "Source")
+        self.tooltip_columns[col] = store.SOURCE
+        tree.append_column (col)
+        col.set_resizable (True)
+
+        cell = Gtk.CellRendererText ()
+        col.pack_start (cell, False)
+        col.set_cell_data_func (cell, format_filename_col, store.SOURCE)
+
+        col = Gtk.TreeViewColumn (title = "Line")
+        tree.append_column (col)
+        col.set_resizable (True)
+
+        cell = Gtk.CellRendererText (xalign = 1)
+        col.pack_start (cell, False)
+        col.add_attribute (cell, "text", self.FrameStore.LINE)
+
+        def format_view_source_col (tree_col, cell, model, iter, cols):
+            filename = model[iter][cols[0]] or None
+            line     = model[iter][cols[1]] or "0"
+
+            cell.set_property ("file", filename and find_file (filename))
+            cell.set_property ("line", int (line))
+
+        def format_view_source_tooltip (row):
+            filename = row[store.SOURCE]
+
+            if filename:
+                file = find_file (filename)
+
+                if file:
+                    return file.get_path ()
+
+            return None
+
+        col = Gtk.TreeViewColumn ()
+        self.tooltip_columns[col] = format_view_source_tooltip
+        tree.append_column (col)
+
+        cell = self.CellRendererViewSource (xalign = 0)
+        col.pack_start (cell, False)
+        col.set_cell_data_func (cell, format_view_source_col, (store.SOURCE,
+                                                               store.LINE))
+
+        selection.connect ("change-complete", self.selection_change_complete)
+
+    @GObject.Property (type = bool, default = False)
+    def available (self):
+        sel = selection.get_effective_selection ()
+
+        if len (sel) == 1:
+            i, = sel
+
+            return bool (samples[i].backtrace)
+
+        return False
+
+    def update (self):
+        if not self.needs_update or not self.available:
+            return
+
+        self.needs_update = False
+
+        tid = None
+
+        sel_rows = self.thread_tree.get_selection ().get_selected_rows ()[1]
+
+        if sel_rows:
+            tid = self.thread_store[sel_rows[0]][self.ThreadStore.ID]
+
+        i, = selection.get_effective_selection ()
+
+        self.thread_store.clear ()
+
+        for t in range (len (samples[i].backtrace)):
+            thread = samples[i].backtrace[t]
+
+            iter = self.thread_store.append (
+                (t, thread.id, thread.name, str (thread.state))
+            )
+
+            if thread.id == tid:
+                self.thread_tree.get_selection ().select_iter (iter)
+
+    def do_map (self):
+        self.update ()
+
+        Gtk.Box.do_map (self)
+
+    def selection_change_complete (self, selection):
+        self.needs_update = True
+
+        if self.get_mapped ():
+            self.update ()
+
+        self.notify ("available")
+
+    def threads_row_activated (self, tree, path, col):
+        iter = self.thread_store.get_iter (path)
+
+        tid = self.thread_store[iter][self.ThreadStore.ID]
+
+        sel = set ()
+
+        for i in range (len (samples)):
+            threads = filter (lambda thread:
+                                thread.id    == tid and
+                                thread.state == ThreadState.RUNNING,
+                              samples[i].backtrace or [])
+
+            if list (threads):
+                sel.add (i)
+
+        selection.select (sel)
+
+        selection.change_complete ()
+
+    def threads_selection_changed (self, tree_sel):
+        self.frame_store.clear ()
+
+        (store, rows) = tree_sel.get_selected_rows ()
+
+        if not rows:
+            return
+
+        i, = selection.get_effective_selection ()
+
+        try:
+            frames = samples[i].backtrace[store[rows[0]][store.INDEX]].frames
+
+            for frame in frames:
+                info = frame.info
+
+                self.frame_store.append ((
+                    frame.id, hex (frame.address), info.object, info.symbol,
+                    hex (info.offset) if info.offset is not None else None,
+                    info.source, str (info.line) if info.line else None
+                ))
+        except:
+            pass
+
+    def frames_row_activated (self, tree, path, col):
+        iter = self.frame_store.get_iter (path)
+
+        address = int (self.frame_store[iter][self.FrameStore.ADDRESS], 0)
+        info    = address_map.get (address, None)
+
+        if not info:
+            return
+
+        id = info.id
+
+        if not id:
+            return
+
+        sel = set ()
+
+        def has_frame (sample, id):
+            for thread in sample.backtrace or []:
+                for frame in thread.frames:
+                    if frame.info.id == id:
+                        return True
+
+            return False
+
+        for i in range (len (samples)):
+            if has_frame (samples[i], id):
+                sel.add (i)
+
+        selection.select (sel)
+
+        selection.change_complete ()
+
+    def frames_query_tooltip (self, tree, x, y, keyboard_mode, tooltip):
+        hit, x, y, model, path, iter =  tree.get_tooltip_context (x, y,
+                                                                  keyboard_mode)
+
+        if hit:
+            column = None
+
+            if keyboard_mode:
+                cursor_path, cursor_col = tree.get_cursor ()
+
+                if path.compare (cursor_path) == 0:
+                    column = self.tooltip_columns[cursor_col]
+            else:
+                for col in self.tooltip_columns:
+                    area = tree.get_cell_area (path, col)
+
+                    if x >= area.x and x < area.x + area.width and \
+                       y >= area.y and y < area.y + area.height:
+                        column = self.tooltip_columns[col]
+
+                        break
+
+            if column is not None:
+                value = None
+
+                if type (column) == int:
+                    value = model[iter][column]
+                else:
+                    value = column (model[iter])
+
+                if value:
+                    tooltip.set_text (str (value))
+
+                    return True
+
+        return False
+
+class CellRendererPercentage (Gtk.CellRendererText):
+    padding = 0
+
+    def __init__ (self, *args, **kwargs):
+        Gtk.CellRendererText.__init__ (self, *args, xalign = 1, **kwargs)
+
+        self.value = 0
+
+    @GObject.Property (type = float)
+    def value (self):
+        return self.value_property
+
+    @value.setter
+    def value (self, value):
+        self.value_property = value
+
+        self.set_property ("text", format_percentage (value, 2))
+
+    def do_render (self, cr, widget, background_area, cell_area, flags):
+        full_width  = cell_area.width  - 2 * self.padding
+        full_height = cell_area.height - 2 * self.padding
+
+        if full_width <= 0 or full_height <= 0:
+            return
+
+        state    = widget.get_state_flags()
+        style    = widget.get_style_context ()
+        fg_color = style.get_color (state)
+
+        rounded_rectangle (cr,
+                           cell_area.x + self.padding,
+                           cell_area.y + self.padding,
+                           full_width,
+                           full_height,
+                           1)
+
+        cr.clip ()
+
+        cr.set_source_rgba (*blend_colors ((0, 0, 0, 0), fg_color, 0.2))
+        cr.paint ()
+
+        Gtk.CellRendererText.do_render (self,
+                                        cr, widget,
+                                        background_area, cell_area,
+                                        flags)
+
+        value  = min (max (self.value, 0), 1)
+        width  = round (full_width * value)
+        height = full_height
+
+        if width > 0 and height > 0:
+            state = Gtk.StateFlags        (state |
+                                           Gtk.StateFlags.SELECTED)
+            flags = Gtk.CellRendererState (flags |
+                                           Gtk.CellRendererState.SELECTED)
+
+            style.save ()
+            style.set_state (state)
+
+            x = round ((full_width - width) * self.get_property ("xalign"))
+
+            cr.rectangle (cell_area.x + self.padding + x,
+                          cell_area.y + self.padding,
+                          width,
+                          height)
+
+            cr.clip ()
+
+            Gtk.render_background (style, cr,
+                                   cell_area.x,     cell_area.y,
+                                   cell_area.width, cell_area.height)
+
+            cr.set_source_rgba (0, 0, 0, 0.25)
+            cr.paint ()
+
+            Gtk.CellRendererText.do_render (self,
+                                            cr, widget,
+                                            background_area, cell_area,
+                                            flags)
+
+            style.restore ()
+
+class ProfileViewer (Gtk.ScrolledWindow):
+    class ThreadFilter (Gtk.TreeView):
+        class Store (Gtk.ListStore):
+            VISIBLE = 0
+            ID      = 1
+            NAME    = 2
+            STATE   = {list (ThreadState)[i]: 3 + i
+                       for i in range (len (ThreadState))}
+
+            def __init__ (self):
+                Gtk.ListStore.__init__ (self,
+                                        bool, int, str,
+                                        *(len (self.STATE) * (bool,)))
+
+                threads = list ({thread.id
+                                 for sample in samples
+                                 for thread in sample.backtrace or ()})
+                threads.sort ()
+
+                states = [state == ThreadState.RUNNING for state in self.STATE]
+
+                for id in threads:
+                    self.append ((False, id, None, *states))
+
+            def get_filter (self):
+                return {row[self.ID]: {state
+                                       for state, column in self.STATE.items ()
+                                       if row[column]}
+                        for row in self}
+
+            def set_filter (self, filter):
+                for row in self:
+                    states = filter[row[self.ID]]
+
+                    for state, column in self.STATE.items ():
+                        row[column] = state in states
+
+        def __init__ (self, *args, **kwargs):
+            Gtk.TreeView.__init__ (self, *args, **kwargs)
+
+            self.needs_update = True
+
+            store = self.Store ()
+            self.store = store
+
+            filter = Gtk.TreeModelFilter (child_model = store)
+            filter.set_visible_column (store.VISIBLE)
+            self.set_model (filter)
+            self.set_search_column (store.NAME)
+
+            col = Gtk.TreeViewColumn (title = "ID")
+            self.append_column (col)
+
+            cell = Gtk.CellRendererText (xalign = 1)
+            col.pack_start (cell, False)
+            col.add_attribute (cell, "text", store.ID)
+
+            col = Gtk.TreeViewColumn (title = "Name")
+            self.append_column (col)
+
+            cell = Gtk.CellRendererText ()
+            col.pack_start (cell, False)
+            col.add_attribute (cell, "text", store.NAME)
+
+            for state in store.STATE:
+                col = Gtk.TreeViewColumn (title = str (state))
+                col.column = store.STATE[state]
+                self.append_column (col)
+                col.set_alignment (0.5)
+                col.set_clickable (True)
+
+                def col_clicked (col):
+                    active = not all (row[col.column] for row in filter)
+
+                    for row in filter:
+                        row[col.column] = active
+
+                col.connect ("clicked", col_clicked)
+
+                cell = Gtk.CellRendererToggle ()
+                cell.column = store.STATE[state]
+                col.pack_start (cell, False)
+                col.add_attribute (cell, "active", store.STATE[state])
+
+                def cell_toggled (cell, path):
+                    filter[path][cell.column] = not cell.get_property ("active")
+
+                cell.connect ("toggled", cell_toggled)
+
+            selection.connect ("change-complete",
+                               self.selection_change_complete)
+
+        def update (self):
+            if not self.needs_update:
+                return
+
+            self.needs_update = False
+
+            sel = selection.get_effective_selection ()
+
+            threads = {thread.id: thread.name
+                       for i in sel
+                       for thread in samples[i].backtrace or ()}
+
+            for row in self.store:
+                id = row[self.store.ID]
+
+                if id in threads:
+                    row[self.store.VISIBLE] = True
+                    row[self.store.NAME]    = threads[id]
+                else:
+                    row[self.store.VISIBLE] = False
+                    row[self.store.NAME]    = None
+
+        def do_map (self):
+            self.update ()
+
+            Gtk.TreeView.do_map (self)
+
+        def selection_change_complete (self, selection):
+            self.needs_update = True
+
+            if self.get_mapped ():
+                self.update ()
+
+    class ThreadPopover (Gtk.Popover):
+        def __init__ (self, *args, **kwargs):
+            Gtk.Popover.__init__ (self, *args, border_width = 4, **kwargs)
+
+            frame = Gtk.Frame (shadow_type = Gtk.ShadowType.IN)
+            self.add (frame)
+            frame.show ()
+
+            scrolled = Gtk.ScrolledWindow (
+                hscrollbar_policy        = Gtk.PolicyType.NEVER,
+                vscrollbar_policy        = Gtk.PolicyType.AUTOMATIC,
+                propagate_natural_height = True,
+                max_content_height       = 400
+            )
+            frame.add (scrolled)
+            scrolled.show ()
+
+            thread_filter = ProfileViewer.ThreadFilter ()
+            self.thread_filter = thread_filter
+            scrolled.add (thread_filter)
+            thread_filter.show ()
+
+    class Profile (Gtk.Box):
+        ProfileFrame = namedtuple ("ProfileFrame", ("sample", "stack", "i"))
+
+        class Direction (enum.Enum):
+            CALLEES = enum.auto ()
+            CALLERS = enum.auto ()
+
+        class Store (Gtk.ListStore):
+            ID        = 0
+            FUNCTION  = 1
+            EXCLUSIVE = 2
+            INCLUSIVE = 3
+
+            def __init__ (self):
+                Gtk.ListStore.__init__ (self,
+                                        GObject.TYPE_UINT64, str, float, float)
+
+        __gsignals__ = {
+            "needs-update":       (GObject.SignalFlags.RUN_FIRST,
+                                   None, (bool,)),
+            "subprofile-added":   (GObject.SignalFlags.RUN_FIRST,
+                                   None, (Gtk.Widget,)),
+            "subprofile-removed": (GObject.SignalFlags.RUN_FIRST,
+                                   None, (Gtk.Widget,)),
+            "path-changed":       (GObject.SignalFlags.RUN_FIRST,
+                                   None, ())
+        }
+
+        def __init__ (self,
+                      root      = None,
+                      id        = None,
+                      title     = None,
+                      frames    = None,
+                      direction = Direction.CALLEES,
+                      sort      = (Store.INCLUSIVE, Gtk.SortType.DESCENDING),
+                      *args,
+                      **kwargs):
+            Gtk.Box.__init__ (self,
+                              *args,
+                              orientation = Gtk.Orientation.HORIZONTAL,
+                              **kwargs)
+
+            self.root      = root or self
+            self.id        = id
+            self.frames    = frames
+            self.direction = direction
+
+            self.subprofile = None
+
+            vbox = Gtk.Box (orientation = Gtk.Orientation.VERTICAL)
+            self.pack_start (vbox, False, False, 0)
+            vbox.show ()
+
+            header = Gtk.HeaderBar (title = title or "All Functions")
+            self.header = header
+            vbox.pack_start (header, False, False, 0)
+            header.show ()
+
+            if not id:
+                popover = ProfileViewer.ThreadPopover ()
+
+                thread_filter_store = popover.thread_filter.store
+
+                self.thread_filter_store = thread_filter_store
+                self.thread_filter       = thread_filter_store.get_filter ()
+
+                history.add_source (self.thread_filter_source_get,
+                                    self.thread_filter_source_set)
+
+                button = Gtk.MenuButton (popover = popover)
+                header.pack_end (button)
+                button.show ()
+
+                button.connect ("toggled", self.thread_filter_button_toggled)
+
+                hbox = Gtk.Box (orientation = Gtk.Orientation.HORIZONTAL,
+                                spacing     = 4)
+                button.add (hbox)
+                hbox.show ()
+
+                label = Gtk.Label (label = "Threads")
+                hbox.pack_start (label, False, False, 0)
+                label.show ()
+
+                image = Gtk.Image.new_from_icon_name ("pan-down-symbolic",
+                                                      Gtk.IconSize.BUTTON)
+                hbox.pack_start (image, False, False, 0)
+                image.show ()
+
+                history.add_source (self.direction_source_get,
+                                    self.direction_source_set)
+
+                button = Gtk.Button (tooltip_text = "Call-graph direction")
+                header.pack_end (button)
+                button.show ()
+
+                button.connect ("clicked", self.direction_button_clicked)
+
+                image = Gtk.Image ()
+                self.direction_image = image
+                button.add (image)
+                image.show ()
+            else:
+                button = Gtk.Button.new_from_icon_name (
+                    "edit-select-symbolic",
+                    Gtk.IconSize.BUTTON
+                )
+                header.pack_end (button)
+                button.set_tooltip_text (
+                    str (Selection (frame.sample for frame in frames))
+                )
+                button.show ()
+
+                button.connect ("clicked", self.select_samples_clicked)
+
+            scrolled = Gtk.ScrolledWindow (
+                hscrollbar_policy = Gtk.PolicyType.NEVER,
+                vscrollbar_policy = Gtk.PolicyType.AUTOMATIC
+            )
+            vbox.pack_start (scrolled, True, True, 0)
+            scrolled.show ()
+
+            store = self.Store ()
+            self.store = store
+            store.set_sort_column_id (*sort)
+
+            tree = Gtk.TreeView (model = store)
+            self.tree = tree
+            scrolled.add (tree)
+            tree.set_search_column (store.FUNCTION)
+            tree.show ()
+
+            tree.get_selection ().connect ("changed",
+                                           self.tree_selection_changed)
+
+            tree.connect ("row-activated",   self.tree_row_activated)
+            tree.connect ("key-press-event", self.tree_key_press_event)
+
+            col = Gtk.TreeViewColumn (title = "Function")
+            tree.append_column (col)
+            col.set_resizable (True)
+            col.set_sort_column_id (store.FUNCTION)
+
+            cell = Gtk.CellRendererText (ellipsize = Pango.EllipsizeMode.END)
+            col.pack_start (cell, True)
+            col.add_attribute (cell, "text", store.FUNCTION)
+            cell.set_property ("width-chars", 40)
+
+            col = Gtk.TreeViewColumn (title = "Self")
+            tree.append_column (col)
+            col.set_alignment (0.5)
+            col.set_sort_column_id (store.EXCLUSIVE)
+
+            cell = CellRendererPercentage ()
+            col.pack_start (cell, False)
+            col.add_attribute (cell, "value", store.EXCLUSIVE)
+
+            col = Gtk.TreeViewColumn (title = "All")
+            tree.append_column (col)
+            col.set_alignment (0.5)
+            col.set_sort_column_id (store.INCLUSIVE)
+
+            cell = CellRendererPercentage ()
+            col.pack_start (cell, False)
+            col.add_attribute (cell, "value", store.INCLUSIVE)
+
+            if id:
+                self.update ()
+
+        def update (self):
+            self.remove_subprofile ()
+
+            if not self.id:
+                self.update_frames ()
+
+            self.update_store ()
+
+            self.update_ui ()
+
+        def update_frames (self):
+            self.frames = []
+
+            for i in selection.get_effective_selection ():
+                for thread in samples[i].backtrace or []:
+                    if thread.state in self.thread_filter[thread.id]:
+                        thread_frames = thread.frames
+
+                        if self.direction == self.Direction.CALLERS:
+                            thread_frames = reversed (thread_frames)
+
+                        stack   = []
+                        prev_id = 0
+
+                        for frame in thread_frames:
+                            id = frame.info.id
+
+                            if id == prev_id:
+                                continue
+
+                            self.frames.append (self.ProfileFrame (
+                                sample = i,
+                                stack  = stack,
+                                i      = len (stack)
+                            ))
+
+                            stack.append (frame)
+
+                            prev_id = id
+
+        def update_store (self):
+            stacks  = {}
+            symbols = {}
+
+            sort = self.store.get_sort_column_id ()
+
+            self.store = self.Store ()
+
+            for frame in self.frames:
+                info      = frame.stack[frame.i].info
+                symbol_id = info.id
+                stack_id  = builtins.id (frame.stack)
+
+                symbol = symbols.get (symbol_id, None)
+
+                if not symbol:
+                    symbol             = [info, 0, 0]
+                    symbols[symbol_id] = symbol
+
+                stack = stacks.get (stack_id, None)
+
+                if not stack:
+                    stack            = set ()
+                    stacks[stack_id] = stack
+
+                if frame.i == 0:
+                    symbol[1] += 1
+
+                if symbol_id not in stack:
+                    stack.add (symbol_id)
+
+                    symbol[2] += 1
+
+            n_stacks = len (stacks)
+
+            for symbol in symbols.values ():
+                id   = symbol[0].id
+                name = symbol[0].name if id != self.id else "[Self]"
+
+                self.store.append ((id,
+                                    name,
+                                    symbol[1] / n_stacks,
+                                    symbol[2] / n_stacks))
+
+            self.store.set_sort_column_id (*sort)
+
+            self.tree.set_model (self.store)
+            self.tree.set_search_column (self.store.FUNCTION)
+
+        def update_ui (self):
+            if not self.id:
+                if self.direction == self.Direction.CALLEES:
+                    icon_name = "format-indent-more-symbolic"
+                else:
+                    icon_name = "format-indent-less-symbolic"
+
+                self.direction_image.set_from_icon_name (icon_name,
+                                                         Gtk.IconSize.BUTTON)
+            else:
+                if self.direction == self.Direction.CALLEES:
+                    subtitle = "Callees"
+                else:
+                    subtitle = "Callers"
+
+                self.header.set_subtitle (subtitle)
+
+        def select (self, id):
+            if id is not None:
+                for row in self.store:
+                    if row[self.store.ID] == id:
+                        iter = row.iter
+                        path = self.store.get_path (iter)
+
+                        self.tree.get_selection ().select_iter (iter)
+
+                        self.tree.scroll_to_cell (path, None, True, 0.5, 0)
+
+                        break
+            else:
+                self.tree.get_selection ().unselect_all ()
+
+        def add_subprofile (self, subprofile):
+            self.remove_subprofile ()
+
+            box = Gtk.Box (orientation = Gtk.Orientation.HORIZONTAL)
+            self.subprofile_box = box
+            self.pack_start (box, True, True, 0)
+            box.show ()
+
+            separator = Gtk.Separator (orientation = Gtk.Orientation.VERTICAL)
+            box.pack_start (separator, False, False, 0)
+            separator.show ()
+
+            self.subprofile = subprofile
+            box.pack_start (subprofile, True, True, 0)
+            subprofile.show ()
+
+            subprofile.connect ("subprofile-added",
+                                lambda profile, subprofile:
+                                    self.emit ("subprofile-added",
+                                               subprofile))
+            subprofile.connect ("subprofile-removed",
+                                lambda profile, subprofile:
+                                    self.emit ("subprofile-removed",
+                                               subprofile))
+            subprofile.connect ("path-changed",
+                                lambda profile: self.emit ("path-changed"))
+
+            self.emit ("subprofile-added", subprofile)
+
+        def remove_subprofile (self):
+            if self.subprofile:
+                subprofile = self.subprofile
+
+                self.remove (self.subprofile_box)
+
+                self.subprofile     = None
+                self.subprofile_box = None
+
+                self.emit ("subprofile-removed", subprofile)
+
+        def get_path (self):
+            tree_sel = self.tree.get_selection ()
+
+            sel_rows = tree_sel.get_selected_rows ()[1]
+
+            if not sel_rows:
+                return ()
+
+            id = self.store[sel_rows[0]][self.store.ID]
+
+            if self.subprofile:
+                return (id,) + self.subprofile.get_path ()
+            else:
+                return (id,)
+
+        def set_path (self, path):
+            self.select (path[0] if path else None)
+
+            if self.subprofile:
+                self.subprofile.set_path (path[1:])
+
+        def thread_filter_source_get (self):
+            return self.thread_filter_store.get_filter ()
+
+        def thread_filter_source_set (self, thread_filter):
+            self.thread_filter = thread_filter
+
+            self.thread_filter_store.set_filter (thread_filter)
+
+            self.emit ("needs-update", False)
+
+        def thread_filter_button_toggled (self, button):
+            if not button.get_active ():
+                thread_filter = self.thread_filter_store.get_filter ()
+
+                if thread_filter != self.thread_filter:
+                    self.thread_filter = thread_filter
+
+                    history.start_group ()
+
+                    history.record ()
+
+                    self.emit ("needs-update", True)
+
+                    history.end_group ()
+
+        def direction_source_get (self):
+            return self.direction
+
+        def direction_source_set (self, direction):
+            self.direction = direction
+
+            self.emit ("needs-update", False)
+
+        def direction_button_clicked (self, button):
+            if self.direction == self.Direction.CALLEES:
+                self.direction = self.Direction.CALLERS
+            else:
+                self.direction = self.Direction.CALLEES
+
+            history.start_group ()
+
+            history.record ()
+
+            self.emit ("needs-update", True)
+
+            history.end_group ()
+
+        def select_samples_clicked (self, button):
+            selection.select ({frame.sample for frame in self.frames})
+
+            selection.change_complete ()
+
+        def tree_selection_changed (self, tree_sel):
+            self.remove_subprofile ()
+
+            sel_rows = tree_sel.get_selected_rows ()[1]
+
+            if not sel_rows:
+                self.emit ("path-changed")
+
+                return
+
+            id    = self.store[sel_rows[0]][self.store.ID]
+            title = self.store[sel_rows[0]][self.store.FUNCTION]
+
+            frames = []
+
+            for frame in self.frames:
+                if frame.stack[frame.i].info.id == id:
+                    frames.append (frame)
+
+                    if frame.i > 0 and id != self.id:
+                        frames.append (self.ProfileFrame (sample = frame.sample,
+                                                          stack  = frame.stack,
+                                                          i      = frame.i - 1))
+
+            if id != self.id:
+                self.add_subprofile (ProfileViewer.Profile (
+                    self.root,
+                    id,
+                    title,
+                    frames,
+                    self.direction,
+                    self.store.get_sort_column_id ()
+                ))
+            else:
+                filenames = {frame.stack[frame.i].info.source
+                             for frame in frames}
+                filenames = list (filter (bool, filenames))
+
+                if len (filenames) == 1:
+                    file = find_file (filenames[0])
+
+                    if file:
+                        self.add_subprofile (ProfileViewer.SourceProfile (
+                            file,
+                            frames[0].stack[frames[0].i].info.name,
+                            frames
+                        ))
+
+            self.emit ("path-changed")
+
+        def tree_row_activated (self, tree, path, col):
+            if self.root != self:
+                self.root.select (self.store[path][self.store.ID])
+
+        def tree_key_press_event (self, tree, event):
+            if event.keyval == Gdk.KEY_Escape:
+                self.select (None)
+
+                if self.root is not self:
+                    self.get_parent ().get_ancestor (
+                        ProfileViewer.Profile
+                    ).tree.grab_focus ()
+
+                return True
+
+            return False
+
+    class SourceProfile (Gtk.Box):
+        class Store (Gtk.ListStore):
+            LINE       = 0
+            HAS_FRAMES = 1
+            EXCLUSIVE  = 2
+            INCLUSIVE  = 3
+            TEXT       = 4
+
+            def __init__ (self):
+                Gtk.ListStore.__init__ (self, int, bool, float, float, str)
+
+        __gsignals__ = {
+            "subprofile-added":   (GObject.SignalFlags.RUN_FIRST,
+                                   None, (Gtk.Widget,)),
+            "subprofile-removed": (GObject.SignalFlags.RUN_FIRST,
+                                   None, (Gtk.Widget,)),
+            "path-changed":       (GObject.SignalFlags.RUN_FIRST,
+                                   None, ())
+        }
+
+        def __init__ (self,
+                      file,
+                      function,
+                      frames,
+                      *args,
+                      **kwargs):
+            Gtk.Box.__init__ (self,
+                              *args,
+                              orientation = Gtk.Orientation.VERTICAL,
+                              **kwargs)
+
+            self.file   = file
+            self.frames = frames
+
+            header = Gtk.HeaderBar (title    = file.get_basename (),
+                                    subtitle = function)
+            self.header = header
+            self.pack_start (header, False, False, 0)
+            header.show ()
+
+            box = Gtk.Box (orientation = Gtk.Orientation.HORIZONTAL)
+            header.pack_start (box)
+            box.get_style_context ().add_class ("linked")
+            box.get_style_context ().add_class ("raised")
+            box.show ()
+
+            button = Gtk.Button.new_from_icon_name ("go-up-symbolic",
+                                                    Gtk.IconSize.BUTTON)
+            self.prev_button = button
+            box.pack_start (button, False, True, 0)
+            button.show ()
+
+            button.connect ("clicked", lambda *args: self.move (-1))
+
+            button = Gtk.Button.new_from_icon_name ("go-down-symbolic",
+                                                    Gtk.IconSize.BUTTON)
+            self.next_button = button
+            box.pack_end (button, False, True, 0)
+            button.show ()
+
+            button.connect ("clicked", lambda *args: self.move (+1))
+
+            button = Gtk.Button.new_from_icon_name ("edit-select-symbolic",
+                                                    Gtk.IconSize.BUTTON)
+            self.select_samples_button = button
+            header.pack_end (button)
+            button.show ()
+
+            button.connect ("clicked", self.select_samples_clicked)
+
+            button = Gtk.Button.new_from_icon_name ("text-x-generic-symbolic",
+                                                    Gtk.IconSize.BUTTON)
+            header.pack_end (button)
+            button.set_tooltip_text (file.get_path ())
+            button.show ()
+
+            button.connect ("clicked", self.view_source_clicked)
+
+            scrolled = Gtk.ScrolledWindow (
+                hscrollbar_policy = Gtk.PolicyType.NEVER,
+                vscrollbar_policy = Gtk.PolicyType.AUTOMATIC
+            )
+            self.pack_start (scrolled, True, True, 0)
+            scrolled.show ()
+
+            store = self.Store ()
+            self.store = store
+
+            tree = Gtk.TreeView (model = store)
+            self.tree = tree
+            scrolled.add (tree)
+            tree.set_search_column (store.LINE)
+            tree.show ()
+
+            tree.get_selection ().connect ("changed",
+                                           self.tree_selection_changed)
+
+            scale = 0.85
+
+            col = Gtk.TreeViewColumn (title = "Self")
+            tree.append_column (col)
+            col.set_alignment (0.5)
+            col.set_sort_column_id (store.EXCLUSIVE)
+
+            cell = CellRendererPercentage (scale = scale)
+            col.pack_start (cell, False)
+            col.add_attribute (cell, "visible", store.HAS_FRAMES)
+            col.add_attribute (cell, "value",   store.EXCLUSIVE)
+
+            col = Gtk.TreeViewColumn (title = "All")
+            tree.append_column (col)
+            col.set_alignment (0.5)
+            col.set_sort_column_id (store.INCLUSIVE)
+
+            cell = CellRendererPercentage (scale = scale)
+            col.pack_start (cell, False)
+            col.add_attribute (cell, "visible", store.HAS_FRAMES)
+            col.add_attribute (cell, "value",   store.INCLUSIVE)
+
+            col = Gtk.TreeViewColumn ()
+            tree.append_column (col)
+
+            cell = Gtk.CellRendererText (xalign = 1,
+                                         xpad   = 8,
+                                         family = "Monospace",
+                                         weight = Pango.Weight.BOLD,
+                                         scale  = scale)
+            col.pack_start (cell, False)
+            col.add_attribute (cell, "text", store.LINE)
+
+            cell = Gtk.CellRendererText (family = "Monospace",
+                                         scale  = scale)
+            col.pack_start (cell, True)
+            col.add_attribute (cell, "text", store.TEXT)
+
+            self.update ()
+
+        def get_samples (self):
+            sel_rows = self.tree.get_selection ().get_selected_rows ()[1]
+
+            if sel_rows:
+                line = self.store[sel_rows[0]][self.store.LINE]
+
+                sel = {frame.sample for frame in self.frames
+                       if frame.stack[frame.i].info.line == line}
+
+                return sel
+            else:
+                return {}
+
+        def update (self):
+            self.update_store ()
+            self.update_ui ()
+
+        def update_store (self):
+            stacks = {}
+            lines  = {}
+
+            for frame in self.frames:
+                info     = frame.stack[frame.i].info
+                line_id  = info.line
+                stack_id = builtins.id (frame.stack)
+
+                line = lines.get (line_id, None)
+
+                if not line:
+                    line           = [0, 0]
+                    lines[line_id] = line
+
+                stack = stacks.get (stack_id, None)
+
+                if not stack:
+                    stack            = set ()
+                    stacks[stack_id] = stack
+
+                if frame.i == 0:
+                    line[0] += 1
+
+                if line_id not in stack:
+                    stack.add (line_id)
+
+                    line[1] += 1
+
+            self.lines = list (lines.keys ())
+            self.lines.sort ()
+
+            n_stacks = len (stacks)
+
+            self.store.clear ()
+
+            i = 1
+
+            for text in open (self.file.get_path (), "r"):
+                text = text.rstrip ("\n")
+
+                line = lines.get (i, None)
+
+                if line:
+                    self.store.append ((i,
+                                        True,
+                                        line[0] / n_stacks,
+                                        line[1] / n_stacks,
+                                        text))
+                else:
+                    self.store.append ((i,
+                                        False,
+                                        0,
+                                        0,
+                                        text))
+
+                i += 1
+
+            self.select (max (lines.items (), key = lambda line: line[1][1])[0])
+
+        def update_ui (self):
+            sel_rows = self.tree.get_selection ().get_selected_rows ()[1]
+
+            if sel_rows:
+                line = self.store[sel_rows[0]][self.store.LINE]
+
+                i = bisect.bisect_left (self.lines, line)
+
+                self.prev_button.set_sensitive (i > 0)
+
+                if i < len (self.lines) and self.lines[i] == line:
+                    i += 1
+
+                self.next_button.set_sensitive (i < len (self.lines))
+            else:
+                self.prev_button.set_sensitive (False)
+                self.next_button.set_sensitive (False)
+
+            samples = self.get_samples ()
+
+            if samples:
+                self.select_samples_button.set_sensitive (True)
+                self.select_samples_button.set_tooltip_text (
+                    str (Selection (samples))
+                )
+            else:
+                self.select_samples_button.set_sensitive (False)
+                self.select_samples_button.set_tooltip_text (None)
+
+        def select (self, line):
+            if line is not None:
+                for row in self.store:
+                    if row[self.store.LINE] == line:
+                        iter = row.iter
+                        path = self.store.get_path (iter)
+
+                        self.tree.get_selection ().select_iter (iter)
+
+                        self.tree.scroll_to_cell (path, None, True, 0.5, 0)
+
+                        break
+            else:
+                self.tree.get_selection ().unselect_all ()
+
+
+        def move (self, dir):
+            if dir == 0:
+                return
+
+            sel_rows = self.tree.get_selection ().get_selected_rows ()[1]
+
+            if sel_rows:
+                line = self.store[sel_rows[0]][self.store.LINE]
+
+                i = bisect.bisect_left (self.lines, line)
+
+                if dir < 0:
+                    i -= 1
+                elif i < len (self.lines) and self.lines[i] == line:
+                    i += 1
+
+                if i >= 0 and i < len (self.lines):
+                    self.select (self.lines[i])
+                else:
+                    self.select (None)
+
+        def select_samples_clicked (self, button):
+            selection.select (self.get_samples ())
+
+            selection.change_complete ()
+
+        def view_source_clicked (self, button):
+            line = 0
+
+            sel_rows = self.tree.get_selection ().get_selected_rows ()[1]
+
+            if sel_rows:
+                line = self.store[sel_rows[0]][self.store.LINE]
+
+            run_editor (self.file, line)
+
+        def get_path (self):
+            tree_sel = self.tree.get_selection ()
+
+            sel_rows = tree_sel.get_selected_rows ()[1]
+
+            if not sel_rows:
+                return ()
+
+            line = self.store[sel_rows[0]][self.store.LINE]
+
+            return (line,)
+
+        def set_path (self, path):
+            self.select (path[0] if path else None)
+
+        def tree_selection_changed (self, tree_sel):
+            self.update_ui ()
+
+            self.emit ("path-changed")
+
+    def __init__ (self, *args, **kwargs):
+        Gtk.ScrolledWindow.__init__ (
+            self,
+            *args,
+            hscrollbar_policy = Gtk.PolicyType.AUTOMATIC,
+            vscrollbar_policy = Gtk.PolicyType.NEVER,
+            **kwargs
+        )
+
+        self.adjustment_changed_handler = None
+        self.needs_update               = True
+        self.path                       = ()
+
+        profile = self.Profile ()
+        self.root_profile = profile
+        self.add (profile)
+        profile.show ()
+
+        selection.connect ("change-complete", self.selection_change_complete)
+
+        profile.connect ("needs-update",       self.profile_needs_update)
+        profile.connect ("subprofile-added",   self.profile_subprofile_added)
+        profile.connect ("subprofile-removed", self.profile_subprofile_removed)
+        profile.connect ("path-changed",       self.profile_path_changed)
+
+        history.add_source (self.source_get, self.source_set)
+
+    @GObject.Property (type = bool, default = False)
+    def available (self):
+        sel = selection.get_effective_selection ()
+
+        if len (sel) > 1:
+            return any (samples[i].backtrace for i in sel)
+
+        return False
+
+    def update (self):
+        if not self.available:
+            return
+
+        history.block ()
+
+        if self.needs_update:
+            self.root_profile.update ()
+
+            self.needs_update = False
+
+        self.root_profile.set_path (self.path)
+
+        history.unblock ()
+
+    def queue_update (self, now = False):
+        self.needs_update = True
+
+        if now or self.get_mapped ():
+            self.update ()
+
+    def do_map (self):
+        self.update ()
+
+        Gtk.ScrolledWindow.do_map (self)
+
+    def selection_change_complete (self, selection):
+        self.queue_update ()
+
+        self.notify ("available")
+
+    def profile_needs_update (self, profile, now):
+        self.queue_update (now)
+
+    def profile_subprofile_added (self, profile, subprofile):
+        if not history.is_blocked ():
+            self.path = profile.get_path ()
+
+        history.record ()
+
+        if not self.adjustment_changed_handler:
+            adjustment = self.get_hadjustment ()
+
+            def adjustment_changed (adjustment):
+                GObject.signal_handler_disconnect (
+                    adjustment,
+                    self.adjustment_changed_handler
+                )
+                self.adjustment_changed_handler = None
+
+                adjustment.set_value (adjustment.get_upper ())
+
+            self.adjustment_changed_handler = adjustment.connect (
+                "changed",
+                adjustment_changed
+            )
+
+    def profile_subprofile_removed (self, profile, subprofile):
+        if not history.is_blocked ():
+            self.path = profile.get_path ()
+
+        history.record ()
+
+
+    def profile_path_changed (self, profile):
+        if not history.is_blocked ():
+            self.path = profile.get_path ()
+
+        history.update ()
+
+    def source_get (self):
+        return self.path
+
+    def source_set (self, path):
+        self.path = path
+
+        if self.get_mapped ():
+            self.root_profile.set_path (path)
+
+class LogViewer (Gtk.Window):
+    def __init__ (self, *args, **kwargs):
+        Gtk.Window.__init__ (
+            self,
+            *args,
+            default_width   = 1024,
+            default_height  = 768,
+            window_position = Gtk.WindowPosition.CENTER,
+            **kwargs)
+
+        header = Gtk.HeaderBar (
+            title             = "GIMP Performance Log Viewer",
+            show_close_button = True
+        )
+        self.header = header
+        self.set_titlebar (header)
+        header.show ()
+
+        box = Gtk.Box (orientation = Gtk.Orientation.HORIZONTAL)
+        header.pack_start (box)
+        box.get_style_context ().add_class ("linked")
+        box.get_style_context ().add_class ("raised")
+        box.show ()
+
+        button = Gtk.Button.new_from_icon_name ("go-previous-symbolic",
+                                                Gtk.IconSize.BUTTON)
+        box.pack_start (button, False, True, 0)
+        button.show ()
+
+        history.bind_property ("can-undo",
+                               button, "sensitive",
+                               GObject.BindingFlags.SYNC_CREATE)
+
+        button.connect ("clicked", lambda *args: history.undo ())
+
+        button = Gtk.Button.new_from_icon_name ("go-next-symbolic",
+                                                Gtk.IconSize.BUTTON)
+        box.pack_end (button, False, True, 0)
+        button.show ()
+
+        history.bind_property ("can-redo",
+                               button, "sensitive",
+                               GObject.BindingFlags.SYNC_CREATE)
+
+        button.connect ("clicked", lambda *args: history.redo ())
+
+        button = Gtk.MenuButton ()
+        header.pack_end (button)
+        button.set_tooltip_text ("Find samples")
+        button.show ()
+
+        image = Gtk.Image.new_from_icon_name ("edit-find-symbolic",
+                                              Gtk.IconSize.BUTTON)
+        button.add (image)
+        image.show ()
+
+        popover = FindSamplesPopover (relative_to = button)
+        self.find_popover = popover
+        button.set_popover (popover)
+
+        def selection_action (action):
+            def f (*args):
+                action (selection)
+                selection.change_complete ()
+
+            return f
+
+        button = Gtk.Button.new_from_icon_name (
+            "object-flip-horizontal-symbolic",
+            Gtk.IconSize.BUTTON
+        )
+        header.pack_end (button)
+        button.set_tooltip_text ("Invert selection")
+        button.show ()
+
+        button.connect ("clicked", selection_action (Selection.invert))
+
+        button = Gtk.Button.new_from_icon_name (
+            "edit-clear-symbolic",
+            Gtk.IconSize.BUTTON
+        )
+        self.clear_selection_button = button
+        header.pack_end (button)
+        button.set_tooltip_text ("Clear selection")
+        button.show ()
+
+        button.connect ("clicked", selection_action (Selection.clear))
+
+        paned = Gtk.Paned (orientation = Gtk.Orientation.VERTICAL)
+        self.paned = paned
+        self.add (paned)
+        paned.set_position (144)
+        paned.show ()
+
+        graphs = SampleGraphList ()
+        paned.add1 (graphs)
+        paned.child_set (graphs, shrink = False)
+        graphs.show ()
+
+        hbox = Gtk.Box (orientation = Gtk.Orientation.HORIZONTAL)
+        paned.add2 (hbox)
+        hbox.show ()
+
+        sidebar = Gtk.StackSidebar ()
+        hbox.pack_start (sidebar, False, False, 0)
+        sidebar.show ()
+
+        stack = Gtk.Stack (transition_type = Gtk.StackTransitionType.CROSSFADE)
+        self.stack = stack
+        hbox.pack_start (stack, True, True, 0)
+        stack.show ()
+
+        sidebar.set_stack (stack)
+
+        info_viewer = InformationViewer ()
+        stack.add_titled (info_viewer, "information", "Information")
+        info_viewer.show ()
+
+        if markers:
+            markers_viewer = MarkersViewer ()
+            stack.add_titled (markers_viewer, "markers", "Markers")
+            markers_viewer.show ()
+
+        vars_viewer = VariablesViewer ()
+        stack.add_titled (vars_viewer, "variables", "Variables")
+        vars_viewer.show ()
+
+        box = Gtk.Box (orientation = Gtk.Orientation.VERTICAL)
+        self.cflow_box = box
+        stack.add_named (box, "cflow")
+
+        backtrace_viewer = BacktraceViewer ()
+        self.backtrace_viewer = backtrace_viewer
+        box.pack_start (backtrace_viewer, True, True, 0)
+
+        backtrace_viewer.bind_property ("available",
+                                        backtrace_viewer, "visible",
+                                        GObject.BindingFlags.SYNC_CREATE)
+
+        backtrace_viewer.connect ("notify::available",
+                                  self.cflow_notify_available)
+
+        profile_viewer = ProfileViewer ()
+        self.profile_viewer = profile_viewer
+        box.pack_start (profile_viewer, True, True, 0)
+
+        profile_viewer.bind_property ("available",
+                                      profile_viewer, "visible",
+                                      GObject.BindingFlags.SYNC_CREATE)
+
+        profile_viewer.connect ("notify::available",
+                                self.cflow_notify_available)
+
+        self.cflow_notify_available (self)
+
+        selection.connect ("change-complete", self.selection_change_complete)
+
+        self.selection_change_complete (selection)
+
+    def selection_change_complete (self, selection):
+        self.header.set_subtitle (str (selection))
+        self.clear_selection_button.set_sensitive (selection.selection)
+
+    def cflow_notify_available (self, *args):
+        if self.backtrace_viewer.available:
+            self.stack.child_set (self.cflow_box, title = "Backtrace")
+            self.cflow_box.show ()
+        elif self.profile_viewer.available:
+            self.stack.child_set (self.cflow_box, title = "Profile")
+            self.cflow_box.show ()
+        else:
+            self.cflow_box.hide ()
+
+Gtk.Settings.get_default ().set_property ("gtk-application-prefer-dark-theme",
+                                          True)
+
+window = LogViewer ()
+window.show ()
+
+window.connect ("destroy", Gtk.main_quit)
+
+history.record ()
+
+Gtk.main ()