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
31 #include "callbacks.h"
32 #include "interface.h"
34 #include <ltt/trace.h>
35 #include <ltt/facility.h>
37 #include <ltt/event.h>
38 #include <lttv/lttv.h>
39 #include <lttv/module.h>
40 #include <lttv/iattribute.h>
41 #include <lttv/stats.h>
42 #include <lttv/filter.h>
43 #include <lttvwindow/mainwindow.h>
44 #include <lttvwindow/mainwindow-private.h>
45 #include <lttvwindow/menu.h>
46 #include <lttvwindow/toolbar.h>
47 #include <lttvwindow/lttvwindow.h>
48 #include <lttvwindow/lttvwindowtraces.h>
51 static LttTime lttvwindow_default_time_width
= { 1, 0 };
52 #define CLIP_BUF 256 // size of clipboard buffer
54 extern LttvTrace
*g_init_trace
;
57 /** Array containing instanced objects. */
58 extern GSList
* g_main_window_list
;
60 /** MD : keep old directory. */
61 static char remember_plugins_dir
[PATH_MAX
] = "";
62 static char remember_trace_dir
[PATH_MAX
] = "";
65 MainWindow
* get_window_data_struct(GtkWidget
* widget
);
66 char * get_load_module(MainWindow
*mw
,
67 char ** load_module_name
, int nb_module
);
68 char * get_unload_module(MainWindow
*mw
,
69 char ** loaded_module_name
, int nb_module
);
70 char * get_remove_trace(MainWindow
*mw
, char ** all_trace_name
, int nb_trace
);
71 char * get_selection(MainWindow
*mw
,
72 char ** all_name
, int nb
, char *title
, char * column_title
);
73 Tab
* create_tab(MainWindow
* mw
, Tab
*copy_tab
,
74 GtkNotebook
* notebook
, char * label
);
76 static void insert_viewer(GtkWidget
* widget
, lttvwindow_viewer_constructor constructor
);
78 Tab
*create_new_tab(GtkWidget
* widget
, gpointer user_data
);
80 static gboolean
lttvwindow_process_pending_requests(Tab
*tab
);
94 /* Pasting routines */
96 static void MEventBox1a_receive(GtkClipboard
*clipboard
,
100 if(text
== NULL
) return;
101 Tab
*tab
= (Tab
*)data
;
102 gchar buffer
[CLIP_BUF
];
103 gchar
*ptr
= buffer
, *ptr_ssec
, *ptr_snsec
, *ptr_esec
, *ptr_ensec
;
105 strncpy(buffer
, text
, CLIP_BUF
);
108 while(!isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
109 /* remove leading junk */
111 while(isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
112 /* read all the first number */
116 while(!isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
117 /* remove leading junk */
119 while(isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
120 /* read all the first number */
124 while(!isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
125 /* remove leading junk */
127 while(isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
128 /* read all the first number */
132 while(!isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
133 /* remove leading junk */
135 while(isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
136 /* read all the first number */
139 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry1
),
140 (double)strtoul(ptr_ssec
, NULL
, 10));
141 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry2
),
142 (double)strtoul(ptr_snsec
, NULL
, 10));
143 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry3
),
144 (double)strtoul(ptr_esec
, NULL
, 10));
145 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry4
),
146 (double)strtoul(ptr_ensec
, NULL
, 10));
149 static gboolean
on_MEventBox1a_paste(GtkWidget
*widget
, GdkEventButton
*event
,
152 Tab
*tab
= (Tab
*)data
;
154 GtkClipboard
*clip
= gtk_clipboard_get_for_display(gdk_display_get_default(),
155 GDK_SELECTION_PRIMARY
);
156 gtk_clipboard_request_text(clip
,
157 (GtkClipboardTextReceivedFunc
)MEventBox1a_receive
,
164 static void MEventBox1b_receive(GtkClipboard
*clipboard
,
168 if(text
== NULL
) return;
169 Tab
*tab
= (Tab
*)data
;
170 gchar buffer
[CLIP_BUF
];
171 gchar
*ptr
= buffer
, *ptr_sec
, *ptr_nsec
;
173 strncpy(buffer
, text
, CLIP_BUF
);
175 while(!isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
176 /* remove leading junk */
178 while(isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
179 /* read all the first number */
183 while(!isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
184 /* remove leading junk */
186 while(isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
187 /* read all the first number */
190 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry1
),
191 (double)strtoul(ptr_sec
, NULL
, 10));
192 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry2
),
193 (double)strtoul(ptr_nsec
, NULL
, 10));
197 static gboolean
on_MEventBox1b_paste(GtkWidget
*widget
, GdkEventButton
*event
,
200 Tab
*tab
= (Tab
*)data
;
202 GtkClipboard
*clip
= gtk_clipboard_get_for_display(gdk_display_get_default(),
203 GDK_SELECTION_PRIMARY
);
204 gtk_clipboard_request_text(clip
,
205 (GtkClipboardTextReceivedFunc
)MEventBox1b_receive
,
211 static void MEventBox3b_receive(GtkClipboard
*clipboard
,
215 if(text
== NULL
) return;
216 Tab
*tab
= (Tab
*)data
;
217 gchar buffer
[CLIP_BUF
];
218 gchar
*ptr
= buffer
, *ptr_sec
, *ptr_nsec
;
220 strncpy(buffer
, text
, CLIP_BUF
);
222 while(!isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
223 /* remove leading junk */
225 while(isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
226 /* read all the first number */
230 while(!isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
231 /* remove leading junk */
233 while(isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
234 /* read all the first number */
237 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry3
),
238 (double)strtoul(ptr_sec
, NULL
, 10));
239 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry4
),
240 (double)strtoul(ptr_nsec
, NULL
, 10));
244 static gboolean
on_MEventBox3b_paste(GtkWidget
*widget
, GdkEventButton
*event
,
247 Tab
*tab
= (Tab
*)data
;
249 GtkClipboard
*clip
= gtk_clipboard_get_for_display(gdk_display_get_default(),
250 GDK_SELECTION_PRIMARY
);
251 gtk_clipboard_request_text(clip
,
252 (GtkClipboardTextReceivedFunc
)MEventBox3b_receive
,
258 static void MEventBox5b_receive(GtkClipboard
*clipboard
,
262 if(text
== NULL
) return;
263 Tab
*tab
= (Tab
*)data
;
264 gchar buffer
[CLIP_BUF
];
265 gchar
*ptr
= buffer
, *ptr_sec
, *ptr_nsec
;
267 strncpy(buffer
, text
, CLIP_BUF
);
269 while(!isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
270 /* remove leading junk */
272 while(isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
273 /* read all the first number */
277 while(!isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
278 /* remove leading junk */
280 while(isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
281 /* read all the first number */
284 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry5
),
285 (double)strtoul(ptr_sec
, NULL
, 10));
286 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry6
),
287 (double)strtoul(ptr_nsec
, NULL
, 10));
291 static gboolean
on_MEventBox5b_paste(GtkWidget
*widget
, GdkEventButton
*event
,
294 Tab
*tab
= (Tab
*)data
;
296 GtkClipboard
*clip
= gtk_clipboard_get_for_display(gdk_display_get_default(),
297 GDK_SELECTION_PRIMARY
);
298 gtk_clipboard_request_text(clip
,
299 (GtkClipboardTextReceivedFunc
)MEventBox5b_receive
,
305 static gboolean
viewer_grab_focus(GtkWidget
*widget
, GdkEventButton
*event
,
308 GtkWidget
*viewer
= GTK_WIDGET(data
);
309 GtkWidget
*viewer_container
= gtk_widget_get_parent(viewer
);
311 g_debug("FOCUS GRABBED");
312 g_object_set_data(G_OBJECT(viewer_container
), "focused_viewer", viewer
);
317 static void connect_focus_recursive(GtkWidget
*widget
,
320 if(GTK_IS_CONTAINER(widget
)) {
321 gtk_container_forall(GTK_CONTAINER(widget
),
322 (GtkCallback
)connect_focus_recursive
,
326 if(GTK_IS_TREE_VIEW(widget
)) {
327 gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(widget
), TRUE
);
329 gtk_widget_add_events(widget
, GDK_BUTTON_PRESS_MASK
);
330 g_signal_connect (G_OBJECT(widget
),
331 "button-press-event",
332 G_CALLBACK (viewer_grab_focus
),
336 /* Stop all the processings and call gtk_main_quit() */
337 static void mainwindow_quit()
339 lttvwindowtraces_unregister_requests(g_quark_from_string("stats"));
340 lttvwindowtraces_unregister_requests(g_quark_from_string("state"));
341 lttvwindowtraces_unregister_computation_hooks(g_quark_from_string("stats"));
342 lttvwindowtraces_unregister_computation_hooks(g_quark_from_string("state"));
348 /* insert_viewer function constructs an instance of a viewer first,
349 * then inserts the widget of the instance into the container of the
354 insert_viewer_wrap(GtkWidget
*menuitem
, gpointer user_data
)
356 insert_viewer((GtkWidget
*)menuitem
, (lttvwindow_viewer_constructor
)user_data
);
360 /* internal functions */
361 void insert_viewer(GtkWidget
* widget
, lttvwindow_viewer_constructor constructor
)
363 GtkWidget
* viewer_container
;
364 MainWindow
* mw_data
= get_window_data_struct(widget
);
365 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
367 TimeInterval
* time_interval
;
368 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
369 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
373 tab
= create_new_tab(widget
, NULL
);
375 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
378 viewer_container
= tab
->viewer_container
;
380 viewer
= (GtkWidget
*)constructor(tab
);
383 //gtk_multivpaned_widget_add(GTK_MULTIVPANED(multivpaned), viewer);
385 gtk_box_pack_end(GTK_BOX(viewer_container
),
391 /* We want to connect the viewer_grab_focus to EVERY
392 * child of this widget. The little trick is to get each child
393 * of each GTK_CONTAINER, even subchildren.
395 connect_focus_recursive(viewer
, viewer
);
400 * Function to set/update traceset for the viewers
401 * @param tab viewer's tab
402 * @param traceset traceset of the main window.
404 * 0 : traceset updated
405 * 1 : no traceset hooks to update; not an error.
408 int SetTraceset(Tab
* tab
, LttvTraceset
*traceset
)
410 LttvTracesetContext
*tsc
=
411 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
412 TimeInterval time_span
= tsc
->time_span
;
413 TimeWindow new_time_window
= tab
->time_window
;
414 LttTime new_current_time
= tab
->current_time
;
416 /* Set the tab's time window and current time if
418 if(ltt_time_compare(tab
->time_window
.start_time
, time_span
.start_time
) < 0
419 || ltt_time_compare(tab
->time_window
.end_time
,
420 time_span
.end_time
) > 0) {
421 new_time_window
.start_time
= time_span
.start_time
;
423 new_current_time
= time_span
.start_time
;
427 if(ltt_time_compare(lttvwindow_default_time_width
,
428 ltt_time_sub(time_span
.end_time
, time_span
.start_time
)) < 0
430 ltt_time_compare(time_span
.end_time
, time_span
.start_time
) == 0)
431 tmp_time
= lttvwindow_default_time_width
;
433 tmp_time
= time_span
.end_time
;
435 new_time_window
.time_width
= tmp_time
;
436 new_time_window
.time_width_double
= ltt_time_to_double(tmp_time
);
437 new_time_window
.end_time
= ltt_time_add(new_time_window
.start_time
,
438 new_time_window
.time_width
) ;
445 GtkAdjustment
*adjustment
= gtk_range_get_adjustment(GTK_RANGE(tab
->scrollbar
));
446 LttTime upper
= ltt_time_sub(time_span
.end_time
, time_span
.start_time
);
448 g_object_set(G_OBJECT(adjustment
),
452 ltt_time_to_double(upper
)
453 * NANOSECONDS_PER_SECOND
, /* upper */
455 ltt_time_to_double(tab
->time_window
.time_width
)
456 / SCROLL_STEP_PER_PAGE
457 * NANOSECONDS_PER_SECOND
, /* step increment */
459 ltt_time_to_double(tab
->time_window
.time_width
)
460 * NANOSECONDS_PER_SECOND
, /* page increment */
462 ltt_time_to_double(tab
->time_window
.time_width
)
463 * NANOSECONDS_PER_SECOND
, /* page size */
465 gtk_adjustment_changed(adjustment
);
467 g_object_set(G_OBJECT(adjustment
),
470 ltt_time_sub(tab
->time_window
.start_time
, time_span
.start_time
))
471 * NANOSECONDS_PER_SECOND
, /* value */
473 gtk_adjustment_value_changed(adjustment
);
475 /* set the time bar. The value callbacks will change their nsec themself */
477 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry1
),
478 (double)time_span
.start_time
.tv_sec
,
479 (double)time_span
.end_time
.tv_sec
);
482 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry3
),
483 (double)time_span
.start_time
.tv_sec
,
484 (double)time_span
.end_time
.tv_sec
);
486 /* current seconds */
487 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry5
),
488 (double)time_span
.start_time
.tv_sec
,
489 (double)time_span
.end_time
.tv_sec
);
492 /* Finally, call the update hooks of the viewers */
494 LttvAttributeValue value
;
498 g_assert( lttv_iattribute_find_by_path(tab
->attributes
,
499 "hooks/updatetraceset", LTTV_POINTER
, &value
));
501 tmp
= (LttvHooks
*)*(value
.v_pointer
);
502 if(tmp
== NULL
) retval
= 1;
503 else lttv_hooks_call(tmp
,traceset
);
505 time_change_manager(tab
, new_time_window
);
506 current_time_change_manager(tab
, new_current_time
);
512 * Function to set/update filter for the viewers
513 * @param tab viewer's tab
514 * @param filter filter of the main window.
517 * 0 : filters updated
518 * 1 : no filter hooks to update; not an error.
521 int SetFilter(Tab
* tab
, gpointer filter
)
524 LttvAttributeValue value
;
526 g_assert(lttv_iattribute_find_by_path(tab
->attributes
,
527 "hooks/updatefilter", LTTV_POINTER
, &value
));
529 tmp
= (LttvHooks
*)*(value
.v_pointer
);
531 if(tmp
== NULL
) return 1;
532 lttv_hooks_call(tmp
,filter
);
540 * Function to redraw each viewer belonging to the current tab
541 * @param tab viewer's tab
544 void update_traceset(Tab
*tab
)
546 LttvAttributeValue value
;
548 g_assert(lttv_iattribute_find_by_path(tab
->attributes
,
549 "hooks/updatetraceset", LTTV_POINTER
, &value
));
550 tmp
= (LttvHooks
*)*(value
.v_pointer
);
551 if(tmp
== NULL
) return;
552 lttv_hooks_call(tmp
, NULL
);
556 /* get_label function is used to get user input, it displays an input
557 * box, which allows user to input a string
560 void get_label_string (GtkWidget
* text
, gchar
* label
)
562 GtkEntry
* entry
= (GtkEntry
*)text
;
563 if(strlen(gtk_entry_get_text(entry
))!=0)
564 strcpy(label
,gtk_entry_get_text(entry
));
567 gboolean
get_label(MainWindow
* mw
, gchar
* str
, gchar
* dialogue_title
, gchar
* label_str
)
569 GtkWidget
* dialogue
;
574 dialogue
= gtk_dialog_new_with_buttons(dialogue_title
,NULL
,
576 GTK_STOCK_OK
,GTK_RESPONSE_ACCEPT
,
577 GTK_STOCK_CANCEL
,GTK_RESPONSE_REJECT
,
580 label
= gtk_label_new(label_str
);
581 gtk_widget_show(label
);
583 text
= gtk_entry_new();
584 gtk_widget_show(text
);
586 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), label
,TRUE
, TRUE
,0);
587 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), text
,FALSE
, FALSE
,0);
589 id
= gtk_dialog_run(GTK_DIALOG(dialogue
));
591 case GTK_RESPONSE_ACCEPT
:
592 get_label_string(text
,str
);
593 gtk_widget_destroy(dialogue
);
595 case GTK_RESPONSE_REJECT
:
597 gtk_widget_destroy(dialogue
);
604 /* get_window_data_struct function is actually a lookup function,
605 * given a widget which is in the tree of the main window, it will
606 * return the MainWindow data structure associated with main window
609 MainWindow
* get_window_data_struct(GtkWidget
* widget
)
612 MainWindow
* mw_data
;
614 mw
= lookup_widget(widget
, "MWindow");
616 g_info("Main window does not exist\n");
620 mw_data
= (MainWindow
*) g_object_get_data(G_OBJECT(mw
),"main_window_data");
622 g_warning("Main window data does not exist\n");
629 /* create_new_window function, just constructs a new main window
632 void create_new_window(GtkWidget
* widget
, gpointer user_data
, gboolean clone
)
634 MainWindow
* parent
= get_window_data_struct(widget
);
637 g_info("Clone : use the same traceset\n");
638 construct_main_window(parent
);
640 g_info("Empty : traceset is set to NULL\n");
641 construct_main_window(NULL
);
645 /* Get the currently focused viewer.
646 * If no viewer is focused, use the first one.
648 * If no viewer available, return NULL.
650 GtkWidget
*viewer_container_focus(GtkWidget
*container
)
654 widget
= (GtkWidget
*)g_object_get_data(G_OBJECT(container
),
658 g_debug("no widget focused");
659 GList
*children
= gtk_container_get_children(GTK_CONTAINER(container
));
662 widget
= GTK_WIDGET(children
->data
);
663 g_object_set_data(G_OBJECT(container
),
673 gint
viewer_container_position(GtkWidget
*container
, GtkWidget
*child
)
676 if(child
== NULL
) return -1;
680 memset(&value
, 0, sizeof(GValue
));
681 g_value_init(&value
, G_TYPE_INT
);
682 gtk_container_child_get_property(GTK_CONTAINER(container
),
686 pos
= g_value_get_int(&value
);
692 /* move_*_viewer functions move the selected view up/down in
696 void move_down_viewer(GtkWidget
* widget
, gpointer user_data
)
698 MainWindow
* mw
= get_window_data_struct(widget
);
699 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
701 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
702 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
708 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
711 //gtk_multivpaned_widget_move_up(GTK_MULTIVPANED(tab->multivpaned));
713 /* change the position in the vbox */
714 GtkWidget
*focus_widget
;
716 focus_widget
= viewer_container_focus(tab
->viewer_container
);
717 position
= viewer_container_position(tab
->viewer_container
, focus_widget
);
720 /* can move up one position */
721 gtk_box_reorder_child(GTK_BOX(tab
->viewer_container
),
728 void move_up_viewer(GtkWidget
* widget
, gpointer user_data
)
730 MainWindow
* mw
= get_window_data_struct(widget
);
731 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
733 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
734 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
740 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
743 //gtk_multivpaned_widget_move_down(GTK_MULTIVPANED(tab->multivpaned));
744 /* change the position in the vbox */
745 GtkWidget
*focus_widget
;
747 focus_widget
= viewer_container_focus(tab
->viewer_container
);
748 position
= viewer_container_position(tab
->viewer_container
, focus_widget
);
752 g_list_length(gtk_container_get_children(
753 GTK_CONTAINER(tab
->viewer_container
)))-1
755 /* can move down one position */
756 gtk_box_reorder_child(GTK_BOX(tab
->viewer_container
),
764 /* delete_viewer deletes the selected viewer in the current tab
767 void delete_viewer(GtkWidget
* widget
, gpointer user_data
)
769 MainWindow
* mw
= get_window_data_struct(widget
);
770 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
772 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
773 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
779 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
782 //gtk_multivpaned_widget_delete(GTK_MULTIVPANED(tab->multivpaned));
784 GtkWidget
*focus_widget
= viewer_container_focus(tab
->viewer_container
);
786 if(focus_widget
!= NULL
)
787 gtk_widget_destroy(focus_widget
);
789 g_object_set_data(G_OBJECT(tab
->viewer_container
), "focused_viewer", NULL
);
793 /* open_traceset will open a traceset saved in a file
794 * Right now, it is not finished yet, (not working)
798 void open_traceset(GtkWidget
* widget
, gpointer user_data
)
802 LttvTraceset
* traceset
;
803 MainWindow
* mw_data
= get_window_data_struct(widget
);
804 GtkFileSelection
* file_selector
=
805 (GtkFileSelection
*)gtk_file_selection_new("Select a traceset");
807 gtk_file_selection_hide_fileop_buttons(file_selector
);
809 gtk_window_set_transient_for(GTK_WINDOW(file_selector
),
810 GTK_WINDOW(mw_data
->mwindow
));
812 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
814 case GTK_RESPONSE_ACCEPT
:
815 case GTK_RESPONSE_OK
:
816 dir
= gtk_file_selection_get_selections (file_selector
);
817 traceset
= lttv_traceset_load(dir
[0]);
818 g_info("Open a trace set %s\n", dir
[0]);
821 case GTK_RESPONSE_REJECT
:
822 case GTK_RESPONSE_CANCEL
:
824 gtk_widget_destroy((GtkWidget
*)file_selector
);
830 /* lttvwindow_process_pending_requests
832 * This internal function gets called by g_idle, taking care of the pending
833 * requests. It is responsible for concatenation of time intervals and position
834 * requests. It does it with the following algorithm organizing process traceset
835 * calls. Here is the detailed description of the way it works :
837 * - Events Requests Servicing Algorithm
839 * Data structures necessary :
841 * List of requests added to context : list_in
842 * List of requests not added to context : list_out
847 * list_out : many events requests
849 * FIXME : insert rest of algorithm here
853 #define list_out tab->events_requests
855 gboolean
lttvwindow_process_pending_requests(Tab
*tab
)
858 LttvTracesetContext
*tsc
;
859 LttvTracefileContext
*tfc
;
860 GSList
*list_in
= NULL
;
864 LttvTracesetContextPosition
*end_position
;
867 g_critical("Foreground processing : tab does not exist. Processing removed.");
871 /* There is no events requests pending : we should never have been called! */
872 g_assert(g_slist_length(list_out
) != 0);
874 tsc
= LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
876 //set the cursor to be X shape, indicating that the computer is busy in doing its job
878 new = gdk_cursor_new(GDK_X_CURSOR
);
879 widget
= lookup_widget(tab
->mw
->mwindow
, "MToolbar1");
880 win
= gtk_widget_get_parent_window(widget
);
881 gdk_window_set_cursor(win
, new);
882 gdk_cursor_unref(new);
883 gdk_window_stick(win
);
884 gdk_window_unstick(win
);
887 g_debug("SIZE events req len : %d", g_slist_length(list_out
));
889 /* Preliminary check for no trace in traceset */
890 /* Unregister the routine if empty, empty list_out too */
891 if(lttv_traceset_number(tsc
->ts
) == 0) {
893 /* - For each req in list_out */
894 GSList
*iter
= list_out
;
896 while(iter
!= NULL
) {
898 gboolean remove
= FALSE
;
899 gboolean free_data
= FALSE
;
900 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
902 /* - Call end request for req */
903 if(events_request
->servicing
== TRUE
)
904 lttv_hooks_call(events_request
->after_request
, (gpointer
)tsc
);
906 /* - remove req from list_out */
907 /* Destroy the request */
914 GSList
*remove_iter
= iter
;
916 iter
= g_slist_next(iter
);
917 if(free_data
) events_request_free((EventsRequest
*)remove_iter
->data
);
918 list_out
= g_slist_remove_link(list_out
, remove_iter
);
919 } else { // not remove
920 iter
= g_slist_next(iter
);
925 /* 0.1 Lock Traces */
930 iter_trace
<lttv_traceset_number(tsc
->ts
);
932 LttvTrace
*trace_v
= lttv_traceset_get(tsc
->ts
, iter_trace
);
934 if(lttvwindowtraces_lock(trace_v
) != 0) {
935 g_critical("Foreground processing : Unable to get trace lock");
936 return TRUE
; /* Cannot get lock, try later */
941 /* 0.2 Seek tracefiles positions to context position */
942 //g_assert(lttv_process_traceset_seek_position(tsc, sync_position) == 0);
943 lttv_process_traceset_synchronize_tracefiles(tsc
);
946 /* Events processing algorithm implementation */
947 /* Warning : the gtk_events_pending takes a LOT of cpu time. So what we do
948 * instead is to leave the control to GTK and take it back.
950 /* A. Servicing loop */
951 //while( (g_slist_length(list_in) != 0 || g_slist_length(list_out) != 0)) {
952 if((g_slist_length(list_in
) != 0 || g_slist_length(list_out
) != 0)) {
954 /* 1. If list_in is empty (need a seek) */
955 if( g_slist_length(list_in
) == 0 ) {
957 /* list in is empty, need a seek */
959 /* 1.1 Add requests to list_in */
960 GSList
*ltime
= NULL
;
964 /* 1.1.1 Find all time requests with the lowest start time in list_out
967 if(g_slist_length(list_out
) > 0)
968 ltime
= g_slist_append(ltime
, g_slist_nth_data(list_out
, 0));
969 for(iter
=g_slist_nth(list_out
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
970 /* Find all time requests with the lowest start time in list_out */
971 EventsRequest
*event_request_ltime
= (EventsRequest
*)g_slist_nth_data(ltime
, 0);
972 EventsRequest
*event_request_list_out
= (EventsRequest
*)iter
->data
;
975 comp
= ltt_time_compare(event_request_ltime
->start_time
,
976 event_request_list_out
->start_time
);
978 ltime
= g_slist_append(ltime
, event_request_list_out
);
980 /* Remove all elements from ltime, and add current */
982 ltime
= g_slist_delete_link(ltime
, g_slist_nth(ltime
, 0));
983 ltime
= g_slist_append(ltime
, event_request_list_out
);
987 /* 1.1.2 Find all position requests with the lowest position in list_out
990 if(g_slist_length(list_out
) > 0)
991 lpos
= g_slist_append(lpos
, g_slist_nth_data(list_out
, 0));
992 for(iter
=g_slist_nth(list_out
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
993 /* Find all position requests with the lowest position in list_out */
994 EventsRequest
*event_request_lpos
= (EventsRequest
*)g_slist_nth_data(lpos
, 0);
995 EventsRequest
*event_request_list_out
= (EventsRequest
*)iter
->data
;
998 if(event_request_lpos
->start_position
!= NULL
999 && event_request_list_out
->start_position
!= NULL
)
1001 comp
= lttv_traceset_context_pos_pos_compare
1002 (event_request_lpos
->start_position
,
1003 event_request_list_out
->start_position
);
1008 lpos
= g_slist_append(lpos
, event_request_list_out
);
1010 /* Remove all elements from lpos, and add current */
1012 lpos
= g_slist_delete_link(lpos
, g_slist_nth(lpos
, 0));
1013 lpos
= g_slist_append(lpos
, event_request_list_out
);
1018 EventsRequest
*event_request_lpos
= (EventsRequest
*)g_slist_nth_data(lpos
, 0);
1019 EventsRequest
*event_request_ltime
= (EventsRequest
*)g_slist_nth_data(ltime
, 0);
1020 LttTime lpos_start_time
;
1022 if(event_request_lpos
!= NULL
1023 && event_request_lpos
->start_position
!= NULL
) {
1024 lpos_start_time
= lttv_traceset_context_position_get_time(
1025 event_request_lpos
->start_position
);
1028 /* 1.1.3 If lpos.start time < ltime */
1029 if(event_request_lpos
!= NULL
1030 && event_request_lpos
->start_position
!= NULL
1031 && ltt_time_compare(lpos_start_time
,
1032 event_request_ltime
->start_time
)<0) {
1033 /* Add lpos to list_in, remove them from list_out */
1034 for(iter
=lpos
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
1035 /* Add to list_in */
1036 EventsRequest
*event_request_lpos
=
1037 (EventsRequest
*)iter
->data
;
1039 list_in
= g_slist_append(list_in
, event_request_lpos
);
1040 /* Remove from list_out */
1041 list_out
= g_slist_remove(list_out
, event_request_lpos
);
1044 /* 1.1.4 (lpos.start time >= ltime) */
1045 /* Add ltime to list_in, remove them from list_out */
1047 for(iter
=ltime
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
1048 /* Add to list_in */
1049 EventsRequest
*event_request_ltime
=
1050 (EventsRequest
*)iter
->data
;
1052 list_in
= g_slist_append(list_in
, event_request_ltime
);
1053 /* Remove from list_out */
1054 list_out
= g_slist_remove(list_out
, event_request_ltime
);
1059 g_slist_free(ltime
);
1064 tfc
= lttv_traceset_context_get_current_tfc(tsc
);
1065 g_assert(g_slist_length(list_in
)>0);
1066 EventsRequest
*events_request
= g_slist_nth_data(list_in
, 0);
1069 /* 1.2.1 If first request in list_in is a time request */
1070 if(events_request
->start_position
== NULL
) {
1071 /* - If first req in list_in start time != current time */
1072 if(tfc
== NULL
|| ltt_time_compare(events_request
->start_time
,
1073 tfc
->timestamp
) != 0)
1074 /* - Seek to that time */
1075 g_debug("SEEK TIME : %lu, %lu", events_request
->start_time
.tv_sec
,
1076 events_request
->start_time
.tv_nsec
);
1077 //lttv_process_traceset_seek_time(tsc, events_request->start_time);
1078 lttv_state_traceset_seek_time_closest(LTTV_TRACESET_STATE(tsc
),
1079 events_request
->start_time
);
1081 /* Process the traceset with only state hooks */
1083 lttv_process_traceset_middle(tsc
,
1084 events_request
->start_time
,
1087 g_assert(seek_count
< LTTV_STATE_SAVE_INTERVAL
);
1093 LttvTracefileContext
*tfc
=
1094 lttv_traceset_context_get_current_tfc(tsc
);
1095 /* Else, the first request in list_in is a position request */
1096 /* If first req in list_in pos != current pos */
1097 g_assert(events_request
->start_position
!= NULL
);
1098 g_debug("SEEK POS time : %lu, %lu",
1099 lttv_traceset_context_position_get_time(
1100 events_request
->start_position
).tv_sec
,
1101 lttv_traceset_context_position_get_time(
1102 events_request
->start_position
).tv_nsec
);
1105 g_debug("SEEK POS context time : %lu, %lu",
1106 tfc
->timestamp
.tv_sec
,
1107 tfc
->timestamp
.tv_nsec
);
1109 g_debug("SEEK POS context time : %lu, %lu",
1110 ltt_time_infinite
.tv_sec
,
1111 ltt_time_infinite
.tv_nsec
);
1113 g_assert(events_request
->start_position
!= NULL
);
1114 if(lttv_traceset_context_ctx_pos_compare(tsc
,
1115 events_request
->start_position
) != 0) {
1116 /* 1.2.2.1 Seek to that position */
1117 g_debug("SEEK POSITION");
1118 //lttv_process_traceset_seek_position(tsc, events_request->start_position);
1119 pos_time
= lttv_traceset_context_position_get_time(
1120 events_request
->start_position
);
1122 lttv_state_traceset_seek_time_closest(LTTV_TRACESET_STATE(tsc
),
1125 /* Process the traceset with only state hooks */
1127 lttv_process_traceset_middle(tsc
,
1130 events_request
->start_position
);
1131 g_assert(lttv_traceset_context_ctx_pos_compare(tsc
,
1132 events_request
->start_position
) == 0);
1139 /* 1.3 Add hooks and call before request for all list_in members */
1141 GSList
*iter
= NULL
;
1143 for(iter
=list_in
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
1144 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1145 /* 1.3.1 If !servicing */
1146 if(events_request
->servicing
== FALSE
) {
1147 /* - begin request hooks called
1148 * - servicing = TRUE
1150 lttv_hooks_call(events_request
->before_request
, (gpointer
)tsc
);
1151 events_request
->servicing
= TRUE
;
1153 /* 1.3.2 call before chunk
1154 * 1.3.3 events hooks added
1156 if(events_request
->trace
== -1)
1157 lttv_process_traceset_begin(tsc
,
1158 events_request
->before_chunk_traceset
,
1159 events_request
->before_chunk_trace
,
1160 events_request
->before_chunk_tracefile
,
1161 events_request
->event
,
1162 events_request
->event_by_id
);
1164 guint nb_trace
= lttv_traceset_number(tsc
->ts
);
1165 g_assert((guint
)events_request
->trace
< nb_trace
&&
1166 events_request
->trace
> -1);
1167 LttvTraceContext
*tc
= tsc
->traces
[events_request
->trace
];
1169 lttv_hooks_call(events_request
->before_chunk_traceset
, tsc
);
1171 lttv_trace_context_add_hooks(tc
,
1172 events_request
->before_chunk_trace
,
1173 events_request
->before_chunk_tracefile
,
1174 events_request
->event
,
1175 events_request
->event_by_id
);
1180 /* 2. Else, list_in is not empty, we continue a read */
1183 /* 2.0 For each req of list_in */
1184 GSList
*iter
= list_in
;
1186 while(iter
!= NULL
) {
1188 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1190 /* - Call before chunk
1191 * - events hooks added
1193 if(events_request
->trace
== -1)
1194 lttv_process_traceset_begin(tsc
,
1195 events_request
->before_chunk_traceset
,
1196 events_request
->before_chunk_trace
,
1197 events_request
->before_chunk_tracefile
,
1198 events_request
->event
,
1199 events_request
->event_by_id
);
1201 guint nb_trace
= lttv_traceset_number(tsc
->ts
);
1202 g_assert((guint
)events_request
->trace
< nb_trace
&&
1203 events_request
->trace
> -1);
1204 LttvTraceContext
*tc
= tsc
->traces
[events_request
->trace
];
1206 lttv_hooks_call(events_request
->before_chunk_traceset
, tsc
);
1208 lttv_trace_context_add_hooks(tc
,
1209 events_request
->before_chunk_trace
,
1210 events_request
->before_chunk_tracefile
,
1211 events_request
->event
,
1212 events_request
->event_by_id
);
1215 iter
= g_slist_next(iter
);
1220 tfc
= lttv_traceset_context_get_current_tfc(tsc
);
1222 /* 2.1 For each req of list_out */
1223 GSList
*iter
= list_out
;
1225 while(iter
!= NULL
) {
1227 gboolean remove
= FALSE
;
1228 gboolean free_data
= FALSE
;
1229 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1231 /* if req.start time == current context time
1232 * or req.start position == current position*/
1233 if( ltt_time_compare(events_request
->start_time
,
1234 tfc
->timestamp
) == 0
1236 (events_request
->start_position
!= NULL
1238 lttv_traceset_context_ctx_pos_compare(tsc
,
1239 events_request
->start_position
) == 0)
1241 /* - Add to list_in, remove from list_out */
1242 list_in
= g_slist_append(list_in
, events_request
);
1246 /* - If !servicing */
1247 if(events_request
->servicing
== FALSE
) {
1248 /* - begin request hooks called
1249 * - servicing = TRUE
1251 lttv_hooks_call(events_request
->before_request
, (gpointer
)tsc
);
1252 events_request
->servicing
= TRUE
;
1254 /* call before chunk
1255 * events hooks added
1257 if(events_request
->trace
== -1)
1258 lttv_process_traceset_begin(tsc
,
1259 events_request
->before_chunk_traceset
,
1260 events_request
->before_chunk_trace
,
1261 events_request
->before_chunk_tracefile
,
1262 events_request
->event
,
1263 events_request
->event_by_id
);
1265 guint nb_trace
= lttv_traceset_number(tsc
->ts
);
1266 g_assert((guint
)events_request
->trace
< nb_trace
&&
1267 events_request
->trace
> -1);
1268 LttvTraceContext
*tc
= tsc
->traces
[events_request
->trace
];
1270 lttv_hooks_call(events_request
->before_chunk_traceset
, tsc
);
1272 lttv_trace_context_add_hooks(tc
,
1273 events_request
->before_chunk_trace
,
1274 events_request
->before_chunk_tracefile
,
1275 events_request
->event
,
1276 events_request
->event_by_id
);
1285 GSList
*remove_iter
= iter
;
1287 iter
= g_slist_next(iter
);
1288 if(free_data
) events_request_free((EventsRequest
*)remove_iter
->data
);
1289 list_out
= g_slist_remove_link(list_out
, remove_iter
);
1290 } else { // not remove
1291 iter
= g_slist_next(iter
);
1297 /* 3. Find end criterions */
1302 /* 3.1.1 Find lowest end time in list_in */
1303 g_assert(g_slist_length(list_in
)>0);
1304 end_time
= ((EventsRequest
*)g_slist_nth_data(list_in
,0))->end_time
;
1306 for(iter
=g_slist_nth(list_in
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
1307 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1309 if(ltt_time_compare(events_request
->end_time
,
1311 end_time
= events_request
->end_time
;
1314 /* 3.1.2 Find lowest start time in list_out */
1315 for(iter
=list_out
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
1316 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1318 if(ltt_time_compare(events_request
->start_time
,
1320 end_time
= events_request
->start_time
;
1325 /* 3.2 Number of events */
1327 /* 3.2.1 Find lowest number of events in list_in */
1330 end_nb_events
= ((EventsRequest
*)g_slist_nth_data(list_in
,0))->num_events
;
1332 for(iter
=g_slist_nth(list_in
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
1333 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1335 if(events_request
->num_events
< end_nb_events
)
1336 end_nb_events
= events_request
->num_events
;
1339 /* 3.2.2 Use min(CHUNK_NUM_EVENTS, min num events in list_in) as
1342 end_nb_events
= MIN(CHUNK_NUM_EVENTS
, end_nb_events
);
1346 /* 3.3 End position */
1348 /* 3.3.1 Find lowest end position in list_in */
1351 end_position
=((EventsRequest
*)g_slist_nth_data(list_in
,0))->end_position
;
1353 for(iter
=g_slist_nth(list_in
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
1354 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1356 if(events_request
->end_position
!= NULL
&& end_position
!= NULL
&&
1357 lttv_traceset_context_pos_pos_compare(events_request
->end_position
,
1359 end_position
= events_request
->end_position
;
1364 /* 3.3.2 Find lowest start position in list_out */
1367 for(iter
=list_out
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
1368 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1370 if(events_request
->end_position
!= NULL
&& end_position
!= NULL
&&
1371 lttv_traceset_context_pos_pos_compare(events_request
->end_position
,
1373 end_position
= events_request
->end_position
;
1378 /* 4. Call process traceset middle */
1379 g_debug("Calling process traceset middle with %p, %lu sec %lu nsec, %u nb ev, %p end pos", tsc
, end_time
.tv_sec
, end_time
.tv_nsec
, end_nb_events
, end_position
);
1380 count
= lttv_process_traceset_middle(tsc
, end_time
, end_nb_events
, end_position
);
1382 tfc
= lttv_traceset_context_get_current_tfc(tsc
);
1384 g_debug("Context time after middle : %lu, %lu", tfc
->timestamp
.tv_sec
,
1385 tfc
->timestamp
.tv_nsec
);
1387 g_debug("End of trace reached after middle.");
1391 /* 5. After process traceset middle */
1392 tfc
= lttv_traceset_context_get_current_tfc(tsc
);
1394 /* - if current context time > traceset.end time */
1395 if(tfc
== NULL
|| ltt_time_compare(tfc
->timestamp
,
1396 tsc
->time_span
.end_time
) > 0) {
1397 /* - For each req in list_in */
1398 GSList
*iter
= list_in
;
1400 while(iter
!= NULL
) {
1402 gboolean remove
= FALSE
;
1403 gboolean free_data
= FALSE
;
1404 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1406 /* - Remove events hooks for req
1407 * - Call end chunk for req
1410 if(events_request
->trace
== -1)
1411 lttv_process_traceset_end(tsc
,
1412 events_request
->after_chunk_traceset
,
1413 events_request
->after_chunk_trace
,
1414 events_request
->after_chunk_tracefile
,
1415 events_request
->event
,
1416 events_request
->event_by_id
);
1419 guint nb_trace
= lttv_traceset_number(tsc
->ts
);
1420 g_assert(events_request
->trace
< nb_trace
&&
1421 events_request
->trace
> -1);
1422 LttvTraceContext
*tc
= tsc
->traces
[events_request
->trace
];
1424 lttv_trace_context_remove_hooks(tc
,
1425 events_request
->after_chunk_trace
,
1426 events_request
->after_chunk_tracefile
,
1427 events_request
->event
,
1428 events_request
->event_by_id
);
1429 lttv_hooks_call(events_request
->after_chunk_traceset
, tsc
);
1434 /* - Call end request for req */
1435 lttv_hooks_call(events_request
->after_request
, (gpointer
)tsc
);
1437 /* - remove req from list_in */
1438 /* Destroy the request */
1445 GSList
*remove_iter
= iter
;
1447 iter
= g_slist_next(iter
);
1448 if(free_data
) events_request_free((EventsRequest
*)remove_iter
->data
);
1449 list_in
= g_slist_remove_link(list_in
, remove_iter
);
1450 } else { // not remove
1451 iter
= g_slist_next(iter
);
1456 /* 5.1 For each req in list_in */
1457 GSList
*iter
= list_in
;
1459 while(iter
!= NULL
) {
1461 gboolean remove
= FALSE
;
1462 gboolean free_data
= FALSE
;
1463 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1465 /* - Remove events hooks for req
1466 * - Call end chunk for req
1468 if(events_request
->trace
== -1)
1469 lttv_process_traceset_end(tsc
,
1470 events_request
->after_chunk_traceset
,
1471 events_request
->after_chunk_trace
,
1472 events_request
->after_chunk_tracefile
,
1473 events_request
->event
,
1474 events_request
->event_by_id
);
1477 guint nb_trace
= lttv_traceset_number(tsc
->ts
);
1478 g_assert(events_request
->trace
< nb_trace
&&
1479 events_request
->trace
> -1);
1480 LttvTraceContext
*tc
= tsc
->traces
[events_request
->trace
];
1482 lttv_trace_context_remove_hooks(tc
,
1483 events_request
->after_chunk_trace
,
1484 events_request
->after_chunk_tracefile
,
1485 events_request
->event
,
1486 events_request
->event_by_id
);
1488 lttv_hooks_call(events_request
->after_chunk_traceset
, tsc
);
1491 /* - req.num -= count */
1492 g_assert(events_request
->num_events
>= count
);
1493 events_request
->num_events
-= count
;
1495 g_assert(tfc
!= NULL
);
1496 /* - if req.num == 0
1498 * current context time >= req.end time
1500 * req.end pos == current pos
1502 * req.stop_flag == TRUE
1504 if( events_request
->num_events
== 0
1506 events_request
->stop_flag
== TRUE
1508 ltt_time_compare(tfc
->timestamp
,
1509 events_request
->end_time
) >= 0
1511 (events_request
->end_position
!= NULL
1513 lttv_traceset_context_ctx_pos_compare(tsc
,
1514 events_request
->end_position
) == 0)
1517 g_assert(events_request
->servicing
== TRUE
);
1518 /* - Call end request for req
1519 * - remove req from list_in */
1520 lttv_hooks_call(events_request
->after_request
, (gpointer
)tsc
);
1521 /* - remove req from list_in */
1522 /* Destroy the request */
1530 GSList
*remove_iter
= iter
;
1532 iter
= g_slist_next(iter
);
1533 if(free_data
) events_request_free((EventsRequest
*)remove_iter
->data
);
1534 list_in
= g_slist_remove_link(list_in
, remove_iter
);
1535 } else { // not remove
1536 iter
= g_slist_next(iter
);
1542 /* End of removed servicing loop : leave control to GTK instead. */
1543 // if(gtk_events_pending()) break;
1546 /* B. When interrupted between chunks */
1549 GSList
*iter
= list_in
;
1551 /* 1. for each request in list_in */
1552 while(iter
!= NULL
) {
1554 gboolean remove
= FALSE
;
1555 gboolean free_data
= FALSE
;
1556 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1558 /* 1.1. Use current postition as start position */
1559 if(events_request
->start_position
!= NULL
)
1560 lttv_traceset_context_position_destroy(events_request
->start_position
);
1561 events_request
->start_position
= lttv_traceset_context_position_new(tsc
);
1562 lttv_traceset_context_position_save(tsc
, events_request
->start_position
);
1564 /* 1.2. Remove start time */
1565 events_request
->start_time
= ltt_time_infinite
;
1567 /* 1.3. Move from list_in to list_out */
1570 list_out
= g_slist_append(list_out
, events_request
);
1575 GSList
*remove_iter
= iter
;
1577 iter
= g_slist_next(iter
);
1578 if(free_data
) events_request_free((EventsRequest
*)remove_iter
->data
);
1579 list_in
= g_slist_remove_link(list_in
, remove_iter
);
1580 } else { // not remove
1581 iter
= g_slist_next(iter
);
1587 /* C Unlock Traces */
1589 lttv_process_traceset_get_sync_data(tsc
);
1590 //lttv_traceset_context_position_save(tsc, sync_position);
1595 iter_trace
<lttv_traceset_number(tsc
->ts
);
1597 LttvTrace
*trace_v
= lttv_traceset_get(tsc
->ts
, iter_trace
);
1599 lttvwindowtraces_unlock(trace_v
);
1603 //set the cursor back to normal
1604 gdk_window_set_cursor(win
, NULL
);
1607 g_assert(g_slist_length(list_in
) == 0);
1609 if( g_slist_length(list_out
) == 0 ) {
1610 /* Put tab's request pending flag back to normal */
1611 tab
->events_request_pending
= FALSE
;
1612 g_debug("remove the idle fct");
1613 return FALSE
; /* Remove the idle function */
1615 g_debug("leave the idle fct");
1616 return TRUE
; /* Leave the idle function */
1618 /* We do not use simili-round-robin, it may require to read 1 meg buffers
1619 * again and again if many tracesets use the same tracefiles. */
1620 /* Hack for round-robin idle functions */
1621 /* It will put the idle function at the end of the pool */
1622 /*g_idle_add_full((G_PRIORITY_HIGH_IDLE + 21),
1623 (GSourceFunc)execute_events_requests,
1633 static void lttvwindow_add_trace(Tab
*tab
, LttvTrace
*trace_v
)
1635 LttvTraceset
*traceset
= tab
->traceset_info
->traceset
;
1637 guint num_traces
= lttv_traceset_number(traceset
);
1639 //Verify if trace is already present.
1640 for(i
=0; i
<num_traces
; i
++)
1642 LttvTrace
* trace
= lttv_traceset_get(traceset
, i
);
1643 if(trace
== trace_v
)
1647 //Keep a reference to the traces so they are not freed.
1648 for(i
=0; i
<lttv_traceset_number(traceset
); i
++)
1650 LttvTrace
* trace
= lttv_traceset_get(traceset
, i
);
1651 lttv_trace_ref(trace
);
1654 //remove state update hooks
1655 lttv_state_remove_event_hooks(
1656 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1658 lttv_context_fini(LTTV_TRACESET_CONTEXT(
1659 tab
->traceset_info
->traceset_context
));
1660 g_object_unref(tab
->traceset_info
->traceset_context
);
1662 lttv_traceset_add(traceset
, trace_v
);
1663 lttv_trace_ref(trace_v
); /* local ref */
1665 /* Create new context */
1666 tab
->traceset_info
->traceset_context
=
1667 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
1669 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->
1674 //add state update hooks
1675 lttv_state_add_event_hooks(
1676 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1677 //Remove local reference to the traces.
1678 for(i
=0; i
<lttv_traceset_number(traceset
); i
++)
1680 LttvTrace
* trace
= lttv_traceset_get(traceset
, i
);
1681 lttv_trace_unref(trace
);
1685 //add_trace_into_traceset_selector(GTK_MULTIVPANED(tab->multivpaned), lttv_trace(trace_v));
1688 /* add_trace adds a trace into the current traceset. It first displays a
1689 * directory selection dialogue to let user choose a trace, then recreates
1690 * tracset_context, and redraws all the viewer of the current tab
1693 void add_trace(GtkWidget
* widget
, gpointer user_data
)
1696 LttvTrace
* trace_v
;
1697 LttvTraceset
* traceset
;
1699 char abs_path
[PATH_MAX
];
1701 MainWindow
* mw_data
= get_window_data_struct(widget
);
1702 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
1704 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1705 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1709 tab
= create_new_tab(widget
, NULL
);
1711 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1714 //GtkDirSelection * file_selector = (GtkDirSelection *)gtk_dir_selection_new("Select a trace");
1715 GtkFileSelection
* file_selector
= (GtkFileSelection
*)gtk_file_selection_new("Select a trace");
1716 gtk_widget_hide( (file_selector
)->file_list
->parent
) ;
1717 gtk_file_selection_hide_fileop_buttons(file_selector
);
1718 gtk_window_set_transient_for(GTK_WINDOW(file_selector
),
1719 GTK_WINDOW(mw_data
->mwindow
));
1721 if(remember_trace_dir
[0] != '\0')
1722 gtk_file_selection_set_filename(file_selector
, remember_trace_dir
);
1724 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
1726 case GTK_RESPONSE_ACCEPT
:
1727 case GTK_RESPONSE_OK
:
1728 dir
= gtk_file_selection_get_filename (file_selector
);
1729 strncpy(remember_trace_dir
, dir
, PATH_MAX
);
1730 strncat(remember_trace_dir
, "/", PATH_MAX
);
1731 if(!dir
|| strlen(dir
) == 0){
1732 gtk_widget_destroy((GtkWidget
*)file_selector
);
1735 get_absolute_pathname(dir
, abs_path
);
1736 trace_v
= lttvwindowtraces_get_trace_by_name(abs_path
);
1737 if(trace_v
== NULL
) {
1738 trace
= ltt_trace_open(abs_path
);
1740 g_warning("cannot open trace %s", abs_path
);
1742 GtkWidget
*dialogue
=
1743 gtk_message_dialog_new(
1744 GTK_WINDOW(gtk_widget_get_toplevel(widget
)),
1745 GTK_DIALOG_MODAL
|GTK_DIALOG_DESTROY_WITH_PARENT
,
1748 "Cannot open trace : maybe you should enter in the trace "
1749 "directory to select it ?");
1750 gtk_dialog_run(GTK_DIALOG(dialogue
));
1751 gtk_widget_destroy(dialogue
);
1754 trace_v
= lttv_trace_new(trace
);
1755 lttvwindowtraces_add_trace(trace_v
);
1756 lttvwindow_add_trace(tab
, trace_v
);
1759 lttvwindow_add_trace(tab
, trace_v
);
1762 gtk_widget_destroy((GtkWidget
*)file_selector
);
1764 //update current tab
1765 //update_traceset(mw_data);
1767 /* Call the updatetraceset hooks */
1769 traceset
= tab
->traceset_info
->traceset
;
1770 SetTraceset(tab
, traceset
);
1771 // in expose now call_pending_read_hooks(mw_data);
1773 //lttvwindow_report_current_time(mw_data,&(tab->current_time));
1775 case GTK_RESPONSE_REJECT
:
1776 case GTK_RESPONSE_CANCEL
:
1778 gtk_widget_destroy((GtkWidget
*)file_selector
);
1783 /* remove_trace removes a trace from the current traceset if all viewers in
1784 * the current tab are not interested in the trace. It first displays a
1785 * dialogue, which shows all traces in the current traceset, to let user choose
1786 * a trace, then it checks if all viewers unselect the trace, if it is true,
1787 * it will remove the trace, recreate the traceset_contex,
1788 * and redraws all the viewer of the current tab. If there is on trace in the
1789 * current traceset, it will delete all viewers of the current tab
1791 * It destroys the filter tree. FIXME... we should request for an update
1795 void remove_trace(GtkWidget
*widget
, gpointer user_data
)
1798 LttvTrace
* trace_v
;
1799 LttvTraceset
* traceset
;
1800 gint i
, j
, nb_trace
, index
=-1;
1801 char ** name
, *remove_trace_name
;
1802 MainWindow
* mw_data
= get_window_data_struct(widget
);
1803 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
1805 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1806 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1812 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1815 nb_trace
=lttv_traceset_number(tab
->traceset_info
->traceset
);
1816 name
= g_new(char*,nb_trace
);
1817 for(i
= 0; i
< nb_trace
; i
++){
1818 trace_v
= lttv_traceset_get(tab
->traceset_info
->traceset
, i
);
1819 trace
= lttv_trace(trace_v
);
1820 name
[i
] = g_quark_to_string(ltt_trace_name(trace
));
1823 remove_trace_name
= get_remove_trace(mw_data
, name
, nb_trace
);
1826 if(remove_trace_name
){
1828 /* yuk, cut n paste from old code.. should be better (MD)*/
1829 for(i
= 0; i
<nb_trace
; i
++) {
1830 if(strcmp(remove_trace_name
,name
[i
]) == 0){
1835 traceset
= tab
->traceset_info
->traceset
;
1836 //Keep a reference to the traces so they are not freed.
1837 for(j
=0; j
<lttv_traceset_number(traceset
); j
++)
1839 LttvTrace
* trace
= lttv_traceset_get(traceset
, j
);
1840 lttv_trace_ref(trace
);
1843 //remove state update hooks
1844 lttv_state_remove_event_hooks(
1845 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1846 lttv_context_fini(LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
));
1847 g_object_unref(tab
->traceset_info
->traceset_context
);
1849 trace_v
= lttv_traceset_get(traceset
, index
);
1851 lttv_traceset_remove(traceset
, index
);
1852 lttv_trace_unref(trace_v
); // Remove local reference
1854 if(lttv_trace_get_ref_number(trace_v
) <= 1) {
1855 /* ref 1 : lttvwindowtraces only*/
1856 ltt_trace_close(lttv_trace(trace_v
));
1857 /* lttvwindowtraces_remove_trace takes care of destroying
1858 * the traceset linked with the trace_v and also of destroying
1859 * the trace_v at the same time.
1861 lttvwindowtraces_remove_trace(trace_v
);
1864 tab
->traceset_info
->traceset_context
=
1865 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
1867 LTTV_TRACESET_CONTEXT(tab
->
1868 traceset_info
->traceset_context
),traceset
);
1869 //add state update hooks
1870 lttv_state_add_event_hooks(
1871 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1873 //Remove local reference to the traces.
1874 for(j
=0; j
<lttv_traceset_number(traceset
); j
++)
1876 LttvTrace
* trace
= lttv_traceset_get(traceset
, j
);
1877 lttv_trace_unref(trace
);
1880 SetTraceset(tab
, (gpointer
)traceset
);
1886 void remove_trace(GtkWidget
* widget
, gpointer user_data
)
1889 LttvTrace
* trace_v
;
1890 LttvTraceset
* traceset
;
1891 gint i
, j
, nb_trace
;
1892 char ** name
, *remove_trace_name
;
1893 MainWindow
* mw_data
= get_window_data_struct(widget
);
1894 LttvTracesetSelector
* s
;
1895 LttvTraceSelector
* t
;
1898 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
1900 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1901 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1907 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1910 nb_trace
=lttv_traceset_number(tab
->traceset_info
->traceset
);
1911 name
= g_new(char*,nb_trace
);
1912 for(i
= 0; i
< nb_trace
; i
++){
1913 trace_v
= lttv_traceset_get(tab
->traceset_info
->traceset
, i
);
1914 trace
= lttv_trace(trace_v
);
1915 name
[i
] = ltt_trace_name(trace
);
1918 remove_trace_name
= get_remove_trace(name
, nb_trace
);
1920 if(remove_trace_name
){
1921 for(i
=0; i
<nb_trace
; i
++){
1922 if(strcmp(remove_trace_name
,name
[i
]) == 0){
1923 //unselect the trace from the current viewer
1925 w
= gtk_multivpaned_get_widget(GTK_MULTIVPANED(tab
->multivpaned
));
1927 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
1929 t
= lttv_traceset_selector_trace_get(s
,i
);
1930 lttv_trace_selector_set_selected(t
, FALSE
);
1933 //check if other viewers select the trace
1934 w
= gtk_multivpaned_get_first_widget(GTK_MULTIVPANED(tab
->multivpaned
));
1936 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
1938 t
= lttv_traceset_selector_trace_get(s
,i
);
1939 selected
= lttv_trace_selector_get_selected(t
);
1942 w
= gtk_multivpaned_get_next_widget(GTK_MULTIVPANED(tab
->multivpaned
));
1944 }else selected
= FALSE
;
1946 //if no viewer selects the trace, remove it
1948 remove_trace_from_traceset_selector(GTK_MULTIVPANED(tab
->multivpaned
), i
);
1950 traceset
= tab
->traceset_info
->traceset
;
1951 //Keep a reference to the traces so they are not freed.
1952 for(j
=0; j
<lttv_traceset_number(traceset
); j
++)
1954 LttvTrace
* trace
= lttv_traceset_get(traceset
, j
);
1955 lttv_trace_ref(trace
);
1958 //remove state update hooks
1959 lttv_state_remove_event_hooks(
1960 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1961 lttv_context_fini(LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
));
1962 g_object_unref(tab
->traceset_info
->traceset_context
);
1965 trace_v
= lttv_traceset_get(traceset
, i
);
1967 if(lttv_trace_get_ref_number(trace_v
) <= 2) {
1968 /* ref 2 : traceset, local */
1969 lttvwindowtraces_remove_trace(trace_v
);
1970 ltt_trace_close(lttv_trace(trace_v
));
1973 lttv_traceset_remove(traceset
, i
);
1974 lttv_trace_unref(trace_v
); // Remove local reference
1976 if(!lttv_trace_get_ref_number(trace_v
))
1977 lttv_trace_destroy(trace_v
);
1979 tab
->traceset_info
->traceset_context
=
1980 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
1982 LTTV_TRACESET_CONTEXT(tab
->
1983 traceset_info
->traceset_context
),traceset
);
1984 //add state update hooks
1985 lttv_state_add_event_hooks(
1986 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1988 //Remove local reference to the traces.
1989 for(j
=0; j
<lttv_traceset_number(traceset
); j
++)
1991 LttvTrace
* trace
= lttv_traceset_get(traceset
, j
);
1992 lttv_trace_unref(trace
);
1996 //update current tab
1997 //update_traceset(mw_data);
2000 SetTraceset(tab
, (gpointer
)traceset
);
2001 // in expose now call_pending_read_hooks(mw_data);
2003 //lttvwindow_report_current_time(mw_data,&(tab->current_time));
2006 // while(tab->multi_vpaned->num_children){
2007 // gtk_multi_vpaned_widget_delete(tab->multi_vpaned);
2021 /* Redraw all the viewers in the current tab */
2022 void redraw(GtkWidget
*widget
, gpointer user_data
)
2024 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
2025 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
2026 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
2031 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
2035 LttvAttributeValue value
;
2037 g_assert(lttv_iattribute_find_by_path(tab
->attributes
, "hooks/redraw", LTTV_POINTER
, &value
));
2039 tmp
= (LttvHooks
*)*(value
.v_pointer
);
2041 lttv_hooks_call(tmp
,NULL
);
2045 void continue_processing(GtkWidget
*widget
, gpointer user_data
)
2047 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
2048 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
2049 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
2054 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
2058 LttvAttributeValue value
;
2060 g_assert(lttv_iattribute_find_by_path(tab
->attributes
,
2061 "hooks/continue", LTTV_POINTER
, &value
));
2063 tmp
= (LttvHooks
*)*(value
.v_pointer
);
2065 lttv_hooks_call(tmp
,NULL
);
2068 /* Stop the processing for the calling main window's current tab.
2069 * It removes every processing requests that are in its list. It does not call
2070 * the end request hooks, because the request is not finished.
2073 void stop_processing(GtkWidget
*widget
, gpointer user_data
)
2075 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
2076 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
2077 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
2082 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
2084 GSList
*iter
= tab
->events_requests
;
2086 while(iter
!= NULL
) {
2087 GSList
*remove_iter
= iter
;
2088 iter
= g_slist_next(iter
);
2090 g_free(remove_iter
->data
);
2091 tab
->events_requests
=
2092 g_slist_remove_link(tab
->events_requests
, remove_iter
);
2094 tab
->events_request_pending
= FALSE
;
2095 g_idle_remove_by_data(tab
);
2096 g_assert(g_slist_length(tab
->events_requests
) == 0);
2100 /* save will save the traceset to a file
2101 * Not implemented yet FIXME
2104 void save(GtkWidget
* widget
, gpointer user_data
)
2109 void save_as(GtkWidget
* widget
, gpointer user_data
)
2111 g_info("Save as\n");
2115 /* zoom will change the time_window of all the viewers of the
2116 * current tab, and redisplay them. The main functionality is to
2117 * determine the new time_window of the current tab
2120 void zoom(GtkWidget
* widget
, double size
)
2122 TimeInterval time_span
;
2123 TimeWindow new_time_window
;
2124 LttTime current_time
, time_delta
;
2125 MainWindow
* mw_data
= get_window_data_struct(widget
);
2126 LttvTracesetContext
*tsc
;
2127 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
2129 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
2130 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
2136 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
2139 if(size
== 1) return;
2141 tsc
= LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
2142 time_span
= tsc
->time_span
;
2143 new_time_window
= tab
->time_window
;
2144 current_time
= tab
->current_time
;
2146 time_delta
= ltt_time_sub(time_span
.end_time
,time_span
.start_time
);
2148 new_time_window
.start_time
= time_span
.start_time
;
2149 new_time_window
.time_width
= time_delta
;
2150 new_time_window
.time_width_double
= ltt_time_to_double(time_delta
);
2151 new_time_window
.end_time
= ltt_time_add(new_time_window
.start_time
,
2152 new_time_window
.time_width
) ;
2154 new_time_window
.time_width
= ltt_time_div(new_time_window
.time_width
, size
);
2155 new_time_window
.time_width_double
=
2156 ltt_time_to_double(new_time_window
.time_width
);
2157 if(ltt_time_compare(new_time_window
.time_width
,time_delta
) > 0)
2158 { /* Case where zoom out is bigger than trace length */
2159 new_time_window
.start_time
= time_span
.start_time
;
2160 new_time_window
.time_width
= time_delta
;
2161 new_time_window
.time_width_double
= ltt_time_to_double(time_delta
);
2162 new_time_window
.end_time
= ltt_time_add(new_time_window
.start_time
,
2163 new_time_window
.time_width
) ;
2167 /* Center the image on the current time */
2168 new_time_window
.start_time
=
2169 ltt_time_sub(current_time
,
2170 ltt_time_from_double(new_time_window
.time_width_double
/2.0));
2171 new_time_window
.end_time
= ltt_time_add(new_time_window
.start_time
,
2172 new_time_window
.time_width
) ;
2173 /* If on borders, don't fall off */
2174 if(ltt_time_compare(new_time_window
.start_time
, time_span
.start_time
) <0
2175 || ltt_time_compare(new_time_window
.start_time
, time_span
.end_time
) >0)
2177 new_time_window
.start_time
= time_span
.start_time
;
2178 new_time_window
.end_time
= ltt_time_add(new_time_window
.start_time
,
2179 new_time_window
.time_width
) ;
2183 if(ltt_time_compare(new_time_window
.end_time
,
2184 time_span
.end_time
) > 0
2185 || ltt_time_compare(new_time_window
.end_time
,
2186 time_span
.start_time
) < 0)
2188 new_time_window
.start_time
=
2189 ltt_time_sub(time_span
.end_time
, new_time_window
.time_width
);
2191 new_time_window
.end_time
= ltt_time_add(new_time_window
.start_time
,
2192 new_time_window
.time_width
) ;
2199 if(ltt_time_compare(new_time_window
.time_width
, ltt_time_zero
) == 0) {
2200 g_warning("Zoom more than 1 ns impossible");
2202 time_change_manager(tab
, new_time_window
);
2206 void zoom_in(GtkWidget
* widget
, gpointer user_data
)
2211 void zoom_out(GtkWidget
* widget
, gpointer user_data
)
2216 void zoom_extended(GtkWidget
* widget
, gpointer user_data
)
2221 void go_to_time(GtkWidget
* widget
, gpointer user_data
)
2223 g_info("Go to time\n");
2226 void show_time_frame(GtkWidget
* widget
, gpointer user_data
)
2228 g_info("Show time frame\n");
2232 /* callback function */
2235 on_empty_traceset_activate (GtkMenuItem
*menuitem
,
2238 create_new_window((GtkWidget
*)menuitem
, user_data
, FALSE
);
2243 on_clone_traceset_activate (GtkMenuItem
*menuitem
,
2246 create_new_window((GtkWidget
*)menuitem
, user_data
, TRUE
);
2250 /* create_new_tab calls create_tab to construct a new tab in the main window
2253 Tab
*create_new_tab(GtkWidget
* widget
, gpointer user_data
){
2254 gchar label
[PATH_MAX
];
2255 MainWindow
* mw_data
= get_window_data_struct(widget
);
2257 GtkNotebook
* notebook
= (GtkNotebook
*)lookup_widget(widget
, "MNotebook");
2258 if(notebook
== NULL
){
2259 g_info("Notebook does not exist\n");
2262 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
2263 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
2269 copy_tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
2272 strcpy(label
,"Page");
2273 if(get_label(mw_data
, label
,"Get the name of the tab","Please input tab's name"))
2274 return (create_tab (mw_data
, copy_tab
, notebook
, label
));
2280 on_tab_activate (GtkMenuItem
*menuitem
,
2283 create_new_tab((GtkWidget
*)menuitem
, user_data
);
2288 on_open_activate (GtkMenuItem
*menuitem
,
2291 open_traceset((GtkWidget
*)menuitem
, user_data
);
2296 on_close_activate (GtkMenuItem
*menuitem
,
2299 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2300 main_window_destructor(mw_data
);
2304 /* remove the current tab from the main window
2308 on_close_tab_activate (GtkWidget
*widget
,
2312 GtkWidget
* notebook
;
2314 MainWindow
* mw_data
= get_window_data_struct(widget
);
2315 notebook
= lookup_widget(widget
, "MNotebook");
2316 if(notebook
== NULL
){
2317 g_info("Notebook does not exist\n");
2321 page_num
= gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
));
2323 gtk_notebook_remove_page(GTK_NOTEBOOK(notebook
), page_num
);
2328 on_close_tab_X_clicked (GtkWidget
*widget
,
2332 GtkWidget
*notebook
= lookup_widget(widget
, "MNotebook");
2333 if(notebook
== NULL
){
2334 g_info("Notebook does not exist\n");
2338 if((page_num
= gtk_notebook_page_num(GTK_NOTEBOOK(notebook
), widget
)) != -1)
2339 gtk_notebook_remove_page(GTK_NOTEBOOK(notebook
), page_num
);
2345 on_add_trace_activate (GtkMenuItem
*menuitem
,
2348 add_trace((GtkWidget
*)menuitem
, user_data
);
2353 on_remove_trace_activate (GtkMenuItem
*menuitem
,
2356 remove_trace((GtkWidget
*)menuitem
, user_data
);
2361 on_save_activate (GtkMenuItem
*menuitem
,
2364 save((GtkWidget
*)menuitem
, user_data
);
2369 on_save_as_activate (GtkMenuItem
*menuitem
,
2372 save_as((GtkWidget
*)menuitem
, user_data
);
2377 on_quit_activate (GtkMenuItem
*menuitem
,
2385 on_cut_activate (GtkMenuItem
*menuitem
,
2393 on_copy_activate (GtkMenuItem
*menuitem
,
2401 on_paste_activate (GtkMenuItem
*menuitem
,
2409 on_delete_activate (GtkMenuItem
*menuitem
,
2417 on_zoom_in_activate (GtkMenuItem
*menuitem
,
2420 zoom_in((GtkWidget
*)menuitem
, user_data
);
2425 on_zoom_out_activate (GtkMenuItem
*menuitem
,
2428 zoom_out((GtkWidget
*)menuitem
, user_data
);
2433 on_zoom_extended_activate (GtkMenuItem
*menuitem
,
2436 zoom_extended((GtkWidget
*)menuitem
, user_data
);
2441 on_go_to_time_activate (GtkMenuItem
*menuitem
,
2444 go_to_time((GtkWidget
*)menuitem
, user_data
);
2449 on_show_time_frame_activate (GtkMenuItem
*menuitem
,
2452 show_time_frame((GtkWidget
*)menuitem
, user_data
);
2457 on_move_viewer_up_activate (GtkMenuItem
*menuitem
,
2460 move_up_viewer((GtkWidget
*)menuitem
, user_data
);
2465 on_move_viewer_down_activate (GtkMenuItem
*menuitem
,
2468 move_down_viewer((GtkWidget
*)menuitem
, user_data
);
2473 on_remove_viewer_activate (GtkMenuItem
*menuitem
,
2476 delete_viewer((GtkWidget
*)menuitem
, user_data
);
2480 on_trace_facility_activate (GtkMenuItem
*menuitem
,
2483 g_info("Trace facility selector: %s\n");
2487 /* Dispaly a file selection dialogue to let user select a library, then call
2488 * lttv_library_load().
2492 on_load_library_activate (GtkMenuItem
*menuitem
,
2495 GError
*error
= NULL
;
2496 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2498 gchar load_module_path_alter
[PATH_MAX
];
2502 gchar
*load_module_path
;
2503 name
= g_ptr_array_new();
2504 nb
= lttv_library_path_number();
2505 /* ask for the library path */
2509 path
= lttv_library_path_get(i
);
2510 g_ptr_array_add(name
, path
);
2513 load_module_path
= get_selection(mw_data
,
2514 (char **)(name
->pdata
), name
->len
,
2515 "Select a library path", "Library paths");
2516 if(load_module_path
!= NULL
)
2517 strncpy(load_module_path_alter
, load_module_path
, PATH_MAX
-1); // -1 for /
2519 g_ptr_array_free(name
, TRUE
);
2521 if(load_module_path
== NULL
) return;
2525 /* Make sure the module path ends with a / */
2526 gchar
*ptr
= load_module_path_alter
;
2528 ptr
= strchr(ptr
, '\0');
2530 if(*(ptr
-1) != '/') {
2537 /* Ask for the library to load : list files in the previously selected
2539 gchar str
[PATH_MAX
];
2542 GtkFileSelection
* file_selector
=
2543 (GtkFileSelection
*)gtk_file_selection_new("Select a module");
2544 gtk_file_selection_set_filename(file_selector
, load_module_path_alter
);
2545 gtk_file_selection_hide_fileop_buttons(file_selector
);
2547 gtk_window_set_transient_for(GTK_WINDOW(file_selector
),
2548 GTK_WINDOW(mw_data
->mwindow
));
2551 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
2553 case GTK_RESPONSE_ACCEPT
:
2554 case GTK_RESPONSE_OK
:
2555 dir
= gtk_file_selection_get_selections (file_selector
);
2556 strncpy(str
,dir
[0],PATH_MAX
);
2557 strncpy(remember_plugins_dir
,dir
[0],PATH_MAX
);
2558 /* only keep file name */
2560 str1
= strrchr(str
,'/');
2563 str1
= strrchr(str
,'\\');
2568 if(*str1
== 'l' && *(str1
+1)== 'i' && *(str1
+2)=='b')
2570 remove info after
. */
2574 str2
= strrchr(str2
, '.');
2575 if(str2
!= NULL
) *str2
= '\0';
2577 lttv_module_require(str1
, &error
);
2579 lttv_library_load(str1
, &error
);
2580 if(error
!= NULL
) g_warning("%s", error
->message
);
2581 else g_info("Load library: %s\n", str
);
2583 case GTK_RESPONSE_REJECT
:
2584 case GTK_RESPONSE_CANCEL
:
2586 gtk_widget_destroy((GtkWidget
*)file_selector
);
2597 /* Display all loaded modules, let user to select a module to unload
2598 * by calling lttv_module_unload
2602 on_unload_library_activate (GtkMenuItem
*menuitem
,
2605 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2607 LttvLibrary
*library
= NULL
;
2612 name
= g_ptr_array_new();
2613 nb
= lttv_library_number();
2614 LttvLibraryInfo
*lib_info
= g_new(LttvLibraryInfo
,nb
);
2615 /* ask for the library name */
2618 LttvLibrary
*iter_lib
= lttv_library_get(i
);
2619 lttv_library_info(iter_lib
, &lib_info
[i
]);
2621 gchar
*path
= lib_info
[i
].name
;
2622 g_ptr_array_add(name
, path
);
2624 lib_name
= get_selection(mw_data
, (char **)(name
->pdata
), name
->len
,
2625 "Select a library", "Libraries");
2626 if(lib_name
!= NULL
) {
2628 if(strcmp(lib_name
, lib_info
[i
].name
) == 0) {
2629 library
= lttv_library_get(i
);
2634 g_ptr_array_free(name
, TRUE
);
2637 if(lib_name
== NULL
) return;
2639 if(library
!= NULL
) lttv_library_unload(library
);
2643 /* Dispaly a file selection dialogue to let user select a module, then call
2644 * lttv_module_require().
2648 on_load_module_activate (GtkMenuItem
*menuitem
,
2651 GError
*error
= NULL
;
2652 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2654 LttvLibrary
*library
= NULL
;
2659 name
= g_ptr_array_new();
2660 nb
= lttv_library_number();
2661 LttvLibraryInfo
*lib_info
= g_new(LttvLibraryInfo
,nb
);
2662 /* ask for the library name */
2665 LttvLibrary
*iter_lib
= lttv_library_get(i
);
2666 lttv_library_info(iter_lib
, &lib_info
[i
]);
2668 gchar
*path
= lib_info
[i
].name
;
2669 g_ptr_array_add(name
, path
);
2671 lib_name
= get_selection(mw_data
,(char **)(name
->pdata
), name
->len
,
2672 "Select a library", "Libraries");
2673 if(lib_name
!= NULL
) {
2675 if(strcmp(lib_name
, lib_info
[i
].name
) == 0) {
2676 library
= lttv_library_get(i
);
2681 g_ptr_array_free(name
, TRUE
);
2684 if(lib_name
== NULL
) return;
2687 //LttvModule *module;
2688 gchar module_name_out
[PATH_MAX
];
2690 /* Ask for the module to load : list modules in the selected lib */
2694 nb
= lttv_library_module_number(library
);
2695 LttvModuleInfo
*module_info
= g_new(LttvModuleInfo
,nb
);
2696 name
= g_ptr_array_new();
2697 /* ask for the module name */
2700 LttvModule
*iter_module
= lttv_library_module_get(library
, i
);
2701 lttv_module_info(iter_module
, &module_info
[i
]);
2703 gchar
*path
= module_info
[i
].name
;
2704 g_ptr_array_add(name
, path
);
2706 module_name
= get_selection(mw_data
, (char **)(name
->pdata
), name
->len
,
2707 "Select a module", "Modules");
2708 if(module_name
!= NULL
) {
2710 if(strcmp(module_name
, module_info
[i
].name
) == 0) {
2711 strncpy(module_name_out
, module_name
, PATH_MAX
);
2712 //module = lttv_library_module_get(i);
2718 g_ptr_array_free(name
, TRUE
);
2719 g_free(module_info
);
2721 if(module_name
== NULL
) return;
2724 lttv_module_require(module_name_out
, &error
);
2725 if(error
!= NULL
) g_warning("%s", error
->message
);
2726 else g_info("Load module: %s", module_name_out
);
2733 gchar str
[PATH_MAX
];
2736 GtkFileSelection
* file_selector
=
2737 (GtkFileSelection
*)gtk_file_selection_new("Select a module");
2738 gtk_file_selection_set_filename(file_selector
, load_module_path_alter
);
2739 gtk_file_selection_hide_fileop_buttons(file_selector
);
2742 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
2744 case GTK_RESPONSE_ACCEPT
:
2745 case GTK_RESPONSE_OK
:
2746 dir
= gtk_file_selection_get_selections (file_selector
);
2747 strncpy(str
,dir
[0],PATH_MAX
);
2748 strncpy(remember_plugins_dir
,dir
[0],PATH_MAX
);
2750 /* only keep file name */
2752 str1
= strrchr(str
,'/');
2755 str1
= strrchr(str
,'\\');
2760 if(*str1
== 'l' && *(str1
+1)== 'i' && *(str1
+2)=='b')
2762 remove info after
. */
2766 str2
= strrchr(str2
, '.');
2767 if(str2
!= NULL
) *str2
= '\0';
2769 lttv_module_require(str1
, &error
);
2771 lttv_library_load(str1
, &error
);
2772 if(error
!= NULL
) g_warning(error
->message
);
2773 else g_info("Load library: %s\n", str
);
2775 case GTK_RESPONSE_REJECT
:
2776 case GTK_RESPONSE_CANCEL
:
2778 gtk_widget_destroy((GtkWidget
*)file_selector
);
2790 /* Display all loaded modules, let user to select a module to unload
2791 * by calling lttv_module_unload
2795 on_unload_module_activate (GtkMenuItem
*menuitem
,
2798 GError
*error
= NULL
;
2799 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2801 LttvLibrary
*library
;
2806 name
= g_ptr_array_new();
2807 nb
= lttv_library_number();
2808 LttvLibraryInfo
*lib_info
= g_new(LttvLibraryInfo
,nb
);
2809 /* ask for the library name */
2812 LttvLibrary
*iter_lib
= lttv_library_get(i
);
2813 lttv_library_info(iter_lib
, &lib_info
[i
]);
2815 gchar
*path
= lib_info
[i
].name
;
2816 g_ptr_array_add(name
, path
);
2818 lib_name
= get_selection(mw_data
, (char **)(name
->pdata
), name
->len
,
2819 "Select a library", "Libraries");
2820 if(lib_name
!= NULL
) {
2822 if(strcmp(lib_name
, lib_info
[i
].name
) == 0) {
2823 library
= lttv_library_get(i
);
2828 g_ptr_array_free(name
, TRUE
);
2831 if(lib_name
== NULL
) return;
2834 LttvModule
*module
= NULL
;
2836 /* Ask for the module to load : list modules in the selected lib */
2840 nb
= lttv_library_module_number(library
);
2841 LttvModuleInfo
*module_info
= g_new(LttvModuleInfo
,nb
);
2842 name
= g_ptr_array_new();
2843 /* ask for the module name */
2846 LttvModule
*iter_module
= lttv_library_module_get(library
, i
);
2847 lttv_module_info(iter_module
, &module_info
[i
]);
2849 gchar
*path
= module_info
[i
].name
;
2850 if(module_info
[i
].use_count
> 0) g_ptr_array_add(name
, path
);
2852 module_name
= get_selection(mw_data
, (char **)(name
->pdata
), name
->len
,
2853 "Select a module", "Modules");
2854 if(module_name
!= NULL
) {
2856 if(strcmp(module_name
, module_info
[i
].name
) == 0) {
2857 module
= lttv_library_module_get(library
, i
);
2863 g_ptr_array_free(name
, TRUE
);
2864 g_free(module_info
);
2866 if(module_name
== NULL
) return;
2869 LttvModuleInfo module_info
;
2870 lttv_module_info(module
, &module_info
);
2871 g_info("Release module: %s\n", module_info
.name
);
2873 lttv_module_release(module
);
2877 /* Display a directory dialogue to let user select a path for library searching
2881 on_add_library_search_path_activate (GtkMenuItem
*menuitem
,
2884 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2885 //GtkDirSelection * file_selector = (GtkDirSelection *)gtk_dir_selection_new("Select library path");
2886 GtkFileSelection
* file_selector
= (GtkFileSelection
*)gtk_file_selection_new("Select a trace");
2887 gtk_widget_hide( (file_selector
)->file_list
->parent
) ;
2889 gtk_window_set_transient_for(GTK_WINDOW(file_selector
),
2890 GTK_WINDOW(mw_data
->mwindow
));
2895 if(remember_plugins_dir
[0] != '\0')
2896 gtk_file_selection_set_filename(file_selector
, remember_plugins_dir
);
2898 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
2900 case GTK_RESPONSE_ACCEPT
:
2901 case GTK_RESPONSE_OK
:
2902 dir
= gtk_file_selection_get_filename (file_selector
);
2903 strncpy(remember_plugins_dir
,dir
,PATH_MAX
);
2904 strncat(remember_plugins_dir
,"/",PATH_MAX
);
2905 lttv_library_path_add(dir
);
2906 case GTK_RESPONSE_REJECT
:
2907 case GTK_RESPONSE_CANCEL
:
2909 gtk_widget_destroy((GtkWidget
*)file_selector
);
2915 /* Display a directory dialogue to let user select a path for library searching
2919 on_remove_library_search_path_activate (GtkMenuItem
*menuitem
,
2922 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2924 const char *lib_path
;
2929 name
= g_ptr_array_new();
2930 nb
= lttv_library_path_number();
2931 /* ask for the library name */
2934 gchar
*path
= lttv_library_path_get(i
);
2935 g_ptr_array_add(name
, path
);
2937 lib_path
= get_selection(mw_data
, (char **)(name
->pdata
), name
->len
,
2938 "Select a library path", "Library paths");
2940 g_ptr_array_free(name
, TRUE
);
2942 if(lib_path
== NULL
) return;
2945 lttv_library_path_remove(lib_path
);
2949 on_color_activate (GtkMenuItem
*menuitem
,
2957 on_save_configuration_activate (GtkMenuItem
*menuitem
,
2960 g_info("Save configuration\n");
2965 on_content_activate (GtkMenuItem
*menuitem
,
2968 g_info("Content\n");
2973 on_about_close_activate (GtkButton
*button
,
2976 GtkWidget
*about_widget
= GTK_WIDGET(user_data
);
2978 gtk_widget_destroy(about_widget
);
2982 on_about_activate (GtkMenuItem
*menuitem
,
2985 MainWindow
*main_window
= get_window_data_struct(GTK_WIDGET(menuitem
));
2986 GtkWidget
*window_widget
= main_window
->mwindow
;
2987 GtkWidget
*about_widget
= gtk_window_new(GTK_WINDOW_TOPLEVEL
);
2988 GtkWindow
*about_window
= GTK_WINDOW(about_widget
);
2989 gint window_width
, window_height
;
2991 gtk_window_set_title(about_window
, "About Linux Trace Toolkit");
2993 gtk_window_set_resizable(about_window
, FALSE
);
2994 gtk_window_set_transient_for(GTK_WINDOW(window_widget
), about_window
);
2995 gtk_window_set_destroy_with_parent(about_window
, TRUE
);
2996 gtk_window_set_modal(about_window
, FALSE
);
2998 /* Put the about window at the center of the screen */
2999 gtk_window_get_size(about_window
, &window_width
, &window_height
);
3000 gtk_window_move (about_window
,
3001 (gdk_screen_width() - window_width
)/2,
3002 (gdk_screen_height() - window_height
)/2);
3004 GtkWidget
*vbox
= gtk_vbox_new(FALSE
, 1);
3006 gtk_container_add(GTK_CONTAINER(about_widget
), vbox
);
3010 GtkWidget
*label1
= gtk_label_new("");
3011 gtk_misc_set_padding(GTK_MISC(label1
), 10, 20);
3012 gtk_label_set_markup(GTK_LABEL(label1
), "\
3013 <big>Linux Trace Toolkit</big>");
3014 gtk_label_set_justify(GTK_LABEL(label1
), GTK_JUSTIFY_CENTER
);
3016 GtkWidget
*label2
= gtk_label_new("");
3017 gtk_misc_set_padding(GTK_MISC(label2
), 10, 20);
3018 gtk_label_set_markup(GTK_LABEL(label2
), "\
3021 Michel Dagenais (New trace format, lttv main)\n\
3022 Mathieu Desnoyers (Kernel Tracer, Directory structure, build with automake/conf,\n\
3023 lttv gui, control flow view, gui cooperative trace reading\n\
3024 scheduler with interruptible foreground and background\n\
3025 computation, detailed event list (rewrite), trace reading\n\
3026 library (rewrite))\n\
3027 Benoit Des Ligneris, Eric Clement (Cluster adaptation, work in progress)\n\
3028 Xang-Xiu Yang (new trace reading library and converter, lttv gui, \n\
3029 detailed event list and statistics view)\n\
3030 Tom Zanussi (RelayFS)\n\
3032 Strongly inspired from the original Linux Trace Toolkit Visualizer made by\n\
3035 GtkWidget
*label3
= gtk_label_new("");
3036 gtk_label_set_markup(GTK_LABEL(label3
), "\
3037 Linux Trace Toolkit Viewer, Copyright (C) 2004\n\
3039 Mathieu Desnoyers\n\
3041 Linux Trace Toolkit comes with ABSOLUTELY NO WARRANTY.\n\
3042 This is free software, and you are welcome to redistribute it\n\
3043 under certain conditions. See COPYING for details.");
3044 gtk_misc_set_padding(GTK_MISC(label3
), 10, 20);
3046 gtk_box_pack_start_defaults(GTK_BOX(vbox
), label1
);
3047 gtk_box_pack_start_defaults(GTK_BOX(vbox
), label2
);
3048 gtk_box_pack_start_defaults(GTK_BOX(vbox
), label3
);
3050 GtkWidget
*hbox
= gtk_hbox_new(TRUE
, 0);
3051 gtk_box_pack_end(GTK_BOX(vbox
), hbox
, FALSE
, FALSE
, 0);
3052 GtkWidget
*close_button
= gtk_button_new_with_mnemonic("_Close");
3053 gtk_box_pack_end(GTK_BOX(hbox
), close_button
, FALSE
, FALSE
, 0);
3054 gtk_container_set_border_width(GTK_CONTAINER(close_button
), 20);
3056 g_signal_connect(G_OBJECT(close_button
), "clicked",
3057 G_CALLBACK(on_about_close_activate
),
3058 (gpointer
)about_widget
);
3060 gtk_widget_show_all(about_widget
);
3065 on_button_new_clicked (GtkButton
*button
,
3068 create_new_window((GtkWidget
*)button
, user_data
, TRUE
);
3072 on_button_new_tab_clicked (GtkButton
*button
,
3075 create_new_tab((GtkWidget
*)button
, user_data
);
3079 on_button_open_clicked (GtkButton
*button
,
3082 open_traceset((GtkWidget
*)button
, user_data
);
3087 on_button_add_trace_clicked (GtkButton
*button
,
3090 add_trace((GtkWidget
*)button
, user_data
);
3095 on_button_remove_trace_clicked (GtkButton
*button
,
3098 remove_trace((GtkWidget
*)button
, user_data
);
3102 on_button_redraw_clicked (GtkButton
*button
,
3105 redraw((GtkWidget
*)button
, user_data
);
3109 on_button_continue_processing_clicked (GtkButton
*button
,
3112 continue_processing((GtkWidget
*)button
, user_data
);
3116 on_button_stop_processing_clicked (GtkButton
*button
,
3119 stop_processing((GtkWidget
*)button
, user_data
);
3125 on_button_save_clicked (GtkButton
*button
,
3128 save((GtkWidget
*)button
, user_data
);
3133 on_button_save_as_clicked (GtkButton
*button
,
3136 save_as((GtkWidget
*)button
, user_data
);
3141 on_button_zoom_in_clicked (GtkButton
*button
,
3144 zoom_in((GtkWidget
*)button
, user_data
);
3149 on_button_zoom_out_clicked (GtkButton
*button
,
3152 zoom_out((GtkWidget
*)button
, user_data
);
3157 on_button_zoom_extended_clicked (GtkButton
*button
,
3160 zoom_extended((GtkWidget
*)button
, user_data
);
3165 on_button_go_to_time_clicked (GtkButton
*button
,
3168 go_to_time((GtkWidget
*)button
, user_data
);
3173 on_button_show_time_frame_clicked (GtkButton
*button
,
3176 show_time_frame((GtkWidget
*)button
, user_data
);
3181 on_button_move_up_clicked (GtkButton
*button
,
3184 move_up_viewer((GtkWidget
*)button
, user_data
);
3189 on_button_move_down_clicked (GtkButton
*button
,
3192 move_down_viewer((GtkWidget
*)button
, user_data
);
3197 on_button_delete_viewer_clicked (GtkButton
*button
,
3200 delete_viewer((GtkWidget
*)button
, user_data
);
3204 on_MWindow_destroy (GtkWidget
*widget
,
3207 MainWindow
*main_window
= get_window_data_struct(widget
);
3208 LttvIAttribute
*attributes
= main_window
->attributes
;
3209 LttvAttributeValue value
;
3211 //This is unnecessary, since widgets will be destroyed
3212 //by the main window widget anyway.
3213 //remove_all_menu_toolbar_constructors(main_window, NULL);
3215 g_assert(lttv_iattribute_find_by_path(attributes
,
3216 "viewers/menu", LTTV_POINTER
, &value
));
3217 lttv_menus_destroy((LttvMenus
*)*(value
.v_pointer
));
3219 g_assert(lttv_iattribute_find_by_path(attributes
,
3220 "viewers/toolbar", LTTV_POINTER
, &value
));
3221 lttv_toolbars_destroy((LttvToolbars
*)*(value
.v_pointer
));
3223 g_object_unref(main_window
->attributes
);
3224 g_main_window_list
= g_slist_remove(g_main_window_list
, main_window
);
3226 g_info("There are now : %d windows\n",g_slist_length(g_main_window_list
));
3227 if(g_slist_length(g_main_window_list
) == 0)
3232 on_MWindow_configure (GtkWidget
*widget
,
3233 GdkEventConfigure
*event
,
3236 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)widget
);
3238 // MD : removed time width modification upon resizing of the main window.
3239 // The viewers will redraw themselves completely, without time interval
3242 if(mw_data->window_width){
3243 time_span = LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->Time_Span ;
3244 time_win = tab->time_window;
3245 ratio = width / mw_data->window_width;
3246 tab->time_window.time_width = ltt_time_mul(time_win.time_width,ratio);
3247 time = ltt_time_sub(time_span->endTime, time_win.start_time);
3248 if(ltt_time_compare(time, tab->time_window.time_width) < 0){
3249 tab->time_window.time_width = time;
3255 mw_data->window_width = (int)width;
3264 on_MNotebook_switch_page (GtkNotebook
*notebook
,
3265 GtkNotebookPage
*page
,
3273 void time_change_manager (Tab
*tab
,
3274 TimeWindow new_time_window
)
3276 /* Only one source of time change */
3277 if(tab
->time_manager_lock
== TRUE
) return;
3279 tab
->time_manager_lock
= TRUE
;
3281 LttvTracesetContext
*tsc
= LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3282 TimeInterval time_span
= tsc
->time_span
;
3283 LttTime start_time
= new_time_window
.start_time
;
3284 LttTime end_time
= new_time_window
.end_time
;
3286 g_assert(ltt_time_compare(start_time
, end_time
) < 0);
3289 GtkAdjustment
*adjustment
= gtk_range_get_adjustment(GTK_RANGE(tab
->scrollbar
));
3290 LttTime upper
= ltt_time_sub(time_span
.end_time
, time_span
.start_time
);
3292 gtk_range_set_increments(GTK_RANGE(tab
->scrollbar
),
3293 ltt_time_to_double(new_time_window
.time_width
)
3294 / SCROLL_STEP_PER_PAGE
3295 * NANOSECONDS_PER_SECOND
, /* step increment */
3296 ltt_time_to_double(new_time_window
.time_width
)
3297 * NANOSECONDS_PER_SECOND
); /* page increment */
3298 gtk_range_set_range(GTK_RANGE(tab
->scrollbar
),
3300 ltt_time_to_double(upper
)
3301 * NANOSECONDS_PER_SECOND
); /* upper */
3303 g_object_set(G_OBJECT(adjustment
),
3307 ltt_time_to_double(upper
), /* upper */
3309 new_time_window
.time_width_double
3310 / SCROLL_STEP_PER_PAGE
, /* step increment */
3312 new_time_window
.time_width_double
,
3313 /* page increment */
3315 new_time_window
.time_width_double
, /* page size */
3317 gtk_adjustment_changed(adjustment
);
3319 // g_object_set(G_OBJECT(adjustment),
3321 // ltt_time_to_double(
3322 // ltt_time_sub(start_time, time_span.start_time))
3325 //gtk_adjustment_value_changed(adjustment);
3326 gtk_range_set_value(GTK_RANGE(tab
->scrollbar
),
3328 ltt_time_sub(start_time
, time_span
.start_time
)) /* value */);
3330 /* set the time bar. */
3332 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry1
),
3333 (double)time_span
.start_time
.tv_sec
,
3334 (double)time_span
.end_time
.tv_sec
);
3335 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry1
),
3336 (double)start_time
.tv_sec
);
3338 /* start nanoseconds */
3339 if(start_time
.tv_sec
== time_span
.start_time
.tv_sec
) {
3340 /* can be both beginning and end at the same time. */
3341 if(start_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3342 /* If we are at the end, max nsec to end.. -1 (not zero length) */
3343 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry2
),
3344 (double)time_span
.start_time
.tv_nsec
,
3345 (double)time_span
.end_time
.tv_nsec
-1);
3347 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry2
),
3348 (double)time_span
.start_time
.tv_nsec
,
3349 (double)NANOSECONDS_PER_SECOND
-1);
3351 } else if(start_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3352 /* If we are at the end, max nsec to end.. -1 (not zero length) */
3353 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry2
),
3355 (double)time_span
.end_time
.tv_nsec
-1);
3356 } else /* anywhere else */
3357 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry2
),
3359 (double)NANOSECONDS_PER_SECOND
-1);
3360 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry2
),
3361 (double)start_time
.tv_nsec
);
3364 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry3
),
3365 (double)time_span
.start_time
.tv_sec
,
3366 (double)time_span
.end_time
.tv_sec
);
3367 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry3
),
3368 (double)end_time
.tv_sec
);
3370 /* end nanoseconds */
3371 if(end_time
.tv_sec
== time_span
.start_time
.tv_sec
) {
3372 /* can be both beginning and end at the same time. */
3373 if(end_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3374 /* If we are at the end, max nsec to end.. */
3375 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry4
),
3376 (double)time_span
.start_time
.tv_nsec
+1,
3377 (double)time_span
.end_time
.tv_nsec
);
3379 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry4
),
3380 (double)time_span
.start_time
.tv_nsec
+1,
3381 (double)NANOSECONDS_PER_SECOND
-1);
3384 else if(end_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3385 /* If we are at the end, max nsec to end.. */
3386 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry4
),
3388 (double)time_span
.end_time
.tv_nsec
);
3390 else /* anywhere else */
3391 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry4
),
3393 (double)NANOSECONDS_PER_SECOND
-1);
3394 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry4
),
3395 (double)end_time
.tv_nsec
);
3397 /* call viewer hooks for new time window */
3398 set_time_window(tab
, &new_time_window
);
3400 tab
->time_manager_lock
= FALSE
;
3404 /* value changed for frame start s
3406 * Check time span : if ns is out of range, clip it the nearest good value.
3409 on_MEntry1_value_changed (GtkSpinButton
*spinbutton
,
3412 Tab
*tab
=(Tab
*)user_data
;
3413 LttvTracesetContext
* tsc
=
3414 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3415 TimeInterval time_span
= tsc
->time_span
;
3416 gint value
= gtk_spin_button_get_value_as_int(spinbutton
);
3418 TimeWindow new_time_window
= tab
->time_window
;
3420 LttTime end_time
= new_time_window
.end_time
;
3422 new_time_window
.start_time
.tv_sec
= value
;
3424 /* start nanoseconds */
3425 if(new_time_window
.start_time
.tv_sec
== time_span
.start_time
.tv_sec
) {
3426 if(new_time_window
.start_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3427 if(new_time_window
.start_time
.tv_nsec
> time_span
.end_time
.tv_nsec
)
3428 new_time_window
.start_time
.tv_nsec
= time_span
.end_time
.tv_nsec
-1;
3429 if(new_time_window
.start_time
.tv_nsec
< time_span
.start_time
.tv_nsec
)
3430 new_time_window
.start_time
.tv_nsec
= time_span
.start_time
.tv_nsec
;
3432 if(new_time_window
.start_time
.tv_nsec
< time_span
.start_time
.tv_nsec
)
3433 new_time_window
.start_time
.tv_nsec
= time_span
.start_time
.tv_nsec
;
3436 else if(new_time_window
.start_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3437 if(new_time_window
.start_time
.tv_nsec
> time_span
.end_time
.tv_nsec
)
3438 new_time_window
.start_time
.tv_nsec
= time_span
.end_time
.tv_nsec
-1;
3441 if(ltt_time_compare(new_time_window
.start_time
, end_time
) >= 0) {
3442 /* Then, we must push back end time : keep the same time width
3443 * if possible, else end traceset time */
3444 end_time
= LTT_TIME_MIN(ltt_time_add(new_time_window
.start_time
,
3445 new_time_window
.time_width
),
3446 time_span
.end_time
);
3449 /* Fix the time width to fit start time and end time */
3450 new_time_window
.time_width
= ltt_time_sub(end_time
,
3451 new_time_window
.start_time
);
3452 new_time_window
.time_width_double
=
3453 ltt_time_to_double(new_time_window
.time_width
);
3455 new_time_window
.end_time
= end_time
;
3457 time_change_manager(tab
, new_time_window
);
3462 on_MEntry2_value_changed (GtkSpinButton
*spinbutton
,
3465 Tab
*tab
=(Tab
*)user_data
;
3466 LttvTracesetContext
* tsc
=
3467 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3468 TimeInterval time_span
= tsc
->time_span
;
3469 gint value
= gtk_spin_button_get_value_as_int(spinbutton
);
3471 TimeWindow new_time_window
= tab
->time_window
;
3473 LttTime end_time
= new_time_window
.end_time
;
3475 new_time_window
.start_time
.tv_nsec
= value
;
3477 if(ltt_time_compare(new_time_window
.start_time
, end_time
) >= 0) {
3478 /* Then, we must push back end time : keep the same time width
3479 * if possible, else end traceset time */
3480 end_time
= LTT_TIME_MIN(ltt_time_add(new_time_window
.start_time
,
3481 new_time_window
.time_width
),
3482 time_span
.end_time
);
3485 /* Fix the time width to fit start time and end time */
3486 new_time_window
.time_width
= ltt_time_sub(end_time
,
3487 new_time_window
.start_time
);
3488 new_time_window
.time_width_double
=
3489 ltt_time_to_double(new_time_window
.time_width
);
3491 new_time_window
.end_time
= end_time
;
3493 time_change_manager(tab
, new_time_window
);
3498 on_MEntry3_value_changed (GtkSpinButton
*spinbutton
,
3501 Tab
*tab
=(Tab
*)user_data
;
3502 LttvTracesetContext
* tsc
=
3503 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3504 TimeInterval time_span
= tsc
->time_span
;
3505 gint value
= gtk_spin_button_get_value_as_int(spinbutton
);
3507 TimeWindow new_time_window
= tab
->time_window
;
3509 LttTime end_time
= new_time_window
.end_time
;
3511 end_time
.tv_sec
= value
;
3513 /* end nanoseconds */
3514 if(end_time
.tv_sec
== time_span
.start_time
.tv_sec
) {
3515 if(end_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3516 if(end_time
.tv_nsec
> time_span
.end_time
.tv_nsec
)
3517 end_time
.tv_nsec
= time_span
.end_time
.tv_nsec
;
3518 if(end_time
.tv_nsec
< time_span
.start_time
.tv_nsec
)
3519 end_time
.tv_nsec
= time_span
.start_time
.tv_nsec
+1;
3521 if(end_time
.tv_nsec
< time_span
.start_time
.tv_nsec
)
3522 end_time
.tv_nsec
= time_span
.start_time
.tv_nsec
+1;
3525 else if(end_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3526 if(end_time
.tv_nsec
> time_span
.end_time
.tv_nsec
)
3527 end_time
.tv_nsec
= time_span
.end_time
.tv_nsec
;
3530 if(ltt_time_compare(new_time_window
.start_time
, end_time
) >= 0) {
3531 /* Then, we must push front start time : keep the same time width
3532 * if possible, else end traceset time */
3533 new_time_window
.start_time
= LTT_TIME_MAX(
3534 ltt_time_sub(end_time
,
3535 new_time_window
.time_width
),
3536 time_span
.start_time
);
3539 /* Fix the time width to fit start time and end time */
3540 new_time_window
.time_width
= ltt_time_sub(end_time
,
3541 new_time_window
.start_time
);
3542 new_time_window
.time_width_double
=
3543 ltt_time_to_double(new_time_window
.time_width
);
3545 new_time_window
.end_time
= end_time
;
3547 time_change_manager(tab
, new_time_window
);
3552 on_MEntry4_value_changed (GtkSpinButton
*spinbutton
,
3555 Tab
*tab
=(Tab
*)user_data
;
3556 LttvTracesetContext
* tsc
=
3557 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3558 TimeInterval time_span
= tsc
->time_span
;
3559 gint value
= gtk_spin_button_get_value_as_int(spinbutton
);
3561 TimeWindow new_time_window
= tab
->time_window
;
3563 LttTime end_time
= new_time_window
.end_time
;
3565 end_time
.tv_nsec
= value
;
3567 if(ltt_time_compare(new_time_window
.start_time
, end_time
) >= 0) {
3568 /* Then, we must push front start time : keep the same time width
3569 * if possible, else end traceset time */
3570 new_time_window
.start_time
= LTT_TIME_MAX(
3571 ltt_time_sub(end_time
,
3572 new_time_window
.time_width
),
3573 time_span
.start_time
);
3576 /* Fix the time width to fit start time and end time */
3577 new_time_window
.time_width
= ltt_time_sub(end_time
,
3578 new_time_window
.start_time
);
3579 new_time_window
.time_width_double
=
3580 ltt_time_to_double(new_time_window
.time_width
);
3581 new_time_window
.end_time
= end_time
;
3583 time_change_manager(tab
, new_time_window
);
3588 void current_time_change_manager (Tab
*tab
,
3589 LttTime new_current_time
)
3591 /* Only one source of time change */
3592 if(tab
->current_time_manager_lock
== TRUE
) return;
3594 tab
->current_time_manager_lock
= TRUE
;
3596 LttvTracesetContext
*tsc
= LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3597 TimeInterval time_span
= tsc
->time_span
;
3599 /* current seconds */
3600 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry5
),
3601 (double)time_span
.start_time
.tv_sec
,
3602 (double)time_span
.end_time
.tv_sec
);
3603 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry5
),
3604 (double)new_current_time
.tv_sec
);
3607 /* start nanoseconds */
3608 if(new_current_time
.tv_sec
== time_span
.start_time
.tv_sec
) {
3609 /* can be both beginning and end at the same time. */
3610 if(new_current_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3611 /* If we are at the end, max nsec to end.. */
3612 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry6
),
3613 (double)time_span
.start_time
.tv_nsec
,
3614 (double)time_span
.end_time
.tv_nsec
);
3616 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry6
),
3617 (double)time_span
.start_time
.tv_nsec
,
3618 (double)NANOSECONDS_PER_SECOND
-1);
3620 } else if(new_current_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3621 /* If we are at the end, max nsec to end.. */
3622 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry6
),
3624 (double)time_span
.end_time
.tv_nsec
);
3625 } else /* anywhere else */
3626 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry6
),
3628 (double)NANOSECONDS_PER_SECOND
-1);
3630 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry6
),
3631 (double)new_current_time
.tv_nsec
);
3633 set_current_time(tab
, &new_current_time
);
3635 tab
->current_time_manager_lock
= FALSE
;
3638 void current_position_change_manager(Tab
*tab
,
3639 LttvTracesetContextPosition
*pos
)
3641 LttvTracesetContext
*tsc
=
3642 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3643 TimeInterval time_span
= tsc
->time_span
;
3645 g_assert(lttv_process_traceset_seek_position(tsc
, pos
) == 0);
3646 LttTime new_time
= lttv_traceset_context_position_get_time(pos
);
3647 /* Put the context in a state coherent position */
3648 lttv_state_traceset_seek_time_closest((LttvTracesetState
*)tsc
, ltt_time_zero
);
3650 current_time_change_manager(tab
, new_time
);
3652 set_current_position(tab
, pos
);
3657 on_MEntry5_value_changed (GtkSpinButton
*spinbutton
,
3660 Tab
*tab
= (Tab
*)user_data
;
3661 LttvTracesetContext
* tsc
=
3662 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3663 TimeInterval time_span
= tsc
->time_span
;
3664 gint value
= gtk_spin_button_get_value_as_int(spinbutton
);
3665 LttTime new_current_time
= tab
->current_time
;
3666 new_current_time
.tv_sec
= value
;
3668 /* current nanoseconds */
3669 if(new_current_time
.tv_sec
== time_span
.start_time
.tv_sec
) {
3670 if(new_current_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3671 if(new_current_time
.tv_nsec
> time_span
.end_time
.tv_nsec
)
3672 new_current_time
.tv_nsec
= time_span
.end_time
.tv_nsec
;
3673 if(new_current_time
.tv_nsec
< time_span
.start_time
.tv_nsec
)
3674 new_current_time
.tv_nsec
= time_span
.start_time
.tv_nsec
;
3676 if(new_current_time
.tv_nsec
< time_span
.start_time
.tv_nsec
)
3677 new_current_time
.tv_nsec
= time_span
.start_time
.tv_nsec
;
3680 else if(new_current_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3681 if(new_current_time
.tv_nsec
> time_span
.end_time
.tv_nsec
)
3682 new_current_time
.tv_nsec
= time_span
.end_time
.tv_nsec
;
3685 current_time_change_manager(tab
, new_current_time
);
3689 on_MEntry6_value_changed (GtkSpinButton
*spinbutton
,
3692 Tab
*tab
= (Tab
*)user_data
;
3693 gint value
= gtk_spin_button_get_value_as_int(spinbutton
);
3694 LttTime new_current_time
= tab
->current_time
;
3695 new_current_time
.tv_nsec
= value
;
3697 current_time_change_manager(tab
, new_current_time
);
3701 void scroll_value_changed_cb(GtkWidget
*scrollbar
,
3704 Tab
*tab
= (Tab
*)user_data
;
3705 TimeWindow new_time_window
;
3707 GtkAdjustment
*adjust
= gtk_range_get_adjustment(GTK_RANGE(scrollbar
));
3708 gdouble value
= gtk_adjustment_get_value(adjust
);
3709 // gdouble upper, lower, ratio, page_size;
3711 LttvTracesetContext
* tsc
=
3712 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3713 TimeInterval time_span
= tsc
->time_span
;
3715 time
= ltt_time_add(ltt_time_from_double(value
),
3716 time_span
.start_time
);
3718 new_time_window
.start_time
= time
;
3720 page_size
= adjust
->page_size
;
3722 new_time_window
.time_width
=
3723 ltt_time_from_double(page_size
);
3725 new_time_window
.time_width_double
=
3728 new_time_window
.end_time
= ltt_time_add(new_time_window
.start_time
,
3729 new_time_window
.time_width
);
3732 time_change_manager(tab
, new_time_window
);
3734 //time_window = tab->time_window;
3736 lower
= adjust
->lower
;
3737 upper
= adjust
->upper
;
3738 ratio
= (value
- lower
) / (upper
- lower
);
3739 g_info("lower %lu, upper %lu, value %lu, ratio %lu", lower
, upper
, value
, ratio
);
3741 //time = ltt_time_sub(time_span->end_time, time_span->start_time);
3742 //time = ltt_time_mul(time, (float)ratio);
3743 //time = ltt_time_add(time_span->start_time, time);
3744 time
= ltt_time_add(ltt_time_from_double(value
),
3745 time_span
.start_time
);
3747 time_window
.start_time
= time
;
3749 page_size
= adjust
->page_size
;
3751 time_window
.time_width
=
3752 ltt_time_from_double(page_size
);
3753 //time = ltt_time_sub(time_span.end_time, time);
3754 //if(ltt_time_compare(time,time_window.time_width) < 0){
3755 // time_window.time_width = time;
3758 /* call viewer hooks for new time window */
3759 set_time_window(tab
, &time_window
);
3764 /* Display a dialogue showing all eventtypes and traces, let user to select the interested
3765 * eventtypes, tracefiles and traces (filter)
3768 /* Select a trace which will be removed from traceset
3771 char * get_remove_trace(MainWindow
*mw_data
,
3772 char ** all_trace_name
, int nb_trace
)
3774 return get_selection(mw_data
, all_trace_name
, nb_trace
,
3775 "Select a trace", "Trace pathname");
3779 /* Select a module which will be loaded
3782 char * get_load_module(MainWindow
*mw_data
,
3783 char ** load_module_name
, int nb_module
)
3785 return get_selection(mw_data
, load_module_name
, nb_module
,
3786 "Select a module to load", "Module name");
3792 /* Select a module which will be unloaded
3795 char * get_unload_module(MainWindow
*mw_data
,
3796 char ** loaded_module_name
, int nb_module
)
3798 return get_selection(mw_data
, loaded_module_name
, nb_module
,
3799 "Select a module to unload", "Module name");
3803 /* Display a dialogue which shows all selectable items, let user to
3804 * select one of them
3807 char * get_selection(MainWindow
*mw_data
,
3808 char ** loaded_module_name
, int nb_module
,
3809 char *title
, char * column_title
)
3811 GtkWidget
* dialogue
;
3812 GtkWidget
* scroll_win
;
3814 GtkListStore
* store
;
3815 GtkTreeViewColumn
* column
;
3816 GtkCellRenderer
* renderer
;
3817 GtkTreeSelection
* select
;
3820 char * unload_module_name
= NULL
;
3822 dialogue
= gtk_dialog_new_with_buttons(title
,
3825 GTK_STOCK_OK
,GTK_RESPONSE_ACCEPT
,
3826 GTK_STOCK_CANCEL
,GTK_RESPONSE_REJECT
,
3828 gtk_window_set_default_size((GtkWindow
*)dialogue
, 500, 200);
3829 gtk_window_set_transient_for(GTK_WINDOW(dialogue
),
3830 GTK_WINDOW(mw_data
->mwindow
));
3832 scroll_win
= gtk_scrolled_window_new (NULL
, NULL
);
3833 gtk_widget_show ( scroll_win
);
3834 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win
),
3835 GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
3837 store
= gtk_list_store_new (N_COLUMNS
,G_TYPE_STRING
);
3838 tree
= gtk_tree_view_new_with_model(GTK_TREE_MODEL (store
));
3839 gtk_widget_show ( tree
);
3840 g_object_unref (G_OBJECT (store
));
3842 renderer
= gtk_cell_renderer_text_new ();
3843 column
= gtk_tree_view_column_new_with_attributes (column_title
,
3845 "text", MODULE_COLUMN
,
3847 gtk_tree_view_column_set_alignment (column
, 0.5);
3848 gtk_tree_view_column_set_fixed_width (column
, 150);
3849 gtk_tree_view_append_column (GTK_TREE_VIEW (tree
), column
);
3851 select
= gtk_tree_view_get_selection (GTK_TREE_VIEW (tree
));
3852 gtk_tree_selection_set_mode (select
, GTK_SELECTION_SINGLE
);
3854 gtk_container_add (GTK_CONTAINER (scroll_win
), tree
);
3856 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), scroll_win
,TRUE
, TRUE
,0);
3858 for(i
=0;i
<nb_module
;i
++){
3859 gtk_list_store_append (store
, &iter
);
3860 gtk_list_store_set (store
, &iter
, MODULE_COLUMN
,loaded_module_name
[i
],-1);
3863 id
= gtk_dialog_run(GTK_DIALOG(dialogue
));
3864 GtkTreeModel
**store_model
= (GtkTreeModel
**)&store
;
3866 case GTK_RESPONSE_ACCEPT
:
3867 case GTK_RESPONSE_OK
:
3868 if (gtk_tree_selection_get_selected (select
, store_model
, &iter
)){
3869 gtk_tree_model_get ((GtkTreeModel
*)store
, &iter
, MODULE_COLUMN
, &unload_module_name
, -1);
3871 case GTK_RESPONSE_REJECT
:
3872 case GTK_RESPONSE_CANCEL
:
3874 gtk_widget_destroy(dialogue
);
3878 return unload_module_name
;
3882 /* Insert all menu entry and tool buttons into this main window
3887 void add_all_menu_toolbar_constructors(MainWindow
* mw
, gpointer user_data
)
3891 lttvwindow_viewer_constructor constructor
;
3892 LttvMenus
* global_menu
, * instance_menu
;
3893 LttvToolbars
* global_toolbar
, * instance_toolbar
;
3894 LttvMenuClosure
*menu_item
;
3895 LttvToolbarClosure
*toolbar_item
;
3896 LttvAttributeValue value
;
3897 LttvIAttribute
*global_attributes
= LTTV_IATTRIBUTE(lttv_global_attributes());
3898 LttvIAttribute
*attributes
= mw
->attributes
;
3899 GtkWidget
* tool_menu_title_menu
, *new_widget
, *pixmap
;
3901 g_assert(lttv_iattribute_find_by_path(global_attributes
,
3902 "viewers/menu", LTTV_POINTER
, &value
));
3903 if(*(value
.v_pointer
) == NULL
)
3904 *(value
.v_pointer
) = lttv_menus_new();
3905 global_menu
= (LttvMenus
*)*(value
.v_pointer
);
3907 g_assert(lttv_iattribute_find_by_path(attributes
,
3908 "viewers/menu", LTTV_POINTER
, &value
));
3909 if(*(value
.v_pointer
) == NULL
)
3910 *(value
.v_pointer
) = lttv_menus_new();
3911 instance_menu
= (LttvMenus
*)*(value
.v_pointer
);
3915 g_assert(lttv_iattribute_find_by_path(global_attributes
,
3916 "viewers/toolbar", LTTV_POINTER
, &value
));
3917 if(*(value
.v_pointer
) == NULL
)
3918 *(value
.v_pointer
) = lttv_toolbars_new();
3919 global_toolbar
= (LttvToolbars
*)*(value
.v_pointer
);
3921 g_assert(lttv_iattribute_find_by_path(attributes
,
3922 "viewers/toolbar", LTTV_POINTER
, &value
));
3923 if(*(value
.v_pointer
) == NULL
)
3924 *(value
.v_pointer
) = lttv_toolbars_new();
3925 instance_toolbar
= (LttvToolbars
*)*(value
.v_pointer
);
3927 /* Add missing menu entries to window instance */
3928 for(i
=0;i
<global_menu
->len
;i
++) {
3929 menu_item
= &g_array_index(global_menu
, LttvMenuClosure
, i
);
3931 //add menu_item to window instance;
3932 constructor
= menu_item
->con
;
3933 tool_menu_title_menu
= lookup_widget(mw
->mwindow
,"ToolMenuTitle_menu");
3935 gtk_menu_item_new_with_mnemonic (menu_item
->menu_text
);
3936 gtk_container_add (GTK_CONTAINER (tool_menu_title_menu
),
3938 g_signal_connect ((gpointer
) new_widget
, "activate",
3939 G_CALLBACK (insert_viewer_wrap
),
3941 gtk_widget_show (new_widget
);
3942 lttv_menus_add(instance_menu
, menu_item
->con
,
3943 menu_item
->menu_path
,
3944 menu_item
->menu_text
,
3949 /* Add missing toolbar entries to window instance */
3950 for(i
=0;i
<global_toolbar
->len
;i
++) {
3951 toolbar_item
= &g_array_index(global_toolbar
, LttvToolbarClosure
, i
);
3953 //add toolbar_item to window instance;
3954 constructor
= toolbar_item
->con
;
3955 tool_menu_title_menu
= lookup_widget(mw
->mwindow
,"MToolbar1");
3956 pixbuf
= gdk_pixbuf_new_from_xpm_data((const char**)toolbar_item
->pixmap
);
3957 pixmap
= gtk_image_new_from_pixbuf(pixbuf
);
3959 gtk_toolbar_append_element (GTK_TOOLBAR (tool_menu_title_menu
),
3960 GTK_TOOLBAR_CHILD_BUTTON
,
3963 toolbar_item
->tooltip
, NULL
,
3964 pixmap
, NULL
, NULL
);
3965 gtk_label_set_use_underline(
3966 GTK_LABEL (((GtkToolbarChild
*) (
3967 g_list_last (GTK_TOOLBAR
3968 (tool_menu_title_menu
)->children
)->data
))->label
),
3970 gtk_container_set_border_width (GTK_CONTAINER (new_widget
), 1);
3971 g_signal_connect ((gpointer
) new_widget
,
3973 G_CALLBACK (insert_viewer_wrap
),
3975 gtk_widget_show (new_widget
);
3977 lttv_toolbars_add(instance_toolbar
, toolbar_item
->con
,
3978 toolbar_item
->tooltip
,
3979 toolbar_item
->pixmap
,
3987 /* Create a main window
3990 MainWindow
*construct_main_window(MainWindow
* parent
)
3992 g_debug("construct_main_window()");
3993 GtkWidget
* new_window
; /* New generated main window */
3994 MainWindow
* new_m_window
;/* New main window structure */
3995 GtkNotebook
* notebook
;
3996 LttvIAttribute
*attributes
=
3997 LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
));
3998 LttvAttributeValue value
;
4001 new_m_window
= g_new(MainWindow
, 1);
4003 // Add the object's information to the module's array
4004 g_main_window_list
= g_slist_append(g_main_window_list
, new_m_window
);
4006 new_window
= create_MWindow();
4007 gtk_widget_show (new_window
);
4009 new_m_window
->mwindow
= new_window
;
4010 new_m_window
->attributes
= attributes
;
4012 g_assert(lttv_iattribute_find_by_path(attributes
,
4013 "viewers/menu", LTTV_POINTER
, &value
));
4014 *(value
.v_pointer
) = lttv_menus_new();
4016 g_assert(lttv_iattribute_find_by_path(attributes
,
4017 "viewers/toolbar", LTTV_POINTER
, &value
));
4018 *(value
.v_pointer
) = lttv_toolbars_new();
4020 add_all_menu_toolbar_constructors(new_m_window
, NULL
);
4022 g_object_set_data_full(G_OBJECT(new_window
),
4024 (gpointer
)new_m_window
,
4025 (GDestroyNotify
)g_free
);
4026 //create a default tab
4027 notebook
= (GtkNotebook
*)lookup_widget(new_m_window
->mwindow
, "MNotebook");
4028 if(notebook
== NULL
){
4029 g_info("Notebook does not exist\n");
4030 /* FIXME : destroy partially created widgets */
4031 g_free(new_m_window
);
4034 //gtk_notebook_popup_enable (GTK_NOTEBOOK(notebook));
4035 //for now there is no name field in LttvTraceset structure
4036 //Use "Traceset" as the label for the default tab
4038 GtkWidget
* parent_notebook
= lookup_widget(parent
->mwindow
, "MNotebook");
4039 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(parent_notebook
),
4040 gtk_notebook_get_current_page(GTK_NOTEBOOK(parent_notebook
)));
4046 parent_tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
4048 new_tab
= create_tab(new_m_window
, parent_tab
, notebook
, "Traceset");
4050 new_tab
= create_tab(new_m_window
, NULL
, notebook
, "Traceset");
4053 /* Insert default viewers */
4055 LttvAttributeType type
;
4056 LttvAttributeName name
;
4057 LttvAttributeValue value
;
4058 LttvAttribute
*attribute
;
4060 LttvIAttribute
*attributes_global
=
4061 LTTV_IATTRIBUTE(lttv_global_attributes());
4063 g_assert(attribute
=
4064 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
4065 LTTV_IATTRIBUTE(attributes_global
),
4066 LTTV_VIEWER_CONSTRUCTORS
)));
4068 name
= g_quark_from_string("guievents");
4069 type
= lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute
),
4071 if(type
== LTTV_POINTER
) {
4072 lttvwindow_viewer_constructor viewer_constructor
=
4073 (lttvwindow_viewer_constructor
)*value
.v_pointer
;
4074 insert_viewer(new_window
, viewer_constructor
);
4077 name
= g_quark_from_string("guicontrolflow");
4078 type
= lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute
),
4080 if(type
== LTTV_POINTER
) {
4081 lttvwindow_viewer_constructor viewer_constructor
=
4082 (lttvwindow_viewer_constructor
)*value
.v_pointer
;
4083 insert_viewer(new_window
, viewer_constructor
);
4086 name
= g_quark_from_string("guistatistics");
4087 type
= lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute
),
4089 if(type
== LTTV_POINTER
) {
4090 lttvwindow_viewer_constructor viewer_constructor
=
4091 (lttvwindow_viewer_constructor
)*value
.v_pointer
;
4092 insert_viewer(new_window
, viewer_constructor
);
4096 g_info("There are now : %d windows\n",g_slist_length(g_main_window_list
));
4098 return new_m_window
;
4102 /* Free the memory occupied by a tab structure
4106 void tab_destructor(Tab
* tab
)
4108 int i
, nb
, ref_count
;
4111 gtk_object_destroy(GTK_OBJECT(tab
->tooltips
));
4114 g_object_unref(tab
->attributes
);
4116 if(tab
->interrupted_state
)
4117 g_object_unref(tab
->interrupted_state
);
4120 if(tab
->traceset_info
->traceset_context
!= NULL
){
4121 //remove state update hooks
4122 lttv_state_remove_event_hooks(
4123 (LttvTracesetState
*)tab
->traceset_info
->
4125 lttv_context_fini(LTTV_TRACESET_CONTEXT(tab
->traceset_info
->
4127 g_object_unref(tab
->traceset_info
->traceset_context
);
4129 if(tab
->traceset_info
->traceset
!= NULL
) {
4130 nb
= lttv_traceset_number(tab
->traceset_info
->traceset
);
4131 for(i
= 0 ; i
< nb
; i
++) {
4132 trace
= lttv_traceset_get(tab
->traceset_info
->traceset
, i
);
4133 ref_count
= lttv_trace_get_ref_number(trace
);
4135 ltt_trace_close(lttv_trace(trace
));
4139 lttv_filter_destroy(tab
->filter
);
4140 lttv_traceset_destroy(tab
->traceset_info
->traceset
);
4141 /* Remove the idle events requests processing function of the tab */
4142 g_idle_remove_by_data(tab
);
4144 g_slist_free(tab
->events_requests
);
4145 g_free(tab
->traceset_info
);
4150 /* Create a tab and insert it into the current main window
4153 Tab
* create_tab(MainWindow
* mw
, Tab
*copy_tab
,
4154 GtkNotebook
* notebook
, char * label
)
4159 //create a new tab data structure
4162 //construct and initialize the traceset_info
4163 tab
->traceset_info
= g_new(TracesetInfo
,1);
4166 tab
->traceset_info
->traceset
=
4167 lttv_traceset_copy(copy_tab
->traceset_info
->traceset
);
4169 /* Copy the previous tab's filter */
4170 /* We can clone the filter, as we copy the trace set also */
4171 /* The filter must always be in sync with the trace set */
4172 tab
->filter
= lttv_filter_clone(copy_tab
->filter
);
4174 tab
->traceset_info
->traceset
= lttv_traceset_new();
4178 lttv_attribute_write_xml(
4179 lttv_traceset_attribute(tab
->traceset_info
->traceset
),
4185 tab
->time_manager_lock
= FALSE
;
4186 tab
->current_time_manager_lock
= FALSE
;
4188 //FIXME copy not implemented in lower level
4189 tab
->traceset_info
->traceset_context
=
4190 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
4191 g_assert(tab
->traceset_info
->traceset_context
!= NULL
);
4193 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
),
4194 tab
->traceset_info
->traceset
);
4195 //add state update hooks
4196 lttv_state_add_event_hooks(
4197 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
4199 //determine the current_time and time_window of the tab
4201 if(copy_tab
!= NULL
){
4202 tab
->time_window
= copy_tab
->time_window
;
4203 tab
->current_time
= copy_tab
->current_time
;
4205 tab
->time_window
.start_time
=
4206 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
4207 time_span
.start_time
;
4208 if(DEFAULT_TIME_WIDTH_S
<
4209 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
4210 time_span
.end_time
.tv_sec
)
4211 tmp_time
.tv_sec
= DEFAULT_TIME_WIDTH_S
;
4214 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
4215 time_span
.end_time
.tv_sec
;
4216 tmp_time
.tv_nsec
= 0;
4217 tab
->time_window
.time_width
= tmp_time
;
4218 tab
->current_time
.tv_sec
=
4219 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
4220 time_span
.start_time
.tv_sec
;
4221 tab
->current_time
.tv_nsec
=
4222 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
4223 time_span
.start_time
.tv_nsec
;
4226 tab
->attributes
= LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
));
4227 tab
->interrupted_state
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
4229 tab
->vbox
= gtk_vbox_new(FALSE
, 2);
4230 tab
->viewer_container
= gtk_vbox_new(TRUE
, 2);
4231 tab
->scrollbar
= gtk_hscrollbar_new(NULL
);
4232 //tab->multivpaned = gtk_multi_vpaned_new();
4234 gtk_box_pack_start(GTK_BOX(tab
->vbox
),
4235 tab
->viewer_container
,
4237 TRUE
, /* Give the extra space to the child */
4238 0); /* No padding */
4241 // tab->time_window = copy_tab->time_window;
4242 // tab->current_time = copy_tab->current_time;
4245 /* Create the timebar */
4247 tab
->MTimebar
= gtk_hbox_new(FALSE
, 2);
4248 gtk_widget_show(tab
->MTimebar
);
4249 tab
->tooltips
= gtk_tooltips_new();
4251 tab
->MEventBox1a
= gtk_event_box_new();
4252 gtk_widget_show(tab
->MEventBox1a
);
4253 gtk_tooltips_set_tip(tab
->tooltips
, tab
->MEventBox1a
,
4254 "Paste Start and End Times Here", "");
4255 tab
->MText1a
= gtk_label_new("Time Frame ");
4256 gtk_widget_show(tab
->MText1a
);
4257 gtk_container_add(GTK_CONTAINER(tab
->MEventBox1a
), tab
->MText1a
);
4258 tab
->MEventBox1b
= gtk_event_box_new();
4259 gtk_widget_show(tab
->MEventBox1b
);
4260 gtk_tooltips_set_tip(tab
->tooltips
, tab
->MEventBox1b
,
4261 "Paste Start Time Here", "");
4262 tab
->MText1b
= gtk_label_new("start: ");
4263 gtk_widget_show(tab
->MText1b
);
4264 gtk_container_add(GTK_CONTAINER(tab
->MEventBox1b
), tab
->MText1b
);
4265 tab
->MText2
= gtk_label_new("s");
4266 gtk_widget_show(tab
->MText2
);
4267 tab
->MText3a
= gtk_label_new("ns");
4268 gtk_widget_show(tab
->MText3a
);
4269 tab
->MEventBox3b
= gtk_event_box_new();
4270 gtk_widget_show(tab
->MEventBox3b
);
4271 gtk_tooltips_set_tip(tab
->tooltips
, tab
->MEventBox3b
,
4272 "Paste End Time Here", "");
4273 tab
->MText3b
= gtk_label_new("end:");
4274 gtk_widget_show(tab
->MText3b
);
4275 gtk_container_add(GTK_CONTAINER(tab
->MEventBox3b
), tab
->MText3b
);
4276 tab
->MText4
= gtk_label_new("s");
4277 gtk_widget_show(tab
->MText4
);
4278 tab
->MText5a
= gtk_label_new("ns");
4279 gtk_widget_show(tab
->MText5a
);
4280 tab
->MEventBox5b
= gtk_event_box_new();
4281 gtk_widget_show(tab
->MEventBox5b
);
4282 gtk_tooltips_set_tip(tab
->tooltips
, tab
->MEventBox5b
,
4283 "Paste Current Time Here", "");
4284 tab
->MText5b
= gtk_label_new("Current Time:");
4285 gtk_widget_show(tab
->MText5b
);
4286 gtk_container_add(GTK_CONTAINER(tab
->MEventBox5b
), tab
->MText5b
);
4287 tab
->MText6
= gtk_label_new("s");
4288 gtk_widget_show(tab
->MText6
);
4289 tab
->MText7
= gtk_label_new("ns");
4290 gtk_widget_show(tab
->MText7
);
4292 tab
->MEntry1
= gtk_spin_button_new_with_range(0.0, 1.0, 1.0);
4293 gtk_spin_button_set_digits(GTK_SPIN_BUTTON(tab
->MEntry1
),0);
4294 gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(tab
->MEntry1
),TRUE
);
4295 gtk_widget_show(tab
->MEntry1
);
4296 tab
->MEntry2
= gtk_spin_button_new_with_range(0.0, 1.0, 1.0);
4297 gtk_spin_button_set_digits(GTK_SPIN_BUTTON(tab
->MEntry2
),0);
4298 gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(tab
->MEntry2
),TRUE
);
4299 gtk_widget_show(tab
->MEntry2
);
4300 tab
->MEntry3
= gtk_spin_button_new_with_range(0.0, 1.0, 1.0);
4301 gtk_spin_button_set_digits(GTK_SPIN_BUTTON(tab
->MEntry3
),0);
4302 gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(tab
->MEntry3
),TRUE
);
4303 gtk_widget_show(tab
->MEntry3
);
4304 tab
->MEntry4
= gtk_spin_button_new_with_range(0.0, 1.0, 1.0);
4305 gtk_spin_button_set_digits(GTK_SPIN_BUTTON(tab
->MEntry4
),0);
4306 gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(tab
->MEntry4
),TRUE
);
4307 gtk_widget_show(tab
->MEntry4
);
4308 tab
->MEntry5
= gtk_spin_button_new_with_range(0.0, 1.0, 1.0);
4309 gtk_spin_button_set_digits(GTK_SPIN_BUTTON(tab
->MEntry5
),0);
4310 gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(tab
->MEntry5
),TRUE
);
4311 gtk_widget_show(tab
->MEntry5
);
4312 tab
->MEntry6
= gtk_spin_button_new_with_range(0.0, 1.0, 1.0);
4313 gtk_spin_button_set_digits(GTK_SPIN_BUTTON(tab
->MEntry6
),0);
4314 gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(tab
->MEntry6
),TRUE
);
4315 gtk_widget_show(tab
->MEntry6
);
4318 GtkWidget
*temp_widget
;
4320 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MEventBox1a
, FALSE
,
4322 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MEventBox1b
, FALSE
,
4324 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MEntry1
, FALSE
, FALSE
, 0);
4325 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MText2
, FALSE
, FALSE
, 0);
4326 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MEntry2
, FALSE
, FALSE
, 0);
4327 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MText3a
, FALSE
, FALSE
, 0);
4328 temp_widget
= gtk_vseparator_new();
4329 gtk_widget_show(temp_widget
);
4330 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), temp_widget
, FALSE
, FALSE
, 0);
4331 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MEventBox3b
, FALSE
,
4333 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MEntry3
, FALSE
, FALSE
, 0);
4334 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MText4
, FALSE
, FALSE
, 0);
4335 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MEntry4
, FALSE
, FALSE
, 0);
4336 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MText5a
, FALSE
, FALSE
, 0);
4337 temp_widget
= gtk_vseparator_new();
4338 gtk_widget_show(temp_widget
);
4339 gtk_box_pack_end (GTK_BOX (tab
->MTimebar
), tab
->MText7
, FALSE
, FALSE
, 0);
4340 gtk_box_pack_end (GTK_BOX (tab
->MTimebar
), tab
->MEntry6
, FALSE
, FALSE
, 0);
4341 gtk_box_pack_end (GTK_BOX (tab
->MTimebar
), tab
->MText6
, FALSE
, FALSE
, 0);
4342 gtk_box_pack_end (GTK_BOX (tab
->MTimebar
), tab
->MEntry5
, FALSE
, FALSE
, 0);
4343 gtk_box_pack_end (GTK_BOX (tab
->MTimebar
), tab
->MEventBox5b
, FALSE
,
4345 gtk_box_pack_end (GTK_BOX (tab
->MTimebar
), temp_widget
, FALSE
, FALSE
, 0);
4348 //GtkWidget *test = gtk_button_new_with_label("drop");
4349 //gtk_button_set_relief(GTK_BUTTON(test), GTK_RELIEF_NONE);
4350 //gtk_widget_show(test);
4351 //gtk_box_pack_end(GTK_BOX (tab->MTimebar), test, FALSE, FALSE, 0);
4352 //gtk_widget_add_events(tab->MText1, GDK_ALL_EVENTS_MASK);//GDK_BUTTON_PRESS_MASK);
4353 /*GtkWidget *event_box = gtk_event_box_new();
4354 gtk_widget_show(event_box);
4355 gtk_tooltips_set_tip(tooltips, event_box,
4356 "Paste Current Time Here", "");
4357 gtk_box_pack_end(GTK_BOX (tab->MTimebar), event_box, FALSE, FALSE, 0);
4358 GtkWidget *test = gtk_label_new("drop");
4359 gtk_container_add(GTK_CONTAINER(event_box), test);
4360 gtk_widget_show(test);
4361 g_signal_connect (G_OBJECT(event_box),
4362 "button-press-event",
4363 G_CALLBACK (on_MText1_paste),
4367 g_signal_connect (G_OBJECT(tab
->MEventBox1a
),
4368 "button-press-event",
4369 G_CALLBACK (on_MEventBox1a_paste
),
4372 g_signal_connect (G_OBJECT(tab
->MEventBox1b
),
4373 "button-press-event",
4374 G_CALLBACK (on_MEventBox1b_paste
),
4376 g_signal_connect (G_OBJECT(tab
->MEventBox3b
),
4377 "button-press-event",
4378 G_CALLBACK (on_MEventBox3b_paste
),
4380 g_signal_connect (G_OBJECT(tab
->MEventBox5b
),
4381 "button-press-event",
4382 G_CALLBACK (on_MEventBox5b_paste
),
4386 gtk_box_pack_end(GTK_BOX(tab
->vbox
),
4388 FALSE
, /* Do not expand */
4389 FALSE
, /* Fill has no effect here (expand false) */
4390 0); /* No padding */
4392 gtk_box_pack_end(GTK_BOX(tab
->vbox
),
4394 FALSE
, /* Do not expand */
4395 FALSE
, /* Fill has no effect here (expand false) */
4396 0); /* No padding */
4398 g_object_set_data(G_OBJECT(tab
->viewer_container
), "focused_viewer", NULL
);
4404 // Display a label with a X
4405 GtkWidget *w_hbox = gtk_hbox_new(FALSE, 4);
4406 GtkWidget *w_label = gtk_label_new (label);
4407 GtkWidget *pixmap = create_pixmap(GTK_WIDGET(notebook), "close.png");
4408 GtkWidget *w_button = gtk_button_new ();
4409 gtk_container_add(GTK_CONTAINER(w_button), pixmap);
4410 //GtkWidget *w_button = gtk_button_new_with_label("x");
4412 gtk_button_set_relief(GTK_BUTTON(w_button), GTK_RELIEF_NONE);
4414 gtk_box_pack_start(GTK_BOX(w_hbox), w_label, TRUE, TRUE, 0);
4415 gtk_box_pack_end(GTK_BOX(w_hbox), w_button, FALSE,
4418 g_signal_connect_swapped (w_button, "clicked",
4419 G_CALLBACK (on_close_tab_X_clicked),
4422 gtk_widget_set_state(w_button, GTK_STATE_ACTIVE);
4424 gtk_widget_show (w_label);
4425 gtk_widget_show (pixmap);
4426 gtk_widget_show (w_button);
4427 gtk_widget_show (w_hbox);
4429 tab->label = w_hbox;
4433 tab
->label
= gtk_label_new (label
);
4435 gtk_widget_show(tab
->label
);
4436 gtk_widget_show(tab
->scrollbar
);
4437 gtk_widget_show(tab
->viewer_container
);
4438 gtk_widget_show(tab
->vbox
);
4439 //gtk_widget_show(tab->multivpaned);
4442 /* Start with empty events requests list */
4443 tab
->events_requests
= NULL
;
4444 tab
->events_request_pending
= FALSE
;
4446 g_object_set_data_full(
4447 G_OBJECT(tab
->vbox
),
4450 (GDestroyNotify
)tab_destructor
);
4452 g_signal_connect(G_OBJECT(tab
->scrollbar
), "value-changed",
4453 G_CALLBACK(scroll_value_changed_cb
), tab
);
4455 g_signal_connect ((gpointer
) tab
->MEntry1
, "value-changed",
4456 G_CALLBACK (on_MEntry1_value_changed
),
4458 g_signal_connect ((gpointer
) tab
->MEntry2
, "value-changed",
4459 G_CALLBACK (on_MEntry2_value_changed
),
4461 g_signal_connect ((gpointer
) tab
->MEntry3
, "value-changed",
4462 G_CALLBACK (on_MEntry3_value_changed
),
4464 g_signal_connect ((gpointer
) tab
->MEntry4
, "value-changed",
4465 G_CALLBACK (on_MEntry4_value_changed
),
4467 g_signal_connect ((gpointer
) tab
->MEntry5
, "value-changed",
4468 G_CALLBACK (on_MEntry5_value_changed
),
4470 g_signal_connect ((gpointer
) tab
->MEntry6
, "value-changed",
4471 G_CALLBACK (on_MEntry6_value_changed
),
4474 //g_signal_connect(G_OBJECT(tab->scrollbar), "changed",
4475 // G_CALLBACK(scroll_value_changed_cb), tab);
4478 //insert tab into notebook
4479 gtk_notebook_append_page(notebook
,
4482 list
= gtk_container_get_children(GTK_CONTAINER(notebook
));
4483 gtk_notebook_set_current_page(notebook
,g_list_length(list
)-1);
4484 // always show : not if(g_list_length(list)>1)
4485 gtk_notebook_set_show_tabs(notebook
, TRUE
);
4488 lttvwindow_report_time_window(tab
, copy_tab
->time_window
);
4489 lttvwindow_report_current_time(tab
, copy_tab
->current_time
);
4491 TimeWindow time_window
;
4493 time_window
.start_time
= ltt_time_zero
;
4494 time_window
.end_time
= ltt_time_add(time_window
.start_time
,
4495 lttvwindow_default_time_width
);
4496 time_window
.time_width
= lttvwindow_default_time_width
;
4497 time_window
.time_width_double
= ltt_time_to_double(time_window
.time_width
);
4499 lttvwindow_report_time_window(tab
, time_window
);
4500 lttvwindow_report_current_time(tab
, ltt_time_zero
);
4503 LttvTraceset
*traceset
= tab
->traceset_info
->traceset
;
4504 SetTraceset(tab
, traceset
);
4510 * execute_events_requests
4512 * Idle function that executes the pending requests for a tab.
4514 * @return return value : TRUE : keep the idle function, FALSE : remove it.
4516 gboolean
execute_events_requests(Tab
*tab
)
4518 return ( lttvwindow_process_pending_requests(tab
) );
4522 void create_main_window_with_trace(const gchar
*path
)
4524 if(path
== NULL
) return;
4527 MainWindow
*mw
= construct_main_window(NULL
);
4528 GtkWidget
*widget
= mw
->mwindow
;
4530 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
4531 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
4532 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
4536 tab
= create_new_tab(widget
, NULL
);
4538 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
4542 gchar abs_path
[PATH_MAX
];
4546 get_absolute_pathname(path
, abs_path
);
4547 trace_v
= lttvwindowtraces_get_trace_by_name(abs_path
);
4548 if(trace_v
== NULL
) {
4549 trace
= ltt_trace_open(abs_path
);
4551 g_warning("cannot open trace %s", abs_path
);
4553 GtkWidget
*dialogue
=
4554 gtk_message_dialog_new(
4555 GTK_WINDOW(gtk_widget_get_toplevel(widget
)),
4556 GTK_DIALOG_MODAL
|GTK_DIALOG_DESTROY_WITH_PARENT
,
4559 "Cannot open trace : maybe you should enter in the directory"
4561 gtk_dialog_run(GTK_DIALOG(dialogue
));
4562 gtk_widget_destroy(dialogue
);
4564 trace_v
= lttv_trace_new(trace
);
4565 lttvwindowtraces_add_trace(trace_v
);
4566 lttvwindow_add_trace(tab
, trace_v
);
4569 lttvwindow_add_trace(tab
, trace_v
);
4572 LttvTraceset
*traceset
;
4574 traceset
= tab
->traceset_info
->traceset
;
4575 SetTraceset(tab
, traceset
);