1 /* This file is part of the Linux Trace Toolkit Graphic User Interface
2 * Copyright (C) 2003-2004 Xiangxiu Yang, Mathieu Desnoyers
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License Version 2 as
6 * published by the Free Software Foundation;
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
13 * You should have received a copy of the GNU General Public License
14 * along with this program; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
20 This file is what every viewer plugin writer should refer to.
25 A viewer plugin is, before anything, a plugin. As a dynamically loadable
26 module, it thus has an init and a destroy function called whenever it is
27 loaded/initialized and unloaded/destroyed. A graphical module depends on
28 lttvwindow for construction of its viewer instances. In order to achieve this,
29 it must register its constructor function to the main window along with
30 button description or text menu entry description. A module keeps a list of
31 every viewer that currently sits in memory so it can destroy them before the
32 module gets unloaded/destroyed.
37 The main window is a container that offers menus, buttons and a notebook. Some
38 of those menus and buttons are part of the core of the main window, others
39 are dynamically added and removed when modules are loaded/unloaded.
41 The notebook contains as much tabs as wanted. Each tab is linked with a
42 set of traces (traceset). Each trace contains many tracefiles (one per cpu).
43 A trace corresponds to a kernel being traced. A traceset corresponds to
44 many traces read together. The time span of a traceset goes from the
45 earliest start of all the traces to the latest end of all the traces.
47 Inside each tab are added the viewers. When they interact with the main
48 window through the lttvwindow API, they affect the other viewers located
49 in the same tab as they are.
51 The insertion of many viewers in a tab permits a quick look at all the
52 information wanted in a glance. The main window does merge the read requests
53 from all the viewers in the same tab in a way that every viewer will get exactly
54 the events it asked for, while the event reading loop and state update are
55 shared. It improves performance of events delivery to the viewers.
59 Viewer Instance Related API
61 The lifetime of a viewer is as follows. The viewer constructor function is
62 called each time an instance view is created (one subwindow of this viewer
63 type is created by the user either by clicking on the menu item or the button
64 corresponding to the viewer). Thereafter, the viewer gets hooks called for
65 different purposes by the window containing it. These hooks are detailed
66 below. It also has to deal with GTK Events. Finally, it can be destructed by
67 having its top level widget unreferenced by the main window or by any
68 GTK Event causing a "destroy-event" signal on the its top widget. Another
69 possible way for it do be destroyed is if the module gets unloaded. The module
70 unload function will have to emit a "destroy" signal on each top level widget
71 of all instances of its viewers.
74 Notices from Main Window
76 time_window : This is the time interval visible on the viewer's tab. Every
77 viewer that cares about being synchronised by respect to the
78 time with other viewers should register to this notification.
79 They should redraw all or part of their display when this occurs.
81 traceset : This notification is called whenever a trace is added/removed
82 from the traceset. As it affects all the data displayed by the
83 viewer, it sould redraw itself totally.
85 filter : FIXME : describe..
87 current_time: Being able to zoom nearer a specific time or highlight a specific
88 time on every viewer in synchronicity implies that the viewer
89 has to shown a visual sign over the drawing or select an event
90 when it receives this notice. It should also inform the main
91 window with the appropriate report API function when a user
92 selects a specific time as being the current time.
94 dividor : This notice links the positions of the horizontal dividors
95 between the graphic display zone of every viewer and their Y axis,
96 typically showing processes, cpus, ...
99 FIXME : Add background computation explanation here
100 background_init: prepare for background computation (comes after show_end).
101 process_trace for background: done in small chunks in gtk_idle, hooks called.
102 background_end: remove the hooks and perhaps update the window.
105 Reporting Changes to the Main Window
107 In most cases, the enclosing window knows about updates such as described in the
108 Notification section higher. There are a few cases, however, where updates are
109 caused by actions known by a view instance. For example, clicking in a view may
110 update the current time; all viewers within the same window must be told about
111 the new current time to change the currently highlighted time point. A viewer
112 reports such events by calling lttvwindow_report_current_time on its lttvwindow.
113 The lttvwindow will consequently call current_time_notify for each of its
117 Available report methods are :
119 lttvwindow_report_status : reports the text of the status bar.
120 lttvwindow_report_time_window : reports the new time window.
121 lttvwindow_report_current_time : reports the new current time.
122 lttvwindow_report_dividor : reports the new horizontal dividor's position.
123 lttvwindow_report_focus : One on the widgets in the viewer has the keyboard's
128 Requesting Events to Main Window
130 Events can be requested by passing a EventsRequest structure to the main window.
131 They will be delivered later when the next g_idle functions will be called.
132 Event delivery is done by calling the event hook for this event ID, or the
133 main event hooks. A pointer to the EventsRequest structure is passed as
134 hook_data to the event hooks of the viewers.
136 EventsRequest consists in
137 - a pointer to the viewer specific data structure
138 - a start timestamp or position
139 - a stop_flag, ending the read process when set to TRUE
140 - a end timestamp and/or position and/or number of events to read
141 - hook lists to call for traceset/trace/tracefile begin and end, and for each
142 event (event hooks and event_by_id hooks).
144 The main window will deliver events for every EventRequests it has pending
145 through an algorithm that guarantee that all events requested, and only them,
146 will be delivered to the viewer between the call of the tracefile_begin hooks
147 and the call of the tracefile_end hooks.
149 If a viewer wants to stop the event request at a certain point inside the event
150 hooks, it has to set the stop_flag to TRUE and return TRUE from the hook
151 function. Then return value will stop the process traceset. Then, the main
152 window will look for the stop_flag and remove the EventRequests from its lists,
153 calling the process_traceset_end for this request (it removes hooks from the
154 context and calls the after hooks).
156 It no stop_flag is rose, the end timestamp, end position or number of events to
157 read has to be reached to determine the end of the request. Otherwise,
158 the end of traceset does determine it.
165 GTK is quite different from the other graphical toolkits around there. The main
166 difference resides in that there are many X Windows inside one GtkWindow,
167 instead of just one. That means that X events are delivered by the glib main
168 loop directly to the widget corresponding to the GdkWindow affected by the X
171 Event delivery to a widget emits a signal on that widget. Then, if a handler
172 is connected to this widget's signal, it will be executed. There are default
173 handlers for signals, connected at class instantiation time. There is also
174 the possibility to connect other handlers to these signals, which is what
175 should be done in most cases when a viewer needs to interact with X in any
180 Signal emission and propagation is described there :
182 http://www.gtk.org/tutorial/sec-signalemissionandpropagation.html
184 For further information on the GTK main loop (now a wrapper over glib main loop)
187 http://developer.gnome.org/doc/API/2.0/gtk/gtk-General.html
188 http://developer.gnome.org/doc/API/2.0/glib/glib-The-Main-Event-Loop.html
191 For documentation on event handling in GTK/GDK, see :
193 http://developer.gnome.org/doc/API/2.0/gdk/gdk-Events.html
194 http://developer.gnome.org/doc/API/2.0/gdk/gdk-Event-Structures.html
197 Signals can be connected to handlers, emitted, propagated, blocked,
200 http://developer.gnome.org/doc/API/2.0/gobject/gobject-Signals.html
207 Provides the exposed region in the GdkEventExpose structure.
209 There are two ways of dealing with exposures. The first one is to directly draw
210 on the screen and the second one is to draw in a pixmap buffer, and then to
211 update the screen when necessary.
213 In the first case, the expose event will be responsible for registering hooks to
214 process_traceset and require time intervals to the main window. So, in this
215 scenario, if a part of the screen is damaged, the trace has to be read to
218 In the second case, with a pixmap buffer, the expose handler is only responsible
219 of showing the pixmap buffer on the screen. If the pixmap buffer has never
220 been filled with a drawing, the expose handler may ask for it to be filled.
222 The interest of using events request to the main window instead of reading the
223 events directly from the trace comes from the fact that the main window
224 does merge requests from the different viewers in the same tab so that the
225 read loop and the state update is shared. As viewers will, in the common
226 scenario, request the same events, only one pass through the trace that will
227 call the right hooks for the right intervals will be done.
229 When the traceset read is over for a events request, the traceset_end hook is
230 called. It has the responsibility of finishing the drawing if some parts
231 still need to be drawn and to show it on the screen (if the viewer uses a pixmap
234 It can add dotted lines and such visual effects to enhance the user's
238 FIXME : explain other important events
246 * \brief API used by the graphical viewers to interact with their top window.
248 * Main window (lttvwindow module) is the place to contain and display viewers.
249 * Viewers (lttv plugins) interact with main window through this API.
250 * This header file should be included in each graphic module.
256 #include <ltt/time.h>
257 #include <lttv/hook.h>
258 #include <lttv/tracecontext.h>
259 #include <lttv/stats.h>
260 #include <lttvwindow/common.h>
261 //FIXME (not ready yet) #include <lttv/filter.h>
264 /* Module Related API */
267 /* constructor a the viewer */
268 //FIXME explain LttvTracesetSelector and key
269 typedef GtkWidget
* (*lttvwindow_viewer_constructor
)
270 (MainWindow
* main_window
, LttvTracesetSelector
* s
, char *key
);
274 * Function to register a view constructor so that main window can generate
275 * a toolbar item for the viewer in order to generate a new instance easily.
277 * It should be called by init function of the module.
279 * @param pixmap Image shown on the toolbar item.
280 * @param tooltip tooltip of the toolbar item.
281 * @param view_constructor constructor of the viewer.
284 void lttvwindow_register_toolbar
287 lttvwindow_viewer_constructor view_constructor
);
291 * Function to unregister the viewer's constructor, release the space
292 * occupied by pixmap, tooltip and constructor of the viewer.
294 * It will be called when a module is unloaded.
296 * @param view_constructor constructor of the viewer.
299 void lttvwindow_unregister_toolbar
300 (lttvwindow_viewer_constructor view_constructor
);
304 * Function to register a view constructor so that main window can generate
305 * a menu item for the viewer in order to generate a new instance easily.
307 * It will be called by init function of the module.
309 * @param menu_path path of the menu item.
310 * @param menu_text text of the menu item.
311 * @param view_constructor constructor of the viewer.
314 void lttvwindow_register_menu(char *menu_path
,
316 lttvwindow_viewer_constructor view_constructor
);
320 * Function to unregister the viewer's constructor, release the space
321 * occupied by menu_path, menu_text and constructor of the viewer.
323 * It will be called when a module is unloaded.
325 * @param view_constructor constructor of the viewer.
328 void lttvwindow_unregister_menu(lttvwindow_viewer_constructor view_constructor
);
332 /* Viewer Instance Related API */
335 * Structure used as hook_data for the time_window_notify hook.
337 typedef struct _TimeWindowNotifyData
{
338 TimeWindow
*new_time_window
;
339 TimeWindow
*old_time_window
;
340 } TimeWindowNotifyData
;
344 * Function to register a hook function that will be called by the main window
345 * when the time interval needs to be updated.
347 * This register function is typically called by the constructor of the viewer.
349 * @param main_win the main window the viewer belongs to.
350 * @param hook hook that sould be called by the main window when the time
351 * interval changes. This hook function takes a
352 * TimeWindowNotifyData* as call_data.
353 * @param hook_data hook data associated with the hook function. It will
354 * be typically a pointer to the viewer's data structure.
357 void lttvwindow_register_time_window_notify(MainWindow
*main_win
,
363 * Function to unregister the time_window notification hook.
365 * This unregister function is typically called by the destructor of the viewer.
367 * @param main_win the main window the viewer belongs to.
368 * @param hook hook that sould be called by the main window when the time
369 * interval changes. This hook function takes a
370 * TimeWindowNotifyData* as call_data.
371 * @param hook_data hook data associated with the hook function. It will
372 * be typically a pointer to the viewer's data structure.
375 void lttvwindow_unregister_time_window_notify(MainWindow
*main_win
,
381 * Function to register a hook function that will be called by the main window
382 * when the traceset is changed. That means that the viewer must redraw
383 * itself completely or check if it's affected by the particular change to the
386 * This register function is typically called by the constructor of the viewer.
388 * @param main_win the main window the viewer belongs to.
389 * @param hook hook that should be called whenever a change to the traceset
390 * occurs. The call_data of this hook is a NULL pointer.
391 * @param hook_data hook data associated with the hook function. It will
392 * be typically a pointer to the viewer's data structure.
395 void lttvwindow_register_traceset_notify(MainWindow
*main_win
,
401 * Function to unregister the traceset_notify hook.
403 * @param main_win the main window the viewer belongs to.
404 * @param hook hook that should be called whenever a change to the traceset
405 * occurs. The call_data of this hook is a NULL pointer.
406 * @param hook_data hook data associated with the hook function. It will
407 * be typically a pointer to the viewer's data structure.
410 void lttvwindow_unregister_traceset_notify(MainWindow
*main_win
,
416 * Function to register a hook function for a viewer to set/update its
419 * FIXME : Add information about what a filter is as seen from a viewer and how
422 * This register function is typically called by the constructor of the viewer.
424 * @param main_win the main window the viewer belongs to.
425 * @param hook hook function called by the main window when a filter change
427 * @param hook_data hook data associated with the hook function. It will
428 * be typically a pointer to the viewer's data structure.
431 void lttvwindow_register_filter_notify(MainWindow
*main_win
,
437 * Function to unregister a viewer's hook function which is used to
438 * set/update the filter of the viewer.
440 * This unregistration is called by the destructor of the viewer.
442 * @param main_win the main window the viewer belongs to.
443 * @param hook hook function called by the main window when a filter change
445 * @param hook_data hook data associated with the hook function. It will
446 * be typically a pointer to the viewer's data structure.
449 void lttvwindow_unregister_filter_notify(MainWindow
* main_win
,
455 * Function to register a hook function for a viewer to set/update its
458 * @param main_win the main window the viewer belongs to.
459 * @param hook hook function of the viewer that updates the current time. The
460 * call_data is a LttTime* representing the new current time.
461 * @param hook_data hook data associated with the hook function. It will
462 * be typically a pointer to the viewer's data structure.
465 void lttvwindow_register_current_time_notify(MainWindow
*main_win
,
471 * Function to unregister a viewer's hook function which is used to
472 * set/update the current time of the viewer.
473 * @param main_win the main window the viewer belongs to.
474 * @param hook hook function of the viewer that updates the current time. The
475 * call_data is a LttTime* representing the new current time.
476 * @param hook_data hook data associated with the hook function. It will
477 * be typically a pointer to the viewer's data structure.
480 void lttvwindow_unregister_current_time_notify(MainWindow
*main_win
,
486 * Function to register a hook function for a viewer to set/update the
487 * dividor of the hpane. It provides a way to make the horizontal
488 * dividors of all the viewers linked together.
490 * @param main_win the main window the viewer belongs to.
491 * @param hook hook function of the viewer that will be called whenever a
492 * dividor changes in another viewer. The call_data of this hook
493 * is a gint*. The value of the integer is the new position of the
495 * @param hook_data hook data associated with the hook function. It will
496 * be typically a pointer to the viewer's data structure.
499 void lttvwindow_register_dividor(MainWindow
*main_win
,
505 * Function to unregister a viewer's hook function which is used to
506 * set/update hpane's dividor of the viewer.
508 * @param main_win the main window the viewer belongs to.
509 * @param hook hook function of the viewer that will be called whenever a
510 * dividor changes in another viewer. The call_data of this hook
511 * is a gint*. The value of the integer is the new position of the
513 * @param hook_data hook data associated with the hook function. It will
514 * be typically a pointer to the viewer's data structure.
517 void lttvwindow_unregister_dividor(MainWindow
*main_win
,
524 * This method reports the information to show on the status bar in the
527 * @param main_win the main window the viewer belongs to.
528 * @param info the message which will be shown in the status bar.
531 void lttvwindow_report_status(MainWindow
*main_win
, const char *info
);
535 * Function to set the time interval of the current tab.a
537 * @param main_win the main window the viewer belongs to.
538 * @param time_interval pointer to the time interval value.
541 void lttvwindow_report_time_window(MainWindow
*main_win
,
542 const TimeWindow
*time_window
);
545 * Function to set the current time/event of the current tab.
546 * It will be called by a viewer's signal handle associated with
547 * the button-release-event signal
548 * @param main_win the main window the viewer belongs to.
549 * @param time a pointer where time is stored.
552 void lttvwindow_report_current_time(MainWindow
*main_win
,
553 const LttTime
*time
);
557 * Function to set the position of the hpane's dividor (viewer).
558 * It will typically be called by a viewer's signal handle associated
559 * with the motion_notify_event event/signal.
561 * @param main_win the main window the viewer belongs to.
562 * @param position position of the hpane's dividor.
565 void lttvwindow_report_dividor(MainWindow
*main_win
, gint position
);
568 * Function to set the focused viewer of the tab.
569 * It will be called by a viewer's signal handle associated with
570 * the grab_focus signal of all widgets in the viewer.
572 * @param main_win the main window the viewer belongs to.
573 * @param top_widget the top widget containing all the other widgets of the
576 void lttvwindow_report_focus(MainWindow
*main_win
,
577 GtkWidget
*top_widget
);
581 /* Structure sent to the time request hook */
582 /* Value considered as empty */
583 typedef struct _EventsRequest
{
584 LttTime start_time
, /* Unset : { 0, 0 } */
585 LttvTracesetContextPosition start_position
, /* Unset : num_traces = 0 */
586 gboolean stop_flag
, /* Continue:TRUE Stop:FALSE */
587 LttTime end_time
, /* Unset : { 0, 0 } */
588 guint num_events
, /* Unset : G_MAXUINT */
589 LttvTracesetContextPosition end_position
, /* Unset : num_traces = 0 */
590 LttvHooks
*before_traceset
, /* Unset : NULL */
591 LttvHooks
*before_trace
, /* Unset : NULL */
592 LttvHooks
*before_tracefile
, /* Unset : NULL */
593 LttvHooks
*event
, /* Unset : NULL */
594 LttvHooksById
*event_by_id
, /* Unset : NULL */
595 LttvHooks
*after_tracefile
, /* Unset : NULL */
596 LttvHooks
*after_trace
, /* Unset : NULL */
597 LttvHooks
*after_traceset
/* Unset : NULL */
602 * Function to request data in a specific time interval to the main window. The
603 * time request servicing is differed until the glib idle functions are
606 * The viewer has to provide hooks that should be associated with the event
609 * Either start time or start position must be defined in a EventRequest
610 * structure for it to be valid.
612 * end_time, end_position and num_events can all be defined. The first one
613 * to occur will be used as end criterion.
615 * @param main_win the main window the viewer belongs to.
616 * @param events_requested the structure of request from.
619 void lttvwindow_events_request(MainWindow
*main_win
,
620 EventsRequest events_request
);
623 * Function to get the current time window of the current tab.
625 * @param main_win the main window the viewer belongs to.
626 * @return a pointer to the current tab's time interval.
629 const TimeWindow
*lttvwindow_get_time_window(MainWindow
*main_win
);
633 * Function to get the current time of the current tab.
635 * @param main_win the main window the viewer belongs to.
636 * @return a pointer to the current tab's current time.
639 const LttTime
*lttvwindow_get_current_time(MainWindow
*main_win
);
643 * Function to get the filter of the current tab.
644 * @param main_win, the main window the viewer belongs to.
645 * @param filter, a pointer to a filter.
649 typedef void lttv_filter
;
651 const lttv_filter
*lttvwindow_get_filter(MainWindow
*main_win
);
655 * Function to get the stats of the traceset
656 * It must be non const so the viewer can modify it.
657 * FIXME : a set/get pair of functions would be more appropriate here.
658 * @param main_win the main window the viewer belongs to.
659 * @return A pointer to Traceset statistics.
662 LttvTracesetStats
* lttvwindow_get_traceset_stats(MainWindow
*main_win
);
665 * Function to get the context of the traceset
666 * It must be non const so the viewer can add and remove hooks from it.
667 * @param main_win the main window the viewer belongs to.
668 * @return Context of the current tab.
672 LttvTracesetContext
* lttvwindow_get_traceset_context(MainWindow
*main_win
);