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>
49 #include <lttvwindow/gtkdirsel.h>
52 static LttTime lttvwindow_default_time_width
= { 1, 0 };
53 #define CLIP_BUF 256 // size of clipboard buffer
55 extern LttvTrace
*g_init_trace
;
58 /** Array containing instanced objects. */
59 extern GSList
* g_main_window_list
;
61 /** MD : keep old directory. */
62 static char remember_plugins_dir
[PATH_MAX
] = "";
63 static char remember_trace_dir
[PATH_MAX
] = "";
66 MainWindow
* get_window_data_struct(GtkWidget
* widget
);
67 char * get_load_module(char ** load_module_name
, int nb_module
);
68 char * get_unload_module(char ** loaded_module_name
, int nb_module
);
69 char * get_remove_trace(char ** all_trace_name
, int nb_trace
);
70 char * get_selection(char ** all_name
, int nb
, char *title
, char * column_title
);
71 Tab
* create_tab(MainWindow
* mw
, Tab
*copy_tab
,
72 GtkNotebook
* notebook
, char * label
);
74 static void insert_viewer(GtkWidget
* widget
, lttvwindow_viewer_constructor constructor
);
76 Tab
*create_new_tab(GtkWidget
* widget
, gpointer user_data
);
78 static gboolean
lttvwindow_process_pending_requests(Tab
*tab
);
92 /* Pasting routines */
94 static void MEventBox1a_receive(GtkClipboard
*clipboard
,
98 if(text
== NULL
) return;
99 Tab
*tab
= (Tab
*)data
;
100 gchar buffer
[CLIP_BUF
];
101 gchar
*ptr
= buffer
, *ptr_ssec
, *ptr_snsec
, *ptr_esec
, *ptr_ensec
;
103 strncpy(buffer
, text
, CLIP_BUF
);
106 while(!isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
107 /* remove leading junk */
109 while(isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
110 /* read all the first number */
114 while(!isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
115 /* remove leading junk */
117 while(isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
118 /* read all the first number */
122 while(!isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
123 /* remove leading junk */
125 while(isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
126 /* read all the first number */
130 while(!isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
131 /* remove leading junk */
133 while(isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
134 /* read all the first number */
137 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry1
),
138 (double)strtoul(ptr_ssec
, NULL
, 10));
139 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry2
),
140 (double)strtoul(ptr_snsec
, NULL
, 10));
141 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry3
),
142 (double)strtoul(ptr_esec
, NULL
, 10));
143 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry4
),
144 (double)strtoul(ptr_ensec
, NULL
, 10));
147 static gboolean
on_MEventBox1a_paste(GtkWidget
*widget
, GdkEventButton
*event
,
150 Tab
*tab
= (Tab
*)data
;
152 GtkClipboard
*clip
= gtk_clipboard_get_for_display(gdk_display_get_default(),
153 GDK_SELECTION_PRIMARY
);
154 gtk_clipboard_request_text(clip
,
155 (GtkClipboardTextReceivedFunc
)MEventBox1a_receive
,
162 static void MEventBox1b_receive(GtkClipboard
*clipboard
,
166 if(text
== NULL
) return;
167 Tab
*tab
= (Tab
*)data
;
168 gchar buffer
[CLIP_BUF
];
169 gchar
*ptr
= buffer
, *ptr_sec
, *ptr_nsec
;
171 strncpy(buffer
, text
, CLIP_BUF
);
173 while(!isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
174 /* remove leading junk */
176 while(isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
177 /* read all the first number */
181 while(!isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
182 /* remove leading junk */
184 while(isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
185 /* read all the first number */
188 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry1
),
189 (double)strtoul(ptr_sec
, NULL
, 10));
190 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry2
),
191 (double)strtoul(ptr_nsec
, NULL
, 10));
195 static gboolean
on_MEventBox1b_paste(GtkWidget
*widget
, GdkEventButton
*event
,
198 Tab
*tab
= (Tab
*)data
;
200 GtkClipboard
*clip
= gtk_clipboard_get_for_display(gdk_display_get_default(),
201 GDK_SELECTION_PRIMARY
);
202 gtk_clipboard_request_text(clip
,
203 (GtkClipboardTextReceivedFunc
)MEventBox1b_receive
,
209 static void MEventBox3b_receive(GtkClipboard
*clipboard
,
213 if(text
== NULL
) return;
214 Tab
*tab
= (Tab
*)data
;
215 gchar buffer
[CLIP_BUF
];
216 gchar
*ptr
= buffer
, *ptr_sec
, *ptr_nsec
;
218 strncpy(buffer
, text
, CLIP_BUF
);
220 while(!isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
221 /* remove leading junk */
223 while(isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
224 /* read all the first number */
228 while(!isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
229 /* remove leading junk */
231 while(isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
232 /* read all the first number */
235 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry3
),
236 (double)strtoul(ptr_sec
, NULL
, 10));
237 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry4
),
238 (double)strtoul(ptr_nsec
, NULL
, 10));
242 static gboolean
on_MEventBox3b_paste(GtkWidget
*widget
, GdkEventButton
*event
,
245 Tab
*tab
= (Tab
*)data
;
247 GtkClipboard
*clip
= gtk_clipboard_get_for_display(gdk_display_get_default(),
248 GDK_SELECTION_PRIMARY
);
249 gtk_clipboard_request_text(clip
,
250 (GtkClipboardTextReceivedFunc
)MEventBox3b_receive
,
256 static void MEventBox5b_receive(GtkClipboard
*clipboard
,
260 if(text
== NULL
) return;
261 Tab
*tab
= (Tab
*)data
;
262 gchar buffer
[CLIP_BUF
];
263 gchar
*ptr
= buffer
, *ptr_sec
, *ptr_nsec
;
265 strncpy(buffer
, text
, CLIP_BUF
);
267 while(!isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
268 /* remove leading junk */
270 while(isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
271 /* read all the first number */
275 while(!isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
276 /* remove leading junk */
278 while(isdigit(*ptr
) && ptr
< buffer
+CLIP_BUF
-1) ptr
++;
279 /* read all the first number */
282 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry5
),
283 (double)strtoul(ptr_sec
, NULL
, 10));
284 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry6
),
285 (double)strtoul(ptr_nsec
, NULL
, 10));
289 static gboolean
on_MEventBox5b_paste(GtkWidget
*widget
, GdkEventButton
*event
,
292 Tab
*tab
= (Tab
*)data
;
294 GtkClipboard
*clip
= gtk_clipboard_get_for_display(gdk_display_get_default(),
295 GDK_SELECTION_PRIMARY
);
296 gtk_clipboard_request_text(clip
,
297 (GtkClipboardTextReceivedFunc
)MEventBox5b_receive
,
303 static gboolean
viewer_grab_focus(GtkWidget
*widget
, GdkEventButton
*event
,
306 GtkWidget
*viewer
= GTK_WIDGET(data
);
307 GtkWidget
*viewer_container
= gtk_widget_get_parent(viewer
);
309 g_debug("FOCUS GRABBED");
310 g_object_set_data(G_OBJECT(viewer_container
), "focused_viewer", viewer
);
315 static void connect_focus_recursive(GtkWidget
*widget
,
318 if(GTK_IS_CONTAINER(widget
)) {
319 gtk_container_forall(GTK_CONTAINER(widget
),
320 (GtkCallback
)connect_focus_recursive
,
324 if(GTK_IS_TREE_VIEW(widget
)) {
325 gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(widget
), TRUE
);
327 gtk_widget_add_events(widget
, GDK_BUTTON_PRESS_MASK
);
328 g_signal_connect (G_OBJECT(widget
),
329 "button-press-event",
330 G_CALLBACK (viewer_grab_focus
),
334 /* Stop all the processings and call gtk_main_quit() */
335 static void mainwindow_quit()
337 lttvwindowtraces_unregister_requests(g_quark_from_string("stats"));
338 lttvwindowtraces_unregister_requests(g_quark_from_string("state"));
339 lttvwindowtraces_unregister_computation_hooks(g_quark_from_string("stats"));
340 lttvwindowtraces_unregister_computation_hooks(g_quark_from_string("state"));
346 /* insert_viewer function constructs an instance of a viewer first,
347 * then inserts the widget of the instance into the container of the
352 insert_viewer_wrap(GtkWidget
*menuitem
, gpointer user_data
)
354 insert_viewer((GtkWidget
*)menuitem
, (lttvwindow_viewer_constructor
)user_data
);
358 /* internal functions */
359 void insert_viewer(GtkWidget
* widget
, lttvwindow_viewer_constructor constructor
)
361 GtkWidget
* viewer_container
;
362 MainWindow
* mw_data
= get_window_data_struct(widget
);
363 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
365 TimeInterval
* time_interval
;
366 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
367 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
371 tab
= create_new_tab(widget
, NULL
);
373 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
376 viewer_container
= tab
->viewer_container
;
378 viewer
= (GtkWidget
*)constructor(tab
);
381 //gtk_multivpaned_widget_add(GTK_MULTIVPANED(multivpaned), viewer);
383 gtk_box_pack_end(GTK_BOX(viewer_container
),
389 /* We want to connect the viewer_grab_focus to EVERY
390 * child of this widget. The little trick is to get each child
391 * of each GTK_CONTAINER, even subchildren.
393 connect_focus_recursive(viewer
, viewer
);
398 * Function to set/update traceset for the viewers
399 * @param tab viewer's tab
400 * @param traceset traceset of the main window.
402 * 0 : traceset updated
403 * 1 : no traceset hooks to update; not an error.
406 int SetTraceset(Tab
* tab
, LttvTraceset
*traceset
)
408 LttvTracesetContext
*tsc
=
409 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
410 TimeInterval time_span
= tsc
->time_span
;
411 TimeWindow new_time_window
= tab
->time_window
;
412 LttTime new_current_time
= tab
->current_time
;
414 /* Set the tab's time window and current time if
416 if(ltt_time_compare(tab
->time_window
.start_time
, time_span
.start_time
) < 0
417 || ltt_time_compare(tab
->time_window
.end_time
,
418 time_span
.end_time
) > 0) {
419 new_time_window
.start_time
= time_span
.start_time
;
421 new_current_time
= time_span
.start_time
;
425 if(ltt_time_compare(lttvwindow_default_time_width
,
426 ltt_time_sub(time_span
.end_time
, time_span
.start_time
)) < 0
428 ltt_time_compare(time_span
.end_time
, time_span
.start_time
) == 0)
429 tmp_time
= lttvwindow_default_time_width
;
431 tmp_time
= time_span
.end_time
;
433 new_time_window
.time_width
= tmp_time
;
434 new_time_window
.time_width_double
= ltt_time_to_double(tmp_time
);
435 new_time_window
.end_time
= ltt_time_add(new_time_window
.start_time
,
436 new_time_window
.time_width
) ;
443 GtkAdjustment
*adjustment
= gtk_range_get_adjustment(GTK_RANGE(tab
->scrollbar
));
444 LttTime upper
= ltt_time_sub(time_span
.end_time
, time_span
.start_time
);
446 g_object_set(G_OBJECT(adjustment
),
450 ltt_time_to_double(upper
)
451 * NANOSECONDS_PER_SECOND
, /* upper */
453 ltt_time_to_double(tab
->time_window
.time_width
)
454 / SCROLL_STEP_PER_PAGE
455 * NANOSECONDS_PER_SECOND
, /* step increment */
457 ltt_time_to_double(tab
->time_window
.time_width
)
458 * NANOSECONDS_PER_SECOND
, /* page increment */
460 ltt_time_to_double(tab
->time_window
.time_width
)
461 * NANOSECONDS_PER_SECOND
, /* page size */
463 gtk_adjustment_changed(adjustment
);
465 g_object_set(G_OBJECT(adjustment
),
468 ltt_time_sub(tab
->time_window
.start_time
, time_span
.start_time
))
469 * NANOSECONDS_PER_SECOND
, /* value */
471 gtk_adjustment_value_changed(adjustment
);
473 /* set the time bar. The value callbacks will change their nsec themself */
475 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry1
),
476 (double)time_span
.start_time
.tv_sec
,
477 (double)time_span
.end_time
.tv_sec
);
480 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry3
),
481 (double)time_span
.start_time
.tv_sec
,
482 (double)time_span
.end_time
.tv_sec
);
484 /* current seconds */
485 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry5
),
486 (double)time_span
.start_time
.tv_sec
,
487 (double)time_span
.end_time
.tv_sec
);
490 /* Finally, call the update hooks of the viewers */
492 LttvAttributeValue value
;
496 g_assert( lttv_iattribute_find_by_path(tab
->attributes
,
497 "hooks/updatetraceset", LTTV_POINTER
, &value
));
499 tmp
= (LttvHooks
*)*(value
.v_pointer
);
500 if(tmp
== NULL
) retval
= 1;
501 else lttv_hooks_call(tmp
,traceset
);
503 time_change_manager(tab
, new_time_window
);
504 current_time_change_manager(tab
, new_current_time
);
510 * Function to set/update filter for the viewers
511 * @param tab viewer's tab
512 * @param filter filter of the main window.
515 * 0 : filters updated
516 * 1 : no filter hooks to update; not an error.
519 int SetFilter(Tab
* tab
, gpointer filter
)
522 LttvAttributeValue value
;
524 g_assert(lttv_iattribute_find_by_path(tab
->attributes
,
525 "hooks/updatefilter", LTTV_POINTER
, &value
));
527 tmp
= (LttvHooks
*)*(value
.v_pointer
);
529 if(tmp
== NULL
) return 1;
530 lttv_hooks_call(tmp
,filter
);
538 * Function to redraw each viewer belonging to the current tab
539 * @param tab viewer's tab
542 void update_traceset(Tab
*tab
)
544 LttvAttributeValue value
;
546 g_assert(lttv_iattribute_find_by_path(tab
->attributes
,
547 "hooks/updatetraceset", LTTV_POINTER
, &value
));
548 tmp
= (LttvHooks
*)*(value
.v_pointer
);
549 if(tmp
== NULL
) return;
550 lttv_hooks_call(tmp
, NULL
);
554 /* get_label function is used to get user input, it displays an input
555 * box, which allows user to input a string
558 void get_label_string (GtkWidget
* text
, gchar
* label
)
560 GtkEntry
* entry
= (GtkEntry
*)text
;
561 if(strlen(gtk_entry_get_text(entry
))!=0)
562 strcpy(label
,gtk_entry_get_text(entry
));
565 gboolean
get_label(MainWindow
* mw
, gchar
* str
, gchar
* dialogue_title
, gchar
* label_str
)
567 GtkWidget
* dialogue
;
572 dialogue
= gtk_dialog_new_with_buttons(dialogue_title
,NULL
,
574 GTK_STOCK_OK
,GTK_RESPONSE_ACCEPT
,
575 GTK_STOCK_CANCEL
,GTK_RESPONSE_REJECT
,
578 label
= gtk_label_new(label_str
);
579 gtk_widget_show(label
);
581 text
= gtk_entry_new();
582 gtk_widget_show(text
);
584 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), label
,TRUE
, TRUE
,0);
585 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), text
,FALSE
, FALSE
,0);
587 id
= gtk_dialog_run(GTK_DIALOG(dialogue
));
589 case GTK_RESPONSE_ACCEPT
:
590 get_label_string(text
,str
);
591 gtk_widget_destroy(dialogue
);
593 case GTK_RESPONSE_REJECT
:
595 gtk_widget_destroy(dialogue
);
602 /* get_window_data_struct function is actually a lookup function,
603 * given a widget which is in the tree of the main window, it will
604 * return the MainWindow data structure associated with main window
607 MainWindow
* get_window_data_struct(GtkWidget
* widget
)
610 MainWindow
* mw_data
;
612 mw
= lookup_widget(widget
, "MWindow");
614 g_info("Main window does not exist\n");
618 mw_data
= (MainWindow
*) g_object_get_data(G_OBJECT(mw
),"main_window_data");
620 g_warning("Main window data does not exist\n");
627 /* create_new_window function, just constructs a new main window
630 void create_new_window(GtkWidget
* widget
, gpointer user_data
, gboolean clone
)
632 MainWindow
* parent
= get_window_data_struct(widget
);
635 g_info("Clone : use the same traceset\n");
636 construct_main_window(parent
);
638 g_info("Empty : traceset is set to NULL\n");
639 construct_main_window(NULL
);
643 /* Get the currently focused viewer.
644 * If no viewer is focused, use the first one.
646 * If no viewer available, return NULL.
648 GtkWidget
*viewer_container_focus(GtkWidget
*container
)
652 widget
= (GtkWidget
*)g_object_get_data(G_OBJECT(container
),
656 g_debug("no widget focused");
657 GList
*children
= gtk_container_get_children(GTK_CONTAINER(container
));
660 widget
= GTK_WIDGET(children
->data
);
661 g_object_set_data(G_OBJECT(container
),
671 gint
viewer_container_position(GtkWidget
*container
, GtkWidget
*child
)
674 if(child
== NULL
) return -1;
678 memset(&value
, 0, sizeof(GValue
));
679 g_value_init(&value
, G_TYPE_INT
);
680 gtk_container_child_get_property(GTK_CONTAINER(container
),
684 pos
= g_value_get_int(&value
);
690 /* move_*_viewer functions move the selected view up/down in
694 void move_down_viewer(GtkWidget
* widget
, gpointer user_data
)
696 MainWindow
* mw
= get_window_data_struct(widget
);
697 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
699 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
700 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
706 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
709 //gtk_multivpaned_widget_move_up(GTK_MULTIVPANED(tab->multivpaned));
711 /* change the position in the vbox */
712 GtkWidget
*focus_widget
;
714 focus_widget
= viewer_container_focus(tab
->viewer_container
);
715 position
= viewer_container_position(tab
->viewer_container
, focus_widget
);
718 /* can move up one position */
719 gtk_box_reorder_child(GTK_BOX(tab
->viewer_container
),
726 void move_up_viewer(GtkWidget
* widget
, gpointer user_data
)
728 MainWindow
* mw
= get_window_data_struct(widget
);
729 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
731 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
732 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
738 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
741 //gtk_multivpaned_widget_move_down(GTK_MULTIVPANED(tab->multivpaned));
742 /* change the position in the vbox */
743 GtkWidget
*focus_widget
;
745 focus_widget
= viewer_container_focus(tab
->viewer_container
);
746 position
= viewer_container_position(tab
->viewer_container
, focus_widget
);
750 g_list_length(gtk_container_get_children(
751 GTK_CONTAINER(tab
->viewer_container
)))-1
753 /* can move down one position */
754 gtk_box_reorder_child(GTK_BOX(tab
->viewer_container
),
762 /* delete_viewer deletes the selected viewer in the current tab
765 void delete_viewer(GtkWidget
* widget
, gpointer user_data
)
767 MainWindow
* mw
= get_window_data_struct(widget
);
768 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
770 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
771 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
777 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
780 //gtk_multivpaned_widget_delete(GTK_MULTIVPANED(tab->multivpaned));
782 GtkWidget
*focus_widget
= viewer_container_focus(tab
->viewer_container
);
784 if(focus_widget
!= NULL
)
785 gtk_widget_destroy(focus_widget
);
787 g_object_set_data(G_OBJECT(tab
->viewer_container
), "focused_viewer", NULL
);
791 /* open_traceset will open a traceset saved in a file
792 * Right now, it is not finished yet, (not working)
796 void open_traceset(GtkWidget
* widget
, gpointer user_data
)
800 LttvTraceset
* traceset
;
801 MainWindow
* mw_data
= get_window_data_struct(widget
);
802 GtkFileSelection
* file_selector
=
803 (GtkFileSelection
*)gtk_file_selection_new("Select a traceset");
805 gtk_file_selection_hide_fileop_buttons(file_selector
);
807 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
809 case GTK_RESPONSE_ACCEPT
:
810 case GTK_RESPONSE_OK
:
811 dir
= gtk_file_selection_get_selections (file_selector
);
812 traceset
= lttv_traceset_load(dir
[0]);
813 g_info("Open a trace set %s\n", dir
[0]);
816 case GTK_RESPONSE_REJECT
:
817 case GTK_RESPONSE_CANCEL
:
819 gtk_widget_destroy((GtkWidget
*)file_selector
);
825 /* lttvwindow_process_pending_requests
827 * This internal function gets called by g_idle, taking care of the pending
828 * requests. It is responsible for concatenation of time intervals and position
829 * requests. It does it with the following algorithm organizing process traceset
830 * calls. Here is the detailed description of the way it works :
832 * - Events Requests Servicing Algorithm
834 * Data structures necessary :
836 * List of requests added to context : list_in
837 * List of requests not added to context : list_out
842 * list_out : many events requests
844 * FIXME : insert rest of algorithm here
848 #define list_out tab->events_requests
850 gboolean
lttvwindow_process_pending_requests(Tab
*tab
)
853 LttvTracesetContext
*tsc
;
854 LttvTracefileContext
*tfc
;
855 GSList
*list_in
= NULL
;
859 LttvTracesetContextPosition
*end_position
;
862 g_critical("Foreground processing : tab does not exist. Processing removed.");
866 /* There is no events requests pending : we should never have been called! */
867 g_assert(g_slist_length(list_out
) != 0);
869 tsc
= LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
871 //set the cursor to be X shape, indicating that the computer is busy in doing its job
873 new = gdk_cursor_new(GDK_X_CURSOR
);
874 widget
= lookup_widget(tab
->mw
->mwindow
, "MToolbar1");
875 win
= gtk_widget_get_parent_window(widget
);
876 gdk_window_set_cursor(win
, new);
877 gdk_cursor_unref(new);
878 gdk_window_stick(win
);
879 gdk_window_unstick(win
);
882 g_debug("SIZE events req len : %d", g_slist_length(list_out
));
884 /* Preliminary check for no trace in traceset */
885 /* Unregister the routine if empty, empty list_out too */
886 if(lttv_traceset_number(tsc
->ts
) == 0) {
888 /* - For each req in list_out */
889 GSList
*iter
= list_out
;
891 while(iter
!= NULL
) {
893 gboolean remove
= FALSE
;
894 gboolean free_data
= FALSE
;
895 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
897 /* - Call end request for req */
898 if(events_request
->servicing
== TRUE
)
899 lttv_hooks_call(events_request
->after_request
, (gpointer
)tsc
);
901 /* - remove req from list_out */
902 /* Destroy the request */
909 GSList
*remove_iter
= iter
;
911 iter
= g_slist_next(iter
);
912 if(free_data
) events_request_free((EventsRequest
*)remove_iter
->data
);
913 list_out
= g_slist_remove_link(list_out
, remove_iter
);
914 } else { // not remove
915 iter
= g_slist_next(iter
);
920 /* 0.1 Lock Traces */
925 iter_trace
<lttv_traceset_number(tsc
->ts
);
927 LttvTrace
*trace_v
= lttv_traceset_get(tsc
->ts
, iter_trace
);
929 if(lttvwindowtraces_lock(trace_v
) != 0) {
930 g_critical("Foreground processing : Unable to get trace lock");
931 return TRUE
; /* Cannot get lock, try later */
936 /* 0.2 Seek tracefiles positions to context position */
937 //g_assert(lttv_process_traceset_seek_position(tsc, sync_position) == 0);
938 lttv_process_traceset_synchronize_tracefiles(tsc
);
941 /* Events processing algorithm implementation */
942 /* Warning : the gtk_events_pending takes a LOT of cpu time. So what we do
943 * instead is to leave the control to GTK and take it back.
945 /* A. Servicing loop */
946 //while( (g_slist_length(list_in) != 0 || g_slist_length(list_out) != 0)) {
947 if((g_slist_length(list_in
) != 0 || g_slist_length(list_out
) != 0)) {
949 /* 1. If list_in is empty (need a seek) */
950 if( g_slist_length(list_in
) == 0 ) {
952 /* list in is empty, need a seek */
954 /* 1.1 Add requests to list_in */
955 GSList
*ltime
= NULL
;
959 /* 1.1.1 Find all time requests with the lowest start time in list_out
962 if(g_slist_length(list_out
) > 0)
963 ltime
= g_slist_append(ltime
, g_slist_nth_data(list_out
, 0));
964 for(iter
=g_slist_nth(list_out
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
965 /* Find all time requests with the lowest start time in list_out */
966 EventsRequest
*event_request_ltime
= (EventsRequest
*)g_slist_nth_data(ltime
, 0);
967 EventsRequest
*event_request_list_out
= (EventsRequest
*)iter
->data
;
970 comp
= ltt_time_compare(event_request_ltime
->start_time
,
971 event_request_list_out
->start_time
);
973 ltime
= g_slist_append(ltime
, event_request_list_out
);
975 /* Remove all elements from ltime, and add current */
977 ltime
= g_slist_delete_link(ltime
, g_slist_nth(ltime
, 0));
978 ltime
= g_slist_append(ltime
, event_request_list_out
);
982 /* 1.1.2 Find all position requests with the lowest position in list_out
985 if(g_slist_length(list_out
) > 0)
986 lpos
= g_slist_append(lpos
, g_slist_nth_data(list_out
, 0));
987 for(iter
=g_slist_nth(list_out
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
988 /* Find all position requests with the lowest position in list_out */
989 EventsRequest
*event_request_lpos
= (EventsRequest
*)g_slist_nth_data(lpos
, 0);
990 EventsRequest
*event_request_list_out
= (EventsRequest
*)iter
->data
;
993 if(event_request_lpos
->start_position
!= NULL
994 && event_request_list_out
->start_position
!= NULL
)
996 comp
= lttv_traceset_context_pos_pos_compare
997 (event_request_lpos
->start_position
,
998 event_request_list_out
->start_position
);
1003 lpos
= g_slist_append(lpos
, event_request_list_out
);
1005 /* Remove all elements from lpos, and add current */
1007 lpos
= g_slist_delete_link(lpos
, g_slist_nth(lpos
, 0));
1008 lpos
= g_slist_append(lpos
, event_request_list_out
);
1013 EventsRequest
*event_request_lpos
= (EventsRequest
*)g_slist_nth_data(lpos
, 0);
1014 EventsRequest
*event_request_ltime
= (EventsRequest
*)g_slist_nth_data(ltime
, 0);
1015 LttTime lpos_start_time
;
1017 if(event_request_lpos
!= NULL
1018 && event_request_lpos
->start_position
!= NULL
) {
1019 lpos_start_time
= lttv_traceset_context_position_get_time(
1020 event_request_lpos
->start_position
);
1023 /* 1.1.3 If lpos.start time < ltime */
1024 if(event_request_lpos
!= NULL
1025 && event_request_lpos
->start_position
!= NULL
1026 && ltt_time_compare(lpos_start_time
,
1027 event_request_ltime
->start_time
)<0) {
1028 /* Add lpos to list_in, remove them from list_out */
1029 for(iter
=lpos
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
1030 /* Add to list_in */
1031 EventsRequest
*event_request_lpos
=
1032 (EventsRequest
*)iter
->data
;
1034 list_in
= g_slist_append(list_in
, event_request_lpos
);
1035 /* Remove from list_out */
1036 list_out
= g_slist_remove(list_out
, event_request_lpos
);
1039 /* 1.1.4 (lpos.start time >= ltime) */
1040 /* Add ltime to list_in, remove them from list_out */
1042 for(iter
=ltime
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
1043 /* Add to list_in */
1044 EventsRequest
*event_request_ltime
=
1045 (EventsRequest
*)iter
->data
;
1047 list_in
= g_slist_append(list_in
, event_request_ltime
);
1048 /* Remove from list_out */
1049 list_out
= g_slist_remove(list_out
, event_request_ltime
);
1054 g_slist_free(ltime
);
1059 tfc
= lttv_traceset_context_get_current_tfc(tsc
);
1060 g_assert(g_slist_length(list_in
)>0);
1061 EventsRequest
*events_request
= g_slist_nth_data(list_in
, 0);
1064 /* 1.2.1 If first request in list_in is a time request */
1065 if(events_request
->start_position
== NULL
) {
1066 /* - If first req in list_in start time != current time */
1067 if(tfc
== NULL
|| ltt_time_compare(events_request
->start_time
,
1068 tfc
->timestamp
) != 0)
1069 /* - Seek to that time */
1070 g_debug("SEEK TIME : %lu, %lu", events_request
->start_time
.tv_sec
,
1071 events_request
->start_time
.tv_nsec
);
1072 //lttv_process_traceset_seek_time(tsc, events_request->start_time);
1073 lttv_state_traceset_seek_time_closest(LTTV_TRACESET_STATE(tsc
),
1074 events_request
->start_time
);
1076 /* Process the traceset with only state hooks */
1078 lttv_process_traceset_middle(tsc
,
1079 events_request
->start_time
,
1082 g_assert(seek_count
< LTTV_STATE_SAVE_INTERVAL
);
1088 /* Else, the first request in list_in is a position request */
1089 /* If first req in list_in pos != current pos */
1090 g_assert(events_request
->start_position
!= NULL
);
1091 g_debug("SEEK POS time : %lu, %lu",
1092 lttv_traceset_context_position_get_time(
1093 events_request
->start_position
).tv_sec
,
1094 lttv_traceset_context_position_get_time(
1095 events_request
->start_position
).tv_nsec
);
1097 g_debug("SEEK POS context time : %lu, %lu",
1098 lttv_traceset_context_get_current_tfc(tsc
)->timestamp
.tv_sec
,
1099 lttv_traceset_context_get_current_tfc(tsc
)->timestamp
.tv_nsec
);
1100 g_assert(events_request
->start_position
!= NULL
);
1101 if(lttv_traceset_context_ctx_pos_compare(tsc
,
1102 events_request
->start_position
) != 0) {
1103 /* 1.2.2.1 Seek to that position */
1104 g_debug("SEEK POSITION");
1105 //lttv_process_traceset_seek_position(tsc, events_request->start_position);
1106 pos_time
= lttv_traceset_context_position_get_time(
1107 events_request
->start_position
);
1109 lttv_state_traceset_seek_time_closest(LTTV_TRACESET_STATE(tsc
),
1112 /* Process the traceset with only state hooks */
1114 lttv_process_traceset_middle(tsc
,
1117 events_request
->start_position
);
1118 g_assert(lttv_traceset_context_ctx_pos_compare(tsc
,
1119 events_request
->start_position
) == 0);
1126 /* 1.3 Add hooks and call before request for all list_in members */
1128 GSList
*iter
= NULL
;
1130 for(iter
=list_in
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
1131 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1132 /* 1.3.1 If !servicing */
1133 if(events_request
->servicing
== FALSE
) {
1134 /* - begin request hooks called
1135 * - servicing = TRUE
1137 lttv_hooks_call(events_request
->before_request
, (gpointer
)tsc
);
1138 events_request
->servicing
= TRUE
;
1140 /* 1.3.2 call before chunk
1141 * 1.3.3 events hooks added
1143 if(events_request
->trace
== -1)
1144 lttv_process_traceset_begin(tsc
,
1145 events_request
->before_chunk_traceset
,
1146 events_request
->before_chunk_trace
,
1147 events_request
->before_chunk_tracefile
,
1148 events_request
->event
,
1149 events_request
->event_by_id
);
1151 guint nb_trace
= lttv_traceset_number(tsc
->ts
);
1152 g_assert((guint
)events_request
->trace
< nb_trace
&&
1153 events_request
->trace
> -1);
1154 LttvTraceContext
*tc
= tsc
->traces
[events_request
->trace
];
1156 lttv_hooks_call(events_request
->before_chunk_traceset
, tsc
);
1158 lttv_trace_context_add_hooks(tc
,
1159 events_request
->before_chunk_trace
,
1160 events_request
->before_chunk_tracefile
,
1161 events_request
->event
,
1162 events_request
->event_by_id
);
1167 /* 2. Else, list_in is not empty, we continue a read */
1170 /* 2.0 For each req of list_in */
1171 GSList
*iter
= list_in
;
1173 while(iter
!= NULL
) {
1175 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1177 /* - Call before chunk
1178 * - events hooks added
1180 if(events_request
->trace
== -1)
1181 lttv_process_traceset_begin(tsc
,
1182 events_request
->before_chunk_traceset
,
1183 events_request
->before_chunk_trace
,
1184 events_request
->before_chunk_tracefile
,
1185 events_request
->event
,
1186 events_request
->event_by_id
);
1188 guint nb_trace
= lttv_traceset_number(tsc
->ts
);
1189 g_assert((guint
)events_request
->trace
< nb_trace
&&
1190 events_request
->trace
> -1);
1191 LttvTraceContext
*tc
= tsc
->traces
[events_request
->trace
];
1193 lttv_hooks_call(events_request
->before_chunk_traceset
, tsc
);
1195 lttv_trace_context_add_hooks(tc
,
1196 events_request
->before_chunk_trace
,
1197 events_request
->before_chunk_tracefile
,
1198 events_request
->event
,
1199 events_request
->event_by_id
);
1202 iter
= g_slist_next(iter
);
1207 tfc
= lttv_traceset_context_get_current_tfc(tsc
);
1209 /* 2.1 For each req of list_out */
1210 GSList
*iter
= list_out
;
1212 while(iter
!= NULL
) {
1214 gboolean remove
= FALSE
;
1215 gboolean free_data
= FALSE
;
1216 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1218 /* if req.start time == current context time
1219 * or req.start position == current position*/
1220 if( ltt_time_compare(events_request
->start_time
,
1221 tfc
->timestamp
) == 0
1223 (events_request
->start_position
!= NULL
1225 lttv_traceset_context_ctx_pos_compare(tsc
,
1226 events_request
->start_position
) == 0)
1228 /* - Add to list_in, remove from list_out */
1229 list_in
= g_slist_append(list_in
, events_request
);
1233 /* - If !servicing */
1234 if(events_request
->servicing
== FALSE
) {
1235 /* - begin request hooks called
1236 * - servicing = TRUE
1238 lttv_hooks_call(events_request
->before_request
, (gpointer
)tsc
);
1239 events_request
->servicing
= TRUE
;
1241 /* call before chunk
1242 * events hooks added
1244 if(events_request
->trace
== -1)
1245 lttv_process_traceset_begin(tsc
,
1246 events_request
->before_chunk_traceset
,
1247 events_request
->before_chunk_trace
,
1248 events_request
->before_chunk_tracefile
,
1249 events_request
->event
,
1250 events_request
->event_by_id
);
1252 guint nb_trace
= lttv_traceset_number(tsc
->ts
);
1253 g_assert((guint
)events_request
->trace
< nb_trace
&&
1254 events_request
->trace
> -1);
1255 LttvTraceContext
*tc
= tsc
->traces
[events_request
->trace
];
1257 lttv_hooks_call(events_request
->before_chunk_traceset
, tsc
);
1259 lttv_trace_context_add_hooks(tc
,
1260 events_request
->before_chunk_trace
,
1261 events_request
->before_chunk_tracefile
,
1262 events_request
->event
,
1263 events_request
->event_by_id
);
1272 GSList
*remove_iter
= iter
;
1274 iter
= g_slist_next(iter
);
1275 if(free_data
) events_request_free((EventsRequest
*)remove_iter
->data
);
1276 list_out
= g_slist_remove_link(list_out
, remove_iter
);
1277 } else { // not remove
1278 iter
= g_slist_next(iter
);
1284 /* 3. Find end criterions */
1289 /* 3.1.1 Find lowest end time in list_in */
1290 g_assert(g_slist_length(list_in
)>0);
1291 end_time
= ((EventsRequest
*)g_slist_nth_data(list_in
,0))->end_time
;
1293 for(iter
=g_slist_nth(list_in
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
1294 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1296 if(ltt_time_compare(events_request
->end_time
,
1298 end_time
= events_request
->end_time
;
1301 /* 3.1.2 Find lowest start time in list_out */
1302 for(iter
=list_out
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
1303 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1305 if(ltt_time_compare(events_request
->start_time
,
1307 end_time
= events_request
->start_time
;
1312 /* 3.2 Number of events */
1314 /* 3.2.1 Find lowest number of events in list_in */
1317 end_nb_events
= ((EventsRequest
*)g_slist_nth_data(list_in
,0))->num_events
;
1319 for(iter
=g_slist_nth(list_in
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
1320 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1322 if(events_request
->num_events
< end_nb_events
)
1323 end_nb_events
= events_request
->num_events
;
1326 /* 3.2.2 Use min(CHUNK_NUM_EVENTS, min num events in list_in) as
1329 end_nb_events
= MIN(CHUNK_NUM_EVENTS
, end_nb_events
);
1333 /* 3.3 End position */
1335 /* 3.3.1 Find lowest end position in list_in */
1338 end_position
=((EventsRequest
*)g_slist_nth_data(list_in
,0))->end_position
;
1340 for(iter
=g_slist_nth(list_in
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
1341 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1343 if(events_request
->end_position
!= NULL
&& end_position
!= NULL
&&
1344 lttv_traceset_context_pos_pos_compare(events_request
->end_position
,
1346 end_position
= events_request
->end_position
;
1351 /* 3.3.2 Find lowest start position in list_out */
1354 for(iter
=list_out
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
1355 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1357 if(events_request
->end_position
!= NULL
&& end_position
!= NULL
&&
1358 lttv_traceset_context_pos_pos_compare(events_request
->end_position
,
1360 end_position
= events_request
->end_position
;
1365 /* 4. Call process traceset middle */
1366 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
);
1367 count
= lttv_process_traceset_middle(tsc
, end_time
, end_nb_events
, end_position
);
1369 tfc
= lttv_traceset_context_get_current_tfc(tsc
);
1371 g_debug("Context time after middle : %lu, %lu", tfc
->timestamp
.tv_sec
,
1372 tfc
->timestamp
.tv_nsec
);
1374 g_debug("End of trace reached after middle.");
1378 /* 5. After process traceset middle */
1379 tfc
= lttv_traceset_context_get_current_tfc(tsc
);
1381 /* - if current context time > traceset.end time */
1382 if(tfc
== NULL
|| ltt_time_compare(tfc
->timestamp
,
1383 tsc
->time_span
.end_time
) > 0) {
1384 /* - For each req in list_in */
1385 GSList
*iter
= list_in
;
1387 while(iter
!= NULL
) {
1389 gboolean remove
= FALSE
;
1390 gboolean free_data
= FALSE
;
1391 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1393 /* - Remove events hooks for req
1394 * - Call end chunk for req
1397 if(events_request
->trace
== -1)
1398 lttv_process_traceset_end(tsc
,
1399 events_request
->after_chunk_traceset
,
1400 events_request
->after_chunk_trace
,
1401 events_request
->after_chunk_tracefile
,
1402 events_request
->event
,
1403 events_request
->event_by_id
);
1406 guint nb_trace
= lttv_traceset_number(tsc
->ts
);
1407 g_assert(events_request
->trace
< nb_trace
&&
1408 events_request
->trace
> -1);
1409 LttvTraceContext
*tc
= tsc
->traces
[events_request
->trace
];
1411 lttv_trace_context_remove_hooks(tc
,
1412 events_request
->after_chunk_trace
,
1413 events_request
->after_chunk_tracefile
,
1414 events_request
->event
,
1415 events_request
->event_by_id
);
1416 lttv_hooks_call(events_request
->after_chunk_traceset
, tsc
);
1421 /* - Call end request for req */
1422 lttv_hooks_call(events_request
->after_request
, (gpointer
)tsc
);
1424 /* - remove req from list_in */
1425 /* Destroy the request */
1432 GSList
*remove_iter
= iter
;
1434 iter
= g_slist_next(iter
);
1435 if(free_data
) events_request_free((EventsRequest
*)remove_iter
->data
);
1436 list_in
= g_slist_remove_link(list_in
, remove_iter
);
1437 } else { // not remove
1438 iter
= g_slist_next(iter
);
1443 /* 5.1 For each req in list_in */
1444 GSList
*iter
= list_in
;
1446 while(iter
!= NULL
) {
1448 gboolean remove
= FALSE
;
1449 gboolean free_data
= FALSE
;
1450 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1452 /* - Remove events hooks for req
1453 * - Call end chunk for req
1455 if(events_request
->trace
== -1)
1456 lttv_process_traceset_end(tsc
,
1457 events_request
->after_chunk_traceset
,
1458 events_request
->after_chunk_trace
,
1459 events_request
->after_chunk_tracefile
,
1460 events_request
->event
,
1461 events_request
->event_by_id
);
1464 guint nb_trace
= lttv_traceset_number(tsc
->ts
);
1465 g_assert(events_request
->trace
< nb_trace
&&
1466 events_request
->trace
> -1);
1467 LttvTraceContext
*tc
= tsc
->traces
[events_request
->trace
];
1469 lttv_trace_context_remove_hooks(tc
,
1470 events_request
->after_chunk_trace
,
1471 events_request
->after_chunk_tracefile
,
1472 events_request
->event
,
1473 events_request
->event_by_id
);
1475 lttv_hooks_call(events_request
->after_chunk_traceset
, tsc
);
1478 /* - req.num -= count */
1479 g_assert(events_request
->num_events
>= count
);
1480 events_request
->num_events
-= count
;
1482 g_assert(tfc
!= NULL
);
1483 /* - if req.num == 0
1485 * current context time >= req.end time
1487 * req.end pos == current pos
1489 * req.stop_flag == TRUE
1491 if( events_request
->num_events
== 0
1493 events_request
->stop_flag
== TRUE
1495 ltt_time_compare(tfc
->timestamp
,
1496 events_request
->end_time
) >= 0
1498 (events_request
->end_position
!= NULL
1500 lttv_traceset_context_ctx_pos_compare(tsc
,
1501 events_request
->end_position
) == 0)
1504 g_assert(events_request
->servicing
== TRUE
);
1505 /* - Call end request for req
1506 * - remove req from list_in */
1507 lttv_hooks_call(events_request
->after_request
, (gpointer
)tsc
);
1508 /* - remove req from list_in */
1509 /* Destroy the request */
1517 GSList
*remove_iter
= iter
;
1519 iter
= g_slist_next(iter
);
1520 if(free_data
) events_request_free((EventsRequest
*)remove_iter
->data
);
1521 list_in
= g_slist_remove_link(list_in
, remove_iter
);
1522 } else { // not remove
1523 iter
= g_slist_next(iter
);
1529 /* End of removed servicing loop : leave control to GTK instead. */
1530 // if(gtk_events_pending()) break;
1533 /* B. When interrupted between chunks */
1536 GSList
*iter
= list_in
;
1538 /* 1. for each request in list_in */
1539 while(iter
!= NULL
) {
1541 gboolean remove
= FALSE
;
1542 gboolean free_data
= FALSE
;
1543 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1545 /* 1.1. Use current postition as start position */
1546 if(events_request
->start_position
!= NULL
)
1547 lttv_traceset_context_position_destroy(events_request
->start_position
);
1548 events_request
->start_position
= lttv_traceset_context_position_new(tsc
);
1549 lttv_traceset_context_position_save(tsc
, events_request
->start_position
);
1551 /* 1.2. Remove start time */
1552 events_request
->start_time
= ltt_time_infinite
;
1554 /* 1.3. Move from list_in to list_out */
1557 list_out
= g_slist_append(list_out
, events_request
);
1562 GSList
*remove_iter
= iter
;
1564 iter
= g_slist_next(iter
);
1565 if(free_data
) events_request_free((EventsRequest
*)remove_iter
->data
);
1566 list_in
= g_slist_remove_link(list_in
, remove_iter
);
1567 } else { // not remove
1568 iter
= g_slist_next(iter
);
1574 /* C Unlock Traces */
1576 lttv_process_traceset_get_sync_data(tsc
);
1577 //lttv_traceset_context_position_save(tsc, sync_position);
1582 iter_trace
<lttv_traceset_number(tsc
->ts
);
1584 LttvTrace
*trace_v
= lttv_traceset_get(tsc
->ts
, iter_trace
);
1586 lttvwindowtraces_unlock(trace_v
);
1590 //set the cursor back to normal
1591 gdk_window_set_cursor(win
, NULL
);
1594 g_assert(g_slist_length(list_in
) == 0);
1596 if( g_slist_length(list_out
) == 0 ) {
1597 /* Put tab's request pending flag back to normal */
1598 tab
->events_request_pending
= FALSE
;
1599 g_debug("remove the idle fct");
1600 return FALSE
; /* Remove the idle function */
1602 g_debug("leave the idle fct");
1603 return TRUE
; /* Leave the idle function */
1605 /* We do not use simili-round-robin, it may require to read 1 meg buffers
1606 * again and again if many tracesets use the same tracefiles. */
1607 /* Hack for round-robin idle functions */
1608 /* It will put the idle function at the end of the pool */
1609 /*g_idle_add_full((G_PRIORITY_HIGH_IDLE + 21),
1610 (GSourceFunc)execute_events_requests,
1620 static void lttvwindow_add_trace(Tab
*tab
, LttvTrace
*trace_v
)
1622 LttvTraceset
*traceset
= tab
->traceset_info
->traceset
;
1624 guint num_traces
= lttv_traceset_number(traceset
);
1626 //Verify if trace is already present.
1627 for(i
=0; i
<num_traces
; i
++)
1629 LttvTrace
* trace
= lttv_traceset_get(traceset
, i
);
1630 if(trace
== trace_v
)
1634 //Keep a reference to the traces so they are not freed.
1635 for(i
=0; i
<lttv_traceset_number(traceset
); i
++)
1637 LttvTrace
* trace
= lttv_traceset_get(traceset
, i
);
1638 lttv_trace_ref(trace
);
1641 //remove state update hooks
1642 lttv_state_remove_event_hooks(
1643 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1645 lttv_context_fini(LTTV_TRACESET_CONTEXT(
1646 tab
->traceset_info
->traceset_context
));
1647 g_object_unref(tab
->traceset_info
->traceset_context
);
1649 lttv_traceset_add(traceset
, trace_v
);
1650 lttv_trace_ref(trace_v
); /* local ref */
1652 /* Create new context */
1653 tab
->traceset_info
->traceset_context
=
1654 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
1656 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->
1661 //add state update hooks
1662 lttv_state_add_event_hooks(
1663 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1664 //Remove local reference to the traces.
1665 for(i
=0; i
<lttv_traceset_number(traceset
); i
++)
1667 LttvTrace
* trace
= lttv_traceset_get(traceset
, i
);
1668 lttv_trace_unref(trace
);
1672 //add_trace_into_traceset_selector(GTK_MULTIVPANED(tab->multivpaned), lttv_trace(trace_v));
1675 /* add_trace adds a trace into the current traceset. It first displays a
1676 * directory selection dialogue to let user choose a trace, then recreates
1677 * tracset_context, and redraws all the viewer of the current tab
1680 void add_trace(GtkWidget
* widget
, gpointer user_data
)
1683 LttvTrace
* trace_v
;
1684 LttvTraceset
* traceset
;
1686 char abs_path
[PATH_MAX
];
1688 MainWindow
* mw_data
= get_window_data_struct(widget
);
1689 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
1691 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1692 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1696 tab
= create_new_tab(widget
, NULL
);
1698 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1701 GtkDirSelection
* file_selector
= (GtkDirSelection
*)gtk_dir_selection_new("Select a trace");
1702 gtk_dir_selection_hide_fileop_buttons(file_selector
);
1704 if(remember_trace_dir
[0] != '\0')
1705 gtk_dir_selection_set_filename(file_selector
, remember_trace_dir
);
1707 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
1709 case GTK_RESPONSE_ACCEPT
:
1710 case GTK_RESPONSE_OK
:
1711 dir
= gtk_dir_selection_get_dir (file_selector
);
1712 strncpy(remember_trace_dir
, dir
, PATH_MAX
);
1713 if(!dir
|| strlen(dir
) == 0){
1714 gtk_widget_destroy((GtkWidget
*)file_selector
);
1717 get_absolute_pathname(dir
, abs_path
);
1718 trace_v
= lttvwindowtraces_get_trace_by_name(abs_path
);
1719 if(trace_v
== NULL
) {
1720 trace
= ltt_trace_open(abs_path
);
1722 g_warning("cannot open trace %s", abs_path
);
1724 trace_v
= lttv_trace_new(trace
);
1725 lttvwindowtraces_add_trace(trace_v
);
1726 lttvwindow_add_trace(tab
, trace_v
);
1729 lttvwindow_add_trace(tab
, trace_v
);
1732 gtk_widget_destroy((GtkWidget
*)file_selector
);
1734 //update current tab
1735 //update_traceset(mw_data);
1737 /* Call the updatetraceset hooks */
1739 traceset
= tab
->traceset_info
->traceset
;
1740 SetTraceset(tab
, traceset
);
1741 // in expose now call_pending_read_hooks(mw_data);
1743 //lttvwindow_report_current_time(mw_data,&(tab->current_time));
1745 case GTK_RESPONSE_REJECT
:
1746 case GTK_RESPONSE_CANCEL
:
1748 gtk_widget_destroy((GtkWidget
*)file_selector
);
1753 /* remove_trace removes a trace from the current traceset if all viewers in
1754 * the current tab are not interested in the trace. It first displays a
1755 * dialogue, which shows all traces in the current traceset, to let user choose
1756 * a trace, then it checks if all viewers unselect the trace, if it is true,
1757 * it will remove the trace, recreate the traceset_contex,
1758 * and redraws all the viewer of the current tab. If there is on trace in the
1759 * current traceset, it will delete all viewers of the current tab
1761 * It destroys the filter tree. FIXME... we should request for an update
1765 void remove_trace(GtkWidget
*widget
, gpointer user_data
)
1768 LttvTrace
* trace_v
;
1769 LttvTraceset
* traceset
;
1770 gint i
, j
, nb_trace
, index
=-1;
1771 char ** name
, *remove_trace_name
;
1772 MainWindow
* mw_data
= get_window_data_struct(widget
);
1773 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
1775 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1776 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1782 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1785 nb_trace
=lttv_traceset_number(tab
->traceset_info
->traceset
);
1786 name
= g_new(char*,nb_trace
);
1787 for(i
= 0; i
< nb_trace
; i
++){
1788 trace_v
= lttv_traceset_get(tab
->traceset_info
->traceset
, i
);
1789 trace
= lttv_trace(trace_v
);
1790 name
[i
] = g_quark_to_string(ltt_trace_name(trace
));
1793 remove_trace_name
= get_remove_trace(name
, nb_trace
);
1796 if(remove_trace_name
){
1798 /* yuk, cut n paste from old code.. should be better (MD)*/
1799 for(i
= 0; i
<nb_trace
; i
++) {
1800 if(strcmp(remove_trace_name
,name
[i
]) == 0){
1805 traceset
= tab
->traceset_info
->traceset
;
1806 //Keep a reference to the traces so they are not freed.
1807 for(j
=0; j
<lttv_traceset_number(traceset
); j
++)
1809 LttvTrace
* trace
= lttv_traceset_get(traceset
, j
);
1810 lttv_trace_ref(trace
);
1813 //remove state update hooks
1814 lttv_state_remove_event_hooks(
1815 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1816 lttv_context_fini(LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
));
1817 g_object_unref(tab
->traceset_info
->traceset_context
);
1819 trace_v
= lttv_traceset_get(traceset
, index
);
1821 lttv_traceset_remove(traceset
, index
);
1822 lttv_trace_unref(trace_v
); // Remove local reference
1824 if(lttv_trace_get_ref_number(trace_v
) <= 1) {
1825 /* ref 1 : lttvwindowtraces only*/
1826 ltt_trace_close(lttv_trace(trace_v
));
1827 /* lttvwindowtraces_remove_trace takes care of destroying
1828 * the traceset linked with the trace_v and also of destroying
1829 * the trace_v at the same time.
1831 lttvwindowtraces_remove_trace(trace_v
);
1834 tab
->traceset_info
->traceset_context
=
1835 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
1837 LTTV_TRACESET_CONTEXT(tab
->
1838 traceset_info
->traceset_context
),traceset
);
1839 //add state update hooks
1840 lttv_state_add_event_hooks(
1841 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1843 //Remove local reference to the traces.
1844 for(j
=0; j
<lttv_traceset_number(traceset
); j
++)
1846 LttvTrace
* trace
= lttv_traceset_get(traceset
, j
);
1847 lttv_trace_unref(trace
);
1850 SetTraceset(tab
, (gpointer
)traceset
);
1856 void remove_trace(GtkWidget
* widget
, gpointer user_data
)
1859 LttvTrace
* trace_v
;
1860 LttvTraceset
* traceset
;
1861 gint i
, j
, nb_trace
;
1862 char ** name
, *remove_trace_name
;
1863 MainWindow
* mw_data
= get_window_data_struct(widget
);
1864 LttvTracesetSelector
* s
;
1865 LttvTraceSelector
* t
;
1868 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
1870 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1871 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1877 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1880 nb_trace
=lttv_traceset_number(tab
->traceset_info
->traceset
);
1881 name
= g_new(char*,nb_trace
);
1882 for(i
= 0; i
< nb_trace
; i
++){
1883 trace_v
= lttv_traceset_get(tab
->traceset_info
->traceset
, i
);
1884 trace
= lttv_trace(trace_v
);
1885 name
[i
] = ltt_trace_name(trace
);
1888 remove_trace_name
= get_remove_trace(name
, nb_trace
);
1890 if(remove_trace_name
){
1891 for(i
=0; i
<nb_trace
; i
++){
1892 if(strcmp(remove_trace_name
,name
[i
]) == 0){
1893 //unselect the trace from the current viewer
1895 w
= gtk_multivpaned_get_widget(GTK_MULTIVPANED(tab
->multivpaned
));
1897 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
1899 t
= lttv_traceset_selector_trace_get(s
,i
);
1900 lttv_trace_selector_set_selected(t
, FALSE
);
1903 //check if other viewers select the trace
1904 w
= gtk_multivpaned_get_first_widget(GTK_MULTIVPANED(tab
->multivpaned
));
1906 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
1908 t
= lttv_traceset_selector_trace_get(s
,i
);
1909 selected
= lttv_trace_selector_get_selected(t
);
1912 w
= gtk_multivpaned_get_next_widget(GTK_MULTIVPANED(tab
->multivpaned
));
1914 }else selected
= FALSE
;
1916 //if no viewer selects the trace, remove it
1918 remove_trace_from_traceset_selector(GTK_MULTIVPANED(tab
->multivpaned
), i
);
1920 traceset
= tab
->traceset_info
->traceset
;
1921 //Keep a reference to the traces so they are not freed.
1922 for(j
=0; j
<lttv_traceset_number(traceset
); j
++)
1924 LttvTrace
* trace
= lttv_traceset_get(traceset
, j
);
1925 lttv_trace_ref(trace
);
1928 //remove state update hooks
1929 lttv_state_remove_event_hooks(
1930 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1931 lttv_context_fini(LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
));
1932 g_object_unref(tab
->traceset_info
->traceset_context
);
1935 trace_v
= lttv_traceset_get(traceset
, i
);
1937 if(lttv_trace_get_ref_number(trace_v
) <= 2) {
1938 /* ref 2 : traceset, local */
1939 lttvwindowtraces_remove_trace(trace_v
);
1940 ltt_trace_close(lttv_trace(trace_v
));
1943 lttv_traceset_remove(traceset
, i
);
1944 lttv_trace_unref(trace_v
); // Remove local reference
1946 if(!lttv_trace_get_ref_number(trace_v
))
1947 lttv_trace_destroy(trace_v
);
1949 tab
->traceset_info
->traceset_context
=
1950 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
1952 LTTV_TRACESET_CONTEXT(tab
->
1953 traceset_info
->traceset_context
),traceset
);
1954 //add state update hooks
1955 lttv_state_add_event_hooks(
1956 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1958 //Remove local reference to the traces.
1959 for(j
=0; j
<lttv_traceset_number(traceset
); j
++)
1961 LttvTrace
* trace
= lttv_traceset_get(traceset
, j
);
1962 lttv_trace_unref(trace
);
1966 //update current tab
1967 //update_traceset(mw_data);
1970 SetTraceset(tab
, (gpointer
)traceset
);
1971 // in expose now call_pending_read_hooks(mw_data);
1973 //lttvwindow_report_current_time(mw_data,&(tab->current_time));
1976 // while(tab->multi_vpaned->num_children){
1977 // gtk_multi_vpaned_widget_delete(tab->multi_vpaned);
1991 /* Redraw all the viewers in the current tab */
1992 void redraw(GtkWidget
*widget
, gpointer user_data
)
1994 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
1995 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1996 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
2001 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
2005 LttvAttributeValue value
;
2007 g_assert(lttv_iattribute_find_by_path(tab
->attributes
, "hooks/redraw", LTTV_POINTER
, &value
));
2009 tmp
= (LttvHooks
*)*(value
.v_pointer
);
2011 lttv_hooks_call(tmp
,NULL
);
2015 void continue_processing(GtkWidget
*widget
, gpointer user_data
)
2017 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
2018 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
2019 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
2024 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
2028 LttvAttributeValue value
;
2030 g_assert(lttv_iattribute_find_by_path(tab
->attributes
,
2031 "hooks/continue", LTTV_POINTER
, &value
));
2033 tmp
= (LttvHooks
*)*(value
.v_pointer
);
2035 lttv_hooks_call(tmp
,NULL
);
2038 /* Stop the processing for the calling main window's current tab.
2039 * It removes every processing requests that are in its list. It does not call
2040 * the end request hooks, because the request is not finished.
2043 void stop_processing(GtkWidget
*widget
, gpointer user_data
)
2045 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
2046 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
2047 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
2052 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
2054 GSList
*iter
= tab
->events_requests
;
2056 while(iter
!= NULL
) {
2057 GSList
*remove_iter
= iter
;
2058 iter
= g_slist_next(iter
);
2060 g_free(remove_iter
->data
);
2061 tab
->events_requests
=
2062 g_slist_remove_link(tab
->events_requests
, remove_iter
);
2064 tab
->events_request_pending
= FALSE
;
2065 g_idle_remove_by_data(tab
);
2066 g_assert(g_slist_length(tab
->events_requests
) == 0);
2070 /* save will save the traceset to a file
2071 * Not implemented yet FIXME
2074 void save(GtkWidget
* widget
, gpointer user_data
)
2079 void save_as(GtkWidget
* widget
, gpointer user_data
)
2081 g_info("Save as\n");
2085 /* zoom will change the time_window of all the viewers of the
2086 * current tab, and redisplay them. The main functionality is to
2087 * determine the new time_window of the current tab
2090 void zoom(GtkWidget
* widget
, double size
)
2092 TimeInterval time_span
;
2093 TimeWindow new_time_window
;
2094 LttTime current_time
, time_delta
;
2095 MainWindow
* mw_data
= get_window_data_struct(widget
);
2096 LttvTracesetContext
*tsc
;
2097 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
2099 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
2100 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
2106 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
2109 if(size
== 1) return;
2111 tsc
= LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
2112 time_span
= tsc
->time_span
;
2113 new_time_window
= tab
->time_window
;
2114 current_time
= tab
->current_time
;
2116 time_delta
= ltt_time_sub(time_span
.end_time
,time_span
.start_time
);
2118 new_time_window
.start_time
= time_span
.start_time
;
2119 new_time_window
.time_width
= time_delta
;
2120 new_time_window
.time_width_double
= ltt_time_to_double(time_delta
);
2121 new_time_window
.end_time
= ltt_time_add(new_time_window
.start_time
,
2122 new_time_window
.time_width
) ;
2124 new_time_window
.time_width
= ltt_time_div(new_time_window
.time_width
, size
);
2125 new_time_window
.time_width_double
=
2126 ltt_time_to_double(new_time_window
.time_width
);
2127 if(ltt_time_compare(new_time_window
.time_width
,time_delta
) > 0)
2128 { /* Case where zoom out is bigger than trace length */
2129 new_time_window
.start_time
= time_span
.start_time
;
2130 new_time_window
.time_width
= time_delta
;
2131 new_time_window
.time_width_double
= ltt_time_to_double(time_delta
);
2132 new_time_window
.end_time
= ltt_time_add(new_time_window
.start_time
,
2133 new_time_window
.time_width
) ;
2137 /* Center the image on the current time */
2138 new_time_window
.start_time
=
2139 ltt_time_sub(current_time
,
2140 ltt_time_from_double(new_time_window
.time_width_double
/2.0));
2141 new_time_window
.end_time
= ltt_time_add(new_time_window
.start_time
,
2142 new_time_window
.time_width
) ;
2143 /* If on borders, don't fall off */
2144 if(ltt_time_compare(new_time_window
.start_time
, time_span
.start_time
) <0)
2146 new_time_window
.start_time
= time_span
.start_time
;
2147 new_time_window
.end_time
= ltt_time_add(new_time_window
.start_time
,
2148 new_time_window
.time_width
) ;
2152 if(ltt_time_compare(new_time_window
.end_time
,
2153 time_span
.end_time
) > 0)
2155 new_time_window
.start_time
=
2156 ltt_time_sub(time_span
.end_time
, new_time_window
.time_width
);
2158 new_time_window
.end_time
= ltt_time_add(new_time_window
.start_time
,
2159 new_time_window
.time_width
) ;
2166 if(ltt_time_compare(new_time_window
.time_width
, ltt_time_zero
) == 0) {
2167 g_warning("Zoom more than 1 ns impossible");
2169 time_change_manager(tab
, new_time_window
);
2173 void zoom_in(GtkWidget
* widget
, gpointer user_data
)
2178 void zoom_out(GtkWidget
* widget
, gpointer user_data
)
2183 void zoom_extended(GtkWidget
* widget
, gpointer user_data
)
2188 void go_to_time(GtkWidget
* widget
, gpointer user_data
)
2190 g_info("Go to time\n");
2193 void show_time_frame(GtkWidget
* widget
, gpointer user_data
)
2195 g_info("Show time frame\n");
2199 /* callback function */
2202 on_empty_traceset_activate (GtkMenuItem
*menuitem
,
2205 create_new_window((GtkWidget
*)menuitem
, user_data
, FALSE
);
2210 on_clone_traceset_activate (GtkMenuItem
*menuitem
,
2213 create_new_window((GtkWidget
*)menuitem
, user_data
, TRUE
);
2217 /* create_new_tab calls create_tab to construct a new tab in the main window
2220 Tab
*create_new_tab(GtkWidget
* widget
, gpointer user_data
){
2221 gchar label
[PATH_MAX
];
2222 MainWindow
* mw_data
= get_window_data_struct(widget
);
2224 GtkNotebook
* notebook
= (GtkNotebook
*)lookup_widget(widget
, "MNotebook");
2225 if(notebook
== NULL
){
2226 g_info("Notebook does not exist\n");
2229 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
2230 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
2236 copy_tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
2239 strcpy(label
,"Page");
2240 if(get_label(mw_data
, label
,"Get the name of the tab","Please input tab's name"))
2241 return (create_tab (mw_data
, copy_tab
, notebook
, label
));
2247 on_tab_activate (GtkMenuItem
*menuitem
,
2250 create_new_tab((GtkWidget
*)menuitem
, user_data
);
2255 on_open_activate (GtkMenuItem
*menuitem
,
2258 open_traceset((GtkWidget
*)menuitem
, user_data
);
2263 on_close_activate (GtkMenuItem
*menuitem
,
2266 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2267 main_window_destructor(mw_data
);
2271 /* remove the current tab from the main window
2275 on_close_tab_activate (GtkWidget
*widget
,
2279 GtkWidget
* notebook
;
2281 MainWindow
* mw_data
= get_window_data_struct(widget
);
2282 notebook
= lookup_widget(widget
, "MNotebook");
2283 if(notebook
== NULL
){
2284 g_info("Notebook does not exist\n");
2288 page_num
= gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
));
2290 gtk_notebook_remove_page(GTK_NOTEBOOK(notebook
), page_num
);
2295 on_close_tab_X_clicked (GtkWidget
*widget
,
2299 GtkWidget
*notebook
= lookup_widget(widget
, "MNotebook");
2300 if(notebook
== NULL
){
2301 g_info("Notebook does not exist\n");
2305 if((page_num
= gtk_notebook_page_num(GTK_NOTEBOOK(notebook
), widget
)) != -1)
2306 gtk_notebook_remove_page(GTK_NOTEBOOK(notebook
), page_num
);
2312 on_add_trace_activate (GtkMenuItem
*menuitem
,
2315 add_trace((GtkWidget
*)menuitem
, user_data
);
2320 on_remove_trace_activate (GtkMenuItem
*menuitem
,
2323 remove_trace((GtkWidget
*)menuitem
, user_data
);
2328 on_save_activate (GtkMenuItem
*menuitem
,
2331 save((GtkWidget
*)menuitem
, user_data
);
2336 on_save_as_activate (GtkMenuItem
*menuitem
,
2339 save_as((GtkWidget
*)menuitem
, user_data
);
2344 on_quit_activate (GtkMenuItem
*menuitem
,
2352 on_cut_activate (GtkMenuItem
*menuitem
,
2360 on_copy_activate (GtkMenuItem
*menuitem
,
2368 on_paste_activate (GtkMenuItem
*menuitem
,
2376 on_delete_activate (GtkMenuItem
*menuitem
,
2384 on_zoom_in_activate (GtkMenuItem
*menuitem
,
2387 zoom_in((GtkWidget
*)menuitem
, user_data
);
2392 on_zoom_out_activate (GtkMenuItem
*menuitem
,
2395 zoom_out((GtkWidget
*)menuitem
, user_data
);
2400 on_zoom_extended_activate (GtkMenuItem
*menuitem
,
2403 zoom_extended((GtkWidget
*)menuitem
, user_data
);
2408 on_go_to_time_activate (GtkMenuItem
*menuitem
,
2411 go_to_time((GtkWidget
*)menuitem
, user_data
);
2416 on_show_time_frame_activate (GtkMenuItem
*menuitem
,
2419 show_time_frame((GtkWidget
*)menuitem
, user_data
);
2424 on_move_viewer_up_activate (GtkMenuItem
*menuitem
,
2427 move_up_viewer((GtkWidget
*)menuitem
, user_data
);
2432 on_move_viewer_down_activate (GtkMenuItem
*menuitem
,
2435 move_down_viewer((GtkWidget
*)menuitem
, user_data
);
2440 on_remove_viewer_activate (GtkMenuItem
*menuitem
,
2443 delete_viewer((GtkWidget
*)menuitem
, user_data
);
2447 on_trace_facility_activate (GtkMenuItem
*menuitem
,
2450 g_info("Trace facility selector: %s\n");
2454 /* Dispaly a file selection dialogue to let user select a library, then call
2455 * lttv_library_load().
2459 on_load_library_activate (GtkMenuItem
*menuitem
,
2462 GError
*error
= NULL
;
2463 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2465 gchar load_module_path_alter
[PATH_MAX
];
2469 gchar
*load_module_path
;
2470 name
= g_ptr_array_new();
2471 nb
= lttv_library_path_number();
2472 /* ask for the library path */
2476 path
= lttv_library_path_get(i
);
2477 g_ptr_array_add(name
, path
);
2480 load_module_path
= get_selection((char **)(name
->pdata
), name
->len
,
2481 "Select a library path", "Library paths");
2482 if(load_module_path
!= NULL
)
2483 strncpy(load_module_path_alter
, load_module_path
, PATH_MAX
-1); // -1 for /
2485 g_ptr_array_free(name
, TRUE
);
2487 if(load_module_path
== NULL
) return;
2491 /* Make sure the module path ends with a / */
2492 gchar
*ptr
= load_module_path_alter
;
2494 ptr
= strchr(ptr
, '\0');
2496 if(*(ptr
-1) != '/') {
2503 /* Ask for the library to load : list files in the previously selected
2505 gchar str
[PATH_MAX
];
2508 GtkFileSelection
* file_selector
=
2509 (GtkFileSelection
*)gtk_file_selection_new("Select a module");
2510 gtk_file_selection_set_filename(file_selector
, load_module_path_alter
);
2511 gtk_file_selection_hide_fileop_buttons(file_selector
);
2514 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
2516 case GTK_RESPONSE_ACCEPT
:
2517 case GTK_RESPONSE_OK
:
2518 dir
= gtk_file_selection_get_selections (file_selector
);
2519 strncpy(str
,dir
[0],PATH_MAX
);
2520 strncpy(remember_plugins_dir
,dir
[0],PATH_MAX
);
2521 /* only keep file name */
2523 str1
= strrchr(str
,'/');
2526 str1
= strrchr(str
,'\\');
2531 if(*str1
== 'l' && *(str1
+1)== 'i' && *(str1
+2)=='b')
2533 remove info after
. */
2537 str2
= strrchr(str2
, '.');
2538 if(str2
!= NULL
) *str2
= '\0';
2540 lttv_module_require(str1
, &error
);
2542 lttv_library_load(str1
, &error
);
2543 if(error
!= NULL
) g_warning("%s", error
->message
);
2544 else g_info("Load library: %s\n", str
);
2546 case GTK_RESPONSE_REJECT
:
2547 case GTK_RESPONSE_CANCEL
:
2549 gtk_widget_destroy((GtkWidget
*)file_selector
);
2560 /* Display all loaded modules, let user to select a module to unload
2561 * by calling lttv_module_unload
2565 on_unload_library_activate (GtkMenuItem
*menuitem
,
2568 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2570 LttvLibrary
*library
= NULL
;
2575 name
= g_ptr_array_new();
2576 nb
= lttv_library_number();
2577 LttvLibraryInfo
*lib_info
= g_new(LttvLibraryInfo
,nb
);
2578 /* ask for the library name */
2581 LttvLibrary
*iter_lib
= lttv_library_get(i
);
2582 lttv_library_info(iter_lib
, &lib_info
[i
]);
2584 gchar
*path
= lib_info
[i
].name
;
2585 g_ptr_array_add(name
, path
);
2587 lib_name
= get_selection((char **)(name
->pdata
), name
->len
,
2588 "Select a library", "Libraries");
2589 if(lib_name
!= NULL
) {
2591 if(strcmp(lib_name
, lib_info
[i
].name
) == 0) {
2592 library
= lttv_library_get(i
);
2597 g_ptr_array_free(name
, TRUE
);
2600 if(lib_name
== NULL
) return;
2602 if(library
!= NULL
) lttv_library_unload(library
);
2606 /* Dispaly a file selection dialogue to let user select a module, then call
2607 * lttv_module_require().
2611 on_load_module_activate (GtkMenuItem
*menuitem
,
2614 GError
*error
= NULL
;
2615 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2617 LttvLibrary
*library
= NULL
;
2622 name
= g_ptr_array_new();
2623 nb
= lttv_library_number();
2624 LttvLibraryInfo
*lib_info
= g_new(LttvLibraryInfo
,nb
);
2625 /* ask for the library name */
2628 LttvLibrary
*iter_lib
= lttv_library_get(i
);
2629 lttv_library_info(iter_lib
, &lib_info
[i
]);
2631 gchar
*path
= lib_info
[i
].name
;
2632 g_ptr_array_add(name
, path
);
2634 lib_name
= get_selection((char **)(name
->pdata
), name
->len
,
2635 "Select a library", "Libraries");
2636 if(lib_name
!= NULL
) {
2638 if(strcmp(lib_name
, lib_info
[i
].name
) == 0) {
2639 library
= lttv_library_get(i
);
2644 g_ptr_array_free(name
, TRUE
);
2647 if(lib_name
== NULL
) return;
2650 //LttvModule *module;
2651 gchar module_name_out
[PATH_MAX
];
2653 /* Ask for the module to load : list modules in the selected lib */
2657 nb
= lttv_library_module_number(library
);
2658 LttvModuleInfo
*module_info
= g_new(LttvModuleInfo
,nb
);
2659 name
= g_ptr_array_new();
2660 /* ask for the module name */
2663 LttvModule
*iter_module
= lttv_library_module_get(library
, i
);
2664 lttv_module_info(iter_module
, &module_info
[i
]);
2666 gchar
*path
= module_info
[i
].name
;
2667 g_ptr_array_add(name
, path
);
2669 module_name
= get_selection((char **)(name
->pdata
), name
->len
,
2670 "Select a module", "Modules");
2671 if(module_name
!= NULL
) {
2673 if(strcmp(module_name
, module_info
[i
].name
) == 0) {
2674 strncpy(module_name_out
, module_name
, PATH_MAX
);
2675 //module = lttv_library_module_get(i);
2681 g_ptr_array_free(name
, TRUE
);
2682 g_free(module_info
);
2684 if(module_name
== NULL
) return;
2687 lttv_module_require(module_name_out
, &error
);
2688 if(error
!= NULL
) g_warning("%s", error
->message
);
2689 else g_info("Load module: %s", module_name_out
);
2696 gchar str
[PATH_MAX
];
2699 GtkFileSelection
* file_selector
=
2700 (GtkFileSelection
*)gtk_file_selection_new("Select a module");
2701 gtk_file_selection_set_filename(file_selector
, load_module_path_alter
);
2702 gtk_file_selection_hide_fileop_buttons(file_selector
);
2705 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
2707 case GTK_RESPONSE_ACCEPT
:
2708 case GTK_RESPONSE_OK
:
2709 dir
= gtk_file_selection_get_selections (file_selector
);
2710 strncpy(str
,dir
[0],PATH_MAX
);
2711 strncpy(remember_plugins_dir
,dir
[0],PATH_MAX
);
2713 /* only keep file name */
2715 str1
= strrchr(str
,'/');
2718 str1
= strrchr(str
,'\\');
2723 if(*str1
== 'l' && *(str1
+1)== 'i' && *(str1
+2)=='b')
2725 remove info after
. */
2729 str2
= strrchr(str2
, '.');
2730 if(str2
!= NULL
) *str2
= '\0';
2732 lttv_module_require(str1
, &error
);
2734 lttv_library_load(str1
, &error
);
2735 if(error
!= NULL
) g_warning(error
->message
);
2736 else g_info("Load library: %s\n", str
);
2738 case GTK_RESPONSE_REJECT
:
2739 case GTK_RESPONSE_CANCEL
:
2741 gtk_widget_destroy((GtkWidget
*)file_selector
);
2753 /* Display all loaded modules, let user to select a module to unload
2754 * by calling lttv_module_unload
2758 on_unload_module_activate (GtkMenuItem
*menuitem
,
2761 GError
*error
= NULL
;
2762 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2764 LttvLibrary
*library
;
2769 name
= g_ptr_array_new();
2770 nb
= lttv_library_number();
2771 LttvLibraryInfo
*lib_info
= g_new(LttvLibraryInfo
,nb
);
2772 /* ask for the library name */
2775 LttvLibrary
*iter_lib
= lttv_library_get(i
);
2776 lttv_library_info(iter_lib
, &lib_info
[i
]);
2778 gchar
*path
= lib_info
[i
].name
;
2779 g_ptr_array_add(name
, path
);
2781 lib_name
= get_selection((char **)(name
->pdata
), name
->len
,
2782 "Select a library", "Libraries");
2783 if(lib_name
!= NULL
) {
2785 if(strcmp(lib_name
, lib_info
[i
].name
) == 0) {
2786 library
= lttv_library_get(i
);
2791 g_ptr_array_free(name
, TRUE
);
2794 if(lib_name
== NULL
) return;
2797 LttvModule
*module
= NULL
;
2799 /* Ask for the module to load : list modules in the selected lib */
2803 nb
= lttv_library_module_number(library
);
2804 LttvModuleInfo
*module_info
= g_new(LttvModuleInfo
,nb
);
2805 name
= g_ptr_array_new();
2806 /* ask for the module name */
2809 LttvModule
*iter_module
= lttv_library_module_get(library
, i
);
2810 lttv_module_info(iter_module
, &module_info
[i
]);
2812 gchar
*path
= module_info
[i
].name
;
2813 if(module_info
[i
].use_count
> 0) g_ptr_array_add(name
, path
);
2815 module_name
= get_selection((char **)(name
->pdata
), name
->len
,
2816 "Select a module", "Modules");
2817 if(module_name
!= NULL
) {
2819 if(strcmp(module_name
, module_info
[i
].name
) == 0) {
2820 module
= lttv_library_module_get(library
, i
);
2826 g_ptr_array_free(name
, TRUE
);
2827 g_free(module_info
);
2829 if(module_name
== NULL
) return;
2832 LttvModuleInfo module_info
;
2833 lttv_module_info(module
, &module_info
);
2834 g_info("Release module: %s\n", module_info
.name
);
2836 lttv_module_release(module
);
2840 /* Display a directory dialogue to let user select a path for library searching
2844 on_add_library_search_path_activate (GtkMenuItem
*menuitem
,
2847 GtkDirSelection
* file_selector
= (GtkDirSelection
*)gtk_dir_selection_new("Select library path");
2851 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2852 if(remember_plugins_dir
[0] != '\0')
2853 gtk_dir_selection_set_filename(file_selector
, remember_plugins_dir
);
2855 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
2857 case GTK_RESPONSE_ACCEPT
:
2858 case GTK_RESPONSE_OK
:
2859 dir
= gtk_dir_selection_get_dir (file_selector
);
2860 strncpy(remember_plugins_dir
,dir
,PATH_MAX
);
2861 strncat(remember_plugins_dir
,"/",PATH_MAX
);
2862 lttv_library_path_add(dir
);
2863 case GTK_RESPONSE_REJECT
:
2864 case GTK_RESPONSE_CANCEL
:
2866 gtk_widget_destroy((GtkWidget
*)file_selector
);
2872 /* Display a directory dialogue to let user select a path for library searching
2876 on_remove_library_search_path_activate (GtkMenuItem
*menuitem
,
2879 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2881 const char *lib_path
;
2886 name
= g_ptr_array_new();
2887 nb
= lttv_library_path_number();
2888 /* ask for the library name */
2891 gchar
*path
= lttv_library_path_get(i
);
2892 g_ptr_array_add(name
, path
);
2894 lib_path
= get_selection((char **)(name
->pdata
), name
->len
,
2895 "Select a library path", "Library paths");
2897 g_ptr_array_free(name
, TRUE
);
2899 if(lib_path
== NULL
) return;
2902 lttv_library_path_remove(lib_path
);
2906 on_color_activate (GtkMenuItem
*menuitem
,
2914 on_save_configuration_activate (GtkMenuItem
*menuitem
,
2917 g_info("Save configuration\n");
2922 on_content_activate (GtkMenuItem
*menuitem
,
2925 g_info("Content\n");
2930 on_about_close_activate (GtkButton
*button
,
2933 GtkWidget
*about_widget
= GTK_WIDGET(user_data
);
2935 gtk_widget_destroy(about_widget
);
2939 on_about_activate (GtkMenuItem
*menuitem
,
2942 MainWindow
*main_window
= get_window_data_struct(GTK_WIDGET(menuitem
));
2943 GtkWidget
*window_widget
= main_window
->mwindow
;
2944 GtkWidget
*about_widget
= gtk_window_new(GTK_WINDOW_TOPLEVEL
);
2945 GtkWindow
*about_window
= GTK_WINDOW(about_widget
);
2946 gint window_width
, window_height
;
2948 gtk_window_set_title(about_window
, "About Linux Trace Toolkit");
2950 gtk_window_set_resizable(about_window
, FALSE
);
2951 gtk_window_set_transient_for(GTK_WINDOW(window_widget
), about_window
);
2952 gtk_window_set_destroy_with_parent(about_window
, TRUE
);
2953 gtk_window_set_modal(about_window
, FALSE
);
2955 /* Put the about window at the center of the screen */
2956 gtk_window_get_size(about_window
, &window_width
, &window_height
);
2957 gtk_window_move (about_window
,
2958 (gdk_screen_width() - window_width
)/2,
2959 (gdk_screen_height() - window_height
)/2);
2961 GtkWidget
*vbox
= gtk_vbox_new(FALSE
, 1);
2963 gtk_container_add(GTK_CONTAINER(about_widget
), vbox
);
2967 GtkWidget
*label1
= gtk_label_new("");
2968 gtk_misc_set_padding(GTK_MISC(label1
), 10, 20);
2969 gtk_label_set_markup(GTK_LABEL(label1
), "\
2970 <big>Linux Trace Toolkit</big>");
2971 gtk_label_set_justify(GTK_LABEL(label1
), GTK_JUSTIFY_CENTER
);
2973 GtkWidget
*label2
= gtk_label_new("");
2974 gtk_misc_set_padding(GTK_MISC(label2
), 10, 20);
2975 gtk_label_set_markup(GTK_LABEL(label2
), "\
2978 Michel Dagenais (New trace format, lttv main)\n\
2979 Mathieu Desnoyers (Directory structure, build with automake/conf,\n\
2980 lttv gui, control flow view, gui cooperative trace reading\n\
2981 scheduler with interruptible foreground and background\n\
2982 computation, detailed event list)\n\
2983 Benoit Des Ligneris, Eric Clement (Cluster adaptation, work in progress)\n\
2984 Xang-Xiu Yang (new trace reading library and converter, lttv gui, \n\
2985 detailed event list and statistics view)\n\
2986 Tom Zanussi (RelayFS)\n\
2988 Strongly inspired from the original Linux Trace Toolkit Visualizer made by\n\
2991 GtkWidget
*label3
= gtk_label_new("");
2992 gtk_label_set_markup(GTK_LABEL(label3
), "\
2993 Linux Trace Toolkit Viewer, Copyright (C) 2004\n\
2995 Mathieu Desnoyers\n\
2997 Linux Trace Toolkit comes with ABSOLUTELY NO WARRANTY.\n\
2998 This is free software, and you are welcome to redistribute it\n\
2999 under certain conditions. See COPYING for details.");
3000 gtk_misc_set_padding(GTK_MISC(label3
), 10, 20);
3002 gtk_box_pack_start_defaults(GTK_BOX(vbox
), label1
);
3003 gtk_box_pack_start_defaults(GTK_BOX(vbox
), label2
);
3004 gtk_box_pack_start_defaults(GTK_BOX(vbox
), label3
);
3006 GtkWidget
*hbox
= gtk_hbox_new(TRUE
, 0);
3007 gtk_box_pack_end(GTK_BOX(vbox
), hbox
, FALSE
, FALSE
, 0);
3008 GtkWidget
*close_button
= gtk_button_new_with_mnemonic("_Close");
3009 gtk_box_pack_end(GTK_BOX(hbox
), close_button
, FALSE
, FALSE
, 0);
3010 gtk_container_set_border_width(GTK_CONTAINER(close_button
), 20);
3012 g_signal_connect(G_OBJECT(close_button
), "clicked",
3013 G_CALLBACK(on_about_close_activate
),
3014 (gpointer
)about_widget
);
3016 gtk_widget_show_all(about_widget
);
3021 on_button_new_clicked (GtkButton
*button
,
3024 create_new_window((GtkWidget
*)button
, user_data
, TRUE
);
3028 on_button_new_tab_clicked (GtkButton
*button
,
3031 create_new_tab((GtkWidget
*)button
, user_data
);
3035 on_button_open_clicked (GtkButton
*button
,
3038 open_traceset((GtkWidget
*)button
, user_data
);
3043 on_button_add_trace_clicked (GtkButton
*button
,
3046 add_trace((GtkWidget
*)button
, user_data
);
3051 on_button_remove_trace_clicked (GtkButton
*button
,
3054 remove_trace((GtkWidget
*)button
, user_data
);
3058 on_button_redraw_clicked (GtkButton
*button
,
3061 redraw((GtkWidget
*)button
, user_data
);
3065 on_button_continue_processing_clicked (GtkButton
*button
,
3068 continue_processing((GtkWidget
*)button
, user_data
);
3072 on_button_stop_processing_clicked (GtkButton
*button
,
3075 stop_processing((GtkWidget
*)button
, user_data
);
3081 on_button_save_clicked (GtkButton
*button
,
3084 save((GtkWidget
*)button
, user_data
);
3089 on_button_save_as_clicked (GtkButton
*button
,
3092 save_as((GtkWidget
*)button
, user_data
);
3097 on_button_zoom_in_clicked (GtkButton
*button
,
3100 zoom_in((GtkWidget
*)button
, user_data
);
3105 on_button_zoom_out_clicked (GtkButton
*button
,
3108 zoom_out((GtkWidget
*)button
, user_data
);
3113 on_button_zoom_extended_clicked (GtkButton
*button
,
3116 zoom_extended((GtkWidget
*)button
, user_data
);
3121 on_button_go_to_time_clicked (GtkButton
*button
,
3124 go_to_time((GtkWidget
*)button
, user_data
);
3129 on_button_show_time_frame_clicked (GtkButton
*button
,
3132 show_time_frame((GtkWidget
*)button
, user_data
);
3137 on_button_move_up_clicked (GtkButton
*button
,
3140 move_up_viewer((GtkWidget
*)button
, user_data
);
3145 on_button_move_down_clicked (GtkButton
*button
,
3148 move_down_viewer((GtkWidget
*)button
, user_data
);
3153 on_button_delete_viewer_clicked (GtkButton
*button
,
3156 delete_viewer((GtkWidget
*)button
, user_data
);
3160 on_MWindow_destroy (GtkWidget
*widget
,
3163 MainWindow
*main_window
= get_window_data_struct(widget
);
3164 LttvIAttribute
*attributes
= main_window
->attributes
;
3165 LttvAttributeValue value
;
3167 //This is unnecessary, since widgets will be destroyed
3168 //by the main window widget anyway.
3169 //remove_all_menu_toolbar_constructors(main_window, NULL);
3171 g_assert(lttv_iattribute_find_by_path(attributes
,
3172 "viewers/menu", LTTV_POINTER
, &value
));
3173 lttv_menus_destroy((LttvMenus
*)*(value
.v_pointer
));
3175 g_assert(lttv_iattribute_find_by_path(attributes
,
3176 "viewers/toolbar", LTTV_POINTER
, &value
));
3177 lttv_toolbars_destroy((LttvToolbars
*)*(value
.v_pointer
));
3179 g_object_unref(main_window
->attributes
);
3180 g_main_window_list
= g_slist_remove(g_main_window_list
, main_window
);
3182 g_info("There are now : %d windows\n",g_slist_length(g_main_window_list
));
3183 if(g_slist_length(g_main_window_list
) == 0)
3188 on_MWindow_configure (GtkWidget
*widget
,
3189 GdkEventConfigure
*event
,
3192 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)widget
);
3194 // MD : removed time width modification upon resizing of the main window.
3195 // The viewers will redraw themselves completely, without time interval
3198 if(mw_data->window_width){
3199 time_span = LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->Time_Span ;
3200 time_win = tab->time_window;
3201 ratio = width / mw_data->window_width;
3202 tab->time_window.time_width = ltt_time_mul(time_win.time_width,ratio);
3203 time = ltt_time_sub(time_span->endTime, time_win.start_time);
3204 if(ltt_time_compare(time, tab->time_window.time_width) < 0){
3205 tab->time_window.time_width = time;
3211 mw_data->window_width = (int)width;
3220 on_MNotebook_switch_page (GtkNotebook
*notebook
,
3221 GtkNotebookPage
*page
,
3229 void time_change_manager (Tab
*tab
,
3230 TimeWindow new_time_window
)
3232 /* Only one source of time change */
3233 if(tab
->time_manager_lock
== TRUE
) return;
3235 tab
->time_manager_lock
= TRUE
;
3237 LttvTracesetContext
*tsc
= LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3238 TimeInterval time_span
= tsc
->time_span
;
3239 LttTime start_time
= new_time_window
.start_time
;
3240 LttTime end_time
= new_time_window
.end_time
;
3242 g_assert(ltt_time_compare(start_time
, end_time
) < 0);
3245 GtkAdjustment
*adjustment
= gtk_range_get_adjustment(GTK_RANGE(tab
->scrollbar
));
3246 LttTime upper
= ltt_time_sub(time_span
.end_time
, time_span
.start_time
);
3248 gtk_range_set_increments(GTK_RANGE(tab
->scrollbar
),
3249 ltt_time_to_double(new_time_window
.time_width
)
3250 / SCROLL_STEP_PER_PAGE
3251 * NANOSECONDS_PER_SECOND
, /* step increment */
3252 ltt_time_to_double(new_time_window
.time_width
)
3253 * NANOSECONDS_PER_SECOND
); /* page increment */
3254 gtk_range_set_range(GTK_RANGE(tab
->scrollbar
),
3256 ltt_time_to_double(upper
)
3257 * NANOSECONDS_PER_SECOND
); /* upper */
3259 g_object_set(G_OBJECT(adjustment
),
3263 ltt_time_to_double(upper
), /* upper */
3265 new_time_window
.time_width_double
3266 / SCROLL_STEP_PER_PAGE
, /* step increment */
3268 new_time_window
.time_width_double
,
3269 /* page increment */
3271 new_time_window
.time_width_double
, /* page size */
3273 gtk_adjustment_changed(adjustment
);
3275 // g_object_set(G_OBJECT(adjustment),
3277 // ltt_time_to_double(
3278 // ltt_time_sub(start_time, time_span.start_time))
3281 //gtk_adjustment_value_changed(adjustment);
3282 gtk_range_set_value(GTK_RANGE(tab
->scrollbar
),
3284 ltt_time_sub(start_time
, time_span
.start_time
)) /* value */);
3286 /* set the time bar. */
3288 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry1
),
3289 (double)time_span
.start_time
.tv_sec
,
3290 (double)time_span
.end_time
.tv_sec
);
3291 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry1
),
3292 (double)start_time
.tv_sec
);
3294 /* start nanoseconds */
3295 if(start_time
.tv_sec
== time_span
.start_time
.tv_sec
) {
3296 /* can be both beginning and end at the same time. */
3297 if(start_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3298 /* If we are at the end, max nsec to end.. -1 (not zero length) */
3299 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry2
),
3300 (double)time_span
.start_time
.tv_nsec
,
3301 (double)time_span
.end_time
.tv_nsec
-1);
3303 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry2
),
3304 (double)time_span
.start_time
.tv_nsec
,
3305 (double)NANOSECONDS_PER_SECOND
-1);
3307 } else if(start_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3308 /* If we are at the end, max nsec to end.. -1 (not zero length) */
3309 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry2
),
3311 (double)time_span
.end_time
.tv_nsec
-1);
3312 } else /* anywhere else */
3313 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry2
),
3315 (double)NANOSECONDS_PER_SECOND
-1);
3316 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry2
),
3317 (double)start_time
.tv_nsec
);
3320 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry3
),
3321 (double)time_span
.start_time
.tv_sec
,
3322 (double)time_span
.end_time
.tv_sec
);
3323 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry3
),
3324 (double)end_time
.tv_sec
);
3326 /* end nanoseconds */
3327 if(end_time
.tv_sec
== time_span
.start_time
.tv_sec
) {
3328 /* can be both beginning and end at the same time. */
3329 if(end_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3330 /* If we are at the end, max nsec to end.. */
3331 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry4
),
3332 (double)time_span
.start_time
.tv_nsec
+1,
3333 (double)time_span
.end_time
.tv_nsec
);
3335 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry4
),
3336 (double)time_span
.start_time
.tv_nsec
+1,
3337 (double)NANOSECONDS_PER_SECOND
-1);
3340 else if(end_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3341 /* If we are at the end, max nsec to end.. */
3342 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry4
),
3344 (double)time_span
.end_time
.tv_nsec
);
3346 else /* anywhere else */
3347 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry4
),
3349 (double)NANOSECONDS_PER_SECOND
-1);
3350 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry4
),
3351 (double)end_time
.tv_nsec
);
3353 /* call viewer hooks for new time window */
3354 set_time_window(tab
, &new_time_window
);
3356 tab
->time_manager_lock
= FALSE
;
3360 /* value changed for frame start s
3362 * Check time span : if ns is out of range, clip it the nearest good value.
3365 on_MEntry1_value_changed (GtkSpinButton
*spinbutton
,
3368 Tab
*tab
=(Tab
*)user_data
;
3369 LttvTracesetContext
* tsc
=
3370 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3371 TimeInterval time_span
= tsc
->time_span
;
3372 gint value
= gtk_spin_button_get_value_as_int(spinbutton
);
3374 TimeWindow new_time_window
= tab
->time_window
;
3376 LttTime end_time
= new_time_window
.end_time
;
3378 new_time_window
.start_time
.tv_sec
= value
;
3380 /* start nanoseconds */
3381 if(new_time_window
.start_time
.tv_sec
== time_span
.start_time
.tv_sec
) {
3382 if(new_time_window
.start_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3383 if(new_time_window
.start_time
.tv_nsec
> time_span
.end_time
.tv_nsec
)
3384 new_time_window
.start_time
.tv_nsec
= time_span
.end_time
.tv_nsec
-1;
3385 if(new_time_window
.start_time
.tv_nsec
< time_span
.start_time
.tv_nsec
)
3386 new_time_window
.start_time
.tv_nsec
= time_span
.start_time
.tv_nsec
;
3388 if(new_time_window
.start_time
.tv_nsec
< time_span
.start_time
.tv_nsec
)
3389 new_time_window
.start_time
.tv_nsec
= time_span
.start_time
.tv_nsec
;
3392 else if(new_time_window
.start_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3393 if(new_time_window
.start_time
.tv_nsec
> time_span
.end_time
.tv_nsec
)
3394 new_time_window
.start_time
.tv_nsec
= time_span
.end_time
.tv_nsec
-1;
3397 if(ltt_time_compare(new_time_window
.start_time
, end_time
) >= 0) {
3398 /* Then, we must push back end time : keep the same time width
3399 * if possible, else end traceset time */
3400 end_time
= LTT_TIME_MIN(ltt_time_add(new_time_window
.start_time
,
3401 new_time_window
.time_width
),
3402 time_span
.end_time
);
3405 /* Fix the time width to fit start time and end time */
3406 new_time_window
.time_width
= ltt_time_sub(end_time
,
3407 new_time_window
.start_time
);
3408 new_time_window
.time_width_double
=
3409 ltt_time_to_double(new_time_window
.time_width
);
3411 new_time_window
.end_time
= end_time
;
3413 time_change_manager(tab
, new_time_window
);
3418 on_MEntry2_value_changed (GtkSpinButton
*spinbutton
,
3421 Tab
*tab
=(Tab
*)user_data
;
3422 LttvTracesetContext
* tsc
=
3423 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3424 TimeInterval time_span
= tsc
->time_span
;
3425 gint value
= gtk_spin_button_get_value_as_int(spinbutton
);
3427 TimeWindow new_time_window
= tab
->time_window
;
3429 LttTime end_time
= new_time_window
.end_time
;
3431 new_time_window
.start_time
.tv_nsec
= value
;
3433 if(ltt_time_compare(new_time_window
.start_time
, end_time
) >= 0) {
3434 /* Then, we must push back end time : keep the same time width
3435 * if possible, else end traceset time */
3436 end_time
= LTT_TIME_MIN(ltt_time_add(new_time_window
.start_time
,
3437 new_time_window
.time_width
),
3438 time_span
.end_time
);
3441 /* Fix the time width to fit start time and end time */
3442 new_time_window
.time_width
= ltt_time_sub(end_time
,
3443 new_time_window
.start_time
);
3444 new_time_window
.time_width_double
=
3445 ltt_time_to_double(new_time_window
.time_width
);
3447 new_time_window
.end_time
= end_time
;
3449 time_change_manager(tab
, new_time_window
);
3454 on_MEntry3_value_changed (GtkSpinButton
*spinbutton
,
3457 Tab
*tab
=(Tab
*)user_data
;
3458 LttvTracesetContext
* tsc
=
3459 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3460 TimeInterval time_span
= tsc
->time_span
;
3461 gint value
= gtk_spin_button_get_value_as_int(spinbutton
);
3463 TimeWindow new_time_window
= tab
->time_window
;
3465 LttTime end_time
= new_time_window
.end_time
;
3467 end_time
.tv_sec
= value
;
3469 /* end nanoseconds */
3470 if(end_time
.tv_sec
== time_span
.start_time
.tv_sec
) {
3471 if(end_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3472 if(end_time
.tv_nsec
> time_span
.end_time
.tv_nsec
)
3473 end_time
.tv_nsec
= time_span
.end_time
.tv_nsec
;
3474 if(end_time
.tv_nsec
< time_span
.start_time
.tv_nsec
)
3475 end_time
.tv_nsec
= time_span
.start_time
.tv_nsec
+1;
3477 if(end_time
.tv_nsec
< time_span
.start_time
.tv_nsec
)
3478 end_time
.tv_nsec
= time_span
.start_time
.tv_nsec
+1;
3481 else if(end_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3482 if(end_time
.tv_nsec
> time_span
.end_time
.tv_nsec
)
3483 end_time
.tv_nsec
= time_span
.end_time
.tv_nsec
;
3486 if(ltt_time_compare(new_time_window
.start_time
, end_time
) >= 0) {
3487 /* Then, we must push front start time : keep the same time width
3488 * if possible, else end traceset time */
3489 new_time_window
.start_time
= LTT_TIME_MAX(
3490 ltt_time_sub(end_time
,
3491 new_time_window
.time_width
),
3492 time_span
.start_time
);
3495 /* Fix the time width to fit start time and end time */
3496 new_time_window
.time_width
= ltt_time_sub(end_time
,
3497 new_time_window
.start_time
);
3498 new_time_window
.time_width_double
=
3499 ltt_time_to_double(new_time_window
.time_width
);
3501 new_time_window
.end_time
= end_time
;
3503 time_change_manager(tab
, new_time_window
);
3508 on_MEntry4_value_changed (GtkSpinButton
*spinbutton
,
3511 Tab
*tab
=(Tab
*)user_data
;
3512 LttvTracesetContext
* tsc
=
3513 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3514 TimeInterval time_span
= tsc
->time_span
;
3515 gint value
= gtk_spin_button_get_value_as_int(spinbutton
);
3517 TimeWindow new_time_window
= tab
->time_window
;
3519 LttTime end_time
= new_time_window
.end_time
;
3521 end_time
.tv_nsec
= value
;
3523 if(ltt_time_compare(new_time_window
.start_time
, end_time
) >= 0) {
3524 /* Then, we must push front start time : keep the same time width
3525 * if possible, else end traceset time */
3526 new_time_window
.start_time
= LTT_TIME_MAX(
3527 ltt_time_sub(end_time
,
3528 new_time_window
.time_width
),
3529 time_span
.start_time
);
3532 /* Fix the time width to fit start time and end time */
3533 new_time_window
.time_width
= ltt_time_sub(end_time
,
3534 new_time_window
.start_time
);
3535 new_time_window
.time_width_double
=
3536 ltt_time_to_double(new_time_window
.time_width
);
3537 new_time_window
.end_time
= end_time
;
3539 time_change_manager(tab
, new_time_window
);
3544 void current_time_change_manager (Tab
*tab
,
3545 LttTime new_current_time
)
3547 /* Only one source of time change */
3548 if(tab
->current_time_manager_lock
== TRUE
) return;
3550 tab
->current_time_manager_lock
= TRUE
;
3552 LttvTracesetContext
*tsc
= LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3553 TimeInterval time_span
= tsc
->time_span
;
3555 /* current seconds */
3556 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry5
),
3557 (double)time_span
.start_time
.tv_sec
,
3558 (double)time_span
.end_time
.tv_sec
);
3559 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry5
),
3560 (double)new_current_time
.tv_sec
);
3563 /* start nanoseconds */
3564 if(new_current_time
.tv_sec
== time_span
.start_time
.tv_sec
) {
3565 /* can be both beginning and end at the same time. */
3566 if(new_current_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3567 /* If we are at the end, max nsec to end.. */
3568 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry6
),
3569 (double)time_span
.start_time
.tv_nsec
,
3570 (double)time_span
.end_time
.tv_nsec
);
3572 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry6
),
3573 (double)time_span
.start_time
.tv_nsec
,
3574 (double)NANOSECONDS_PER_SECOND
-1);
3576 } else if(new_current_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3577 /* If we are at the end, max nsec to end.. */
3578 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry6
),
3580 (double)time_span
.end_time
.tv_nsec
);
3581 } else /* anywhere else */
3582 gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab
->MEntry6
),
3584 (double)NANOSECONDS_PER_SECOND
-1);
3586 gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab
->MEntry6
),
3587 (double)new_current_time
.tv_nsec
);
3589 set_current_time(tab
, &new_current_time
);
3591 tab
->current_time_manager_lock
= FALSE
;
3594 void current_position_change_manager(Tab
*tab
,
3595 LttvTracesetContextPosition
*pos
)
3597 LttvTracesetContext
*tsc
=
3598 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3599 TimeInterval time_span
= tsc
->time_span
;
3601 g_assert(lttv_process_traceset_seek_position(tsc
, pos
) == 0);
3602 LttTime new_time
= lttv_traceset_context_position_get_time(pos
);
3604 current_time_change_manager(tab
, new_time
);
3606 set_current_position(tab
, pos
);
3611 on_MEntry5_value_changed (GtkSpinButton
*spinbutton
,
3614 Tab
*tab
= (Tab
*)user_data
;
3615 LttvTracesetContext
* tsc
=
3616 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3617 TimeInterval time_span
= tsc
->time_span
;
3618 gint value
= gtk_spin_button_get_value_as_int(spinbutton
);
3619 LttTime new_current_time
= tab
->current_time
;
3620 new_current_time
.tv_sec
= value
;
3622 /* current nanoseconds */
3623 if(new_current_time
.tv_sec
== time_span
.start_time
.tv_sec
) {
3624 if(new_current_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3625 if(new_current_time
.tv_nsec
> time_span
.end_time
.tv_nsec
)
3626 new_current_time
.tv_nsec
= time_span
.end_time
.tv_nsec
;
3627 if(new_current_time
.tv_nsec
< time_span
.start_time
.tv_nsec
)
3628 new_current_time
.tv_nsec
= time_span
.start_time
.tv_nsec
;
3630 if(new_current_time
.tv_nsec
< time_span
.start_time
.tv_nsec
)
3631 new_current_time
.tv_nsec
= time_span
.start_time
.tv_nsec
;
3634 else if(new_current_time
.tv_sec
== time_span
.end_time
.tv_sec
) {
3635 if(new_current_time
.tv_nsec
> time_span
.end_time
.tv_nsec
)
3636 new_current_time
.tv_nsec
= time_span
.end_time
.tv_nsec
;
3639 current_time_change_manager(tab
, new_current_time
);
3643 on_MEntry6_value_changed (GtkSpinButton
*spinbutton
,
3646 Tab
*tab
= (Tab
*)user_data
;
3647 gint value
= gtk_spin_button_get_value_as_int(spinbutton
);
3648 LttTime new_current_time
= tab
->current_time
;
3649 new_current_time
.tv_nsec
= value
;
3651 current_time_change_manager(tab
, new_current_time
);
3655 void scroll_value_changed_cb(GtkWidget
*scrollbar
,
3658 Tab
*tab
= (Tab
*)user_data
;
3659 TimeWindow new_time_window
;
3661 GtkAdjustment
*adjust
= gtk_range_get_adjustment(GTK_RANGE(scrollbar
));
3662 gdouble value
= gtk_adjustment_get_value(adjust
);
3663 // gdouble upper, lower, ratio, page_size;
3665 LttvTracesetContext
* tsc
=
3666 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
3667 TimeInterval time_span
= tsc
->time_span
;
3669 time
= ltt_time_add(ltt_time_from_double(value
),
3670 time_span
.start_time
);
3672 new_time_window
.start_time
= time
;
3674 page_size
= adjust
->page_size
;
3676 new_time_window
.time_width
=
3677 ltt_time_from_double(page_size
);
3679 new_time_window
.time_width_double
=
3682 new_time_window
.end_time
= ltt_time_add(new_time_window
.start_time
,
3683 new_time_window
.time_width
);
3686 time_change_manager(tab
, new_time_window
);
3688 //time_window = tab->time_window;
3690 lower
= adjust
->lower
;
3691 upper
= adjust
->upper
;
3692 ratio
= (value
- lower
) / (upper
- lower
);
3693 g_info("lower %lu, upper %lu, value %lu, ratio %lu", lower
, upper
, value
, ratio
);
3695 //time = ltt_time_sub(time_span->end_time, time_span->start_time);
3696 //time = ltt_time_mul(time, (float)ratio);
3697 //time = ltt_time_add(time_span->start_time, time);
3698 time
= ltt_time_add(ltt_time_from_double(value
),
3699 time_span
.start_time
);
3701 time_window
.start_time
= time
;
3703 page_size
= adjust
->page_size
;
3705 time_window
.time_width
=
3706 ltt_time_from_double(page_size
);
3707 //time = ltt_time_sub(time_span.end_time, time);
3708 //if(ltt_time_compare(time,time_window.time_width) < 0){
3709 // time_window.time_width = time;
3712 /* call viewer hooks for new time window */
3713 set_time_window(tab
, &time_window
);
3718 /* Display a dialogue showing all eventtypes and traces, let user to select the interested
3719 * eventtypes, tracefiles and traces (filter)
3722 /* Select a trace which will be removed from traceset
3725 char * get_remove_trace(char ** all_trace_name
, int nb_trace
)
3727 return get_selection(all_trace_name
, nb_trace
,
3728 "Select a trace", "Trace pathname");
3732 /* Select a module which will be loaded
3735 char * get_load_module(char ** load_module_name
, int nb_module
)
3737 return get_selection(load_module_name
, nb_module
,
3738 "Select a module to load", "Module name");
3744 /* Select a module which will be unloaded
3747 char * get_unload_module(char ** loaded_module_name
, int nb_module
)
3749 return get_selection(loaded_module_name
, nb_module
,
3750 "Select a module to unload", "Module name");
3754 /* Display a dialogue which shows all selectable items, let user to
3755 * select one of them
3758 char * get_selection(char ** loaded_module_name
, int nb_module
,
3759 char *title
, char * column_title
)
3761 GtkWidget
* dialogue
;
3762 GtkWidget
* scroll_win
;
3764 GtkListStore
* store
;
3765 GtkTreeViewColumn
* column
;
3766 GtkCellRenderer
* renderer
;
3767 GtkTreeSelection
* select
;
3770 char * unload_module_name
= NULL
;
3772 dialogue
= gtk_dialog_new_with_buttons(title
,
3775 GTK_STOCK_OK
,GTK_RESPONSE_ACCEPT
,
3776 GTK_STOCK_CANCEL
,GTK_RESPONSE_REJECT
,
3778 gtk_window_set_default_size((GtkWindow
*)dialogue
, 500, 200);
3780 scroll_win
= gtk_scrolled_window_new (NULL
, NULL
);
3781 gtk_widget_show ( scroll_win
);
3782 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win
),
3783 GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
3785 store
= gtk_list_store_new (N_COLUMNS
,G_TYPE_STRING
);
3786 tree
= gtk_tree_view_new_with_model(GTK_TREE_MODEL (store
));
3787 gtk_widget_show ( tree
);
3788 g_object_unref (G_OBJECT (store
));
3790 renderer
= gtk_cell_renderer_text_new ();
3791 column
= gtk_tree_view_column_new_with_attributes (column_title
,
3793 "text", MODULE_COLUMN
,
3795 gtk_tree_view_column_set_alignment (column
, 0.5);
3796 gtk_tree_view_column_set_fixed_width (column
, 150);
3797 gtk_tree_view_append_column (GTK_TREE_VIEW (tree
), column
);
3799 select
= gtk_tree_view_get_selection (GTK_TREE_VIEW (tree
));
3800 gtk_tree_selection_set_mode (select
, GTK_SELECTION_SINGLE
);
3802 gtk_container_add (GTK_CONTAINER (scroll_win
), tree
);
3804 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), scroll_win
,TRUE
, TRUE
,0);
3806 for(i
=0;i
<nb_module
;i
++){
3807 gtk_list_store_append (store
, &iter
);
3808 gtk_list_store_set (store
, &iter
, MODULE_COLUMN
,loaded_module_name
[i
],-1);
3811 id
= gtk_dialog_run(GTK_DIALOG(dialogue
));
3812 GtkTreeModel
**store_model
= (GtkTreeModel
**)&store
;
3814 case GTK_RESPONSE_ACCEPT
:
3815 case GTK_RESPONSE_OK
:
3816 if (gtk_tree_selection_get_selected (select
, store_model
, &iter
)){
3817 gtk_tree_model_get ((GtkTreeModel
*)store
, &iter
, MODULE_COLUMN
, &unload_module_name
, -1);
3819 case GTK_RESPONSE_REJECT
:
3820 case GTK_RESPONSE_CANCEL
:
3822 gtk_widget_destroy(dialogue
);
3826 return unload_module_name
;
3830 /* Insert all menu entry and tool buttons into this main window
3835 void add_all_menu_toolbar_constructors(MainWindow
* mw
, gpointer user_data
)
3839 lttvwindow_viewer_constructor constructor
;
3840 LttvMenus
* global_menu
, * instance_menu
;
3841 LttvToolbars
* global_toolbar
, * instance_toolbar
;
3842 LttvMenuClosure
*menu_item
;
3843 LttvToolbarClosure
*toolbar_item
;
3844 LttvAttributeValue value
;
3845 LttvIAttribute
*global_attributes
= LTTV_IATTRIBUTE(lttv_global_attributes());
3846 LttvIAttribute
*attributes
= mw
->attributes
;
3847 GtkWidget
* tool_menu_title_menu
, *new_widget
, *pixmap
;
3849 g_assert(lttv_iattribute_find_by_path(global_attributes
,
3850 "viewers/menu", LTTV_POINTER
, &value
));
3851 if(*(value
.v_pointer
) == NULL
)
3852 *(value
.v_pointer
) = lttv_menus_new();
3853 global_menu
= (LttvMenus
*)*(value
.v_pointer
);
3855 g_assert(lttv_iattribute_find_by_path(attributes
,
3856 "viewers/menu", LTTV_POINTER
, &value
));
3857 if(*(value
.v_pointer
) == NULL
)
3858 *(value
.v_pointer
) = lttv_menus_new();
3859 instance_menu
= (LttvMenus
*)*(value
.v_pointer
);
3863 g_assert(lttv_iattribute_find_by_path(global_attributes
,
3864 "viewers/toolbar", LTTV_POINTER
, &value
));
3865 if(*(value
.v_pointer
) == NULL
)
3866 *(value
.v_pointer
) = lttv_toolbars_new();
3867 global_toolbar
= (LttvToolbars
*)*(value
.v_pointer
);
3869 g_assert(lttv_iattribute_find_by_path(attributes
,
3870 "viewers/toolbar", LTTV_POINTER
, &value
));
3871 if(*(value
.v_pointer
) == NULL
)
3872 *(value
.v_pointer
) = lttv_toolbars_new();
3873 instance_toolbar
= (LttvToolbars
*)*(value
.v_pointer
);
3875 /* Add missing menu entries to window instance */
3876 for(i
=0;i
<global_menu
->len
;i
++) {
3877 menu_item
= &g_array_index(global_menu
, LttvMenuClosure
, i
);
3879 //add menu_item to window instance;
3880 constructor
= menu_item
->con
;
3881 tool_menu_title_menu
= lookup_widget(mw
->mwindow
,"ToolMenuTitle_menu");
3883 gtk_menu_item_new_with_mnemonic (menu_item
->menu_text
);
3884 gtk_container_add (GTK_CONTAINER (tool_menu_title_menu
),
3886 g_signal_connect ((gpointer
) new_widget
, "activate",
3887 G_CALLBACK (insert_viewer_wrap
),
3889 gtk_widget_show (new_widget
);
3890 lttv_menus_add(instance_menu
, menu_item
->con
,
3891 menu_item
->menu_path
,
3892 menu_item
->menu_text
,
3897 /* Add missing toolbar entries to window instance */
3898 for(i
=0;i
<global_toolbar
->len
;i
++) {
3899 toolbar_item
= &g_array_index(global_toolbar
, LttvToolbarClosure
, i
);
3901 //add toolbar_item to window instance;
3902 constructor
= toolbar_item
->con
;
3903 tool_menu_title_menu
= lookup_widget(mw
->mwindow
,"MToolbar1");
3904 pixbuf
= gdk_pixbuf_new_from_xpm_data((const char**)toolbar_item
->pixmap
);
3905 pixmap
= gtk_image_new_from_pixbuf(pixbuf
);
3907 gtk_toolbar_append_element (GTK_TOOLBAR (tool_menu_title_menu
),
3908 GTK_TOOLBAR_CHILD_BUTTON
,
3911 toolbar_item
->tooltip
, NULL
,
3912 pixmap
, NULL
, NULL
);
3913 gtk_label_set_use_underline(
3914 GTK_LABEL (((GtkToolbarChild
*) (
3915 g_list_last (GTK_TOOLBAR
3916 (tool_menu_title_menu
)->children
)->data
))->label
),
3918 gtk_container_set_border_width (GTK_CONTAINER (new_widget
), 1);
3919 g_signal_connect ((gpointer
) new_widget
,
3921 G_CALLBACK (insert_viewer_wrap
),
3923 gtk_widget_show (new_widget
);
3925 lttv_toolbars_add(instance_toolbar
, toolbar_item
->con
,
3926 toolbar_item
->tooltip
,
3927 toolbar_item
->pixmap
,
3935 /* Create a main window
3938 void construct_main_window(MainWindow
* parent
)
3940 g_debug("construct_main_window()");
3941 GtkWidget
* new_window
; /* New generated main window */
3942 MainWindow
* new_m_window
;/* New main window structure */
3943 GtkNotebook
* notebook
;
3944 LttvIAttribute
*attributes
=
3945 LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
));
3946 LttvAttributeValue value
;
3949 new_m_window
= g_new(MainWindow
, 1);
3951 // Add the object's information to the module's array
3952 g_main_window_list
= g_slist_append(g_main_window_list
, new_m_window
);
3954 new_window
= create_MWindow();
3955 gtk_widget_show (new_window
);
3957 new_m_window
->mwindow
= new_window
;
3958 new_m_window
->attributes
= attributes
;
3960 g_assert(lttv_iattribute_find_by_path(attributes
,
3961 "viewers/menu", LTTV_POINTER
, &value
));
3962 *(value
.v_pointer
) = lttv_menus_new();
3964 g_assert(lttv_iattribute_find_by_path(attributes
,
3965 "viewers/toolbar", LTTV_POINTER
, &value
));
3966 *(value
.v_pointer
) = lttv_toolbars_new();
3968 add_all_menu_toolbar_constructors(new_m_window
, NULL
);
3970 g_object_set_data_full(G_OBJECT(new_window
),
3972 (gpointer
)new_m_window
,
3973 (GDestroyNotify
)g_free
);
3974 //create a default tab
3975 notebook
= (GtkNotebook
*)lookup_widget(new_m_window
->mwindow
, "MNotebook");
3976 if(notebook
== NULL
){
3977 g_info("Notebook does not exist\n");
3980 //gtk_notebook_popup_enable (GTK_NOTEBOOK(notebook));
3981 //for now there is no name field in LttvTraceset structure
3982 //Use "Traceset" as the label for the default tab
3984 GtkWidget
* parent_notebook
= lookup_widget(parent
->mwindow
, "MNotebook");
3985 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(parent_notebook
),
3986 gtk_notebook_get_current_page(GTK_NOTEBOOK(parent_notebook
)));
3992 parent_tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
3994 new_tab
= create_tab(new_m_window
, parent_tab
, notebook
, "Traceset");
3996 new_tab
= create_tab(new_m_window
, NULL
, notebook
, "Traceset");
3997 /* First window, use command line trace */
3998 if(g_init_trace
!= NULL
){
3999 lttvwindow_add_trace(new_tab
,
4003 LttvTraceset
*traceset
= new_tab
->traceset_info
->traceset
;
4004 SetTraceset(new_tab
, traceset
);
4006 /* Insert default viewers */
4008 LttvAttributeType type
;
4009 LttvAttributeName name
;
4010 LttvAttributeValue value
;
4011 LttvAttribute
*attribute
;
4013 LttvIAttribute
*attributes_global
=
4014 LTTV_IATTRIBUTE(lttv_global_attributes());
4016 g_assert(attribute
=
4017 LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
4018 LTTV_IATTRIBUTE(attributes_global
),
4019 LTTV_VIEWER_CONSTRUCTORS
)));
4021 name
= g_quark_from_string("guievents");
4022 type
= lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute
),
4024 if(type
== LTTV_POINTER
) {
4025 lttvwindow_viewer_constructor viewer_constructor
=
4026 (lttvwindow_viewer_constructor
)*value
.v_pointer
;
4027 insert_viewer(new_window
, viewer_constructor
);
4030 name
= g_quark_from_string("guicontrolflow");
4031 type
= lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute
),
4033 if(type
== LTTV_POINTER
) {
4034 lttvwindow_viewer_constructor viewer_constructor
=
4035 (lttvwindow_viewer_constructor
)*value
.v_pointer
;
4036 insert_viewer(new_window
, viewer_constructor
);
4039 name
= g_quark_from_string("guistatistics");
4040 type
= lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute
),
4042 if(type
== LTTV_POINTER
) {
4043 lttvwindow_viewer_constructor viewer_constructor
=
4044 (lttvwindow_viewer_constructor
)*value
.v_pointer
;
4045 insert_viewer(new_window
, viewer_constructor
);
4051 g_info("There are now : %d windows\n",g_slist_length(g_main_window_list
));
4055 /* Free the memory occupied by a tab structure
4059 void tab_destructor(Tab
* tab
)
4061 int i
, nb
, ref_count
;
4064 gtk_object_destroy(GTK_OBJECT(tab
->tooltips
));
4067 g_object_unref(tab
->attributes
);
4069 if(tab
->interrupted_state
)
4070 g_object_unref(tab
->interrupted_state
);
4073 if(tab
->traceset_info
->traceset_context
!= NULL
){
4074 //remove state update hooks
4075 lttv_state_remove_event_hooks(
4076 (LttvTracesetState
*)tab
->traceset_info
->
4078 lttv_context_fini(LTTV_TRACESET_CONTEXT(tab
->traceset_info
->
4080 g_object_unref(tab
->traceset_info
->traceset_context
);
4082 if(tab
->traceset_info
->traceset
!= NULL
) {
4083 nb
= lttv_traceset_number(tab
->traceset_info
->traceset
);
4084 for(i
= 0 ; i
< nb
; i
++) {
4085 trace
= lttv_traceset_get(tab
->traceset_info
->traceset
, i
);
4086 ref_count
= lttv_trace_get_ref_number(trace
);
4088 ltt_trace_close(lttv_trace(trace
));
4092 lttv_filter_destroy(tab
->filter
);
4093 lttv_traceset_destroy(tab
->traceset_info
->traceset
);
4094 /* Remove the idle events requests processing function of the tab */
4095 g_idle_remove_by_data(tab
);
4097 g_slist_free(tab
->events_requests
);
4098 g_free(tab
->traceset_info
);
4103 /* Create a tab and insert it into the current main window
4106 Tab
* create_tab(MainWindow
* mw
, Tab
*copy_tab
,
4107 GtkNotebook
* notebook
, char * label
)
4112 //create a new tab data structure
4115 //construct and initialize the traceset_info
4116 tab
->traceset_info
= g_new(TracesetInfo
,1);
4119 tab
->traceset_info
->traceset
=
4120 lttv_traceset_copy(copy_tab
->traceset_info
->traceset
);
4122 /* Copy the previous tab's filter */
4123 /* We can clone the filter, as we copy the trace set also */
4124 /* The filter must always be in sync with the trace set */
4125 tab
->filter
= lttv_filter_clone(copy_tab
->filter
);
4127 tab
->traceset_info
->traceset
= lttv_traceset_new();
4131 lttv_attribute_write_xml(
4132 lttv_traceset_attribute(tab
->traceset_info
->traceset
),
4138 tab
->time_manager_lock
= FALSE
;
4139 tab
->current_time_manager_lock
= FALSE
;
4141 //FIXME copy not implemented in lower level
4142 tab
->traceset_info
->traceset_context
=
4143 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
4144 g_assert(tab
->traceset_info
->traceset_context
!= NULL
);
4146 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
),
4147 tab
->traceset_info
->traceset
);
4148 //add state update hooks
4149 lttv_state_add_event_hooks(
4150 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
4152 //determine the current_time and time_window of the tab
4154 if(copy_tab
!= NULL
){
4155 tab
->time_window
= copy_tab
->time_window
;
4156 tab
->current_time
= copy_tab
->current_time
;
4158 tab
->time_window
.start_time
=
4159 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
4160 time_span
.start_time
;
4161 if(DEFAULT_TIME_WIDTH_S
<
4162 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
4163 time_span
.end_time
.tv_sec
)
4164 tmp_time
.tv_sec
= DEFAULT_TIME_WIDTH_S
;
4167 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
4168 time_span
.end_time
.tv_sec
;
4169 tmp_time
.tv_nsec
= 0;
4170 tab
->time_window
.time_width
= tmp_time
;
4171 tab
->current_time
.tv_sec
=
4172 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
4173 time_span
.start_time
.tv_sec
;
4174 tab
->current_time
.tv_nsec
=
4175 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
4176 time_span
.start_time
.tv_nsec
;
4179 tab
->attributes
= LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
));
4180 tab
->interrupted_state
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
4182 tab
->vbox
= gtk_vbox_new(FALSE
, 2);
4183 tab
->viewer_container
= gtk_vbox_new(TRUE
, 2);
4184 tab
->scrollbar
= gtk_hscrollbar_new(NULL
);
4185 //tab->multivpaned = gtk_multi_vpaned_new();
4187 gtk_box_pack_start(GTK_BOX(tab
->vbox
),
4188 tab
->viewer_container
,
4190 TRUE
, /* Give the extra space to the child */
4191 0); /* No padding */
4194 // tab->time_window = copy_tab->time_window;
4195 // tab->current_time = copy_tab->current_time;
4198 /* Create the timebar */
4200 tab
->MTimebar
= gtk_hbox_new(FALSE
, 2);
4201 gtk_widget_show(tab
->MTimebar
);
4202 tab
->tooltips
= gtk_tooltips_new();
4204 tab
->MEventBox1a
= gtk_event_box_new();
4205 gtk_widget_show(tab
->MEventBox1a
);
4206 gtk_tooltips_set_tip(tab
->tooltips
, tab
->MEventBox1a
,
4207 "Paste Start and End Times Here", "");
4208 tab
->MText1a
= gtk_label_new("Time Frame ");
4209 gtk_widget_show(tab
->MText1a
);
4210 gtk_container_add(GTK_CONTAINER(tab
->MEventBox1a
), tab
->MText1a
);
4211 tab
->MEventBox1b
= gtk_event_box_new();
4212 gtk_widget_show(tab
->MEventBox1b
);
4213 gtk_tooltips_set_tip(tab
->tooltips
, tab
->MEventBox1b
,
4214 "Paste Start Time Here", "");
4215 tab
->MText1b
= gtk_label_new("start: ");
4216 gtk_widget_show(tab
->MText1b
);
4217 gtk_container_add(GTK_CONTAINER(tab
->MEventBox1b
), tab
->MText1b
);
4218 tab
->MText2
= gtk_label_new("s");
4219 gtk_widget_show(tab
->MText2
);
4220 tab
->MText3a
= gtk_label_new("ns");
4221 gtk_widget_show(tab
->MText3a
);
4222 tab
->MEventBox3b
= gtk_event_box_new();
4223 gtk_widget_show(tab
->MEventBox3b
);
4224 gtk_tooltips_set_tip(tab
->tooltips
, tab
->MEventBox3b
,
4225 "Paste End Time Here", "");
4226 tab
->MText3b
= gtk_label_new("end:");
4227 gtk_widget_show(tab
->MText3b
);
4228 gtk_container_add(GTK_CONTAINER(tab
->MEventBox3b
), tab
->MText3b
);
4229 tab
->MText4
= gtk_label_new("s");
4230 gtk_widget_show(tab
->MText4
);
4231 tab
->MText5a
= gtk_label_new("ns");
4232 gtk_widget_show(tab
->MText5a
);
4233 tab
->MEventBox5b
= gtk_event_box_new();
4234 gtk_widget_show(tab
->MEventBox5b
);
4235 gtk_tooltips_set_tip(tab
->tooltips
, tab
->MEventBox5b
,
4236 "Paste Current Time Here", "");
4237 tab
->MText5b
= gtk_label_new("Current Time:");
4238 gtk_widget_show(tab
->MText5b
);
4239 gtk_container_add(GTK_CONTAINER(tab
->MEventBox5b
), tab
->MText5b
);
4240 tab
->MText6
= gtk_label_new("s");
4241 gtk_widget_show(tab
->MText6
);
4242 tab
->MText7
= gtk_label_new("ns");
4243 gtk_widget_show(tab
->MText7
);
4245 tab
->MEntry1
= gtk_spin_button_new_with_range(0.0, 1.0, 1.0);
4246 gtk_spin_button_set_digits(GTK_SPIN_BUTTON(tab
->MEntry1
),0);
4247 gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(tab
->MEntry1
),TRUE
);
4248 gtk_widget_show(tab
->MEntry1
);
4249 tab
->MEntry2
= gtk_spin_button_new_with_range(0.0, 1.0, 1.0);
4250 gtk_spin_button_set_digits(GTK_SPIN_BUTTON(tab
->MEntry2
),0);
4251 gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(tab
->MEntry2
),TRUE
);
4252 gtk_widget_show(tab
->MEntry2
);
4253 tab
->MEntry3
= gtk_spin_button_new_with_range(0.0, 1.0, 1.0);
4254 gtk_spin_button_set_digits(GTK_SPIN_BUTTON(tab
->MEntry3
),0);
4255 gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(tab
->MEntry3
),TRUE
);
4256 gtk_widget_show(tab
->MEntry3
);
4257 tab
->MEntry4
= gtk_spin_button_new_with_range(0.0, 1.0, 1.0);
4258 gtk_spin_button_set_digits(GTK_SPIN_BUTTON(tab
->MEntry4
),0);
4259 gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(tab
->MEntry4
),TRUE
);
4260 gtk_widget_show(tab
->MEntry4
);
4261 tab
->MEntry5
= gtk_spin_button_new_with_range(0.0, 1.0, 1.0);
4262 gtk_spin_button_set_digits(GTK_SPIN_BUTTON(tab
->MEntry5
),0);
4263 gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(tab
->MEntry5
),TRUE
);
4264 gtk_widget_show(tab
->MEntry5
);
4265 tab
->MEntry6
= gtk_spin_button_new_with_range(0.0, 1.0, 1.0);
4266 gtk_spin_button_set_digits(GTK_SPIN_BUTTON(tab
->MEntry6
),0);
4267 gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(tab
->MEntry6
),TRUE
);
4268 gtk_widget_show(tab
->MEntry6
);
4271 GtkWidget
*temp_widget
;
4273 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MEventBox1a
, FALSE
,
4275 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MEventBox1b
, FALSE
,
4277 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MEntry1
, FALSE
, FALSE
, 0);
4278 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MText2
, FALSE
, FALSE
, 0);
4279 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MEntry2
, FALSE
, FALSE
, 0);
4280 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MText3a
, FALSE
, FALSE
, 0);
4281 temp_widget
= gtk_vseparator_new();
4282 gtk_widget_show(temp_widget
);
4283 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), temp_widget
, FALSE
, FALSE
, 0);
4284 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MEventBox3b
, FALSE
,
4286 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MEntry3
, FALSE
, FALSE
, 0);
4287 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MText4
, FALSE
, FALSE
, 0);
4288 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MEntry4
, FALSE
, FALSE
, 0);
4289 gtk_box_pack_start (GTK_BOX (tab
->MTimebar
), tab
->MText5a
, FALSE
, FALSE
, 0);
4290 temp_widget
= gtk_vseparator_new();
4291 gtk_widget_show(temp_widget
);
4292 gtk_box_pack_end (GTK_BOX (tab
->MTimebar
), tab
->MText7
, FALSE
, FALSE
, 0);
4293 gtk_box_pack_end (GTK_BOX (tab
->MTimebar
), tab
->MEntry6
, FALSE
, FALSE
, 0);
4294 gtk_box_pack_end (GTK_BOX (tab
->MTimebar
), tab
->MText6
, FALSE
, FALSE
, 0);
4295 gtk_box_pack_end (GTK_BOX (tab
->MTimebar
), tab
->MEntry5
, FALSE
, FALSE
, 0);
4296 gtk_box_pack_end (GTK_BOX (tab
->MTimebar
), tab
->MEventBox5b
, FALSE
,
4298 gtk_box_pack_end (GTK_BOX (tab
->MTimebar
), temp_widget
, FALSE
, FALSE
, 0);
4301 //GtkWidget *test = gtk_button_new_with_label("drop");
4302 //gtk_button_set_relief(GTK_BUTTON(test), GTK_RELIEF_NONE);
4303 //gtk_widget_show(test);
4304 //gtk_box_pack_end(GTK_BOX (tab->MTimebar), test, FALSE, FALSE, 0);
4305 //gtk_widget_add_events(tab->MText1, GDK_ALL_EVENTS_MASK);//GDK_BUTTON_PRESS_MASK);
4306 /*GtkWidget *event_box = gtk_event_box_new();
4307 gtk_widget_show(event_box);
4308 gtk_tooltips_set_tip(tooltips, event_box,
4309 "Paste Current Time Here", "");
4310 gtk_box_pack_end(GTK_BOX (tab->MTimebar), event_box, FALSE, FALSE, 0);
4311 GtkWidget *test = gtk_label_new("drop");
4312 gtk_container_add(GTK_CONTAINER(event_box), test);
4313 gtk_widget_show(test);
4314 g_signal_connect (G_OBJECT(event_box),
4315 "button-press-event",
4316 G_CALLBACK (on_MText1_paste),
4320 g_signal_connect (G_OBJECT(tab
->MEventBox1a
),
4321 "button-press-event",
4322 G_CALLBACK (on_MEventBox1a_paste
),
4325 g_signal_connect (G_OBJECT(tab
->MEventBox1b
),
4326 "button-press-event",
4327 G_CALLBACK (on_MEventBox1b_paste
),
4329 g_signal_connect (G_OBJECT(tab
->MEventBox3b
),
4330 "button-press-event",
4331 G_CALLBACK (on_MEventBox3b_paste
),
4333 g_signal_connect (G_OBJECT(tab
->MEventBox5b
),
4334 "button-press-event",
4335 G_CALLBACK (on_MEventBox5b_paste
),
4339 gtk_box_pack_end(GTK_BOX(tab
->vbox
),
4341 FALSE
, /* Do not expand */
4342 FALSE
, /* Fill has no effect here (expand false) */
4343 0); /* No padding */
4345 gtk_box_pack_end(GTK_BOX(tab
->vbox
),
4347 FALSE
, /* Do not expand */
4348 FALSE
, /* Fill has no effect here (expand false) */
4349 0); /* No padding */
4351 g_object_set_data(G_OBJECT(tab
->viewer_container
), "focused_viewer", NULL
);
4357 // Display a label with a X
4358 GtkWidget *w_hbox = gtk_hbox_new(FALSE, 4);
4359 GtkWidget *w_label = gtk_label_new (label);
4360 GtkWidget *pixmap = create_pixmap(GTK_WIDGET(notebook), "close.png");
4361 GtkWidget *w_button = gtk_button_new ();
4362 gtk_container_add(GTK_CONTAINER(w_button), pixmap);
4363 //GtkWidget *w_button = gtk_button_new_with_label("x");
4365 gtk_button_set_relief(GTK_BUTTON(w_button), GTK_RELIEF_NONE);
4367 gtk_box_pack_start(GTK_BOX(w_hbox), w_label, TRUE, TRUE, 0);
4368 gtk_box_pack_end(GTK_BOX(w_hbox), w_button, FALSE,
4371 g_signal_connect_swapped (w_button, "clicked",
4372 G_CALLBACK (on_close_tab_X_clicked),
4375 gtk_widget_set_state(w_button, GTK_STATE_ACTIVE);
4377 gtk_widget_show (w_label);
4378 gtk_widget_show (pixmap);
4379 gtk_widget_show (w_button);
4380 gtk_widget_show (w_hbox);
4382 tab->label = w_hbox;
4386 tab
->label
= gtk_label_new (label
);
4388 gtk_widget_show(tab
->label
);
4389 gtk_widget_show(tab
->scrollbar
);
4390 gtk_widget_show(tab
->viewer_container
);
4391 gtk_widget_show(tab
->vbox
);
4392 //gtk_widget_show(tab->multivpaned);
4395 /* Start with empty events requests list */
4396 tab
->events_requests
= NULL
;
4397 tab
->events_request_pending
= FALSE
;
4399 g_object_set_data_full(
4400 G_OBJECT(tab
->vbox
),
4403 (GDestroyNotify
)tab_destructor
);
4405 g_signal_connect(G_OBJECT(tab
->scrollbar
), "value-changed",
4406 G_CALLBACK(scroll_value_changed_cb
), tab
);
4408 g_signal_connect ((gpointer
) tab
->MEntry1
, "value-changed",
4409 G_CALLBACK (on_MEntry1_value_changed
),
4411 g_signal_connect ((gpointer
) tab
->MEntry2
, "value-changed",
4412 G_CALLBACK (on_MEntry2_value_changed
),
4414 g_signal_connect ((gpointer
) tab
->MEntry3
, "value-changed",
4415 G_CALLBACK (on_MEntry3_value_changed
),
4417 g_signal_connect ((gpointer
) tab
->MEntry4
, "value-changed",
4418 G_CALLBACK (on_MEntry4_value_changed
),
4420 g_signal_connect ((gpointer
) tab
->MEntry5
, "value-changed",
4421 G_CALLBACK (on_MEntry5_value_changed
),
4423 g_signal_connect ((gpointer
) tab
->MEntry6
, "value-changed",
4424 G_CALLBACK (on_MEntry6_value_changed
),
4427 //g_signal_connect(G_OBJECT(tab->scrollbar), "changed",
4428 // G_CALLBACK(scroll_value_changed_cb), tab);
4431 //insert tab into notebook
4432 gtk_notebook_append_page(notebook
,
4435 list
= gtk_container_get_children(GTK_CONTAINER(notebook
));
4436 gtk_notebook_set_current_page(notebook
,g_list_length(list
)-1);
4437 // always show : not if(g_list_length(list)>1)
4438 gtk_notebook_set_show_tabs(notebook
, TRUE
);
4441 lttvwindow_report_time_window(tab
, copy_tab
->time_window
);
4442 lttvwindow_report_current_time(tab
, copy_tab
->current_time
);
4444 TimeWindow time_window
;
4446 time_window
.start_time
= ltt_time_zero
;
4447 time_window
.end_time
= ltt_time_add(time_window
.start_time
,
4448 lttvwindow_default_time_width
);
4449 time_window
.time_width
= lttvwindow_default_time_width
;
4450 time_window
.time_width_double
= ltt_time_to_double(time_window
.time_width
);
4452 lttvwindow_report_time_window(tab
, time_window
);
4453 lttvwindow_report_current_time(tab
, ltt_time_zero
);
4456 LttvTraceset
*traceset
= tab
->traceset_info
->traceset
;
4457 SetTraceset(tab
, traceset
);
4463 * execute_events_requests
4465 * Idle function that executes the pending requests for a tab.
4467 * @return return value : TRUE : keep the idle function, FALSE : remove it.
4469 gboolean
execute_events_requests(Tab
*tab
)
4471 return ( lttvwindow_process_pending_requests(tab
) );