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 /* Else, the first request in list_in is a position request */
1094 /* If first req in list_in pos != current pos */
1095 g_assert(events_request
->start_position
!= NULL
);
1096 g_debug("SEEK POS time : %lu, %lu",
1097 lttv_traceset_context_position_get_time(
1098 events_request
->start_position
).tv_sec
,
1099 lttv_traceset_context_position_get_time(
1100 events_request
->start_position
).tv_nsec
);
1102 g_debug("SEEK POS context time : %lu, %lu",
1103 lttv_traceset_context_get_current_tfc(tsc
)->timestamp
.tv_sec
,
1104 lttv_traceset_context_get_current_tfc(tsc
)->timestamp
.tv_nsec
);
1105 g_assert(events_request
->start_position
!= NULL
);
1106 if(lttv_traceset_context_ctx_pos_compare(tsc
,
1107 events_request
->start_position
) != 0) {
1108 /* 1.2.2.1 Seek to that position */
1109 g_debug("SEEK POSITION");
1110 //lttv_process_traceset_seek_position(tsc, events_request->start_position);
1111 pos_time
= lttv_traceset_context_position_get_time(
1112 events_request
->start_position
);
1114 lttv_state_traceset_seek_time_closest(LTTV_TRACESET_STATE(tsc
),
1117 /* Process the traceset with only state hooks */
1119 lttv_process_traceset_middle(tsc
,
1122 events_request
->start_position
);
1123 g_assert(lttv_traceset_context_ctx_pos_compare(tsc
,
1124 events_request
->start_position
) == 0);
1131 /* 1.3 Add hooks and call before request for all list_in members */
1133 GSList
*iter
= NULL
;
1135 for(iter
=list_in
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
1136 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1137 /* 1.3.1 If !servicing */
1138 if(events_request
->servicing
== FALSE
) {
1139 /* - begin request hooks called
1140 * - servicing = TRUE
1142 lttv_hooks_call(events_request
->before_request
, (gpointer
)tsc
);
1143 events_request
->servicing
= TRUE
;
1145 /* 1.3.2 call before chunk
1146 * 1.3.3 events hooks added
1148 if(events_request
->trace
== -1)
1149 lttv_process_traceset_begin(tsc
,
1150 events_request
->before_chunk_traceset
,
1151 events_request
->before_chunk_trace
,
1152 events_request
->before_chunk_tracefile
,
1153 events_request
->event
,
1154 events_request
->event_by_id
);
1156 guint nb_trace
= lttv_traceset_number(tsc
->ts
);
1157 g_assert((guint
)events_request
->trace
< nb_trace
&&
1158 events_request
->trace
> -1);
1159 LttvTraceContext
*tc
= tsc
->traces
[events_request
->trace
];
1161 lttv_hooks_call(events_request
->before_chunk_traceset
, tsc
);
1163 lttv_trace_context_add_hooks(tc
,
1164 events_request
->before_chunk_trace
,
1165 events_request
->before_chunk_tracefile
,
1166 events_request
->event
,
1167 events_request
->event_by_id
);
1172 /* 2. Else, list_in is not empty, we continue a read */
1175 /* 2.0 For each req of list_in */
1176 GSList
*iter
= list_in
;
1178 while(iter
!= NULL
) {
1180 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1182 /* - Call before chunk
1183 * - events hooks added
1185 if(events_request
->trace
== -1)
1186 lttv_process_traceset_begin(tsc
,
1187 events_request
->before_chunk_traceset
,
1188 events_request
->before_chunk_trace
,
1189 events_request
->before_chunk_tracefile
,
1190 events_request
->event
,
1191 events_request
->event_by_id
);
1193 guint nb_trace
= lttv_traceset_number(tsc
->ts
);
1194 g_assert((guint
)events_request
->trace
< nb_trace
&&
1195 events_request
->trace
> -1);
1196 LttvTraceContext
*tc
= tsc
->traces
[events_request
->trace
];
1198 lttv_hooks_call(events_request
->before_chunk_traceset
, tsc
);
1200 lttv_trace_context_add_hooks(tc
,
1201 events_request
->before_chunk_trace
,
1202 events_request
->before_chunk_tracefile
,
1203 events_request
->event
,
1204 events_request
->event_by_id
);
1207 iter
= g_slist_next(iter
);
1212 tfc
= lttv_traceset_context_get_current_tfc(tsc
);
1214 /* 2.1 For each req of list_out */
1215 GSList
*iter
= list_out
;
1217 while(iter
!= NULL
) {
1219 gboolean remove
= FALSE
;
1220 gboolean free_data
= FALSE
;
1221 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1223 /* if req.start time == current context time
1224 * or req.start position == current position*/
1225 if( ltt_time_compare(events_request
->start_time
,
1226 tfc
->timestamp
) == 0
1228 (events_request
->start_position
!= NULL
1230 lttv_traceset_context_ctx_pos_compare(tsc
,
1231 events_request
->start_position
) == 0)
1233 /* - Add to list_in, remove from list_out */
1234 list_in
= g_slist_append(list_in
, events_request
);
1238 /* - If !servicing */
1239 if(events_request
->servicing
== FALSE
) {
1240 /* - begin request hooks called
1241 * - servicing = TRUE
1243 lttv_hooks_call(events_request
->before_request
, (gpointer
)tsc
);
1244 events_request
->servicing
= TRUE
;
1246 /* call before chunk
1247 * events hooks added
1249 if(events_request
->trace
== -1)
1250 lttv_process_traceset_begin(tsc
,
1251 events_request
->before_chunk_traceset
,
1252 events_request
->before_chunk_trace
,
1253 events_request
->before_chunk_tracefile
,
1254 events_request
->event
,
1255 events_request
->event_by_id
);
1257 guint nb_trace
= lttv_traceset_number(tsc
->ts
);
1258 g_assert((guint
)events_request
->trace
< nb_trace
&&
1259 events_request
->trace
> -1);
1260 LttvTraceContext
*tc
= tsc
->traces
[events_request
->trace
];
1262 lttv_hooks_call(events_request
->before_chunk_traceset
, tsc
);
1264 lttv_trace_context_add_hooks(tc
,
1265 events_request
->before_chunk_trace
,
1266 events_request
->before_chunk_tracefile
,
1267 events_request
->event
,
1268 events_request
->event_by_id
);
1277 GSList
*remove_iter
= iter
;
1279 iter
= g_slist_next(iter
);
1280 if(free_data
) events_request_free((EventsRequest
*)remove_iter
->data
);
1281 list_out
= g_slist_remove_link(list_out
, remove_iter
);
1282 } else { // not remove
1283 iter
= g_slist_next(iter
);
1289 /* 3. Find end criterions */
1294 /* 3.1.1 Find lowest end time in list_in */
1295 g_assert(g_slist_length(list_in
)>0);
1296 end_time
= ((EventsRequest
*)g_slist_nth_data(list_in
,0))->end_time
;
1298 for(iter
=g_slist_nth(list_in
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
1299 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1301 if(ltt_time_compare(events_request
->end_time
,
1303 end_time
= events_request
->end_time
;
1306 /* 3.1.2 Find lowest start time in list_out */
1307 for(iter
=list_out
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
1308 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1310 if(ltt_time_compare(events_request
->start_time
,
1312 end_time
= events_request
->start_time
;
1317 /* 3.2 Number of events */
1319 /* 3.2.1 Find lowest number of events in list_in */
1322 end_nb_events
= ((EventsRequest
*)g_slist_nth_data(list_in
,0))->num_events
;
1324 for(iter
=g_slist_nth(list_in
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
1325 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1327 if(events_request
->num_events
< end_nb_events
)
1328 end_nb_events
= events_request
->num_events
;
1331 /* 3.2.2 Use min(CHUNK_NUM_EVENTS, min num events in list_in) as
1334 end_nb_events
= MIN(CHUNK_NUM_EVENTS
, end_nb_events
);
1338 /* 3.3 End position */
1340 /* 3.3.1 Find lowest end position in list_in */
1343 end_position
=((EventsRequest
*)g_slist_nth_data(list_in
,0))->end_position
;
1345 for(iter
=g_slist_nth(list_in
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
1346 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1348 if(events_request
->end_position
!= NULL
&& end_position
!= NULL
&&
1349 lttv_traceset_context_pos_pos_compare(events_request
->end_position
,
1351 end_position
= events_request
->end_position
;
1356 /* 3.3.2 Find lowest start position in list_out */
1359 for(iter
=list_out
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
1360 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1362 if(events_request
->end_position
!= NULL
&& end_position
!= NULL
&&
1363 lttv_traceset_context_pos_pos_compare(events_request
->end_position
,
1365 end_position
= events_request
->end_position
;
1370 /* 4. Call process traceset middle */
1371 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
);
1372 count
= lttv_process_traceset_middle(tsc
, end_time
, end_nb_events
, end_position
);
1374 tfc
= lttv_traceset_context_get_current_tfc(tsc
);
1376 g_debug("Context time after middle : %lu, %lu", tfc
->timestamp
.tv_sec
,
1377 tfc
->timestamp
.tv_nsec
);
1379 g_debug("End of trace reached after middle.");
1383 /* 5. After process traceset middle */
1384 tfc
= lttv_traceset_context_get_current_tfc(tsc
);
1386 /* - if current context time > traceset.end time */
1387 if(tfc
== NULL
|| ltt_time_compare(tfc
->timestamp
,
1388 tsc
->time_span
.end_time
) > 0) {
1389 /* - For each req in list_in */
1390 GSList
*iter
= list_in
;
1392 while(iter
!= NULL
) {
1394 gboolean remove
= FALSE
;
1395 gboolean free_data
= FALSE
;
1396 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1398 /* - Remove events hooks for req
1399 * - Call end chunk for req
1402 if(events_request
->trace
== -1)
1403 lttv_process_traceset_end(tsc
,
1404 events_request
->after_chunk_traceset
,
1405 events_request
->after_chunk_trace
,
1406 events_request
->after_chunk_tracefile
,
1407 events_request
->event
,
1408 events_request
->event_by_id
);
1411 guint nb_trace
= lttv_traceset_number(tsc
->ts
);
1412 g_assert(events_request
->trace
< nb_trace
&&
1413 events_request
->trace
> -1);
1414 LttvTraceContext
*tc
= tsc
->traces
[events_request
->trace
];
1416 lttv_trace_context_remove_hooks(tc
,
1417 events_request
->after_chunk_trace
,
1418 events_request
->after_chunk_tracefile
,
1419 events_request
->event
,
1420 events_request
->event_by_id
);
1421 lttv_hooks_call(events_request
->after_chunk_traceset
, tsc
);
1426 /* - Call end request for req */
1427 lttv_hooks_call(events_request
->after_request
, (gpointer
)tsc
);
1429 /* - remove req from list_in */
1430 /* Destroy the request */
1437 GSList
*remove_iter
= iter
;
1439 iter
= g_slist_next(iter
);
1440 if(free_data
) events_request_free((EventsRequest
*)remove_iter
->data
);
1441 list_in
= g_slist_remove_link(list_in
, remove_iter
);
1442 } else { // not remove
1443 iter
= g_slist_next(iter
);
1448 /* 5.1 For each req in list_in */
1449 GSList
*iter
= list_in
;
1451 while(iter
!= NULL
) {
1453 gboolean remove
= FALSE
;
1454 gboolean free_data
= FALSE
;
1455 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1457 /* - Remove events hooks for req
1458 * - Call end chunk for req
1460 if(events_request
->trace
== -1)
1461 lttv_process_traceset_end(tsc
,
1462 events_request
->after_chunk_traceset
,
1463 events_request
->after_chunk_trace
,
1464 events_request
->after_chunk_tracefile
,
1465 events_request
->event
,
1466 events_request
->event_by_id
);
1469 guint nb_trace
= lttv_traceset_number(tsc
->ts
);
1470 g_assert(events_request
->trace
< nb_trace
&&
1471 events_request
->trace
> -1);
1472 LttvTraceContext
*tc
= tsc
->traces
[events_request
->trace
];
1474 lttv_trace_context_remove_hooks(tc
,
1475 events_request
->after_chunk_trace
,
1476 events_request
->after_chunk_tracefile
,
1477 events_request
->event
,
1478 events_request
->event_by_id
);
1480 lttv_hooks_call(events_request
->after_chunk_traceset
, tsc
);
1483 /* - req.num -= count */
1484 g_assert(events_request
->num_events
>= count
);
1485 events_request
->num_events
-= count
;
1487 g_assert(tfc
!= NULL
);
1488 /* - if req.num == 0
1490 * current context time >= req.end time
1492 * req.end pos == current pos
1494 * req.stop_flag == TRUE
1496 if( events_request
->num_events
== 0
1498 events_request
->stop_flag
== TRUE
1500 ltt_time_compare(tfc
->timestamp
,
1501 events_request
->end_time
) >= 0
1503 (events_request
->end_position
!= NULL
1505 lttv_traceset_context_ctx_pos_compare(tsc
,
1506 events_request
->end_position
) == 0)
1509 g_assert(events_request
->servicing
== TRUE
);
1510 /* - Call end request for req
1511 * - remove req from list_in */
1512 lttv_hooks_call(events_request
->after_request
, (gpointer
)tsc
);
1513 /* - remove req from list_in */
1514 /* Destroy the request */
1522 GSList
*remove_iter
= iter
;
1524 iter
= g_slist_next(iter
);
1525 if(free_data
) events_request_free((EventsRequest
*)remove_iter
->data
);
1526 list_in
= g_slist_remove_link(list_in
, remove_iter
);
1527 } else { // not remove
1528 iter
= g_slist_next(iter
);
1534 /* End of removed servicing loop : leave control to GTK instead. */
1535 // if(gtk_events_pending()) break;
1538 /* B. When interrupted between chunks */
1541 GSList
*iter
= list_in
;
1543 /* 1. for each request in list_in */
1544 while(iter
!= NULL
) {
1546 gboolean remove
= FALSE
;
1547 gboolean free_data
= FALSE
;
1548 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1550 /* 1.1. Use current postition as start position */
1551 if(events_request
->start_position
!= NULL
)
1552 lttv_traceset_context_position_destroy(events_request
->start_position
);
1553 events_request
->start_position
= lttv_traceset_context_position_new(tsc
);
1554 lttv_traceset_context_position_save(tsc
, events_request
->start_position
);
1556 /* 1.2. Remove start time */
1557 events_request
->start_time
= ltt_time_infinite
;
1559 /* 1.3. Move from list_in to list_out */
1562 list_out
= g_slist_append(list_out
, events_request
);
1567 GSList
*remove_iter
= iter
;
1569 iter
= g_slist_next(iter
);
1570 if(free_data
) events_request_free((EventsRequest
*)remove_iter
->data
);
1571 list_in
= g_slist_remove_link(list_in
, remove_iter
);
1572 } else { // not remove
1573 iter
= g_slist_next(iter
);
1579 /* C Unlock Traces */
1581 lttv_process_traceset_get_sync_data(tsc
);
1582 //lttv_traceset_context_position_save(tsc, sync_position);
1587 iter_trace
<lttv_traceset_number(tsc
->ts
);
1589 LttvTrace
*trace_v
= lttv_traceset_get(tsc
->ts
, iter_trace
);
1591 lttvwindowtraces_unlock(trace_v
);
1595 //set the cursor back to normal
1596 gdk_window_set_cursor(win
, NULL
);
1599 g_assert(g_slist_length(list_in
) == 0);
1601 if( g_slist_length(list_out
) == 0 ) {
1602 /* Put tab's request pending flag back to normal */
1603 tab
->events_request_pending
= FALSE
;
1604 g_debug("remove the idle fct");
1605 return FALSE
; /* Remove the idle function */
1607 g_debug("leave the idle fct");
1608 return TRUE
; /* Leave the idle function */
1610 /* We do not use simili-round-robin, it may require to read 1 meg buffers
1611 * again and again if many tracesets use the same tracefiles. */
1612 /* Hack for round-robin idle functions */
1613 /* It will put the idle function at the end of the pool */
1614 /*g_idle_add_full((G_PRIORITY_HIGH_IDLE + 21),
1615 (GSourceFunc)execute_events_requests,
1625 static void lttvwindow_add_trace(Tab
*tab
, LttvTrace
*trace_v
)
1627 LttvTraceset
*traceset
= tab
->traceset_info
->traceset
;
1629 guint num_traces
= lttv_traceset_number(traceset
);
1631 //Verify if trace is already present.
1632 for(i
=0; i
<num_traces
; i
++)
1634 LttvTrace
* trace
= lttv_traceset_get(traceset
, i
);
1635 if(trace
== trace_v
)
1639 //Keep a reference to the traces so they are not freed.
1640 for(i
=0; i
<lttv_traceset_number(traceset
); i
++)
1642 LttvTrace
* trace
= lttv_traceset_get(traceset
, i
);
1643 lttv_trace_ref(trace
);
1646 //remove state update hooks
1647 lttv_state_remove_event_hooks(
1648 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1650 lttv_context_fini(LTTV_TRACESET_CONTEXT(
1651 tab
->traceset_info
->traceset_context
));
1652 g_object_unref(tab
->traceset_info
->traceset_context
);
1654 lttv_traceset_add(traceset
, trace_v
);
1655 lttv_trace_ref(trace_v
); /* local ref */
1657 /* Create new context */
1658 tab
->traceset_info
->traceset_context
=
1659 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
1661 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->
1666 //add state update hooks
1667 lttv_state_add_event_hooks(
1668 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1669 //Remove local reference to the traces.
1670 for(i
=0; i
<lttv_traceset_number(traceset
); i
++)
1672 LttvTrace
* trace
= lttv_traceset_get(traceset
, i
);
1673 lttv_trace_unref(trace
);
1677 //add_trace_into_traceset_selector(GTK_MULTIVPANED(tab->multivpaned), lttv_trace(trace_v));
1680 /* add_trace adds a trace into the current traceset. It first displays a
1681 * directory selection dialogue to let user choose a trace, then recreates
1682 * tracset_context, and redraws all the viewer of the current tab
1685 void add_trace(GtkWidget
* widget
, gpointer user_data
)
1688 LttvTrace
* trace_v
;
1689 LttvTraceset
* traceset
;
1691 char abs_path
[PATH_MAX
];
1693 MainWindow
* mw_data
= get_window_data_struct(widget
);
1694 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
1696 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1697 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1701 tab
= create_new_tab(widget
, NULL
);
1703 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1706 //GtkDirSelection * file_selector = (GtkDirSelection *)gtk_dir_selection_new("Select a trace");
1707 GtkFileSelection
* file_selector
= (GtkFileSelection
*)gtk_file_selection_new("Select a trace");
1708 gtk_widget_hide( (file_selector
)->file_list
->parent
) ;
1709 gtk_file_selection_hide_fileop_buttons(file_selector
);
1710 gtk_window_set_transient_for(GTK_WINDOW(file_selector
),
1711 GTK_WINDOW(mw_data
->mwindow
));
1713 if(remember_trace_dir
[0] != '\0')
1714 gtk_file_selection_set_filename(file_selector
, remember_trace_dir
);
1716 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
1718 case GTK_RESPONSE_ACCEPT
:
1719 case GTK_RESPONSE_OK
:
1720 dir
= gtk_file_selection_get_filename (file_selector
);
1721 strncpy(remember_trace_dir
, dir
, PATH_MAX
);
1722 strncat(remember_trace_dir
, "/", PATH_MAX
);
1723 if(!dir
|| strlen(dir
) == 0){
1724 gtk_widget_destroy((GtkWidget
*)file_selector
);
1727 get_absolute_pathname(dir
, abs_path
);
1728 trace_v
= lttvwindowtraces_get_trace_by_name(abs_path
);
1729 if(trace_v
== NULL
) {
1730 trace
= ltt_trace_open(abs_path
);
1732 g_warning("cannot open trace %s", abs_path
);
1734 trace_v
= lttv_trace_new(trace
);
1735 lttvwindowtraces_add_trace(trace_v
);
1736 lttvwindow_add_trace(tab
, trace_v
);
1739 lttvwindow_add_trace(tab
, trace_v
);
1742 gtk_widget_destroy((GtkWidget
*)file_selector
);
1744 //update current tab
1745 //update_traceset(mw_data);
1747 /* Call the updatetraceset hooks */
1749 traceset
= tab
->traceset_info
->traceset
;
1750 SetTraceset(tab
, traceset
);
1751 // in expose now call_pending_read_hooks(mw_data);
1753 //lttvwindow_report_current_time(mw_data,&(tab->current_time));
1755 case GTK_RESPONSE_REJECT
:
1756 case GTK_RESPONSE_CANCEL
:
1758 gtk_widget_destroy((GtkWidget
*)file_selector
);
1763 /* remove_trace removes a trace from the current traceset if all viewers in
1764 * the current tab are not interested in the trace. It first displays a
1765 * dialogue, which shows all traces in the current traceset, to let user choose
1766 * a trace, then it checks if all viewers unselect the trace, if it is true,
1767 * it will remove the trace, recreate the traceset_contex,
1768 * and redraws all the viewer of the current tab. If there is on trace in the
1769 * current traceset, it will delete all viewers of the current tab
1771 * It destroys the filter tree. FIXME... we should request for an update
1775 void remove_trace(GtkWidget
*widget
, gpointer user_data
)
1778 LttvTrace
* trace_v
;
1779 LttvTraceset
* traceset
;
1780 gint i
, j
, nb_trace
, index
=-1;
1781 char ** name
, *remove_trace_name
;
1782 MainWindow
* mw_data
= get_window_data_struct(widget
);
1783 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
1785 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1786 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1792 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1795 nb_trace
=lttv_traceset_number(tab
->traceset_info
->traceset
);
1796 name
= g_new(char*,nb_trace
);
1797 for(i
= 0; i
< nb_trace
; i
++){
1798 trace_v
= lttv_traceset_get(tab
->traceset_info
->traceset
, i
);
1799 trace
= lttv_trace(trace_v
);
1800 name
[i
] = g_quark_to_string(ltt_trace_name(trace
));
1803 remove_trace_name
= get_remove_trace(mw_data
, name
, nb_trace
);
1806 if(remove_trace_name
){
1808 /* yuk, cut n paste from old code.. should be better (MD)*/
1809 for(i
= 0; i
<nb_trace
; i
++) {
1810 if(strcmp(remove_trace_name
,name
[i
]) == 0){
1815 traceset
= tab
->traceset_info
->traceset
;
1816 //Keep a reference to the traces so they are not freed.
1817 for(j
=0; j
<lttv_traceset_number(traceset
); j
++)
1819 LttvTrace
* trace
= lttv_traceset_get(traceset
, j
);
1820 lttv_trace_ref(trace
);
1823 //remove state update hooks
1824 lttv_state_remove_event_hooks(
1825 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1826 lttv_context_fini(LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
));
1827 g_object_unref(tab
->traceset_info
->traceset_context
);
1829 trace_v
= lttv_traceset_get(traceset
, index
);
1831 lttv_traceset_remove(traceset
, index
);
1832 lttv_trace_unref(trace_v
); // Remove local reference
1834 if(lttv_trace_get_ref_number(trace_v
) <= 1) {
1835 /* ref 1 : lttvwindowtraces only*/
1836 ltt_trace_close(lttv_trace(trace_v
));
1837 /* lttvwindowtraces_remove_trace takes care of destroying
1838 * the traceset linked with the trace_v and also of destroying
1839 * the trace_v at the same time.
1841 lttvwindowtraces_remove_trace(trace_v
);
1844 tab
->traceset_info
->traceset_context
=
1845 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
1847 LTTV_TRACESET_CONTEXT(tab
->
1848 traceset_info
->traceset_context
),traceset
);
1849 //add state update hooks
1850 lttv_state_add_event_hooks(
1851 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1853 //Remove local reference to the traces.
1854 for(j
=0; j
<lttv_traceset_number(traceset
); j
++)
1856 LttvTrace
* trace
= lttv_traceset_get(traceset
, j
);
1857 lttv_trace_unref(trace
);
1860 SetTraceset(tab
, (gpointer
)traceset
);
1866 void remove_trace(GtkWidget
* widget
, gpointer user_data
)
1869 LttvTrace
* trace_v
;
1870 LttvTraceset
* traceset
;
1871 gint i
, j
, nb_trace
;
1872 char ** name
, *remove_trace_name
;
1873 MainWindow
* mw_data
= get_window_data_struct(widget
);
1874 LttvTracesetSelector
* s
;
1875 LttvTraceSelector
* t
;
1878 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
1880 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1881 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1887 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1890 nb_trace
=lttv_traceset_number(tab
->traceset_info
->traceset
);
1891 name
= g_new(char*,nb_trace
);
1892 for(i
= 0; i
< nb_trace
; i
++){
1893 trace_v
= lttv_traceset_get(tab
->traceset_info
->traceset
, i
);
1894 trace
= lttv_trace(trace_v
);
1895 name
[i
] = ltt_trace_name(trace
);
1898 remove_trace_name
= get_remove_trace(name
, nb_trace
);
1900 if(remove_trace_name
){
1901 for(i
=0; i
<nb_trace
; i
++){
1902 if(strcmp(remove_trace_name
,name
[i
]) == 0){
1903 //unselect the trace from the current viewer
1905 w
= gtk_multivpaned_get_widget(GTK_MULTIVPANED(tab
->multivpaned
));
1907 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
1909 t
= lttv_traceset_selector_trace_get(s
,i
);
1910 lttv_trace_selector_set_selected(t
, FALSE
);
1913 //check if other viewers select the trace
1914 w
= gtk_multivpaned_get_first_widget(GTK_MULTIVPANED(tab
->multivpaned
));
1916 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
1918 t
= lttv_traceset_selector_trace_get(s
,i
);
1919 selected
= lttv_trace_selector_get_selected(t
);
1922 w
= gtk_multivpaned_get_next_widget(GTK_MULTIVPANED(tab
->multivpaned
));
1924 }else selected
= FALSE
;
1926 //if no viewer selects the trace, remove it
1928 remove_trace_from_traceset_selector(GTK_MULTIVPANED(tab
->multivpaned
), i
);
1930 traceset
= tab
->traceset_info
->traceset
;
1931 //Keep a reference to the traces so they are not freed.
1932 for(j
=0; j
<lttv_traceset_number(traceset
); j
++)
1934 LttvTrace
* trace
= lttv_traceset_get(traceset
, j
);
1935 lttv_trace_ref(trace
);
1938 //remove state update hooks
1939 lttv_state_remove_event_hooks(
1940 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1941 lttv_context_fini(LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
));
1942 g_object_unref(tab
->traceset_info
->traceset_context
);
1945 trace_v
= lttv_traceset_get(traceset
, i
);
1947 if(lttv_trace_get_ref_number(trace_v
) <= 2) {
1948 /* ref 2 : traceset, local */
1949 lttvwindowtraces_remove_trace(trace_v
);
1950 ltt_trace_close(lttv_trace(trace_v
));
1953 lttv_traceset_remove(traceset
, i
);
1954 lttv_trace_unref(trace_v
); // Remove local reference
1956 if(!lttv_trace_get_ref_number(trace_v
))
1957 lttv_trace_destroy(trace_v
);
1959 tab
->traceset_info
->traceset_context
=
1960 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
1962 LTTV_TRACESET_CONTEXT(tab
->
1963 traceset_info
->traceset_context
),traceset
);
1964 //add state update hooks
1965 lttv_state_add_event_hooks(
1966 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1968 //Remove local reference to the traces.
1969 for(j
=0; j
<lttv_traceset_number(traceset
); j
++)
1971 LttvTrace
* trace
= lttv_traceset_get(traceset
, j
);
1972 lttv_trace_unref(trace
);
1976 //update current tab
1977 //update_traceset(mw_data);
1980 SetTraceset(tab
, (gpointer
)traceset
);
1981 // in expose now call_pending_read_hooks(mw_data);
1983 //lttvwindow_report_current_time(mw_data,&(tab->current_time));
1986 // while(tab->multi_vpaned->num_children){
1987 // gtk_multi_vpaned_widget_delete(tab->multi_vpaned);
2001 /* Redraw all the viewers in the current tab */
2002 void redraw(GtkWidget
*widget
, gpointer user_data
)
2004 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
2005 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
2006 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
2011 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
2015 LttvAttributeValue value
;
2017 g_assert(lttv_iattribute_find_by_path(tab
->attributes
, "hooks/redraw", LTTV_POINTER
, &value
));
2019 tmp
= (LttvHooks
*)*(value
.v_pointer
);
2021 lttv_hooks_call(tmp
,NULL
);
2025 void continue_processing(GtkWidget
*widget
, gpointer user_data
)
2027 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
2028 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
2029 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
2034 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
2038 LttvAttributeValue value
;
2040 g_assert(lttv_iattribute_find_by_path(tab
->attributes
,
2041 "hooks/continue", LTTV_POINTER
, &value
));
2043 tmp
= (LttvHooks
*)*(value
.v_pointer
);
2045 lttv_hooks_call(tmp
,NULL
);
2048 /* Stop the processing for the calling main window's current tab.
2049 * It removes every processing requests that are in its list. It does not call
2050 * the end request hooks, because the request is not finished.
2053 void stop_processing(GtkWidget
*widget
, gpointer user_data
)
2055 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
2056 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
2057 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
2062 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
2064 GSList
*iter
= tab
->events_requests
;
2066 while(iter
!= NULL
) {
2067 GSList
*remove_iter
= iter
;
2068 iter
= g_slist_next(iter
);
2070 g_free(remove_iter
->data
);
2071 tab
->events_requests
=
2072 g_slist_remove_link(tab
->events_requests
, remove_iter
);
2074 tab
->events_request_pending
= FALSE
;
2075 g_idle_remove_by_data(tab
);
2076 g_assert(g_slist_length(tab
->events_requests
) == 0);
2080 /* save will save the traceset to a file
2081 * Not implemented yet FIXME
2084 void save(GtkWidget
* widget
, gpointer user_data
)
2089 void save_as(GtkWidget
* widget
, gpointer user_data
)
2091 g_info("Save as\n");
2095 /* zoom will change the time_window of all the viewers of the
2096 * current tab, and redisplay them. The main functionality is to
2097 * determine the new time_window of the current tab
2100 void zoom(GtkWidget
* widget
, double size
)
2102 TimeInterval time_span
;
2103 TimeWindow new_time_window
;
2104 LttTime current_time
, time_delta
;
2105 MainWindow
* mw_data
= get_window_data_struct(widget
);
2106 LttvTracesetContext
*tsc
;
2107 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
2109 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
2110 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
2116 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
2119 if(size
== 1) return;
2121 tsc
= LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
2122 time_span
= tsc
->time_span
;
2123 new_time_window
= tab
->time_window
;
2124 current_time
= tab
->current_time
;
2126 time_delta
= ltt_time_sub(time_span
.end_time
,time_span
.start_time
);
2128 new_time_window
.start_time
= time_span
.start_time
;
2129 new_time_window
.time_width
= time_delta
;
2130 new_time_window
.time_width_double
= ltt_time_to_double(time_delta
);
2131 new_time_window
.end_time
= ltt_time_add(new_time_window
.start_time
,
2132 new_time_window
.time_width
) ;
2134 new_time_window
.time_width
= ltt_time_div(new_time_window
.time_width
, size
);
2135 new_time_window
.time_width_double
=
2136 ltt_time_to_double(new_time_window
.time_width
);
2137 if(ltt_time_compare(new_time_window
.time_width
,time_delta
) > 0)
2138 { /* Case where zoom out is bigger than trace length */
2139 new_time_window
.start_time
= time_span
.start_time
;
2140 new_time_window
.time_width
= time_delta
;
2141 new_time_window
.time_width_double
= ltt_time_to_double(time_delta
);
2142 new_time_window
.end_time
= ltt_time_add(new_time_window
.start_time
,
2143 new_time_window
.time_width
) ;
2147 /* Center the image on the current time */
2148 new_time_window
.start_time
=
2149 ltt_time_sub(current_time
,
2150 ltt_time_from_double(new_time_window
.time_width_double
/2.0));
2151 new_time_window
.end_time
= ltt_time_add(new_time_window
.start_time
,
2152 new_time_window
.time_width
) ;
2153 /* If on borders, don't fall off */
2154 if(ltt_time_compare(new_time_window
.start_time
, time_span
.start_time
) <0)
2156 new_time_window
.start_time
= time_span
.start_time
;
2157 new_time_window
.end_time
= ltt_time_add(new_time_window
.start_time
,
2158 new_time_window
.time_width
) ;
2162 if(ltt_time_compare(new_time_window
.end_time
,
2163 time_span
.end_time
) > 0)
2165 new_time_window
.start_time
=
2166 ltt_time_sub(time_span
.end_time
, new_time_window
.time_width
);
2168 new_time_window
.end_time
= ltt_time_add(new_time_window
.start_time
,
2169 new_time_window
.time_width
) ;
2176 if(ltt_time_compare(new_time_window
.time_width
, ltt_time_zero
) == 0) {
2177 g_warning("Zoom more than 1 ns impossible");
2179 time_change_manager(tab
, new_time_window
);
2183 void zoom_in(GtkWidget
* widget
, gpointer user_data
)
2188 void zoom_out(GtkWidget
* widget
, gpointer user_data
)
2193 void zoom_extended(GtkWidget
* widget
, gpointer user_data
)
2198 void go_to_time(GtkWidget
* widget
, gpointer user_data
)
2200 g_info("Go to time\n");
2203 void show_time_frame(GtkWidget
* widget
, gpointer user_data
)
2205 g_info("Show time frame\n");
2209 /* callback function */
2212 on_empty_traceset_activate (GtkMenuItem
*menuitem
,
2215 create_new_window((GtkWidget
*)menuitem
, user_data
, FALSE
);
2220 on_clone_traceset_activate (GtkMenuItem
*menuitem
,
2223 create_new_window((GtkWidget
*)menuitem
, user_data
, TRUE
);
2227 /* create_new_tab calls create_tab to construct a new tab in the main window
2230 Tab
*create_new_tab(GtkWidget
* widget
, gpointer user_data
){
2231 gchar label
[PATH_MAX
];
2232 MainWindow
* mw_data
= get_window_data_struct(widget
);
2234 GtkNotebook
* notebook
= (GtkNotebook
*)lookup_widget(widget
, "MNotebook");
2235 if(notebook
== NULL
){
2236 g_info("Notebook does not exist\n");
2239 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
2240 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
2246 copy_tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
2249 strcpy(label
,"Page");
2250 if(get_label(mw_data
, label
,"Get the name of the tab","Please input tab's name"))
2251 return (create_tab (mw_data
, copy_tab
, notebook
, label
));
2257 on_tab_activate (GtkMenuItem
*menuitem
,
2260 create_new_tab((GtkWidget
*)menuitem
, user_data
);
2265 on_open_activate (GtkMenuItem
*menuitem
,
2268 open_traceset((GtkWidget
*)menuitem
, user_data
);
2273 on_close_activate (GtkMenuItem
*menuitem
,
2276 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2277 main_window_destructor(mw_data
);
2281 /* remove the current tab from the main window
2285 on_close_tab_activate (GtkWidget
*widget
,
2289 GtkWidget
* notebook
;
2291 MainWindow
* mw_data
= get_window_data_struct(widget
);
2292 notebook
= lookup_widget(widget
, "MNotebook");
2293 if(notebook
== NULL
){
2294 g_info("Notebook does not exist\n");
2298 page_num
= gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
));
2300 gtk_notebook_remove_page(GTK_NOTEBOOK(notebook
), page_num
);
2305 on_close_tab_X_clicked (GtkWidget
*widget
,
2309 GtkWidget
*notebook
= lookup_widget(widget
, "MNotebook");
2310 if(notebook
== NULL
){
2311 g_info("Notebook does not exist\n");
2315 if((page_num
= gtk_notebook_page_num(GTK_NOTEBOOK(notebook
), widget
)) != -1)
2316 gtk_notebook_remove_page(GTK_NOTEBOOK(notebook
), page_num
);
2322 on_add_trace_activate (GtkMenuItem
*menuitem
,
2325 add_trace((GtkWidget
*)menuitem
, user_data
);
2330 on_remove_trace_activate (GtkMenuItem
*menuitem
,
2333 remove_trace((GtkWidget
*)menuitem
, user_data
);
2338 on_save_activate (GtkMenuItem
*menuitem
,
2341 save((GtkWidget
*)menuitem
, user_data
);
2346 on_save_as_activate (GtkMenuItem
*menuitem
,
2349 save_as((GtkWidget
*)menuitem
, user_data
);
2354 on_quit_activate (GtkMenuItem
*menuitem
,
2362 on_cut_activate (GtkMenuItem
*menuitem
,
2370 on_copy_activate (GtkMenuItem
*menuitem
,
2378 on_paste_activate (GtkMenuItem
*menuitem
,
2386 on_delete_activate (GtkMenuItem
*menuitem
,
2394 on_zoom_in_activate (GtkMenuItem
*menuitem
,
2397 zoom_in((GtkWidget
*)menuitem
, user_data
);
2402 on_zoom_out_activate (GtkMenuItem
*menuitem
,
2405 zoom_out((GtkWidget
*)menuitem
, user_data
);
2410 on_zoom_extended_activate (GtkMenuItem
*menuitem
,
2413 zoom_extended((GtkWidget
*)menuitem
, user_data
);
2418 on_go_to_time_activate (GtkMenuItem
*menuitem
,
2421 go_to_time((GtkWidget
*)menuitem
, user_data
);
2426 on_show_time_frame_activate (GtkMenuItem
*menuitem
,
2429 show_time_frame((GtkWidget
*)menuitem
, user_data
);
2434 on_move_viewer_up_activate (GtkMenuItem
*menuitem
,
2437 move_up_viewer((GtkWidget
*)menuitem
, user_data
);
2442 on_move_viewer_down_activate (GtkMenuItem
*menuitem
,
2445 move_down_viewer((GtkWidget
*)menuitem
, user_data
);
2450 on_remove_viewer_activate (GtkMenuItem
*menuitem
,
2453 delete_viewer((GtkWidget
*)menuitem
, user_data
);
2457 on_trace_facility_activate (GtkMenuItem
*menuitem
,
2460 g_info("Trace facility selector: %s\n");
2464 /* Dispaly a file selection dialogue to let user select a library, then call
2465 * lttv_library_load().
2469 on_load_library_activate (GtkMenuItem
*menuitem
,
2472 GError
*error
= NULL
;
2473 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2475 gchar load_module_path_alter
[PATH_MAX
];
2479 gchar
*load_module_path
;
2480 name
= g_ptr_array_new();
2481 nb
= lttv_library_path_number();
2482 /* ask for the library path */
2486 path
= lttv_library_path_get(i
);
2487 g_ptr_array_add(name
, path
);
2490 load_module_path
= get_selection(mw_data
,
2491 (char **)(name
->pdata
), name
->len
,
2492 "Select a library path", "Library paths");
2493 if(load_module_path
!= NULL
)
2494 strncpy(load_module_path_alter
, load_module_path
, PATH_MAX
-1); // -1 for /
2496 g_ptr_array_free(name
, TRUE
);
2498 if(load_module_path
== NULL
) return;
2502 /* Make sure the module path ends with a / */
2503 gchar
*ptr
= load_module_path_alter
;
2505 ptr
= strchr(ptr
, '\0');
2507 if(*(ptr
-1) != '/') {
2514 /* Ask for the library to load : list files in the previously selected
2516 gchar str
[PATH_MAX
];
2519 GtkFileSelection
* file_selector
=
2520 (GtkFileSelection
*)gtk_file_selection_new("Select a module");
2521 gtk_file_selection_set_filename(file_selector
, load_module_path_alter
);
2522 gtk_file_selection_hide_fileop_buttons(file_selector
);
2524 gtk_window_set_transient_for(GTK_WINDOW(file_selector
),
2525 GTK_WINDOW(mw_data
->mwindow
));
2528 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
2530 case GTK_RESPONSE_ACCEPT
:
2531 case GTK_RESPONSE_OK
:
2532 dir
= gtk_file_selection_get_selections (file_selector
);
2533 strncpy(str
,dir
[0],PATH_MAX
);
2534 strncpy(remember_plugins_dir
,dir
[0],PATH_MAX
);
2535 /* only keep file name */
2537 str1
= strrchr(str
,'/');
2540 str1
= strrchr(str
,'\\');
2545 if(*str1
== 'l' && *(str1
+1)== 'i' && *(str1
+2)=='b')
2547 remove info after
. */
2551 str2
= strrchr(str2
, '.');
2552 if(str2
!= NULL
) *str2
= '\0';
2554 lttv_module_require(str1
, &error
);
2556 lttv_library_load(str1
, &error
);
2557 if(error
!= NULL
) g_warning("%s", error
->message
);
2558 else g_info("Load library: %s\n", str
);
2560 case GTK_RESPONSE_REJECT
:
2561 case GTK_RESPONSE_CANCEL
:
2563 gtk_widget_destroy((GtkWidget
*)file_selector
);
2574 /* Display all loaded modules, let user to select a module to unload
2575 * by calling lttv_module_unload
2579 on_unload_library_activate (GtkMenuItem
*menuitem
,
2582 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2584 LttvLibrary
*library
= NULL
;
2589 name
= g_ptr_array_new();
2590 nb
= lttv_library_number();
2591 LttvLibraryInfo
*lib_info
= g_new(LttvLibraryInfo
,nb
);
2592 /* ask for the library name */
2595 LttvLibrary
*iter_lib
= lttv_library_get(i
);
2596 lttv_library_info(iter_lib
, &lib_info
[i
]);
2598 gchar
*path
= lib_info
[i
].name
;
2599 g_ptr_array_add(name
, path
);
2601 lib_name
= get_selection(mw_data
, (char **)(name
->pdata
), name
->len
,
2602 "Select a library", "Libraries");
2603 if(lib_name
!= NULL
) {
2605 if(strcmp(lib_name
, lib_info
[i
].name
) == 0) {
2606 library
= lttv_library_get(i
);
2611 g_ptr_array_free(name
, TRUE
);
2614 if(lib_name
== NULL
) return;
2616 if(library
!= NULL
) lttv_library_unload(library
);
2620 /* Dispaly a file selection dialogue to let user select a module, then call
2621 * lttv_module_require().
2625 on_load_module_activate (GtkMenuItem
*menuitem
,
2628 GError
*error
= NULL
;
2629 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2631 LttvLibrary
*library
= NULL
;
2636 name
= g_ptr_array_new();
2637 nb
= lttv_library_number();
2638 LttvLibraryInfo
*lib_info
= g_new(LttvLibraryInfo
,nb
);
2639 /* ask for the library name */
2642 LttvLibrary
*iter_lib
= lttv_library_get(i
);
2643 lttv_library_info(iter_lib
, &lib_info
[i
]);
2645 gchar
*path
= lib_info
[i
].name
;
2646 g_ptr_array_add(name
, path
);
2648 lib_name
= get_selection(mw_data
,(char **)(name
->pdata
), name
->len
,
2649 "Select a library", "Libraries");
2650 if(lib_name
!= NULL
) {
2652 if(strcmp(lib_name
, lib_info
[i
].name
) == 0) {
2653 library
= lttv_library_get(i
);
2658 g_ptr_array_free(name
, TRUE
);
2661 if(lib_name
== NULL
) return;
2664 //LttvModule *module;
2665 gchar module_name_out
[PATH_MAX
];
2667 /* Ask for the module to load : list modules in the selected lib */
2671 nb
= lttv_library_module_number(library
);
2672 LttvModuleInfo
*module_info
= g_new(LttvModuleInfo
,nb
);
2673 name
= g_ptr_array_new();
2674 /* ask for the module name */
2677 LttvModule
*iter_module
= lttv_library_module_get(library
, i
);
2678 lttv_module_info(iter_module
, &module_info
[i
]);
2680 gchar
*path
= module_info
[i
].name
;
2681 g_ptr_array_add(name
, path
);
2683 module_name
= get_selection(mw_data
, (char **)(name
->pdata
), name
->len
,
2684 "Select a module", "Modules");
2685 if(module_name
!= NULL
) {
2687 if(strcmp(module_name
, module_info
[i
].name
) == 0) {
2688 strncpy(module_name_out
, module_name
, PATH_MAX
);
2689 //module = lttv_library_module_get(i);
2695 g_ptr_array_free(name
, TRUE
);
2696 g_free(module_info
);
2698 if(module_name
== NULL
) return;
2701 lttv_module_require(module_name_out
, &error
);
2702 if(error
!= NULL
) g_warning("%s", error
->message
);
2703 else g_info("Load module: %s", module_name_out
);
2710 gchar str
[PATH_MAX
];
2713 GtkFileSelection
* file_selector
=
2714 (GtkFileSelection
*)gtk_file_selection_new("Select a module");
2715 gtk_file_selection_set_filename(file_selector
, load_module_path_alter
);
2716 gtk_file_selection_hide_fileop_buttons(file_selector
);
2719 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
2721 case GTK_RESPONSE_ACCEPT
:
2722 case GTK_RESPONSE_OK
:
2723 dir
= gtk_file_selection_get_selections (file_selector
);
2724 strncpy(str
,dir
[0],PATH_MAX
);
2725 strncpy(remember_plugins_dir
,dir
[0],PATH_MAX
);
2727 /* only keep file name */
2729 str1
= strrchr(str
,'/');
2732 str1
= strrchr(str
,'\\');
2737 if(*str1
== 'l' && *(str1
+1)== 'i' && *(str1
+2)=='b')
2739 remove info after
. */
2743 str2
= strrchr(str2
, '.');
2744 if(str2
!= NULL
) *str2
= '\0';
2746 lttv_module_require(str1
, &error
);
2748 lttv_library_load(str1
, &error
);
2749 if(error
!= NULL
) g_warning(error
->message
);
2750 else g_info("Load library: %s\n", str
);
2752 case GTK_RESPONSE_REJECT
:
2753 case GTK_RESPONSE_CANCEL
:
2755 gtk_widget_destroy((GtkWidget
*)file_selector
);
2767 /* Display all loaded modules, let user to select a module to unload
2768 * by calling lttv_module_unload
2772 on_unload_module_activate (GtkMenuItem
*menuitem
,
2775 GError
*error
= NULL
;
2776 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2778 LttvLibrary
*library
;
2783 name
= g_ptr_array_new();
2784 nb
= lttv_library_number();
2785 LttvLibraryInfo
*lib_info
= g_new(LttvLibraryInfo
,nb
);
2786 /* ask for the library name */
2789 LttvLibrary
*iter_lib
= lttv_library_get(i
);
2790 lttv_library_info(iter_lib
, &lib_info
[i
]);
2792 gchar
*path
= lib_info
[i
].name
;
2793 g_ptr_array_add(name
, path
);
2795 lib_name
= get_selection(mw_data
, (char **)(name
->pdata
), name
->len
,
2796 "Select a library", "Libraries");
2797 if(lib_name
!= NULL
) {
2799 if(strcmp(lib_name
, lib_info
[i
].name
) == 0) {
2800 library
= lttv_library_get(i
);
2805 g_ptr_array_free(name
, TRUE
);
2808 if(lib_name
== NULL
) return;
2811 LttvModule
*module
= NULL
;
2813 /* Ask for the module to load : list modules in the selected lib */
2817 nb
= lttv_library_module_number(library
);
2818 LttvModuleInfo
*module_info
= g_new(LttvModuleInfo
,nb
);
2819 name
= g_ptr_array_new();
2820 /* ask for the module name */
2823 LttvModule
*iter_module
= lttv_library_module_get(library
, i
);
2824 lttv_module_info(iter_module
, &module_info
[i
]);
2826 gchar
*path
= module_info
[i
].name
;
2827 if(module_info
[i
].use_count
> 0) g_ptr_array_add(name
, path
);
2829 module_name
= get_selection(mw_data
, (char **)(name
->pdata
), name
->len
,
2830 "Select a module", "Modules");
2831 if(module_name
!= NULL
) {
2833 if(strcmp(module_name
, module_info
[i
].name
) == 0) {
2834 module
= lttv_library_module_get(library
, i
);
2840 g_ptr_array_free(name
, TRUE
);
2841 g_free(module_info
);
2843 if(module_name
== NULL
) return;
2846 LttvModuleInfo module_info
;
2847 lttv_module_info(module
, &module_info
);
2848 g_info("Release module: %s\n", module_info
.name
);
2850 lttv_module_release(module
);
2854 /* Display a directory dialogue to let user select a path for library searching
2858 on_add_library_search_path_activate (GtkMenuItem
*menuitem
,
2861 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2862 //GtkDirSelection * file_selector = (GtkDirSelection *)gtk_dir_selection_new("Select library path");
2863 GtkFileSelection
* file_selector
= (GtkFileSelection
*)gtk_file_selection_new("Select a trace");
2864 gtk_widget_hide( (file_selector
)->file_list
->parent
) ;
2866 gtk_window_set_transient_for(GTK_WINDOW(file_selector
),
2867 GTK_WINDOW(mw_data
->mwindow
));
2872 if(remember_plugins_dir
[0] != '\0')
2873 gtk_file_selection_set_filename(file_selector
, remember_plugins_dir
);
2875 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
2877 case GTK_RESPONSE_ACCEPT
:
2878 case GTK_RESPONSE_OK
:
2879 dir
= gtk_file_selection_get_filename (file_selector
);
2880 strncpy(remember_plugins_dir
,dir
,PATH_MAX
);
2881 strncat(remember_plugins_dir
,"/",PATH_MAX
);
2882 lttv_library_path_add(dir
);
2883 case GTK_RESPONSE_REJECT
:
2884 case GTK_RESPONSE_CANCEL
:
2886 gtk_widget_destroy((GtkWidget
*)file_selector
);
2892 /* Display a directory dialogue to let user select a path for library searching
2896 on_remove_library_search_path_activate (GtkMenuItem
*menuitem
,
2899 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2901 const char *lib_path
;
2906 name
= g_ptr_array_new();
2907 nb
= lttv_library_path_number();
2908 /* ask for the library name */
2911 gchar
*path
= lttv_library_path_get(i
);
2912 g_ptr_array_add(name
, path
);
2914 lib_path
= get_selection(mw_data
, (char **)(name
->pdata
), name
->len
,
2915 "Select a library path", "Library paths");
2917 g_ptr_array_free(name
, TRUE
);
2919 if(lib_path
== NULL
) return;
2922 lttv_library_path_remove(lib_path
);
2926 on_color_activate (GtkMenuItem
*menuitem
,
2934 on_save_configuration_activate (GtkMenuItem
*menuitem
,
2937 g_info("Save configuration\n");
2942 on_content_activate (GtkMenuItem
*menuitem
,
2945 g_info("Content\n");
2950 on_about_close_activate (GtkButton
*button
,
2953 GtkWidget
*about_widget
= GTK_WIDGET(user_data
);
2955 gtk_widget_destroy(about_widget
);
2959 on_about_activate (GtkMenuItem
*menuitem
,
2962 MainWindow
*main_window
= get_window_data_struct(GTK_WIDGET(menuitem
));
2963 GtkWidget
*window_widget
= main_window
->mwindow
;
2964 GtkWidget
*about_widget
= gtk_window_new(GTK_WINDOW_TOPLEVEL
);
2965 GtkWindow
*about_window
= GTK_WINDOW(about_widget
);
2966 gint window_width
, window_height
;
2968 gtk_window_set_title(about_window
, "About Linux Trace Toolkit");
2970 gtk_window_set_resizable(about_window
, FALSE
);
2971 gtk_window_set_transient_for(GTK_WINDOW(window_widget
), about_window
);
2972 gtk_window_set_destroy_with_parent(about_window
, TRUE
);
2973 gtk_window_set_modal(about_window
, FALSE
);
2975 /* Put the about window at the center of the screen */
2976 gtk_window_get_size(about_window
, &window_width
, &window_height
);
2977 gtk_window_move (about_window
,
2978 (gdk_screen_width() - window_width
)/2,
2979 (gdk_screen_height() - window_height
)/2);
2981 GtkWidget
*vbox
= gtk_vbox_new(FALSE
, 1);
2983 gtk_container_add(GTK_CONTAINER(about_widget
), vbox
);
2987 GtkWidget
*label1
= gtk_label_new("");
2988 gtk_misc_set_padding(GTK_MISC(label1
), 10, 20);
2989 gtk_label_set_markup(GTK_LABEL(label1
), "\
2990 <big>Linux Trace Toolkit</big>");
2991 gtk_label_set_justify(GTK_LABEL(label1
), GTK_JUSTIFY_CENTER
);
2993 GtkWidget
*label2
= gtk_label_new("");
2994 gtk_misc_set_padding(GTK_MISC(label2
), 10, 20);
2995 gtk_label_set_markup(GTK_LABEL(label2
), "\
2998 Michel Dagenais (New trace format, lttv main)\n\
2999 Mathieu Desnoyers (Kernel Tracer, Directory structure, build with automake/conf,\n\
3000 lttv gui, control flow view, gui cooperative trace reading\n\
3001 scheduler with interruptible foreground and background\n\
3002 computation, detailed event list (rewrite), trace reading\n\
3003 library (rewrite))\n\
3004 Benoit Des Ligneris, Eric Clement (Cluster adaptation, work in progress)\n\
3005 Xang-Xiu Yang (new trace reading library and converter, lttv gui, \n\
3006 detailed event list and statistics view)\n\
3007 Tom Zanussi (RelayFS)\n\
3009 Strongly inspired from the original Linux Trace Toolkit Visualizer made by\n\
3012 GtkWidget
*label3
= gtk_label_new("");
3013 gtk_label_set_markup(GTK_LABEL(label3
), "\
3014 Linux Trace Toolkit Viewer, Copyright (C) 2004\n\
3016 Mathieu Desnoyers\n\
3018 Linux Trace Toolkit comes with ABSOLUTELY NO WARRANTY.\n\
3019 This is free software, and you are welcome to redistribute it\n\
3020 under certain conditions. See COPYING for details.");
3021 gtk_misc_set_padding(GTK_MISC(label3
), 10, 20);
3023 gtk_box_pack_start_defaults(GTK_BOX(vbox
), label1
);
3024 gtk_box_pack_start_defaults(GTK_BOX(vbox
), label2
);
3025 gtk_box_pack_start_defaults(GTK_BOX(vbox
), label3
);
3027 GtkWidget
*hbox
= gtk_hbox_new(TRUE
, 0);
3028 gtk_box_pack_end(GTK_BOX(vbox
), hbox
, FALSE
, FALSE
, 0);
3029 GtkWidget
*close_button
= gtk_button_new_with_mnemonic("_Close");
3030 gtk_box_pack_end(GTK_BOX(hbox
), close_button
, FALSE
, FALSE
, 0);
3031 gtk_container_set_border_width(GTK_CONTAINER(close_button
), 20);
3033 g_signal_connect(G_OBJECT(close_button
), "clicked",
3034 G_CALLBACK(on_about_close_activate
),
3035 (gpointer
)about_widget
);
3037 gtk_widget_show_all(about_widget
);
3042 on_button_new_clicked (GtkButton
*button
,
3045 create_new_window((GtkWidget
*)button
, user_data
, TRUE
);
3049 on_button_new_tab_clicked (GtkButton
*button
,
3052 create_new_tab((GtkWidget
*)button
, user_data
);
3056 on_button_open_clicked (GtkButton
*button
,
3059 open_traceset((GtkWidget
*)button
, user_data
);
3064 on_button_add_trace_clicked (GtkButton
*button
,
3067 add_trace((GtkWidget
*)button
, user_data
);
3072 on_button_remove_trace_clicked (GtkButton
*button
,
3075 remove_trace((GtkWidget
*)button
, user_data
);
3079 on_button_redraw_clicked (GtkButton
*button
,
3082 redraw((GtkWidget
*)button
, user_data
);
3086 on_button_continue_processing_clicked (GtkButton
*button
,
3089 continue_processing((GtkWidget
*)button
, user_data
);
3093 on_button_stop_processing_clicked (GtkButton
*button
,
3096 stop_processing((GtkWidget
*)button
, user_data
);
3102 on_button_save_clicked (GtkButton
*button
,
3105 save((GtkWidget
*)button
, user_data
);
3110 on_button_save_as_clicked (GtkButton
*button
,
3113 save_as((GtkWidget
*)button
, user_data
);
3118 on_button_zoom_in_clicked (GtkButton
*button
,
3121 zoom_in((GtkWidget
*)button
, user_data
);
3126 on_button_zoom_out_clicked (GtkButton
*button
,
3129 zoom_out((GtkWidget
*)button
, user_data
);
3134 on_button_zoom_extended_clicked (GtkButton
*button
,
3137 zoom_extended((GtkWidget
*)button
, user_data
);
3142 on_button_go_to_time_clicked (GtkButton
*button
,
3145 go_to_time((GtkWidget
*)button
, user_data
);
3150 on_button_show_time_frame_clicked (GtkButton
*button
,
3153 show_time_frame((GtkWidget
*)button
, user_data
);
3158 on_button_move_up_clicked (GtkButton
*button
,
3161 move_up_viewer((GtkWidget
*)button
, user_data
);
3166 on_button_move_down_clicked (GtkButton
*button
,
3169 move_down_viewer((GtkWidget
*)button
, user_data
);
3174 on_button_delete_viewer_clicked (GtkButton
*button
,
3177 delete_viewer((GtkWidget
*)button
, user_data
);
3181 on_MWindow_destroy (GtkWidget
*widget
,
3184 MainWindow
*main_window
= get_window_data_struct(widget
);
3185 LttvIAttribute
*attributes
= main_window
->attributes
;
3186 LttvAttributeValue value
;
3188 //This is unnecessary, since widgets will be destroyed
3189 //by the main window widget anyway.
3190 //remove_all_menu_toolbar_constructors(main_window, NULL);
3192 g_assert(lttv_iattribute_find_by_path(attributes
,
3193 "viewers/menu", LTTV_POINTER
, &value
));
3194 lttv_menus_destroy((LttvMenus
*)*(value
.v_pointer
));
3196 g_assert(lttv_iattribute_find_by_path(attributes
,
3197 "viewers/toolbar", LTTV_POINTER
, &value
));
3198 lttv_toolbars_destroy((LttvToolbars
*)*(value
.v_pointer
));
3200 g_object_unref(main_window
->attributes
);
3201 g_main_window_list
= g_slist_remove(g_main_window_list
, main_window
);
3203 g_info("There are now : %d windows\n",g_slist_length(g_main_window_list
));
3204 if(g_slist_length(g_main_window_list
) == 0)
3209 on_MWindow_configure (GtkWidget
*widget
,
3210 GdkEventConfigure
*event
,
3213 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)widget
);
3215 // MD : removed time width modification upon resizing of the main window.
3216 // The viewers will redraw themselves completely, without time interval
3219 if(mw_data->window_width){
3220 time_span = LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->Time_Span ;
3221 time_win = tab->time_window;
3222 ratio = width / mw_data->window_width;
3223 tab->time_window.time_width = ltt_time_mul(time_win.time_width,ratio);
3224 time = ltt_time_sub(time_span->endTime, time_win.start_time);
3225 if(ltt_time_compare(time, tab->time_window.time_width) < 0){
3226 tab->time_window.time_width = time;
3232 mw_data->window_width = (int)width;
3241 on_MNotebook_switch_page (GtkNotebook
*notebook
,
3242 GtkNotebookPage
*page
,
3250 void time_change_manager (Tab
*tab
,
3251 TimeWindow new_time_window
)
3253 /* Only one source of time change */
3254 if(tab
->time_manager_lock
== TRUE
) return;
3256 tab
->time_manager_lock
= TRUE
;
3258 LttvTracesetContext
*tsc
= LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3259 TimeInterval time_span
= tsc
->time_span
;
3260 LttTime start_time
= new_time_window
.start_time
;
3261 LttTime end_time
= new_time_window
.end_time
;
3263 g_assert(ltt_time_compare(start_time
, end_time
) < 0);
3266 GtkAdjustment
*adjustment
= gtk_range_get_adjustment(GTK_RANGE(tab
->scrollbar
));
3267 LttTime upper
= ltt_time_sub(time_span
.end_time
, time_span
.start_time
);
3269 gtk_range_set_increments(GTK_RANGE(tab
->scrollbar
),
3270 ltt_time_to_double(new_time_window
.time_width
)
3271 / SCROLL_STEP_PER_PAGE
3272 * NANOSECONDS_PER_SECOND
, /* step increment */
3273 ltt_time_to_double(new_time_window
.time_width
)
3274 * NANOSECONDS_PER_SECOND
); /* page increment */
3275 gtk_range_set_range(GTK_RANGE(tab
->scrollbar
),
3277 ltt_time_to_double(upper
)
3278 * NANOSECONDS_PER_SECOND
); /* upper */
3280 g_object_set(G_OBJECT(adjustment
),
3284 ltt_time_to_double(upper
), /* upper */
3286 new_time_window
.time_width_double
3287 / SCROLL_STEP_PER_PAGE
, /* step increment */
3289 new_time_window
.time_width_double
,
3290 /* page increment */
3292 new_time_window
.time_width_double
, /* page size */
3294 gtk_adjustment_changed(adjustment
);
3296 // g_object_set(G_OBJECT(adjustment),
3298 // ltt_time_to_double(
3299 // ltt_time_sub(start_time, time_span.start_time))
3302 //gtk_adjustment_value_changed(adjustment);
3303 gtk_range_set_value(GTK_RANGE(tab
->scrollbar
),
3305 ltt_time_sub(start_time
, time_span
.start_time
)) /* value */);
3307 /* set the time bar. */
3309 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry1
),
3310 (double)time_span
.start_time
.tv_sec
,
3311 (double)time_span
.end_time
.tv_sec
);
3312 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry1
),
3313 (double)start_time
.tv_sec
);
3315 /* start nanoseconds */
3316 if(start_time
.tv_sec
== time_span
.start_time
.tv_sec
) {
3317 /* can be both beginning and end at the same time. */
3318 if(start_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3319 /* If we are at the end, max nsec to end.. -1 (not zero length) */
3320 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry2
),
3321 (double)time_span
.start_time
.tv_nsec
,
3322 (double)time_span
.end_time
.tv_nsec
-1);
3324 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry2
),
3325 (double)time_span
.start_time
.tv_nsec
,
3326 (double)NANOSECONDS_PER_SECOND
-1);
3328 } else if(start_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3329 /* If we are at the end, max nsec to end.. -1 (not zero length) */
3330 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry2
),
3332 (double)time_span
.end_time
.tv_nsec
-1);
3333 } else /* anywhere else */
3334 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry2
),
3336 (double)NANOSECONDS_PER_SECOND
-1);
3337 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry2
),
3338 (double)start_time
.tv_nsec
);
3341 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry3
),
3342 (double)time_span
.start_time
.tv_sec
,
3343 (double)time_span
.end_time
.tv_sec
);
3344 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry3
),
3345 (double)end_time
.tv_sec
);
3347 /* end nanoseconds */
3348 if(end_time
.tv_sec
== time_span
.start_time
.tv_sec
) {
3349 /* can be both beginning and end at the same time. */
3350 if(end_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3351 /* If we are at the end, max nsec to end.. */
3352 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry4
),
3353 (double)time_span
.start_time
.tv_nsec
+1,
3354 (double)time_span
.end_time
.tv_nsec
);
3356 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry4
),
3357 (double)time_span
.start_time
.tv_nsec
+1,
3358 (double)NANOSECONDS_PER_SECOND
-1);
3361 else if(end_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3362 /* If we are at the end, max nsec to end.. */
3363 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry4
),
3365 (double)time_span
.end_time
.tv_nsec
);
3367 else /* anywhere else */
3368 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry4
),
3370 (double)NANOSECONDS_PER_SECOND
-1);
3371 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry4
),
3372 (double)end_time
.tv_nsec
);
3374 /* call viewer hooks for new time window */
3375 set_time_window(tab
, &new_time_window
);
3377 tab
->time_manager_lock
= FALSE
;
3381 /* value changed for frame start s
3383 * Check time span : if ns is out of range, clip it the nearest good value.
3386 on_MEntry1_value_changed (GtkSpinButton
*spinbutton
,
3389 Tab
*tab
=(Tab
*)user_data
;
3390 LttvTracesetContext
* tsc
=
3391 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3392 TimeInterval time_span
= tsc
->time_span
;
3393 gint value
= gtk_spin_button_get_value_as_int(spinbutton
);
3395 TimeWindow new_time_window
= tab
->time_window
;
3397 LttTime end_time
= new_time_window
.end_time
;
3399 new_time_window
.start_time
.tv_sec
= value
;
3401 /* start nanoseconds */
3402 if(new_time_window
.start_time
.tv_sec
== time_span
.start_time
.tv_sec
) {
3403 if(new_time_window
.start_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3404 if(new_time_window
.start_time
.tv_nsec
> time_span
.end_time
.tv_nsec
)
3405 new_time_window
.start_time
.tv_nsec
= time_span
.end_time
.tv_nsec
-1;
3406 if(new_time_window
.start_time
.tv_nsec
< time_span
.start_time
.tv_nsec
)
3407 new_time_window
.start_time
.tv_nsec
= time_span
.start_time
.tv_nsec
;
3409 if(new_time_window
.start_time
.tv_nsec
< time_span
.start_time
.tv_nsec
)
3410 new_time_window
.start_time
.tv_nsec
= time_span
.start_time
.tv_nsec
;
3413 else if(new_time_window
.start_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3414 if(new_time_window
.start_time
.tv_nsec
> time_span
.end_time
.tv_nsec
)
3415 new_time_window
.start_time
.tv_nsec
= time_span
.end_time
.tv_nsec
-1;
3418 if(ltt_time_compare(new_time_window
.start_time
, end_time
) >= 0) {
3419 /* Then, we must push back end time : keep the same time width
3420 * if possible, else end traceset time */
3421 end_time
= LTT_TIME_MIN(ltt_time_add(new_time_window
.start_time
,
3422 new_time_window
.time_width
),
3423 time_span
.end_time
);
3426 /* Fix the time width to fit start time and end time */
3427 new_time_window
.time_width
= ltt_time_sub(end_time
,
3428 new_time_window
.start_time
);
3429 new_time_window
.time_width_double
=
3430 ltt_time_to_double(new_time_window
.time_width
);
3432 new_time_window
.end_time
= end_time
;
3434 time_change_manager(tab
, new_time_window
);
3439 on_MEntry2_value_changed (GtkSpinButton
*spinbutton
,
3442 Tab
*tab
=(Tab
*)user_data
;
3443 LttvTracesetContext
* tsc
=
3444 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3445 TimeInterval time_span
= tsc
->time_span
;
3446 gint value
= gtk_spin_button_get_value_as_int(spinbutton
);
3448 TimeWindow new_time_window
= tab
->time_window
;
3450 LttTime end_time
= new_time_window
.end_time
;
3452 new_time_window
.start_time
.tv_nsec
= value
;
3454 if(ltt_time_compare(new_time_window
.start_time
, end_time
) >= 0) {
3455 /* Then, we must push back end time : keep the same time width
3456 * if possible, else end traceset time */
3457 end_time
= LTT_TIME_MIN(ltt_time_add(new_time_window
.start_time
,
3458 new_time_window
.time_width
),
3459 time_span
.end_time
);
3462 /* Fix the time width to fit start time and end time */
3463 new_time_window
.time_width
= ltt_time_sub(end_time
,
3464 new_time_window
.start_time
);
3465 new_time_window
.time_width_double
=
3466 ltt_time_to_double(new_time_window
.time_width
);
3468 new_time_window
.end_time
= end_time
;
3470 time_change_manager(tab
, new_time_window
);
3475 on_MEntry3_value_changed (GtkSpinButton
*spinbutton
,
3478 Tab
*tab
=(Tab
*)user_data
;
3479 LttvTracesetContext
* tsc
=
3480 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3481 TimeInterval time_span
= tsc
->time_span
;
3482 gint value
= gtk_spin_button_get_value_as_int(spinbutton
);
3484 TimeWindow new_time_window
= tab
->time_window
;
3486 LttTime end_time
= new_time_window
.end_time
;
3488 end_time
.tv_sec
= value
;
3490 /* end nanoseconds */
3491 if(end_time
.tv_sec
== time_span
.start_time
.tv_sec
) {
3492 if(end_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3493 if(end_time
.tv_nsec
> time_span
.end_time
.tv_nsec
)
3494 end_time
.tv_nsec
= time_span
.end_time
.tv_nsec
;
3495 if(end_time
.tv_nsec
< time_span
.start_time
.tv_nsec
)
3496 end_time
.tv_nsec
= time_span
.start_time
.tv_nsec
+1;
3498 if(end_time
.tv_nsec
< time_span
.start_time
.tv_nsec
)
3499 end_time
.tv_nsec
= time_span
.start_time
.tv_nsec
+1;
3502 else if(end_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3503 if(end_time
.tv_nsec
> time_span
.end_time
.tv_nsec
)
3504 end_time
.tv_nsec
= time_span
.end_time
.tv_nsec
;
3507 if(ltt_time_compare(new_time_window
.start_time
, end_time
) >= 0) {
3508 /* Then, we must push front start time : keep the same time width
3509 * if possible, else end traceset time */
3510 new_time_window
.start_time
= LTT_TIME_MAX(
3511 ltt_time_sub(end_time
,
3512 new_time_window
.time_width
),
3513 time_span
.start_time
);
3516 /* Fix the time width to fit start time and end time */
3517 new_time_window
.time_width
= ltt_time_sub(end_time
,
3518 new_time_window
.start_time
);
3519 new_time_window
.time_width_double
=
3520 ltt_time_to_double(new_time_window
.time_width
);
3522 new_time_window
.end_time
= end_time
;
3524 time_change_manager(tab
, new_time_window
);
3529 on_MEntry4_value_changed (GtkSpinButton
*spinbutton
,
3532 Tab
*tab
=(Tab
*)user_data
;
3533 LttvTracesetContext
* tsc
=
3534 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3535 TimeInterval time_span
= tsc
->time_span
;
3536 gint value
= gtk_spin_button_get_value_as_int(spinbutton
);
3538 TimeWindow new_time_window
= tab
->time_window
;
3540 LttTime end_time
= new_time_window
.end_time
;
3542 end_time
.tv_nsec
= value
;
3544 if(ltt_time_compare(new_time_window
.start_time
, end_time
) >= 0) {
3545 /* Then, we must push front start time : keep the same time width
3546 * if possible, else end traceset time */
3547 new_time_window
.start_time
= LTT_TIME_MAX(
3548 ltt_time_sub(end_time
,
3549 new_time_window
.time_width
),
3550 time_span
.start_time
);
3553 /* Fix the time width to fit start time and end time */
3554 new_time_window
.time_width
= ltt_time_sub(end_time
,
3555 new_time_window
.start_time
);
3556 new_time_window
.time_width_double
=
3557 ltt_time_to_double(new_time_window
.time_width
);
3558 new_time_window
.end_time
= end_time
;
3560 time_change_manager(tab
, new_time_window
);
3565 void current_time_change_manager (Tab
*tab
,
3566 LttTime new_current_time
)
3568 /* Only one source of time change */
3569 if(tab
->current_time_manager_lock
== TRUE
) return;
3571 tab
->current_time_manager_lock
= TRUE
;
3573 LttvTracesetContext
*tsc
= LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3574 TimeInterval time_span
= tsc
->time_span
;
3576 /* current seconds */
3577 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry5
),
3578 (double)time_span
.start_time
.tv_sec
,
3579 (double)time_span
.end_time
.tv_sec
);
3580 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry5
),
3581 (double)new_current_time
.tv_sec
);
3584 /* start nanoseconds */
3585 if(new_current_time
.tv_sec
== time_span
.start_time
.tv_sec
) {
3586 /* can be both beginning and end at the same time. */
3587 if(new_current_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3588 /* If we are at the end, max nsec to end.. */
3589 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry6
),
3590 (double)time_span
.start_time
.tv_nsec
,
3591 (double)time_span
.end_time
.tv_nsec
);
3593 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry6
),
3594 (double)time_span
.start_time
.tv_nsec
,
3595 (double)NANOSECONDS_PER_SECOND
-1);
3597 } else if(new_current_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3598 /* If we are at the end, max nsec to end.. */
3599 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry6
),
3601 (double)time_span
.end_time
.tv_nsec
);
3602 } else /* anywhere else */
3603 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry6
),
3605 (double)NANOSECONDS_PER_SECOND
-1);
3607 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry6
),
3608 (double)new_current_time
.tv_nsec
);
3610 set_current_time(tab
, &new_current_time
);
3612 tab
->current_time_manager_lock
= FALSE
;
3615 void current_position_change_manager(Tab
*tab
,
3616 LttvTracesetContextPosition
*pos
)
3618 LttvTracesetContext
*tsc
=
3619 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3620 TimeInterval time_span
= tsc
->time_span
;
3622 g_assert(lttv_process_traceset_seek_position(tsc
, pos
) == 0);
3623 LttTime new_time
= lttv_traceset_context_position_get_time(pos
);
3624 /* Put the context in a state coherent position */
3625 lttv_state_traceset_seek_time_closest((LttvTracesetState
*)tsc
, ltt_time_zero
);
3627 current_time_change_manager(tab
, new_time
);
3629 set_current_position(tab
, pos
);
3634 on_MEntry5_value_changed (GtkSpinButton
*spinbutton
,
3637 Tab
*tab
= (Tab
*)user_data
;
3638 LttvTracesetContext
* tsc
=
3639 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3640 TimeInterval time_span
= tsc
->time_span
;
3641 gint value
= gtk_spin_button_get_value_as_int(spinbutton
);
3642 LttTime new_current_time
= tab
->current_time
;
3643 new_current_time
.tv_sec
= value
;
3645 /* current nanoseconds */
3646 if(new_current_time
.tv_sec
== time_span
.start_time
.tv_sec
) {
3647 if(new_current_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3648 if(new_current_time
.tv_nsec
> time_span
.end_time
.tv_nsec
)
3649 new_current_time
.tv_nsec
= time_span
.end_time
.tv_nsec
;
3650 if(new_current_time
.tv_nsec
< time_span
.start_time
.tv_nsec
)
3651 new_current_time
.tv_nsec
= time_span
.start_time
.tv_nsec
;
3653 if(new_current_time
.tv_nsec
< time_span
.start_time
.tv_nsec
)
3654 new_current_time
.tv_nsec
= time_span
.start_time
.tv_nsec
;
3657 else if(new_current_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3658 if(new_current_time
.tv_nsec
> time_span
.end_time
.tv_nsec
)
3659 new_current_time
.tv_nsec
= time_span
.end_time
.tv_nsec
;
3662 current_time_change_manager(tab
, new_current_time
);
3666 on_MEntry6_value_changed (GtkSpinButton
*spinbutton
,
3669 Tab
*tab
= (Tab
*)user_data
;
3670 gint value
= gtk_spin_button_get_value_as_int(spinbutton
);
3671 LttTime new_current_time
= tab
->current_time
;
3672 new_current_time
.tv_nsec
= value
;
3674 current_time_change_manager(tab
, new_current_time
);
3678 void scroll_value_changed_cb(GtkWidget
*scrollbar
,
3681 Tab
*tab
= (Tab
*)user_data
;
3682 TimeWindow new_time_window
;
3684 GtkAdjustment
*adjust
= gtk_range_get_adjustment(GTK_RANGE(scrollbar
));
3685 gdouble value
= gtk_adjustment_get_value(adjust
);
3686 // gdouble upper, lower, ratio, page_size;
3688 LttvTracesetContext
* tsc
=
3689 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3690 TimeInterval time_span
= tsc
->time_span
;
3692 time
= ltt_time_add(ltt_time_from_double(value
),
3693 time_span
.start_time
);
3695 new_time_window
.start_time
= time
;
3697 page_size
= adjust
->page_size
;
3699 new_time_window
.time_width
=
3700 ltt_time_from_double(page_size
);
3702 new_time_window
.time_width_double
=
3705 new_time_window
.end_time
= ltt_time_add(new_time_window
.start_time
,
3706 new_time_window
.time_width
);
3709 time_change_manager(tab
, new_time_window
);
3711 //time_window = tab->time_window;
3713 lower
= adjust
->lower
;
3714 upper
= adjust
->upper
;
3715 ratio
= (value
- lower
) / (upper
- lower
);
3716 g_info("lower %lu, upper %lu, value %lu, ratio %lu", lower
, upper
, value
, ratio
);
3718 //time = ltt_time_sub(time_span->end_time, time_span->start_time);
3719 //time = ltt_time_mul(time, (float)ratio);
3720 //time = ltt_time_add(time_span->start_time, time);
3721 time
= ltt_time_add(ltt_time_from_double(value
),
3722 time_span
.start_time
);
3724 time_window
.start_time
= time
;
3726 page_size
= adjust
->page_size
;
3728 time_window
.time_width
=
3729 ltt_time_from_double(page_size
);
3730 //time = ltt_time_sub(time_span.end_time, time);
3731 //if(ltt_time_compare(time,time_window.time_width) < 0){
3732 // time_window.time_width = time;
3735 /* call viewer hooks for new time window */
3736 set_time_window(tab
, &time_window
);
3741 /* Display a dialogue showing all eventtypes and traces, let user to select the interested
3742 * eventtypes, tracefiles and traces (filter)
3745 /* Select a trace which will be removed from traceset
3748 char * get_remove_trace(MainWindow
*mw_data
,
3749 char ** all_trace_name
, int nb_trace
)
3751 return get_selection(mw_data
, all_trace_name
, nb_trace
,
3752 "Select a trace", "Trace pathname");
3756 /* Select a module which will be loaded
3759 char * get_load_module(MainWindow
*mw_data
,
3760 char ** load_module_name
, int nb_module
)
3762 return get_selection(mw_data
, load_module_name
, nb_module
,
3763 "Select a module to load", "Module name");
3769 /* Select a module which will be unloaded
3772 char * get_unload_module(MainWindow
*mw_data
,
3773 char ** loaded_module_name
, int nb_module
)
3775 return get_selection(mw_data
, loaded_module_name
, nb_module
,
3776 "Select a module to unload", "Module name");
3780 /* Display a dialogue which shows all selectable items, let user to
3781 * select one of them
3784 char * get_selection(MainWindow
*mw_data
,
3785 char ** loaded_module_name
, int nb_module
,
3786 char *title
, char * column_title
)
3788 GtkWidget
* dialogue
;
3789 GtkWidget
* scroll_win
;
3791 GtkListStore
* store
;
3792 GtkTreeViewColumn
* column
;
3793 GtkCellRenderer
* renderer
;
3794 GtkTreeSelection
* select
;
3797 char * unload_module_name
= NULL
;
3799 dialogue
= gtk_dialog_new_with_buttons(title
,
3802 GTK_STOCK_OK
,GTK_RESPONSE_ACCEPT
,
3803 GTK_STOCK_CANCEL
,GTK_RESPONSE_REJECT
,
3805 gtk_window_set_default_size((GtkWindow
*)dialogue
, 500, 200);
3806 gtk_window_set_transient_for(GTK_WINDOW(dialogue
),
3807 GTK_WINDOW(mw_data
->mwindow
));
3809 scroll_win
= gtk_scrolled_window_new (NULL
, NULL
);
3810 gtk_widget_show ( scroll_win
);
3811 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win
),
3812 GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
3814 store
= gtk_list_store_new (N_COLUMNS
,G_TYPE_STRING
);
3815 tree
= gtk_tree_view_new_with_model(GTK_TREE_MODEL (store
));
3816 gtk_widget_show ( tree
);
3817 g_object_unref (G_OBJECT (store
));
3819 renderer
= gtk_cell_renderer_text_new ();
3820 column
= gtk_tree_view_column_new_with_attributes (column_title
,
3822 "text", MODULE_COLUMN
,
3824 gtk_tree_view_column_set_alignment (column
, 0.5);
3825 gtk_tree_view_column_set_fixed_width (column
, 150);
3826 gtk_tree_view_append_column (GTK_TREE_VIEW (tree
), column
);
3828 select
= gtk_tree_view_get_selection (GTK_TREE_VIEW (tree
));
3829 gtk_tree_selection_set_mode (select
, GTK_SELECTION_SINGLE
);
3831 gtk_container_add (GTK_CONTAINER (scroll_win
), tree
);
3833 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), scroll_win
,TRUE
, TRUE
,0);
3835 for(i
=0;i
<nb_module
;i
++){
3836 gtk_list_store_append (store
, &iter
);
3837 gtk_list_store_set (store
, &iter
, MODULE_COLUMN
,loaded_module_name
[i
],-1);
3840 id
= gtk_dialog_run(GTK_DIALOG(dialogue
));
3841 GtkTreeModel
**store_model
= (GtkTreeModel
**)&store
;
3843 case GTK_RESPONSE_ACCEPT
:
3844 case GTK_RESPONSE_OK
:
3845 if (gtk_tree_selection_get_selected (select
, store_model
, &iter
)){
3846 gtk_tree_model_get ((GtkTreeModel
*)store
, &iter
, MODULE_COLUMN
, &unload_module_name
, -1);
3848 case GTK_RESPONSE_REJECT
:
3849 case GTK_RESPONSE_CANCEL
:
3851 gtk_widget_destroy(dialogue
);
3855 return unload_module_name
;
3859 /* Insert all menu entry and tool buttons into this main window
3864 void add_all_menu_toolbar_constructors(MainWindow
* mw
, gpointer user_data
)
3868 lttvwindow_viewer_constructor constructor
;
3869 LttvMenus
* global_menu
, * instance_menu
;
3870 LttvToolbars
* global_toolbar
, * instance_toolbar
;
3871 LttvMenuClosure
*menu_item
;
3872 LttvToolbarClosure
*toolbar_item
;
3873 LttvAttributeValue value
;
3874 LttvIAttribute
*global_attributes
= LTTV_IATTRIBUTE(lttv_global_attributes());
3875 LttvIAttribute
*attributes
= mw
->attributes
;
3876 GtkWidget
* tool_menu_title_menu
, *new_widget
, *pixmap
;
3878 g_assert(lttv_iattribute_find_by_path(global_attributes
,
3879 "viewers/menu", LTTV_POINTER
, &value
));
3880 if(*(value
.v_pointer
) == NULL
)
3881 *(value
.v_pointer
) = lttv_menus_new();
3882 global_menu
= (LttvMenus
*)*(value
.v_pointer
);
3884 g_assert(lttv_iattribute_find_by_path(attributes
,
3885 "viewers/menu", LTTV_POINTER
, &value
));
3886 if(*(value
.v_pointer
) == NULL
)
3887 *(value
.v_pointer
) = lttv_menus_new();
3888 instance_menu
= (LttvMenus
*)*(value
.v_pointer
);
3892 g_assert(lttv_iattribute_find_by_path(global_attributes
,
3893 "viewers/toolbar", LTTV_POINTER
, &value
));
3894 if(*(value
.v_pointer
) == NULL
)
3895 *(value
.v_pointer
) = lttv_toolbars_new();
3896 global_toolbar
= (LttvToolbars
*)*(value
.v_pointer
);
3898 g_assert(lttv_iattribute_find_by_path(attributes
,
3899 "viewers/toolbar", LTTV_POINTER
, &value
));
3900 if(*(value
.v_pointer
) == NULL
)
3901 *(value
.v_pointer
) = lttv_toolbars_new();
3902 instance_toolbar
= (LttvToolbars
*)*(value
.v_pointer
);
3904 /* Add missing menu entries to window instance */
3905 for(i
=0;i
<global_menu
->len
;i
++) {
3906 menu_item
= &g_array_index(global_menu
, LttvMenuClosure
, i
);
3908 //add menu_item to window instance;
3909 constructor
= menu_item
->con
;
3910 tool_menu_title_menu
= lookup_widget(mw
->mwindow
,"ToolMenuTitle_menu");
3912 gtk_menu_item_new_with_mnemonic (menu_item
->menu_text
);
3913 gtk_container_add (GTK_CONTAINER (tool_menu_title_menu
),
3915 g_signal_connect ((gpointer
) new_widget
, "activate",
3916 G_CALLBACK (insert_viewer_wrap
),
3918 gtk_widget_show (new_widget
);
3919 lttv_menus_add(instance_menu
, menu_item
->con
,
3920 menu_item
->menu_path
,
3921 menu_item
->menu_text
,
3926 /* Add missing toolbar entries to window instance */
3927 for(i
=0;i
<global_toolbar
->len
;i
++) {
3928 toolbar_item
= &g_array_index(global_toolbar
, LttvToolbarClosure
, i
);
3930 //add toolbar_item to window instance;
3931 constructor
= toolbar_item
->con
;
3932 tool_menu_title_menu
= lookup_widget(mw
->mwindow
,"MToolbar1");
3933 pixbuf
= gdk_pixbuf_new_from_xpm_data((const char**)toolbar_item
->pixmap
);
3934 pixmap
= gtk_image_new_from_pixbuf(pixbuf
);
3936 gtk_toolbar_append_element (GTK_TOOLBAR (tool_menu_title_menu
),
3937 GTK_TOOLBAR_CHILD_BUTTON
,
3940 toolbar_item
->tooltip
, NULL
,
3941 pixmap
, NULL
, NULL
);
3942 gtk_label_set_use_underline(
3943 GTK_LABEL (((GtkToolbarChild
*) (
3944 g_list_last (GTK_TOOLBAR
3945 (tool_menu_title_menu
)->children
)->data
))->label
),
3947 gtk_container_set_border_width (GTK_CONTAINER (new_widget
), 1);
3948 g_signal_connect ((gpointer
) new_widget
,
3950 G_CALLBACK (insert_viewer_wrap
),
3952 gtk_widget_show (new_widget
);
3954 lttv_toolbars_add(instance_toolbar
, toolbar_item
->con
,
3955 toolbar_item
->tooltip
,
3956 toolbar_item
->pixmap
,
3964 /* Create a main window
3967 void construct_main_window(MainWindow
* parent
)
3969 g_debug("construct_main_window()");
3970 GtkWidget
* new_window
; /* New generated main window */
3971 MainWindow
* new_m_window
;/* New main window structure */
3972 GtkNotebook
* notebook
;
3973 LttvIAttribute
*attributes
=
3974 LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
));
3975 LttvAttributeValue value
;
3978 new_m_window
= g_new(MainWindow
, 1);
3980 // Add the object's information to the module's array
3981 g_main_window_list
= g_slist_append(g_main_window_list
, new_m_window
);
3983 new_window
= create_MWindow();
3984 gtk_widget_show (new_window
);
3986 new_m_window
->mwindow
= new_window
;
3987 new_m_window
->attributes
= attributes
;
3989 g_assert(lttv_iattribute_find_by_path(attributes
,
3990 "viewers/menu", LTTV_POINTER
, &value
));
3991 *(value
.v_pointer
) = lttv_menus_new();
3993 g_assert(lttv_iattribute_find_by_path(attributes
,
3994 "viewers/toolbar", LTTV_POINTER
, &value
));
3995 *(value
.v_pointer
) = lttv_toolbars_new();
3997 add_all_menu_toolbar_constructors(new_m_window
, NULL
);
3999 g_object_set_data_full(G_OBJECT(new_window
),
4001 (gpointer
)new_m_window
,
4002 (GDestroyNotify
)g_free
);
4003 //create a default tab
4004 notebook
= (GtkNotebook
*)lookup_widget(new_m_window
->mwindow
, "MNotebook");
4005 if(notebook
== NULL
){
4006 g_info("Notebook does not exist\n");
4009 //gtk_notebook_popup_enable (GTK_NOTEBOOK(notebook));
4010 //for now there is no name field in LttvTraceset structure
4011 //Use "Traceset" as the label for the default tab
4013 GtkWidget
* parent_notebook
= lookup_widget(parent
->mwindow
, "MNotebook");
4014 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(parent_notebook
),
4015 gtk_notebook_get_current_page(GTK_NOTEBOOK(parent_notebook
)));
4021 parent_tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
4023 new_tab
= create_tab(new_m_window
, parent_tab
, notebook
, "Traceset");
4025 new_tab
= create_tab(new_m_window
, NULL
, notebook
, "Traceset");
4026 /* First window, use command line trace */
4027 if(g_init_trace
!= NULL
){
4028 lttvwindow_add_trace(new_tab
,
4032 LttvTraceset
*traceset
= new_tab
->traceset_info
->traceset
;
4033 SetTraceset(new_tab
, traceset
);
4035 /* Insert default viewers */
4037 LttvAttributeType type
;
4038 LttvAttributeName name
;
4039 LttvAttributeValue value
;
4040 LttvAttribute
*attribute
;
4042 LttvIAttribute
*attributes_global
=
4043 LTTV_IATTRIBUTE(lttv_global_attributes());
4045 g_assert(attribute
=
4046 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
4047 LTTV_IATTRIBUTE(attributes_global
),
4048 LTTV_VIEWER_CONSTRUCTORS
)));
4050 name
= g_quark_from_string("guievents");
4051 type
= lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute
),
4053 if(type
== LTTV_POINTER
) {
4054 lttvwindow_viewer_constructor viewer_constructor
=
4055 (lttvwindow_viewer_constructor
)*value
.v_pointer
;
4056 insert_viewer(new_window
, viewer_constructor
);
4059 name
= g_quark_from_string("guicontrolflow");
4060 type
= lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute
),
4062 if(type
== LTTV_POINTER
) {
4063 lttvwindow_viewer_constructor viewer_constructor
=
4064 (lttvwindow_viewer_constructor
)*value
.v_pointer
;
4065 insert_viewer(new_window
, viewer_constructor
);
4068 name
= g_quark_from_string("guistatistics");
4069 type
= lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute
),
4071 if(type
== LTTV_POINTER
) {
4072 lttvwindow_viewer_constructor viewer_constructor
=
4073 (lttvwindow_viewer_constructor
)*value
.v_pointer
;
4074 insert_viewer(new_window
, viewer_constructor
);
4080 g_info("There are now : %d windows\n",g_slist_length(g_main_window_list
));
4084 /* Free the memory occupied by a tab structure
4088 void tab_destructor(Tab
* tab
)
4090 int i
, nb
, ref_count
;
4093 gtk_object_destroy(GTK_OBJECT(tab
->tooltips
));
4096 g_object_unref(tab
->attributes
);
4098 if(tab
->interrupted_state
)
4099 g_object_unref(tab
->interrupted_state
);
4102 if(tab
->traceset_info
->traceset_context
!= NULL
){
4103 //remove state update hooks
4104 lttv_state_remove_event_hooks(
4105 (LttvTracesetState
*)tab
->traceset_info
->
4107 lttv_context_fini(LTTV_TRACESET_CONTEXT(tab
->traceset_info
->
4109 g_object_unref(tab
->traceset_info
->traceset_context
);
4111 if(tab
->traceset_info
->traceset
!= NULL
) {
4112 nb
= lttv_traceset_number(tab
->traceset_info
->traceset
);
4113 for(i
= 0 ; i
< nb
; i
++) {
4114 trace
= lttv_traceset_get(tab
->traceset_info
->traceset
, i
);
4115 ref_count
= lttv_trace_get_ref_number(trace
);
4117 ltt_trace_close(lttv_trace(trace
));
4121 lttv_filter_destroy(tab
->filter
);
4122 lttv_traceset_destroy(tab
->traceset_info
->traceset
);
4123 /* Remove the idle events requests processing function of the tab */
4124 g_idle_remove_by_data(tab
);
4126 g_slist_free(tab
->events_requests
);
4127 g_free(tab
->traceset_info
);
4132 /* Create a tab and insert it into the current main window
4135 Tab
* create_tab(MainWindow
* mw
, Tab
*copy_tab
,
4136 GtkNotebook
* notebook
, char * label
)
4141 //create a new tab data structure
4144 //construct and initialize the traceset_info
4145 tab
->traceset_info
= g_new(TracesetInfo
,1);
4148 tab
->traceset_info
->traceset
=
4149 lttv_traceset_copy(copy_tab
->traceset_info
->traceset
);
4151 /* Copy the previous tab's filter */
4152 /* We can clone the filter, as we copy the trace set also */
4153 /* The filter must always be in sync with the trace set */
4154 tab
->filter
= lttv_filter_clone(copy_tab
->filter
);
4156 tab
->traceset_info
->traceset
= lttv_traceset_new();
4160 lttv_attribute_write_xml(
4161 lttv_traceset_attribute(tab
->traceset_info
->traceset
),
4167 tab
->time_manager_lock
= FALSE
;
4168 tab
->current_time_manager_lock
= FALSE
;
4170 //FIXME copy not implemented in lower level
4171 tab
->traceset_info
->traceset_context
=
4172 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
4173 g_assert(tab
->traceset_info
->traceset_context
!= NULL
);
4175 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
),
4176 tab
->traceset_info
->traceset
);
4177 //add state update hooks
4178 lttv_state_add_event_hooks(
4179 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
4181 //determine the current_time and time_window of the tab
4183 if(copy_tab
!= NULL
){
4184 tab
->time_window
= copy_tab
->time_window
;
4185 tab
->current_time
= copy_tab
->current_time
;
4187 tab
->time_window
.start_time
=
4188 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
4189 time_span
.start_time
;
4190 if(DEFAULT_TIME_WIDTH_S
<
4191 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
4192 time_span
.end_time
.tv_sec
)
4193 tmp_time
.tv_sec
= DEFAULT_TIME_WIDTH_S
;
4196 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
4197 time_span
.end_time
.tv_sec
;
4198 tmp_time
.tv_nsec
= 0;
4199 tab
->time_window
.time_width
= tmp_time
;
4200 tab
->current_time
.tv_sec
=
4201 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
4202 time_span
.start_time
.tv_sec
;
4203 tab
->current_time
.tv_nsec
=
4204 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
4205 time_span
.start_time
.tv_nsec
;
4208 tab
->attributes
= LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
));
4209 tab
->interrupted_state
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
4211 tab
->vbox
= gtk_vbox_new(FALSE
, 2);
4212 tab
->viewer_container
= gtk_vbox_new(TRUE
, 2);
4213 tab
->scrollbar
= gtk_hscrollbar_new(NULL
);
4214 //tab->multivpaned = gtk_multi_vpaned_new();
4216 gtk_box_pack_start(GTK_BOX(tab
->vbox
),
4217 tab
->viewer_container
,
4219 TRUE
, /* Give the extra space to the child */
4220 0); /* No padding */
4223 // tab->time_window = copy_tab->time_window;
4224 // tab->current_time = copy_tab->current_time;
4227 /* Create the timebar */
4229 tab
->MTimebar
= gtk_hbox_new(FALSE
, 2);
4230 gtk_widget_show(tab
->MTimebar
);
4231 tab
->tooltips
= gtk_tooltips_new();
4233 tab
->MEventBox1a
= gtk_event_box_new();
4234 gtk_widget_show(tab
->MEventBox1a
);
4235 gtk_tooltips_set_tip(tab
->tooltips
, tab
->MEventBox1a
,
4236 "Paste Start and End Times Here", "");
4237 tab
->MText1a
= gtk_label_new("Time Frame ");
4238 gtk_widget_show(tab
->MText1a
);
4239 gtk_container_add(GTK_CONTAINER(tab
->MEventBox1a
), tab
->MText1a
);
4240 tab
->MEventBox1b
= gtk_event_box_new();
4241 gtk_widget_show(tab
->MEventBox1b
);
4242 gtk_tooltips_set_tip(tab
->tooltips
, tab
->MEventBox1b
,
4243 "Paste Start Time Here", "");
4244 tab
->MText1b
= gtk_label_new("start: ");
4245 gtk_widget_show(tab
->MText1b
);
4246 gtk_container_add(GTK_CONTAINER(tab
->MEventBox1b
), tab
->MText1b
);
4247 tab
->MText2
= gtk_label_new("s");
4248 gtk_widget_show(tab
->MText2
);
4249 tab
->MText3a
= gtk_label_new("ns");
4250 gtk_widget_show(tab
->MText3a
);
4251 tab
->MEventBox3b
= gtk_event_box_new();
4252 gtk_widget_show(tab
->MEventBox3b
);
4253 gtk_tooltips_set_tip(tab
->tooltips
, tab
->MEventBox3b
,
4254 "Paste End Time Here", "");
4255 tab
->MText3b
= gtk_label_new("end:");
4256 gtk_widget_show(tab
->MText3b
);
4257 gtk_container_add(GTK_CONTAINER(tab
->MEventBox3b
), tab
->MText3b
);
4258 tab
->MText4
= gtk_label_new("s");
4259 gtk_widget_show(tab
->MText4
);
4260 tab
->MText5a
= gtk_label_new("ns");
4261 gtk_widget_show(tab
->MText5a
);
4262 tab
->MEventBox5b
= gtk_event_box_new();
4263 gtk_widget_show(tab
->MEventBox5b
);
4264 gtk_tooltips_set_tip(tab
->tooltips
, tab
->MEventBox5b
,
4265 "Paste Current Time Here", "");
4266 tab
->MText5b
= gtk_label_new("Current Time:");
4267 gtk_widget_show(tab
->MText5b
);
4268 gtk_container_add(GTK_CONTAINER(tab
->MEventBox5b
), tab
->MText5b
);
4269 tab
->MText6
= gtk_label_new("s");
4270 gtk_widget_show(tab
->MText6
);
4271 tab
->MText7
= gtk_label_new("ns");
4272 gtk_widget_show(tab
->MText7
);
4274 tab
->MEntry1
= gtk_spin_button_new_with_range(0.0, 1.0, 1.0);
4275 gtk_spin_button_set_digits(GTK_SPIN_BUTTON(tab
->MEntry1
),0);
4276 gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(tab
->MEntry1
),TRUE
);
4277 gtk_widget_show(tab
->MEntry1
);
4278 tab
->MEntry2
= gtk_spin_button_new_with_range(0.0, 1.0, 1.0);
4279 gtk_spin_button_set_digits(GTK_SPIN_BUTTON(tab
->MEntry2
),0);
4280 gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(tab
->MEntry2
),TRUE
);
4281 gtk_widget_show(tab
->MEntry2
);
4282 tab
->MEntry3
= gtk_spin_button_new_with_range(0.0, 1.0, 1.0);
4283 gtk_spin_button_set_digits(GTK_SPIN_BUTTON(tab
->MEntry3
),0);
4284 gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(tab
->MEntry3
),TRUE
);
4285 gtk_widget_show(tab
->MEntry3
);
4286 tab
->MEntry4
= gtk_spin_button_new_with_range(0.0, 1.0, 1.0);
4287 gtk_spin_button_set_digits(GTK_SPIN_BUTTON(tab
->MEntry4
),0);
4288 gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(tab
->MEntry4
),TRUE
);
4289 gtk_widget_show(tab
->MEntry4
);
4290 tab
->MEntry5
= gtk_spin_button_new_with_range(0.0, 1.0, 1.0);
4291 gtk_spin_button_set_digits(GTK_SPIN_BUTTON(tab
->MEntry5
),0);
4292 gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(tab
->MEntry5
),TRUE
);
4293 gtk_widget_show(tab
->MEntry5
);
4294 tab
->MEntry6
= gtk_spin_button_new_with_range(0.0, 1.0, 1.0);
4295 gtk_spin_button_set_digits(GTK_SPIN_BUTTON(tab
->MEntry6
),0);
4296 gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(tab
->MEntry6
),TRUE
);
4297 gtk_widget_show(tab
->MEntry6
);
4300 GtkWidget
*temp_widget
;
4302 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MEventBox1a
, FALSE
,
4304 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MEventBox1b
, FALSE
,
4306 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MEntry1
, FALSE
, FALSE
, 0);
4307 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MText2
, FALSE
, FALSE
, 0);
4308 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MEntry2
, FALSE
, FALSE
, 0);
4309 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MText3a
, FALSE
, FALSE
, 0);
4310 temp_widget
= gtk_vseparator_new();
4311 gtk_widget_show(temp_widget
);
4312 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), temp_widget
, FALSE
, FALSE
, 0);
4313 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MEventBox3b
, FALSE
,
4315 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MEntry3
, FALSE
, FALSE
, 0);
4316 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MText4
, FALSE
, FALSE
, 0);
4317 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MEntry4
, FALSE
, FALSE
, 0);
4318 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MText5a
, FALSE
, FALSE
, 0);
4319 temp_widget
= gtk_vseparator_new();
4320 gtk_widget_show(temp_widget
);
4321 gtk_box_pack_end (GTK_BOX (tab
->MTimebar
), tab
->MText7
, FALSE
, FALSE
, 0);
4322 gtk_box_pack_end (GTK_BOX (tab
->MTimebar
), tab
->MEntry6
, FALSE
, FALSE
, 0);
4323 gtk_box_pack_end (GTK_BOX (tab
->MTimebar
), tab
->MText6
, FALSE
, FALSE
, 0);
4324 gtk_box_pack_end (GTK_BOX (tab
->MTimebar
), tab
->MEntry5
, FALSE
, FALSE
, 0);
4325 gtk_box_pack_end (GTK_BOX (tab
->MTimebar
), tab
->MEventBox5b
, FALSE
,
4327 gtk_box_pack_end (GTK_BOX (tab
->MTimebar
), temp_widget
, FALSE
, FALSE
, 0);
4330 //GtkWidget *test = gtk_button_new_with_label("drop");
4331 //gtk_button_set_relief(GTK_BUTTON(test), GTK_RELIEF_NONE);
4332 //gtk_widget_show(test);
4333 //gtk_box_pack_end(GTK_BOX (tab->MTimebar), test, FALSE, FALSE, 0);
4334 //gtk_widget_add_events(tab->MText1, GDK_ALL_EVENTS_MASK);//GDK_BUTTON_PRESS_MASK);
4335 /*GtkWidget *event_box = gtk_event_box_new();
4336 gtk_widget_show(event_box);
4337 gtk_tooltips_set_tip(tooltips, event_box,
4338 "Paste Current Time Here", "");
4339 gtk_box_pack_end(GTK_BOX (tab->MTimebar), event_box, FALSE, FALSE, 0);
4340 GtkWidget *test = gtk_label_new("drop");
4341 gtk_container_add(GTK_CONTAINER(event_box), test);
4342 gtk_widget_show(test);
4343 g_signal_connect (G_OBJECT(event_box),
4344 "button-press-event",
4345 G_CALLBACK (on_MText1_paste),
4349 g_signal_connect (G_OBJECT(tab
->MEventBox1a
),
4350 "button-press-event",
4351 G_CALLBACK (on_MEventBox1a_paste
),
4354 g_signal_connect (G_OBJECT(tab
->MEventBox1b
),
4355 "button-press-event",
4356 G_CALLBACK (on_MEventBox1b_paste
),
4358 g_signal_connect (G_OBJECT(tab
->MEventBox3b
),
4359 "button-press-event",
4360 G_CALLBACK (on_MEventBox3b_paste
),
4362 g_signal_connect (G_OBJECT(tab
->MEventBox5b
),
4363 "button-press-event",
4364 G_CALLBACK (on_MEventBox5b_paste
),
4368 gtk_box_pack_end(GTK_BOX(tab
->vbox
),
4370 FALSE
, /* Do not expand */
4371 FALSE
, /* Fill has no effect here (expand false) */
4372 0); /* No padding */
4374 gtk_box_pack_end(GTK_BOX(tab
->vbox
),
4376 FALSE
, /* Do not expand */
4377 FALSE
, /* Fill has no effect here (expand false) */
4378 0); /* No padding */
4380 g_object_set_data(G_OBJECT(tab
->viewer_container
), "focused_viewer", NULL
);
4386 // Display a label with a X
4387 GtkWidget *w_hbox = gtk_hbox_new(FALSE, 4);
4388 GtkWidget *w_label = gtk_label_new (label);
4389 GtkWidget *pixmap = create_pixmap(GTK_WIDGET(notebook), "close.png");
4390 GtkWidget *w_button = gtk_button_new ();
4391 gtk_container_add(GTK_CONTAINER(w_button), pixmap);
4392 //GtkWidget *w_button = gtk_button_new_with_label("x");
4394 gtk_button_set_relief(GTK_BUTTON(w_button), GTK_RELIEF_NONE);
4396 gtk_box_pack_start(GTK_BOX(w_hbox), w_label, TRUE, TRUE, 0);
4397 gtk_box_pack_end(GTK_BOX(w_hbox), w_button, FALSE,
4400 g_signal_connect_swapped (w_button, "clicked",
4401 G_CALLBACK (on_close_tab_X_clicked),
4404 gtk_widget_set_state(w_button, GTK_STATE_ACTIVE);
4406 gtk_widget_show (w_label);
4407 gtk_widget_show (pixmap);
4408 gtk_widget_show (w_button);
4409 gtk_widget_show (w_hbox);
4411 tab->label = w_hbox;
4415 tab
->label
= gtk_label_new (label
);
4417 gtk_widget_show(tab
->label
);
4418 gtk_widget_show(tab
->scrollbar
);
4419 gtk_widget_show(tab
->viewer_container
);
4420 gtk_widget_show(tab
->vbox
);
4421 //gtk_widget_show(tab->multivpaned);
4424 /* Start with empty events requests list */
4425 tab
->events_requests
= NULL
;
4426 tab
->events_request_pending
= FALSE
;
4428 g_object_set_data_full(
4429 G_OBJECT(tab
->vbox
),
4432 (GDestroyNotify
)tab_destructor
);
4434 g_signal_connect(G_OBJECT(tab
->scrollbar
), "value-changed",
4435 G_CALLBACK(scroll_value_changed_cb
), tab
);
4437 g_signal_connect ((gpointer
) tab
->MEntry1
, "value-changed",
4438 G_CALLBACK (on_MEntry1_value_changed
),
4440 g_signal_connect ((gpointer
) tab
->MEntry2
, "value-changed",
4441 G_CALLBACK (on_MEntry2_value_changed
),
4443 g_signal_connect ((gpointer
) tab
->MEntry3
, "value-changed",
4444 G_CALLBACK (on_MEntry3_value_changed
),
4446 g_signal_connect ((gpointer
) tab
->MEntry4
, "value-changed",
4447 G_CALLBACK (on_MEntry4_value_changed
),
4449 g_signal_connect ((gpointer
) tab
->MEntry5
, "value-changed",
4450 G_CALLBACK (on_MEntry5_value_changed
),
4452 g_signal_connect ((gpointer
) tab
->MEntry6
, "value-changed",
4453 G_CALLBACK (on_MEntry6_value_changed
),
4456 //g_signal_connect(G_OBJECT(tab->scrollbar), "changed",
4457 // G_CALLBACK(scroll_value_changed_cb), tab);
4460 //insert tab into notebook
4461 gtk_notebook_append_page(notebook
,
4464 list
= gtk_container_get_children(GTK_CONTAINER(notebook
));
4465 gtk_notebook_set_current_page(notebook
,g_list_length(list
)-1);
4466 // always show : not if(g_list_length(list)>1)
4467 gtk_notebook_set_show_tabs(notebook
, TRUE
);
4470 lttvwindow_report_time_window(tab
, copy_tab
->time_window
);
4471 lttvwindow_report_current_time(tab
, copy_tab
->current_time
);
4473 TimeWindow time_window
;
4475 time_window
.start_time
= ltt_time_zero
;
4476 time_window
.end_time
= ltt_time_add(time_window
.start_time
,
4477 lttvwindow_default_time_width
);
4478 time_window
.time_width
= lttvwindow_default_time_width
;
4479 time_window
.time_width_double
= ltt_time_to_double(time_window
.time_width
);
4481 lttvwindow_report_time_window(tab
, time_window
);
4482 lttvwindow_report_current_time(tab
, ltt_time_zero
);
4485 LttvTraceset
*traceset
= tab
->traceset_info
->traceset
;
4486 SetTraceset(tab
, traceset
);
4492 * execute_events_requests
4494 * Idle function that executes the pending requests for a tab.
4496 * @return return value : TRUE : keep the idle function, FALSE : remove it.
4498 gboolean
execute_events_requests(Tab
*tab
)
4500 return ( lttvwindow_process_pending_requests(tab
) );