1 /* This file is part of the Linux Trace Toolkit viewer
2 * Copyright (C) 2003-2004 XangXiu Yang
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,
25 #include "callbacks.h"
26 #include "interface.h"
28 #include <lttv/lttv.h>
29 #include <lttvwindow/mainwindow.h>
30 #include <lttvwindow/menu.h>
31 #include <lttvwindow/toolbar.h>
32 #include <lttvwindow/viewer.h>
33 #include <lttv/module.h>
34 #include <lttvwindow/gtkdirsel.h>
35 #include <lttv/iattribute.h>
36 #include <lttvwindow/lttvfilter.h>
37 #include <ltt/trace.h>
38 #include <ltt/facility.h>
40 #define PATH_LENGTH 256
41 #define DEFAULT_TIME_WIDTH_S 1
43 extern LttvTrace
*g_init_trace
;
46 /** Array containing instanced objects. */
47 extern GSList
* g_main_window_list
;
49 static int g_win_count
= 0;
51 // MD : keep old directory
52 static char remember_plugins_dir
[PATH_LENGTH
] = "";
53 static char remember_trace_dir
[PATH_LENGTH
] = "";
56 MainWindow
* get_window_data_struct(GtkWidget
* widget
);
57 char * get_unload_module(char ** loaded_module_name
, int nb_module
);
58 char * get_remove_trace(char ** all_trace_name
, int nb_trace
);
59 char * get_selection(char ** all_name
, int nb
, char *title
, char * column_title
);
60 gboolean
get_filter_selection(LttvTracesetSelector
*s
, char *title
, char * column_title
);
61 void * create_tab(MainWindow
* parent
, MainWindow
* current_window
,
62 GtkNotebook
* notebook
, char * label
);
64 void insert_viewer(GtkWidget
* widget
, lttvwindow_viewer_constructor constructor
);
65 void update_filter(LttvTracesetSelector
*s
, GtkTreeStore
*store
);
67 void checkbox_changed(GtkTreeView
*treeview
,
69 GtkTreeViewColumn
*arg2
,
71 void remove_trace_from_traceset_selector(GtkMultiVPaned
* paned
, unsigned i
);
72 void add_trace_into_traceset_selector(GtkMultiVPaned
* paned
, LttTrace
* trace
);
74 LttvTracesetSelector
* construct_traceset_selector(LttvTraceset
* traceset
);
76 void redraw_viewer(MainWindow
* mw_data
, TimeWindow
* time_window
);
77 unsigned get_max_event_number(MainWindow
* mw_data
);
91 /* Construct a selector(filter), which will be associated with a viewer,
92 * and provides an interface for user to select interested events and traces
95 LttvTracesetSelector
* construct_traceset_selector(LttvTraceset
* traceset
)
97 LttvTracesetSelector
* s
;
98 LttvTraceSelector
* trace
;
99 LttvTracefileSelector
* tracefile
;
100 LttvEventtypeSelector
* eventtype
;
102 int nb_trace
, nb_tracefile
, nb_control
, nb_per_cpu
, nb_facility
, nb_event
;
109 s
= lttv_traceset_selector_new(lttv_traceset_name(traceset
));
110 nb_trace
= lttv_traceset_number(traceset
);
111 for(i
=0;i
<nb_trace
;i
++){
112 trace_v
= lttv_traceset_get(traceset
, i
);
113 t
= lttv_trace(trace_v
);
114 trace
= lttv_trace_selector_new(t
);
115 lttv_traceset_selector_trace_add(s
, trace
);
117 nb_facility
= ltt_trace_facility_number(t
);
118 for(k
=0;k
<nb_facility
;k
++){
119 fac
= ltt_trace_facility_get(t
,k
);
120 nb_event
= (int) ltt_facility_eventtype_number(fac
);
121 for(m
=0;m
<nb_event
;m
++){
122 et
= ltt_facility_eventtype_get(fac
,m
);
123 eventtype
= lttv_eventtype_selector_new(et
);
124 lttv_trace_selector_eventtype_add(trace
, eventtype
);
128 nb_control
= ltt_trace_control_tracefile_number(t
);
129 nb_per_cpu
= ltt_trace_per_cpu_tracefile_number(t
);
130 nb_tracefile
= nb_control
+ nb_per_cpu
;
132 for(j
= 0 ; j
< nb_tracefile
; j
++) {
134 tf
= ltt_trace_control_tracefile_get(t
, j
);
136 tf
= ltt_trace_per_cpu_tracefile_get(t
, j
- nb_control
);
137 tracefile
= lttv_tracefile_selector_new(tf
);
138 lttv_trace_selector_tracefile_add(trace
, tracefile
);
139 lttv_eventtype_selector_copy(trace
, tracefile
);
146 /* insert_viewer function constructs an instance of a viewer first,
147 * then inserts the widget of the instance into the container of the
152 insert_viewer_wrap(GtkWidget
*menuitem
, gpointer user_data
)
156 insert_viewer((GtkWidget
*)menuitem
, (lttvwindow_viewer_constructor
)user_data
);
157 // selected_hook(&val);
161 /* internal functions */
162 void insert_viewer(GtkWidget
* widget
, lttvwindow_viewer_constructor constructor
)
164 GtkMultiVPaned
* multi_vpaned
;
165 MainWindow
* mw_data
;
167 LttvTracesetSelector
* s
;
168 TimeInterval
* time_interval
;
169 TimeWindow time_window
, t
;
171 mw_data
= get_window_data_struct(widget
);
172 if(!mw_data
->current_tab
) return;
173 multi_vpaned
= mw_data
->current_tab
->multi_vpaned
;
175 s
= construct_traceset_selector(mw_data
->current_tab
->traceset_info
->traceset
);
176 viewer
= (GtkWidget
*)constructor(mw_data
, s
, "Traceset_Selector");
179 gtk_multi_vpaned_widget_add(multi_vpaned
, viewer
);
181 // g_object_unref(G_OBJECT(viewer));
183 time_window
= mw_data
->current_tab
->time_window
;
184 time_interval
= (TimeInterval
*)g_object_get_data(G_OBJECT(viewer
), TRACESET_TIME_SPAN
);
187 time_window
.start_time
= time_interval
->startTime
;
188 time_window
.time_width
= ltt_time_sub(time_interval
->endTime
,time_interval
->startTime
);
191 redraw_viewer(mw_data
,&time_window
);
192 lttvwindow_report_current_time(mw_data
,&(mw_data
->current_tab
->current_time
));
194 lttvwindow_report_time_window(mw_data
,&t
);
200 /* get_label function is used to get user input, it displays an input
201 * box, which allows user to input a string
204 void get_label_string (GtkWidget
* text
, gchar
* label
)
206 GtkEntry
* entry
= (GtkEntry
*)text
;
207 if(strlen(gtk_entry_get_text(entry
))!=0)
208 strcpy(label
,gtk_entry_get_text(entry
));
211 gboolean
get_label(MainWindow
* mw
, gchar
* str
, gchar
* dialogue_title
, gchar
* label_str
)
213 GtkWidget
* dialogue
;
218 dialogue
= gtk_dialog_new_with_buttons(dialogue_title
,NULL
,
220 GTK_STOCK_OK
,GTK_RESPONSE_ACCEPT
,
221 GTK_STOCK_CANCEL
,GTK_RESPONSE_REJECT
,
224 label
= gtk_label_new(label_str
);
225 gtk_widget_show(label
);
227 text
= gtk_entry_new();
228 gtk_widget_show(text
);
230 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), label
,TRUE
, TRUE
,0);
231 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), text
,FALSE
, FALSE
,0);
233 id
= gtk_dialog_run(GTK_DIALOG(dialogue
));
235 case GTK_RESPONSE_ACCEPT
:
236 get_label_string(text
,str
);
237 gtk_widget_destroy(dialogue
);
239 case GTK_RESPONSE_REJECT
:
241 gtk_widget_destroy(dialogue
);
248 /* get_window_data_struct function is actually a lookup function,
249 * given a widget which is in the tree of the main window, it will
250 * return the MainWindow data structure associated with main window
253 MainWindow
* get_window_data_struct(GtkWidget
* widget
)
256 MainWindow
* mw_data
;
258 mw
= lookup_widget(widget
, "MWindow");
260 g_printf("Main window does not exist\n");
264 mw_data
= (MainWindow
*) g_object_get_data(G_OBJECT(mw
),"mainWindow");
266 g_printf("Main window data does not exist\n");
273 /* create_new_window function, just constructs a new main window
276 void create_new_window(GtkWidget
* widget
, gpointer user_data
, gboolean clone
)
278 MainWindow
* parent
= get_window_data_struct(widget
);
281 g_printf("Clone : use the same traceset\n");
282 construct_main_window(parent
);
284 g_printf("Empty : traceset is set to NULL\n");
285 construct_main_window(NULL
);
290 /* move_*_viewer functions move the selected view up/down in
294 void move_up_viewer(GtkWidget
* widget
, gpointer user_data
)
296 MainWindow
* mw
= get_window_data_struct(widget
);
297 if(!mw
->current_tab
) return;
298 gtk_multi_vpaned_widget_move_up(mw
->current_tab
->multi_vpaned
);
301 void move_down_viewer(GtkWidget
* widget
, gpointer user_data
)
303 MainWindow
* mw
= get_window_data_struct(widget
);
304 if(!mw
->current_tab
) return;
305 gtk_multi_vpaned_widget_move_down(mw
->current_tab
->multi_vpaned
);
309 /* delete_viewer deletes the selected viewer in the current tab
312 void delete_viewer(GtkWidget
* widget
, gpointer user_data
)
314 MainWindow
* mw
= get_window_data_struct(widget
);
315 if(!mw
->current_tab
) return;
316 gtk_multi_vpaned_widget_delete(mw
->current_tab
->multi_vpaned
);
320 /* open_traceset will open a traceset saved in a file
321 * Right now, it is not finished yet, (not working)
324 void open_traceset(GtkWidget
* widget
, gpointer user_data
)
328 LttvTraceset
* traceset
;
329 MainWindow
* mw_data
= get_window_data_struct(widget
);
330 GtkFileSelection
* file_selector
=
331 (GtkFileSelection
*)gtk_file_selection_new("Select a traceset");
333 gtk_file_selection_hide_fileop_buttons(file_selector
);
335 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
337 case GTK_RESPONSE_ACCEPT
:
338 case GTK_RESPONSE_OK
:
339 dir
= gtk_file_selection_get_selections (file_selector
);
340 traceset
= lttv_traceset_load(dir
[0]);
341 g_printf("Open a trace set %s\n", dir
[0]);
344 case GTK_RESPONSE_REJECT
:
345 case GTK_RESPONSE_CANCEL
:
347 gtk_widget_destroy((GtkWidget
*)file_selector
);
354 /* get_max_event_number returns the event number limit used by
355 * lttv_process_traceset(LttvTracesetContext, endTime, maxNumEvents)
356 * each viewer can set the limit
359 unsigned get_max_event_number(MainWindow
* mw_data
)
361 unsigned nb
= 0, *size
;
364 w
= gtk_multi_vpaned_get_first_widget(mw_data
->current_tab
->multi_vpaned
);
366 size
= (unsigned*)g_object_get_data(G_OBJECT(w
), MAX_NUMBER_EVENT
);
374 w
= gtk_multi_vpaned_get_next_widget(mw_data
->current_tab
->multi_vpaned
);
380 /* redraw_viewer parses the traceset first by calling
381 * process_traceset, then display all viewers of
385 void redraw_viewer(MainWindow
* mw_data
, TimeWindow
* time_window
)
387 unsigned max_nb_events
;
391 LttvTracesetContext
*tsc
=
392 LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->traceset_info
->
395 //set the cursor to be X shape, indicating that the computer is busy in doing its job
396 new = gdk_cursor_new(GDK_X_CURSOR
);
397 widget
= lookup_widget(mw_data
->mwindow
, "MToolbar1");
398 win
= gtk_widget_get_parent_window(widget
);
399 gdk_window_set_cursor(win
, new);
400 gdk_cursor_unref(new);
401 gdk_window_stick(win
);
402 gdk_window_unstick(win
);
404 //update time window of each viewer, let viewer insert hooks needed by process_traceset
405 lttvwindow_report_time_window(mw_data
, time_window
);
407 max_nb_events
= get_max_event_number(mw_data
);
409 lttv_process_traceset_seek_time(tsc
, time_window
->start_time
);
410 lttv_process_traceset(tsc
,
411 ltt_time_add(time_window
->start_time
,time_window
->time_width
),
414 //call hooks to show each viewer and let them remove hooks
415 show_viewer(mw_data
);
417 //set the cursor back to normal
418 gdk_window_set_cursor(win
, NULL
);
422 /* add_trace_into_traceset_selector, each instance of a viewer has an associated
423 * selector (filter), when a trace is added into traceset, the selector should
424 * reflect the change. The function is used to update the selector
427 void add_trace_into_traceset_selector(GtkMultiVPaned
* paned
, LttTrace
* t
)
429 int j
, k
, m
, nb_tracefile
, nb_control
, nb_per_cpu
, nb_facility
, nb_event
;
430 LttvTracesetSelector
* s
;
431 LttvTraceSelector
* trace
;
432 LttvTracefileSelector
* tracefile
;
433 LttvEventtypeSelector
* eventtype
;
439 w
= gtk_multi_vpaned_get_first_widget(paned
);
441 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
444 trace
= lttv_trace_selector_new(t
);
445 lttv_traceset_selector_trace_add(s
, trace
);
447 nb_facility
= ltt_trace_facility_number(t
);
448 for(k
=0;k
<nb_facility
;k
++){
449 fac
= ltt_trace_facility_get(t
,k
);
450 nb_event
= (int) ltt_facility_eventtype_number(fac
);
451 for(m
=0;m
<nb_event
;m
++){
452 et
= ltt_facility_eventtype_get(fac
,m
);
453 eventtype
= lttv_eventtype_selector_new(et
);
454 lttv_trace_selector_eventtype_add(trace
, eventtype
);
458 nb_control
= ltt_trace_control_tracefile_number(t
);
459 nb_per_cpu
= ltt_trace_per_cpu_tracefile_number(t
);
460 nb_tracefile
= nb_control
+ nb_per_cpu
;
462 for(j
= 0 ; j
< nb_tracefile
; j
++) {
464 tf
= ltt_trace_control_tracefile_get(t
, j
);
466 tf
= ltt_trace_per_cpu_tracefile_get(t
, j
- nb_control
);
467 tracefile
= lttv_tracefile_selector_new(tf
);
468 lttv_trace_selector_tracefile_add(trace
, tracefile
);
469 lttv_eventtype_selector_copy(trace
, tracefile
);
471 }else g_warning("Module does not support filtering\n");
473 w
= gtk_multi_vpaned_get_next_widget(paned
);
478 /* add_trace adds a trace into the current traceset. It first displays a
479 * directory selection dialogue to let user choose a trace, then recreates
480 * tracset_context, and redraws all the viewer of the current tab
483 void add_trace(GtkWidget
* widget
, gpointer user_data
)
487 LttvTraceset
* traceset
;
488 LttvTracesetStats
* tmp_context
;
491 MainWindow
* mw_data
= get_window_data_struct(widget
);
492 GtkDirSelection
* file_selector
= (GtkDirSelection
*)gtk_dir_selection_new("Select a trace");
493 gtk_dir_selection_hide_fileop_buttons(file_selector
);
494 if(remember_trace_dir
[0] != '\0')
495 gtk_dir_selection_set_filename(file_selector
, remember_trace_dir
);
497 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
499 case GTK_RESPONSE_ACCEPT
:
500 case GTK_RESPONSE_OK
:
501 dir
= gtk_dir_selection_get_dir (file_selector
);
502 strncpy(remember_trace_dir
, dir
, PATH_LENGTH
);
503 if(!dir
|| strlen(dir
) ==0){
504 gtk_widget_destroy((GtkWidget
*)file_selector
);
507 trace
= ltt_trace_open(dir
);
508 if(trace
== NULL
) g_critical("cannot open trace %s", dir
);
509 trace_v
= lttv_trace_new(trace
);
510 traceset
= mw_data
->current_tab
->traceset_info
->traceset
;
512 // Keep the context until the new one is created.
513 tmp_context
= mw_data
->current_tab
->traceset_info
->traceset_context
;
514 mw_data
->current_tab
->traceset_info
->traceset_context
= NULL
;
516 lttv_traceset_add(traceset
, trace_v
);
517 mw_data
->current_tab
->traceset_info
->traceset_context
=
518 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
520 LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->traceset_info
->
523 //add state update hooks
524 lttv_state_add_event_hooks(
525 (LttvTracesetState
*)mw_data
->current_tab
->traceset_info
->traceset_context
);
526 if(tmp_context
!= NULL
)
528 //remove state update hooks
529 lttv_state_remove_event_hooks(
530 (LttvTracesetState
*)tmp_context
);
531 lttv_context_fini(LTTV_TRACESET_CONTEXT(tmp_context
));
532 g_object_unref(tmp_context
);
537 add_trace_into_traceset_selector(mw_data
->current_tab
->multi_vpaned
, trace
);
539 gtk_widget_destroy((GtkWidget
*)file_selector
);
542 update_traceset(mw_data
);
544 //get_traceset_time_span(mw_data,LTTV_TRACESET_CONTEXT(mw_data->current_tab->traceset_info->traceset_context)->Time_Span);
545 if(lttv_traceset_number(mw_data
->current_tab
->traceset_info
->traceset
) == 1 ||
546 ltt_time_compare(mw_data
->current_tab
->current_time
,
547 LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->traceset_info
->traceset_context
)->Time_Span
->startTime
)<0){
548 mw_data
->current_tab
->current_time
=
549 LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->traceset_info
->traceset_context
)->Time_Span
->startTime
;
550 mw_data
->current_tab
->time_window
.start_time
= mw_data
->current_tab
->current_time
;
551 mw_data
->current_tab
->time_window
.time_width
.tv_sec
= DEFAULT_TIME_WIDTH_S
;
552 mw_data
->current_tab
->time_window
.time_width
.tv_nsec
= 0;
555 redraw_viewer(mw_data
, &(mw_data
->current_tab
->time_window
));
556 lttvwindow_report_current_time(mw_data
,&(mw_data
->current_tab
->current_time
));
558 case GTK_RESPONSE_REJECT
:
559 case GTK_RESPONSE_CANCEL
:
561 gtk_widget_destroy((GtkWidget
*)file_selector
);
567 /* remove_trace_into_traceset_selector, each instance of a viewer has an associated
568 * selector (filter), when a trace is remove from traceset, the selector should
569 * reflect the change. The function is used to update the selector
572 void remove_trace_from_traceset_selector(GtkMultiVPaned
* paned
, unsigned i
)
574 LttvTracesetSelector
* s
;
575 LttvTraceSelector
* t
;
578 w
= gtk_multi_vpaned_get_first_widget(paned
);
580 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
582 t
= lttv_traceset_selector_trace_get(s
,i
);
583 lttv_traceset_selector_trace_remove(s
, i
);
584 lttv_trace_selector_destroy(t
);
585 }g_warning("Module dose not support filtering\n");
586 w
= gtk_multi_vpaned_get_next_widget(paned
);
591 /* remove_trace removes a trace from the current traceset if all viewers in
592 * the current tab are not interested in the trace. It first displays a
593 * dialogue, which shows all traces in the current traceset, to let user choose
594 * a trace, then it checks if all viewers unselect the trace, if it is true,
595 * it will remove the trace, recreate the traceset_contex,
596 * and redraws all the viewer of the current tab. If there is on trace in the
597 * current traceset, it will delete all viewers of the current tab
600 void remove_trace(GtkWidget
* widget
, gpointer user_data
)
604 LttvTraceset
* traceset
;
605 LttvTracesetStats
* tmp_context
;
607 char ** name
, *remove_trace_name
;
608 MainWindow
* mw_data
= get_window_data_struct(widget
);
609 LttvTracesetSelector
* s
;
610 LttvTraceSelector
* t
;
614 nb_trace
=lttv_traceset_number(mw_data
->current_tab
->traceset_info
->traceset
);
615 name
= g_new(char*,nb_trace
);
616 for(i
= 0; i
< nb_trace
; i
++){
617 trace_v
= lttv_traceset_get(mw_data
->current_tab
->
618 traceset_info
->traceset
, i
);
619 trace
= lttv_trace(trace_v
);
620 name
[i
] = ltt_trace_name(trace
);
623 remove_trace_name
= get_remove_trace(name
, nb_trace
);
625 if(remove_trace_name
){
626 for(i
=0; i
<nb_trace
; i
++){
627 if(strcmp(remove_trace_name
,name
[i
]) == 0){
628 //unselect the trace from the current viewer
629 w
= gtk_multi_vpaned_get_widget(mw_data
->current_tab
->multi_vpaned
);
631 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
633 t
= lttv_traceset_selector_trace_get(s
,i
);
634 lttv_trace_selector_set_selected(t
, FALSE
);
637 //check if other viewers select the trace
638 w
= gtk_multi_vpaned_get_first_widget(mw_data
->current_tab
->multi_vpaned
);
640 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
642 t
= lttv_traceset_selector_trace_get(s
,i
);
643 selected
= lttv_trace_selector_get_selected(t
);
646 w
= gtk_multi_vpaned_get_next_widget(mw_data
->current_tab
->multi_vpaned
);
648 }else selected
= FALSE
;
650 //if no viewer selects the trace, remove it
652 remove_trace_from_traceset_selector(mw_data
->current_tab
->multi_vpaned
, i
);
654 traceset
= mw_data
->current_tab
->traceset_info
->traceset
;
655 trace_v
= lttv_traceset_get(traceset
, i
);
656 if(lttv_trace_get_ref_number(trace_v
) <= 1)
657 ltt_trace_close(lttv_trace(trace_v
));
659 // Keep the context until the new one is created.
660 tmp_context
= mw_data
->current_tab
->traceset_info
->traceset_context
;
661 mw_data
->current_tab
->traceset_info
->traceset_context
= NULL
;
663 lttv_traceset_remove(traceset
, i
);
664 if(!lttv_trace_get_ref_number(trace_v
))
665 lttv_trace_destroy(trace_v
);
666 mw_data
->current_tab
->traceset_info
->traceset_context
=
667 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
669 LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->
670 traceset_info
->traceset_context
),traceset
);
671 //add state update hooks
672 lttv_state_add_event_hooks(
673 (LttvTracesetState
*)mw_data
->current_tab
->traceset_info
->traceset_context
);
675 if(tmp_context
!= NULL
){
676 //remove state update hooks
677 lttv_state_remove_event_hooks(
678 (LttvTracesetState
*)tmp_context
);
679 lttv_context_fini(LTTV_TRACESET_CONTEXT(tmp_context
));
680 g_object_unref(tmp_context
);
685 update_traceset(mw_data
);
687 redraw_viewer(mw_data
, &(mw_data
->current_tab
->time_window
));
688 lttvwindow_report_current_time(mw_data
,&(mw_data
->current_tab
->current_time
));
690 if(mw_data
->current_tab
){
691 while(mw_data
->current_tab
->multi_vpaned
->num_children
){
692 gtk_multi_vpaned_widget_delete(mw_data
->current_tab
->multi_vpaned
);
706 /* save will save the traceset to a file
707 * Not implemented yet
710 void save(GtkWidget
* widget
, gpointer user_data
)
715 void save_as(GtkWidget
* widget
, gpointer user_data
)
717 g_printf("Save as\n");
721 /* zoom will change the time_window of all the viewers of the
722 * current tab, and redisplay them. The main functionality is to
723 * determine the new time_window of the current tab
726 void zoom(GtkWidget
* widget
, double size
)
728 TimeInterval
*time_span
;
729 TimeWindow time_window
;
730 LttTime current_time
, time_delta
, time_s
, time_e
, time_t;
731 MainWindow
* mw_data
= get_window_data_struct(widget
);
733 if(size
== 1) return;
735 time_span
= LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->
736 traceset_info
->traceset_context
)->Time_Span
;
737 time_window
= mw_data
->current_tab
->time_window
;
738 current_time
= mw_data
->current_tab
->current_time
;
740 time_delta
= ltt_time_sub(time_span
->endTime
,time_span
->startTime
);
742 time_window
.start_time
= time_span
->startTime
;
743 time_window
.time_width
= time_delta
;
745 time_window
.time_width
= ltt_time_div(time_window
.time_width
, size
);
746 if(ltt_time_compare(time_window
.time_width
,time_delta
) > 0)
747 time_window
.time_width
= time_delta
;
749 time_t = ltt_time_div(time_window
.time_width
, 2);
750 if(ltt_time_compare(current_time
, time_t) < 0){
751 time_s
= time_span
->startTime
;
753 time_s
= ltt_time_sub(current_time
,time_t);
755 time_e
= ltt_time_add(current_time
,time_t);
756 if(ltt_time_compare(time_span
->startTime
, time_s
) > 0){
757 time_s
= time_span
->startTime
;
758 }else if(ltt_time_compare(time_span
->endTime
, time_e
) < 0){
759 time_e
= time_span
->endTime
;
760 time_s
= ltt_time_sub(time_e
,time_window
.time_width
);
762 time_window
.start_time
= time_s
;
764 redraw_viewer(mw_data
, &time_window
);
765 lttvwindow_report_current_time(mw_data
,&(mw_data
->current_tab
->current_time
));
766 gtk_multi_vpaned_set_adjust(mw_data
->current_tab
->multi_vpaned
, FALSE
);
769 void zoom_in(GtkWidget
* widget
, gpointer user_data
)
774 void zoom_out(GtkWidget
* widget
, gpointer user_data
)
779 void zoom_extended(GtkWidget
* widget
, gpointer user_data
)
784 void go_to_time(GtkWidget
* widget
, gpointer user_data
)
786 g_printf("Go to time\n");
789 void show_time_frame(GtkWidget
* widget
, gpointer user_data
)
791 g_printf("Show time frame\n");
795 /* callback function */
798 on_empty_traceset_activate (GtkMenuItem
*menuitem
,
801 create_new_window((GtkWidget
*)menuitem
, user_data
, FALSE
);
806 on_clone_traceset_activate (GtkMenuItem
*menuitem
,
809 create_new_window((GtkWidget
*)menuitem
, user_data
, TRUE
);
813 /* create_new_tab calls create_tab to construct a new tab in the main window
816 void create_new_tab(GtkWidget
* widget
, gpointer user_data
){
817 gchar label
[PATH_LENGTH
];
818 MainWindow
* mw_data
= get_window_data_struct(widget
);
819 GtkNotebook
* notebook
= (GtkNotebook
*)lookup_widget(widget
, "MNotebook");
820 if(notebook
== NULL
){
821 g_printf("Notebook does not exist\n");
825 strcpy(label
,"Page");
826 if(get_label(mw_data
, label
,"Get the name of the tab","Please input tab's name"))
827 create_tab (mw_data
, mw_data
, notebook
, label
);
831 on_tab_activate (GtkMenuItem
*menuitem
,
834 create_new_tab((GtkWidget
*)menuitem
, user_data
);
839 on_open_activate (GtkMenuItem
*menuitem
,
842 open_traceset((GtkWidget
*)menuitem
, user_data
);
847 on_close_activate (GtkMenuItem
*menuitem
,
850 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
851 main_window_destructor(mw_data
);
855 /* remove the current tab from the main window if it is not the default tab
859 on_close_tab_activate (GtkMenuItem
*menuitem
,
864 GtkWidget
* notebook
;
866 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
867 notebook
= lookup_widget((GtkWidget
*)menuitem
, "MNotebook");
868 if(notebook
== NULL
){
869 g_printf("Notebook does not exist\n");
873 if(mw_data
->tab
== mw_data
->current_tab
){
874 // tmp = mw_data->current_tb;
875 // mw_data->tab = mw_data->current_tab->next;
876 g_printf("The default TAB can not be deleted\n");
880 while(tmp
!= mw_data
->current_tab
){
886 gtk_notebook_remove_page((GtkNotebook
*)notebook
, count
);
887 list
= gtk_container_get_children(GTK_CONTAINER(notebook
));
888 if(g_list_length(list
)==1)
889 gtk_notebook_set_show_tabs((GtkNotebook
*)notebook
, FALSE
);
894 on_add_trace_activate (GtkMenuItem
*menuitem
,
897 add_trace((GtkWidget
*)menuitem
, user_data
);
902 on_remove_trace_activate (GtkMenuItem
*menuitem
,
905 remove_trace((GtkWidget
*)menuitem
, user_data
);
910 on_save_activate (GtkMenuItem
*menuitem
,
913 save((GtkWidget
*)menuitem
, user_data
);
918 on_save_as_activate (GtkMenuItem
*menuitem
,
921 save_as((GtkWidget
*)menuitem
, user_data
);
926 on_quit_activate (GtkMenuItem
*menuitem
,
934 on_cut_activate (GtkMenuItem
*menuitem
,
942 on_copy_activate (GtkMenuItem
*menuitem
,
950 on_paste_activate (GtkMenuItem
*menuitem
,
958 on_delete_activate (GtkMenuItem
*menuitem
,
961 g_printf("Delete\n");
966 on_zoom_in_activate (GtkMenuItem
*menuitem
,
969 zoom_in((GtkWidget
*)menuitem
, user_data
);
974 on_zoom_out_activate (GtkMenuItem
*menuitem
,
977 zoom_out((GtkWidget
*)menuitem
, user_data
);
982 on_zoom_extended_activate (GtkMenuItem
*menuitem
,
985 zoom_extended((GtkWidget
*)menuitem
, user_data
);
990 on_go_to_time_activate (GtkMenuItem
*menuitem
,
993 go_to_time((GtkWidget
*)menuitem
, user_data
);
998 on_show_time_frame_activate (GtkMenuItem
*menuitem
,
1001 show_time_frame((GtkWidget
*)menuitem
, user_data
);
1006 on_move_viewer_up_activate (GtkMenuItem
*menuitem
,
1009 move_up_viewer((GtkWidget
*)menuitem
, user_data
);
1014 on_move_viewer_down_activate (GtkMenuItem
*menuitem
,
1017 move_down_viewer((GtkWidget
*)menuitem
, user_data
);
1022 on_remove_viewer_activate (GtkMenuItem
*menuitem
,
1025 delete_viewer((GtkWidget
*)menuitem
, user_data
);
1029 on_trace_filter_activate (GtkMenuItem
*menuitem
,
1032 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1033 LttvTracesetSelector
* s
;
1034 GtkWidget
* w
= gtk_multi_vpaned_get_widget(mw_data
->current_tab
->multi_vpaned
);
1036 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
1038 g_printf("There is no viewer yet\n");
1041 if(get_filter_selection(s
, "Configure trace and tracefile filter", "Select traces and tracefiles")){
1042 update_traceset(mw_data
);
1043 redraw_viewer(mw_data
, &(mw_data
->current_tab
->time_window
));
1044 lttvwindow_report_current_time(mw_data
,&(mw_data
->current_tab
->current_time
));
1049 on_trace_facility_activate (GtkMenuItem
*menuitem
,
1052 g_printf("Trace facility selector: %s\n");
1056 /* Dispaly a file selection dialogue to let user select a module, then call
1057 * lttv_module_load(), finally insert tool button and menu entry in the main window
1058 * for the loaded module
1062 on_load_module_activate (GtkMenuItem
*menuitem
,
1067 char str
[PATH_LENGTH
], *str1
;
1068 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1069 GtkFileSelection
* file_selector
= (GtkFileSelection
*)gtk_file_selection_new("Select a module");
1070 if(remember_plugins_dir
[0] != '\0')
1071 gtk_file_selection_set_filename(file_selector
, remember_plugins_dir
);
1072 gtk_file_selection_hide_fileop_buttons(file_selector
);
1075 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
1077 case GTK_RESPONSE_ACCEPT
:
1078 case GTK_RESPONSE_OK
:
1079 dir
= gtk_file_selection_get_selections (file_selector
);
1080 strncpy(str
,dir
[0],PATH_LENGTH
);
1081 strncpy(remember_plugins_dir
,dir
[0],PATH_LENGTH
);
1082 str1
= strrchr(str
,'/');
1085 str1
= strrchr(str
,'\\');
1088 lttv_module_require(str1
, NULL
);
1089 g_slist_foreach(g_main_window_list
, (gpointer
)insert_menu_toolbar_item
,
1092 case GTK_RESPONSE_REJECT
:
1093 case GTK_RESPONSE_CANCEL
:
1095 gtk_widget_destroy((GtkWidget
*)file_selector
);
1098 g_printf("Load module: %s\n", str
);
1102 /* Display all loaded modules, let user to select a module to unload
1103 * by calling lttv_module_unload
1107 on_unload_module_activate (GtkMenuItem
*menuitem
,
1112 char *unload_module_name
;
1114 LttvLibrary
*library
;
1115 LttvLibraryInfo library_info
;
1116 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1118 name
= g_ptr_array_new();
1119 nb
= lttv_library_number();
1122 library
= lttv_library_get(i
);
1123 lttv_library_info(library
, &library_info
);
1124 if(library_info
.load_count
> 0) g_ptr_array_add(name
, library_info
.name
);
1127 unload_module_name
=get_unload_module((char **)(name
->pdata
), name
->len
);
1129 if(unload_module_name
){
1131 library
= lttv_library_get(i
);
1132 lttv_library_info(library
, &library_info
);
1133 if(strcmp(unload_module_name
, library_info
.name
) == 0){
1134 lttv_library_unload(library
);
1140 g_ptr_array_free(name
, TRUE
);
1144 /* Display a directory dialogue to let user select a path for module searching
1148 on_add_module_search_path_activate (GtkMenuItem
*menuitem
,
1151 GtkDirSelection
* file_selector
= (GtkDirSelection
*)gtk_dir_selection_new("Select module path");
1155 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1156 if(remember_plugins_dir
[0] != '\0')
1157 gtk_dir_selection_set_filename(file_selector
, remember_plugins_dir
);
1159 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
1161 case GTK_RESPONSE_ACCEPT
:
1162 case GTK_RESPONSE_OK
:
1163 dir
= gtk_dir_selection_get_dir (file_selector
);
1164 strncpy(remember_plugins_dir
,dir
,PATH_LENGTH
);
1165 strncat(remember_plugins_dir
,"/",PATH_LENGTH
);
1166 lttv_library_path_add(dir
);
1167 case GTK_RESPONSE_REJECT
:
1168 case GTK_RESPONSE_CANCEL
:
1170 gtk_widget_destroy((GtkWidget
*)file_selector
);
1177 on_color_activate (GtkMenuItem
*menuitem
,
1180 g_printf("Color\n");
1185 on_filter_activate (GtkMenuItem
*menuitem
,
1188 g_printf("Filter\n");
1193 on_save_configuration_activate (GtkMenuItem
*menuitem
,
1196 g_printf("Save configuration\n");
1201 on_content_activate (GtkMenuItem
*menuitem
,
1204 g_printf("Content\n");
1209 on_about_activate (GtkMenuItem
*menuitem
,
1212 g_printf("About...\n");
1217 on_button_new_clicked (GtkButton
*button
,
1220 create_new_window((GtkWidget
*)button
, user_data
, TRUE
);
1224 on_button_new_tab_clicked (GtkButton
*button
,
1227 create_new_tab((GtkWidget
*)button
, user_data
);
1231 on_button_open_clicked (GtkButton
*button
,
1234 open_traceset((GtkWidget
*)button
, user_data
);
1239 on_button_add_trace_clicked (GtkButton
*button
,
1242 add_trace((GtkWidget
*)button
, user_data
);
1247 on_button_remove_trace_clicked (GtkButton
*button
,
1250 remove_trace((GtkWidget
*)button
, user_data
);
1255 on_button_save_clicked (GtkButton
*button
,
1258 save((GtkWidget
*)button
, user_data
);
1263 on_button_save_as_clicked (GtkButton
*button
,
1266 save_as((GtkWidget
*)button
, user_data
);
1271 on_button_zoom_in_clicked (GtkButton
*button
,
1274 zoom_in((GtkWidget
*)button
, user_data
);
1279 on_button_zoom_out_clicked (GtkButton
*button
,
1282 zoom_out((GtkWidget
*)button
, user_data
);
1287 on_button_zoom_extended_clicked (GtkButton
*button
,
1290 zoom_extended((GtkWidget
*)button
, user_data
);
1295 on_button_go_to_time_clicked (GtkButton
*button
,
1298 go_to_time((GtkWidget
*)button
, user_data
);
1303 on_button_show_time_frame_clicked (GtkButton
*button
,
1306 show_time_frame((GtkWidget
*)button
, user_data
);
1311 on_button_move_up_clicked (GtkButton
*button
,
1314 move_up_viewer((GtkWidget
*)button
, user_data
);
1319 on_button_move_down_clicked (GtkButton
*button
,
1322 move_down_viewer((GtkWidget
*)button
, user_data
);
1327 on_button_delete_viewer_clicked (GtkButton
*button
,
1330 delete_viewer((GtkWidget
*)button
, user_data
);
1334 on_MWindow_destroy (GtkObject
*object
,
1337 MainWindow
*Main_Window
= get_window_data_struct((GtkWidget
*)object
);
1339 Tab
*tab
= Main_Window
->tab
;
1341 g_printf("There are : %d windows\n",g_slist_length(g_main_window_list
));
1344 if(g_win_count
== 0)
1349 on_MWindow_configure (GtkWidget
*widget
,
1350 GdkEventConfigure
*event
,
1353 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)widget
);
1354 float width
= event
->width
;
1355 Tab
* tab
= mw_data
->tab
;
1356 TimeWindow time_win
;
1358 TimeInterval
*time_span
;
1361 // MD : removed time width modification upon resizing of the main window.
1362 // The viewers will redraw themselves completely, without time interval
1365 if(mw_data->window_width){
1366 time_span = LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->Time_Span ;
1367 time_win = tab->time_window;
1368 ratio = width / mw_data->window_width;
1369 tab->time_window.time_width = ltt_time_mul(time_win.time_width,ratio);
1370 time = ltt_time_sub(time_span->endTime, time_win.start_time);
1371 if(ltt_time_compare(time, tab->time_window.time_width) < 0){
1372 tab->time_window.time_width = time;
1378 mw_data->window_width = (int)width;
1388 on_MNotebook_switch_page (GtkNotebook
*notebook
,
1389 GtkNotebookPage
*page
,
1393 MainWindow
* mw
= get_window_data_struct((GtkWidget
*)notebook
);
1394 Tab
* tab
= mw
->tab
;
1400 mw
->current_tab
= tab
;
1404 /* callback function to check or uncheck the check box (filter)
1407 void checkbox_changed(GtkTreeView
*treeview
,
1409 GtkTreeViewColumn
*arg2
,
1412 GtkTreeStore
* store
= (GtkTreeStore
*)gtk_tree_view_get_model (treeview
);
1416 if (gtk_tree_model_get_iter ((GtkTreeModel
*)store
, &iter
, arg1
)){
1417 gtk_tree_model_get ((GtkTreeModel
*)store
, &iter
, CHECKBOX_COLUMN
, &value
, -1);
1418 value
= value
? FALSE
: TRUE
;
1419 gtk_tree_store_set (GTK_TREE_STORE (store
), &iter
, CHECKBOX_COLUMN
, value
, -1);
1425 /* According to user's selection, update selector(filter)
1428 void update_filter(LttvTracesetSelector
*s
, GtkTreeStore
*store
)
1430 GtkTreeIter iter
, child_iter
, child_iter1
, child_iter2
;
1431 int i
, j
, k
, nb_eventtype
;
1432 LttvTraceSelector
* trace
;
1433 LttvTracefileSelector
* tracefile
;
1434 LttvEventtypeSelector
* eventtype
;
1435 gboolean value
, value1
, value2
;
1437 if(gtk_tree_model_get_iter_first((GtkTreeModel
*)store
, &iter
)){
1440 trace
= lttv_traceset_selector_trace_get(s
, i
);
1441 nb_eventtype
= lttv_trace_selector_eventtype_number(trace
);
1442 gtk_tree_model_get ((GtkTreeModel
*)store
, &iter
, CHECKBOX_COLUMN
, &value
,-1);
1445 if(gtk_tree_model_iter_children ((GtkTreeModel
*)store
, &child_iter
, &iter
)){
1447 if(j
<1){//eventtype selector for trace
1448 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter
, CHECKBOX_COLUMN
, &value2
,-1);
1451 if(gtk_tree_model_iter_children ((GtkTreeModel
*)store
, &child_iter1
, &child_iter
)){
1453 eventtype
= lttv_trace_selector_eventtype_get(trace
,k
);
1454 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter1
, CHECKBOX_COLUMN
, &value2
,-1);
1455 lttv_eventtype_selector_set_selected(eventtype
,value2
);
1457 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &child_iter1
));
1460 }else{ //tracefile selector
1461 tracefile
= lttv_trace_selector_tracefile_get(trace
, j
- 1);
1462 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter
, CHECKBOX_COLUMN
, &value1
,-1);
1463 lttv_tracefile_selector_set_selected(tracefile
,value1
);
1465 gtk_tree_model_iter_children((GtkTreeModel
*)store
, &child_iter1
, &child_iter
); //eventtype selector
1466 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter1
, CHECKBOX_COLUMN
, &value2
,-1);
1469 if(gtk_tree_model_iter_children ((GtkTreeModel
*)store
, &child_iter2
, &child_iter1
)){
1470 do{//eventtype selector for tracefile
1471 eventtype
= lttv_tracefile_selector_eventtype_get(tracefile
,k
);
1472 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter2
, CHECKBOX_COLUMN
, &value2
,-1);
1473 lttv_eventtype_selector_set_selected(eventtype
,value2
);
1475 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &child_iter2
));
1481 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &child_iter
));
1484 lttv_trace_selector_set_selected(trace
,value
);
1486 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &iter
));
1491 /* Display a dialogue showing all eventtypes and traces, let user to select the interested
1492 * eventtypes, tracefiles and traces (filter)
1495 gboolean
get_filter_selection(LttvTracesetSelector
*s
,char *title
, char * column_title
)
1497 GtkWidget
* dialogue
;
1498 GtkTreeStore
* store
;
1500 GtkWidget
* scroll_win
;
1501 GtkCellRenderer
* renderer
;
1502 GtkTreeViewColumn
* column
;
1503 GtkTreeIter iter
, child_iter
, child_iter1
, child_iter2
;
1504 int i
, j
, k
, id
, nb_trace
, nb_tracefile
, nb_eventtype
;
1505 LttvTraceSelector
* trace
;
1506 LttvTracefileSelector
* tracefile
;
1507 LttvEventtypeSelector
* eventtype
;
1511 dialogue
= gtk_dialog_new_with_buttons(title
,
1514 GTK_STOCK_OK
,GTK_RESPONSE_ACCEPT
,
1515 GTK_STOCK_CANCEL
,GTK_RESPONSE_REJECT
,
1517 gtk_window_set_default_size((GtkWindow
*)dialogue
, 300, 500);
1519 store
= gtk_tree_store_new (TOTAL_COLUMNS
, G_TYPE_BOOLEAN
, G_TYPE_STRING
);
1520 tree
= gtk_tree_view_new_with_model (GTK_TREE_MODEL (store
));
1521 g_object_unref (G_OBJECT (store
));
1522 g_signal_connect (G_OBJECT (tree
), "row-activated",
1523 G_CALLBACK (checkbox_changed
),
1527 renderer
= gtk_cell_renderer_toggle_new ();
1528 gtk_cell_renderer_toggle_set_radio((GtkCellRendererToggle
*)renderer
, FALSE
);
1530 g_object_set (G_OBJECT (renderer
),"activatable", TRUE
, NULL
);
1532 column
= gtk_tree_view_column_new_with_attributes ("Checkbox",
1534 "active", CHECKBOX_COLUMN
,
1536 gtk_tree_view_column_set_alignment (column
, 0.5);
1537 gtk_tree_view_column_set_fixed_width (column
, 20);
1538 gtk_tree_view_append_column (GTK_TREE_VIEW (tree
), column
);
1540 renderer
= gtk_cell_renderer_text_new ();
1541 column
= gtk_tree_view_column_new_with_attributes (column_title
,
1543 "text", NAME_COLUMN
,
1545 gtk_tree_view_column_set_alignment (column
, 0.0);
1546 gtk_tree_view_append_column (GTK_TREE_VIEW (tree
), column
);
1547 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW (tree
), FALSE
);
1549 scroll_win
= gtk_scrolled_window_new (NULL
, NULL
);
1550 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win
),
1551 GTK_POLICY_AUTOMATIC
,GTK_POLICY_AUTOMATIC
);
1552 gtk_container_add (GTK_CONTAINER (scroll_win
), tree
);
1554 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), scroll_win
,TRUE
, TRUE
,0);
1556 gtk_widget_show(scroll_win
);
1557 gtk_widget_show(tree
);
1559 nb_trace
= lttv_traceset_selector_trace_number(s
);
1560 for(i
=0;i
<nb_trace
;i
++){
1561 trace
= lttv_traceset_selector_trace_get(s
, i
);
1562 name
= lttv_trace_selector_get_name(trace
);
1563 gtk_tree_store_append (store
, &iter
, NULL
);
1564 checked
= lttv_trace_selector_get_selected(trace
);
1565 gtk_tree_store_set (store
, &iter
,
1566 CHECKBOX_COLUMN
,checked
,
1570 gtk_tree_store_append (store
, &child_iter
, &iter
);
1571 gtk_tree_store_set (store
, &child_iter
,
1572 CHECKBOX_COLUMN
, checked
,
1573 NAME_COLUMN
,"eventtype",
1576 nb_eventtype
= lttv_trace_selector_eventtype_number(trace
);
1577 for(j
=0;j
<nb_eventtype
;j
++){
1578 eventtype
= lttv_trace_selector_eventtype_get(trace
,j
);
1579 name
= lttv_eventtype_selector_get_name(eventtype
);
1580 checked
= lttv_eventtype_selector_get_selected(eventtype
);
1581 gtk_tree_store_append (store
, &child_iter1
, &child_iter
);
1582 gtk_tree_store_set (store
, &child_iter1
,
1583 CHECKBOX_COLUMN
, checked
,
1588 nb_tracefile
= lttv_trace_selector_tracefile_number(trace
);
1589 for(j
=0;j
<nb_tracefile
;j
++){
1590 tracefile
= lttv_trace_selector_tracefile_get(trace
, j
);
1591 name
= lttv_tracefile_selector_get_name(tracefile
);
1592 gtk_tree_store_append (store
, &child_iter
, &iter
);
1593 checked
= lttv_tracefile_selector_get_selected(tracefile
);
1594 gtk_tree_store_set (store
, &child_iter
,
1595 CHECKBOX_COLUMN
, checked
,
1599 gtk_tree_store_append (store
, &child_iter1
, &child_iter
);
1600 gtk_tree_store_set (store
, &child_iter1
,
1601 CHECKBOX_COLUMN
, checked
,
1602 NAME_COLUMN
,"eventtype",
1605 for(k
=0;k
<nb_eventtype
;k
++){
1606 eventtype
= lttv_tracefile_selector_eventtype_get(tracefile
,k
);
1607 name
= lttv_eventtype_selector_get_name(eventtype
);
1608 checked
= lttv_eventtype_selector_get_selected(eventtype
);
1609 gtk_tree_store_append (store
, &child_iter2
, &child_iter1
);
1610 gtk_tree_store_set (store
, &child_iter2
,
1611 CHECKBOX_COLUMN
, checked
,
1618 id
= gtk_dialog_run(GTK_DIALOG(dialogue
));
1620 case GTK_RESPONSE_ACCEPT
:
1621 case GTK_RESPONSE_OK
:
1622 update_filter(s
, store
);
1623 gtk_widget_destroy(dialogue
);
1625 case GTK_RESPONSE_REJECT
:
1626 case GTK_RESPONSE_CANCEL
:
1628 gtk_widget_destroy(dialogue
);
1635 /* Select a trace which will be removed from traceset
1638 char * get_remove_trace(char ** all_trace_name
, int nb_trace
)
1640 return get_selection(all_trace_name
, nb_trace
,
1641 "Select a trace", "Trace pathname");
1645 /* Select a module which will be unloaded
1648 char * get_unload_module(char ** loaded_module_name
, int nb_module
)
1650 return get_selection(loaded_module_name
, nb_module
,
1651 "Select an unload module", "Module pathname");
1655 /* Display a dialogue which shows all selectable items, let user to
1656 * select one of them
1659 char * get_selection(char ** loaded_module_name
, int nb_module
,
1660 char *title
, char * column_title
)
1662 GtkWidget
* dialogue
;
1663 GtkWidget
* scroll_win
;
1665 GtkListStore
* store
;
1666 GtkTreeViewColumn
* column
;
1667 GtkCellRenderer
* renderer
;
1668 GtkTreeSelection
* select
;
1671 char * unload_module_name
= NULL
;
1673 dialogue
= gtk_dialog_new_with_buttons(title
,
1676 GTK_STOCK_OK
,GTK_RESPONSE_ACCEPT
,
1677 GTK_STOCK_CANCEL
,GTK_RESPONSE_REJECT
,
1679 gtk_window_set_default_size((GtkWindow
*)dialogue
, 500, 200);
1681 scroll_win
= gtk_scrolled_window_new (NULL
, NULL
);
1682 gtk_widget_show ( scroll_win
);
1683 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win
),
1684 GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
1686 store
= gtk_list_store_new (N_COLUMNS
,G_TYPE_STRING
);
1687 tree
= gtk_tree_view_new_with_model(GTK_TREE_MODEL (store
));
1688 gtk_widget_show ( tree
);
1689 g_object_unref (G_OBJECT (store
));
1691 renderer
= gtk_cell_renderer_text_new ();
1692 column
= gtk_tree_view_column_new_with_attributes (column_title
,
1694 "text", MODULE_COLUMN
,
1696 gtk_tree_view_column_set_alignment (column
, 0.5);
1697 gtk_tree_view_column_set_fixed_width (column
, 150);
1698 gtk_tree_view_append_column (GTK_TREE_VIEW (tree
), column
);
1700 select
= gtk_tree_view_get_selection (GTK_TREE_VIEW (tree
));
1701 gtk_tree_selection_set_mode (select
, GTK_SELECTION_SINGLE
);
1703 gtk_container_add (GTK_CONTAINER (scroll_win
), tree
);
1705 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), scroll_win
,TRUE
, TRUE
,0);
1707 for(i
=0;i
<nb_module
;i
++){
1708 gtk_list_store_append (store
, &iter
);
1709 gtk_list_store_set (store
, &iter
, MODULE_COLUMN
,loaded_module_name
[i
],-1);
1712 id
= gtk_dialog_run(GTK_DIALOG(dialogue
));
1714 case GTK_RESPONSE_ACCEPT
:
1715 case GTK_RESPONSE_OK
:
1716 if (gtk_tree_selection_get_selected (select
, (GtkTreeModel
**)&store
, &iter
)){
1717 gtk_tree_model_get ((GtkTreeModel
*)store
, &iter
, MODULE_COLUMN
, &unload_module_name
, -1);
1719 case GTK_RESPONSE_REJECT
:
1720 case GTK_RESPONSE_CANCEL
:
1722 gtk_widget_destroy(dialogue
);
1726 return unload_module_name
;
1733 void main_window_destroy_hash_key(gpointer key
)
1738 void main_window_destroy_hash_data(gpointer data
)
1743 /* Insert menu entry and tool button into all main windows for modules
1744 * It checks whether the menu entry or tool button exists or not,
1745 * if they do not exist, then construct the widget and insert them
1746 * into all main windows
1749 void insert_menu_toolbar_item(MainWindow
* mw
, gpointer user_data
)
1753 lttvwindow_viewer_constructor constructor
;
1755 LttvToolbars
* toolbar
;
1756 lttv_menu_closure
*menu_item
;
1757 lttv_toolbar_closure
*toolbar_item
;
1758 LttvAttributeValue value
;
1759 LttvIAttribute
*attributes
= LTTV_IATTRIBUTE(lttv_global_attributes());
1760 GtkWidget
* tool_menu_title_menu
, *insert_view
, *pixmap
, *tmp
;
1762 g_assert(lttv_iattribute_find_by_path(attributes
,
1763 "viewers/menu", LTTV_POINTER
, &value
));
1764 menu
= (LttvMenus
*)*(value
.v_pointer
);
1767 for(i
=0;i
<menu
->len
;i
++){
1768 menu_item
= &g_array_index(menu
, lttv_menu_closure
, i
);
1769 tmp
= g_hash_table_lookup(mw
->hash_menu_item
, g_strdup(menu_item
->menuText
));
1771 constructor
= menu_item
->con
;
1772 tool_menu_title_menu
= lookup_widget(mw
->mwindow
,"ToolMenuTitle_menu");
1773 insert_view
= gtk_menu_item_new_with_mnemonic (menu_item
->menuText
);
1774 gtk_widget_show (insert_view
);
1775 gtk_container_add (GTK_CONTAINER (tool_menu_title_menu
), insert_view
);
1776 g_signal_connect ((gpointer
) insert_view
, "activate",
1777 G_CALLBACK (insert_viewer_wrap
),
1779 g_hash_table_insert(mw
->hash_menu_item
, g_strdup(menu_item
->menuText
),
1784 g_assert(lttv_iattribute_find_by_path(attributes
,
1785 "viewers/toolbar", LTTV_POINTER
, &value
));
1786 toolbar
= (LttvToolbars
*)*(value
.v_pointer
);
1789 for(i
=0;i
<toolbar
->len
;i
++){
1790 toolbar_item
= &g_array_index(toolbar
, lttv_toolbar_closure
, i
);
1791 tmp
= g_hash_table_lookup(mw
->hash_toolbar_item
, g_strdup(toolbar_item
->tooltip
));
1793 constructor
= toolbar_item
->con
;
1794 tool_menu_title_menu
= lookup_widget(mw
->mwindow
,"MToolbar1");
1795 pixbuf
= gdk_pixbuf_new_from_xpm_data ((const char**)toolbar_item
->pixmap
);
1796 pixmap
= gtk_image_new_from_pixbuf(pixbuf
);
1797 insert_view
= gtk_toolbar_append_element (GTK_TOOLBAR (tool_menu_title_menu
),
1798 GTK_TOOLBAR_CHILD_BUTTON
,
1801 toolbar_item
->tooltip
, NULL
,
1802 pixmap
, NULL
, NULL
);
1803 gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild
*) (g_list_last (GTK_TOOLBAR (tool_menu_title_menu
)->children
)->data
))->label
), TRUE
);
1804 gtk_widget_show (insert_view
);
1805 gtk_container_set_border_width (GTK_CONTAINER (insert_view
), 1);
1806 g_signal_connect ((gpointer
) insert_view
, "clicked",G_CALLBACK (insert_viewer_wrap
),constructor
);
1807 g_hash_table_insert(mw
->hash_toolbar_item
, g_strdup(toolbar_item
->tooltip
),
1814 /* Create a main window
1817 void construct_main_window(MainWindow
* parent
)
1819 g_debug("construct_main_window()");
1820 GtkWidget
* new_window
; /* New generated main window */
1821 MainWindow
* new_m_window
;/* New main window structure */
1822 GtkNotebook
* notebook
;
1823 LttvIAttribute
*attributes
=
1824 LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
));
1825 LttvAttributeValue value
;
1827 new_m_window
= g_new(MainWindow
, 1);
1829 // Add the object's information to the module's array
1830 g_main_window_list
= g_slist_append(g_main_window_list
, new_m_window
);
1833 new_window
= create_MWindow();
1834 gtk_widget_show (new_window
);
1836 new_m_window
->attributes
= attributes
;
1838 new_m_window
->mwindow
= new_window
;
1839 new_m_window
->tab
= NULL
;
1840 new_m_window
->current_tab
= NULL
;
1841 new_m_window
->attributes
= LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
));
1843 new_m_window
->hash_menu_item
= g_hash_table_new_full (g_str_hash
, g_str_equal
,
1844 main_window_destroy_hash_key
,
1845 main_window_destroy_hash_data
);
1846 new_m_window
->hash_toolbar_item
= g_hash_table_new_full (g_str_hash
, g_str_equal
,
1847 main_window_destroy_hash_key
,
1848 main_window_destroy_hash_data
);
1850 insert_menu_toolbar_item(new_m_window
, NULL
);
1852 g_object_set_data(G_OBJECT(new_window
), "mainWindow", (gpointer
)new_m_window
);
1854 //create a default tab
1855 notebook
= (GtkNotebook
*)lookup_widget(new_m_window
->mwindow
, "MNotebook");
1856 if(notebook
== NULL
){
1857 g_printf("Notebook does not exist\n");
1860 //for now there is no name field in LttvTraceset structure
1861 //Use "Traceset" as the label for the default tab
1862 create_tab(parent
, new_m_window
, notebook
,"Traceset");
1864 g_object_set_data_full(
1865 G_OBJECT(new_m_window
->mwindow
),
1868 (GDestroyNotify
)main_window_free
);
1874 /* Free the memory occupied by a tab structure
1878 void tab_destructor(Tab
* tab_instance
)
1880 int i
, nb
, ref_count
;
1883 if(tab_instance
->attributes
)
1884 g_object_unref(tab_instance
->attributes
);
1886 if(tab_instance
->mw
->tab
== tab_instance
){
1887 tab_instance
->mw
->tab
= tab_instance
->next
;
1889 Tab
* tmp1
, *tmp
= tab_instance
->mw
->tab
;
1890 while(tmp
!= tab_instance
){
1894 tmp1
->next
= tab_instance
->next
;
1897 if(tab_instance
->traceset_info
->traceset_context
!= NULL
){
1898 //remove state update hooks
1899 lttv_state_remove_event_hooks(
1900 (LttvTracesetState
*)tab_instance
->traceset_info
->
1902 lttv_context_fini(LTTV_TRACESET_CONTEXT(tab_instance
->traceset_info
->
1904 g_object_unref(tab_instance
->traceset_info
->traceset_context
);
1906 if(tab_instance
->traceset_info
->traceset
!= NULL
) {
1907 nb
= lttv_traceset_number(tab_instance
->traceset_info
->traceset
);
1908 for(i
= 0 ; i
< nb
; i
++) {
1909 trace
= lttv_traceset_get(tab_instance
->traceset_info
->traceset
, i
);
1910 ref_count
= lttv_trace_get_ref_number(trace
);
1912 ltt_trace_close(lttv_trace(trace
));
1913 lttv_trace_destroy(trace
);
1915 // lttv_trace_destroy(trace);
1918 lttv_traceset_destroy(tab_instance
->traceset_info
->traceset
);
1919 g_free(tab_instance
->traceset_info
);
1920 g_free(tab_instance
);
1924 /* Create a tab and insert it into the current main window
1927 void * create_tab(MainWindow
* parent
, MainWindow
* current_window
,
1928 GtkNotebook
* notebook
, char * label
)
1932 MainWindow
* mw_data
= current_window
;
1935 //create a new tab data structure
1936 tmp_tab
= mw_data
->tab
;
1937 while(tmp_tab
&& tmp_tab
->next
) tmp_tab
= tmp_tab
->next
;
1939 mw_data
->current_tab
= NULL
;
1940 tmp_tab
= g_new(Tab
,1);
1941 mw_data
->tab
= tmp_tab
;
1943 tmp_tab
->next
= g_new(Tab
,1);
1944 tmp_tab
= tmp_tab
->next
;
1947 //construct and initialize the traceset_info
1948 tmp_tab
->traceset_info
= g_new(TracesetInfo
,1);
1950 tmp_tab
->traceset_info
->traceset
=
1951 lttv_traceset_copy(parent
->current_tab
->traceset_info
->traceset
);
1953 if(mw_data
->current_tab
){
1954 tmp_tab
->traceset_info
->traceset
=
1955 lttv_traceset_copy(mw_data
->current_tab
->traceset_info
->traceset
);
1957 tmp_tab
->traceset_info
->traceset
= lttv_traceset_new();
1958 /* Add the command line trace */
1959 if(g_init_trace
!= NULL
)
1960 lttv_traceset_add(tmp_tab
->traceset_info
->traceset
, g_init_trace
);
1963 //FIXME copy not implemented in lower level
1964 tmp_tab
->traceset_info
->traceset_context
=
1965 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
1967 LTTV_TRACESET_CONTEXT(tmp_tab
->traceset_info
->traceset_context
),
1968 tmp_tab
->traceset_info
->traceset
);
1969 //add state update hooks
1970 lttv_state_add_event_hooks(
1971 (LttvTracesetState
*)tmp_tab
->traceset_info
->traceset_context
);
1974 //determine the current_time and time_window of the tab
1975 if(mw_data
->current_tab
){
1976 // Will have to read directly at the main window level, as we want
1977 // to be able to modify a traceset on the fly.
1978 tmp_tab
->time_window
= mw_data
->current_tab
->time_window
;
1979 tmp_tab
->current_time
= mw_data
->current_tab
->current_time
;
1981 // Will have to read directly at the main window level, as we want
1982 // to be able to modify a traceset on the fly.
1983 // get_traceset_time_span(mw_data,&tmp_tab->traceStartTime, &tmp_tab->traceEndTime);
1984 tmp_tab
->time_window
.start_time
=
1985 LTTV_TRACESET_CONTEXT(tmp_tab
->traceset_info
->traceset_context
)->Time_Span
->startTime
;
1986 if(DEFAULT_TIME_WIDTH_S
<
1987 LTTV_TRACESET_CONTEXT(tmp_tab
->traceset_info
->traceset_context
)->Time_Span
->endTime
.tv_sec
)
1988 tmp_time
.tv_sec
= DEFAULT_TIME_WIDTH_S
;
1991 LTTV_TRACESET_CONTEXT(tmp_tab
->traceset_info
->traceset_context
)->Time_Span
->endTime
.tv_sec
;
1992 tmp_time
.tv_nsec
= 0;
1993 tmp_tab
->time_window
.time_width
= tmp_time
;
1994 tmp_tab
->current_time
.tv_sec
=
1995 LTTV_TRACESET_CONTEXT(tmp_tab
->traceset_info
->traceset_context
)->Time_Span
->startTime
.tv_sec
;
1996 tmp_tab
->current_time
.tv_nsec
=
1997 LTTV_TRACESET_CONTEXT(tmp_tab
->traceset_info
->traceset_context
)->Time_Span
->startTime
.tv_nsec
;
1999 tmp_tab
->attributes
= LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
));
2000 // mw_data->current_tab = tmp_tab;
2001 tmp_tab
->multi_vpaned
= (GtkMultiVPaned
*)gtk_multi_vpaned_new();
2002 tmp_tab
->multi_vpaned
->mw
= mw_data
;
2003 gtk_widget_show((GtkWidget
*)tmp_tab
->multi_vpaned
);
2004 tmp_tab
->next
= NULL
;
2005 tmp_tab
->mw
= mw_data
;
2007 tmp_tab
->label
= gtk_label_new (label
);
2008 gtk_widget_show (tmp_tab
->label
);
2010 g_object_set_data_full(
2011 G_OBJECT(tmp_tab
->multi_vpaned
),
2014 (GDestroyNotify
)tab_destructor
);
2016 //insert tab into notebook
2017 gtk_notebook_append_page(notebook
, (GtkWidget
*)tmp_tab
->multi_vpaned
, tmp_tab
->label
);
2018 list
= gtk_container_get_children(GTK_CONTAINER(notebook
));
2019 gtk_notebook_set_current_page(notebook
,g_list_length(list
)-1);
2020 if(g_list_length(list
)>1)
2021 gtk_notebook_set_show_tabs(notebook
, TRUE
);
2025 /* Remove menu entry and tool button from main window for the
2029 void remove_menu_item(gpointer main_win
, gpointer user_data
)
2031 MainWindow
* mw
= (MainWindow
*) main_win
;
2032 lttv_menu_closure
*menu_item
= (lttv_menu_closure
*)user_data
;
2033 GtkWidget
* tool_menu_title_menu
, *insert_view
;
2035 tool_menu_title_menu
= lookup_widget(mw
->mwindow
,"ToolMenuTitle_menu");
2036 insert_view
= (GtkWidget
*)g_hash_table_lookup(mw
->hash_menu_item
,
2037 menu_item
->menuText
);
2039 g_hash_table_remove(mw
->hash_menu_item
, menu_item
->menuText
);
2040 gtk_container_remove (GTK_CONTAINER (tool_menu_title_menu
), insert_view
);
2044 void remove_toolbar_item(gpointer main_win
, gpointer user_data
)
2046 MainWindow
* mw
= (MainWindow
*) main_win
;
2047 lttv_toolbar_closure
*toolbar_item
= (lttv_toolbar_closure
*)user_data
;
2048 GtkWidget
* tool_menu_title_menu
, *insert_view
;
2051 tool_menu_title_menu
= lookup_widget(mw
->mwindow
,"MToolbar1");
2052 insert_view
= (GtkWidget
*)g_hash_table_lookup(mw
->hash_toolbar_item
,
2053 toolbar_item
->tooltip
);
2055 g_hash_table_remove(mw
->hash_toolbar_item
, toolbar_item
->tooltip
);
2056 gtk_container_remove (GTK_CONTAINER (tool_menu_title_menu
), insert_view
);
2061 * Remove menu and toolbar item when a module unloaded from all
2065 void main_window_remove_menu_item(lttvwindow_viewer_constructor constructor
)
2069 lttv_menu_closure
*menu_item
;
2070 LttvAttributeValue value
;
2071 LttvIAttribute
*attributes
= LTTV_IATTRIBUTE(lttv_global_attributes());
2073 g_assert(lttv_iattribute_find_by_path(attributes
,
2074 "viewers/menu", LTTV_POINTER
, &value
));
2075 menu
= (LttvMenus
*)*(value
.v_pointer
);
2078 for(i
=0;i
<menu
->len
;i
++){
2079 menu_item
= &g_array_index(menu
, lttv_menu_closure
, i
);
2080 if(menu_item
->con
!= constructor
) continue;
2081 if(g_main_window_list
){
2082 g_slist_foreach(g_main_window_list
, remove_menu_item
, menu_item
);
2090 void main_window_remove_toolbar_item(lttvwindow_viewer_constructor constructor
)
2093 LttvToolbars
* toolbar
;
2094 lttv_toolbar_closure
*toolbar_item
;
2095 LttvAttributeValue value
;
2096 LttvIAttribute
*attributes
= LTTV_IATTRIBUTE(lttv_global_attributes());
2098 g_assert(lttv_iattribute_find_by_path(attributes
,
2099 "viewers/toolbar", LTTV_POINTER
, &value
));
2100 toolbar
= (LttvToolbars
*)*(value
.v_pointer
);
2103 for(i
=0;i
<toolbar
->len
;i
++){
2104 toolbar_item
= &g_array_index(toolbar
, lttv_toolbar_closure
, i
);
2105 if(toolbar_item
->con
!= constructor
) continue;
2106 if(g_main_window_list
){
2107 g_slist_foreach(g_main_window_list
, remove_toolbar_item
, toolbar_item
);