1 /* This file is part of the Linux Trace Toolkit viewer
2 * Copyright (C) 2003-2004 XangXiu 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,
23 #include <limits.h> // for PATH_MAX
28 #include "callbacks.h"
29 #include "interface.h"
31 #include <ltt/trace.h>
32 #include <ltt/facility.h>
34 #include <ltt/event.h>
35 #include <lttv/lttv.h>
36 #include <lttv/module.h>
37 #include <lttv/iattribute.h>
38 #include <lttv/stats.h>
39 #include <lttvwindow/mainwindow.h>
40 #include <lttvwindow/mainwindow-private.h>
41 #include <lttvwindow/menu.h>
42 #include <lttvwindow/toolbar.h>
43 #include <lttvwindow/lttvwindow.h>
44 #include <lttvwindow/lttvwindowtraces.h>
45 #include <lttvwindow/gtkdirsel.h>
46 #include <lttvwindow/lttvfilter.h>
49 #define DEFAULT_TIME_WIDTH_S 1
51 extern LttvTrace
*g_init_trace
;
54 /** Array containing instanced objects. */
55 extern GSList
* g_main_window_list
;
57 /** MD : keep old directory. */
58 static char remember_plugins_dir
[PATH_MAX
] = "";
59 static char remember_trace_dir
[PATH_MAX
] = "";
62 MainWindow
* get_window_data_struct(GtkWidget
* widget
);
63 char * get_load_module(char ** load_module_name
, int nb_module
);
64 char * get_unload_module(char ** loaded_module_name
, int nb_module
);
65 char * get_remove_trace(char ** all_trace_name
, int nb_trace
);
66 char * get_selection(char ** all_name
, int nb
, char *title
, char * column_title
);
67 gboolean
get_filter_selection(LttvTracesetSelector
*s
, char *title
, char * column_title
);
68 Tab
* create_tab(MainWindow
* mw
, Tab
*copy_tab
,
69 GtkNotebook
* notebook
, char * label
);
71 static void insert_viewer(GtkWidget
* widget
, lttvwindow_viewer_constructor constructor
);
72 void update_filter(LttvTracesetSelector
*s
, GtkTreeStore
*store
);
74 void checkbox_changed(GtkTreeView
*treeview
,
76 GtkTreeViewColumn
*arg2
,
78 void remove_trace_from_traceset_selector(GtkWidget
* paned
, unsigned i
);
79 void add_trace_into_traceset_selector(GtkWidget
* paned
, LttTrace
* trace
);
80 Tab
*create_new_tab(GtkWidget
* widget
, gpointer user_data
);
82 LttvTracesetSelector
* construct_traceset_selector(LttvTraceset
* traceset
);
84 static gboolean
lttvwindow_process_pending_requests(Tab
*tab
);
98 /* Construct a selector(filter), which will be associated with a viewer,
99 * and provides an interface for user to select interested events and traces
102 LttvTracesetSelector
* construct_traceset_selector(LttvTraceset
* traceset
)
104 LttvTracesetSelector
* s
;
105 LttvTraceSelector
* trace
;
106 LttvTracefileSelector
* tracefile
;
107 LttvEventtypeSelector
* eventtype
;
109 int nb_trace
, nb_tracefile
, nb_control
, nb_per_cpu
, nb_facility
, nb_event
;
116 s
= lttv_traceset_selector_new(lttv_traceset_name(traceset
));
117 nb_trace
= lttv_traceset_number(traceset
);
118 for(i
=0;i
<nb_trace
;i
++){
119 trace_v
= lttv_traceset_get(traceset
, i
);
120 t
= lttv_trace(trace_v
);
121 trace
= lttv_trace_selector_new(t
);
122 lttv_traceset_selector_trace_add(s
, trace
);
124 nb_facility
= ltt_trace_facility_number(t
);
125 for(k
=0;k
<nb_facility
;k
++){
126 fac
= ltt_trace_facility_get(t
,k
);
127 nb_event
= (int) ltt_facility_eventtype_number(fac
);
128 for(m
=0;m
<nb_event
;m
++){
129 et
= ltt_facility_eventtype_get(fac
,m
);
130 eventtype
= lttv_eventtype_selector_new(et
);
131 lttv_trace_selector_eventtype_add(trace
, eventtype
);
135 nb_control
= ltt_trace_control_tracefile_number(t
);
136 nb_per_cpu
= ltt_trace_per_cpu_tracefile_number(t
);
137 nb_tracefile
= nb_control
+ nb_per_cpu
;
139 for(j
= 0 ; j
< nb_tracefile
; j
++) {
141 tf
= ltt_trace_control_tracefile_get(t
, j
);
143 tf
= ltt_trace_per_cpu_tracefile_get(t
, j
- nb_control
);
144 tracefile
= lttv_tracefile_selector_new(tf
);
145 lttv_trace_selector_tracefile_add(trace
, tracefile
);
146 lttv_eventtype_selector_copy(trace
, tracefile
);
153 static gboolean
viewer_grab_focus(GtkWidget
*widget
, GdkEventButton
*event
,
156 GtkWidget
*viewer_container
= GTK_WIDGET(data
);
158 g_debug("FOCUS GRABBED");
159 g_object_set_data(G_OBJECT(viewer_container
), "focused_viewer", widget
);
163 /* insert_viewer function constructs an instance of a viewer first,
164 * then inserts the widget of the instance into the container of the
169 insert_viewer_wrap(GtkWidget
*menuitem
, gpointer user_data
)
173 insert_viewer((GtkWidget
*)menuitem
, (lttvwindow_viewer_constructor
)user_data
);
174 // selected_hook(&val);
178 /* internal functions */
179 void insert_viewer(GtkWidget
* widget
, lttvwindow_viewer_constructor constructor
)
181 GtkWidget
* viewer_container
;
182 MainWindow
* mw_data
= get_window_data_struct(widget
);
183 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
185 LttvTracesetSelector
* s
;
186 TimeInterval
* time_interval
;
187 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
188 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
192 tab
= create_new_tab(widget
, NULL
);
194 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
197 viewer_container
= tab
->viewer_container
;
199 s
= construct_traceset_selector(tab
->traceset_info
->traceset
);
200 viewer
= (GtkWidget
*)constructor(tab
, s
, "Traceset_Selector");
203 //gtk_multivpaned_widget_add(GTK_MULTIVPANED(multivpaned), viewer);
205 gtk_box_pack_end(GTK_BOX(viewer_container
),
211 g_signal_connect (G_OBJECT(viewer
),
212 "button-press-event",
213 G_CALLBACK (viewer_grab_focus
),
214 (gpointer
)viewer_container
);
216 // We unref here, because it is now referenced by the viewer_container!
217 // not for a box ... g_object_unref(G_OBJECT(viewer));
219 // The viewer will show itself when it receives a show notify
220 // So we call the show notify hooks here. It will
221 // typically add hooks for reading, we call process trace, and the
222 // end of reading hook will call gtk_widget_show and unregister the
224 // Note that show notify gets the time_requested through the call_data.
225 //show_viewer(mw_data);
226 // in expose now call_pending_read_hooks(mw_data);
231 * Function to set/update traceset for the viewers
232 * @param tab viewer's tab
233 * @param traceset traceset of the main window.
235 * 0 : traceset updated
236 * 1 : no traceset hooks to update; not an error.
239 int SetTraceset(Tab
* tab
, LttvTraceset
*traceset
)
242 LttvAttributeValue value
;
246 g_assert( lttv_iattribute_find_by_path(tab
->attributes
,
247 "hooks/updatetraceset", LTTV_POINTER
, &value
));
249 tmp
= (LttvHooks
*)*(value
.v_pointer
);
250 if(tmp
== NULL
) retval
= 1;
251 else lttv_hooks_call(tmp
,traceset
);
255 LttvTracesetContext
*tsc
=
256 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
257 TimeInterval time_span
= tsc
->time_span
;
258 GtkAdjustment
*adjustment
= gtk_range_get_adjustment(GTK_RANGE(tab
->scrollbar
));
260 g_object_set(G_OBJECT(adjustment
),
262 ltt_time_to_double(time_span
.start_time
)
263 * NANOSECONDS_PER_SECOND
, /* lower */
265 ltt_time_to_double(time_span
.end_time
)
266 * NANOSECONDS_PER_SECOND
, /* upper */
268 ltt_time_to_double(tab
->time_window
.time_width
)
269 / SCROLL_STEP_PER_PAGE
270 * NANOSECONDS_PER_SECOND
, /* step increment */
272 ltt_time_to_double(tab
->time_window
.time_width
)
273 * NANOSECONDS_PER_SECOND
, /* page increment */
275 ltt_time_to_double(tab
->time_window
.time_width
)
276 * NANOSECONDS_PER_SECOND
, /* page size */
278 gtk_adjustment_changed(adjustment
);
280 g_object_set(G_OBJECT(adjustment
),
282 ltt_time_to_double(tab
->time_window
.start_time
)
283 * NANOSECONDS_PER_SECOND
, /* value */
285 gtk_adjustment_value_changed(adjustment
);
291 * Function to set/update filter for the viewers
292 * @param tab viewer's tab
293 * @param filter filter of the main window.
296 * 0 : filters updated
297 * 1 : no filter hooks to update; not an error.
300 int SetFilter(Tab
* tab
, gpointer filter
)
303 LttvAttributeValue value
;
305 g_assert(lttv_iattribute_find_by_path(tab
->attributes
,
306 "hooks/updatefilter", LTTV_POINTER
, &value
));
308 tmp
= (LttvHooks
*)*(value
.v_pointer
);
310 if(tmp
== NULL
) return 1;
311 lttv_hooks_call(tmp
,filter
);
319 * Function to redraw each viewer belonging to the current tab
320 * @param tab viewer's tab
323 void update_traceset(Tab
*tab
)
325 LttvAttributeValue value
;
327 g_assert(lttv_iattribute_find_by_path(tab
->attributes
,
328 "hooks/updatetraceset", LTTV_POINTER
, &value
));
329 tmp
= (LttvHooks
*)*(value
.v_pointer
);
330 if(tmp
== NULL
) return;
331 lttv_hooks_call(tmp
, NULL
);
335 /* get_label function is used to get user input, it displays an input
336 * box, which allows user to input a string
339 void get_label_string (GtkWidget
* text
, gchar
* label
)
341 GtkEntry
* entry
= (GtkEntry
*)text
;
342 if(strlen(gtk_entry_get_text(entry
))!=0)
343 strcpy(label
,gtk_entry_get_text(entry
));
346 gboolean
get_label(MainWindow
* mw
, gchar
* str
, gchar
* dialogue_title
, gchar
* label_str
)
348 GtkWidget
* dialogue
;
353 dialogue
= gtk_dialog_new_with_buttons(dialogue_title
,NULL
,
355 GTK_STOCK_OK
,GTK_RESPONSE_ACCEPT
,
356 GTK_STOCK_CANCEL
,GTK_RESPONSE_REJECT
,
359 label
= gtk_label_new(label_str
);
360 gtk_widget_show(label
);
362 text
= gtk_entry_new();
363 gtk_widget_show(text
);
365 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), label
,TRUE
, TRUE
,0);
366 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), text
,FALSE
, FALSE
,0);
368 id
= gtk_dialog_run(GTK_DIALOG(dialogue
));
370 case GTK_RESPONSE_ACCEPT
:
371 get_label_string(text
,str
);
372 gtk_widget_destroy(dialogue
);
374 case GTK_RESPONSE_REJECT
:
376 gtk_widget_destroy(dialogue
);
383 /* get_window_data_struct function is actually a lookup function,
384 * given a widget which is in the tree of the main window, it will
385 * return the MainWindow data structure associated with main window
388 MainWindow
* get_window_data_struct(GtkWidget
* widget
)
391 MainWindow
* mw_data
;
393 mw
= lookup_widget(widget
, "MWindow");
395 g_printf("Main window does not exist\n");
399 mw_data
= (MainWindow
*) g_object_get_data(G_OBJECT(mw
),"main_window_data");
401 g_printf("Main window data does not exist\n");
408 /* create_new_window function, just constructs a new main window
411 void create_new_window(GtkWidget
* widget
, gpointer user_data
, gboolean clone
)
413 MainWindow
* parent
= get_window_data_struct(widget
);
416 g_printf("Clone : use the same traceset\n");
417 construct_main_window(parent
);
419 g_printf("Empty : traceset is set to NULL\n");
420 construct_main_window(NULL
);
424 GtkWidget
*viewer_container_focus(GtkWidget
*container
)
428 widget
= (GtkWidget
*)g_object_get_data(G_OBJECT(container
),
431 if(widget
== NULL
) g_debug("no widget focused");
437 gint
viewer_container_position(GtkWidget
*container
, GtkWidget
*child
)
440 if(child
== NULL
) return -1;
443 GValue value
= { 0, };
444 g_value_init(&value
, G_TYPE_INT
);
445 gtk_container_child_get_property(GTK_CONTAINER(container
),
449 pos
= g_value_get_int(&value
);
455 /* move_*_viewer functions move the selected view up/down in
459 void move_down_viewer(GtkWidget
* widget
, gpointer user_data
)
461 MainWindow
* mw
= get_window_data_struct(widget
);
462 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
464 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
465 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
471 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
474 //gtk_multivpaned_widget_move_up(GTK_MULTIVPANED(tab->multivpaned));
476 /* change the position in the vbox */
477 GtkWidget
*focus_widget
;
479 focus_widget
= viewer_container_focus(tab
->viewer_container
);
480 position
= viewer_container_position(tab
->viewer_container
, focus_widget
);
483 /* can move up one position */
484 gtk_box_reorder_child(GTK_BOX(tab
->viewer_container
),
491 void move_up_viewer(GtkWidget
* widget
, gpointer user_data
)
493 MainWindow
* mw
= get_window_data_struct(widget
);
494 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
496 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
497 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
503 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
506 //gtk_multivpaned_widget_move_down(GTK_MULTIVPANED(tab->multivpaned));
507 /* change the position in the vbox */
508 GtkWidget
*focus_widget
;
510 focus_widget
= viewer_container_focus(tab
->viewer_container
);
511 position
= viewer_container_position(tab
->viewer_container
, focus_widget
);
515 g_list_length(gtk_container_get_children(
516 GTK_CONTAINER(tab
->viewer_container
)))-1
518 /* can move down one position */
519 gtk_box_reorder_child(GTK_BOX(tab
->viewer_container
),
527 /* delete_viewer deletes the selected viewer in the current tab
530 void delete_viewer(GtkWidget
* widget
, gpointer user_data
)
532 MainWindow
* mw
= get_window_data_struct(widget
);
533 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
535 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
536 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
542 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
545 //gtk_multivpaned_widget_delete(GTK_MULTIVPANED(tab->multivpaned));
547 GtkWidget
*focus_widget
= viewer_container_focus(tab
->viewer_container
);
549 if(focus_widget
!= NULL
)
550 gtk_widget_destroy(focus_widget
);
552 g_object_set_data(G_OBJECT(tab
->viewer_container
), "focused_viewer", NULL
);
556 /* open_traceset will open a traceset saved in a file
557 * Right now, it is not finished yet, (not working)
561 void open_traceset(GtkWidget
* widget
, gpointer user_data
)
565 LttvTraceset
* traceset
;
566 MainWindow
* mw_data
= get_window_data_struct(widget
);
567 GtkFileSelection
* file_selector
=
568 (GtkFileSelection
*)gtk_file_selection_new("Select a traceset");
570 gtk_file_selection_hide_fileop_buttons(file_selector
);
572 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
574 case GTK_RESPONSE_ACCEPT
:
575 case GTK_RESPONSE_OK
:
576 dir
= gtk_file_selection_get_selections (file_selector
);
577 traceset
= lttv_traceset_load(dir
[0]);
578 g_printf("Open a trace set %s\n", dir
[0]);
581 case GTK_RESPONSE_REJECT
:
582 case GTK_RESPONSE_CANCEL
:
584 gtk_widget_destroy((GtkWidget
*)file_selector
);
590 static void events_request_free(EventsRequest
*events_request
)
592 if(events_request
== NULL
) return;
594 if(events_request
->start_position
!= NULL
)
595 lttv_traceset_context_position_destroy(events_request
->start_position
);
596 if(events_request
->end_position
!= NULL
)
597 lttv_traceset_context_position_destroy(events_request
->end_position
);
598 if(events_request
->before_chunk_traceset
!= NULL
)
599 lttv_hooks_destroy(events_request
->before_chunk_traceset
);
600 if(events_request
->before_chunk_trace
!= NULL
)
601 lttv_hooks_destroy(events_request
->before_chunk_trace
);
602 if(events_request
->before_chunk_tracefile
!= NULL
)
603 lttv_hooks_destroy(events_request
->before_chunk_tracefile
);
604 if(events_request
->event
!= NULL
)
605 lttv_hooks_destroy(events_request
->event
);
606 if(events_request
->event_by_id
!= NULL
)
607 lttv_hooks_by_id_destroy(events_request
->event_by_id
);
608 if(events_request
->after_chunk_tracefile
!= NULL
)
609 lttv_hooks_destroy(events_request
->after_chunk_tracefile
);
610 if(events_request
->after_chunk_trace
!= NULL
)
611 lttv_hooks_destroy(events_request
->after_chunk_trace
);
612 if(events_request
->after_chunk_traceset
!= NULL
)
613 lttv_hooks_destroy(events_request
->after_chunk_traceset
);
614 if(events_request
->before_request
!= NULL
)
615 lttv_hooks_destroy(events_request
->before_request
);
616 if(events_request
->after_request
!= NULL
)
617 lttv_hooks_destroy(events_request
->after_request
);
619 g_free(events_request
);
624 /* lttvwindow_process_pending_requests
626 * This internal function gets called by g_idle, taking care of the pending
627 * requests. It is responsible for concatenation of time intervals and position
628 * requests. It does it with the following algorithm organizing process traceset
629 * calls. Here is the detailed description of the way it works :
631 * - Events Requests Servicing Algorithm
633 * Data structures necessary :
635 * List of requests added to context : list_in
636 * List of requests not added to context : list_out
641 * list_out : many events requests
643 * FIXME : insert rest of algorithm here
647 #define list_out tab->events_requests
649 gboolean
lttvwindow_process_pending_requests(Tab
*tab
)
651 unsigned max_nb_events
;
655 LttvTracesetContext
*tsc
;
656 LttvTracefileContext
*tfc
;
657 GSList
*list_in
= NULL
;
661 LttvTracesetContextPosition
*end_position
;
664 g_critical("Foreground processing : tab does not exist. Processing removed.");
668 /* There is no events requests pending : we should never have been called! */
669 g_assert(g_slist_length(list_out
) != 0);
671 tsc
= LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
673 //set the cursor to be X shape, indicating that the computer is busy in doing its job
675 new = gdk_cursor_new(GDK_X_CURSOR
);
676 widget
= lookup_widget(tab
->mw
->mwindow
, "MToolbar1");
677 win
= gtk_widget_get_parent_window(widget
);
678 gdk_window_set_cursor(win
, new);
679 gdk_cursor_unref(new);
680 gdk_window_stick(win
);
681 gdk_window_unstick(win
);
684 g_debug("SIZE events req len : %d", g_slist_length(list_out
));
686 /* Preliminary check for no trace in traceset */
687 /* Unregister the routine if empty, empty list_out too */
688 if(lttv_traceset_number(tsc
->ts
) == 0) {
690 /* - For each req in list_out */
691 GSList
*iter
= list_out
;
693 while(iter
!= NULL
) {
695 gboolean remove
= FALSE
;
696 gboolean free_data
= FALSE
;
697 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
699 /* - Call end request for req */
700 if(events_request
->servicing
== TRUE
)
701 lttv_hooks_call(events_request
->after_request
, (gpointer
)tsc
);
703 /* - remove req from list_out */
704 /* Destroy the request */
711 GSList
*remove_iter
= iter
;
713 iter
= g_slist_next(iter
);
714 if(free_data
) events_request_free((EventsRequest
*)remove_iter
->data
);
715 list_out
= g_slist_remove_link(list_out
, remove_iter
);
716 } else { // not remove
717 iter
= g_slist_next(iter
);
722 /* 0.1 Lock Traces */
727 iter_trace
<lttv_traceset_number(tsc
->ts
);
729 LttvTrace
*trace_v
= lttv_traceset_get(tsc
->ts
, iter_trace
);
731 if(lttvwindowtraces_lock(trace_v
) != 0) {
732 g_critical("Foreground processing : Unable to get trace lock");
733 return TRUE
; /* Cannot get lock, try later */
738 /* 0.2 Seek tracefiles positions to context position */
739 lttv_process_traceset_synchronize_tracefiles(tsc
);
742 /* Events processing algorithm implementation */
743 /* Warning : the gtk_events_pending takes a LOT of cpu time. So what we do
744 * instead is to leave the control to GTK and take it back.
746 /* A. Servicing loop */
747 //while( (g_slist_length(list_in) != 0 || g_slist_length(list_out) != 0)) {
748 if((g_slist_length(list_in
) != 0 || g_slist_length(list_out
) != 0)) {
750 /* 1. If list_in is empty (need a seek) */
751 if( g_slist_length(list_in
) == 0 ) {
753 /* list in is empty, need a seek */
755 /* 1.1 Add requests to list_in */
756 GSList
*ltime
= NULL
;
760 /* 1.1.1 Find all time requests with the lowest start time in list_out
763 if(g_slist_length(list_out
) > 0)
764 ltime
= g_slist_append(ltime
, g_slist_nth_data(list_out
, 0));
765 for(iter
=g_slist_nth(list_out
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
766 /* Find all time requests with the lowest start time in list_out */
767 guint index_ltime
= g_array_index(ltime
, guint
, 0);
768 EventsRequest
*event_request_ltime
= (EventsRequest
*)g_slist_nth_data(ltime
, 0);
769 EventsRequest
*event_request_list_out
= (EventsRequest
*)iter
->data
;
772 comp
= ltt_time_compare(event_request_ltime
->start_time
,
773 event_request_list_out
->start_time
);
775 ltime
= g_slist_append(ltime
, event_request_list_out
);
777 /* Remove all elements from ltime, and add current */
779 ltime
= g_slist_delete_link(ltime
, g_slist_nth(ltime
, 0));
780 ltime
= g_slist_append(ltime
, event_request_list_out
);
784 /* 1.1.2 Find all position requests with the lowest position in list_out
787 if(g_slist_length(list_out
) > 0)
788 lpos
= g_slist_append(lpos
, g_slist_nth_data(list_out
, 0));
789 for(iter
=g_slist_nth(list_out
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
790 /* Find all position requests with the lowest position in list_out */
791 EventsRequest
*event_request_lpos
= (EventsRequest
*)g_slist_nth_data(lpos
, 0);
792 EventsRequest
*event_request_list_out
= (EventsRequest
*)iter
->data
;
795 if(event_request_lpos
->start_position
!= NULL
796 && event_request_list_out
->start_position
!= NULL
)
798 comp
= lttv_traceset_context_pos_pos_compare
799 (event_request_lpos
->start_position
,
800 event_request_list_out
->start_position
);
805 lpos
= g_slist_append(lpos
, event_request_list_out
);
807 /* Remove all elements from lpos, and add current */
809 lpos
= g_slist_delete_link(lpos
, g_slist_nth(lpos
, 0));
810 lpos
= g_slist_append(lpos
, event_request_list_out
);
815 EventsRequest
*event_request_lpos
= (EventsRequest
*)g_slist_nth_data(lpos
, 0);
816 EventsRequest
*event_request_ltime
= (EventsRequest
*)g_slist_nth_data(ltime
, 0);
817 LttTime lpos_start_time
;
819 if(event_request_lpos
!= NULL
820 && event_request_lpos
->start_position
!= NULL
) {
821 lpos_start_time
= lttv_traceset_context_position_get_time(
822 event_request_lpos
->start_position
);
825 /* 1.1.3 If lpos.start time < ltime */
826 if(event_request_lpos
!= NULL
827 && event_request_lpos
->start_position
!= NULL
828 && ltt_time_compare(lpos_start_time
,
829 event_request_ltime
->start_time
)<0) {
830 /* Add lpos to list_in, remove them from list_out */
831 for(iter
=lpos
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
833 EventsRequest
*event_request_lpos
=
834 (EventsRequest
*)iter
->data
;
836 list_in
= g_slist_append(list_in
, event_request_lpos
);
837 /* Remove from list_out */
838 list_out
= g_slist_remove(list_out
, event_request_lpos
);
841 /* 1.1.4 (lpos.start time >= ltime) */
842 /* Add ltime to list_in, remove them from list_out */
844 for(iter
=ltime
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
846 EventsRequest
*event_request_ltime
=
847 (EventsRequest
*)iter
->data
;
849 list_in
= g_slist_append(list_in
, event_request_ltime
);
850 /* Remove from list_out */
851 list_out
= g_slist_remove(list_out
, event_request_ltime
);
861 tfc
= lttv_traceset_context_get_current_tfc(tsc
);
862 g_assert(g_slist_length(list_in
)>0);
863 EventsRequest
*events_request
= g_slist_nth_data(list_in
, 0);
866 /* 1.2.1 If first request in list_in is a time request */
867 if(events_request
->start_position
== NULL
) {
868 /* - If first req in list_in start time != current time */
869 if(tfc
== NULL
|| ltt_time_compare(events_request
->start_time
,
870 tfc
->timestamp
) != 0)
871 /* - Seek to that time */
872 g_debug("SEEK TIME : %lu, %lu", events_request
->start_time
.tv_sec
,
873 events_request
->start_time
.tv_nsec
);
874 //lttv_process_traceset_seek_time(tsc, events_request->start_time);
875 lttv_state_traceset_seek_time_closest(LTTV_TRACESET_STATE(tsc
),
876 events_request
->start_time
);
878 /* Process the traceset with only state hooks */
880 lttv_process_traceset_middle(tsc
,
881 events_request
->start_time
,
887 /* Else, the first request in list_in is a position request */
888 /* If first req in list_in pos != current pos */
889 g_assert(events_request
->start_position
!= NULL
);
890 g_debug("SEEK POS time : %lu, %lu",
891 lttv_traceset_context_position_get_time(
892 events_request
->start_position
).tv_sec
,
893 lttv_traceset_context_position_get_time(
894 events_request
->start_position
).tv_nsec
);
896 g_debug("SEEK POS context time : %lu, %lu",
897 lttv_traceset_context_get_current_tfc(tsc
)->timestamp
.tv_sec
,
898 lttv_traceset_context_get_current_tfc(tsc
)->timestamp
.tv_nsec
);
899 g_assert(events_request
->start_position
!= NULL
);
900 if(lttv_traceset_context_ctx_pos_compare(tsc
,
901 events_request
->start_position
) != 0) {
902 /* 1.2.2.1 Seek to that position */
903 g_debug("SEEK POSITION");
904 //lttv_process_traceset_seek_position(tsc, events_request->start_position);
905 pos_time
= lttv_traceset_context_position_get_time(
906 events_request
->start_position
);
908 lttv_state_traceset_seek_time_closest(LTTV_TRACESET_STATE(tsc
),
911 /* Process the traceset with only state hooks */
913 lttv_process_traceset_middle(tsc
,
916 events_request
->start_position
);
917 g_assert(lttv_traceset_context_ctx_pos_compare(tsc
,
918 events_request
->start_position
) == 0);
925 /* 1.3 Add hooks and call before request for all list_in members */
929 for(iter
=list_in
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
930 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
931 /* 1.3.1 If !servicing */
932 if(events_request
->servicing
== FALSE
) {
933 /* - begin request hooks called
936 lttv_hooks_call(events_request
->before_request
, (gpointer
)tsc
);
937 events_request
->servicing
= TRUE
;
939 /* 1.3.2 call before chunk
940 * 1.3.3 events hooks added
942 lttv_process_traceset_begin(tsc
, events_request
->before_chunk_traceset
,
943 events_request
->before_chunk_trace
,
944 events_request
->before_chunk_tracefile
,
945 events_request
->event
,
946 events_request
->event_by_id
);
950 /* 2. Else, list_in is not empty, we continue a read */
953 /* 2.0 For each req of list_in */
954 GSList
*iter
= list_in
;
956 while(iter
!= NULL
) {
958 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
960 /* - Call before chunk
961 * - events hooks added
963 lttv_process_traceset_begin(tsc
, events_request
->before_chunk_traceset
,
964 events_request
->before_chunk_trace
,
965 events_request
->before_chunk_tracefile
,
966 events_request
->event
,
967 events_request
->event_by_id
);
969 iter
= g_slist_next(iter
);
974 tfc
= lttv_traceset_context_get_current_tfc(tsc
);
976 /* 2.1 For each req of list_out */
977 GSList
*iter
= list_out
;
979 while(iter
!= NULL
) {
981 gboolean remove
= FALSE
;
982 gboolean free_data
= FALSE
;
983 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
985 /* if req.start time == current context time
986 * or req.start position == current position*/
987 if( ltt_time_compare(events_request
->start_time
,
990 (events_request
->start_position
!= NULL
992 lttv_traceset_context_ctx_pos_compare(tsc
,
993 events_request
->start_position
) == 0)
995 /* - Add to list_in, remove from list_out */
996 list_in
= g_slist_append(list_in
, events_request
);
1000 /* - If !servicing */
1001 if(events_request
->servicing
== FALSE
) {
1002 /* - begin request hooks called
1003 * - servicing = TRUE
1005 lttv_hooks_call(events_request
->before_request
, (gpointer
)tsc
);
1006 events_request
->servicing
= TRUE
;
1008 /* call before chunk
1009 * events hooks added
1011 lttv_process_traceset_begin(tsc
, events_request
->before_chunk_traceset
,
1012 events_request
->before_chunk_trace
,
1013 events_request
->before_chunk_tracefile
,
1014 events_request
->event
,
1015 events_request
->event_by_id
);
1021 GSList
*remove_iter
= iter
;
1023 iter
= g_slist_next(iter
);
1024 if(free_data
) events_request_free((EventsRequest
*)remove_iter
->data
);
1025 list_out
= g_slist_remove_link(list_out
, remove_iter
);
1026 } else { // not remove
1027 iter
= g_slist_next(iter
);
1033 /* 3. Find end criterions */
1038 /* 3.1.1 Find lowest end time in list_in */
1039 g_assert(g_slist_length(list_in
)>0);
1040 end_time
= ((EventsRequest
*)g_slist_nth_data(list_in
,0))->end_time
;
1042 for(iter
=g_slist_nth(list_in
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
1043 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1045 if(ltt_time_compare(events_request
->end_time
,
1047 end_time
= events_request
->end_time
;
1050 /* 3.1.2 Find lowest start time in list_out */
1051 for(iter
=list_out
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
1052 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1054 if(ltt_time_compare(events_request
->start_time
,
1056 end_time
= events_request
->start_time
;
1061 /* 3.2 Number of events */
1063 /* 3.2.1 Find lowest number of events in list_in */
1066 end_nb_events
= ((EventsRequest
*)g_slist_nth_data(list_in
,0))->num_events
;
1068 for(iter
=g_slist_nth(list_in
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
1069 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1071 if(events_request
->num_events
< end_nb_events
)
1072 end_nb_events
= events_request
->num_events
;
1075 /* 3.2.2 Use min(CHUNK_NUM_EVENTS, min num events in list_in) as
1078 end_nb_events
= MIN(CHUNK_NUM_EVENTS
, end_nb_events
);
1082 /* 3.3 End position */
1084 /* 3.3.1 Find lowest end position in list_in */
1087 end_position
=((EventsRequest
*)g_slist_nth_data(list_in
,0))->end_position
;
1089 for(iter
=g_slist_nth(list_in
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
1090 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1092 if(events_request
->end_position
!= NULL
&& end_position
!= NULL
&&
1093 lttv_traceset_context_pos_pos_compare(events_request
->end_position
,
1095 end_position
= events_request
->end_position
;
1100 /* 3.3.2 Find lowest start position in list_out */
1103 for(iter
=list_out
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
1104 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1106 if(events_request
->end_position
!= NULL
&& end_position
!= NULL
&&
1107 lttv_traceset_context_pos_pos_compare(events_request
->end_position
,
1109 end_position
= events_request
->end_position
;
1114 /* 4. Call process traceset middle */
1115 g_debug("Calling process traceset middle with %p, %lu sec %lu nsec, %lu nb ev, %p end pos", tsc
, end_time
.tv_sec
, end_time
.tv_nsec
, end_nb_events
, end_position
);
1116 count
= lttv_process_traceset_middle(tsc
, end_time
, end_nb_events
, end_position
);
1118 tfc
= lttv_traceset_context_get_current_tfc(tsc
);
1120 g_debug("Context time after middle : %lu, %lu", tfc
->timestamp
.tv_sec
,
1121 tfc
->timestamp
.tv_nsec
);
1123 g_debug("End of trace reached after middle.");
1127 /* 5. After process traceset middle */
1128 tfc
= lttv_traceset_context_get_current_tfc(tsc
);
1130 /* - if current context time > traceset.end time */
1131 if(tfc
== NULL
|| ltt_time_compare(tfc
->timestamp
,
1132 tsc
->time_span
.end_time
) > 0) {
1133 /* - For each req in list_in */
1134 GSList
*iter
= list_in
;
1136 while(iter
!= NULL
) {
1138 gboolean remove
= FALSE
;
1139 gboolean free_data
= FALSE
;
1140 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1142 /* - Remove events hooks for req
1143 * - Call end chunk for req
1145 lttv_process_traceset_end(tsc
, events_request
->after_chunk_traceset
,
1146 events_request
->after_chunk_trace
,
1147 events_request
->after_chunk_tracefile
,
1148 events_request
->event
,
1149 events_request
->event_by_id
);
1150 /* - Call end request for req */
1151 lttv_hooks_call(events_request
->after_request
, (gpointer
)tsc
);
1153 /* - remove req from list_in */
1154 /* Destroy the request */
1161 GSList
*remove_iter
= iter
;
1163 iter
= g_slist_next(iter
);
1164 if(free_data
) events_request_free((EventsRequest
*)remove_iter
->data
);
1165 list_in
= g_slist_remove_link(list_in
, remove_iter
);
1166 } else { // not remove
1167 iter
= g_slist_next(iter
);
1172 /* 5.1 For each req in list_in */
1173 GSList
*iter
= list_in
;
1175 while(iter
!= NULL
) {
1177 gboolean remove
= FALSE
;
1178 gboolean free_data
= FALSE
;
1179 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1181 /* - Remove events hooks for req
1182 * - Call end chunk for req
1184 lttv_process_traceset_end(tsc
, events_request
->after_chunk_traceset
,
1185 events_request
->after_chunk_trace
,
1186 events_request
->after_chunk_tracefile
,
1187 events_request
->event
,
1188 events_request
->event_by_id
);
1190 /* - req.num -= count */
1191 g_assert(events_request
->num_events
>= count
);
1192 events_request
->num_events
-= count
;
1194 g_assert(tfc
!= NULL
);
1195 /* - if req.num == 0
1197 * current context time >= req.end time
1199 * req.end pos == current pos
1201 * req.stop_flag == TRUE
1203 if( events_request
->num_events
== 0
1205 events_request
->stop_flag
== TRUE
1207 ltt_time_compare(tfc
->timestamp
,
1208 events_request
->end_time
) >= 0
1210 (events_request
->end_position
!= NULL
1212 lttv_traceset_context_ctx_pos_compare(tsc
,
1213 events_request
->end_position
) == 0)
1216 g_assert(events_request
->servicing
== TRUE
);
1217 /* - Call end request for req
1218 * - remove req from list_in */
1219 lttv_hooks_call(events_request
->after_request
, (gpointer
)tsc
);
1220 /* - remove req from list_in */
1221 /* Destroy the request */
1229 GSList
*remove_iter
= iter
;
1231 iter
= g_slist_next(iter
);
1232 if(free_data
) events_request_free((EventsRequest
*)remove_iter
->data
);
1233 list_in
= g_slist_remove_link(list_in
, remove_iter
);
1234 } else { // not remove
1235 iter
= g_slist_next(iter
);
1241 /* End of removed servicing loop : leave control to GTK instead. */
1242 // if(gtk_events_pending()) break;
1245 /* B. When interrupted between chunks */
1248 GSList
*iter
= list_in
;
1250 /* 1. for each request in list_in */
1251 while(iter
!= NULL
) {
1253 gboolean remove
= FALSE
;
1254 gboolean free_data
= FALSE
;
1255 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1257 /* 1.1. Use current postition as start position */
1258 if(events_request
->start_position
!= NULL
)
1259 lttv_traceset_context_position_destroy(events_request
->start_position
);
1260 events_request
->start_position
= lttv_traceset_context_position_new();
1261 lttv_traceset_context_position_save(tsc
, events_request
->start_position
);
1263 /* 1.2. Remove start time */
1264 events_request
->start_time
.tv_sec
= G_MAXUINT
;
1265 events_request
->start_time
.tv_nsec
= G_MAXUINT
;
1267 /* 1.3. Move from list_in to list_out */
1270 list_out
= g_slist_append(list_out
, events_request
);
1275 GSList
*remove_iter
= iter
;
1277 iter
= g_slist_next(iter
);
1278 if(free_data
) events_request_free((EventsRequest
*)remove_iter
->data
);
1279 list_in
= g_slist_remove_link(list_in
, remove_iter
);
1280 } else { // not remove
1281 iter
= g_slist_next(iter
);
1288 /* C Unlock Traces */
1290 //lttv_process_traceset_get_sync_data(tsc);
1295 iter_trace
<lttv_traceset_number(tsc
->ts
);
1297 LttvTrace
*trace_v
= lttv_traceset_get(tsc
->ts
, iter_trace
);
1299 lttvwindowtraces_unlock(trace_v
);
1304 //set the cursor back to normal
1305 gdk_window_set_cursor(win
, NULL
);
1308 g_assert(g_slist_length(list_in
) == 0);
1310 if( g_slist_length(list_out
) == 0 ) {
1311 /* Put tab's request pending flag back to normal */
1312 tab
->events_request_pending
= FALSE
;
1313 g_debug("remove the idle fct");
1314 return FALSE
; /* Remove the idle function */
1316 g_debug("leave the idle fct");
1317 return TRUE
; /* Leave the idle function */
1319 /* We do not use simili-round-robin, it may require to read 1 meg buffers
1320 * again and again if many tracesets use the same tracefiles. */
1321 /* Hack for round-robin idle functions */
1322 /* It will put the idle function at the end of the pool */
1323 /*g_idle_add_full((G_PRIORITY_HIGH_IDLE + 21),
1324 (GSourceFunc)execute_events_requests,
1334 /* add_trace_into_traceset_selector, each instance of a viewer has an associated
1335 * selector (filter), when a trace is added into traceset, the selector should
1336 * reflect the change. The function is used to update the selector
1339 void add_trace_into_traceset_selector(GtkWidget
* paned
, LttTrace
* t
)
1341 int j
, k
, m
, nb_tracefile
, nb_control
, nb_per_cpu
, nb_facility
, nb_event
;
1342 LttvTracesetSelector
* s
;
1343 LttvTraceSelector
* trace
;
1344 LttvTracefileSelector
* tracefile
;
1345 LttvEventtypeSelector
* eventtype
;
1351 w
= gtk_multivpaned_get_first_widget(GTK_MULTIVPANED(paned
));
1353 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
1356 trace
= lttv_trace_selector_new(t
);
1357 lttv_traceset_selector_trace_add(s
, trace
);
1359 nb_facility
= ltt_trace_facility_number(t
);
1360 for(k
=0;k
<nb_facility
;k
++){
1361 fac
= ltt_trace_facility_get(t
,k
);
1362 nb_event
= (int) ltt_facility_eventtype_number(fac
);
1363 for(m
=0;m
<nb_event
;m
++){
1364 et
= ltt_facility_eventtype_get(fac
,m
);
1365 eventtype
= lttv_eventtype_selector_new(et
);
1366 lttv_trace_selector_eventtype_add(trace
, eventtype
);
1370 nb_control
= ltt_trace_control_tracefile_number(t
);
1371 nb_per_cpu
= ltt_trace_per_cpu_tracefile_number(t
);
1372 nb_tracefile
= nb_control
+ nb_per_cpu
;
1374 for(j
= 0 ; j
< nb_tracefile
; j
++) {
1376 tf
= ltt_trace_control_tracefile_get(t
, j
);
1378 tf
= ltt_trace_per_cpu_tracefile_get(t
, j
- nb_control
);
1379 tracefile
= lttv_tracefile_selector_new(tf
);
1380 lttv_trace_selector_tracefile_add(trace
, tracefile
);
1381 lttv_eventtype_selector_copy(trace
, tracefile
);
1383 }else g_warning("Module does not support filtering\n");
1385 w
= gtk_multivpaned_get_next_widget(GTK_MULTIVPANED(paned
));
1390 static void lttvwindow_add_trace(Tab
*tab
, LttvTrace
*trace_v
)
1392 LttvTraceset
*traceset
= tab
->traceset_info
->traceset
;
1394 guint num_traces
= lttv_traceset_number(traceset
);
1396 //Verify if trace is already present.
1397 for(i
=0; i
<num_traces
; i
++)
1399 LttvTrace
* trace
= lttv_traceset_get(traceset
, i
);
1400 if(trace
== trace_v
)
1404 //Keep a reference to the traces so they are not freed.
1405 for(i
=0; i
<lttv_traceset_number(traceset
); i
++)
1407 LttvTrace
* trace
= lttv_traceset_get(traceset
, i
);
1408 lttv_trace_ref(trace
);
1411 //remove state update hooks
1412 lttv_state_remove_event_hooks(
1413 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1415 lttv_context_fini(LTTV_TRACESET_CONTEXT(
1416 tab
->traceset_info
->traceset_context
));
1417 g_object_unref(tab
->traceset_info
->traceset_context
);
1419 lttv_traceset_add(traceset
, trace_v
);
1420 lttv_trace_ref(trace_v
); /* local ref */
1422 /* Create new context */
1423 tab
->traceset_info
->traceset_context
=
1424 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
1426 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->
1430 /* Set the tab's time window and current time if
1432 TimeInterval time_span
=
1433 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->time_span
;
1434 if(ltt_time_compare(tab
->time_window
.start_time
, time_span
.start_time
) < 0
1435 || ltt_time_compare( ltt_time_add(tab
->time_window
.start_time
,
1436 tab
->time_window
.time_width
),
1437 time_span
.end_time
) > 0) {
1438 tab
->time_window
.start_time
=
1439 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
1440 time_span
.start_time
;
1442 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
1443 time_span
.start_time
;
1447 if(DEFAULT_TIME_WIDTH_S
<
1448 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
1449 time_span
.end_time
.tv_sec
)
1450 tmp_time
.tv_sec
= DEFAULT_TIME_WIDTH_S
;
1453 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
1454 time_span
.end_time
.tv_sec
;
1455 tmp_time
.tv_nsec
= 0;
1456 tab
->time_window
.time_width
= tmp_time
;
1460 //add state update hooks
1461 lttv_state_add_event_hooks(
1462 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1463 //Remove local reference to the traces.
1464 for(i
=0; i
<lttv_traceset_number(traceset
); i
++)
1466 LttvTrace
* trace
= lttv_traceset_get(traceset
, i
);
1467 lttv_trace_unref(trace
);
1471 //add_trace_into_traceset_selector(GTK_MULTIVPANED(tab->multivpaned), lttv_trace(trace_v));
1474 /* add_trace adds a trace into the current traceset. It first displays a
1475 * directory selection dialogue to let user choose a trace, then recreates
1476 * tracset_context, and redraws all the viewer of the current tab
1479 void add_trace(GtkWidget
* widget
, gpointer user_data
)
1482 LttvTrace
* trace_v
;
1483 LttvTraceset
* traceset
;
1485 char abs_path
[PATH_MAX
];
1488 MainWindow
* mw_data
= get_window_data_struct(widget
);
1489 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
1491 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1492 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1496 tab
= create_new_tab(widget
, NULL
);
1498 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1501 GtkDirSelection
* file_selector
= (GtkDirSelection
*)gtk_dir_selection_new("Select a trace");
1502 gtk_dir_selection_hide_fileop_buttons(file_selector
);
1504 if(remember_trace_dir
[0] != '\0')
1505 gtk_dir_selection_set_filename(file_selector
, remember_trace_dir
);
1507 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
1509 case GTK_RESPONSE_ACCEPT
:
1510 case GTK_RESPONSE_OK
:
1511 dir
= gtk_dir_selection_get_dir (file_selector
);
1512 strncpy(remember_trace_dir
, dir
, PATH_MAX
);
1513 if(!dir
|| strlen(dir
) == 0){
1514 gtk_widget_destroy((GtkWidget
*)file_selector
);
1517 get_absolute_pathname(dir
, abs_path
);
1518 trace_v
= lttvwindowtraces_get_trace_by_name(abs_path
);
1519 if(trace_v
== NULL
) {
1520 trace
= ltt_trace_open(abs_path
);
1522 g_warning("cannot open trace %s", abs_path
);
1524 trace_v
= lttv_trace_new(trace
);
1525 lttvwindowtraces_add_trace(trace_v
);
1526 lttvwindow_add_trace(tab
, trace_v
);
1529 lttvwindow_add_trace(tab
, trace_v
);
1532 gtk_widget_destroy((GtkWidget
*)file_selector
);
1534 //update current tab
1535 //update_traceset(mw_data);
1537 /* Call the updatetraceset hooks */
1539 traceset
= tab
->traceset_info
->traceset
;
1540 SetTraceset(tab
, traceset
);
1541 // in expose now call_pending_read_hooks(mw_data);
1543 //lttvwindow_report_current_time(mw_data,&(tab->current_time));
1545 case GTK_RESPONSE_REJECT
:
1546 case GTK_RESPONSE_CANCEL
:
1548 gtk_widget_destroy((GtkWidget
*)file_selector
);
1554 /* remove_trace_into_traceset_selector, each instance of a viewer has an associated
1555 * selector (filter), when a trace is remove from traceset, the selector should
1556 * reflect the change. The function is used to update the selector
1559 void remove_trace_from_traceset_selector(GtkWidget
* paned
, unsigned i
)
1561 LttvTracesetSelector
* s
;
1562 LttvTraceSelector
* t
;
1565 w
= gtk_multivpaned_get_first_widget(GTK_MULTIVPANED(paned
));
1567 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
1569 t
= lttv_traceset_selector_trace_get(s
,i
);
1570 lttv_traceset_selector_trace_remove(s
, i
);
1571 lttv_trace_selector_destroy(t
);
1572 }g_warning("Module dose not support filtering\n");
1573 w
= gtk_multivpaned_get_next_widget(GTK_MULTIVPANED(paned
));
1578 /* remove_trace removes a trace from the current traceset if all viewers in
1579 * the current tab are not interested in the trace. It first displays a
1580 * dialogue, which shows all traces in the current traceset, to let user choose
1581 * a trace, then it checks if all viewers unselect the trace, if it is true,
1582 * it will remove the trace, recreate the traceset_contex,
1583 * and redraws all the viewer of the current tab. If there is on trace in the
1584 * current traceset, it will delete all viewers of the current tab
1587 // MD : no filter version.
1588 void remove_trace(GtkWidget
*widget
, gpointer user_data
)
1591 LttvTrace
* trace_v
;
1592 LttvTraceset
* traceset
;
1593 gint i
, j
, nb_trace
, index
=-1;
1594 char ** name
, *remove_trace_name
;
1595 MainWindow
* mw_data
= get_window_data_struct(widget
);
1596 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
1598 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1599 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1605 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1608 nb_trace
=lttv_traceset_number(tab
->traceset_info
->traceset
);
1609 name
= g_new(char*,nb_trace
);
1610 for(i
= 0; i
< nb_trace
; i
++){
1611 trace_v
= lttv_traceset_get(tab
->traceset_info
->traceset
, i
);
1612 trace
= lttv_trace(trace_v
);
1613 name
[i
] = ltt_trace_name(trace
);
1616 remove_trace_name
= get_remove_trace(name
, nb_trace
);
1619 if(remove_trace_name
){
1621 /* yuk, cut n paste from old code.. should be better (MD)*/
1622 for(i
= 0; i
<nb_trace
; i
++) {
1623 if(strcmp(remove_trace_name
,name
[i
]) == 0){
1628 traceset
= tab
->traceset_info
->traceset
;
1629 //Keep a reference to the traces so they are not freed.
1630 for(j
=0; j
<lttv_traceset_number(traceset
); j
++)
1632 LttvTrace
* trace
= lttv_traceset_get(traceset
, j
);
1633 lttv_trace_ref(trace
);
1636 //remove state update hooks
1637 lttv_state_remove_event_hooks(
1638 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1639 lttv_context_fini(LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
));
1640 g_object_unref(tab
->traceset_info
->traceset_context
);
1642 trace_v
= lttv_traceset_get(traceset
, index
);
1644 if(lttv_trace_get_ref_number(trace_v
) <= 2) {
1645 /* ref 2 : traceset, local */
1646 lttvwindowtraces_remove_trace(trace_v
);
1647 ltt_trace_close(lttv_trace(trace_v
));
1650 lttv_traceset_remove(traceset
, index
);
1651 lttv_trace_unref(trace_v
); // Remove local reference
1653 if(!lttv_trace_get_ref_number(trace_v
))
1654 lttv_trace_destroy(trace_v
);
1656 tab
->traceset_info
->traceset_context
=
1657 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
1659 LTTV_TRACESET_CONTEXT(tab
->
1660 traceset_info
->traceset_context
),traceset
);
1661 //add state update hooks
1662 lttv_state_add_event_hooks(
1663 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1665 //Remove local reference to the traces.
1666 for(j
=0; j
<lttv_traceset_number(traceset
); j
++)
1668 LttvTrace
* trace
= lttv_traceset_get(traceset
, j
);
1669 lttv_trace_unref(trace
);
1672 SetTraceset(tab
, (gpointer
)traceset
);
1678 void remove_trace(GtkWidget
* widget
, gpointer user_data
)
1681 LttvTrace
* trace_v
;
1682 LttvTraceset
* traceset
;
1683 gint i
, j
, nb_trace
;
1684 char ** name
, *remove_trace_name
;
1685 MainWindow
* mw_data
= get_window_data_struct(widget
);
1686 LttvTracesetSelector
* s
;
1687 LttvTraceSelector
* t
;
1690 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
1692 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1693 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1699 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1702 nb_trace
=lttv_traceset_number(tab
->traceset_info
->traceset
);
1703 name
= g_new(char*,nb_trace
);
1704 for(i
= 0; i
< nb_trace
; i
++){
1705 trace_v
= lttv_traceset_get(tab
->traceset_info
->traceset
, i
);
1706 trace
= lttv_trace(trace_v
);
1707 name
[i
] = ltt_trace_name(trace
);
1710 remove_trace_name
= get_remove_trace(name
, nb_trace
);
1712 if(remove_trace_name
){
1713 for(i
=0; i
<nb_trace
; i
++){
1714 if(strcmp(remove_trace_name
,name
[i
]) == 0){
1715 //unselect the trace from the current viewer
1717 w
= gtk_multivpaned_get_widget(GTK_MULTIVPANED(tab
->multivpaned
));
1719 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
1721 t
= lttv_traceset_selector_trace_get(s
,i
);
1722 lttv_trace_selector_set_selected(t
, FALSE
);
1725 //check if other viewers select the trace
1726 w
= gtk_multivpaned_get_first_widget(GTK_MULTIVPANED(tab
->multivpaned
));
1728 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
1730 t
= lttv_traceset_selector_trace_get(s
,i
);
1731 selected
= lttv_trace_selector_get_selected(t
);
1734 w
= gtk_multivpaned_get_next_widget(GTK_MULTIVPANED(tab
->multivpaned
));
1736 }else selected
= FALSE
;
1738 //if no viewer selects the trace, remove it
1740 remove_trace_from_traceset_selector(GTK_MULTIVPANED(tab
->multivpaned
), i
);
1742 traceset
= tab
->traceset_info
->traceset
;
1743 //Keep a reference to the traces so they are not freed.
1744 for(j
=0; j
<lttv_traceset_number(traceset
); j
++)
1746 LttvTrace
* trace
= lttv_traceset_get(traceset
, j
);
1747 lttv_trace_ref(trace
);
1750 //remove state update hooks
1751 lttv_state_remove_event_hooks(
1752 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1753 lttv_context_fini(LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
));
1754 g_object_unref(tab
->traceset_info
->traceset_context
);
1757 trace_v
= lttv_traceset_get(traceset
, i
);
1759 if(lttv_trace_get_ref_number(trace_v
) <= 2) {
1760 /* ref 2 : traceset, local */
1761 lttvwindowtraces_remove_trace(trace_v
);
1762 ltt_trace_close(lttv_trace(trace_v
));
1765 lttv_traceset_remove(traceset
, i
);
1766 lttv_trace_unref(trace_v
); // Remove local reference
1768 if(!lttv_trace_get_ref_number(trace_v
))
1769 lttv_trace_destroy(trace_v
);
1771 tab
->traceset_info
->traceset_context
=
1772 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
1774 LTTV_TRACESET_CONTEXT(tab
->
1775 traceset_info
->traceset_context
),traceset
);
1776 //add state update hooks
1777 lttv_state_add_event_hooks(
1778 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1780 //Remove local reference to the traces.
1781 for(j
=0; j
<lttv_traceset_number(traceset
); j
++)
1783 LttvTrace
* trace
= lttv_traceset_get(traceset
, j
);
1784 lttv_trace_unref(trace
);
1788 //update current tab
1789 //update_traceset(mw_data);
1792 SetTraceset(tab
, (gpointer
)traceset
);
1793 // in expose now call_pending_read_hooks(mw_data);
1795 //lttvwindow_report_current_time(mw_data,&(tab->current_time));
1798 // while(tab->multi_vpaned->num_children){
1799 // gtk_multi_vpaned_widget_delete(tab->multi_vpaned);
1813 /* Redraw all the viewers in the current tab */
1814 void redraw(GtkWidget
*widget
, gpointer user_data
)
1816 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
1817 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1818 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1823 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1827 LttvAttributeValue value
;
1829 g_assert(lttv_iattribute_find_by_path(tab
->attributes
, "hooks/redraw", LTTV_POINTER
, &value
));
1831 tmp
= (LttvHooks
*)*(value
.v_pointer
);
1833 lttv_hooks_call(tmp
,NULL
);
1837 void continue_processing(GtkWidget
*widget
, gpointer user_data
)
1839 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
1840 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1841 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1846 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1850 LttvAttributeValue value
;
1852 g_assert(lttv_iattribute_find_by_path(tab
->attributes
,
1853 "hooks/continue", LTTV_POINTER
, &value
));
1855 tmp
= (LttvHooks
*)*(value
.v_pointer
);
1857 lttv_hooks_call(tmp
,NULL
);
1860 /* Stop the processing for the calling main window's current tab.
1861 * It removes every processing requests that are in its list. It does not call
1862 * the end request hooks, because the request is not finished.
1865 void stop_processing(GtkWidget
*widget
, gpointer user_data
)
1867 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
1868 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1869 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1874 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1876 GSList
*iter
= tab
->events_requests
;
1878 while(iter
!= NULL
) {
1879 GSList
*remove_iter
= iter
;
1880 iter
= g_slist_next(iter
);
1882 g_free(remove_iter
->data
);
1883 tab
->events_requests
=
1884 g_slist_remove_link(tab
->events_requests
, remove_iter
);
1886 tab
->events_request_pending
= FALSE
;
1887 g_idle_remove_by_data(tab
);
1888 g_assert(g_slist_length(tab
->events_requests
) == 0);
1892 /* save will save the traceset to a file
1893 * Not implemented yet FIXME
1896 void save(GtkWidget
* widget
, gpointer user_data
)
1901 void save_as(GtkWidget
* widget
, gpointer user_data
)
1903 g_printf("Save as\n");
1907 /* zoom will change the time_window of all the viewers of the
1908 * current tab, and redisplay them. The main functionality is to
1909 * determine the new time_window of the current tab
1912 void zoom(GtkWidget
* widget
, double size
)
1914 TimeInterval time_span
;
1915 TimeWindow new_time_window
;
1916 LttTime current_time
, time_delta
, time_s
, time_e
, time_tmp
;
1917 MainWindow
* mw_data
= get_window_data_struct(widget
);
1918 LttvTracesetContext
*tsc
;
1919 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
1921 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1922 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1928 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1931 if(size
== 1) return;
1933 tsc
= LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
1934 time_span
= tsc
->time_span
;
1935 new_time_window
= tab
->time_window
;
1936 current_time
= tab
->current_time
;
1938 time_delta
= ltt_time_sub(time_span
.end_time
,time_span
.start_time
);
1940 new_time_window
.start_time
= time_span
.start_time
;
1941 new_time_window
.time_width
= time_delta
;
1943 new_time_window
.time_width
= ltt_time_div(new_time_window
.time_width
, size
);
1944 if(ltt_time_compare(new_time_window
.time_width
,time_delta
) > 0)
1945 { /* Case where zoom out is bigger than trace length */
1946 new_time_window
.start_time
= time_span
.start_time
;
1947 new_time_window
.time_width
= time_delta
;
1951 /* Center the image on the current time */
1952 new_time_window
.start_time
=
1953 ltt_time_sub(current_time
, ltt_time_div(new_time_window
.time_width
, 2.0));
1954 /* If on borders, don't fall off */
1955 if(ltt_time_compare(new_time_window
.start_time
, time_span
.start_time
) <0)
1957 new_time_window
.start_time
= time_span
.start_time
;
1961 if(ltt_time_compare(
1962 ltt_time_add(new_time_window
.start_time
, new_time_window
.time_width
),
1963 time_span
.end_time
) > 0)
1965 new_time_window
.start_time
=
1966 ltt_time_sub(time_span
.end_time
, new_time_window
.time_width
);
1972 //time_tmp = ltt_time_div(new_time_window.time_width, 2);
1973 //if(ltt_time_compare(current_time, time_tmp) < 0){
1974 // time_s = time_span->startTime;
1976 // time_s = ltt_time_sub(current_time,time_tmp);
1978 //time_e = ltt_time_add(current_time,time_tmp);
1979 //if(ltt_time_compare(time_span->startTime, time_s) > 0){
1980 // time_s = time_span->startTime;
1981 //}else if(ltt_time_compare(time_span->endTime, time_e) < 0){
1982 // time_e = time_span->endTime;
1983 // time_s = ltt_time_sub(time_e,new_time_window.time_width);
1985 //new_time_window.start_time = time_s;
1988 //lttvwindow_report_time_window(mw_data, &new_time_window);
1989 //call_pending_read_hooks(mw_data);
1991 //lttvwindow_report_current_time(mw_data,&(tab->current_time));
1992 //set_time_window(tab, &new_time_window);
1993 // in expose now call_pending_read_hooks(mw_data);
1994 //gtk_multi_vpaned_set_adjust(tab->multi_vpaned, &new_time_window, FALSE);
1998 if( ltt_time_to_double(new_time_window
.time_width
)
1999 * NANOSECONDS_PER_SECOND
2000 / SCROLL_STEP_PER_PAGE
/* step increment */
2002 ltt_time_to_double(new_time_window
.start_time
)
2003 * NANOSECONDS_PER_SECOND
/* page size */
2005 ltt_time_to_double(new_time_window
.start_time
)
2006 * NANOSECONDS_PER_SECOND
/* page size */
2008 g_warning("Can not zoom that far due to scrollbar precision");
2011 ltt_time_from_double(
2012 ltt_time_to_double(new_time_window
.time_width
)
2013 /SCROLL_STEP_PER_PAGE
),
2016 g_warning("Can not zoom that far due to time nanosecond precision");
2019 GtkAdjustment
*adjustment
= gtk_range_get_adjustment(GTK_RANGE(tab
->scrollbar
));
2021 g_object_set(G_OBJECT(adjustment
),
2023 //ltt_time_to_double(new_time_window.start_time)
2024 // * NANOSECONDS_PER_SECOND, /* value */
2026 ltt_time_to_double(time_span
.start_time
)
2027 * NANOSECONDS_PER_SECOND
, /* lower */
2029 ltt_time_to_double(time_span
.end_time
)
2030 * NANOSECONDS_PER_SECOND
, /* upper */
2032 ltt_time_to_double(new_time_window
.time_width
)
2033 / SCROLL_STEP_PER_PAGE
2034 * NANOSECONDS_PER_SECOND
, /* step increment */
2036 ltt_time_to_double(new_time_window
.time_width
)
2037 * NANOSECONDS_PER_SECOND
, /* page increment */
2039 ltt_time_to_double(new_time_window
.time_width
)
2040 * NANOSECONDS_PER_SECOND
, /* page size */
2042 gtk_adjustment_changed(adjustment
);
2043 //gtk_range_set_adjustment(GTK_RANGE(tab->scrollbar), adjustment);
2044 //gtk_adjustment_value_changed(adjustment);
2045 g_object_set(G_OBJECT(adjustment
),
2047 ltt_time_to_double(new_time_window
.start_time
)
2048 * NANOSECONDS_PER_SECOND
, /* value */
2050 gtk_adjustment_value_changed(adjustment
);
2053 //g_object_set(G_OBJECT(adjustment),
2055 // ltt_time_to_double(time_window->start_time)
2056 // * NANOSECONDS_PER_SECOND, /* value */
2058 /* Note : the set value will call set_time_window if scrollbar value changed
2060 //gtk_adjustment_set_value(adjustment,
2061 // ltt_time_to_double(new_time_window.start_time)
2062 // * NANOSECONDS_PER_SECOND);
2066 void zoom_in(GtkWidget
* widget
, gpointer user_data
)
2071 void zoom_out(GtkWidget
* widget
, gpointer user_data
)
2076 void zoom_extended(GtkWidget
* widget
, gpointer user_data
)
2081 void go_to_time(GtkWidget
* widget
, gpointer user_data
)
2083 g_printf("Go to time\n");
2086 void show_time_frame(GtkWidget
* widget
, gpointer user_data
)
2088 g_printf("Show time frame\n");
2092 /* callback function */
2095 on_empty_traceset_activate (GtkMenuItem
*menuitem
,
2098 create_new_window((GtkWidget
*)menuitem
, user_data
, FALSE
);
2103 on_clone_traceset_activate (GtkMenuItem
*menuitem
,
2106 create_new_window((GtkWidget
*)menuitem
, user_data
, TRUE
);
2110 /* create_new_tab calls create_tab to construct a new tab in the main window
2113 Tab
*create_new_tab(GtkWidget
* widget
, gpointer user_data
){
2114 gchar label
[PATH_MAX
];
2115 MainWindow
* mw_data
= get_window_data_struct(widget
);
2117 GtkNotebook
* notebook
= (GtkNotebook
*)lookup_widget(widget
, "MNotebook");
2118 if(notebook
== NULL
){
2119 g_printf("Notebook does not exist\n");
2122 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
2123 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
2129 copy_tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
2132 strcpy(label
,"Page");
2133 if(get_label(mw_data
, label
,"Get the name of the tab","Please input tab's name"))
2134 return (create_tab (mw_data
, copy_tab
, notebook
, label
));
2138 on_tab_activate (GtkMenuItem
*menuitem
,
2141 create_new_tab((GtkWidget
*)menuitem
, user_data
);
2146 on_open_activate (GtkMenuItem
*menuitem
,
2149 open_traceset((GtkWidget
*)menuitem
, user_data
);
2154 on_close_activate (GtkMenuItem
*menuitem
,
2157 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2158 main_window_destructor(mw_data
);
2162 /* remove the current tab from the main window
2166 on_close_tab_activate (GtkWidget
*widget
,
2170 GtkWidget
* notebook
;
2172 MainWindow
* mw_data
= get_window_data_struct(widget
);
2173 notebook
= lookup_widget(widget
, "MNotebook");
2174 if(notebook
== NULL
){
2175 g_printf("Notebook does not exist\n");
2179 page_num
= gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
));
2181 gtk_notebook_remove_page(GTK_NOTEBOOK(notebook
), page_num
);
2186 on_close_tab_X_clicked (GtkWidget
*widget
,
2190 GtkWidget
*notebook
= lookup_widget(widget
, "MNotebook");
2191 if(notebook
== NULL
){
2192 g_printf("Notebook does not exist\n");
2196 if((page_num
= gtk_notebook_page_num(GTK_NOTEBOOK(notebook
), widget
)) != -1)
2197 gtk_notebook_remove_page(GTK_NOTEBOOK(notebook
), page_num
);
2203 on_add_trace_activate (GtkMenuItem
*menuitem
,
2206 add_trace((GtkWidget
*)menuitem
, user_data
);
2211 on_remove_trace_activate (GtkMenuItem
*menuitem
,
2214 remove_trace((GtkWidget
*)menuitem
, user_data
);
2219 on_save_activate (GtkMenuItem
*menuitem
,
2222 save((GtkWidget
*)menuitem
, user_data
);
2227 on_save_as_activate (GtkMenuItem
*menuitem
,
2230 save_as((GtkWidget
*)menuitem
, user_data
);
2235 on_quit_activate (GtkMenuItem
*menuitem
,
2243 on_cut_activate (GtkMenuItem
*menuitem
,
2251 on_copy_activate (GtkMenuItem
*menuitem
,
2254 g_printf("Copye\n");
2259 on_paste_activate (GtkMenuItem
*menuitem
,
2262 g_printf("Paste\n");
2267 on_delete_activate (GtkMenuItem
*menuitem
,
2270 g_printf("Delete\n");
2275 on_zoom_in_activate (GtkMenuItem
*menuitem
,
2278 zoom_in((GtkWidget
*)menuitem
, user_data
);
2283 on_zoom_out_activate (GtkMenuItem
*menuitem
,
2286 zoom_out((GtkWidget
*)menuitem
, user_data
);
2291 on_zoom_extended_activate (GtkMenuItem
*menuitem
,
2294 zoom_extended((GtkWidget
*)menuitem
, user_data
);
2299 on_go_to_time_activate (GtkMenuItem
*menuitem
,
2302 go_to_time((GtkWidget
*)menuitem
, user_data
);
2307 on_show_time_frame_activate (GtkMenuItem
*menuitem
,
2310 show_time_frame((GtkWidget
*)menuitem
, user_data
);
2315 on_move_viewer_up_activate (GtkMenuItem
*menuitem
,
2318 move_up_viewer((GtkWidget
*)menuitem
, user_data
);
2323 on_move_viewer_down_activate (GtkMenuItem
*menuitem
,
2326 move_down_viewer((GtkWidget
*)menuitem
, user_data
);
2331 on_remove_viewer_activate (GtkMenuItem
*menuitem
,
2334 delete_viewer((GtkWidget
*)menuitem
, user_data
);
2339 on_trace_filter_activate (GtkMenuItem
*menuitem
,
2342 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2343 LttvTracesetSelector
* s
;
2345 GtkWidget
* notebook
= lookup_widget(GTK_WIDGET(menuitem
), "MNotebook");
2347 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
2348 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
2354 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
2357 w
= gtk_multivpaned_get_widget(GTK_MULTIVPANED(tab
->multivpaned
));
2359 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
2361 g_printf("There is no viewer yet\n");
2364 if(get_filter_selection(s
, "Configure trace and tracefile filter", "Select traces and tracefiles")){
2365 //FIXME report filter change
2366 //update_traceset(mw_data);
2367 //call_pending_read_hooks(mw_data);
2368 //lttvwindow_report_current_time(mw_data,&(tab->current_time));
2374 on_trace_facility_activate (GtkMenuItem
*menuitem
,
2377 g_printf("Trace facility selector: %s\n");
2381 /* Dispaly a file selection dialogue to let user select a library, then call
2382 * lttv_library_load().
2386 on_load_library_activate (GtkMenuItem
*menuitem
,
2389 GError
*error
= NULL
;
2390 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2392 gchar load_module_path_alter
[PATH_MAX
];
2396 gchar
*load_module_path
;
2397 name
= g_ptr_array_new();
2398 nb
= lttv_library_path_number();
2399 /* ask for the library path */
2403 path
= lttv_library_path_get(i
);
2404 g_ptr_array_add(name
, path
);
2407 load_module_path
= get_selection((char **)(name
->pdata
), name
->len
,
2408 "Select a library path", "Library paths");
2409 if(load_module_path
!= NULL
)
2410 strncpy(load_module_path_alter
, load_module_path
, PATH_MAX
-1); // -1 for /
2412 g_ptr_array_free(name
, TRUE
);
2414 if(load_module_path
== NULL
) return;
2418 /* Make sure the module path ends with a / */
2419 gchar
*ptr
= load_module_path_alter
;
2421 ptr
= strchr(ptr
, '\0');
2423 if(*(ptr
-1) != '/') {
2430 /* Ask for the library to load : list files in the previously selected
2432 gchar str
[PATH_MAX
];
2435 GtkFileSelection
* file_selector
=
2436 (GtkFileSelection
*)gtk_file_selection_new("Select a module");
2437 gtk_file_selection_set_filename(file_selector
, load_module_path_alter
);
2438 gtk_file_selection_hide_fileop_buttons(file_selector
);
2441 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
2443 case GTK_RESPONSE_ACCEPT
:
2444 case GTK_RESPONSE_OK
:
2445 dir
= gtk_file_selection_get_selections (file_selector
);
2446 strncpy(str
,dir
[0],PATH_MAX
);
2447 strncpy(remember_plugins_dir
,dir
[0],PATH_MAX
);
2448 /* only keep file name */
2450 str1
= strrchr(str
,'/');
2453 str1
= strrchr(str
,'\\');
2458 if(*str1
== 'l' && *(str1
+1)== 'i' && *(str1
+2)=='b')
2460 remove info after
. */
2464 str2
= strrchr(str2
, '.');
2465 if(str2
!= NULL
) *str2
= '\0';
2467 lttv_module_require(str1
, &error
);
2469 lttv_library_load(str1
, &error
);
2470 if(error
!= NULL
) g_warning(error
->message
);
2471 else g_printf("Load library: %s\n", str
);
2473 case GTK_RESPONSE_REJECT
:
2474 case GTK_RESPONSE_CANCEL
:
2476 gtk_widget_destroy((GtkWidget
*)file_selector
);
2487 /* Display all loaded modules, let user to select a module to unload
2488 * by calling lttv_module_unload
2492 on_unload_library_activate (GtkMenuItem
*menuitem
,
2495 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2497 LttvLibrary
*library
;
2502 name
= g_ptr_array_new();
2503 nb
= lttv_library_number();
2504 LttvLibraryInfo
*lib_info
= g_new(LttvLibraryInfo
,nb
);
2505 /* ask for the library name */
2508 LttvLibrary
*iter_lib
= lttv_library_get(i
);
2509 lttv_library_info(iter_lib
, &lib_info
[i
]);
2511 gchar
*path
= lib_info
[i
].name
;
2512 g_ptr_array_add(name
, lib_info
[i
].name
);
2514 lib_name
= get_selection((char **)(name
->pdata
), name
->len
,
2515 "Select a library", "Libraries");
2516 if(lib_name
!= NULL
) {
2518 if(strcmp(lib_name
, lib_info
[i
].name
) == 0) {
2519 library
= lttv_library_get(i
);
2524 g_ptr_array_free(name
, TRUE
);
2527 if(lib_name
== NULL
) return;
2530 lttv_library_unload(library
);
2534 /* Dispaly a file selection dialogue to let user select a module, then call
2535 * lttv_module_require().
2539 on_load_module_activate (GtkMenuItem
*menuitem
,
2542 GError
*error
= NULL
;
2543 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2545 LttvLibrary
*library
;
2550 name
= g_ptr_array_new();
2551 nb
= lttv_library_number();
2552 LttvLibraryInfo
*lib_info
= g_new(LttvLibraryInfo
,nb
);
2553 /* ask for the library name */
2556 LttvLibrary
*iter_lib
= lttv_library_get(i
);
2557 lttv_library_info(iter_lib
, &lib_info
[i
]);
2559 gchar
*path
= lib_info
[i
].name
;
2560 g_ptr_array_add(name
, path
);
2562 lib_name
= get_selection((char **)(name
->pdata
), name
->len
,
2563 "Select a library", "Libraries");
2564 if(lib_name
!= NULL
) {
2566 if(strcmp(lib_name
, lib_info
[i
].name
) == 0) {
2567 library
= lttv_library_get(i
);
2572 g_ptr_array_free(name
, TRUE
);
2575 if(lib_name
== NULL
) return;
2578 //LttvModule *module;
2579 gchar module_name_out
[PATH_MAX
];
2581 /* Ask for the module to load : list modules in the selected lib */
2585 LttvModuleInfo
*module_info
= g_new(LttvModuleInfo
,nb
);
2586 name
= g_ptr_array_new();
2587 nb
= lttv_library_module_number(library
);
2588 /* ask for the module name */
2591 LttvModule
*iter_module
= lttv_library_module_get(library
, i
);
2592 lttv_module_info(iter_module
, &module_info
[i
]);
2594 gchar
*path
= module_info
[i
].name
;
2595 g_ptr_array_add(name
, path
);
2597 module_name
= get_selection((char **)(name
->pdata
), name
->len
,
2598 "Select a module", "Modules");
2599 if(module_name
!= NULL
) {
2601 if(strcmp(module_name
, module_info
[i
].name
) == 0) {
2602 strncpy(module_name_out
, module_name
, PATH_MAX
);
2603 //module = lttv_library_module_get(i);
2609 g_ptr_array_free(name
, TRUE
);
2610 g_free(module_info
);
2612 if(module_name
== NULL
) return;
2615 lttv_module_require(module_name_out
, &error
);
2616 if(error
!= NULL
) g_warning(error
->message
);
2617 else g_printf("Load module: %s\n", module_name_out
);
2624 gchar str
[PATH_MAX
];
2627 GtkFileSelection
* file_selector
=
2628 (GtkFileSelection
*)gtk_file_selection_new("Select a module");
2629 gtk_file_selection_set_filename(file_selector
, load_module_path_alter
);
2630 gtk_file_selection_hide_fileop_buttons(file_selector
);
2633 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
2635 case GTK_RESPONSE_ACCEPT
:
2636 case GTK_RESPONSE_OK
:
2637 dir
= gtk_file_selection_get_selections (file_selector
);
2638 strncpy(str
,dir
[0],PATH_MAX
);
2639 strncpy(remember_plugins_dir
,dir
[0],PATH_MAX
);
2641 /* only keep file name */
2643 str1
= strrchr(str
,'/');
2646 str1
= strrchr(str
,'\\');
2651 if(*str1
== 'l' && *(str1
+1)== 'i' && *(str1
+2)=='b')
2653 remove info after
. */
2657 str2
= strrchr(str2
, '.');
2658 if(str2
!= NULL
) *str2
= '\0';
2660 lttv_module_require(str1
, &error
);
2662 lttv_library_load(str1
, &error
);
2663 if(error
!= NULL
) g_warning(error
->message
);
2664 else g_printf("Load library: %s\n", str
);
2666 case GTK_RESPONSE_REJECT
:
2667 case GTK_RESPONSE_CANCEL
:
2669 gtk_widget_destroy((GtkWidget
*)file_selector
);
2681 /* Display all loaded modules, let user to select a module to unload
2682 * by calling lttv_module_unload
2686 on_unload_module_activate (GtkMenuItem
*menuitem
,
2689 GError
*error
= NULL
;
2690 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2692 LttvLibrary
*library
;
2697 name
= g_ptr_array_new();
2698 nb
= lttv_library_number();
2699 LttvLibraryInfo
*lib_info
= g_new(LttvLibraryInfo
,nb
);
2700 /* ask for the library name */
2703 LttvLibrary
*iter_lib
= lttv_library_get(i
);
2704 lttv_library_info(iter_lib
, &lib_info
[i
]);
2706 gchar
*path
= lib_info
[i
].name
;
2707 g_ptr_array_add(name
, path
);
2709 lib_name
= get_selection((char **)(name
->pdata
), name
->len
,
2710 "Select a library", "Libraries");
2711 if(lib_name
!= NULL
) {
2713 if(strcmp(lib_name
, lib_info
[i
].name
) == 0) {
2714 library
= lttv_library_get(i
);
2719 g_ptr_array_free(name
, TRUE
);
2722 if(lib_name
== NULL
) return;
2727 /* Ask for the module to load : list modules in the selected lib */
2731 nb
= lttv_library_module_number(library
);
2732 LttvModuleInfo
*module_info
= g_new(LttvModuleInfo
,nb
);
2733 name
= g_ptr_array_new();
2734 /* ask for the module name */
2737 LttvModule
*iter_module
= lttv_library_module_get(library
, i
);
2738 lttv_module_info(iter_module
, &module_info
[i
]);
2740 gchar
*path
= module_info
[i
].name
;
2741 if(module_info
[i
].use_count
> 0) g_ptr_array_add(name
, path
);
2743 module_name
= get_selection((char **)(name
->pdata
), name
->len
,
2744 "Select a module", "Modules");
2745 if(module_name
!= NULL
) {
2747 if(strcmp(module_name
, module_info
[i
].name
) == 0) {
2748 module
= lttv_library_module_get(library
, i
);
2754 g_ptr_array_free(name
, TRUE
);
2755 g_free(module_info
);
2757 if(module_name
== NULL
) return;
2760 LttvModuleInfo module_info
;
2761 lttv_module_info(module
, &module_info
);
2762 g_printf("Release module: %s\n", module_info
.name
);
2764 lttv_module_release(module
);
2768 /* Display a directory dialogue to let user select a path for library searching
2772 on_add_library_search_path_activate (GtkMenuItem
*menuitem
,
2775 GtkDirSelection
* file_selector
= (GtkDirSelection
*)gtk_dir_selection_new("Select library path");
2779 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2780 if(remember_plugins_dir
[0] != '\0')
2781 gtk_dir_selection_set_filename(file_selector
, remember_plugins_dir
);
2783 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
2785 case GTK_RESPONSE_ACCEPT
:
2786 case GTK_RESPONSE_OK
:
2787 dir
= gtk_dir_selection_get_dir (file_selector
);
2788 strncpy(remember_plugins_dir
,dir
,PATH_MAX
);
2789 strncat(remember_plugins_dir
,"/",PATH_MAX
);
2790 lttv_library_path_add(dir
);
2791 case GTK_RESPONSE_REJECT
:
2792 case GTK_RESPONSE_CANCEL
:
2794 gtk_widget_destroy((GtkWidget
*)file_selector
);
2800 /* Display a directory dialogue to let user select a path for library searching
2804 on_remove_library_search_path_activate (GtkMenuItem
*menuitem
,
2807 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2809 const char *lib_path
;
2814 name
= g_ptr_array_new();
2815 nb
= lttv_library_path_number();
2816 /* ask for the library name */
2819 gchar
*path
= lttv_library_path_get(i
);
2820 g_ptr_array_add(name
, path
);
2822 lib_path
= get_selection((char **)(name
->pdata
), name
->len
,
2823 "Select a library path", "Library paths");
2825 g_ptr_array_free(name
, TRUE
);
2827 if(lib_path
== NULL
) return;
2830 lttv_library_path_remove(lib_path
);
2834 on_color_activate (GtkMenuItem
*menuitem
,
2837 g_printf("Color\n");
2842 on_filter_activate (GtkMenuItem
*menuitem
,
2845 g_printf("Filter\n");
2850 on_save_configuration_activate (GtkMenuItem
*menuitem
,
2853 g_printf("Save configuration\n");
2858 on_content_activate (GtkMenuItem
*menuitem
,
2861 g_printf("Content\n");
2866 on_about_activate (GtkMenuItem
*menuitem
,
2869 g_printf("About...\n");
2874 on_button_new_clicked (GtkButton
*button
,
2877 create_new_window((GtkWidget
*)button
, user_data
, TRUE
);
2881 on_button_new_tab_clicked (GtkButton
*button
,
2884 create_new_tab((GtkWidget
*)button
, user_data
);
2888 on_button_open_clicked (GtkButton
*button
,
2891 open_traceset((GtkWidget
*)button
, user_data
);
2896 on_button_add_trace_clicked (GtkButton
*button
,
2899 add_trace((GtkWidget
*)button
, user_data
);
2904 on_button_remove_trace_clicked (GtkButton
*button
,
2907 remove_trace((GtkWidget
*)button
, user_data
);
2911 on_button_redraw_clicked (GtkButton
*button
,
2914 redraw((GtkWidget
*)button
, user_data
);
2918 on_button_continue_processing_clicked (GtkButton
*button
,
2921 continue_processing((GtkWidget
*)button
, user_data
);
2925 on_button_stop_processing_clicked (GtkButton
*button
,
2928 stop_processing((GtkWidget
*)button
, user_data
);
2934 on_button_save_clicked (GtkButton
*button
,
2937 save((GtkWidget
*)button
, user_data
);
2942 on_button_save_as_clicked (GtkButton
*button
,
2945 save_as((GtkWidget
*)button
, user_data
);
2950 on_button_zoom_in_clicked (GtkButton
*button
,
2953 zoom_in((GtkWidget
*)button
, user_data
);
2958 on_button_zoom_out_clicked (GtkButton
*button
,
2961 zoom_out((GtkWidget
*)button
, user_data
);
2966 on_button_zoom_extended_clicked (GtkButton
*button
,
2969 zoom_extended((GtkWidget
*)button
, user_data
);
2974 on_button_go_to_time_clicked (GtkButton
*button
,
2977 go_to_time((GtkWidget
*)button
, user_data
);
2982 on_button_show_time_frame_clicked (GtkButton
*button
,
2985 show_time_frame((GtkWidget
*)button
, user_data
);
2990 on_button_move_up_clicked (GtkButton
*button
,
2993 move_up_viewer((GtkWidget
*)button
, user_data
);
2998 on_button_move_down_clicked (GtkButton
*button
,
3001 move_down_viewer((GtkWidget
*)button
, user_data
);
3006 on_button_delete_viewer_clicked (GtkButton
*button
,
3009 delete_viewer((GtkWidget
*)button
, user_data
);
3013 on_MWindow_destroy (GtkWidget
*widget
,
3016 MainWindow
*main_window
= get_window_data_struct(widget
);
3017 LttvIAttribute
*attributes
= main_window
->attributes
;
3018 LttvAttributeValue value
;
3020 //This is unnecessary, since widgets will be destroyed
3021 //by the main window widget anyway.
3022 //remove_all_menu_toolbar_constructors(main_window, NULL);
3024 g_assert(lttv_iattribute_find_by_path(attributes
,
3025 "viewers/menu", LTTV_POINTER
, &value
));
3026 lttv_menus_destroy((LttvMenus
*)*(value
.v_pointer
));
3028 g_assert(lttv_iattribute_find_by_path(attributes
,
3029 "viewers/toolbar", LTTV_POINTER
, &value
));
3030 lttv_toolbars_destroy((LttvToolbars
*)*(value
.v_pointer
));
3032 g_object_unref(main_window
->attributes
);
3033 g_main_window_list
= g_slist_remove(g_main_window_list
, main_window
);
3035 g_printf("There are now : %d windows\n",g_slist_length(g_main_window_list
));
3036 if(g_slist_length(g_main_window_list
) == 0)
3041 on_MWindow_configure (GtkWidget
*widget
,
3042 GdkEventConfigure
*event
,
3045 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)widget
);
3046 float width
= event
->width
;
3047 TimeWindow time_win
;
3049 TimeInterval
*time_span
;
3052 // MD : removed time width modification upon resizing of the main window.
3053 // The viewers will redraw themselves completely, without time interval
3056 if(mw_data->window_width){
3057 time_span = LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->Time_Span ;
3058 time_win = tab->time_window;
3059 ratio = width / mw_data->window_width;
3060 tab->time_window.time_width = ltt_time_mul(time_win.time_width,ratio);
3061 time = ltt_time_sub(time_span->endTime, time_win.start_time);
3062 if(ltt_time_compare(time, tab->time_window.time_width) < 0){
3063 tab->time_window.time_width = time;
3069 mw_data->window_width = (int)width;
3078 on_MNotebook_switch_page (GtkNotebook
*notebook
,
3079 GtkNotebookPage
*page
,
3087 void scroll_value_changed_cb(GtkWidget
*scrollbar
,
3090 Tab
*tab
= (Tab
*)user_data
;
3091 TimeWindow time_window
;
3092 TimeInterval
*time_span
;
3094 GtkAdjustment
*adjust
= gtk_range_get_adjustment(GTK_RANGE(scrollbar
));
3095 gdouble value
= gtk_adjustment_get_value(adjust
);
3096 gdouble upper
, lower
, ratio
, page_size
;
3097 LttvTracesetContext
* tsc
=
3098 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3100 //time_window = tab->time_window;
3102 time_span
= &tsc
->time_span
;
3103 lower
= adjust
->lower
;
3104 upper
= adjust
->upper
;
3105 ratio
= (value
- lower
) / (upper
- lower
);
3106 g_info("lower %lu, upper %lu, value %lu, ratio %lu", lower
, upper
, value
, ratio
);
3108 //time = ltt_time_sub(time_span->end_time, time_span->start_time);
3109 //time = ltt_time_mul(time, (float)ratio);
3110 //time = ltt_time_add(time_span->start_time, time);
3111 time
= ltt_time_from_double(value
/NANOSECONDS_PER_SECOND
);
3113 time_window
.start_time
= time
;
3115 page_size
= adjust
->page_size
;
3117 time_window
.time_width
=
3118 ltt_time_from_double(page_size
/NANOSECONDS_PER_SECOND
);
3119 //time = ltt_time_sub(time_span->end_time, time);
3120 //if(ltt_time_compare(time,time_window.time_width) < 0){
3121 // time_window.time_width = time;
3124 /* call viewer hooks for new time window */
3125 set_time_window(tab
, &time_window
);
3130 /* callback function to check or uncheck the check box (filter)
3133 void checkbox_changed(GtkTreeView
*treeview
,
3135 GtkTreeViewColumn
*arg2
,
3138 GtkTreeStore
* store
= (GtkTreeStore
*)gtk_tree_view_get_model (treeview
);
3142 if (gtk_tree_model_get_iter ((GtkTreeModel
*)store
, &iter
, arg1
)){
3143 gtk_tree_model_get ((GtkTreeModel
*)store
, &iter
, CHECKBOX_COLUMN
, &value
, -1);
3144 value
= value
? FALSE
: TRUE
;
3145 gtk_tree_store_set (GTK_TREE_STORE (store
), &iter
, CHECKBOX_COLUMN
, value
, -1);
3151 /* According to user's selection, update selector(filter)
3154 void update_filter(LttvTracesetSelector
*s
, GtkTreeStore
*store
)
3156 GtkTreeIter iter
, child_iter
, child_iter1
, child_iter2
;
3157 int i
, j
, k
, nb_eventtype
;
3158 LttvTraceSelector
* trace
;
3159 LttvTracefileSelector
* tracefile
;
3160 LttvEventtypeSelector
* eventtype
;
3161 gboolean value
, value1
, value2
;
3163 if(gtk_tree_model_get_iter_first((GtkTreeModel
*)store
, &iter
)){
3166 trace
= lttv_traceset_selector_trace_get(s
, i
);
3167 nb_eventtype
= lttv_trace_selector_eventtype_number(trace
);
3168 gtk_tree_model_get ((GtkTreeModel
*)store
, &iter
, CHECKBOX_COLUMN
, &value
,-1);
3171 if(gtk_tree_model_iter_children ((GtkTreeModel
*)store
, &child_iter
, &iter
)){
3173 if(j
<1){//eventtype selector for trace
3174 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter
, CHECKBOX_COLUMN
, &value2
,-1);
3177 if(gtk_tree_model_iter_children ((GtkTreeModel
*)store
, &child_iter1
, &child_iter
)){
3179 eventtype
= lttv_trace_selector_eventtype_get(trace
,k
);
3180 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter1
, CHECKBOX_COLUMN
, &value2
,-1);
3181 lttv_eventtype_selector_set_selected(eventtype
,value2
);
3183 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &child_iter1
));
3186 }else{ //tracefile selector
3187 tracefile
= lttv_trace_selector_tracefile_get(trace
, j
- 1);
3188 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter
, CHECKBOX_COLUMN
, &value1
,-1);
3189 lttv_tracefile_selector_set_selected(tracefile
,value1
);
3191 gtk_tree_model_iter_children((GtkTreeModel
*)store
, &child_iter1
, &child_iter
); //eventtype selector
3192 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter1
, CHECKBOX_COLUMN
, &value2
,-1);
3195 if(gtk_tree_model_iter_children ((GtkTreeModel
*)store
, &child_iter2
, &child_iter1
)){
3196 do{//eventtype selector for tracefile
3197 eventtype
= lttv_tracefile_selector_eventtype_get(tracefile
,k
);
3198 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter2
, CHECKBOX_COLUMN
, &value2
,-1);
3199 lttv_eventtype_selector_set_selected(eventtype
,value2
);
3201 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &child_iter2
));
3207 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &child_iter
));
3210 lttv_trace_selector_set_selected(trace
,value
);
3212 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &iter
));
3217 /* Display a dialogue showing all eventtypes and traces, let user to select the interested
3218 * eventtypes, tracefiles and traces (filter)
3221 gboolean
get_filter_selection(LttvTracesetSelector
*s
,char *title
, char * column_title
)
3223 GtkWidget
* dialogue
;
3224 GtkTreeStore
* store
;
3226 GtkWidget
* scroll_win
;
3227 GtkCellRenderer
* renderer
;
3228 GtkTreeViewColumn
* column
;
3229 GtkTreeIter iter
, child_iter
, child_iter1
, child_iter2
;
3230 int i
, j
, k
, id
, nb_trace
, nb_tracefile
, nb_eventtype
;
3231 LttvTraceSelector
* trace
;
3232 LttvTracefileSelector
* tracefile
;
3233 LttvEventtypeSelector
* eventtype
;
3237 dialogue
= gtk_dialog_new_with_buttons(title
,
3240 GTK_STOCK_OK
,GTK_RESPONSE_ACCEPT
,
3241 GTK_STOCK_CANCEL
,GTK_RESPONSE_REJECT
,
3243 gtk_window_set_default_size((GtkWindow
*)dialogue
, 300, 500);
3245 store
= gtk_tree_store_new (TOTAL_COLUMNS
, G_TYPE_BOOLEAN
, G_TYPE_STRING
);
3246 tree
= gtk_tree_view_new_with_model (GTK_TREE_MODEL (store
));
3247 g_object_unref (G_OBJECT (store
));
3248 g_signal_connect (G_OBJECT (tree
), "row-activated",
3249 G_CALLBACK (checkbox_changed
),
3253 renderer
= gtk_cell_renderer_toggle_new ();
3254 gtk_cell_renderer_toggle_set_radio((GtkCellRendererToggle
*)renderer
, FALSE
);
3256 g_object_set (G_OBJECT (renderer
),"activatable", TRUE
, NULL
);
3258 column
= gtk_tree_view_column_new_with_attributes ("Checkbox",
3260 "active", CHECKBOX_COLUMN
,
3262 gtk_tree_view_column_set_alignment (column
, 0.5);
3263 gtk_tree_view_column_set_fixed_width (column
, 20);
3264 gtk_tree_view_append_column (GTK_TREE_VIEW (tree
), column
);
3266 renderer
= gtk_cell_renderer_text_new ();
3267 column
= gtk_tree_view_column_new_with_attributes (column_title
,
3269 "text", NAME_COLUMN
,
3271 gtk_tree_view_column_set_alignment (column
, 0.0);
3272 gtk_tree_view_append_column (GTK_TREE_VIEW (tree
), column
);
3273 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW (tree
), FALSE
);
3275 scroll_win
= gtk_scrolled_window_new (NULL
, NULL
);
3276 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win
),
3277 GTK_POLICY_AUTOMATIC
,GTK_POLICY_AUTOMATIC
);
3278 gtk_container_add (GTK_CONTAINER (scroll_win
), tree
);
3280 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), scroll_win
,TRUE
, TRUE
,0);
3282 gtk_widget_show(scroll_win
);
3283 gtk_widget_show(tree
);
3285 nb_trace
= lttv_traceset_selector_trace_number(s
);
3286 for(i
=0;i
<nb_trace
;i
++){
3287 trace
= lttv_traceset_selector_trace_get(s
, i
);
3288 name
= lttv_trace_selector_get_name(trace
);
3289 gtk_tree_store_append (store
, &iter
, NULL
);
3290 checked
= lttv_trace_selector_get_selected(trace
);
3291 gtk_tree_store_set (store
, &iter
,
3292 CHECKBOX_COLUMN
,checked
,
3296 gtk_tree_store_append (store
, &child_iter
, &iter
);
3297 gtk_tree_store_set (store
, &child_iter
,
3298 CHECKBOX_COLUMN
, checked
,
3299 NAME_COLUMN
,"eventtype",
3302 nb_eventtype
= lttv_trace_selector_eventtype_number(trace
);
3303 for(j
=0;j
<nb_eventtype
;j
++){
3304 eventtype
= lttv_trace_selector_eventtype_get(trace
,j
);
3305 name
= lttv_eventtype_selector_get_name(eventtype
);
3306 checked
= lttv_eventtype_selector_get_selected(eventtype
);
3307 gtk_tree_store_append (store
, &child_iter1
, &child_iter
);
3308 gtk_tree_store_set (store
, &child_iter1
,
3309 CHECKBOX_COLUMN
, checked
,
3314 nb_tracefile
= lttv_trace_selector_tracefile_number(trace
);
3315 for(j
=0;j
<nb_tracefile
;j
++){
3316 tracefile
= lttv_trace_selector_tracefile_get(trace
, j
);
3317 name
= lttv_tracefile_selector_get_name(tracefile
);
3318 gtk_tree_store_append (store
, &child_iter
, &iter
);
3319 checked
= lttv_tracefile_selector_get_selected(tracefile
);
3320 gtk_tree_store_set (store
, &child_iter
,
3321 CHECKBOX_COLUMN
, checked
,
3325 gtk_tree_store_append (store
, &child_iter1
, &child_iter
);
3326 gtk_tree_store_set (store
, &child_iter1
,
3327 CHECKBOX_COLUMN
, checked
,
3328 NAME_COLUMN
,"eventtype",
3331 for(k
=0;k
<nb_eventtype
;k
++){
3332 eventtype
= lttv_tracefile_selector_eventtype_get(tracefile
,k
);
3333 name
= lttv_eventtype_selector_get_name(eventtype
);
3334 checked
= lttv_eventtype_selector_get_selected(eventtype
);
3335 gtk_tree_store_append (store
, &child_iter2
, &child_iter1
);
3336 gtk_tree_store_set (store
, &child_iter2
,
3337 CHECKBOX_COLUMN
, checked
,
3344 id
= gtk_dialog_run(GTK_DIALOG(dialogue
));
3346 case GTK_RESPONSE_ACCEPT
:
3347 case GTK_RESPONSE_OK
:
3348 update_filter(s
, store
);
3349 gtk_widget_destroy(dialogue
);
3351 case GTK_RESPONSE_REJECT
:
3352 case GTK_RESPONSE_CANCEL
:
3354 gtk_widget_destroy(dialogue
);
3361 /* Select a trace which will be removed from traceset
3364 char * get_remove_trace(char ** all_trace_name
, int nb_trace
)
3366 return get_selection(all_trace_name
, nb_trace
,
3367 "Select a trace", "Trace pathname");
3371 /* Select a module which will be loaded
3374 char * get_load_module(char ** load_module_name
, int nb_module
)
3376 return get_selection(load_module_name
, nb_module
,
3377 "Select a module to load", "Module name");
3383 /* Select a module which will be unloaded
3386 char * get_unload_module(char ** loaded_module_name
, int nb_module
)
3388 return get_selection(loaded_module_name
, nb_module
,
3389 "Select a module to unload", "Module name");
3393 /* Display a dialogue which shows all selectable items, let user to
3394 * select one of them
3397 char * get_selection(char ** loaded_module_name
, int nb_module
,
3398 char *title
, char * column_title
)
3400 GtkWidget
* dialogue
;
3401 GtkWidget
* scroll_win
;
3403 GtkListStore
* store
;
3404 GtkTreeViewColumn
* column
;
3405 GtkCellRenderer
* renderer
;
3406 GtkTreeSelection
* select
;
3409 char * unload_module_name
= NULL
;
3411 dialogue
= gtk_dialog_new_with_buttons(title
,
3414 GTK_STOCK_OK
,GTK_RESPONSE_ACCEPT
,
3415 GTK_STOCK_CANCEL
,GTK_RESPONSE_REJECT
,
3417 gtk_window_set_default_size((GtkWindow
*)dialogue
, 500, 200);
3419 scroll_win
= gtk_scrolled_window_new (NULL
, NULL
);
3420 gtk_widget_show ( scroll_win
);
3421 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win
),
3422 GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
3424 store
= gtk_list_store_new (N_COLUMNS
,G_TYPE_STRING
);
3425 tree
= gtk_tree_view_new_with_model(GTK_TREE_MODEL (store
));
3426 gtk_widget_show ( tree
);
3427 g_object_unref (G_OBJECT (store
));
3429 renderer
= gtk_cell_renderer_text_new ();
3430 column
= gtk_tree_view_column_new_with_attributes (column_title
,
3432 "text", MODULE_COLUMN
,
3434 gtk_tree_view_column_set_alignment (column
, 0.5);
3435 gtk_tree_view_column_set_fixed_width (column
, 150);
3436 gtk_tree_view_append_column (GTK_TREE_VIEW (tree
), column
);
3438 select
= gtk_tree_view_get_selection (GTK_TREE_VIEW (tree
));
3439 gtk_tree_selection_set_mode (select
, GTK_SELECTION_SINGLE
);
3441 gtk_container_add (GTK_CONTAINER (scroll_win
), tree
);
3443 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), scroll_win
,TRUE
, TRUE
,0);
3445 for(i
=0;i
<nb_module
;i
++){
3446 gtk_list_store_append (store
, &iter
);
3447 gtk_list_store_set (store
, &iter
, MODULE_COLUMN
,loaded_module_name
[i
],-1);
3450 id
= gtk_dialog_run(GTK_DIALOG(dialogue
));
3452 case GTK_RESPONSE_ACCEPT
:
3453 case GTK_RESPONSE_OK
:
3454 if (gtk_tree_selection_get_selected (select
, (GtkTreeModel
**)&store
, &iter
)){
3455 gtk_tree_model_get ((GtkTreeModel
*)store
, &iter
, MODULE_COLUMN
, &unload_module_name
, -1);
3457 case GTK_RESPONSE_REJECT
:
3458 case GTK_RESPONSE_CANCEL
:
3460 gtk_widget_destroy(dialogue
);
3464 return unload_module_name
;
3468 /* Insert all menu entry and tool buttons into this main window
3473 void add_all_menu_toolbar_constructors(MainWindow
* mw
, gpointer user_data
)
3477 lttvwindow_viewer_constructor constructor
;
3478 LttvMenus
* global_menu
, * instance_menu
;
3479 LttvToolbars
* global_toolbar
, * instance_toolbar
;
3480 LttvMenuClosure
*menu_item
;
3481 LttvToolbarClosure
*toolbar_item
;
3482 LttvAttributeValue value
;
3483 LttvIAttribute
*global_attributes
= LTTV_IATTRIBUTE(lttv_global_attributes());
3484 LttvIAttribute
*attributes
= mw
->attributes
;
3485 GtkWidget
* tool_menu_title_menu
, *new_widget
, *pixmap
;
3487 g_assert(lttv_iattribute_find_by_path(global_attributes
,
3488 "viewers/menu", LTTV_POINTER
, &value
));
3489 if(*(value
.v_pointer
) == NULL
)
3490 *(value
.v_pointer
) = lttv_menus_new();
3491 global_menu
= (LttvMenus
*)*(value
.v_pointer
);
3493 g_assert(lttv_iattribute_find_by_path(attributes
,
3494 "viewers/menu", LTTV_POINTER
, &value
));
3495 if(*(value
.v_pointer
) == NULL
)
3496 *(value
.v_pointer
) = lttv_menus_new();
3497 instance_menu
= (LttvMenus
*)*(value
.v_pointer
);
3501 g_assert(lttv_iattribute_find_by_path(global_attributes
,
3502 "viewers/toolbar", LTTV_POINTER
, &value
));
3503 if(*(value
.v_pointer
) == NULL
)
3504 *(value
.v_pointer
) = lttv_toolbars_new();
3505 global_toolbar
= (LttvToolbars
*)*(value
.v_pointer
);
3507 g_assert(lttv_iattribute_find_by_path(attributes
,
3508 "viewers/toolbar", LTTV_POINTER
, &value
));
3509 if(*(value
.v_pointer
) == NULL
)
3510 *(value
.v_pointer
) = lttv_toolbars_new();
3511 instance_toolbar
= (LttvToolbars
*)*(value
.v_pointer
);
3513 /* Add missing menu entries to window instance */
3514 for(i
=0;i
<global_menu
->len
;i
++) {
3515 menu_item
= &g_array_index(global_menu
, LttvMenuClosure
, i
);
3517 //add menu_item to window instance;
3518 constructor
= menu_item
->con
;
3519 tool_menu_title_menu
= lookup_widget(mw
->mwindow
,"ToolMenuTitle_menu");
3521 gtk_menu_item_new_with_mnemonic (menu_item
->menu_text
);
3522 gtk_container_add (GTK_CONTAINER (tool_menu_title_menu
),
3524 g_signal_connect ((gpointer
) new_widget
, "activate",
3525 G_CALLBACK (insert_viewer_wrap
),
3527 gtk_widget_show (new_widget
);
3528 lttv_menus_add(instance_menu
, menu_item
->con
,
3529 menu_item
->menu_path
,
3530 menu_item
->menu_text
,
3535 /* Add missing toolbar entries to window instance */
3536 for(i
=0;i
<global_toolbar
->len
;i
++) {
3537 toolbar_item
= &g_array_index(global_toolbar
, LttvToolbarClosure
, i
);
3539 //add toolbar_item to window instance;
3540 constructor
= toolbar_item
->con
;
3541 tool_menu_title_menu
= lookup_widget(mw
->mwindow
,"MToolbar1");
3542 pixbuf
= gdk_pixbuf_new_from_xpm_data((const char**)toolbar_item
->pixmap
);
3543 pixmap
= gtk_image_new_from_pixbuf(pixbuf
);
3545 gtk_toolbar_append_element (GTK_TOOLBAR (tool_menu_title_menu
),
3546 GTK_TOOLBAR_CHILD_BUTTON
,
3549 toolbar_item
->tooltip
, NULL
,
3550 pixmap
, NULL
, NULL
);
3551 gtk_label_set_use_underline(
3552 GTK_LABEL (((GtkToolbarChild
*) (
3553 g_list_last (GTK_TOOLBAR
3554 (tool_menu_title_menu
)->children
)->data
))->label
),
3556 gtk_container_set_border_width (GTK_CONTAINER (new_widget
), 1);
3557 g_signal_connect ((gpointer
) new_widget
,
3559 G_CALLBACK (insert_viewer_wrap
),
3561 gtk_widget_show (new_widget
);
3563 lttv_toolbars_add(instance_toolbar
, toolbar_item
->con
,
3564 toolbar_item
->tooltip
,
3565 toolbar_item
->pixmap
,
3573 /* Create a main window
3576 void construct_main_window(MainWindow
* parent
)
3578 g_debug("construct_main_window()");
3579 GtkWidget
* new_window
; /* New generated main window */
3580 MainWindow
* new_m_window
;/* New main window structure */
3581 GtkNotebook
* notebook
;
3582 LttvIAttribute
*attributes
=
3583 LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
));
3584 LttvAttributeValue value
;
3587 new_m_window
= g_new(MainWindow
, 1);
3589 // Add the object's information to the module's array
3590 g_main_window_list
= g_slist_append(g_main_window_list
, new_m_window
);
3593 new_window
= create_MWindow();
3594 gtk_widget_show (new_window
);
3596 new_m_window
->mwindow
= new_window
;
3597 new_m_window
->attributes
= attributes
;
3599 g_assert(lttv_iattribute_find_by_path(attributes
,
3600 "viewers/menu", LTTV_POINTER
, &value
));
3601 *(value
.v_pointer
) = lttv_menus_new();
3603 g_assert(lttv_iattribute_find_by_path(attributes
,
3604 "viewers/toolbar", LTTV_POINTER
, &value
));
3605 *(value
.v_pointer
) = lttv_toolbars_new();
3607 add_all_menu_toolbar_constructors(new_m_window
, NULL
);
3609 g_object_set_data_full(G_OBJECT(new_window
),
3611 (gpointer
)new_m_window
,
3612 (GDestroyNotify
)g_free
);
3613 //create a default tab
3614 notebook
= (GtkNotebook
*)lookup_widget(new_m_window
->mwindow
, "MNotebook");
3615 if(notebook
== NULL
){
3616 g_printf("Notebook does not exist\n");
3619 gtk_notebook_popup_enable (GTK_NOTEBOOK(notebook
));
3620 //for now there is no name field in LttvTraceset structure
3621 //Use "Traceset" as the label for the default tab
3623 GtkWidget
* parent_notebook
= lookup_widget(parent
->mwindow
, "MNotebook");
3624 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(parent_notebook
),
3625 gtk_notebook_get_current_page(GTK_NOTEBOOK(parent_notebook
)));
3631 parent_tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
3633 new_tab
= create_tab(new_m_window
, parent_tab
, notebook
, "Traceset");
3635 new_tab
= create_tab(new_m_window
, NULL
, notebook
, "Traceset");
3636 /* First window, use command line trace */
3637 if(g_init_trace
!= NULL
){
3638 lttvwindow_add_trace(new_tab
,
3641 LttvTraceset
*traceset
= new_tab
->traceset_info
->traceset
;
3642 SetTraceset(new_tab
, traceset
);
3646 g_printf("There are now : %d windows\n",g_slist_length(g_main_window_list
));
3650 /* Free the memory occupied by a tab structure
3654 void tab_destructor(Tab
* tab_instance
)
3656 int i
, nb
, ref_count
;
3659 if(tab_instance
->attributes
)
3660 g_object_unref(tab_instance
->attributes
);
3662 if(tab_instance
->interrupted_state
)
3663 g_object_unref(tab_instance
->interrupted_state
);
3666 if(tab_instance
->traceset_info
->traceset_context
!= NULL
){
3667 //remove state update hooks
3668 lttv_state_remove_event_hooks(
3669 (LttvTracesetState
*)tab_instance
->traceset_info
->
3671 lttv_context_fini(LTTV_TRACESET_CONTEXT(tab_instance
->traceset_info
->
3673 g_object_unref(tab_instance
->traceset_info
->traceset_context
);
3675 if(tab_instance
->traceset_info
->traceset
!= NULL
) {
3676 nb
= lttv_traceset_number(tab_instance
->traceset_info
->traceset
);
3677 for(i
= 0 ; i
< nb
; i
++) {
3678 trace
= lttv_traceset_get(tab_instance
->traceset_info
->traceset
, i
);
3679 ref_count
= lttv_trace_get_ref_number(trace
);
3681 ltt_trace_close(lttv_trace(trace
));
3685 lttv_traceset_destroy(tab_instance
->traceset_info
->traceset
);
3686 /* Remove the idle events requests processing function of the tab */
3687 g_idle_remove_by_data(tab_instance
);
3689 g_slist_free(tab_instance
->events_requests
);
3690 g_free(tab_instance
->traceset_info
);
3691 g_free(tab_instance
);
3695 /* Create a tab and insert it into the current main window
3698 Tab
* create_tab(MainWindow
* mw
, Tab
*copy_tab
,
3699 GtkNotebook
* notebook
, char * label
)
3705 //create a new tab data structure
3708 //construct and initialize the traceset_info
3709 tab
->traceset_info
= g_new(TracesetInfo
,1);
3712 tab
->traceset_info
->traceset
=
3713 lttv_traceset_copy(copy_tab
->traceset_info
->traceset
);
3715 tab
->traceset_info
->traceset
= lttv_traceset_new();
3719 lttv_attribute_write_xml(
3720 lttv_traceset_attribute(tab
->traceset_info
->traceset
),
3727 //FIXME copy not implemented in lower level
3728 tab
->traceset_info
->traceset_context
=
3729 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
3730 g_assert(tab
->traceset_info
->traceset_context
!= NULL
);
3732 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
),
3733 tab
->traceset_info
->traceset
);
3734 //add state update hooks
3735 lttv_state_add_event_hooks(
3736 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
3738 //determine the current_time and time_window of the tab
3739 if(copy_tab
!= NULL
){
3740 tab
->time_window
= copy_tab
->time_window
;
3741 tab
->current_time
= copy_tab
->current_time
;
3743 tab
->time_window
.start_time
=
3744 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
3745 time_span
.start_time
;
3746 if(DEFAULT_TIME_WIDTH_S
<
3747 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
3748 time_span
.end_time
.tv_sec
)
3749 tmp_time
.tv_sec
= DEFAULT_TIME_WIDTH_S
;
3752 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
3753 time_span
.end_time
.tv_sec
;
3754 tmp_time
.tv_nsec
= 0;
3755 tab
->time_window
.time_width
= tmp_time
;
3756 tab
->current_time
.tv_sec
=
3757 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
3758 time_span
.start_time
.tv_sec
;
3759 tab
->current_time
.tv_nsec
=
3760 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
3761 time_span
.start_time
.tv_nsec
;
3763 tab
->attributes
= LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
));
3764 tab
->interrupted_state
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
3766 tab
->vbox
= gtk_vbox_new(FALSE
, 2);
3767 tab
->viewer_container
= gtk_vbox_new(TRUE
, 2);
3768 tab
->scrollbar
= gtk_hscrollbar_new(NULL
);
3769 //tab->multivpaned = gtk_multi_vpaned_new();
3771 gtk_box_pack_start(GTK_BOX(tab
->vbox
),
3772 tab
->viewer_container
,
3774 TRUE
, /* Give the extra space to the child */
3775 0); /* No padding */
3777 gtk_box_pack_end(GTK_BOX(tab
->vbox
),
3779 FALSE
, /* Do not expand */
3780 FALSE
, /* Fill has no effect here (expand false) */
3781 0); /* No padding */
3783 g_object_set_data(G_OBJECT(tab
->viewer_container
), "focused_viewer", NULL
);
3789 // Display a label with a X
3790 GtkWidget *w_hbox = gtk_hbox_new(FALSE, 4);
3791 GtkWidget *w_label = gtk_label_new (label);
3792 GtkWidget *pixmap = create_pixmap(GTK_WIDGET(notebook), "close.png");
3793 GtkWidget *w_button = gtk_button_new ();
3794 gtk_container_add(GTK_CONTAINER(w_button), pixmap);
3795 //GtkWidget *w_button = gtk_button_new_with_label("x");
3797 gtk_button_set_relief(GTK_BUTTON(w_button), GTK_RELIEF_NONE);
3799 gtk_box_pack_start(GTK_BOX(w_hbox), w_label, TRUE, TRUE, 0);
3800 gtk_box_pack_end(GTK_BOX(w_hbox), w_button, FALSE,
3803 g_signal_connect_swapped (w_button, "clicked",
3804 G_CALLBACK (on_close_tab_X_clicked),
3807 gtk_widget_set_state(w_button, GTK_STATE_ACTIVE);
3809 gtk_widget_show (w_label);
3810 gtk_widget_show (pixmap);
3811 gtk_widget_show (w_button);
3812 gtk_widget_show (w_hbox);
3814 tab->label = w_hbox;
3818 tab
->label
= gtk_label_new (label
);
3820 gtk_widget_show(tab
->label
);
3821 gtk_widget_show(tab
->scrollbar
);
3822 gtk_widget_show(tab
->viewer_container
);
3823 gtk_widget_show(tab
->vbox
);
3824 //gtk_widget_show(tab->multivpaned);
3827 /* Start with empty events requests list */
3828 tab
->events_requests
= NULL
;
3829 tab
->events_request_pending
= FALSE
;
3831 g_object_set_data_full(
3832 G_OBJECT(tab
->vbox
),
3835 (GDestroyNotify
)tab_destructor
);
3837 g_signal_connect(G_OBJECT(tab
->scrollbar
), "value-changed",
3838 G_CALLBACK(scroll_value_changed_cb
), tab
);
3839 //g_signal_connect(G_OBJECT(tab->scrollbar), "changed",
3840 // G_CALLBACK(scroll_value_changed_cb), tab);
3843 //insert tab into notebook
3844 gtk_notebook_append_page(notebook
,
3847 list
= gtk_container_get_children(GTK_CONTAINER(notebook
));
3848 gtk_notebook_set_current_page(notebook
,g_list_length(list
)-1);
3849 // always show : not if(g_list_length(list)>1)
3850 gtk_notebook_set_show_tabs(notebook
, TRUE
);
3856 * execute_events_requests
3858 * Idle function that executes the pending requests for a tab.
3860 * @return return value : TRUE : keep the idle function, FALSE : remove it.
3862 gboolean
execute_events_requests(Tab
*tab
)
3864 return ( lttvwindow_process_pending_requests(tab
) );