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,
26 #include "callbacks.h"
27 #include "interface.h"
29 #include <lttv/lttv.h>
30 #include <lttv/mainwindow.h>
31 #include <lttv/menu.h>
32 #include <lttv/toolbar.h>
33 #include <lttv/gtktraceset.h>
34 #include <lttv/module.h>
35 #include <lttv/gtkdirsel.h>
36 #include <lttv/iattribute.h>
37 #include <lttv/lttvfilter.h>
38 #include <ltt/trace.h>
39 #include <ltt/facility.h>
41 #define PATH_LENGTH 256
42 #define DEFAULT_TIME_WIDTH_S 1
44 extern LttvTrace
*g_init_trace
;
47 /** Array containing instanced objects. */
48 extern GSList
* g_main_window_list
;
50 static int g_win_count
= 0;
52 MainWindow
* get_window_data_struct(GtkWidget
* widget
);
53 char * get_unload_module(char ** loaded_module_name
, int nb_module
);
54 char * get_remove_trace(char ** all_trace_name
, int nb_trace
);
55 char * get_selection(char ** all_name
, int nb
, char *title
, char * column_title
);
56 gboolean
get_filter_selection(LttvTracesetSelector
*s
, char *title
, char * column_title
);
57 void * create_tab(MainWindow
* parent
, MainWindow
* current_window
,
58 GtkNotebook
* notebook
, char * label
);
60 void insert_viewer(GtkWidget
* widget
, view_constructor constructor
);
61 void update_filter(LttvTracesetSelector
*s
, GtkTreeStore
*store
);
63 void checkbox_changed(GtkTreeView
*treeview
,
65 GtkTreeViewColumn
*arg2
,
67 void remove_trace_from_traceset_selector(GtkMultiVPaned
* paned
, unsigned i
);
68 void add_trace_into_traceset_selector(GtkMultiVPaned
* paned
, LttTrace
* trace
);
70 LttvTracesetSelector
* construct_traceset_selector(LttvTraceset
* traceset
);
72 void redraw_viewer(MainWindow
* mw_data
, TimeWindow
* time_window
);
73 unsigned get_max_event_number(MainWindow
* mw_data
);
87 /* Construct a selector(filter), which will be associated with a viewer,
88 * and provides an interface for user to select interested events and traces
91 LttvTracesetSelector
* construct_traceset_selector(LttvTraceset
* traceset
)
93 LttvTracesetSelector
* s
;
94 LttvTraceSelector
* trace
;
95 LttvTracefileSelector
* tracefile
;
96 LttvEventtypeSelector
* eventtype
;
98 int nb_trace
, nb_tracefile
, nb_control
, nb_per_cpu
, nb_facility
, nb_event
;
105 s
= lttv_traceset_selector_new(lttv_traceset_name(traceset
));
106 nb_trace
= lttv_traceset_number(traceset
);
107 for(i
=0;i
<nb_trace
;i
++){
108 trace_v
= lttv_traceset_get(traceset
, i
);
109 t
= lttv_trace(trace_v
);
110 trace
= lttv_trace_selector_new(t
);
111 lttv_traceset_selector_trace_add(s
, trace
);
113 nb_facility
= ltt_trace_facility_number(t
);
114 for(k
=0;k
<nb_facility
;k
++){
115 fac
= ltt_trace_facility_get(t
,k
);
116 nb_event
= (int) ltt_facility_eventtype_number(fac
);
117 for(m
=0;m
<nb_event
;m
++){
118 et
= ltt_facility_eventtype_get(fac
,m
);
119 eventtype
= lttv_eventtype_selector_new(et
);
120 lttv_trace_selector_eventtype_add(trace
, eventtype
);
124 nb_control
= ltt_trace_control_tracefile_number(t
);
125 nb_per_cpu
= ltt_trace_per_cpu_tracefile_number(t
);
126 nb_tracefile
= nb_control
+ nb_per_cpu
;
128 for(j
= 0 ; j
< nb_tracefile
; j
++) {
130 tf
= ltt_trace_control_tracefile_get(t
, j
);
132 tf
= ltt_trace_per_cpu_tracefile_get(t
, j
- nb_control
);
133 tracefile
= lttv_tracefile_selector_new(tf
);
134 lttv_trace_selector_tracefile_add(trace
, tracefile
);
135 lttv_eventtype_selector_copy(trace
, tracefile
);
142 /* insert_viewer function constructs an instance of a viewer first,
143 * then inserts the widget of the instance into the container of the
148 insert_viewer_wrap(GtkWidget
*menuitem
, gpointer user_data
)
152 insert_viewer((GtkWidget
*)menuitem
, (view_constructor
)user_data
);
153 // selected_hook(&val);
157 /* internal functions */
158 void insert_viewer(GtkWidget
* widget
, view_constructor constructor
)
160 GtkMultiVPaned
* multi_vpaned
;
161 MainWindow
* mw_data
;
163 LttvTracesetSelector
* s
;
164 TimeInterval
* time_interval
;
165 TimeWindow time_window
, t
;
167 mw_data
= get_window_data_struct(widget
);
168 if(!mw_data
->current_tab
) return;
169 multi_vpaned
= mw_data
->current_tab
->multi_vpaned
;
171 s
= construct_traceset_selector(mw_data
->current_tab
->traceset_info
->traceset
);
172 viewer
= (GtkWidget
*)constructor(mw_data
, s
, "Traceset_Selector");
175 gtk_multi_vpaned_widget_add(multi_vpaned
, viewer
);
177 // g_object_unref(G_OBJECT(viewer));
179 time_window
= mw_data
->current_tab
->time_window
;
180 time_interval
= (TimeInterval
*)g_object_get_data(G_OBJECT(viewer
), TRACESET_TIME_SPAN
);
183 time_window
.start_time
= time_interval
->startTime
;
184 time_window
.time_width
= ltt_time_sub(time_interval
->endTime
,time_interval
->startTime
);
187 redraw_viewer(mw_data
,&time_window
);
188 set_current_time(mw_data
,&(mw_data
->current_tab
->current_time
));
190 set_time_window(mw_data
,&t
);
196 /* get_label function is used to get user input, it displays an input
197 * box, which allows user to input a string
200 void get_label_string (GtkWidget
* text
, gchar
* label
)
202 GtkEntry
* entry
= (GtkEntry
*)text
;
203 if(strlen(gtk_entry_get_text(entry
))!=0)
204 strcpy(label
,gtk_entry_get_text(entry
));
207 gboolean
get_label(MainWindow
* mw
, gchar
* str
, gchar
* dialogue_title
, gchar
* label_str
)
209 GtkWidget
* dialogue
;
214 dialogue
= gtk_dialog_new_with_buttons(dialogue_title
,NULL
,
216 GTK_STOCK_OK
,GTK_RESPONSE_ACCEPT
,
217 GTK_STOCK_CANCEL
,GTK_RESPONSE_REJECT
,
220 label
= gtk_label_new(label_str
);
221 gtk_widget_show(label
);
223 text
= gtk_entry_new();
224 gtk_widget_show(text
);
226 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), label
,TRUE
, TRUE
,0);
227 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), text
,FALSE
, FALSE
,0);
229 id
= gtk_dialog_run(GTK_DIALOG(dialogue
));
231 case GTK_RESPONSE_ACCEPT
:
232 get_label_string(text
,str
);
233 gtk_widget_destroy(dialogue
);
235 case GTK_RESPONSE_REJECT
:
237 gtk_widget_destroy(dialogue
);
244 /* get_window_data_struct function is actually a lookup function,
245 * given a widget which is in the tree of the main window, it will
246 * return the MainWindow data structure associated with main window
249 MainWindow
* get_window_data_struct(GtkWidget
* widget
)
252 MainWindow
* mw_data
;
254 mw
= lookup_widget(widget
, "MWindow");
256 g_printf("Main window does not exist\n");
260 mw_data
= (MainWindow
*) g_object_get_data(G_OBJECT(mw
),"mainWindow");
262 g_printf("Main window data does not exist\n");
269 /* create_new_window function, just constructs a new main window
272 void create_new_window(GtkWidget
* widget
, gpointer user_data
, gboolean clone
)
274 MainWindow
* parent
= get_window_data_struct(widget
);
277 g_printf("Clone : use the same traceset\n");
278 construct_main_window(parent
, NULL
);
280 g_printf("Empty : traceset is set to NULL\n");
281 construct_main_window(NULL
, parent
->win_creation_data
);
286 /* move_*_viewer functions move the selected view up/down in
290 void move_up_viewer(GtkWidget
* widget
, gpointer user_data
)
292 MainWindow
* mw
= get_window_data_struct(widget
);
293 if(!mw
->current_tab
) return;
294 gtk_multi_vpaned_widget_move_up(mw
->current_tab
->multi_vpaned
);
297 void move_down_viewer(GtkWidget
* widget
, gpointer user_data
)
299 MainWindow
* mw
= get_window_data_struct(widget
);
300 if(!mw
->current_tab
) return;
301 gtk_multi_vpaned_widget_move_down(mw
->current_tab
->multi_vpaned
);
305 /* delete_viewer deletes the selected viewer in the current tab
308 void delete_viewer(GtkWidget
* widget
, gpointer user_data
)
310 MainWindow
* mw
= get_window_data_struct(widget
);
311 if(!mw
->current_tab
) return;
312 gtk_multi_vpaned_widget_delete(mw
->current_tab
->multi_vpaned
);
316 /* open_traceset will open a traceset saved in a file
317 * Right now, it is not finished yet, (not working)
320 void open_traceset(GtkWidget
* widget
, gpointer user_data
)
324 LttvTraceset
* traceset
;
325 MainWindow
* mw_data
= get_window_data_struct(widget
);
326 GtkFileSelection
* file_selector
=
327 (GtkFileSelection
*)gtk_file_selection_new("Select a traceset");
329 gtk_file_selection_hide_fileop_buttons(file_selector
);
331 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
333 case GTK_RESPONSE_ACCEPT
:
334 case GTK_RESPONSE_OK
:
335 dir
= gtk_file_selection_get_selections (file_selector
);
336 traceset
= lttv_traceset_load(dir
[0]);
337 g_printf("Open a trace set %s\n", dir
[0]);
340 case GTK_RESPONSE_REJECT
:
341 case GTK_RESPONSE_CANCEL
:
343 gtk_widget_destroy((GtkWidget
*)file_selector
);
350 /* get_max_event_number returns the event number limit used by
351 * lttv_process_traceset(LttvTracesetContext, endTime, maxNumEvents)
352 * each viewer can set the limit
355 unsigned get_max_event_number(MainWindow
* mw_data
)
357 unsigned nb
= 0, *size
;
360 w
= gtk_multi_vpaned_get_first_widget(mw_data
->current_tab
->multi_vpaned
);
362 size
= (unsigned*)g_object_get_data(G_OBJECT(w
), MAX_NUMBER_EVENT
);
370 w
= gtk_multi_vpaned_get_next_widget(mw_data
->current_tab
->multi_vpaned
);
376 /* redraw_viewer parses the traceset first by calling
377 * process_traceset_api, then display all viewers of
381 void redraw_viewer(MainWindow
* mw_data
, TimeWindow
* time_window
)
383 unsigned max_nb_events
;
388 //set the cursor to be X shape, indicating that the computer is busy in doing its job
389 new = gdk_cursor_new(GDK_X_CURSOR
);
390 widget
= lookup_widget(mw_data
->mwindow
, "MToolbar1");
391 win
= gtk_widget_get_parent_window(widget
);
392 gdk_window_set_cursor(win
, new);
393 gdk_cursor_unref(new);
394 gdk_window_stick(win
);
395 gdk_window_unstick(win
);
397 //update time window of each viewer, let viewer insert hooks needed by process_traceset
398 set_time_window(mw_data
, time_window
);
400 max_nb_events
= get_max_event_number(mw_data
);
402 process_traceset_api(mw_data
, time_window
->start_time
,
403 ltt_time_add(time_window
->start_time
,time_window
->time_width
),
406 //call hooks to show each viewer and let them remove hooks
407 show_viewer(mw_data
);
409 //set the cursor back to normal
410 gdk_window_set_cursor(win
, NULL
);
414 /* add_trace_into_traceset_selector, each instance of a viewer has an associated
415 * selector (filter), when a trace is added into traceset, the selector should
416 * reflect the change. The function is used to update the selector
419 void add_trace_into_traceset_selector(GtkMultiVPaned
* paned
, LttTrace
* t
)
421 int j
, k
, m
, nb_tracefile
, nb_control
, nb_per_cpu
, nb_facility
, nb_event
;
422 LttvTracesetSelector
* s
;
423 LttvTraceSelector
* trace
;
424 LttvTracefileSelector
* tracefile
;
425 LttvEventtypeSelector
* eventtype
;
431 w
= gtk_multi_vpaned_get_first_widget(paned
);
433 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
436 trace
= lttv_trace_selector_new(t
);
437 lttv_traceset_selector_trace_add(s
, trace
);
439 nb_facility
= ltt_trace_facility_number(t
);
440 for(k
=0;k
<nb_facility
;k
++){
441 fac
= ltt_trace_facility_get(t
,k
);
442 nb_event
= (int) ltt_facility_eventtype_number(fac
);
443 for(m
=0;m
<nb_event
;m
++){
444 et
= ltt_facility_eventtype_get(fac
,m
);
445 eventtype
= lttv_eventtype_selector_new(et
);
446 lttv_trace_selector_eventtype_add(trace
, eventtype
);
450 nb_control
= ltt_trace_control_tracefile_number(t
);
451 nb_per_cpu
= ltt_trace_per_cpu_tracefile_number(t
);
452 nb_tracefile
= nb_control
+ nb_per_cpu
;
454 for(j
= 0 ; j
< nb_tracefile
; j
++) {
456 tf
= ltt_trace_control_tracefile_get(t
, j
);
458 tf
= ltt_trace_per_cpu_tracefile_get(t
, j
- nb_control
);
459 tracefile
= lttv_tracefile_selector_new(tf
);
460 lttv_trace_selector_tracefile_add(trace
, tracefile
);
461 lttv_eventtype_selector_copy(trace
, tracefile
);
463 }else g_warning("Module does not support filtering\n");
465 w
= gtk_multi_vpaned_get_next_widget(paned
);
470 /* add_trace adds a trace into the current traceset. It first displays a
471 * directory selection dialogue to let user choose a trace, then recreates
472 * tracset_context, and redraws all the viewer of the current tab
475 void add_trace(GtkWidget
* widget
, gpointer user_data
)
479 LttvTraceset
* traceset
;
482 MainWindow
* mw_data
= get_window_data_struct(widget
);
483 GtkDirSelection
* file_selector
= (GtkDirSelection
*)gtk_dir_selection_new("Select a trace");
484 gtk_dir_selection_hide_fileop_buttons(file_selector
);
486 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
488 case GTK_RESPONSE_ACCEPT
:
489 case GTK_RESPONSE_OK
:
490 dir
= gtk_dir_selection_get_dir (file_selector
);
491 if(!dir
|| strlen(dir
) ==0){
492 gtk_widget_destroy((GtkWidget
*)file_selector
);
495 trace
= ltt_trace_open(dir
);
496 if(trace
== NULL
) g_critical("cannot open trace %s", dir
);
497 trace_v
= lttv_trace_new(trace
);
498 traceset
= mw_data
->current_tab
->traceset_info
->traceset
;
499 if(mw_data
->current_tab
->traceset_info
->traceset_context
!= NULL
){
500 lttv_context_fini(LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->
501 traceset_info
->traceset_context
));
502 g_object_unref(mw_data
->current_tab
->traceset_info
->traceset_context
);
504 lttv_traceset_add(traceset
, trace_v
);
505 mw_data
->current_tab
->traceset_info
->traceset_context
=
506 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
508 LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->traceset_info
->
509 traceset_context
),traceset
);
510 add_trace_into_traceset_selector(mw_data
->current_tab
->multi_vpaned
, trace
);
512 gtk_widget_destroy((GtkWidget
*)file_selector
);
515 update_traceset(mw_data
);
517 get_traceset_time_span(mw_data
,LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->traceset_info
->traceset_context
)->Time_Span
);
518 if(lttv_traceset_number(mw_data
->current_tab
->traceset_info
->traceset
) == 1 ||
519 ltt_time_compare(mw_data
->current_tab
->current_time
,
520 LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->traceset_info
->traceset_context
)->Time_Span
->startTime
)<0){
521 mw_data
->current_tab
->current_time
=
522 LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->traceset_info
->traceset_context
)->Time_Span
->startTime
;
523 mw_data
->current_tab
->time_window
.start_time
= mw_data
->current_tab
->current_time
;
524 mw_data
->current_tab
->time_window
.time_width
.tv_sec
= DEFAULT_TIME_WIDTH_S
;
525 mw_data
->current_tab
->time_window
.time_width
.tv_nsec
= 0;
528 redraw_viewer(mw_data
, &(mw_data
->current_tab
->time_window
));
529 set_current_time(mw_data
,&(mw_data
->current_tab
->current_time
));
531 case GTK_RESPONSE_REJECT
:
532 case GTK_RESPONSE_CANCEL
:
534 gtk_widget_destroy((GtkWidget
*)file_selector
);
540 /* remove_trace_into_traceset_selector, each instance of a viewer has an associated
541 * selector (filter), when a trace is remove from traceset, the selector should
542 * reflect the change. The function is used to update the selector
545 void remove_trace_from_traceset_selector(GtkMultiVPaned
* paned
, unsigned i
)
547 LttvTracesetSelector
* s
;
548 LttvTraceSelector
* t
;
551 w
= gtk_multi_vpaned_get_first_widget(paned
);
553 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
555 t
= lttv_traceset_selector_trace_get(s
,i
);
556 lttv_traceset_selector_trace_remove(s
, i
);
557 lttv_trace_selector_destroy(t
);
558 }g_warning("Module dose not support filtering\n");
559 w
= gtk_multi_vpaned_get_next_widget(paned
);
564 /* remove_trace removes a trace from the current traceset if all viewers in
565 * the current tab are not interested in the trace. It first displays a
566 * dialogue, which shows all traces in the current traceset, to let user choose
567 * a trace, then it checks if all viewers unselect the trace, if it is true,
568 * it will remove the trace, recreate the traceset_contex,
569 * and redraws all the viewer of the current tab. If there is on trace in the
570 * current traceset, it will delete all viewers of the current tab
573 void remove_trace(GtkWidget
* widget
, gpointer user_data
)
577 LttvTraceset
* traceset
;
579 char ** name
, *remove_trace_name
;
580 MainWindow
* mw_data
= get_window_data_struct(widget
);
581 LttvTracesetSelector
* s
;
582 LttvTraceSelector
* t
;
586 nb_trace
=lttv_traceset_number(mw_data
->current_tab
->traceset_info
->traceset
);
587 name
= g_new(char*,nb_trace
);
588 for(i
= 0; i
< nb_trace
; i
++){
589 trace_v
= lttv_traceset_get(mw_data
->current_tab
->
590 traceset_info
->traceset
, i
);
591 trace
= lttv_trace(trace_v
);
592 name
[i
] = ltt_trace_name(trace
);
595 remove_trace_name
= get_remove_trace(name
, nb_trace
);
597 if(remove_trace_name
){
598 for(i
=0; i
<nb_trace
; i
++){
599 if(strcmp(remove_trace_name
,name
[i
]) == 0){
600 //unselect the trace from the current viewer
601 w
= gtk_multi_vpaned_get_widget(mw_data
->current_tab
->multi_vpaned
);
603 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
605 t
= lttv_traceset_selector_trace_get(s
,i
);
606 lttv_trace_selector_set_selected(t
, FALSE
);
609 //check if other viewers select the trace
610 w
= gtk_multi_vpaned_get_first_widget(mw_data
->current_tab
->multi_vpaned
);
612 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
614 t
= lttv_traceset_selector_trace_get(s
,i
);
615 selected
= lttv_trace_selector_get_selected(t
);
618 w
= gtk_multi_vpaned_get_next_widget(mw_data
->current_tab
->multi_vpaned
);
620 }else selected
= FALSE
;
622 //if no viewer selects the trace, remove it
624 remove_trace_from_traceset_selector(mw_data
->current_tab
->multi_vpaned
, i
);
626 traceset
= mw_data
->current_tab
->traceset_info
->traceset
;
627 trace_v
= lttv_traceset_get(traceset
, i
);
628 if(lttv_trace_get_ref_number(trace_v
) <= 1)
629 ltt_trace_close(lttv_trace(trace_v
));
631 if(mw_data
->current_tab
->traceset_info
->traceset_context
!= NULL
){
632 lttv_context_fini(LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->
633 traceset_info
->traceset_context
));
634 g_object_unref(mw_data
->current_tab
->traceset_info
->traceset_context
);
636 lttv_traceset_remove(traceset
, i
);
637 if(!lttv_trace_get_ref_number(trace_v
))
638 lttv_trace_destroy(trace_v
);
639 mw_data
->current_tab
->traceset_info
->traceset_context
=
640 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
642 LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->
643 traceset_info
->traceset_context
),traceset
);
645 update_traceset(mw_data
);
647 redraw_viewer(mw_data
, &(mw_data
->current_tab
->time_window
));
648 set_current_time(mw_data
,&(mw_data
->current_tab
->current_time
));
650 if(mw_data
->current_tab
){
651 while(mw_data
->current_tab
->multi_vpaned
->num_children
){
652 gtk_multi_vpaned_widget_delete(mw_data
->current_tab
->multi_vpaned
);
666 /* save will save the traceset to a file
667 * Not implemented yet
670 void save(GtkWidget
* widget
, gpointer user_data
)
675 void save_as(GtkWidget
* widget
, gpointer user_data
)
677 g_printf("Save as\n");
681 /* zoom will change the time_window of all the viewers of the
682 * current tab, and redisplay them. The main functionality is to
683 * determine the new time_window of the current tab
686 void zoom(GtkWidget
* widget
, double size
)
688 TimeInterval
*time_span
;
689 TimeWindow time_window
;
690 LttTime current_time
, time_delta
, time_s
, time_e
, time_t;
691 MainWindow
* mw_data
= get_window_data_struct(widget
);
693 if(size
== 1) return;
695 time_span
= LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->
696 traceset_info
->traceset_context
)->Time_Span
;
697 time_window
= mw_data
->current_tab
->time_window
;
698 current_time
= mw_data
->current_tab
->current_time
;
700 time_delta
= ltt_time_sub(time_span
->endTime
,time_span
->startTime
);
702 time_window
.start_time
= time_span
->startTime
;
703 time_window
.time_width
= time_delta
;
705 time_window
.time_width
= ltt_time_div(time_window
.time_width
, size
);
706 if(ltt_time_compare(time_window
.time_width
,time_delta
) > 0)
707 time_window
.time_width
= time_delta
;
709 time_t = ltt_time_div(time_window
.time_width
, 2);
710 if(ltt_time_compare(current_time
, time_t) < 0){
711 time_s
= time_span
->startTime
;
713 time_s
= ltt_time_sub(current_time
,time_t);
715 time_e
= ltt_time_add(current_time
,time_t);
716 if(ltt_time_compare(time_span
->startTime
, time_s
) > 0){
717 time_s
= time_span
->startTime
;
718 }else if(ltt_time_compare(time_span
->endTime
, time_e
) < 0){
719 time_e
= time_span
->endTime
;
720 time_s
= ltt_time_sub(time_e
,time_window
.time_width
);
722 time_window
.start_time
= time_s
;
724 redraw_viewer(mw_data
, &time_window
);
725 set_current_time(mw_data
,&(mw_data
->current_tab
->current_time
));
726 gtk_multi_vpaned_set_adjust(mw_data
->current_tab
->multi_vpaned
, FALSE
);
729 void zoom_in(GtkWidget
* widget
, gpointer user_data
)
734 void zoom_out(GtkWidget
* widget
, gpointer user_data
)
739 void zoom_extended(GtkWidget
* widget
, gpointer user_data
)
744 void go_to_time(GtkWidget
* widget
, gpointer user_data
)
746 g_printf("Go to time\n");
749 void show_time_frame(GtkWidget
* widget
, gpointer user_data
)
751 g_printf("Show time frame\n");
755 /* callback function */
758 on_empty_traceset_activate (GtkMenuItem
*menuitem
,
761 create_new_window((GtkWidget
*)menuitem
, user_data
, FALSE
);
766 on_clone_traceset_activate (GtkMenuItem
*menuitem
,
769 create_new_window((GtkWidget
*)menuitem
, user_data
, TRUE
);
773 /* create_new_tab calls create_tab to construct a new tab in the main window
776 void create_new_tab(GtkWidget
* widget
, gpointer user_data
){
777 gchar label
[PATH_LENGTH
];
778 MainWindow
* mw_data
= get_window_data_struct(widget
);
779 GtkNotebook
* notebook
= (GtkNotebook
*)lookup_widget(widget
, "MNotebook");
780 if(notebook
== NULL
){
781 g_printf("Notebook does not exist\n");
785 strcpy(label
,"Page");
786 if(get_label(mw_data
, label
,"Get the name of the tab","Please input tab's name"))
787 create_tab (mw_data
, mw_data
, notebook
, label
);
791 on_tab_activate (GtkMenuItem
*menuitem
,
794 create_new_tab((GtkWidget
*)menuitem
, user_data
);
799 on_open_activate (GtkMenuItem
*menuitem
,
802 open_traceset((GtkWidget
*)menuitem
, user_data
);
807 on_close_activate (GtkMenuItem
*menuitem
,
810 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
811 main_window_destructor(mw_data
);
815 /* remove the current tab from the main window if it is not the default tab
819 on_close_tab_activate (GtkMenuItem
*menuitem
,
824 GtkWidget
* notebook
;
826 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
827 notebook
= lookup_widget((GtkWidget
*)menuitem
, "MNotebook");
828 if(notebook
== NULL
){
829 g_printf("Notebook does not exist\n");
833 if(mw_data
->tab
== mw_data
->current_tab
){
834 // tmp = mw_data->current_tb;
835 // mw_data->tab = mw_data->current_tab->next;
836 g_printf("The default TAB can not be deleted\n");
840 while(tmp
!= mw_data
->current_tab
){
846 gtk_notebook_remove_page((GtkNotebook
*)notebook
, count
);
847 list
= gtk_container_get_children(GTK_CONTAINER(notebook
));
848 if(g_list_length(list
)==1)
849 gtk_notebook_set_show_tabs((GtkNotebook
*)notebook
, FALSE
);
854 on_add_trace_activate (GtkMenuItem
*menuitem
,
857 add_trace((GtkWidget
*)menuitem
, user_data
);
862 on_remove_trace_activate (GtkMenuItem
*menuitem
,
865 remove_trace((GtkWidget
*)menuitem
, user_data
);
870 on_save_activate (GtkMenuItem
*menuitem
,
873 save((GtkWidget
*)menuitem
, user_data
);
878 on_save_as_activate (GtkMenuItem
*menuitem
,
881 save_as((GtkWidget
*)menuitem
, user_data
);
886 on_quit_activate (GtkMenuItem
*menuitem
,
894 on_cut_activate (GtkMenuItem
*menuitem
,
902 on_copy_activate (GtkMenuItem
*menuitem
,
910 on_paste_activate (GtkMenuItem
*menuitem
,
918 on_delete_activate (GtkMenuItem
*menuitem
,
921 g_printf("Delete\n");
926 on_zoom_in_activate (GtkMenuItem
*menuitem
,
929 zoom_in((GtkWidget
*)menuitem
, user_data
);
934 on_zoom_out_activate (GtkMenuItem
*menuitem
,
937 zoom_out((GtkWidget
*)menuitem
, user_data
);
942 on_zoom_extended_activate (GtkMenuItem
*menuitem
,
945 zoom_extended((GtkWidget
*)menuitem
, user_data
);
950 on_go_to_time_activate (GtkMenuItem
*menuitem
,
953 go_to_time((GtkWidget
*)menuitem
, user_data
);
958 on_show_time_frame_activate (GtkMenuItem
*menuitem
,
961 show_time_frame((GtkWidget
*)menuitem
, user_data
);
966 on_move_viewer_up_activate (GtkMenuItem
*menuitem
,
969 move_up_viewer((GtkWidget
*)menuitem
, user_data
);
974 on_move_viewer_down_activate (GtkMenuItem
*menuitem
,
977 move_down_viewer((GtkWidget
*)menuitem
, user_data
);
982 on_remove_viewer_activate (GtkMenuItem
*menuitem
,
985 delete_viewer((GtkWidget
*)menuitem
, user_data
);
989 on_trace_filter_activate (GtkMenuItem
*menuitem
,
992 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
993 LttvTracesetSelector
* s
;
994 GtkWidget
* w
= gtk_multi_vpaned_get_widget(mw_data
->current_tab
->multi_vpaned
);
996 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
998 g_printf("There is no viewer yet\n");
1001 if(get_filter_selection(s
, "Configure trace and tracefile filter", "Select traces and tracefiles")){
1002 update_traceset(mw_data
);
1003 redraw_viewer(mw_data
, &(mw_data
->current_tab
->time_window
));
1004 set_current_time(mw_data
,&(mw_data
->current_tab
->current_time
));
1009 on_trace_facility_activate (GtkMenuItem
*menuitem
,
1012 g_printf("Trace facility selector: %s\n");
1016 /* Dispaly a file selection dialogue to let user select a module, then call
1017 * lttv_module_load(), finally insert tool button and menu entry in the main window
1018 * for the loaded module
1022 on_load_module_activate (GtkMenuItem
*menuitem
,
1027 char str
[PATH_LENGTH
], *str1
;
1028 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1029 GtkFileSelection
* file_selector
= (GtkFileSelection
*)gtk_file_selection_new("Select a module");
1030 gtk_file_selection_hide_fileop_buttons(file_selector
);
1033 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
1035 case GTK_RESPONSE_ACCEPT
:
1036 case GTK_RESPONSE_OK
:
1037 dir
= gtk_file_selection_get_selections (file_selector
);
1038 sprintf(str
,dir
[0]);
1039 str1
= strrchr(str
,'/');
1042 str1
= strrchr(str
,'\\');
1045 if(mw_data
->win_creation_data
)
1046 lttv_module_load(str1
, mw_data
->win_creation_data
->argc
,mw_data
->win_creation_data
->argv
);
1048 lttv_module_load(str1
, 0,NULL
);
1049 g_slist_foreach(g_main_window_list
, (gpointer
)insert_menu_toolbar_item
,
1052 case GTK_RESPONSE_REJECT
:
1053 case GTK_RESPONSE_CANCEL
:
1055 gtk_widget_destroy((GtkWidget
*)file_selector
);
1058 g_printf("Load module: %s\n", str
);
1062 /* Display all loaded modules, let user to select a module to unload
1063 * by calling lttv_module_unload
1067 on_unload_module_activate (GtkMenuItem
*menuitem
,
1071 char **name
, *unload_module_name
;
1073 LttvModule
** modules
, *module
;
1074 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1076 modules
= lttv_module_list(&nb
);
1077 name
= g_new(char*, nb
);
1079 module
= modules
[i
];
1080 name
[i
] = lttv_module_name(module
);
1083 unload_module_name
=get_unload_module(name
,nb
);
1085 if(unload_module_name
){
1087 if(strcmp(unload_module_name
, name
[i
]) == 0){
1088 lttv_module_unload(modules
[i
]);
1098 /* Display a directory dialogue to let user select a path for module searching
1102 on_add_module_search_path_activate (GtkMenuItem
*menuitem
,
1105 GtkDirSelection
* file_selector
= (GtkDirSelection
*)gtk_dir_selection_new("Select module path");
1109 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1111 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
1113 case GTK_RESPONSE_ACCEPT
:
1114 case GTK_RESPONSE_OK
:
1115 dir
= gtk_dir_selection_get_dir (file_selector
);
1116 lttv_module_path_add(dir
);
1117 case GTK_RESPONSE_REJECT
:
1118 case GTK_RESPONSE_CANCEL
:
1120 gtk_widget_destroy((GtkWidget
*)file_selector
);
1127 on_color_activate (GtkMenuItem
*menuitem
,
1130 g_printf("Color\n");
1135 on_filter_activate (GtkMenuItem
*menuitem
,
1138 g_printf("Filter\n");
1143 on_save_configuration_activate (GtkMenuItem
*menuitem
,
1146 g_printf("Save configuration\n");
1151 on_content_activate (GtkMenuItem
*menuitem
,
1154 g_printf("Content\n");
1159 on_about_activate (GtkMenuItem
*menuitem
,
1162 g_printf("About...\n");
1167 on_button_new_clicked (GtkButton
*button
,
1170 create_new_window((GtkWidget
*)button
, user_data
, TRUE
);
1174 on_button_new_tab_clicked (GtkButton
*button
,
1177 create_new_tab((GtkWidget
*)button
, user_data
);
1181 on_button_open_clicked (GtkButton
*button
,
1184 open_traceset((GtkWidget
*)button
, user_data
);
1189 on_button_add_trace_clicked (GtkButton
*button
,
1192 add_trace((GtkWidget
*)button
, user_data
);
1197 on_button_remove_trace_clicked (GtkButton
*button
,
1200 remove_trace((GtkWidget
*)button
, user_data
);
1205 on_button_save_clicked (GtkButton
*button
,
1208 save((GtkWidget
*)button
, user_data
);
1213 on_button_save_as_clicked (GtkButton
*button
,
1216 save_as((GtkWidget
*)button
, user_data
);
1221 on_button_zoom_in_clicked (GtkButton
*button
,
1224 zoom_in((GtkWidget
*)button
, user_data
);
1229 on_button_zoom_out_clicked (GtkButton
*button
,
1232 zoom_out((GtkWidget
*)button
, user_data
);
1237 on_button_zoom_extended_clicked (GtkButton
*button
,
1240 zoom_extended((GtkWidget
*)button
, user_data
);
1245 on_button_go_to_time_clicked (GtkButton
*button
,
1248 go_to_time((GtkWidget
*)button
, user_data
);
1253 on_button_show_time_frame_clicked (GtkButton
*button
,
1256 show_time_frame((GtkWidget
*)button
, user_data
);
1261 on_button_move_up_clicked (GtkButton
*button
,
1264 move_up_viewer((GtkWidget
*)button
, user_data
);
1269 on_button_move_down_clicked (GtkButton
*button
,
1272 move_down_viewer((GtkWidget
*)button
, user_data
);
1277 on_button_delete_viewer_clicked (GtkButton
*button
,
1280 delete_viewer((GtkWidget
*)button
, user_data
);
1284 on_MWindow_destroy (GtkObject
*object
,
1287 MainWindow
*Main_Window
= get_window_data_struct((GtkWidget
*)object
);
1289 Tab
*tab
= Main_Window
->tab
;
1291 g_printf("There are : %d windows\n",g_slist_length(g_main_window_list
));
1294 if(g_win_count
== 0)
1299 on_MWindow_configure (GtkWidget
*widget
,
1300 GdkEventConfigure
*event
,
1303 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)widget
);
1304 float width
= event
->width
;
1305 Tab
* tab
= mw_data
->tab
;
1306 TimeWindow time_win
;
1308 TimeInterval
*time_span
;
1311 // MD : removed time width modification upon resizing of the main window.
1312 // The viewers will redraw themselves completely, without time interval
1315 if(mw_data->window_width){
1316 time_span = LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->Time_Span ;
1317 time_win = tab->time_window;
1318 ratio = width / mw_data->window_width;
1319 tab->time_window.time_width = ltt_time_mul(time_win.time_width,ratio);
1320 time = ltt_time_sub(time_span->endTime, time_win.start_time);
1321 if(ltt_time_compare(time, tab->time_window.time_width) < 0){
1322 tab->time_window.time_width = time;
1328 mw_data->window_width = (int)width;
1338 on_MNotebook_switch_page (GtkNotebook
*notebook
,
1339 GtkNotebookPage
*page
,
1343 MainWindow
* mw
= get_window_data_struct((GtkWidget
*)notebook
);
1344 Tab
* tab
= mw
->tab
;
1350 mw
->current_tab
= tab
;
1354 /* callback function to check or uncheck the check box (filter)
1357 void checkbox_changed(GtkTreeView
*treeview
,
1359 GtkTreeViewColumn
*arg2
,
1362 GtkTreeStore
* store
= (GtkTreeStore
*)gtk_tree_view_get_model (treeview
);
1366 if (gtk_tree_model_get_iter ((GtkTreeModel
*)store
, &iter
, arg1
)){
1367 gtk_tree_model_get ((GtkTreeModel
*)store
, &iter
, CHECKBOX_COLUMN
, &value
, -1);
1368 value
= value
? FALSE
: TRUE
;
1369 gtk_tree_store_set (GTK_TREE_STORE (store
), &iter
, CHECKBOX_COLUMN
, value
, -1);
1375 /* According to user's selection, update selector(filter)
1378 void update_filter(LttvTracesetSelector
*s
, GtkTreeStore
*store
)
1380 GtkTreeIter iter
, child_iter
, child_iter1
, child_iter2
;
1381 int i
, j
, k
, nb_eventtype
;
1382 LttvTraceSelector
* trace
;
1383 LttvTracefileSelector
* tracefile
;
1384 LttvEventtypeSelector
* eventtype
;
1385 gboolean value
, value1
, value2
;
1387 if(gtk_tree_model_get_iter_first((GtkTreeModel
*)store
, &iter
)){
1390 trace
= lttv_traceset_selector_trace_get(s
, i
);
1391 nb_eventtype
= lttv_trace_selector_eventtype_number(trace
);
1392 gtk_tree_model_get ((GtkTreeModel
*)store
, &iter
, CHECKBOX_COLUMN
, &value
,-1);
1395 if(gtk_tree_model_iter_children ((GtkTreeModel
*)store
, &child_iter
, &iter
)){
1397 if(j
<1){//eventtype selector for trace
1398 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter
, CHECKBOX_COLUMN
, &value2
,-1);
1401 if(gtk_tree_model_iter_children ((GtkTreeModel
*)store
, &child_iter1
, &child_iter
)){
1403 eventtype
= lttv_trace_selector_eventtype_get(trace
,k
);
1404 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter1
, CHECKBOX_COLUMN
, &value2
,-1);
1405 lttv_eventtype_selector_set_selected(eventtype
,value2
);
1407 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &child_iter1
));
1410 }else{ //tracefile selector
1411 tracefile
= lttv_trace_selector_tracefile_get(trace
, j
- 1);
1412 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter
, CHECKBOX_COLUMN
, &value1
,-1);
1413 lttv_tracefile_selector_set_selected(tracefile
,value1
);
1415 gtk_tree_model_iter_children((GtkTreeModel
*)store
, &child_iter1
, &child_iter
); //eventtype selector
1416 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter1
, CHECKBOX_COLUMN
, &value2
,-1);
1419 if(gtk_tree_model_iter_children ((GtkTreeModel
*)store
, &child_iter2
, &child_iter1
)){
1420 do{//eventtype selector for tracefile
1421 eventtype
= lttv_tracefile_selector_eventtype_get(tracefile
,k
);
1422 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter2
, CHECKBOX_COLUMN
, &value2
,-1);
1423 lttv_eventtype_selector_set_selected(eventtype
,value2
);
1425 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &child_iter2
));
1431 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &child_iter
));
1434 lttv_trace_selector_set_selected(trace
,value
);
1436 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &iter
));
1441 /* Display a dialogue showing all eventtypes and traces, let user to select the interested
1442 * eventtypes, tracefiles and traces (filter)
1445 gboolean
get_filter_selection(LttvTracesetSelector
*s
,char *title
, char * column_title
)
1447 GtkWidget
* dialogue
;
1448 GtkTreeStore
* store
;
1450 GtkWidget
* scroll_win
;
1451 GtkCellRenderer
* renderer
;
1452 GtkTreeViewColumn
* column
;
1453 GtkTreeIter iter
, child_iter
, child_iter1
, child_iter2
;
1454 int i
, j
, k
, id
, nb_trace
, nb_tracefile
, nb_eventtype
;
1455 LttvTraceSelector
* trace
;
1456 LttvTracefileSelector
* tracefile
;
1457 LttvEventtypeSelector
* eventtype
;
1461 dialogue
= gtk_dialog_new_with_buttons(title
,
1464 GTK_STOCK_OK
,GTK_RESPONSE_ACCEPT
,
1465 GTK_STOCK_CANCEL
,GTK_RESPONSE_REJECT
,
1467 gtk_window_set_default_size((GtkWindow
*)dialogue
, 300, 500);
1469 store
= gtk_tree_store_new (TOTAL_COLUMNS
, G_TYPE_BOOLEAN
, G_TYPE_STRING
);
1470 tree
= gtk_tree_view_new_with_model (GTK_TREE_MODEL (store
));
1471 g_object_unref (G_OBJECT (store
));
1472 g_signal_connect (G_OBJECT (tree
), "row-activated",
1473 G_CALLBACK (checkbox_changed
),
1477 renderer
= gtk_cell_renderer_toggle_new ();
1478 gtk_cell_renderer_toggle_set_radio((GtkCellRendererToggle
*)renderer
, FALSE
);
1480 g_object_set (G_OBJECT (renderer
),"activatable", TRUE
, NULL
);
1482 column
= gtk_tree_view_column_new_with_attributes ("Checkbox",
1484 "active", CHECKBOX_COLUMN
,
1486 gtk_tree_view_column_set_alignment (column
, 0.5);
1487 gtk_tree_view_column_set_fixed_width (column
, 20);
1488 gtk_tree_view_append_column (GTK_TREE_VIEW (tree
), column
);
1490 renderer
= gtk_cell_renderer_text_new ();
1491 column
= gtk_tree_view_column_new_with_attributes (column_title
,
1493 "text", NAME_COLUMN
,
1495 gtk_tree_view_column_set_alignment (column
, 0.0);
1496 gtk_tree_view_append_column (GTK_TREE_VIEW (tree
), column
);
1497 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW (tree
), FALSE
);
1499 scroll_win
= gtk_scrolled_window_new (NULL
, NULL
);
1500 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win
),
1501 GTK_POLICY_AUTOMATIC
,GTK_POLICY_AUTOMATIC
);
1502 gtk_container_add (GTK_CONTAINER (scroll_win
), tree
);
1504 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), scroll_win
,TRUE
, TRUE
,0);
1506 gtk_widget_show(scroll_win
);
1507 gtk_widget_show(tree
);
1509 nb_trace
= lttv_traceset_selector_trace_number(s
);
1510 for(i
=0;i
<nb_trace
;i
++){
1511 trace
= lttv_traceset_selector_trace_get(s
, i
);
1512 name
= lttv_trace_selector_get_name(trace
);
1513 gtk_tree_store_append (store
, &iter
, NULL
);
1514 checked
= lttv_trace_selector_get_selected(trace
);
1515 gtk_tree_store_set (store
, &iter
,
1516 CHECKBOX_COLUMN
,checked
,
1520 gtk_tree_store_append (store
, &child_iter
, &iter
);
1521 gtk_tree_store_set (store
, &child_iter
,
1522 CHECKBOX_COLUMN
, checked
,
1523 NAME_COLUMN
,"eventtype",
1526 nb_eventtype
= lttv_trace_selector_eventtype_number(trace
);
1527 for(j
=0;j
<nb_eventtype
;j
++){
1528 eventtype
= lttv_trace_selector_eventtype_get(trace
,j
);
1529 name
= lttv_eventtype_selector_get_name(eventtype
);
1530 checked
= lttv_eventtype_selector_get_selected(eventtype
);
1531 gtk_tree_store_append (store
, &child_iter1
, &child_iter
);
1532 gtk_tree_store_set (store
, &child_iter1
,
1533 CHECKBOX_COLUMN
, checked
,
1538 nb_tracefile
= lttv_trace_selector_tracefile_number(trace
);
1539 for(j
=0;j
<nb_tracefile
;j
++){
1540 tracefile
= lttv_trace_selector_tracefile_get(trace
, j
);
1541 name
= lttv_tracefile_selector_get_name(tracefile
);
1542 gtk_tree_store_append (store
, &child_iter
, &iter
);
1543 checked
= lttv_tracefile_selector_get_selected(tracefile
);
1544 gtk_tree_store_set (store
, &child_iter
,
1545 CHECKBOX_COLUMN
, checked
,
1549 gtk_tree_store_append (store
, &child_iter1
, &child_iter
);
1550 gtk_tree_store_set (store
, &child_iter1
,
1551 CHECKBOX_COLUMN
, checked
,
1552 NAME_COLUMN
,"eventtype",
1555 for(k
=0;k
<nb_eventtype
;k
++){
1556 eventtype
= lttv_tracefile_selector_eventtype_get(tracefile
,k
);
1557 name
= lttv_eventtype_selector_get_name(eventtype
);
1558 checked
= lttv_eventtype_selector_get_selected(eventtype
);
1559 gtk_tree_store_append (store
, &child_iter2
, &child_iter1
);
1560 gtk_tree_store_set (store
, &child_iter2
,
1561 CHECKBOX_COLUMN
, checked
,
1568 id
= gtk_dialog_run(GTK_DIALOG(dialogue
));
1570 case GTK_RESPONSE_ACCEPT
:
1571 case GTK_RESPONSE_OK
:
1572 update_filter(s
, store
);
1573 gtk_widget_destroy(dialogue
);
1575 case GTK_RESPONSE_REJECT
:
1576 case GTK_RESPONSE_CANCEL
:
1578 gtk_widget_destroy(dialogue
);
1585 /* Select a trace which will be removed from traceset
1588 char * get_remove_trace(char ** all_trace_name
, int nb_trace
)
1590 return get_selection(all_trace_name
, nb_trace
,
1591 "Select a trace", "Trace pathname");
1595 /* Select a module which will be unloaded
1598 char * get_unload_module(char ** loaded_module_name
, int nb_module
)
1600 return get_selection(loaded_module_name
, nb_module
,
1601 "Select an unload module", "Module pathname");
1605 /* Display a dialogue which shows all selectable items, let user to
1606 * select one of them
1609 char * get_selection(char ** loaded_module_name
, int nb_module
,
1610 char *title
, char * column_title
)
1612 GtkWidget
* dialogue
;
1613 GtkWidget
* scroll_win
;
1615 GtkListStore
* store
;
1616 GtkTreeViewColumn
* column
;
1617 GtkCellRenderer
* renderer
;
1618 GtkTreeSelection
* select
;
1621 char * unload_module_name
= NULL
;
1623 dialogue
= gtk_dialog_new_with_buttons(title
,
1626 GTK_STOCK_OK
,GTK_RESPONSE_ACCEPT
,
1627 GTK_STOCK_CANCEL
,GTK_RESPONSE_REJECT
,
1629 gtk_window_set_default_size((GtkWindow
*)dialogue
, 500, 200);
1631 scroll_win
= gtk_scrolled_window_new (NULL
, NULL
);
1632 gtk_widget_show ( scroll_win
);
1633 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win
),
1634 GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
1636 store
= gtk_list_store_new (N_COLUMNS
,G_TYPE_STRING
);
1637 tree
= gtk_tree_view_new_with_model(GTK_TREE_MODEL (store
));
1638 gtk_widget_show ( tree
);
1639 g_object_unref (G_OBJECT (store
));
1641 renderer
= gtk_cell_renderer_text_new ();
1642 column
= gtk_tree_view_column_new_with_attributes (column_title
,
1644 "text", MODULE_COLUMN
,
1646 gtk_tree_view_column_set_alignment (column
, 0.5);
1647 gtk_tree_view_column_set_fixed_width (column
, 150);
1648 gtk_tree_view_append_column (GTK_TREE_VIEW (tree
), column
);
1650 select
= gtk_tree_view_get_selection (GTK_TREE_VIEW (tree
));
1651 gtk_tree_selection_set_mode (select
, GTK_SELECTION_SINGLE
);
1653 gtk_container_add (GTK_CONTAINER (scroll_win
), tree
);
1655 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), scroll_win
,TRUE
, TRUE
,0);
1657 for(i
=0;i
<nb_module
;i
++){
1658 gtk_list_store_append (store
, &iter
);
1659 gtk_list_store_set (store
, &iter
, MODULE_COLUMN
,loaded_module_name
[i
],-1);
1662 id
= gtk_dialog_run(GTK_DIALOG(dialogue
));
1664 case GTK_RESPONSE_ACCEPT
:
1665 case GTK_RESPONSE_OK
:
1666 if (gtk_tree_selection_get_selected (select
, (GtkTreeModel
**)&store
, &iter
)){
1667 gtk_tree_model_get ((GtkTreeModel
*)store
, &iter
, MODULE_COLUMN
, &unload_module_name
, -1);
1669 case GTK_RESPONSE_REJECT
:
1670 case GTK_RESPONSE_CANCEL
:
1672 gtk_widget_destroy(dialogue
);
1676 return unload_module_name
;
1683 void main_window_destroy_hash_key(gpointer key
)
1688 void main_window_destroy_hash_data(gpointer data
)
1693 /* Insert menu entry and tool button into all main windows for modules
1694 * It checks whether the menu entry or tool button exists or not,
1695 * if they do not exist, then construct the widget and insert them
1696 * into all main windows
1699 void insert_menu_toolbar_item(MainWindow
* mw
, gpointer user_data
)
1703 view_constructor constructor
;
1705 LttvToolbars
* toolbar
;
1706 lttv_menu_closure
*menu_item
;
1707 lttv_toolbar_closure
*toolbar_item
;
1708 LttvAttributeValue value
;
1709 LttvIAttribute
*attributes
= LTTV_IATTRIBUTE(lttv_global_attributes());
1710 GtkWidget
* tool_menu_title_menu
, *insert_view
, *pixmap
, *tmp
;
1712 g_assert(lttv_iattribute_find_by_path(attributes
,
1713 "viewers/menu", LTTV_POINTER
, &value
));
1714 menu
= (LttvMenus
*)*(value
.v_pointer
);
1717 for(i
=0;i
<menu
->len
;i
++){
1718 menu_item
= &g_array_index(menu
, lttv_menu_closure
, i
);
1719 tmp
= g_hash_table_lookup(mw
->hash_menu_item
, g_strdup(menu_item
->menuText
));
1721 constructor
= menu_item
->con
;
1722 tool_menu_title_menu
= lookup_widget(mw
->mwindow
,"ToolMenuTitle_menu");
1723 insert_view
= gtk_menu_item_new_with_mnemonic (menu_item
->menuText
);
1724 gtk_widget_show (insert_view
);
1725 gtk_container_add (GTK_CONTAINER (tool_menu_title_menu
), insert_view
);
1726 g_signal_connect ((gpointer
) insert_view
, "activate",
1727 G_CALLBACK (insert_viewer_wrap
),
1729 g_hash_table_insert(mw
->hash_menu_item
, g_strdup(menu_item
->menuText
),
1734 g_assert(lttv_iattribute_find_by_path(attributes
,
1735 "viewers/toolbar", LTTV_POINTER
, &value
));
1736 toolbar
= (LttvToolbars
*)*(value
.v_pointer
);
1739 for(i
=0;i
<toolbar
->len
;i
++){
1740 toolbar_item
= &g_array_index(toolbar
, lttv_toolbar_closure
, i
);
1741 tmp
= g_hash_table_lookup(mw
->hash_toolbar_item
, g_strdup(toolbar_item
->tooltip
));
1743 constructor
= toolbar_item
->con
;
1744 tool_menu_title_menu
= lookup_widget(mw
->mwindow
,"MToolbar1");
1745 pixbuf
= gdk_pixbuf_new_from_xpm_data ((const char**)toolbar_item
->pixmap
);
1746 pixmap
= gtk_image_new_from_pixbuf(pixbuf
);
1747 insert_view
= gtk_toolbar_append_element (GTK_TOOLBAR (tool_menu_title_menu
),
1748 GTK_TOOLBAR_CHILD_BUTTON
,
1751 toolbar_item
->tooltip
, NULL
,
1752 pixmap
, NULL
, NULL
);
1753 gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild
*) (g_list_last (GTK_TOOLBAR (tool_menu_title_menu
)->children
)->data
))->label
), TRUE
);
1754 gtk_widget_show (insert_view
);
1755 gtk_container_set_border_width (GTK_CONTAINER (insert_view
), 1);
1756 g_signal_connect ((gpointer
) insert_view
, "clicked",G_CALLBACK (insert_viewer_wrap
),constructor
);
1757 g_hash_table_insert(mw
->hash_toolbar_item
, g_strdup(toolbar_item
->tooltip
),
1764 /* Create a main window
1767 void construct_main_window(MainWindow
* parent
, WindowCreationData
* win_creation_data
)
1769 g_debug("construct_main_window()");
1770 GtkWidget
* new_window
; /* New generated main window */
1771 MainWindow
* new_m_window
;/* New main window structure */
1772 GtkNotebook
* notebook
;
1773 LttvIAttribute
*attributes
=
1774 LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
));
1775 LttvAttributeValue value
;
1777 new_m_window
= g_new(MainWindow
, 1);
1779 // Add the object's information to the module's array
1780 g_main_window_list
= g_slist_append(g_main_window_list
, new_m_window
);
1783 new_window
= create_MWindow();
1784 gtk_widget_show (new_window
);
1786 new_m_window
->attributes
= attributes
;
1788 new_m_window
->mwindow
= new_window
;
1789 new_m_window
->tab
= NULL
;
1790 new_m_window
->current_tab
= NULL
;
1791 new_m_window
->attributes
= LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
));
1793 new_m_window
->win_creation_data
= parent
->win_creation_data
;
1795 new_m_window
->win_creation_data
= win_creation_data
;
1798 new_m_window
->hash_menu_item
= g_hash_table_new_full (g_str_hash
, g_str_equal
,
1799 main_window_destroy_hash_key
,
1800 main_window_destroy_hash_data
);
1801 new_m_window
->hash_toolbar_item
= g_hash_table_new_full (g_str_hash
, g_str_equal
,
1802 main_window_destroy_hash_key
,
1803 main_window_destroy_hash_data
);
1805 insert_menu_toolbar_item(new_m_window
, NULL
);
1807 g_object_set_data(G_OBJECT(new_window
), "mainWindow", (gpointer
)new_m_window
);
1809 //create a default tab
1810 notebook
= (GtkNotebook
*)lookup_widget(new_m_window
->mwindow
, "MNotebook");
1811 if(notebook
== NULL
){
1812 g_printf("Notebook does not exist\n");
1815 //for now there is no name field in LttvTraceset structure
1816 //Use "Traceset" as the label for the default tab
1817 create_tab(parent
, new_m_window
, notebook
,"Traceset");
1819 g_object_set_data_full(
1820 G_OBJECT(new_m_window
->mwindow
),
1823 (GDestroyNotify
)main_window_free
);
1829 /* Free the memory occupied by a tab structure
1833 void tab_destructor(Tab
* tab_instance
)
1835 int i
, nb
, ref_count
;
1838 if(tab_instance
->attributes
)
1839 g_object_unref(tab_instance
->attributes
);
1841 if(tab_instance
->mw
->tab
== tab_instance
){
1842 tab_instance
->mw
->tab
= tab_instance
->next
;
1844 Tab
* tmp1
, *tmp
= tab_instance
->mw
->tab
;
1845 while(tmp
!= tab_instance
){
1849 tmp1
->next
= tab_instance
->next
;
1852 if(tab_instance
->traceset_info
->traceset_context
!= NULL
){
1853 lttv_context_fini(LTTV_TRACESET_CONTEXT(tab_instance
->traceset_info
->
1855 g_object_unref(tab_instance
->traceset_info
->traceset_context
);
1857 if(tab_instance
->traceset_info
->traceset
!= NULL
) {
1858 nb
= lttv_traceset_number(tab_instance
->traceset_info
->traceset
);
1859 for(i
= 0 ; i
< nb
; i
++) {
1860 trace
= lttv_traceset_get(tab_instance
->traceset_info
->traceset
, i
);
1861 ref_count
= lttv_trace_get_ref_number(trace
);
1863 ltt_trace_close(lttv_trace(trace
));
1864 lttv_trace_destroy(trace
);
1866 // lttv_trace_destroy(trace);
1869 lttv_traceset_destroy(tab_instance
->traceset_info
->traceset
);
1870 g_free(tab_instance
->traceset_info
);
1871 g_free(tab_instance
);
1875 /* Create a tab and insert it into the current main window
1878 void * create_tab(MainWindow
* parent
, MainWindow
* current_window
,
1879 GtkNotebook
* notebook
, char * label
)
1883 MainWindow
* mw_data
= current_window
;
1886 //create a new tab data structure
1887 tmp_tab
= mw_data
->tab
;
1888 while(tmp_tab
&& tmp_tab
->next
) tmp_tab
= tmp_tab
->next
;
1890 mw_data
->current_tab
= NULL
;
1891 tmp_tab
= g_new(Tab
,1);
1892 mw_data
->tab
= tmp_tab
;
1894 tmp_tab
->next
= g_new(Tab
,1);
1895 tmp_tab
= tmp_tab
->next
;
1898 //construct and initialize the traceset_info
1899 tmp_tab
->traceset_info
= g_new(TracesetInfo
,1);
1901 tmp_tab
->traceset_info
->traceset
=
1902 lttv_traceset_copy(parent
->current_tab
->traceset_info
->traceset
);
1904 if(mw_data
->current_tab
){
1905 tmp_tab
->traceset_info
->traceset
=
1906 lttv_traceset_copy(mw_data
->current_tab
->traceset_info
->traceset
);
1908 tmp_tab
->traceset_info
->traceset
= lttv_traceset_new();
1909 /* Add the command line trace */
1910 if(g_init_trace
!= NULL
)
1911 lttv_traceset_add(tmp_tab
->traceset_info
->traceset
, g_init_trace
);
1914 //FIXME copy not implemented in lower level
1915 tmp_tab
->traceset_info
->traceset_context
=
1916 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
1918 LTTV_TRACESET_CONTEXT(tmp_tab
->traceset_info
->traceset_context
),
1919 tmp_tab
->traceset_info
->traceset
);
1921 //determine the current_time and time_window of the tab
1922 if(mw_data
->current_tab
){
1923 // Will have to read directly at the main window level, as we want
1924 // to be able to modify a traceset on the fly.
1925 tmp_tab
->time_window
= mw_data
->current_tab
->time_window
;
1926 tmp_tab
->current_time
= mw_data
->current_tab
->current_time
;
1928 // Will have to read directly at the main window level, as we want
1929 // to be able to modify a traceset on the fly.
1930 // get_traceset_time_span(mw_data,&tmp_tab->traceStartTime, &tmp_tab->traceEndTime);
1931 tmp_tab
->time_window
.start_time
=
1932 LTTV_TRACESET_CONTEXT(tmp_tab
->traceset_info
->traceset_context
)->Time_Span
->startTime
;
1933 if(DEFAULT_TIME_WIDTH_S
<
1934 LTTV_TRACESET_CONTEXT(tmp_tab
->traceset_info
->traceset_context
)->Time_Span
->endTime
.tv_sec
)
1935 tmp_time
.tv_sec
= DEFAULT_TIME_WIDTH_S
;
1938 LTTV_TRACESET_CONTEXT(tmp_tab
->traceset_info
->traceset_context
)->Time_Span
->endTime
.tv_sec
;
1939 tmp_time
.tv_nsec
= 0;
1940 tmp_tab
->time_window
.time_width
= tmp_time
;
1941 tmp_tab
->current_time
.tv_sec
=
1942 LTTV_TRACESET_CONTEXT(tmp_tab
->traceset_info
->traceset_context
)->Time_Span
->startTime
.tv_sec
;
1943 tmp_tab
->current_time
.tv_nsec
=
1944 LTTV_TRACESET_CONTEXT(tmp_tab
->traceset_info
->traceset_context
)->Time_Span
->startTime
.tv_nsec
;
1946 tmp_tab
->attributes
= LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
));
1947 // mw_data->current_tab = tmp_tab;
1948 tmp_tab
->multi_vpaned
= (GtkMultiVPaned
*)gtk_multi_vpaned_new();
1949 tmp_tab
->multi_vpaned
->mw
= mw_data
;
1950 gtk_widget_show((GtkWidget
*)tmp_tab
->multi_vpaned
);
1951 tmp_tab
->next
= NULL
;
1952 tmp_tab
->mw
= mw_data
;
1954 tmp_tab
->label
= gtk_label_new (label
);
1955 gtk_widget_show (tmp_tab
->label
);
1957 g_object_set_data_full(
1958 G_OBJECT(tmp_tab
->multi_vpaned
),
1961 (GDestroyNotify
)tab_destructor
);
1963 //add state update hooks
1964 lttv_state_add_event_hooks(
1965 (LttvTracesetState
*)tmp_tab
->traceset_info
->traceset_context
);
1967 //insert tab into notebook
1968 gtk_notebook_append_page(notebook
, (GtkWidget
*)tmp_tab
->multi_vpaned
, tmp_tab
->label
);
1969 list
= gtk_container_get_children(GTK_CONTAINER(notebook
));
1970 gtk_notebook_set_current_page(notebook
,g_list_length(list
)-1);
1971 if(g_list_length(list
)>1)
1972 gtk_notebook_set_show_tabs(notebook
, TRUE
);
1976 /* Remove menu entry and tool button from main window for the
1980 void remove_menu_item(gpointer main_win
, gpointer user_data
)
1982 MainWindow
* mw
= (MainWindow
*) main_win
;
1983 lttv_menu_closure
*menu_item
= (lttv_menu_closure
*)user_data
;
1984 GtkWidget
* tool_menu_title_menu
, *insert_view
;
1986 tool_menu_title_menu
= lookup_widget(mw
->mwindow
,"ToolMenuTitle_menu");
1987 insert_view
= (GtkWidget
*)g_hash_table_lookup(mw
->hash_menu_item
,
1988 menu_item
->menuText
);
1990 g_hash_table_remove(mw
->hash_menu_item
, menu_item
->menuText
);
1991 gtk_container_remove (GTK_CONTAINER (tool_menu_title_menu
), insert_view
);
1995 void remove_toolbar_item(gpointer main_win
, gpointer user_data
)
1997 MainWindow
* mw
= (MainWindow
*) main_win
;
1998 lttv_toolbar_closure
*toolbar_item
= (lttv_toolbar_closure
*)user_data
;
1999 GtkWidget
* tool_menu_title_menu
, *insert_view
;
2002 tool_menu_title_menu
= lookup_widget(mw
->mwindow
,"MToolbar1");
2003 insert_view
= (GtkWidget
*)g_hash_table_lookup(mw
->hash_toolbar_item
,
2004 toolbar_item
->tooltip
);
2006 g_hash_table_remove(mw
->hash_toolbar_item
, toolbar_item
->tooltip
);
2007 gtk_container_remove (GTK_CONTAINER (tool_menu_title_menu
), insert_view
);
2012 * Remove menu and toolbar item when a module unloaded from all
2016 void main_window_remove_menu_item(lttv_constructor constructor
)
2020 lttv_menu_closure
*menu_item
;
2021 LttvAttributeValue value
;
2022 LttvIAttribute
*attributes
= LTTV_IATTRIBUTE(lttv_global_attributes());
2024 g_assert(lttv_iattribute_find_by_path(attributes
,
2025 "viewers/menu", LTTV_POINTER
, &value
));
2026 menu
= (LttvMenus
*)*(value
.v_pointer
);
2029 for(i
=0;i
<menu
->len
;i
++){
2030 menu_item
= &g_array_index(menu
, lttv_menu_closure
, i
);
2031 if(menu_item
->con
!= constructor
) continue;
2032 if(g_main_window_list
){
2033 g_slist_foreach(g_main_window_list
, remove_menu_item
, menu_item
);
2041 void main_window_remove_toolbar_item(lttv_constructor constructor
)
2044 LttvToolbars
* toolbar
;
2045 lttv_toolbar_closure
*toolbar_item
;
2046 LttvAttributeValue value
;
2047 LttvIAttribute
*attributes
= LTTV_IATTRIBUTE(lttv_global_attributes());
2049 g_assert(lttv_iattribute_find_by_path(attributes
,
2050 "viewers/toolbar", LTTV_POINTER
, &value
));
2051 toolbar
= (LttvToolbars
*)*(value
.v_pointer
);
2054 for(i
=0;i
<toolbar
->len
;i
++){
2055 toolbar_item
= &g_array_index(toolbar
, lttv_toolbar_closure
, i
);
2056 if(toolbar_item
->con
!= constructor
) continue;
2057 if(g_main_window_list
){
2058 g_slist_foreach(g_main_window_list
, remove_toolbar_item
, toolbar_item
);