mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-12-25 01:30:38 +00:00
1099 lines
33 KiB
Python
1099 lines
33 KiB
Python
# -*- coding: utf-8; mode: python; -*-
|
|
#
|
|
# GStreamer Debug Viewer - View and analyze GStreamer debug log files
|
|
#
|
|
# Copyright (C) 2007 René Stadler <mail@renestadler.de>
|
|
#
|
|
# 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 <http://www.gnu.org/licenses/>.
|
|
|
|
"""GStreamer Debug Viewer timeline widget plugin."""
|
|
|
|
import logging
|
|
|
|
from GstDebugViewer import Common, Data
|
|
from GstDebugViewer.GUI.colors import LevelColorThemeTango, ThreadColorThemeTango
|
|
from GstDebugViewer.Plugins import FeatureBase, PluginBase
|
|
|
|
from gettext import gettext as _
|
|
from gi.repository import GObject
|
|
from gi.repository import Gtk
|
|
from gi.repository import Gdk
|
|
import cairo
|
|
|
|
|
|
def iter_model_reversed(model):
|
|
|
|
count = model.iter_n_children(None)
|
|
for i in range(count - 1, 0, -1):
|
|
yield model[i]
|
|
|
|
|
|
class LineFrequencySentinel (object):
|
|
|
|
def __init__(self, model):
|
|
|
|
self.model = model
|
|
self.clear()
|
|
|
|
def clear(self):
|
|
|
|
self.data = None
|
|
self.n_partitions = None
|
|
self.partitions = None
|
|
self.step = None
|
|
self.ts_range = None
|
|
|
|
def _search_ts(self, target_ts, first_index, last_index):
|
|
|
|
model_get = self.model.get_value
|
|
model_iter_nth_child = self.model.iter_nth_child
|
|
col_id = self.model.COL_TIME
|
|
|
|
# TODO: Rewrite using a lightweight view object + bisect.
|
|
|
|
while True:
|
|
middle = (last_index - first_index) // 2 + first_index
|
|
if middle == first_index:
|
|
return first_index
|
|
ts = model_get(model_iter_nth_child(None, middle), col_id)
|
|
if ts < target_ts:
|
|
first_index = middle
|
|
elif ts > target_ts:
|
|
last_index = middle
|
|
else:
|
|
return middle
|
|
|
|
def run_for(self, n):
|
|
|
|
if n == 0:
|
|
raise ValueError("illegal value for n")
|
|
|
|
self.n_partitions = n
|
|
|
|
def process(self):
|
|
|
|
model = self.model
|
|
result = []
|
|
partitions = []
|
|
|
|
first_ts = None
|
|
for row in self.model:
|
|
first_ts = row[model.COL_TIME]
|
|
if first_ts is not None:
|
|
break
|
|
|
|
if first_ts is None:
|
|
return
|
|
|
|
last_ts = None
|
|
i = 0
|
|
UNPARSABLE_LIMIT = 500
|
|
for row in iter_model_reversed(self.model):
|
|
last_ts = row[model.COL_TIME]
|
|
# FIXME: We ignore 0 here (unparsable lines!), this should be
|
|
# handled differently!
|
|
i += 1
|
|
if i == UNPARSABLE_LIMIT:
|
|
break
|
|
if last_ts:
|
|
last_index = row.path[0]
|
|
break
|
|
|
|
if last_ts is None or last_ts < first_ts:
|
|
return
|
|
|
|
step = int(float(last_ts - first_ts) / float(self.n_partitions))
|
|
|
|
YIELD_LIMIT = 100
|
|
limit = YIELD_LIMIT
|
|
|
|
first_index = 0
|
|
target_ts = first_ts + step
|
|
old_found = 0
|
|
while target_ts < last_ts:
|
|
limit -= 1
|
|
if limit == 0:
|
|
limit = YIELD_LIMIT
|
|
yield True
|
|
found = self._search_ts(target_ts, first_index, last_index)
|
|
result.append(found - old_found)
|
|
partitions.append(found)
|
|
old_found = found
|
|
first_index = found
|
|
target_ts += step
|
|
|
|
if step == 0:
|
|
result = []
|
|
partitions = []
|
|
|
|
self.step = step
|
|
self.data = result
|
|
self.partitions = partitions
|
|
self.ts_range = (first_ts, last_ts,)
|
|
|
|
|
|
class LevelDistributionSentinel (object):
|
|
|
|
def __init__(self, freq_sentinel, model):
|
|
|
|
self.freq_sentinel = freq_sentinel
|
|
self.model = model
|
|
self.data = []
|
|
|
|
def clear(self):
|
|
|
|
del self.data[:]
|
|
|
|
def process(self):
|
|
|
|
MAX_LEVELS = 9
|
|
YIELD_LIMIT = 10000
|
|
y = YIELD_LIMIT
|
|
|
|
model_get = self.model.get_value
|
|
model_next = self.model.iter_next
|
|
id_time = self.model.COL_TIME
|
|
id_level = self.model.COL_LEVEL
|
|
del self.data[:]
|
|
data = self.data
|
|
i = 0
|
|
partitions_i = 0
|
|
partitions = self.freq_sentinel.partitions
|
|
counts = [0] * MAX_LEVELS
|
|
tree_iter = self.model.get_iter_first()
|
|
|
|
if not partitions:
|
|
return
|
|
|
|
level_index = 0
|
|
level_iter = None
|
|
|
|
finished = False
|
|
while tree_iter:
|
|
y -= 1
|
|
if y == 0:
|
|
y = YIELD_LIMIT
|
|
yield True
|
|
if level_iter is None:
|
|
stop_index = level_index + 512
|
|
levels = self.model.get_value_range(id_level,
|
|
level_index, stop_index)
|
|
level_index = stop_index
|
|
level_iter = iter(levels)
|
|
try:
|
|
level = level_iter.__next__()
|
|
except StopIteration:
|
|
level_iter = None
|
|
continue
|
|
while i > partitions[partitions_i]:
|
|
data.append(tuple(counts))
|
|
counts = [0] * MAX_LEVELS
|
|
partitions_i += 1
|
|
if partitions_i == len(partitions):
|
|
finished = True
|
|
break
|
|
if finished:
|
|
break
|
|
counts[level] += 1
|
|
i += 1
|
|
|
|
# Now handle the last one:
|
|
data.append(tuple(counts))
|
|
|
|
yield False
|
|
|
|
|
|
class UpdateProcess (object):
|
|
|
|
def __init__(self, freq_sentinel, dist_sentinel):
|
|
|
|
self.freq_sentinel = freq_sentinel
|
|
self.dist_sentinel = dist_sentinel
|
|
self.is_running = False
|
|
self.dispatcher = Common.Data.GSourceDispatcher()
|
|
|
|
def __process(self):
|
|
|
|
if self.freq_sentinel is None or self.dist_sentinel is None:
|
|
return
|
|
|
|
self.is_running = True
|
|
|
|
for x in self.freq_sentinel.process():
|
|
yield True
|
|
|
|
self.handle_sentinel_finished(self.freq_sentinel)
|
|
|
|
for x in self.dist_sentinel.process():
|
|
yield True
|
|
self.handle_sentinel_progress(self.dist_sentinel)
|
|
|
|
self.is_running = False
|
|
|
|
self.handle_sentinel_finished(self.dist_sentinel)
|
|
self.handle_process_finished()
|
|
|
|
yield False
|
|
|
|
def run(self):
|
|
|
|
if self.is_running:
|
|
return
|
|
|
|
self.dispatcher(self.__process())
|
|
|
|
def abort(self):
|
|
|
|
if not self.is_running:
|
|
return
|
|
|
|
self.dispatcher.cancel()
|
|
self.is_running = False
|
|
|
|
def handle_sentinel_progress(self, sentinel):
|
|
|
|
pass
|
|
|
|
def handle_sentinel_finished(self, sentinel):
|
|
|
|
pass
|
|
|
|
def handle_process_finished(self):
|
|
|
|
pass
|
|
|
|
|
|
class VerticalTimelineWidget (Gtk.DrawingArea):
|
|
|
|
__gtype_name__ = "GstDebugViewerVerticalTimelineWidget"
|
|
|
|
def __init__(self, log_view):
|
|
|
|
GObject.GObject.__init__(self)
|
|
|
|
self.logger = logging.getLogger("ui.vtimeline")
|
|
|
|
self.log_view = log_view
|
|
self.theme = ThreadColorThemeTango()
|
|
self.params = None
|
|
self.thread_colors = {}
|
|
self.next_thread_color = 0
|
|
|
|
try:
|
|
self.set_tooltip_text(_("Vertical timeline\n"
|
|
"Different colors represent different threads"))
|
|
except AttributeError:
|
|
# Compatibility.
|
|
pass
|
|
|
|
def do_draw(self, ctx):
|
|
|
|
alloc = self.get_allocation()
|
|
x = alloc.x
|
|
y = alloc.y
|
|
w = alloc.width
|
|
h = alloc.height
|
|
|
|
# White background rectangle.
|
|
ctx.set_line_width(0.)
|
|
ctx.rectangle(0, 0, w, h)
|
|
ctx.set_source_rgb(1., 1., 1.)
|
|
ctx.fill()
|
|
ctx.new_path()
|
|
|
|
if self.params is None:
|
|
self.__update_params()
|
|
|
|
if self.params is None:
|
|
return
|
|
|
|
first_y, cell_height, data = self.params
|
|
if len(data) < 2:
|
|
return
|
|
first_ts, last_ts = data[0][0], data[-1][0]
|
|
ts_range = last_ts - first_ts
|
|
if ts_range == 0:
|
|
return
|
|
|
|
ctx.set_line_width(1.)
|
|
ctx.set_source_rgb(0., 0., 0.)
|
|
|
|
half_height = cell_height // 2 - .5
|
|
quarter_height = cell_height // 4 - .5
|
|
first_y += half_height
|
|
for i, i_data in enumerate(data):
|
|
ts, thread = i_data
|
|
if thread in self.thread_colors:
|
|
ctx.set_source_rgb(*self.thread_colors[thread])
|
|
else:
|
|
self.next_thread_color += 1
|
|
if self.next_thread_color == len(self.theme.colors):
|
|
self.next_thread_color = 0
|
|
color = self.theme.colors[
|
|
self.next_thread_color][0].float_tuple()
|
|
self.thread_colors[thread] = color
|
|
ctx.set_source_rgb(*color)
|
|
ts_fraction = float(ts - first_ts) / ts_range
|
|
ts_offset = ts_fraction * h
|
|
row_offset = first_y + i * cell_height
|
|
ctx.move_to(-.5, ts_offset)
|
|
ctx.line_to(half_height, ts_offset)
|
|
ctx.line_to(w - quarter_height, row_offset)
|
|
ctx.stroke()
|
|
ctx.line_to(w - quarter_height, row_offset)
|
|
ctx.line_to(w + .5, row_offset - half_height)
|
|
ctx.line_to(w + .5, row_offset + half_height)
|
|
ctx.fill()
|
|
return True
|
|
|
|
def do_configure_event(self, event):
|
|
|
|
self.params = None
|
|
self.queue_draw()
|
|
|
|
return False
|
|
|
|
def do_get_preferred_width(self):
|
|
|
|
return 64, 64 # FIXME
|
|
|
|
def clear(self):
|
|
|
|
self.params = None
|
|
self.thread_colors.clear()
|
|
self.next_thread_color = 0
|
|
self.queue_draw()
|
|
|
|
def __update_params(self):
|
|
|
|
# FIXME: Ideally we should take the vertical position difference of the
|
|
# view into account (which is 0 with the current UI layout).
|
|
|
|
view = self.log_view
|
|
model = view.get_model()
|
|
visible_range = view.get_visible_range()
|
|
if visible_range is None:
|
|
return
|
|
start_path, end_path = visible_range
|
|
|
|
if not start_path or not end_path:
|
|
return
|
|
|
|
column = view.get_column(0)
|
|
bg_rect = view.get_background_area(start_path, column)
|
|
cell_height = bg_rect.height
|
|
cell_rect = view.get_cell_area(start_path, column)
|
|
try:
|
|
first_y = view.convert_bin_window_to_widget_coords(
|
|
cell_rect.x, cell_rect.y)[1]
|
|
except (AttributeError, SystemError,):
|
|
# AttributeError is with PyGTK before 2.12. SystemError is raised
|
|
# with PyGTK 2.12.0, pygtk bug #479012.
|
|
first_y = cell_rect.y % cell_height
|
|
|
|
global _warn_tree_view_coords
|
|
try:
|
|
_warn_tree_view_coords
|
|
except NameError:
|
|
self.logger.warning("tree view coordinate conversion method "
|
|
"not available, using aproximate offset")
|
|
# Only warn once:
|
|
_warn_tree_view_coords = True
|
|
|
|
data = []
|
|
tree_iter = model.get_iter(start_path)
|
|
if tree_iter is None:
|
|
return
|
|
while model.get_path(tree_iter) != end_path:
|
|
data.append(
|
|
model.get(tree_iter, model.COL_TIME, model.COL_THREAD))
|
|
tree_iter = model.iter_next(tree_iter)
|
|
|
|
self.params = (first_y, cell_height, data,)
|
|
|
|
def update(self):
|
|
|
|
self.params = None
|
|
self.queue_draw()
|
|
|
|
|
|
class TimelineWidget (Gtk.DrawingArea):
|
|
|
|
__gtype_name__ = "GstDebugViewerTimelineWidget"
|
|
|
|
__gsignals__ = {"change-position": (GObject.SignalFlags.RUN_LAST,
|
|
None,
|
|
(GObject.TYPE_INT,),)}
|
|
|
|
def __init__(self):
|
|
|
|
GObject.GObject.__init__(self)
|
|
|
|
self.logger = logging.getLogger("ui.timeline")
|
|
|
|
self.add_events(Gdk.EventMask.BUTTON1_MOTION_MASK |
|
|
Gdk.EventMask.BUTTON_PRESS_MASK |
|
|
Gdk.EventMask.BUTTON_RELEASE_MASK)
|
|
|
|
self.process = UpdateProcess(None, None)
|
|
self.process.handle_sentinel_progress = self.__handle_sentinel_progress
|
|
self.process.handle_sentinel_finished = self.__handle_sentinel_finished
|
|
|
|
self.model = None
|
|
self.__offscreen = None
|
|
self.__offscreen_size = (0, 0)
|
|
self.__offscreen_dirty = (0, 0)
|
|
|
|
self.__position_ts_range = None
|
|
|
|
try:
|
|
self.set_tooltip_text(_("Log event histogram\n"
|
|
"Different colors represent different log-levels"))
|
|
except AttributeError:
|
|
# Compatibility.
|
|
pass
|
|
|
|
def __handle_sentinel_progress(self, sentinel):
|
|
|
|
if sentinel == self.process.dist_sentinel:
|
|
old_progress = self.__dist_sentinel_progress
|
|
new_progress = len(sentinel.data)
|
|
if new_progress - old_progress >= 32:
|
|
self.__invalidate_offscreen(old_progress, new_progress)
|
|
self.__dist_sentinel_progress = new_progress
|
|
|
|
def __handle_sentinel_finished(self, sentinel):
|
|
|
|
if sentinel == self.process.freq_sentinel:
|
|
self.__invalidate_offscreen(0, -1)
|
|
else:
|
|
self.__invalidate_offscreen(self.__dist_sentinel_progress, -1)
|
|
|
|
def __ensure_offscreen(self):
|
|
|
|
alloc = self.get_allocation()
|
|
if self.__offscreen_size == (alloc.width, alloc.height):
|
|
return
|
|
|
|
self.__offscreen = cairo.ImageSurface(
|
|
cairo.FORMAT_ARGB32, alloc.width, alloc.height)
|
|
self.__offscreen_size = (alloc.width, alloc.height)
|
|
self.__offscreen_dirty = (0, alloc.width)
|
|
if not self.__offscreen:
|
|
self.__offscreen_size = (0, 0)
|
|
raise ValueError("could not obtain offscreen image surface")
|
|
|
|
def __invalidate_offscreen(self, start, stop):
|
|
|
|
alloc = self.get_allocation()
|
|
if stop < 0:
|
|
stop += alloc.width
|
|
|
|
dirty_start, dirty_stop = self.__offscreen_dirty
|
|
if dirty_start != dirty_stop:
|
|
dirty_start = min(dirty_start, start)
|
|
dirty_stop = max(dirty_stop, stop)
|
|
else:
|
|
dirty_start = start
|
|
dirty_stop = stop
|
|
self.__offscreen_dirty = (dirty_start, dirty_stop)
|
|
|
|
# Just like in __draw_offscreen. FIXME: Need this in one place!
|
|
start -= 8
|
|
stop += 8
|
|
self.queue_draw_area(start, 0, stop - start, alloc.height)
|
|
|
|
def __draw_from_offscreen(self, ctx):
|
|
|
|
if not self.props.visible:
|
|
return
|
|
|
|
alloc = self.get_allocation()
|
|
offscreen_width, offscreen_height = self.__offscreen_size
|
|
rect = Gdk.Rectangle() # TODO: damage region
|
|
rect.x, rect.y, rect.width, rect.height = 0, 0, alloc.width, alloc.height
|
|
|
|
# Fill the background (where the offscreen pixmap doesn't fit) with
|
|
# white. This happens after enlarging the window, until all sentinels
|
|
# have finished running.
|
|
if offscreen_width < alloc.width or offscreen_height < alloc.height:
|
|
ctx.rectangle(rect.x, rect.y, rect.width, rect.height)
|
|
ctx.clip()
|
|
|
|
if offscreen_width < alloc.width:
|
|
ctx.rectangle(
|
|
offscreen_width, 0, alloc.width, offscreen_height)
|
|
if offscreen_height < alloc.height:
|
|
ctx.new_path()
|
|
ctx.rectangle(0, offscreen_height, alloc.width, alloc.height)
|
|
|
|
ctx.set_line_width(0.)
|
|
ctx.set_source_rgb(1., 1., 1.)
|
|
ctx.fill()
|
|
|
|
ctx.set_source_surface(self.__offscreen)
|
|
ctx.rectangle(rect.x, rect.y, rect.width, rect.height)
|
|
ctx.paint()
|
|
|
|
self.__draw_position(ctx, clip=rect)
|
|
|
|
def update(self, model):
|
|
|
|
self.clear()
|
|
self.model = model
|
|
|
|
if model is not None:
|
|
self.__dist_sentinel_progress = 0
|
|
self.process.freq_sentinel = LineFrequencySentinel(model)
|
|
self.process.dist_sentinel = LevelDistributionSentinel(
|
|
self.process.freq_sentinel, model)
|
|
width = self.get_allocation().width
|
|
self.process.freq_sentinel.run_for(width)
|
|
self.process.run()
|
|
|
|
def clear(self):
|
|
|
|
self.model = None
|
|
self.process.abort()
|
|
self.process.freq_sentinel = None
|
|
self.process.dist_sentinel = None
|
|
self.__invalidate_offscreen(0, -1)
|
|
|
|
def update_position(self, start_ts, end_ts):
|
|
|
|
if not self.process.freq_sentinel:
|
|
return
|
|
|
|
if not self.process.freq_sentinel.data:
|
|
return
|
|
|
|
alloc = self.get_allocation()
|
|
|
|
# Queue old position rectangle for redraw:
|
|
if self.__position_ts_range is not None:
|
|
start, stop = self.ts_range_to_position(*self.__position_ts_range)
|
|
self.queue_draw_area(start - 1, 0, stop - start + 2, alloc.height)
|
|
# And the new one:
|
|
start, stop = self.ts_range_to_position(start_ts, end_ts)
|
|
self.queue_draw_area(start - 1, 0, stop - start + 2, alloc.height)
|
|
|
|
self.__position_ts_range = (start_ts, end_ts,)
|
|
|
|
def find_indicative_time_step(self):
|
|
|
|
MINIMUM_PIXEL_STEP = 32
|
|
time_per_pixel = self.process.freq_sentinel.step
|
|
return 32 # FIXME use self.freq_sentinel.step and len (self.process.freq_sentinel.data)
|
|
|
|
def __draw_offscreen(self):
|
|
|
|
dirty_start, dirty_stop = self.__offscreen_dirty
|
|
if dirty_start == dirty_stop:
|
|
return
|
|
|
|
self.__offscreen_dirty = (0, 0)
|
|
width, height = self.__offscreen_size
|
|
|
|
ctx = cairo.Context(self.__offscreen)
|
|
|
|
# Indicator (triangle) size is 8, so we need to draw surrounding areas
|
|
# a bit:
|
|
dirty_start -= 8
|
|
dirty_stop += 8
|
|
dirty_start = max(dirty_start, 0)
|
|
dirty_stop = min(dirty_stop, width)
|
|
|
|
ctx.rectangle(dirty_start, 0., dirty_stop, height)
|
|
ctx.clip()
|
|
|
|
# White background rectangle.
|
|
ctx.set_line_width(0.)
|
|
ctx.rectangle(0, 0, width, height)
|
|
ctx.set_source_rgb(1., 1., 1.)
|
|
ctx.fill()
|
|
ctx.new_path()
|
|
|
|
# Horizontal reference lines.
|
|
ctx.set_line_width(1.)
|
|
ctx.set_source_rgb(.95, .95, .95)
|
|
for i in range(height // 16):
|
|
y = i * 16 - .5
|
|
ctx.move_to(0, y)
|
|
ctx.line_to(width, y)
|
|
ctx.stroke()
|
|
|
|
if self.process.freq_sentinel is None:
|
|
return
|
|
|
|
# Vertical reference lines.
|
|
pixel_step = self.find_indicative_time_step()
|
|
ctx.set_source_rgb(.9, .9, .9)
|
|
start = dirty_start - dirty_start % pixel_step
|
|
for x in range(start + pixel_step, dirty_stop, pixel_step):
|
|
ctx.move_to(x - .5, 0)
|
|
ctx.line_to(x - .5, height)
|
|
ctx.stroke()
|
|
|
|
if not self.process.freq_sentinel.data:
|
|
self.logger.debug("frequency sentinel has no data yet")
|
|
return
|
|
|
|
ctx.translate(dirty_start, 0.)
|
|
|
|
maximum = max(self.process.freq_sentinel.data)
|
|
|
|
ctx.set_source_rgb(0., 0., 0.)
|
|
data = self.process.freq_sentinel.data[dirty_start:dirty_stop]
|
|
self.__draw_graph(ctx, height, maximum, data)
|
|
|
|
if not self.process.dist_sentinel.data:
|
|
self.logger.debug("level distribution sentinel has no data yet")
|
|
return
|
|
|
|
colors = LevelColorThemeTango().colors
|
|
dist_data = self.process.dist_sentinel.data[dirty_start:dirty_stop]
|
|
|
|
def cumulative_level_counts(*levels):
|
|
for level_counts in dist_data:
|
|
yield sum((level_counts[level] for level in levels))
|
|
|
|
level = Data.debug_level_info
|
|
levels_prev = (Data.debug_level_trace,
|
|
Data.debug_level_fixme,
|
|
Data.debug_level_log,
|
|
Data.debug_level_debug,)
|
|
ctx.set_source_rgb(*(colors[level][1].float_tuple()))
|
|
self.__draw_graph(ctx, height, maximum,
|
|
list(cumulative_level_counts(level, *levels_prev)))
|
|
|
|
level = Data.debug_level_debug
|
|
levels_prev = (Data.debug_level_trace,
|
|
Data.debug_level_fixme,
|
|
Data.debug_level_log,)
|
|
ctx.set_source_rgb(*(colors[level][1].float_tuple()))
|
|
self.__draw_graph(ctx, height, maximum,
|
|
list(cumulative_level_counts(level, *levels_prev)))
|
|
|
|
level = Data.debug_level_log
|
|
levels_prev = (Data.debug_level_trace, Data.debug_level_fixme,)
|
|
ctx.set_source_rgb(*(colors[level][1].float_tuple()))
|
|
self.__draw_graph(ctx, height, maximum,
|
|
list(cumulative_level_counts(level, *levels_prev)))
|
|
|
|
level = Data.debug_level_fixme
|
|
levels_prev = (Data.debug_level_trace,)
|
|
ctx.set_source_rgb(*(colors[level][1].float_tuple()))
|
|
self.__draw_graph(ctx, height, maximum,
|
|
list(cumulative_level_counts(level, *levels_prev)))
|
|
|
|
level = Data.debug_level_trace
|
|
ctx.set_source_rgb(*(colors[level][1].float_tuple()))
|
|
self.__draw_graph(ctx, height, maximum, [
|
|
counts[level] for counts in dist_data])
|
|
|
|
# Draw error and warning triangle indicators:
|
|
|
|
def triangle(ctx, size=8):
|
|
ctx.move_to(-size // 2, 0)
|
|
ctx.line_to((size + 1) // 2, 0)
|
|
ctx.line_to(0, size / 1.41)
|
|
ctx.close_path()
|
|
|
|
for level in (Data.debug_level_warning, Data.debug_level_error,):
|
|
ctx.set_source_rgb(*(colors[level][1].float_tuple()))
|
|
for i, counts in enumerate(dist_data):
|
|
if counts[level] == 0:
|
|
continue
|
|
ctx.translate(i, 0.)
|
|
triangle(ctx)
|
|
ctx.fill()
|
|
ctx.translate(-i, 0.)
|
|
|
|
def __draw_graph(self, ctx, height, maximum, data):
|
|
|
|
if not data:
|
|
return
|
|
|
|
if maximum:
|
|
heights = [height * float(d) / maximum for d in data]
|
|
else:
|
|
heights = [0. for d in data]
|
|
|
|
ctx.move_to(0, height)
|
|
for i in range(len(heights)):
|
|
ctx.line_to(i - .5, height - heights[i] + .5)
|
|
|
|
ctx.line_to(i, height)
|
|
ctx.close_path()
|
|
|
|
ctx.fill()
|
|
|
|
def __have_position(self):
|
|
|
|
if ((self.process is not None) and
|
|
(self.process.freq_sentinel is not None) and
|
|
(self.process.freq_sentinel.ts_range is not None)):
|
|
return True
|
|
else:
|
|
return False
|
|
|
|
def ts_range_to_position(self, start_ts, end_ts):
|
|
|
|
if not self.__have_position():
|
|
return (0, 0)
|
|
|
|
first_ts, last_ts = self.process.freq_sentinel.ts_range
|
|
step = self.process.freq_sentinel.step
|
|
if step == 0:
|
|
return (0, 0)
|
|
|
|
position1 = int(float(start_ts - first_ts) / step)
|
|
position2 = int(float(end_ts - first_ts) / step)
|
|
|
|
return (position1, position2)
|
|
|
|
def __draw_position(self, ctx, clip=None):
|
|
|
|
if not self.__have_position() or self.__position_ts_range is None:
|
|
if not self.__have_position():
|
|
self.logger.debug("have no positions")
|
|
else:
|
|
self.logger.debug("have no positions_ts_range")
|
|
return
|
|
|
|
start_ts, end_ts = self.__position_ts_range
|
|
position1, position2 = self.ts_range_to_position(start_ts, end_ts)
|
|
|
|
if clip:
|
|
if clip.x + clip.width < position1 - 1 or clip.x > position2 + 1:
|
|
self.logger.debug(
|
|
"outside of clip range: %d + %d, pos: %d, %d", clip.x, clip.width, position1, position2)
|
|
return
|
|
ctx.rectangle(clip.x, clip.y, clip.width, clip.height)
|
|
ctx.clip()
|
|
|
|
height = self.get_allocation().height
|
|
|
|
line_width = position2 - position1
|
|
if line_width <= 1:
|
|
ctx.set_source_rgb(1., 0., 0.)
|
|
ctx.set_line_width(1.)
|
|
ctx.move_to(position1 + .5, 0)
|
|
ctx.line_to(position1 + .5, height)
|
|
ctx.stroke()
|
|
else:
|
|
ctx.set_source_rgba(1., 0., 0., .5)
|
|
ctx.rectangle(position1, 0, line_width, height)
|
|
ctx.fill()
|
|
|
|
def do_draw(self, cr):
|
|
|
|
self.__ensure_offscreen()
|
|
self.__draw_offscreen()
|
|
self.__draw_from_offscreen(cr)
|
|
|
|
return True
|
|
|
|
def do_configure_event(self, event):
|
|
|
|
self.logger.debug("widget size configured to %ix%i",
|
|
event.width, event.height)
|
|
|
|
if event.width < 16:
|
|
return False
|
|
|
|
self.update(self.model)
|
|
|
|
return False
|
|
|
|
def do_get_preferred_height(self):
|
|
|
|
return 64, 64 # FIXME:
|
|
|
|
def do_button_press_event(self, event):
|
|
|
|
if event.button != 1:
|
|
return False
|
|
|
|
# TODO: Check if clicked inside a warning/error indicator triangle and
|
|
# navigate there.
|
|
|
|
if not self.has_grab():
|
|
self.grab_add()
|
|
self.props.has_tooltip = False
|
|
|
|
pos = int(event.x)
|
|
self.emit("change-position", pos)
|
|
return True
|
|
|
|
def do_button_release_event(self, event):
|
|
|
|
if event.button != 1:
|
|
return False
|
|
|
|
if self.has_grab():
|
|
self.grab_remove()
|
|
self.props.has_tooltip = True
|
|
|
|
return True
|
|
|
|
def do_motion_notify_event(self, event):
|
|
|
|
if event.get_state() & Gdk.ModifierType.BUTTON1_MASK:
|
|
self.emit("change-position", int(event.x))
|
|
Gdk.event_request_motions(event)
|
|
return True
|
|
else:
|
|
self._handle_motion(event.x, event.y)
|
|
Gdk.event_request_motions(event)
|
|
return False
|
|
|
|
def _handle_motion(self, x, y):
|
|
|
|
# TODO: Prelight warning and error indicator triangles.
|
|
|
|
pass
|
|
|
|
|
|
class AttachedWindow (object):
|
|
|
|
def __init__(self, feature, window):
|
|
|
|
self.window = window
|
|
|
|
ui = window.ui_manager
|
|
|
|
ui.insert_action_group(feature.action_group, 0)
|
|
|
|
self.merge_id = ui.new_merge_id()
|
|
ui.add_ui(self.merge_id, "/menubar/ViewMenu/ViewMenuAdditions",
|
|
"ViewTimeline", "show-timeline",
|
|
Gtk.UIManagerItemType.MENUITEM, False)
|
|
|
|
ui.add_ui(self.merge_id, "/", "TimelineContextMenu", None,
|
|
Gtk.UIManagerItemType.POPUP, False)
|
|
# TODO: Make hide before/after operate on the partition that the mouse
|
|
# is pointed at instead of the currently selected line.
|
|
# ui.add_ui (self.merge_id, "/TimelineContextMenu", "TimelineHideLinesBefore",
|
|
# "hide-before-line", Gtk.UIManagerItemType.MENUITEM, False)
|
|
# ui.add_ui (self.merge_id, "/TimelineContextMenu", "TimelineHideLinesAfter",
|
|
# "hide-after-line", Gtk.UIManagerItemType.MENUITEM, False)
|
|
ui.add_ui(
|
|
self.merge_id, "/TimelineContextMenu", "TimelineShowHiddenLines",
|
|
"show-hidden-lines", Gtk.UIManagerItemType.MENUITEM, False)
|
|
|
|
box = window.get_top_attach_point()
|
|
|
|
self.timeline = TimelineWidget()
|
|
self.timeline.connect("change-position",
|
|
self.handle_timeline_change_position)
|
|
box.pack_start(self.timeline, False, False, 0)
|
|
self.timeline.hide()
|
|
|
|
self.popup = ui.get_widget("/TimelineContextMenu")
|
|
Common.GUI.widget_add_popup_menu(self.timeline, self.popup)
|
|
|
|
box = window.get_side_attach_point()
|
|
|
|
self.vtimeline = VerticalTimelineWidget(self.window.log_view)
|
|
box.pack_start(self.vtimeline, False, False, 0)
|
|
self.vtimeline.hide()
|
|
|
|
handler = self.handle_log_view_adjustment_value_changed
|
|
adjustment = window.widgets.log_view_scrolled_window.props.vadjustment
|
|
adjustment.connect("value-changed", handler)
|
|
|
|
handler = self.handle_show_action_toggled
|
|
action = feature.action_group.get_action("show-timeline")
|
|
action.connect("toggled", handler)
|
|
handler(action)
|
|
|
|
handler = self.handle_log_view_notify_model
|
|
self.notify_model_id = window.log_view.connect(
|
|
"notify::model", handler)
|
|
|
|
self.idle_scroll_path = None
|
|
self.idle_scroll_id = None
|
|
|
|
def detach(self, feature):
|
|
|
|
self.window.log_view.disconnect(self.notify_model_id)
|
|
self.notify_model_id = None
|
|
|
|
self.window.ui_manager.remove_ui(self.merge_id)
|
|
self.merge_id = None
|
|
|
|
self.window.ui_manager.remove_action_group(feature.action_group)
|
|
|
|
self.timeline.destroy()
|
|
self.timeline = None
|
|
|
|
self.idle_scroll_path = None
|
|
if self.idle_scroll_id is not None:
|
|
GObject.source_remove(self.idle_scroll_id)
|
|
self.idle_scroll_id = None
|
|
|
|
def handle_detach_log_file(self, log_file):
|
|
|
|
self.timeline.clear()
|
|
self.vtimeline.clear()
|
|
|
|
def handle_log_view_notify_model(self, view, gparam):
|
|
|
|
model = view.get_model()
|
|
|
|
if model is None:
|
|
self.timeline.clear()
|
|
self.vtimeline.clear()
|
|
return
|
|
|
|
self.timeline.update(model)
|
|
|
|
# Need to dispatch these idly with a low priority to avoid triggering a
|
|
# warning in treeview.get_visible_range:
|
|
def idle_update():
|
|
self.update_timeline_position()
|
|
self.vtimeline.update()
|
|
return False
|
|
GObject.idle_add(idle_update, priority=GObject.PRIORITY_LOW)
|
|
|
|
def handle_log_view_adjustment_value_changed(self, adj):
|
|
|
|
# FIXME: If not visible, disconnect this handler!
|
|
if not self.timeline.props.visible:
|
|
return
|
|
|
|
self.update_timeline_position()
|
|
self.vtimeline.update()
|
|
|
|
def update_timeline_position(self):
|
|
|
|
visible_range = self.window.get_range()
|
|
if visible_range is None:
|
|
return
|
|
ts1, ts2 = visible_range
|
|
self.timeline.update_position(ts1, ts2)
|
|
|
|
def handle_show_action_toggled(self, action):
|
|
|
|
show = action.props.active
|
|
|
|
if show:
|
|
self.timeline.show()
|
|
self.vtimeline.show()
|
|
else:
|
|
self.timeline.hide()
|
|
self.vtimeline.hide()
|
|
|
|
def handle_timeline_change_position(self, widget, pos):
|
|
|
|
self.goto_time_position(pos)
|
|
|
|
def goto_time_position(self, pos):
|
|
|
|
if not self.timeline.process.freq_sentinel:
|
|
return True
|
|
|
|
data = self.timeline.process.freq_sentinel.data
|
|
if not data:
|
|
return True
|
|
|
|
if pos < 0:
|
|
pos = 0
|
|
elif pos >= len(data):
|
|
pos = len(data) - 1
|
|
|
|
count = sum(data[:pos + 1])
|
|
|
|
path = (count,)
|
|
self.idle_scroll_path = path
|
|
|
|
if self.idle_scroll_id is None:
|
|
self.idle_scroll_id = GObject.idle_add(self.idle_scroll)
|
|
|
|
return False
|
|
|
|
def idle_scroll(self):
|
|
|
|
self.idle_scroll_id = None
|
|
|
|
if self.idle_scroll_path is None:
|
|
return False
|
|
|
|
path = self.idle_scroll_path
|
|
self.idle_scroll_path = None
|
|
|
|
view = self.window.log_view
|
|
view.scroll_to_cell(path, use_align=True, row_align=.5)
|
|
|
|
return False
|
|
|
|
|
|
class TimelineFeature (FeatureBase):
|
|
|
|
def __init__(self, app):
|
|
|
|
self.logger = logging.getLogger("ui.timeline")
|
|
|
|
self.action_group = Gtk.ActionGroup("TimelineActions")
|
|
self.action_group.add_toggle_actions([("show-timeline",
|
|
None, _("_Timeline"),
|
|
"<Ctrl>t")])
|
|
|
|
self.state = app.state.sections[TimelineState._name]
|
|
|
|
self.attached_windows = {}
|
|
|
|
action = self.action_group.get_action("show-timeline")
|
|
action.props.active = self.state.shown
|
|
action.connect("toggled", self.handle_show_action_toggled)
|
|
|
|
def handle_show_action_toggled(self, action):
|
|
|
|
self.state.shown = action.props.active
|
|
|
|
def handle_attach_window(self, window):
|
|
|
|
self.attached_windows[window] = AttachedWindow(self, window)
|
|
|
|
def handle_detach_window(self, window):
|
|
|
|
attached_window = self.attached_windows.pop(window)
|
|
attached_window.detach(self)
|
|
|
|
def handle_attach_log_file(self, window, log_file):
|
|
|
|
pass
|
|
|
|
def handle_detach_log_file(self, window, log_file):
|
|
|
|
attached_window = self.attached_windows[window]
|
|
attached_window.handle_detach_log_file(log_file)
|
|
|
|
|
|
class TimelineState (Common.GUI.StateSection):
|
|
|
|
_name = "timeline"
|
|
|
|
shown = Common.GUI.StateBool("shown", default=True)
|
|
|
|
|
|
class Plugin (PluginBase):
|
|
|
|
features = (TimelineFeature,)
|
|
|
|
def __init__(self, app):
|
|
|
|
app.state.add_section_class(TimelineState)
|
|
self.state = app.state.sections[TimelineState._name]
|