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)
2176 new_time_window
.start_time
= time_span
.start_time
;
2177 new_time_window
.end_time
= ltt_time_add(new_time_window
.start_time
,
2178 new_time_window
.time_width
) ;
2182 if(ltt_time_compare(new_time_window
.end_time
,
2183 time_span
.end_time
) > 0)
2185 new_time_window
.start_time
=
2186 ltt_time_sub(time_span
.end_time
, new_time_window
.time_width
);
2188 new_time_window
.end_time
= ltt_time_add(new_time_window
.start_time
,
2189 new_time_window
.time_width
) ;
2196 if(ltt_time_compare(new_time_window
.time_width
, ltt_time_zero
) == 0) {
2197 g_warning("Zoom more than 1 ns impossible");
2199 time_change_manager(tab
, new_time_window
);
2203 void zoom_in(GtkWidget
* widget
, gpointer user_data
)
2208 void zoom_out(GtkWidget
* widget
, gpointer user_data
)
2213 void zoom_extended(GtkWidget
* widget
, gpointer user_data
)
2218 void go_to_time(GtkWidget
* widget
, gpointer user_data
)
2220 g_info("Go to time\n");
2223 void show_time_frame(GtkWidget
* widget
, gpointer user_data
)
2225 g_info("Show time frame\n");
2229 /* callback function */
2232 on_empty_traceset_activate (GtkMenuItem
*menuitem
,
2235 create_new_window((GtkWidget
*)menuitem
, user_data
, FALSE
);
2240 on_clone_traceset_activate (GtkMenuItem
*menuitem
,
2243 create_new_window((GtkWidget
*)menuitem
, user_data
, TRUE
);
2247 /* create_new_tab calls create_tab to construct a new tab in the main window
2250 Tab
*create_new_tab(GtkWidget
* widget
, gpointer user_data
){
2251 gchar label
[PATH_MAX
];
2252 MainWindow
* mw_data
= get_window_data_struct(widget
);
2254 GtkNotebook
* notebook
= (GtkNotebook
*)lookup_widget(widget
, "MNotebook");
2255 if(notebook
== NULL
){
2256 g_info("Notebook does not exist\n");
2259 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
2260 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
2266 copy_tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
2269 strcpy(label
,"Page");
2270 if(get_label(mw_data
, label
,"Get the name of the tab","Please input tab's name"))
2271 return (create_tab (mw_data
, copy_tab
, notebook
, label
));
2277 on_tab_activate (GtkMenuItem
*menuitem
,
2280 create_new_tab((GtkWidget
*)menuitem
, user_data
);
2285 on_open_activate (GtkMenuItem
*menuitem
,
2288 open_traceset((GtkWidget
*)menuitem
, user_data
);
2293 on_close_activate (GtkMenuItem
*menuitem
,
2296 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2297 main_window_destructor(mw_data
);
2301 /* remove the current tab from the main window
2305 on_close_tab_activate (GtkWidget
*widget
,
2309 GtkWidget
* notebook
;
2311 MainWindow
* mw_data
= get_window_data_struct(widget
);
2312 notebook
= lookup_widget(widget
, "MNotebook");
2313 if(notebook
== NULL
){
2314 g_info("Notebook does not exist\n");
2318 page_num
= gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
));
2320 gtk_notebook_remove_page(GTK_NOTEBOOK(notebook
), page_num
);
2325 on_close_tab_X_clicked (GtkWidget
*widget
,
2329 GtkWidget
*notebook
= lookup_widget(widget
, "MNotebook");
2330 if(notebook
== NULL
){
2331 g_info("Notebook does not exist\n");
2335 if((page_num
= gtk_notebook_page_num(GTK_NOTEBOOK(notebook
), widget
)) != -1)
2336 gtk_notebook_remove_page(GTK_NOTEBOOK(notebook
), page_num
);
2342 on_add_trace_activate (GtkMenuItem
*menuitem
,
2345 add_trace((GtkWidget
*)menuitem
, user_data
);
2350 on_remove_trace_activate (GtkMenuItem
*menuitem
,
2353 remove_trace((GtkWidget
*)menuitem
, user_data
);
2358 on_save_activate (GtkMenuItem
*menuitem
,
2361 save((GtkWidget
*)menuitem
, user_data
);
2366 on_save_as_activate (GtkMenuItem
*menuitem
,
2369 save_as((GtkWidget
*)menuitem
, user_data
);
2374 on_quit_activate (GtkMenuItem
*menuitem
,
2382 on_cut_activate (GtkMenuItem
*menuitem
,
2390 on_copy_activate (GtkMenuItem
*menuitem
,
2398 on_paste_activate (GtkMenuItem
*menuitem
,
2406 on_delete_activate (GtkMenuItem
*menuitem
,
2414 on_zoom_in_activate (GtkMenuItem
*menuitem
,
2417 zoom_in((GtkWidget
*)menuitem
, user_data
);
2422 on_zoom_out_activate (GtkMenuItem
*menuitem
,
2425 zoom_out((GtkWidget
*)menuitem
, user_data
);
2430 on_zoom_extended_activate (GtkMenuItem
*menuitem
,
2433 zoom_extended((GtkWidget
*)menuitem
, user_data
);
2438 on_go_to_time_activate (GtkMenuItem
*menuitem
,
2441 go_to_time((GtkWidget
*)menuitem
, user_data
);
2446 on_show_time_frame_activate (GtkMenuItem
*menuitem
,
2449 show_time_frame((GtkWidget
*)menuitem
, user_data
);
2454 on_move_viewer_up_activate (GtkMenuItem
*menuitem
,
2457 move_up_viewer((GtkWidget
*)menuitem
, user_data
);
2462 on_move_viewer_down_activate (GtkMenuItem
*menuitem
,
2465 move_down_viewer((GtkWidget
*)menuitem
, user_data
);
2470 on_remove_viewer_activate (GtkMenuItem
*menuitem
,
2473 delete_viewer((GtkWidget
*)menuitem
, user_data
);
2477 on_trace_facility_activate (GtkMenuItem
*menuitem
,
2480 g_info("Trace facility selector: %s\n");
2484 /* Dispaly a file selection dialogue to let user select a library, then call
2485 * lttv_library_load().
2489 on_load_library_activate (GtkMenuItem
*menuitem
,
2492 GError
*error
= NULL
;
2493 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2495 gchar load_module_path_alter
[PATH_MAX
];
2499 gchar
*load_module_path
;
2500 name
= g_ptr_array_new();
2501 nb
= lttv_library_path_number();
2502 /* ask for the library path */
2506 path
= lttv_library_path_get(i
);
2507 g_ptr_array_add(name
, path
);
2510 load_module_path
= get_selection(mw_data
,
2511 (char **)(name
->pdata
), name
->len
,
2512 "Select a library path", "Library paths");
2513 if(load_module_path
!= NULL
)
2514 strncpy(load_module_path_alter
, load_module_path
, PATH_MAX
-1); // -1 for /
2516 g_ptr_array_free(name
, TRUE
);
2518 if(load_module_path
== NULL
) return;
2522 /* Make sure the module path ends with a / */
2523 gchar
*ptr
= load_module_path_alter
;
2525 ptr
= strchr(ptr
, '\0');
2527 if(*(ptr
-1) != '/') {
2534 /* Ask for the library to load : list files in the previously selected
2536 gchar str
[PATH_MAX
];
2539 GtkFileSelection
* file_selector
=
2540 (GtkFileSelection
*)gtk_file_selection_new("Select a module");
2541 gtk_file_selection_set_filename(file_selector
, load_module_path_alter
);
2542 gtk_file_selection_hide_fileop_buttons(file_selector
);
2544 gtk_window_set_transient_for(GTK_WINDOW(file_selector
),
2545 GTK_WINDOW(mw_data
->mwindow
));
2548 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
2550 case GTK_RESPONSE_ACCEPT
:
2551 case GTK_RESPONSE_OK
:
2552 dir
= gtk_file_selection_get_selections (file_selector
);
2553 strncpy(str
,dir
[0],PATH_MAX
);
2554 strncpy(remember_plugins_dir
,dir
[0],PATH_MAX
);
2555 /* only keep file name */
2557 str1
= strrchr(str
,'/');
2560 str1
= strrchr(str
,'\\');
2565 if(*str1
== 'l' && *(str1
+1)== 'i' && *(str1
+2)=='b')
2567 remove info after
. */
2571 str2
= strrchr(str2
, '.');
2572 if(str2
!= NULL
) *str2
= '\0';
2574 lttv_module_require(str1
, &error
);
2576 lttv_library_load(str1
, &error
);
2577 if(error
!= NULL
) g_warning("%s", error
->message
);
2578 else g_info("Load library: %s\n", str
);
2580 case GTK_RESPONSE_REJECT
:
2581 case GTK_RESPONSE_CANCEL
:
2583 gtk_widget_destroy((GtkWidget
*)file_selector
);
2594 /* Display all loaded modules, let user to select a module to unload
2595 * by calling lttv_module_unload
2599 on_unload_library_activate (GtkMenuItem
*menuitem
,
2602 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2604 LttvLibrary
*library
= NULL
;
2609 name
= g_ptr_array_new();
2610 nb
= lttv_library_number();
2611 LttvLibraryInfo
*lib_info
= g_new(LttvLibraryInfo
,nb
);
2612 /* ask for the library name */
2615 LttvLibrary
*iter_lib
= lttv_library_get(i
);
2616 lttv_library_info(iter_lib
, &lib_info
[i
]);
2618 gchar
*path
= lib_info
[i
].name
;
2619 g_ptr_array_add(name
, path
);
2621 lib_name
= get_selection(mw_data
, (char **)(name
->pdata
), name
->len
,
2622 "Select a library", "Libraries");
2623 if(lib_name
!= NULL
) {
2625 if(strcmp(lib_name
, lib_info
[i
].name
) == 0) {
2626 library
= lttv_library_get(i
);
2631 g_ptr_array_free(name
, TRUE
);
2634 if(lib_name
== NULL
) return;
2636 if(library
!= NULL
) lttv_library_unload(library
);
2640 /* Dispaly a file selection dialogue to let user select a module, then call
2641 * lttv_module_require().
2645 on_load_module_activate (GtkMenuItem
*menuitem
,
2648 GError
*error
= NULL
;
2649 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2651 LttvLibrary
*library
= NULL
;
2656 name
= g_ptr_array_new();
2657 nb
= lttv_library_number();
2658 LttvLibraryInfo
*lib_info
= g_new(LttvLibraryInfo
,nb
);
2659 /* ask for the library name */
2662 LttvLibrary
*iter_lib
= lttv_library_get(i
);
2663 lttv_library_info(iter_lib
, &lib_info
[i
]);
2665 gchar
*path
= lib_info
[i
].name
;
2666 g_ptr_array_add(name
, path
);
2668 lib_name
= get_selection(mw_data
,(char **)(name
->pdata
), name
->len
,
2669 "Select a library", "Libraries");
2670 if(lib_name
!= NULL
) {
2672 if(strcmp(lib_name
, lib_info
[i
].name
) == 0) {
2673 library
= lttv_library_get(i
);
2678 g_ptr_array_free(name
, TRUE
);
2681 if(lib_name
== NULL
) return;
2684 //LttvModule *module;
2685 gchar module_name_out
[PATH_MAX
];
2687 /* Ask for the module to load : list modules in the selected lib */
2691 nb
= lttv_library_module_number(library
);
2692 LttvModuleInfo
*module_info
= g_new(LttvModuleInfo
,nb
);
2693 name
= g_ptr_array_new();
2694 /* ask for the module name */
2697 LttvModule
*iter_module
= lttv_library_module_get(library
, i
);
2698 lttv_module_info(iter_module
, &module_info
[i
]);
2700 gchar
*path
= module_info
[i
].name
;
2701 g_ptr_array_add(name
, path
);
2703 module_name
= get_selection(mw_data
, (char **)(name
->pdata
), name
->len
,
2704 "Select a module", "Modules");
2705 if(module_name
!= NULL
) {
2707 if(strcmp(module_name
, module_info
[i
].name
) == 0) {
2708 strncpy(module_name_out
, module_name
, PATH_MAX
);
2709 //module = lttv_library_module_get(i);
2715 g_ptr_array_free(name
, TRUE
);
2716 g_free(module_info
);
2718 if(module_name
== NULL
) return;
2721 lttv_module_require(module_name_out
, &error
);
2722 if(error
!= NULL
) g_warning("%s", error
->message
);
2723 else g_info("Load module: %s", module_name_out
);
2730 gchar str
[PATH_MAX
];
2733 GtkFileSelection
* file_selector
=
2734 (GtkFileSelection
*)gtk_file_selection_new("Select a module");
2735 gtk_file_selection_set_filename(file_selector
, load_module_path_alter
);
2736 gtk_file_selection_hide_fileop_buttons(file_selector
);
2739 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
2741 case GTK_RESPONSE_ACCEPT
:
2742 case GTK_RESPONSE_OK
:
2743 dir
= gtk_file_selection_get_selections (file_selector
);
2744 strncpy(str
,dir
[0],PATH_MAX
);
2745 strncpy(remember_plugins_dir
,dir
[0],PATH_MAX
);
2747 /* only keep file name */
2749 str1
= strrchr(str
,'/');
2752 str1
= strrchr(str
,'\\');
2757 if(*str1
== 'l' && *(str1
+1)== 'i' && *(str1
+2)=='b')
2759 remove info after
. */
2763 str2
= strrchr(str2
, '.');
2764 if(str2
!= NULL
) *str2
= '\0';
2766 lttv_module_require(str1
, &error
);
2768 lttv_library_load(str1
, &error
);
2769 if(error
!= NULL
) g_warning(error
->message
);
2770 else g_info("Load library: %s\n", str
);
2772 case GTK_RESPONSE_REJECT
:
2773 case GTK_RESPONSE_CANCEL
:
2775 gtk_widget_destroy((GtkWidget
*)file_selector
);
2787 /* Display all loaded modules, let user to select a module to unload
2788 * by calling lttv_module_unload
2792 on_unload_module_activate (GtkMenuItem
*menuitem
,
2795 GError
*error
= NULL
;
2796 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2798 LttvLibrary
*library
;
2803 name
= g_ptr_array_new();
2804 nb
= lttv_library_number();
2805 LttvLibraryInfo
*lib_info
= g_new(LttvLibraryInfo
,nb
);
2806 /* ask for the library name */
2809 LttvLibrary
*iter_lib
= lttv_library_get(i
);
2810 lttv_library_info(iter_lib
, &lib_info
[i
]);
2812 gchar
*path
= lib_info
[i
].name
;
2813 g_ptr_array_add(name
, path
);
2815 lib_name
= get_selection(mw_data
, (char **)(name
->pdata
), name
->len
,
2816 "Select a library", "Libraries");
2817 if(lib_name
!= NULL
) {
2819 if(strcmp(lib_name
, lib_info
[i
].name
) == 0) {
2820 library
= lttv_library_get(i
);
2825 g_ptr_array_free(name
, TRUE
);
2828 if(lib_name
== NULL
) return;
2831 LttvModule
*module
= NULL
;
2833 /* Ask for the module to load : list modules in the selected lib */
2837 nb
= lttv_library_module_number(library
);
2838 LttvModuleInfo
*module_info
= g_new(LttvModuleInfo
,nb
);
2839 name
= g_ptr_array_new();
2840 /* ask for the module name */
2843 LttvModule
*iter_module
= lttv_library_module_get(library
, i
);
2844 lttv_module_info(iter_module
, &module_info
[i
]);
2846 gchar
*path
= module_info
[i
].name
;
2847 if(module_info
[i
].use_count
> 0) g_ptr_array_add(name
, path
);
2849 module_name
= get_selection(mw_data
, (char **)(name
->pdata
), name
->len
,
2850 "Select a module", "Modules");
2851 if(module_name
!= NULL
) {
2853 if(strcmp(module_name
, module_info
[i
].name
) == 0) {
2854 module
= lttv_library_module_get(library
, i
);
2860 g_ptr_array_free(name
, TRUE
);
2861 g_free(module_info
);
2863 if(module_name
== NULL
) return;
2866 LttvModuleInfo module_info
;
2867 lttv_module_info(module
, &module_info
);
2868 g_info("Release module: %s\n", module_info
.name
);
2870 lttv_module_release(module
);
2874 /* Display a directory dialogue to let user select a path for library searching
2878 on_add_library_search_path_activate (GtkMenuItem
*menuitem
,
2881 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2882 //GtkDirSelection * file_selector = (GtkDirSelection *)gtk_dir_selection_new("Select library path");
2883 GtkFileSelection
* file_selector
= (GtkFileSelection
*)gtk_file_selection_new("Select a trace");
2884 gtk_widget_hide( (file_selector
)->file_list
->parent
) ;
2886 gtk_window_set_transient_for(GTK_WINDOW(file_selector
),
2887 GTK_WINDOW(mw_data
->mwindow
));
2892 if(remember_plugins_dir
[0] != '\0')
2893 gtk_file_selection_set_filename(file_selector
, remember_plugins_dir
);
2895 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
2897 case GTK_RESPONSE_ACCEPT
:
2898 case GTK_RESPONSE_OK
:
2899 dir
= gtk_file_selection_get_filename (file_selector
);
2900 strncpy(remember_plugins_dir
,dir
,PATH_MAX
);
2901 strncat(remember_plugins_dir
,"/",PATH_MAX
);
2902 lttv_library_path_add(dir
);
2903 case GTK_RESPONSE_REJECT
:
2904 case GTK_RESPONSE_CANCEL
:
2906 gtk_widget_destroy((GtkWidget
*)file_selector
);
2912 /* Display a directory dialogue to let user select a path for library searching
2916 on_remove_library_search_path_activate (GtkMenuItem
*menuitem
,
2919 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2921 const char *lib_path
;
2926 name
= g_ptr_array_new();
2927 nb
= lttv_library_path_number();
2928 /* ask for the library name */
2931 gchar
*path
= lttv_library_path_get(i
);
2932 g_ptr_array_add(name
, path
);
2934 lib_path
= get_selection(mw_data
, (char **)(name
->pdata
), name
->len
,
2935 "Select a library path", "Library paths");
2937 g_ptr_array_free(name
, TRUE
);
2939 if(lib_path
== NULL
) return;
2942 lttv_library_path_remove(lib_path
);
2946 on_color_activate (GtkMenuItem
*menuitem
,
2954 on_save_configuration_activate (GtkMenuItem
*menuitem
,
2957 g_info("Save configuration\n");
2962 on_content_activate (GtkMenuItem
*menuitem
,
2965 g_info("Content\n");
2970 on_about_close_activate (GtkButton
*button
,
2973 GtkWidget
*about_widget
= GTK_WIDGET(user_data
);
2975 gtk_widget_destroy(about_widget
);
2979 on_about_activate (GtkMenuItem
*menuitem
,
2982 MainWindow
*main_window
= get_window_data_struct(GTK_WIDGET(menuitem
));
2983 GtkWidget
*window_widget
= main_window
->mwindow
;
2984 GtkWidget
*about_widget
= gtk_window_new(GTK_WINDOW_TOPLEVEL
);
2985 GtkWindow
*about_window
= GTK_WINDOW(about_widget
);
2986 gint window_width
, window_height
;
2988 gtk_window_set_title(about_window
, "About Linux Trace Toolkit");
2990 gtk_window_set_resizable(about_window
, FALSE
);
2991 gtk_window_set_transient_for(GTK_WINDOW(window_widget
), about_window
);
2992 gtk_window_set_destroy_with_parent(about_window
, TRUE
);
2993 gtk_window_set_modal(about_window
, FALSE
);
2995 /* Put the about window at the center of the screen */
2996 gtk_window_get_size(about_window
, &window_width
, &window_height
);
2997 gtk_window_move (about_window
,
2998 (gdk_screen_width() - window_width
)/2,
2999 (gdk_screen_height() - window_height
)/2);
3001 GtkWidget
*vbox
= gtk_vbox_new(FALSE
, 1);
3003 gtk_container_add(GTK_CONTAINER(about_widget
), vbox
);
3007 GtkWidget
*label1
= gtk_label_new("");
3008 gtk_misc_set_padding(GTK_MISC(label1
), 10, 20);
3009 gtk_label_set_markup(GTK_LABEL(label1
), "\
3010 <big>Linux Trace Toolkit</big>");
3011 gtk_label_set_justify(GTK_LABEL(label1
), GTK_JUSTIFY_CENTER
);
3013 GtkWidget
*label2
= gtk_label_new("");
3014 gtk_misc_set_padding(GTK_MISC(label2
), 10, 20);
3015 gtk_label_set_markup(GTK_LABEL(label2
), "\
3018 Michel Dagenais (New trace format, lttv main)\n\
3019 Mathieu Desnoyers (Kernel Tracer, Directory structure, build with automake/conf,\n\
3020 lttv gui, control flow view, gui cooperative trace reading\n\
3021 scheduler with interruptible foreground and background\n\
3022 computation, detailed event list (rewrite), trace reading\n\
3023 library (rewrite))\n\
3024 Benoit Des Ligneris, Eric Clement (Cluster adaptation, work in progress)\n\
3025 Xang-Xiu Yang (new trace reading library and converter, lttv gui, \n\
3026 detailed event list and statistics view)\n\
3027 Tom Zanussi (RelayFS)\n\
3029 Strongly inspired from the original Linux Trace Toolkit Visualizer made by\n\
3032 GtkWidget
*label3
= gtk_label_new("");
3033 gtk_label_set_markup(GTK_LABEL(label3
), "\
3034 Linux Trace Toolkit Viewer, Copyright (C) 2004\n\
3036 Mathieu Desnoyers\n\
3038 Linux Trace Toolkit comes with ABSOLUTELY NO WARRANTY.\n\
3039 This is free software, and you are welcome to redistribute it\n\
3040 under certain conditions. See COPYING for details.");
3041 gtk_misc_set_padding(GTK_MISC(label3
), 10, 20);
3043 gtk_box_pack_start_defaults(GTK_BOX(vbox
), label1
);
3044 gtk_box_pack_start_defaults(GTK_BOX(vbox
), label2
);
3045 gtk_box_pack_start_defaults(GTK_BOX(vbox
), label3
);
3047 GtkWidget
*hbox
= gtk_hbox_new(TRUE
, 0);
3048 gtk_box_pack_end(GTK_BOX(vbox
), hbox
, FALSE
, FALSE
, 0);
3049 GtkWidget
*close_button
= gtk_button_new_with_mnemonic("_Close");
3050 gtk_box_pack_end(GTK_BOX(hbox
), close_button
, FALSE
, FALSE
, 0);
3051 gtk_container_set_border_width(GTK_CONTAINER(close_button
), 20);
3053 g_signal_connect(G_OBJECT(close_button
), "clicked",
3054 G_CALLBACK(on_about_close_activate
),
3055 (gpointer
)about_widget
);
3057 gtk_widget_show_all(about_widget
);
3062 on_button_new_clicked (GtkButton
*button
,
3065 create_new_window((GtkWidget
*)button
, user_data
, TRUE
);
3069 on_button_new_tab_clicked (GtkButton
*button
,
3072 create_new_tab((GtkWidget
*)button
, user_data
);
3076 on_button_open_clicked (GtkButton
*button
,
3079 open_traceset((GtkWidget
*)button
, user_data
);
3084 on_button_add_trace_clicked (GtkButton
*button
,
3087 add_trace((GtkWidget
*)button
, user_data
);
3092 on_button_remove_trace_clicked (GtkButton
*button
,
3095 remove_trace((GtkWidget
*)button
, user_data
);
3099 on_button_redraw_clicked (GtkButton
*button
,
3102 redraw((GtkWidget
*)button
, user_data
);
3106 on_button_continue_processing_clicked (GtkButton
*button
,
3109 continue_processing((GtkWidget
*)button
, user_data
);
3113 on_button_stop_processing_clicked (GtkButton
*button
,
3116 stop_processing((GtkWidget
*)button
, user_data
);
3122 on_button_save_clicked (GtkButton
*button
,
3125 save((GtkWidget
*)button
, user_data
);
3130 on_button_save_as_clicked (GtkButton
*button
,
3133 save_as((GtkWidget
*)button
, user_data
);
3138 on_button_zoom_in_clicked (GtkButton
*button
,
3141 zoom_in((GtkWidget
*)button
, user_data
);
3146 on_button_zoom_out_clicked (GtkButton
*button
,
3149 zoom_out((GtkWidget
*)button
, user_data
);
3154 on_button_zoom_extended_clicked (GtkButton
*button
,
3157 zoom_extended((GtkWidget
*)button
, user_data
);
3162 on_button_go_to_time_clicked (GtkButton
*button
,
3165 go_to_time((GtkWidget
*)button
, user_data
);
3170 on_button_show_time_frame_clicked (GtkButton
*button
,
3173 show_time_frame((GtkWidget
*)button
, user_data
);
3178 on_button_move_up_clicked (GtkButton
*button
,
3181 move_up_viewer((GtkWidget
*)button
, user_data
);
3186 on_button_move_down_clicked (GtkButton
*button
,
3189 move_down_viewer((GtkWidget
*)button
, user_data
);
3194 on_button_delete_viewer_clicked (GtkButton
*button
,
3197 delete_viewer((GtkWidget
*)button
, user_data
);
3201 on_MWindow_destroy (GtkWidget
*widget
,
3204 MainWindow
*main_window
= get_window_data_struct(widget
);
3205 LttvIAttribute
*attributes
= main_window
->attributes
;
3206 LttvAttributeValue value
;
3208 //This is unnecessary, since widgets will be destroyed
3209 //by the main window widget anyway.
3210 //remove_all_menu_toolbar_constructors(main_window, NULL);
3212 g_assert(lttv_iattribute_find_by_path(attributes
,
3213 "viewers/menu", LTTV_POINTER
, &value
));
3214 lttv_menus_destroy((LttvMenus
*)*(value
.v_pointer
));
3216 g_assert(lttv_iattribute_find_by_path(attributes
,
3217 "viewers/toolbar", LTTV_POINTER
, &value
));
3218 lttv_toolbars_destroy((LttvToolbars
*)*(value
.v_pointer
));
3220 g_object_unref(main_window
->attributes
);
3221 g_main_window_list
= g_slist_remove(g_main_window_list
, main_window
);
3223 g_info("There are now : %d windows\n",g_slist_length(g_main_window_list
));
3224 if(g_slist_length(g_main_window_list
) == 0)
3229 on_MWindow_configure (GtkWidget
*widget
,
3230 GdkEventConfigure
*event
,
3233 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)widget
);
3235 // MD : removed time width modification upon resizing of the main window.
3236 // The viewers will redraw themselves completely, without time interval
3239 if(mw_data->window_width){
3240 time_span = LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->Time_Span ;
3241 time_win = tab->time_window;
3242 ratio = width / mw_data->window_width;
3243 tab->time_window.time_width = ltt_time_mul(time_win.time_width,ratio);
3244 time = ltt_time_sub(time_span->endTime, time_win.start_time);
3245 if(ltt_time_compare(time, tab->time_window.time_width) < 0){
3246 tab->time_window.time_width = time;
3252 mw_data->window_width = (int)width;
3261 on_MNotebook_switch_page (GtkNotebook
*notebook
,
3262 GtkNotebookPage
*page
,
3270 void time_change_manager (Tab
*tab
,
3271 TimeWindow new_time_window
)
3273 /* Only one source of time change */
3274 if(tab
->time_manager_lock
== TRUE
) return;
3276 tab
->time_manager_lock
= TRUE
;
3278 LttvTracesetContext
*tsc
= LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3279 TimeInterval time_span
= tsc
->time_span
;
3280 LttTime start_time
= new_time_window
.start_time
;
3281 LttTime end_time
= new_time_window
.end_time
;
3283 g_assert(ltt_time_compare(start_time
, end_time
) < 0);
3286 GtkAdjustment
*adjustment
= gtk_range_get_adjustment(GTK_RANGE(tab
->scrollbar
));
3287 LttTime upper
= ltt_time_sub(time_span
.end_time
, time_span
.start_time
);
3289 gtk_range_set_increments(GTK_RANGE(tab
->scrollbar
),
3290 ltt_time_to_double(new_time_window
.time_width
)
3291 / SCROLL_STEP_PER_PAGE
3292 * NANOSECONDS_PER_SECOND
, /* step increment */
3293 ltt_time_to_double(new_time_window
.time_width
)
3294 * NANOSECONDS_PER_SECOND
); /* page increment */
3295 gtk_range_set_range(GTK_RANGE(tab
->scrollbar
),
3297 ltt_time_to_double(upper
)
3298 * NANOSECONDS_PER_SECOND
); /* upper */
3300 g_object_set(G_OBJECT(adjustment
),
3304 ltt_time_to_double(upper
), /* upper */
3306 new_time_window
.time_width_double
3307 / SCROLL_STEP_PER_PAGE
, /* step increment */
3309 new_time_window
.time_width_double
,
3310 /* page increment */
3312 new_time_window
.time_width_double
, /* page size */
3314 gtk_adjustment_changed(adjustment
);
3316 // g_object_set(G_OBJECT(adjustment),
3318 // ltt_time_to_double(
3319 // ltt_time_sub(start_time, time_span.start_time))
3322 //gtk_adjustment_value_changed(adjustment);
3323 gtk_range_set_value(GTK_RANGE(tab
->scrollbar
),
3325 ltt_time_sub(start_time
, time_span
.start_time
)) /* value */);
3327 /* set the time bar. */
3329 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry1
),
3330 (double)time_span
.start_time
.tv_sec
,
3331 (double)time_span
.end_time
.tv_sec
);
3332 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry1
),
3333 (double)start_time
.tv_sec
);
3335 /* start nanoseconds */
3336 if(start_time
.tv_sec
== time_span
.start_time
.tv_sec
) {
3337 /* can be both beginning and end at the same time. */
3338 if(start_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3339 /* If we are at the end, max nsec to end.. -1 (not zero length) */
3340 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry2
),
3341 (double)time_span
.start_time
.tv_nsec
,
3342 (double)time_span
.end_time
.tv_nsec
-1);
3344 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry2
),
3345 (double)time_span
.start_time
.tv_nsec
,
3346 (double)NANOSECONDS_PER_SECOND
-1);
3348 } else if(start_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3349 /* If we are at the end, max nsec to end.. -1 (not zero length) */
3350 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry2
),
3352 (double)time_span
.end_time
.tv_nsec
-1);
3353 } else /* anywhere else */
3354 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry2
),
3356 (double)NANOSECONDS_PER_SECOND
-1);
3357 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry2
),
3358 (double)start_time
.tv_nsec
);
3361 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry3
),
3362 (double)time_span
.start_time
.tv_sec
,
3363 (double)time_span
.end_time
.tv_sec
);
3364 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry3
),
3365 (double)end_time
.tv_sec
);
3367 /* end nanoseconds */
3368 if(end_time
.tv_sec
== time_span
.start_time
.tv_sec
) {
3369 /* can be both beginning and end at the same time. */
3370 if(end_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3371 /* If we are at the end, max nsec to end.. */
3372 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry4
),
3373 (double)time_span
.start_time
.tv_nsec
+1,
3374 (double)time_span
.end_time
.tv_nsec
);
3376 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry4
),
3377 (double)time_span
.start_time
.tv_nsec
+1,
3378 (double)NANOSECONDS_PER_SECOND
-1);
3381 else if(end_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3382 /* If we are at the end, max nsec to end.. */
3383 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry4
),
3385 (double)time_span
.end_time
.tv_nsec
);
3387 else /* anywhere else */
3388 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry4
),
3390 (double)NANOSECONDS_PER_SECOND
-1);
3391 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry4
),
3392 (double)end_time
.tv_nsec
);
3394 /* call viewer hooks for new time window */
3395 set_time_window(tab
, &new_time_window
);
3397 tab
->time_manager_lock
= FALSE
;
3401 /* value changed for frame start s
3403 * Check time span : if ns is out of range, clip it the nearest good value.
3406 on_MEntry1_value_changed (GtkSpinButton
*spinbutton
,
3409 Tab
*tab
=(Tab
*)user_data
;
3410 LttvTracesetContext
* tsc
=
3411 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3412 TimeInterval time_span
= tsc
->time_span
;
3413 gint value
= gtk_spin_button_get_value_as_int(spinbutton
);
3415 TimeWindow new_time_window
= tab
->time_window
;
3417 LttTime end_time
= new_time_window
.end_time
;
3419 new_time_window
.start_time
.tv_sec
= value
;
3421 /* start nanoseconds */
3422 if(new_time_window
.start_time
.tv_sec
== time_span
.start_time
.tv_sec
) {
3423 if(new_time_window
.start_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3424 if(new_time_window
.start_time
.tv_nsec
> time_span
.end_time
.tv_nsec
)
3425 new_time_window
.start_time
.tv_nsec
= time_span
.end_time
.tv_nsec
-1;
3426 if(new_time_window
.start_time
.tv_nsec
< time_span
.start_time
.tv_nsec
)
3427 new_time_window
.start_time
.tv_nsec
= time_span
.start_time
.tv_nsec
;
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
;
3433 else if(new_time_window
.start_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3434 if(new_time_window
.start_time
.tv_nsec
> time_span
.end_time
.tv_nsec
)
3435 new_time_window
.start_time
.tv_nsec
= time_span
.end_time
.tv_nsec
-1;
3438 if(ltt_time_compare(new_time_window
.start_time
, end_time
) >= 0) {
3439 /* Then, we must push back end time : keep the same time width
3440 * if possible, else end traceset time */
3441 end_time
= LTT_TIME_MIN(ltt_time_add(new_time_window
.start_time
,
3442 new_time_window
.time_width
),
3443 time_span
.end_time
);
3446 /* Fix the time width to fit start time and end time */
3447 new_time_window
.time_width
= ltt_time_sub(end_time
,
3448 new_time_window
.start_time
);
3449 new_time_window
.time_width_double
=
3450 ltt_time_to_double(new_time_window
.time_width
);
3452 new_time_window
.end_time
= end_time
;
3454 time_change_manager(tab
, new_time_window
);
3459 on_MEntry2_value_changed (GtkSpinButton
*spinbutton
,
3462 Tab
*tab
=(Tab
*)user_data
;
3463 LttvTracesetContext
* tsc
=
3464 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3465 TimeInterval time_span
= tsc
->time_span
;
3466 gint value
= gtk_spin_button_get_value_as_int(spinbutton
);
3468 TimeWindow new_time_window
= tab
->time_window
;
3470 LttTime end_time
= new_time_window
.end_time
;
3472 new_time_window
.start_time
.tv_nsec
= value
;
3474 if(ltt_time_compare(new_time_window
.start_time
, end_time
) >= 0) {
3475 /* Then, we must push back end time : keep the same time width
3476 * if possible, else end traceset time */
3477 end_time
= LTT_TIME_MIN(ltt_time_add(new_time_window
.start_time
,
3478 new_time_window
.time_width
),
3479 time_span
.end_time
);
3482 /* Fix the time width to fit start time and end time */
3483 new_time_window
.time_width
= ltt_time_sub(end_time
,
3484 new_time_window
.start_time
);
3485 new_time_window
.time_width_double
=
3486 ltt_time_to_double(new_time_window
.time_width
);
3488 new_time_window
.end_time
= end_time
;
3490 time_change_manager(tab
, new_time_window
);
3495 on_MEntry3_value_changed (GtkSpinButton
*spinbutton
,
3498 Tab
*tab
=(Tab
*)user_data
;
3499 LttvTracesetContext
* tsc
=
3500 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3501 TimeInterval time_span
= tsc
->time_span
;
3502 gint value
= gtk_spin_button_get_value_as_int(spinbutton
);
3504 TimeWindow new_time_window
= tab
->time_window
;
3506 LttTime end_time
= new_time_window
.end_time
;
3508 end_time
.tv_sec
= value
;
3510 /* end nanoseconds */
3511 if(end_time
.tv_sec
== time_span
.start_time
.tv_sec
) {
3512 if(end_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3513 if(end_time
.tv_nsec
> time_span
.end_time
.tv_nsec
)
3514 end_time
.tv_nsec
= time_span
.end_time
.tv_nsec
;
3515 if(end_time
.tv_nsec
< time_span
.start_time
.tv_nsec
)
3516 end_time
.tv_nsec
= time_span
.start_time
.tv_nsec
+1;
3518 if(end_time
.tv_nsec
< time_span
.start_time
.tv_nsec
)
3519 end_time
.tv_nsec
= time_span
.start_time
.tv_nsec
+1;
3522 else if(end_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3523 if(end_time
.tv_nsec
> time_span
.end_time
.tv_nsec
)
3524 end_time
.tv_nsec
= time_span
.end_time
.tv_nsec
;
3527 if(ltt_time_compare(new_time_window
.start_time
, end_time
) >= 0) {
3528 /* Then, we must push front start time : keep the same time width
3529 * if possible, else end traceset time */
3530 new_time_window
.start_time
= LTT_TIME_MAX(
3531 ltt_time_sub(end_time
,
3532 new_time_window
.time_width
),
3533 time_span
.start_time
);
3536 /* Fix the time width to fit start time and end time */
3537 new_time_window
.time_width
= ltt_time_sub(end_time
,
3538 new_time_window
.start_time
);
3539 new_time_window
.time_width_double
=
3540 ltt_time_to_double(new_time_window
.time_width
);
3542 new_time_window
.end_time
= end_time
;
3544 time_change_manager(tab
, new_time_window
);
3549 on_MEntry4_value_changed (GtkSpinButton
*spinbutton
,
3552 Tab
*tab
=(Tab
*)user_data
;
3553 LttvTracesetContext
* tsc
=
3554 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3555 TimeInterval time_span
= tsc
->time_span
;
3556 gint value
= gtk_spin_button_get_value_as_int(spinbutton
);
3558 TimeWindow new_time_window
= tab
->time_window
;
3560 LttTime end_time
= new_time_window
.end_time
;
3562 end_time
.tv_nsec
= value
;
3564 if(ltt_time_compare(new_time_window
.start_time
, end_time
) >= 0) {
3565 /* Then, we must push front start time : keep the same time width
3566 * if possible, else end traceset time */
3567 new_time_window
.start_time
= LTT_TIME_MAX(
3568 ltt_time_sub(end_time
,
3569 new_time_window
.time_width
),
3570 time_span
.start_time
);
3573 /* Fix the time width to fit start time and end time */
3574 new_time_window
.time_width
= ltt_time_sub(end_time
,
3575 new_time_window
.start_time
);
3576 new_time_window
.time_width_double
=
3577 ltt_time_to_double(new_time_window
.time_width
);
3578 new_time_window
.end_time
= end_time
;
3580 time_change_manager(tab
, new_time_window
);
3585 void current_time_change_manager (Tab
*tab
,
3586 LttTime new_current_time
)
3588 /* Only one source of time change */
3589 if(tab
->current_time_manager_lock
== TRUE
) return;
3591 tab
->current_time_manager_lock
= TRUE
;
3593 LttvTracesetContext
*tsc
= LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3594 TimeInterval time_span
= tsc
->time_span
;
3596 /* current seconds */
3597 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry5
),
3598 (double)time_span
.start_time
.tv_sec
,
3599 (double)time_span
.end_time
.tv_sec
);
3600 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry5
),
3601 (double)new_current_time
.tv_sec
);
3604 /* start nanoseconds */
3605 if(new_current_time
.tv_sec
== time_span
.start_time
.tv_sec
) {
3606 /* can be both beginning and end at the same time. */
3607 if(new_current_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3608 /* If we are at the end, max nsec to end.. */
3609 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry6
),
3610 (double)time_span
.start_time
.tv_nsec
,
3611 (double)time_span
.end_time
.tv_nsec
);
3613 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry6
),
3614 (double)time_span
.start_time
.tv_nsec
,
3615 (double)NANOSECONDS_PER_SECOND
-1);
3617 } else if(new_current_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3618 /* If we are at the end, max nsec to end.. */
3619 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry6
),
3621 (double)time_span
.end_time
.tv_nsec
);
3622 } else /* anywhere else */
3623 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry6
),
3625 (double)NANOSECONDS_PER_SECOND
-1);
3627 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry6
),
3628 (double)new_current_time
.tv_nsec
);
3630 set_current_time(tab
, &new_current_time
);
3632 tab
->current_time_manager_lock
= FALSE
;
3635 void current_position_change_manager(Tab
*tab
,
3636 LttvTracesetContextPosition
*pos
)
3638 LttvTracesetContext
*tsc
=
3639 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3640 TimeInterval time_span
= tsc
->time_span
;
3642 g_assert(lttv_process_traceset_seek_position(tsc
, pos
) == 0);
3643 LttTime new_time
= lttv_traceset_context_position_get_time(pos
);
3644 /* Put the context in a state coherent position */
3645 lttv_state_traceset_seek_time_closest((LttvTracesetState
*)tsc
, ltt_time_zero
);
3647 current_time_change_manager(tab
, new_time
);
3649 set_current_position(tab
, pos
);
3654 on_MEntry5_value_changed (GtkSpinButton
*spinbutton
,
3657 Tab
*tab
= (Tab
*)user_data
;
3658 LttvTracesetContext
* tsc
=
3659 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3660 TimeInterval time_span
= tsc
->time_span
;
3661 gint value
= gtk_spin_button_get_value_as_int(spinbutton
);
3662 LttTime new_current_time
= tab
->current_time
;
3663 new_current_time
.tv_sec
= value
;
3665 /* current nanoseconds */
3666 if(new_current_time
.tv_sec
== time_span
.start_time
.tv_sec
) {
3667 if(new_current_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3668 if(new_current_time
.tv_nsec
> time_span
.end_time
.tv_nsec
)
3669 new_current_time
.tv_nsec
= time_span
.end_time
.tv_nsec
;
3670 if(new_current_time
.tv_nsec
< time_span
.start_time
.tv_nsec
)
3671 new_current_time
.tv_nsec
= time_span
.start_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
;
3677 else if(new_current_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3678 if(new_current_time
.tv_nsec
> time_span
.end_time
.tv_nsec
)
3679 new_current_time
.tv_nsec
= time_span
.end_time
.tv_nsec
;
3682 current_time_change_manager(tab
, new_current_time
);
3686 on_MEntry6_value_changed (GtkSpinButton
*spinbutton
,
3689 Tab
*tab
= (Tab
*)user_data
;
3690 gint value
= gtk_spin_button_get_value_as_int(spinbutton
);
3691 LttTime new_current_time
= tab
->current_time
;
3692 new_current_time
.tv_nsec
= value
;
3694 current_time_change_manager(tab
, new_current_time
);
3698 void scroll_value_changed_cb(GtkWidget
*scrollbar
,
3701 Tab
*tab
= (Tab
*)user_data
;
3702 TimeWindow new_time_window
;
3704 GtkAdjustment
*adjust
= gtk_range_get_adjustment(GTK_RANGE(scrollbar
));
3705 gdouble value
= gtk_adjustment_get_value(adjust
);
3706 // gdouble upper, lower, ratio, page_size;
3708 LttvTracesetContext
* tsc
=
3709 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3710 TimeInterval time_span
= tsc
->time_span
;
3712 time
= ltt_time_add(ltt_time_from_double(value
),
3713 time_span
.start_time
);
3715 new_time_window
.start_time
= time
;
3717 page_size
= adjust
->page_size
;
3719 new_time_window
.time_width
=
3720 ltt_time_from_double(page_size
);
3722 new_time_window
.time_width_double
=
3725 new_time_window
.end_time
= ltt_time_add(new_time_window
.start_time
,
3726 new_time_window
.time_width
);
3729 time_change_manager(tab
, new_time_window
);
3731 //time_window = tab->time_window;
3733 lower
= adjust
->lower
;
3734 upper
= adjust
->upper
;
3735 ratio
= (value
- lower
) / (upper
- lower
);
3736 g_info("lower %lu, upper %lu, value %lu, ratio %lu", lower
, upper
, value
, ratio
);
3738 //time = ltt_time_sub(time_span->end_time, time_span->start_time);
3739 //time = ltt_time_mul(time, (float)ratio);
3740 //time = ltt_time_add(time_span->start_time, time);
3741 time
= ltt_time_add(ltt_time_from_double(value
),
3742 time_span
.start_time
);
3744 time_window
.start_time
= time
;
3746 page_size
= adjust
->page_size
;
3748 time_window
.time_width
=
3749 ltt_time_from_double(page_size
);
3750 //time = ltt_time_sub(time_span.end_time, time);
3751 //if(ltt_time_compare(time,time_window.time_width) < 0){
3752 // time_window.time_width = time;
3755 /* call viewer hooks for new time window */
3756 set_time_window(tab
, &time_window
);
3761 /* Display a dialogue showing all eventtypes and traces, let user to select the interested
3762 * eventtypes, tracefiles and traces (filter)
3765 /* Select a trace which will be removed from traceset
3768 char * get_remove_trace(MainWindow
*mw_data
,
3769 char ** all_trace_name
, int nb_trace
)
3771 return get_selection(mw_data
, all_trace_name
, nb_trace
,
3772 "Select a trace", "Trace pathname");
3776 /* Select a module which will be loaded
3779 char * get_load_module(MainWindow
*mw_data
,
3780 char ** load_module_name
, int nb_module
)
3782 return get_selection(mw_data
, load_module_name
, nb_module
,
3783 "Select a module to load", "Module name");
3789 /* Select a module which will be unloaded
3792 char * get_unload_module(MainWindow
*mw_data
,
3793 char ** loaded_module_name
, int nb_module
)
3795 return get_selection(mw_data
, loaded_module_name
, nb_module
,
3796 "Select a module to unload", "Module name");
3800 /* Display a dialogue which shows all selectable items, let user to
3801 * select one of them
3804 char * get_selection(MainWindow
*mw_data
,
3805 char ** loaded_module_name
, int nb_module
,
3806 char *title
, char * column_title
)
3808 GtkWidget
* dialogue
;
3809 GtkWidget
* scroll_win
;
3811 GtkListStore
* store
;
3812 GtkTreeViewColumn
* column
;
3813 GtkCellRenderer
* renderer
;
3814 GtkTreeSelection
* select
;
3817 char * unload_module_name
= NULL
;
3819 dialogue
= gtk_dialog_new_with_buttons(title
,
3822 GTK_STOCK_OK
,GTK_RESPONSE_ACCEPT
,
3823 GTK_STOCK_CANCEL
,GTK_RESPONSE_REJECT
,
3825 gtk_window_set_default_size((GtkWindow
*)dialogue
, 500, 200);
3826 gtk_window_set_transient_for(GTK_WINDOW(dialogue
),
3827 GTK_WINDOW(mw_data
->mwindow
));
3829 scroll_win
= gtk_scrolled_window_new (NULL
, NULL
);
3830 gtk_widget_show ( scroll_win
);
3831 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win
),
3832 GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
3834 store
= gtk_list_store_new (N_COLUMNS
,G_TYPE_STRING
);
3835 tree
= gtk_tree_view_new_with_model(GTK_TREE_MODEL (store
));
3836 gtk_widget_show ( tree
);
3837 g_object_unref (G_OBJECT (store
));
3839 renderer
= gtk_cell_renderer_text_new ();
3840 column
= gtk_tree_view_column_new_with_attributes (column_title
,
3842 "text", MODULE_COLUMN
,
3844 gtk_tree_view_column_set_alignment (column
, 0.5);
3845 gtk_tree_view_column_set_fixed_width (column
, 150);
3846 gtk_tree_view_append_column (GTK_TREE_VIEW (tree
), column
);
3848 select
= gtk_tree_view_get_selection (GTK_TREE_VIEW (tree
));
3849 gtk_tree_selection_set_mode (select
, GTK_SELECTION_SINGLE
);
3851 gtk_container_add (GTK_CONTAINER (scroll_win
), tree
);
3853 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), scroll_win
,TRUE
, TRUE
,0);
3855 for(i
=0;i
<nb_module
;i
++){
3856 gtk_list_store_append (store
, &iter
);
3857 gtk_list_store_set (store
, &iter
, MODULE_COLUMN
,loaded_module_name
[i
],-1);
3860 id
= gtk_dialog_run(GTK_DIALOG(dialogue
));
3861 GtkTreeModel
**store_model
= (GtkTreeModel
**)&store
;
3863 case GTK_RESPONSE_ACCEPT
:
3864 case GTK_RESPONSE_OK
:
3865 if (gtk_tree_selection_get_selected (select
, store_model
, &iter
)){
3866 gtk_tree_model_get ((GtkTreeModel
*)store
, &iter
, MODULE_COLUMN
, &unload_module_name
, -1);
3868 case GTK_RESPONSE_REJECT
:
3869 case GTK_RESPONSE_CANCEL
:
3871 gtk_widget_destroy(dialogue
);
3875 return unload_module_name
;
3879 /* Insert all menu entry and tool buttons into this main window
3884 void add_all_menu_toolbar_constructors(MainWindow
* mw
, gpointer user_data
)
3888 lttvwindow_viewer_constructor constructor
;
3889 LttvMenus
* global_menu
, * instance_menu
;
3890 LttvToolbars
* global_toolbar
, * instance_toolbar
;
3891 LttvMenuClosure
*menu_item
;
3892 LttvToolbarClosure
*toolbar_item
;
3893 LttvAttributeValue value
;
3894 LttvIAttribute
*global_attributes
= LTTV_IATTRIBUTE(lttv_global_attributes());
3895 LttvIAttribute
*attributes
= mw
->attributes
;
3896 GtkWidget
* tool_menu_title_menu
, *new_widget
, *pixmap
;
3898 g_assert(lttv_iattribute_find_by_path(global_attributes
,
3899 "viewers/menu", LTTV_POINTER
, &value
));
3900 if(*(value
.v_pointer
) == NULL
)
3901 *(value
.v_pointer
) = lttv_menus_new();
3902 global_menu
= (LttvMenus
*)*(value
.v_pointer
);
3904 g_assert(lttv_iattribute_find_by_path(attributes
,
3905 "viewers/menu", LTTV_POINTER
, &value
));
3906 if(*(value
.v_pointer
) == NULL
)
3907 *(value
.v_pointer
) = lttv_menus_new();
3908 instance_menu
= (LttvMenus
*)*(value
.v_pointer
);
3912 g_assert(lttv_iattribute_find_by_path(global_attributes
,
3913 "viewers/toolbar", LTTV_POINTER
, &value
));
3914 if(*(value
.v_pointer
) == NULL
)
3915 *(value
.v_pointer
) = lttv_toolbars_new();
3916 global_toolbar
= (LttvToolbars
*)*(value
.v_pointer
);
3918 g_assert(lttv_iattribute_find_by_path(attributes
,
3919 "viewers/toolbar", LTTV_POINTER
, &value
));
3920 if(*(value
.v_pointer
) == NULL
)
3921 *(value
.v_pointer
) = lttv_toolbars_new();
3922 instance_toolbar
= (LttvToolbars
*)*(value
.v_pointer
);
3924 /* Add missing menu entries to window instance */
3925 for(i
=0;i
<global_menu
->len
;i
++) {
3926 menu_item
= &g_array_index(global_menu
, LttvMenuClosure
, i
);
3928 //add menu_item to window instance;
3929 constructor
= menu_item
->con
;
3930 tool_menu_title_menu
= lookup_widget(mw
->mwindow
,"ToolMenuTitle_menu");
3932 gtk_menu_item_new_with_mnemonic (menu_item
->menu_text
);
3933 gtk_container_add (GTK_CONTAINER (tool_menu_title_menu
),
3935 g_signal_connect ((gpointer
) new_widget
, "activate",
3936 G_CALLBACK (insert_viewer_wrap
),
3938 gtk_widget_show (new_widget
);
3939 lttv_menus_add(instance_menu
, menu_item
->con
,
3940 menu_item
->menu_path
,
3941 menu_item
->menu_text
,
3946 /* Add missing toolbar entries to window instance */
3947 for(i
=0;i
<global_toolbar
->len
;i
++) {
3948 toolbar_item
= &g_array_index(global_toolbar
, LttvToolbarClosure
, i
);
3950 //add toolbar_item to window instance;
3951 constructor
= toolbar_item
->con
;
3952 tool_menu_title_menu
= lookup_widget(mw
->mwindow
,"MToolbar1");
3953 pixbuf
= gdk_pixbuf_new_from_xpm_data((const char**)toolbar_item
->pixmap
);
3954 pixmap
= gtk_image_new_from_pixbuf(pixbuf
);
3956 gtk_toolbar_append_element (GTK_TOOLBAR (tool_menu_title_menu
),
3957 GTK_TOOLBAR_CHILD_BUTTON
,
3960 toolbar_item
->tooltip
, NULL
,
3961 pixmap
, NULL
, NULL
);
3962 gtk_label_set_use_underline(
3963 GTK_LABEL (((GtkToolbarChild
*) (
3964 g_list_last (GTK_TOOLBAR
3965 (tool_menu_title_menu
)->children
)->data
))->label
),
3967 gtk_container_set_border_width (GTK_CONTAINER (new_widget
), 1);
3968 g_signal_connect ((gpointer
) new_widget
,
3970 G_CALLBACK (insert_viewer_wrap
),
3972 gtk_widget_show (new_widget
);
3974 lttv_toolbars_add(instance_toolbar
, toolbar_item
->con
,
3975 toolbar_item
->tooltip
,
3976 toolbar_item
->pixmap
,
3984 /* Create a main window
3987 MainWindow
*construct_main_window(MainWindow
* parent
)
3989 g_debug("construct_main_window()");
3990 GtkWidget
* new_window
; /* New generated main window */
3991 MainWindow
* new_m_window
;/* New main window structure */
3992 GtkNotebook
* notebook
;
3993 LttvIAttribute
*attributes
=
3994 LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
));
3995 LttvAttributeValue value
;
3998 new_m_window
= g_new(MainWindow
, 1);
4000 // Add the object's information to the module's array
4001 g_main_window_list
= g_slist_append(g_main_window_list
, new_m_window
);
4003 new_window
= create_MWindow();
4004 gtk_widget_show (new_window
);
4006 new_m_window
->mwindow
= new_window
;
4007 new_m_window
->attributes
= attributes
;
4009 g_assert(lttv_iattribute_find_by_path(attributes
,
4010 "viewers/menu", LTTV_POINTER
, &value
));
4011 *(value
.v_pointer
) = lttv_menus_new();
4013 g_assert(lttv_iattribute_find_by_path(attributes
,
4014 "viewers/toolbar", LTTV_POINTER
, &value
));
4015 *(value
.v_pointer
) = lttv_toolbars_new();
4017 add_all_menu_toolbar_constructors(new_m_window
, NULL
);
4019 g_object_set_data_full(G_OBJECT(new_window
),
4021 (gpointer
)new_m_window
,
4022 (GDestroyNotify
)g_free
);
4023 //create a default tab
4024 notebook
= (GtkNotebook
*)lookup_widget(new_m_window
->mwindow
, "MNotebook");
4025 if(notebook
== NULL
){
4026 g_info("Notebook does not exist\n");
4027 /* FIXME : destroy partially created widgets */
4028 g_free(new_m_window
);
4031 //gtk_notebook_popup_enable (GTK_NOTEBOOK(notebook));
4032 //for now there is no name field in LttvTraceset structure
4033 //Use "Traceset" as the label for the default tab
4035 GtkWidget
* parent_notebook
= lookup_widget(parent
->mwindow
, "MNotebook");
4036 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(parent_notebook
),
4037 gtk_notebook_get_current_page(GTK_NOTEBOOK(parent_notebook
)));
4043 parent_tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
4045 new_tab
= create_tab(new_m_window
, parent_tab
, notebook
, "Traceset");
4047 new_tab
= create_tab(new_m_window
, NULL
, notebook
, "Traceset");
4050 /* Insert default viewers */
4052 LttvAttributeType type
;
4053 LttvAttributeName name
;
4054 LttvAttributeValue value
;
4055 LttvAttribute
*attribute
;
4057 LttvIAttribute
*attributes_global
=
4058 LTTV_IATTRIBUTE(lttv_global_attributes());
4060 g_assert(attribute
=
4061 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
4062 LTTV_IATTRIBUTE(attributes_global
),
4063 LTTV_VIEWER_CONSTRUCTORS
)));
4065 name
= g_quark_from_string("guievents");
4066 type
= lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute
),
4068 if(type
== LTTV_POINTER
) {
4069 lttvwindow_viewer_constructor viewer_constructor
=
4070 (lttvwindow_viewer_constructor
)*value
.v_pointer
;
4071 insert_viewer(new_window
, viewer_constructor
);
4074 name
= g_quark_from_string("guicontrolflow");
4075 type
= lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute
),
4077 if(type
== LTTV_POINTER
) {
4078 lttvwindow_viewer_constructor viewer_constructor
=
4079 (lttvwindow_viewer_constructor
)*value
.v_pointer
;
4080 insert_viewer(new_window
, viewer_constructor
);
4083 name
= g_quark_from_string("guistatistics");
4084 type
= lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute
),
4086 if(type
== LTTV_POINTER
) {
4087 lttvwindow_viewer_constructor viewer_constructor
=
4088 (lttvwindow_viewer_constructor
)*value
.v_pointer
;
4089 insert_viewer(new_window
, viewer_constructor
);
4093 g_info("There are now : %d windows\n",g_slist_length(g_main_window_list
));
4095 return new_m_window
;
4099 /* Free the memory occupied by a tab structure
4103 void tab_destructor(Tab
* tab
)
4105 int i
, nb
, ref_count
;
4108 gtk_object_destroy(GTK_OBJECT(tab
->tooltips
));
4111 g_object_unref(tab
->attributes
);
4113 if(tab
->interrupted_state
)
4114 g_object_unref(tab
->interrupted_state
);
4117 if(tab
->traceset_info
->traceset_context
!= NULL
){
4118 //remove state update hooks
4119 lttv_state_remove_event_hooks(
4120 (LttvTracesetState
*)tab
->traceset_info
->
4122 lttv_context_fini(LTTV_TRACESET_CONTEXT(tab
->traceset_info
->
4124 g_object_unref(tab
->traceset_info
->traceset_context
);
4126 if(tab
->traceset_info
->traceset
!= NULL
) {
4127 nb
= lttv_traceset_number(tab
->traceset_info
->traceset
);
4128 for(i
= 0 ; i
< nb
; i
++) {
4129 trace
= lttv_traceset_get(tab
->traceset_info
->traceset
, i
);
4130 ref_count
= lttv_trace_get_ref_number(trace
);
4132 ltt_trace_close(lttv_trace(trace
));
4136 lttv_filter_destroy(tab
->filter
);
4137 lttv_traceset_destroy(tab
->traceset_info
->traceset
);
4138 /* Remove the idle events requests processing function of the tab */
4139 g_idle_remove_by_data(tab
);
4141 g_slist_free(tab
->events_requests
);
4142 g_free(tab
->traceset_info
);
4147 /* Create a tab and insert it into the current main window
4150 Tab
* create_tab(MainWindow
* mw
, Tab
*copy_tab
,
4151 GtkNotebook
* notebook
, char * label
)
4156 //create a new tab data structure
4159 //construct and initialize the traceset_info
4160 tab
->traceset_info
= g_new(TracesetInfo
,1);
4163 tab
->traceset_info
->traceset
=
4164 lttv_traceset_copy(copy_tab
->traceset_info
->traceset
);
4166 /* Copy the previous tab's filter */
4167 /* We can clone the filter, as we copy the trace set also */
4168 /* The filter must always be in sync with the trace set */
4169 tab
->filter
= lttv_filter_clone(copy_tab
->filter
);
4171 tab
->traceset_info
->traceset
= lttv_traceset_new();
4175 lttv_attribute_write_xml(
4176 lttv_traceset_attribute(tab
->traceset_info
->traceset
),
4182 tab
->time_manager_lock
= FALSE
;
4183 tab
->current_time_manager_lock
= FALSE
;
4185 //FIXME copy not implemented in lower level
4186 tab
->traceset_info
->traceset_context
=
4187 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
4188 g_assert(tab
->traceset_info
->traceset_context
!= NULL
);
4190 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
),
4191 tab
->traceset_info
->traceset
);
4192 //add state update hooks
4193 lttv_state_add_event_hooks(
4194 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
4196 //determine the current_time and time_window of the tab
4198 if(copy_tab
!= NULL
){
4199 tab
->time_window
= copy_tab
->time_window
;
4200 tab
->current_time
= copy_tab
->current_time
;
4202 tab
->time_window
.start_time
=
4203 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
4204 time_span
.start_time
;
4205 if(DEFAULT_TIME_WIDTH_S
<
4206 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
4207 time_span
.end_time
.tv_sec
)
4208 tmp_time
.tv_sec
= DEFAULT_TIME_WIDTH_S
;
4211 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
4212 time_span
.end_time
.tv_sec
;
4213 tmp_time
.tv_nsec
= 0;
4214 tab
->time_window
.time_width
= tmp_time
;
4215 tab
->current_time
.tv_sec
=
4216 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
4217 time_span
.start_time
.tv_sec
;
4218 tab
->current_time
.tv_nsec
=
4219 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
4220 time_span
.start_time
.tv_nsec
;
4223 tab
->attributes
= LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
));
4224 tab
->interrupted_state
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
4226 tab
->vbox
= gtk_vbox_new(FALSE
, 2);
4227 tab
->viewer_container
= gtk_vbox_new(TRUE
, 2);
4228 tab
->scrollbar
= gtk_hscrollbar_new(NULL
);
4229 //tab->multivpaned = gtk_multi_vpaned_new();
4231 gtk_box_pack_start(GTK_BOX(tab
->vbox
),
4232 tab
->viewer_container
,
4234 TRUE
, /* Give the extra space to the child */
4235 0); /* No padding */
4238 // tab->time_window = copy_tab->time_window;
4239 // tab->current_time = copy_tab->current_time;
4242 /* Create the timebar */
4244 tab
->MTimebar
= gtk_hbox_new(FALSE
, 2);
4245 gtk_widget_show(tab
->MTimebar
);
4246 tab
->tooltips
= gtk_tooltips_new();
4248 tab
->MEventBox1a
= gtk_event_box_new();
4249 gtk_widget_show(tab
->MEventBox1a
);
4250 gtk_tooltips_set_tip(tab
->tooltips
, tab
->MEventBox1a
,
4251 "Paste Start and End Times Here", "");
4252 tab
->MText1a
= gtk_label_new("Time Frame ");
4253 gtk_widget_show(tab
->MText1a
);
4254 gtk_container_add(GTK_CONTAINER(tab
->MEventBox1a
), tab
->MText1a
);
4255 tab
->MEventBox1b
= gtk_event_box_new();
4256 gtk_widget_show(tab
->MEventBox1b
);
4257 gtk_tooltips_set_tip(tab
->tooltips
, tab
->MEventBox1b
,
4258 "Paste Start Time Here", "");
4259 tab
->MText1b
= gtk_label_new("start: ");
4260 gtk_widget_show(tab
->MText1b
);
4261 gtk_container_add(GTK_CONTAINER(tab
->MEventBox1b
), tab
->MText1b
);
4262 tab
->MText2
= gtk_label_new("s");
4263 gtk_widget_show(tab
->MText2
);
4264 tab
->MText3a
= gtk_label_new("ns");
4265 gtk_widget_show(tab
->MText3a
);
4266 tab
->MEventBox3b
= gtk_event_box_new();
4267 gtk_widget_show(tab
->MEventBox3b
);
4268 gtk_tooltips_set_tip(tab
->tooltips
, tab
->MEventBox3b
,
4269 "Paste End Time Here", "");
4270 tab
->MText3b
= gtk_label_new("end:");
4271 gtk_widget_show(tab
->MText3b
);
4272 gtk_container_add(GTK_CONTAINER(tab
->MEventBox3b
), tab
->MText3b
);
4273 tab
->MText4
= gtk_label_new("s");
4274 gtk_widget_show(tab
->MText4
);
4275 tab
->MText5a
= gtk_label_new("ns");
4276 gtk_widget_show(tab
->MText5a
);
4277 tab
->MEventBox5b
= gtk_event_box_new();
4278 gtk_widget_show(tab
->MEventBox5b
);
4279 gtk_tooltips_set_tip(tab
->tooltips
, tab
->MEventBox5b
,
4280 "Paste Current Time Here", "");
4281 tab
->MText5b
= gtk_label_new("Current Time:");
4282 gtk_widget_show(tab
->MText5b
);
4283 gtk_container_add(GTK_CONTAINER(tab
->MEventBox5b
), tab
->MText5b
);
4284 tab
->MText6
= gtk_label_new("s");
4285 gtk_widget_show(tab
->MText6
);
4286 tab
->MText7
= gtk_label_new("ns");
4287 gtk_widget_show(tab
->MText7
);
4289 tab
->MEntry1
= gtk_spin_button_new_with_range(0.0, 1.0, 1.0);
4290 gtk_spin_button_set_digits(GTK_SPIN_BUTTON(tab
->MEntry1
),0);
4291 gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(tab
->MEntry1
),TRUE
);
4292 gtk_widget_show(tab
->MEntry1
);
4293 tab
->MEntry2
= gtk_spin_button_new_with_range(0.0, 1.0, 1.0);
4294 gtk_spin_button_set_digits(GTK_SPIN_BUTTON(tab
->MEntry2
),0);
4295 gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(tab
->MEntry2
),TRUE
);
4296 gtk_widget_show(tab
->MEntry2
);
4297 tab
->MEntry3
= gtk_spin_button_new_with_range(0.0, 1.0, 1.0);
4298 gtk_spin_button_set_digits(GTK_SPIN_BUTTON(tab
->MEntry3
),0);
4299 gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(tab
->MEntry3
),TRUE
);
4300 gtk_widget_show(tab
->MEntry3
);
4301 tab
->MEntry4
= gtk_spin_button_new_with_range(0.0, 1.0, 1.0);
4302 gtk_spin_button_set_digits(GTK_SPIN_BUTTON(tab
->MEntry4
),0);
4303 gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(tab
->MEntry4
),TRUE
);
4304 gtk_widget_show(tab
->MEntry4
);
4305 tab
->MEntry5
= gtk_spin_button_new_with_range(0.0, 1.0, 1.0);
4306 gtk_spin_button_set_digits(GTK_SPIN_BUTTON(tab
->MEntry5
),0);
4307 gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(tab
->MEntry5
),TRUE
);
4308 gtk_widget_show(tab
->MEntry5
);
4309 tab
->MEntry6
= gtk_spin_button_new_with_range(0.0, 1.0, 1.0);
4310 gtk_spin_button_set_digits(GTK_SPIN_BUTTON(tab
->MEntry6
),0);
4311 gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(tab
->MEntry6
),TRUE
);
4312 gtk_widget_show(tab
->MEntry6
);
4315 GtkWidget
*temp_widget
;
4317 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MEventBox1a
, FALSE
,
4319 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MEventBox1b
, FALSE
,
4321 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MEntry1
, FALSE
, FALSE
, 0);
4322 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MText2
, FALSE
, FALSE
, 0);
4323 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MEntry2
, FALSE
, FALSE
, 0);
4324 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MText3a
, FALSE
, FALSE
, 0);
4325 temp_widget
= gtk_vseparator_new();
4326 gtk_widget_show(temp_widget
);
4327 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), temp_widget
, FALSE
, FALSE
, 0);
4328 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MEventBox3b
, FALSE
,
4330 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MEntry3
, FALSE
, FALSE
, 0);
4331 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MText4
, FALSE
, FALSE
, 0);
4332 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MEntry4
, FALSE
, FALSE
, 0);
4333 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MText5a
, FALSE
, FALSE
, 0);
4334 temp_widget
= gtk_vseparator_new();
4335 gtk_widget_show(temp_widget
);
4336 gtk_box_pack_end (GTK_BOX (tab
->MTimebar
), tab
->MText7
, FALSE
, FALSE
, 0);
4337 gtk_box_pack_end (GTK_BOX (tab
->MTimebar
), tab
->MEntry6
, FALSE
, FALSE
, 0);
4338 gtk_box_pack_end (GTK_BOX (tab
->MTimebar
), tab
->MText6
, FALSE
, FALSE
, 0);
4339 gtk_box_pack_end (GTK_BOX (tab
->MTimebar
), tab
->MEntry5
, FALSE
, FALSE
, 0);
4340 gtk_box_pack_end (GTK_BOX (tab
->MTimebar
), tab
->MEventBox5b
, FALSE
,
4342 gtk_box_pack_end (GTK_BOX (tab
->MTimebar
), temp_widget
, FALSE
, FALSE
, 0);
4345 //GtkWidget *test = gtk_button_new_with_label("drop");
4346 //gtk_button_set_relief(GTK_BUTTON(test), GTK_RELIEF_NONE);
4347 //gtk_widget_show(test);
4348 //gtk_box_pack_end(GTK_BOX (tab->MTimebar), test, FALSE, FALSE, 0);
4349 //gtk_widget_add_events(tab->MText1, GDK_ALL_EVENTS_MASK);//GDK_BUTTON_PRESS_MASK);
4350 /*GtkWidget *event_box = gtk_event_box_new();
4351 gtk_widget_show(event_box);
4352 gtk_tooltips_set_tip(tooltips, event_box,
4353 "Paste Current Time Here", "");
4354 gtk_box_pack_end(GTK_BOX (tab->MTimebar), event_box, FALSE, FALSE, 0);
4355 GtkWidget *test = gtk_label_new("drop");
4356 gtk_container_add(GTK_CONTAINER(event_box), test);
4357 gtk_widget_show(test);
4358 g_signal_connect (G_OBJECT(event_box),
4359 "button-press-event",
4360 G_CALLBACK (on_MText1_paste),
4364 g_signal_connect (G_OBJECT(tab
->MEventBox1a
),
4365 "button-press-event",
4366 G_CALLBACK (on_MEventBox1a_paste
),
4369 g_signal_connect (G_OBJECT(tab
->MEventBox1b
),
4370 "button-press-event",
4371 G_CALLBACK (on_MEventBox1b_paste
),
4373 g_signal_connect (G_OBJECT(tab
->MEventBox3b
),
4374 "button-press-event",
4375 G_CALLBACK (on_MEventBox3b_paste
),
4377 g_signal_connect (G_OBJECT(tab
->MEventBox5b
),
4378 "button-press-event",
4379 G_CALLBACK (on_MEventBox5b_paste
),
4383 gtk_box_pack_end(GTK_BOX(tab
->vbox
),
4385 FALSE
, /* Do not expand */
4386 FALSE
, /* Fill has no effect here (expand false) */
4387 0); /* No padding */
4389 gtk_box_pack_end(GTK_BOX(tab
->vbox
),
4391 FALSE
, /* Do not expand */
4392 FALSE
, /* Fill has no effect here (expand false) */
4393 0); /* No padding */
4395 g_object_set_data(G_OBJECT(tab
->viewer_container
), "focused_viewer", NULL
);
4401 // Display a label with a X
4402 GtkWidget *w_hbox = gtk_hbox_new(FALSE, 4);
4403 GtkWidget *w_label = gtk_label_new (label);
4404 GtkWidget *pixmap = create_pixmap(GTK_WIDGET(notebook), "close.png");
4405 GtkWidget *w_button = gtk_button_new ();
4406 gtk_container_add(GTK_CONTAINER(w_button), pixmap);
4407 //GtkWidget *w_button = gtk_button_new_with_label("x");
4409 gtk_button_set_relief(GTK_BUTTON(w_button), GTK_RELIEF_NONE);
4411 gtk_box_pack_start(GTK_BOX(w_hbox), w_label, TRUE, TRUE, 0);
4412 gtk_box_pack_end(GTK_BOX(w_hbox), w_button, FALSE,
4415 g_signal_connect_swapped (w_button, "clicked",
4416 G_CALLBACK (on_close_tab_X_clicked),
4419 gtk_widget_set_state(w_button, GTK_STATE_ACTIVE);
4421 gtk_widget_show (w_label);
4422 gtk_widget_show (pixmap);
4423 gtk_widget_show (w_button);
4424 gtk_widget_show (w_hbox);
4426 tab->label = w_hbox;
4430 tab
->label
= gtk_label_new (label
);
4432 gtk_widget_show(tab
->label
);
4433 gtk_widget_show(tab
->scrollbar
);
4434 gtk_widget_show(tab
->viewer_container
);
4435 gtk_widget_show(tab
->vbox
);
4436 //gtk_widget_show(tab->multivpaned);
4439 /* Start with empty events requests list */
4440 tab
->events_requests
= NULL
;
4441 tab
->events_request_pending
= FALSE
;
4443 g_object_set_data_full(
4444 G_OBJECT(tab
->vbox
),
4447 (GDestroyNotify
)tab_destructor
);
4449 g_signal_connect(G_OBJECT(tab
->scrollbar
), "value-changed",
4450 G_CALLBACK(scroll_value_changed_cb
), tab
);
4452 g_signal_connect ((gpointer
) tab
->MEntry1
, "value-changed",
4453 G_CALLBACK (on_MEntry1_value_changed
),
4455 g_signal_connect ((gpointer
) tab
->MEntry2
, "value-changed",
4456 G_CALLBACK (on_MEntry2_value_changed
),
4458 g_signal_connect ((gpointer
) tab
->MEntry3
, "value-changed",
4459 G_CALLBACK (on_MEntry3_value_changed
),
4461 g_signal_connect ((gpointer
) tab
->MEntry4
, "value-changed",
4462 G_CALLBACK (on_MEntry4_value_changed
),
4464 g_signal_connect ((gpointer
) tab
->MEntry5
, "value-changed",
4465 G_CALLBACK (on_MEntry5_value_changed
),
4467 g_signal_connect ((gpointer
) tab
->MEntry6
, "value-changed",
4468 G_CALLBACK (on_MEntry6_value_changed
),
4471 //g_signal_connect(G_OBJECT(tab->scrollbar), "changed",
4472 // G_CALLBACK(scroll_value_changed_cb), tab);
4475 //insert tab into notebook
4476 gtk_notebook_append_page(notebook
,
4479 list
= gtk_container_get_children(GTK_CONTAINER(notebook
));
4480 gtk_notebook_set_current_page(notebook
,g_list_length(list
)-1);
4481 // always show : not if(g_list_length(list)>1)
4482 gtk_notebook_set_show_tabs(notebook
, TRUE
);
4485 lttvwindow_report_time_window(tab
, copy_tab
->time_window
);
4486 lttvwindow_report_current_time(tab
, copy_tab
->current_time
);
4488 TimeWindow time_window
;
4490 time_window
.start_time
= ltt_time_zero
;
4491 time_window
.end_time
= ltt_time_add(time_window
.start_time
,
4492 lttvwindow_default_time_width
);
4493 time_window
.time_width
= lttvwindow_default_time_width
;
4494 time_window
.time_width_double
= ltt_time_to_double(time_window
.time_width
);
4496 lttvwindow_report_time_window(tab
, time_window
);
4497 lttvwindow_report_current_time(tab
, ltt_time_zero
);
4500 LttvTraceset
*traceset
= tab
->traceset_info
->traceset
;
4501 SetTraceset(tab
, traceset
);
4507 * execute_events_requests
4509 * Idle function that executes the pending requests for a tab.
4511 * @return return value : TRUE : keep the idle function, FALSE : remove it.
4513 gboolean
execute_events_requests(Tab
*tab
)
4515 return ( lttvwindow_process_pending_requests(tab
) );
4519 void create_main_window_with_trace(gchar
*path
)
4521 if(path
== NULL
) return;
4524 MainWindow
*mw
= construct_main_window(NULL
);
4525 GtkWidget
*widget
= mw
->mwindow
;
4527 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
4528 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
4529 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
4533 tab
= create_new_tab(widget
, NULL
);
4535 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
4539 gchar abs_path
[PATH_MAX
];
4543 get_absolute_pathname(path
, abs_path
);
4544 trace_v
= lttvwindowtraces_get_trace_by_name(abs_path
);
4545 if(trace_v
== NULL
) {
4546 trace
= ltt_trace_open(abs_path
);
4548 g_warning("cannot open trace %s", abs_path
);
4550 GtkWidget
*dialogue
=
4551 gtk_message_dialog_new(
4552 GTK_WINDOW(gtk_widget_get_toplevel(widget
)),
4553 GTK_DIALOG_MODAL
|GTK_DIALOG_DESTROY_WITH_PARENT
,
4556 "Cannot open trace : maybe you should enter in the directory"
4558 gtk_dialog_run(GTK_DIALOG(dialogue
));
4559 gtk_widget_destroy(dialogue
);
4561 trace_v
= lttv_trace_new(trace
);
4562 lttvwindowtraces_add_trace(trace_v
);
4563 lttvwindow_add_trace(tab
, trace_v
);
4566 lttvwindow_add_trace(tab
, trace_v
);
4569 LttvTraceset
*traceset
;
4571 traceset
= tab
->traceset_info
->traceset
;
4572 SetTraceset(tab
, traceset
);