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 <ltt/trace.h>
29 #include <ltt/facility.h>
31 #include <ltt/event.h>
32 #include <lttv/lttv.h>
33 #include <lttv/module.h>
34 #include <lttv/iattribute.h>
35 #include <lttv/stats.h>
36 #include <lttvwindow/mainwindow.h>
37 #include <lttvwindow/menu.h>
38 #include <lttvwindow/toolbar.h>
39 #include <lttvwindow/viewer.h>
40 #include <lttvwindow/gtkdirsel.h>
41 #include <lttvwindow/lttvfilter.h>
43 #define PATH_LENGTH 256
44 #define DEFAULT_TIME_WIDTH_S 1
46 extern LttvTrace
*g_init_trace
;
49 /** Array containing instanced objects. */
50 extern GSList
* g_main_window_list
;
52 static int g_win_count
= 0;
54 /** MD : keep old directory. */
55 static char remember_plugins_dir
[PATH_LENGTH
] = "";
56 static char remember_trace_dir
[PATH_LENGTH
] = "";
59 MainWindow
* get_window_data_struct(GtkWidget
* widget
);
60 char * get_unload_module(char ** loaded_module_name
, int nb_module
);
61 char * get_remove_trace(char ** all_trace_name
, int nb_trace
);
62 char * get_selection(char ** all_name
, int nb
, char *title
, char * column_title
);
63 gboolean
get_filter_selection(LttvTracesetSelector
*s
, char *title
, char * column_title
);
64 void * create_tab(MainWindow
* parent
, MainWindow
* current_window
,
65 GtkNotebook
* notebook
, char * label
);
67 void insert_viewer(GtkWidget
* widget
, lttvwindow_viewer_constructor constructor
);
68 void update_filter(LttvTracesetSelector
*s
, GtkTreeStore
*store
);
70 void checkbox_changed(GtkTreeView
*treeview
,
72 GtkTreeViewColumn
*arg2
,
74 void remove_trace_from_traceset_selector(GtkMultiVPaned
* paned
, unsigned i
);
75 void add_trace_into_traceset_selector(GtkMultiVPaned
* paned
, LttTrace
* trace
);
77 LttvTracesetSelector
* construct_traceset_selector(LttvTraceset
* traceset
);
79 void call_pending_read_hooks(MainWindow
* mw_data
);
80 unsigned get_max_event_number(MainWindow
* mw_data
);
94 /* Construct a selector(filter), which will be associated with a viewer,
95 * and provides an interface for user to select interested events and traces
98 LttvTracesetSelector
* construct_traceset_selector(LttvTraceset
* traceset
)
100 LttvTracesetSelector
* s
;
101 LttvTraceSelector
* trace
;
102 LttvTracefileSelector
* tracefile
;
103 LttvEventtypeSelector
* eventtype
;
105 int nb_trace
, nb_tracefile
, nb_control
, nb_per_cpu
, nb_facility
, nb_event
;
112 s
= lttv_traceset_selector_new(lttv_traceset_name(traceset
));
113 nb_trace
= lttv_traceset_number(traceset
);
114 for(i
=0;i
<nb_trace
;i
++){
115 trace_v
= lttv_traceset_get(traceset
, i
);
116 t
= lttv_trace(trace_v
);
117 trace
= lttv_trace_selector_new(t
);
118 lttv_traceset_selector_trace_add(s
, trace
);
120 nb_facility
= ltt_trace_facility_number(t
);
121 for(k
=0;k
<nb_facility
;k
++){
122 fac
= ltt_trace_facility_get(t
,k
);
123 nb_event
= (int) ltt_facility_eventtype_number(fac
);
124 for(m
=0;m
<nb_event
;m
++){
125 et
= ltt_facility_eventtype_get(fac
,m
);
126 eventtype
= lttv_eventtype_selector_new(et
);
127 lttv_trace_selector_eventtype_add(trace
, eventtype
);
131 nb_control
= ltt_trace_control_tracefile_number(t
);
132 nb_per_cpu
= ltt_trace_per_cpu_tracefile_number(t
);
133 nb_tracefile
= nb_control
+ nb_per_cpu
;
135 for(j
= 0 ; j
< nb_tracefile
; j
++) {
137 tf
= ltt_trace_control_tracefile_get(t
, j
);
139 tf
= ltt_trace_per_cpu_tracefile_get(t
, j
- nb_control
);
140 tracefile
= lttv_tracefile_selector_new(tf
);
141 lttv_trace_selector_tracefile_add(trace
, tracefile
);
142 lttv_eventtype_selector_copy(trace
, tracefile
);
149 /* insert_viewer function constructs an instance of a viewer first,
150 * then inserts the widget of the instance into the container of the
155 insert_viewer_wrap(GtkWidget
*menuitem
, gpointer user_data
)
159 insert_viewer((GtkWidget
*)menuitem
, (lttvwindow_viewer_constructor
)user_data
);
160 // selected_hook(&val);
164 /* internal functions */
165 void insert_viewer(GtkWidget
* widget
, lttvwindow_viewer_constructor constructor
)
167 GtkMultiVPaned
* multi_vpaned
;
168 MainWindow
* mw_data
;
170 LttvTracesetSelector
* s
;
171 TimeInterval
* time_interval
;
173 mw_data
= get_window_data_struct(widget
);
174 if(!mw_data
->current_tab
) return;
175 multi_vpaned
= mw_data
->current_tab
->multi_vpaned
;
177 s
= construct_traceset_selector(mw_data
->current_tab
->traceset_info
->traceset
);
178 viewer
= (GtkWidget
*)constructor(mw_data
, s
, "Traceset_Selector");
181 gtk_multi_vpaned_widget_add(multi_vpaned
, viewer
);
182 // We unref here, because it is now referenced by the multi_vpaned!
183 g_object_unref(G_OBJECT(viewer
));
185 // The viewer will show itself when it receives a show notify
186 // So we call the show notify hooks here. It will
187 // typically add hooks for reading, we call process trace, and the
188 // end of reading hook will call gtk_widget_show and unregister the
190 // Note that show notify gets the time_requested through the call_data.
191 //show_viewer(mw_data);
192 // in expose now call_pending_read_hooks(mw_data);
197 /* get_label function is used to get user input, it displays an input
198 * box, which allows user to input a string
201 void get_label_string (GtkWidget
* text
, gchar
* label
)
203 GtkEntry
* entry
= (GtkEntry
*)text
;
204 if(strlen(gtk_entry_get_text(entry
))!=0)
205 strcpy(label
,gtk_entry_get_text(entry
));
208 gboolean
get_label(MainWindow
* mw
, gchar
* str
, gchar
* dialogue_title
, gchar
* label_str
)
210 GtkWidget
* dialogue
;
215 dialogue
= gtk_dialog_new_with_buttons(dialogue_title
,NULL
,
217 GTK_STOCK_OK
,GTK_RESPONSE_ACCEPT
,
218 GTK_STOCK_CANCEL
,GTK_RESPONSE_REJECT
,
221 label
= gtk_label_new(label_str
);
222 gtk_widget_show(label
);
224 text
= gtk_entry_new();
225 gtk_widget_show(text
);
227 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), label
,TRUE
, TRUE
,0);
228 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), text
,FALSE
, FALSE
,0);
230 id
= gtk_dialog_run(GTK_DIALOG(dialogue
));
232 case GTK_RESPONSE_ACCEPT
:
233 get_label_string(text
,str
);
234 gtk_widget_destroy(dialogue
);
236 case GTK_RESPONSE_REJECT
:
238 gtk_widget_destroy(dialogue
);
245 /* get_window_data_struct function is actually a lookup function,
246 * given a widget which is in the tree of the main window, it will
247 * return the MainWindow data structure associated with main window
250 MainWindow
* get_window_data_struct(GtkWidget
* widget
)
253 MainWindow
* mw_data
;
255 mw
= lookup_widget(widget
, "MWindow");
257 g_printf("Main window does not exist\n");
261 mw_data
= (MainWindow
*) g_object_get_data(G_OBJECT(mw
),"mainWindow");
263 g_printf("Main window data does not exist\n");
270 /* create_new_window function, just constructs a new main window
273 void create_new_window(GtkWidget
* widget
, gpointer user_data
, gboolean clone
)
275 MainWindow
* parent
= get_window_data_struct(widget
);
278 g_printf("Clone : use the same traceset\n");
279 construct_main_window(parent
);
281 g_printf("Empty : traceset is set to NULL\n");
282 construct_main_window(NULL
);
287 /* move_*_viewer functions move the selected view up/down in
291 void move_up_viewer(GtkWidget
* widget
, gpointer user_data
)
293 MainWindow
* mw
= get_window_data_struct(widget
);
294 if(!mw
->current_tab
) return;
295 gtk_multi_vpaned_widget_move_up(mw
->current_tab
->multi_vpaned
);
298 void move_down_viewer(GtkWidget
* widget
, gpointer user_data
)
300 MainWindow
* mw
= get_window_data_struct(widget
);
301 if(!mw
->current_tab
) return;
302 gtk_multi_vpaned_widget_move_down(mw
->current_tab
->multi_vpaned
);
306 /* delete_viewer deletes the selected viewer in the current tab
309 void delete_viewer(GtkWidget
* widget
, gpointer user_data
)
311 MainWindow
* mw
= get_window_data_struct(widget
);
312 if(!mw
->current_tab
) return;
313 gtk_multi_vpaned_widget_delete(mw
->current_tab
->multi_vpaned
);
317 /* open_traceset will open a traceset saved in a file
318 * Right now, it is not finished yet, (not working)
322 void open_traceset(GtkWidget
* widget
, gpointer user_data
)
326 LttvTraceset
* traceset
;
327 MainWindow
* mw_data
= get_window_data_struct(widget
);
328 GtkFileSelection
* file_selector
=
329 (GtkFileSelection
*)gtk_file_selection_new("Select a traceset");
331 gtk_file_selection_hide_fileop_buttons(file_selector
);
333 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
335 case GTK_RESPONSE_ACCEPT
:
336 case GTK_RESPONSE_OK
:
337 dir
= gtk_file_selection_get_selections (file_selector
);
338 traceset
= lttv_traceset_load(dir
[0]);
339 g_printf("Open a trace set %s\n", dir
[0]);
342 case GTK_RESPONSE_REJECT
:
343 case GTK_RESPONSE_CANCEL
:
345 gtk_widget_destroy((GtkWidget
*)file_selector
);
352 /* get_max_event_number returns the event number limit used by
353 * lttv_process_traceset(LttvTracesetContext, endTime, maxNumEvents)
354 * each viewer can set the limit
357 unsigned get_max_event_number(MainWindow
* mw_data
)
359 unsigned nb
= 0, *size
;
362 w
= gtk_multi_vpaned_get_first_widget(mw_data
->current_tab
->multi_vpaned
);
364 size
= (unsigned*)g_object_get_data(G_OBJECT(w
), MAX_NUMBER_EVENT
);
372 w
= gtk_multi_vpaned_get_next_widget(mw_data
->current_tab
->multi_vpaned
);
378 /* call_pending_read_hooks parses the traceset first by calling
379 * process_traceset, then display all viewers of
381 * It will then remove all entries from the time_requests array.
382 * CHECK : we give more events than requested to the viewers. They
383 * Have to filter them by themselves.
386 gint
compare_time_request(TimeRequest
*a
, TimeRequest
*b
)
388 return ltt_time_compare(a
->time_window
.start_time
, b
->time_window
.start_time
);
391 void call_pending_read_hooks(MainWindow
* mw_data
)
393 unsigned max_nb_events
;
398 LttvTracesetContext
*tsc
;
400 /* Current tab check : if no current tab is present, no hooks to call. */
401 /* It makes the expose works.. */
402 if(mw_data
->current_tab
== NULL
)
405 if(mw_data
->current_tab
->time_requests
->len
== 0)
408 LttvHooks
*tmp_hooks
= lttv_hooks_new();
411 LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->traceset_info
->
414 //set the cursor to be X shape, indicating that the computer is busy in doing its job
415 new = gdk_cursor_new(GDK_X_CURSOR
);
416 widget
= lookup_widget(mw_data
->mwindow
, "MToolbar1");
417 win
= gtk_widget_get_parent_window(widget
);
418 gdk_window_set_cursor(win
, new);
419 gdk_cursor_unref(new);
420 gdk_window_stick(win
);
421 gdk_window_unstick(win
);
424 g_array_sort(mw_data
->current_tab
->time_requests
,
425 (GCompareFunc
)compare_time_request
);
428 //update time window of each viewer, let viewer insert hooks needed by process_traceset
429 //lttvwindow_report_time_window(mw_data, time_window);
431 //max_nb_events = get_max_event_number(mw_data);
433 //call hooks to show each viewer and let them remove hooks
434 //show_viewer(mw_data);
437 // call process trace for each time interval
438 // Will have to be combined!
439 g_critical("SIZE time req len : %d", mw_data
->current_tab
->time_requests
->len
);
441 //g_assert(mw_data->current_tab->time_requests->len <= 1); //FIXME
442 /* Go through each time request. As they are already sorted by start_time,
443 * we check with the current event time if processing is needed. */
444 for(i
=0; i
< mw_data
->current_tab
->time_requests
->len
; i
++)
446 g_critical("RUN i %d", i
);
447 TimeRequest
*time_request
=
448 &g_array_index(mw_data
->current_tab
->time_requests
, TimeRequest
, i
);
449 LttTime end_time
= ltt_time_add( time_request
->time_window
.start_time
,
450 time_request
->time_window
.time_width
);
452 if(i
== 0 || !(ltt_time_compare(time_request
->time_window
.start_time
, ltt_event_time(tsc
->e
))<0) )
454 /* do it if first request or start_time >= last event's time */
455 lttv_process_traceset_seek_time(tsc
, time_request
->time_window
.start_time
);
456 lttv_process_traceset(tsc
, end_time
, time_request
->num_events
);
460 if(ltt_time_compare(time_request
->time_window
.start_time
, ltt_event_time(tsc
->e
))<0
461 && !(ltt_time_compare(end_time
, ltt_event_time(tsc
->e
))<0))
463 /* Continue reading from current event */
464 lttv_process_traceset(tsc
, end_time
, time_request
->num_events
);
469 if(ltt_time_compare(time_request
->time_window
.start_time
, end_time
) > 0)
471 /* This is a request for a minimum number of events, give
472 * more events than necessary */
473 lttv_process_traceset(tsc
, end_time
, time_request
->num_events
);
478 /* Call the end of process_traceset hook */
479 lttv_hooks_add(tmp_hooks
,
480 time_request
->after_hook
,
481 time_request
->after_hook_data
);
482 lttv_hooks_call(tmp_hooks
, time_request
);
483 lttv_hooks_remove(tmp_hooks
, time_request
->after_hook
);
486 /* Free the time requests */
487 g_array_free(mw_data
->current_tab
->time_requests
, TRUE
);
488 mw_data
->current_tab
->time_requests
=
489 g_array_new(FALSE
, FALSE
, sizeof(TimeRequest
));
491 mw_data
->current_tab
->time_request_pending
= FALSE
;
493 lttv_hooks_destroy(tmp_hooks
);
495 //set the cursor back to normal
496 gdk_window_set_cursor(win
, NULL
);
500 /* add_trace_into_traceset_selector, each instance of a viewer has an associated
501 * selector (filter), when a trace is added into traceset, the selector should
502 * reflect the change. The function is used to update the selector
505 void add_trace_into_traceset_selector(GtkMultiVPaned
* paned
, LttTrace
* t
)
507 int j
, k
, m
, nb_tracefile
, nb_control
, nb_per_cpu
, nb_facility
, nb_event
;
508 LttvTracesetSelector
* s
;
509 LttvTraceSelector
* trace
;
510 LttvTracefileSelector
* tracefile
;
511 LttvEventtypeSelector
* eventtype
;
517 w
= gtk_multi_vpaned_get_first_widget(paned
);
519 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
522 trace
= lttv_trace_selector_new(t
);
523 lttv_traceset_selector_trace_add(s
, trace
);
525 nb_facility
= ltt_trace_facility_number(t
);
526 for(k
=0;k
<nb_facility
;k
++){
527 fac
= ltt_trace_facility_get(t
,k
);
528 nb_event
= (int) ltt_facility_eventtype_number(fac
);
529 for(m
=0;m
<nb_event
;m
++){
530 et
= ltt_facility_eventtype_get(fac
,m
);
531 eventtype
= lttv_eventtype_selector_new(et
);
532 lttv_trace_selector_eventtype_add(trace
, eventtype
);
536 nb_control
= ltt_trace_control_tracefile_number(t
);
537 nb_per_cpu
= ltt_trace_per_cpu_tracefile_number(t
);
538 nb_tracefile
= nb_control
+ nb_per_cpu
;
540 for(j
= 0 ; j
< nb_tracefile
; j
++) {
542 tf
= ltt_trace_control_tracefile_get(t
, j
);
544 tf
= ltt_trace_per_cpu_tracefile_get(t
, j
- nb_control
);
545 tracefile
= lttv_tracefile_selector_new(tf
);
546 lttv_trace_selector_tracefile_add(trace
, tracefile
);
547 lttv_eventtype_selector_copy(trace
, tracefile
);
549 }else g_warning("Module does not support filtering\n");
551 w
= gtk_multi_vpaned_get_next_widget(paned
);
556 /* add_trace adds a trace into the current traceset. It first displays a
557 * directory selection dialogue to let user choose a trace, then recreates
558 * tracset_context, and redraws all the viewer of the current tab
561 void add_trace(GtkWidget
* widget
, gpointer user_data
)
565 LttvTraceset
* traceset
;
569 MainWindow
* mw_data
= get_window_data_struct(widget
);
570 GtkDirSelection
* file_selector
= (GtkDirSelection
*)gtk_dir_selection_new("Select a trace");
571 gtk_dir_selection_hide_fileop_buttons(file_selector
);
572 if(remember_trace_dir
[0] != '\0')
573 gtk_dir_selection_set_filename(file_selector
, remember_trace_dir
);
575 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
577 case GTK_RESPONSE_ACCEPT
:
578 case GTK_RESPONSE_OK
:
579 dir
= gtk_dir_selection_get_dir (file_selector
);
580 strncpy(remember_trace_dir
, dir
, PATH_LENGTH
);
581 if(!dir
|| strlen(dir
) == 0){
582 gtk_widget_destroy((GtkWidget
*)file_selector
);
585 trace
= ltt_trace_open(dir
);
586 if(trace
== NULL
) g_critical("cannot open trace %s", dir
);
587 trace_v
= lttv_trace_new(trace
);
588 traceset
= mw_data
->current_tab
->traceset_info
->traceset
;
590 //Keep a reference to the traces so they are not freed.
591 for(i
=0; i
<lttv_traceset_number(traceset
); i
++)
593 LttvTrace
* trace
= lttv_traceset_get(traceset
, i
);
594 lttv_trace_ref(trace
);
597 //remove state update hooks
598 lttv_state_remove_event_hooks(
599 (LttvTracesetState
*)mw_data
->current_tab
->traceset_info
->traceset_context
);
601 lttv_context_fini(LTTV_TRACESET_CONTEXT(
602 mw_data
->current_tab
->traceset_info
->traceset_context
));
603 g_object_unref(mw_data
->current_tab
->traceset_info
->traceset_context
);
606 lttv_traceset_add(traceset
, trace_v
);
608 /* Create new context */
609 mw_data
->current_tab
->traceset_info
->traceset_context
=
610 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
612 LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->traceset_info
->
615 //add state update hooks
616 lttv_state_add_event_hooks(
617 (LttvTracesetState
*)mw_data
->current_tab
->traceset_info
->traceset_context
);
618 //Remove local reference to the traces.
619 for(i
=0; i
<lttv_traceset_number(traceset
); i
++)
621 LttvTrace
* trace
= lttv_traceset_get(traceset
, i
);
622 lttv_trace_unref(trace
);
626 add_trace_into_traceset_selector(mw_data
->current_tab
->multi_vpaned
, trace
);
628 gtk_widget_destroy((GtkWidget
*)file_selector
);
631 //update_traceset(mw_data);
633 //get_traceset_time_span(mw_data,LTTV_TRACESET_CONTEXT(mw_data->current_tab->traceset_info->traceset_context)->Time_Span);
635 lttv_traceset_number(mw_data
->current_tab
->traceset_info
->traceset
) == 1
636 || ltt_time_compare(mw_data
->current_tab
->current_time
,
637 LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->traceset_info
->
638 traceset_context
)->Time_Span
->startTime
)<0)
640 /* Set initial time if this is the first trace in the traceset */
641 mw_data
->current_tab
->current_time
=
642 LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->traceset_info
->
643 traceset_context
)->Time_Span
->startTime
;
644 mw_data
->current_tab
->time_window
.start_time
=
645 mw_data
->current_tab
->current_time
;
646 mw_data
->current_tab
->time_window
.time_width
.tv_sec
=
647 DEFAULT_TIME_WIDTH_S
;
648 mw_data
->current_tab
->time_window
.time_width
.tv_nsec
= 0;
651 /* Call the updatetraceset hooks */
653 SetTraceset(mw_data
, (gpointer
)traceset
);
654 // in expose now call_pending_read_hooks(mw_data);
656 //lttvwindow_report_current_time(mw_data,&(mw_data->current_tab->current_time));
658 case GTK_RESPONSE_REJECT
:
659 case GTK_RESPONSE_CANCEL
:
661 gtk_widget_destroy((GtkWidget
*)file_selector
);
667 /* remove_trace_into_traceset_selector, each instance of a viewer has an associated
668 * selector (filter), when a trace is remove from traceset, the selector should
669 * reflect the change. The function is used to update the selector
672 void remove_trace_from_traceset_selector(GtkMultiVPaned
* paned
, unsigned i
)
674 LttvTracesetSelector
* s
;
675 LttvTraceSelector
* t
;
678 w
= gtk_multi_vpaned_get_first_widget(paned
);
680 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
682 t
= lttv_traceset_selector_trace_get(s
,i
);
683 lttv_traceset_selector_trace_remove(s
, i
);
684 lttv_trace_selector_destroy(t
);
685 }g_warning("Module dose not support filtering\n");
686 w
= gtk_multi_vpaned_get_next_widget(paned
);
691 /* remove_trace removes a trace from the current traceset if all viewers in
692 * the current tab are not interested in the trace. It first displays a
693 * dialogue, which shows all traces in the current traceset, to let user choose
694 * a trace, then it checks if all viewers unselect the trace, if it is true,
695 * it will remove the trace, recreate the traceset_contex,
696 * and redraws all the viewer of the current tab. If there is on trace in the
697 * current traceset, it will delete all viewers of the current tab
700 void remove_trace(GtkWidget
* widget
, gpointer user_data
)
704 LttvTraceset
* traceset
;
706 char ** name
, *remove_trace_name
;
707 MainWindow
* mw_data
= get_window_data_struct(widget
);
708 LttvTracesetSelector
* s
;
709 LttvTraceSelector
* t
;
713 nb_trace
=lttv_traceset_number(mw_data
->current_tab
->traceset_info
->traceset
);
714 name
= g_new(char*,nb_trace
);
715 for(i
= 0; i
< nb_trace
; i
++){
716 trace_v
= lttv_traceset_get(mw_data
->current_tab
->
717 traceset_info
->traceset
, i
);
718 trace
= lttv_trace(trace_v
);
719 name
[i
] = ltt_trace_name(trace
);
722 remove_trace_name
= get_remove_trace(name
, nb_trace
);
724 if(remove_trace_name
){
725 for(i
=0; i
<nb_trace
; i
++){
726 if(strcmp(remove_trace_name
,name
[i
]) == 0){
727 //unselect the trace from the current viewer
728 w
= gtk_multi_vpaned_get_widget(mw_data
->current_tab
->multi_vpaned
);
730 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
732 t
= lttv_traceset_selector_trace_get(s
,i
);
733 lttv_trace_selector_set_selected(t
, FALSE
);
736 //check if other viewers select the trace
737 w
= gtk_multi_vpaned_get_first_widget(mw_data
->current_tab
->multi_vpaned
);
739 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
741 t
= lttv_traceset_selector_trace_get(s
,i
);
742 selected
= lttv_trace_selector_get_selected(t
);
745 w
= gtk_multi_vpaned_get_next_widget(mw_data
->current_tab
->multi_vpaned
);
747 }else selected
= FALSE
;
749 //if no viewer selects the trace, remove it
751 remove_trace_from_traceset_selector(mw_data
->current_tab
->multi_vpaned
, i
);
753 traceset
= mw_data
->current_tab
->traceset_info
->traceset
;
754 trace_v
= lttv_traceset_get(traceset
, i
);
755 if(lttv_trace_get_ref_number(trace_v
) <= 1)
756 ltt_trace_close(lttv_trace(trace_v
));
758 //Keep a reference to the traces so they are not freed.
759 for(j
=0; j
<lttv_traceset_number(traceset
); j
++)
761 LttvTrace
* trace
= lttv_traceset_get(traceset
, j
);
762 lttv_trace_ref(trace
);
765 //remove state update hooks
766 lttv_state_remove_event_hooks(
767 (LttvTracesetState
*)mw_data
->current_tab
->traceset_info
->traceset_context
);
768 lttv_context_fini(LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->traceset_info
->traceset_context
));
769 g_object_unref(mw_data
->current_tab
->traceset_info
->traceset_context
);
772 lttv_traceset_remove(traceset
, i
);
773 lttv_trace_unref(trace_v
); // Remove local reference
774 if(!lttv_trace_get_ref_number(trace_v
))
775 lttv_trace_destroy(trace_v
);
777 mw_data
->current_tab
->traceset_info
->traceset_context
=
778 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
780 LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->
781 traceset_info
->traceset_context
),traceset
);
782 //add state update hooks
783 lttv_state_add_event_hooks(
784 (LttvTracesetState
*)mw_data
->current_tab
->traceset_info
->traceset_context
);
786 //Remove local reference to the traces.
787 for(j
=0; j
<lttv_traceset_number(traceset
); j
++)
789 LttvTrace
* trace
= lttv_traceset_get(traceset
, j
);
790 lttv_trace_unref(trace
);
795 //update_traceset(mw_data);
798 SetTraceset(mw_data
, (gpointer
)traceset
);
799 // in expose now call_pending_read_hooks(mw_data);
801 //lttvwindow_report_current_time(mw_data,&(mw_data->current_tab->current_time));
803 if(mw_data
->current_tab
){
804 while(mw_data
->current_tab
->multi_vpaned
->num_children
){
805 gtk_multi_vpaned_widget_delete(mw_data
->current_tab
->multi_vpaned
);
819 /* save will save the traceset to a file
820 * Not implemented yet FIXME
823 void save(GtkWidget
* widget
, gpointer user_data
)
828 void save_as(GtkWidget
* widget
, gpointer user_data
)
830 g_printf("Save as\n");
834 /* zoom will change the time_window of all the viewers of the
835 * current tab, and redisplay them. The main functionality is to
836 * determine the new time_window of the current tab
839 void zoom(GtkWidget
* widget
, double size
)
841 TimeInterval
*time_span
;
842 TimeWindow new_time_window
;
843 LttTime current_time
, time_delta
, time_s
, time_e
, time_tmp
;
844 MainWindow
* mw_data
= get_window_data_struct(widget
);
846 if(size
== 1) return;
848 time_span
= LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->
849 traceset_info
->traceset_context
)->Time_Span
;
850 new_time_window
= mw_data
->current_tab
->time_window
;
851 current_time
= mw_data
->current_tab
->current_time
;
853 time_delta
= ltt_time_sub(time_span
->endTime
,time_span
->startTime
);
855 new_time_window
.start_time
= time_span
->startTime
;
856 new_time_window
.time_width
= time_delta
;
858 new_time_window
.time_width
= ltt_time_div(new_time_window
.time_width
, size
);
859 if(ltt_time_compare(new_time_window
.time_width
,time_delta
) > 0)
860 { /* Case where zoom out is bigger than trace length */
861 new_time_window
.start_time
= time_span
->startTime
;
862 new_time_window
.time_width
= time_delta
;
866 /* Center the image on the current time */
867 g_critical("update is HERE");
868 new_time_window
.start_time
=
869 ltt_time_sub(current_time
, ltt_time_div(new_time_window
.time_width
, 2.0));
870 /* If on borders, don't fall off */
871 if(ltt_time_compare(new_time_window
.start_time
, time_span
->startTime
) <0)
873 new_time_window
.start_time
= time_span
->startTime
;
878 ltt_time_add(new_time_window
.start_time
, new_time_window
.time_width
),
879 time_span
->endTime
) > 0)
881 new_time_window
.start_time
=
882 ltt_time_sub(time_span
->endTime
, new_time_window
.time_width
);
890 //time_tmp = ltt_time_div(new_time_window.time_width, 2);
891 //if(ltt_time_compare(current_time, time_tmp) < 0){
892 // time_s = time_span->startTime;
894 // time_s = ltt_time_sub(current_time,time_tmp);
896 //time_e = ltt_time_add(current_time,time_tmp);
897 //if(ltt_time_compare(time_span->startTime, time_s) > 0){
898 // time_s = time_span->startTime;
899 //}else if(ltt_time_compare(time_span->endTime, time_e) < 0){
900 // time_e = time_span->endTime;
901 // time_s = ltt_time_sub(time_e,new_time_window.time_width);
903 //new_time_window.start_time = time_s;
906 //lttvwindow_report_time_window(mw_data, &new_time_window);
907 //call_pending_read_hooks(mw_data);
909 //lttvwindow_report_current_time(mw_data,&(mw_data->current_tab->current_time));
910 set_time_window(mw_data
, &new_time_window
);
911 // in expose now call_pending_read_hooks(mw_data);
912 gtk_multi_vpaned_set_adjust(mw_data
->current_tab
->multi_vpaned
, &new_time_window
, FALSE
);
915 void zoom_in(GtkWidget
* widget
, gpointer user_data
)
920 void zoom_out(GtkWidget
* widget
, gpointer user_data
)
925 void zoom_extended(GtkWidget
* widget
, gpointer user_data
)
930 void go_to_time(GtkWidget
* widget
, gpointer user_data
)
932 g_printf("Go to time\n");
935 void show_time_frame(GtkWidget
* widget
, gpointer user_data
)
937 g_printf("Show time frame\n");
941 /* callback function */
944 on_empty_traceset_activate (GtkMenuItem
*menuitem
,
947 create_new_window((GtkWidget
*)menuitem
, user_data
, FALSE
);
952 on_clone_traceset_activate (GtkMenuItem
*menuitem
,
955 create_new_window((GtkWidget
*)menuitem
, user_data
, TRUE
);
959 /* create_new_tab calls create_tab to construct a new tab in the main window
962 void create_new_tab(GtkWidget
* widget
, gpointer user_data
){
963 gchar label
[PATH_LENGTH
];
964 MainWindow
* mw_data
= get_window_data_struct(widget
);
965 GtkNotebook
* notebook
= (GtkNotebook
*)lookup_widget(widget
, "MNotebook");
966 if(notebook
== NULL
){
967 g_printf("Notebook does not exist\n");
971 strcpy(label
,"Page");
972 if(get_label(mw_data
, label
,"Get the name of the tab","Please input tab's name"))
973 create_tab (NULL
, mw_data
, notebook
, label
);
977 on_tab_activate (GtkMenuItem
*menuitem
,
980 create_new_tab((GtkWidget
*)menuitem
, user_data
);
985 on_open_activate (GtkMenuItem
*menuitem
,
988 open_traceset((GtkWidget
*)menuitem
, user_data
);
993 on_close_activate (GtkMenuItem
*menuitem
,
996 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
997 main_window_destructor(mw_data
);
1001 /* remove the current tab from the main window if it is not the default tab
1005 on_close_tab_activate (GtkMenuItem
*menuitem
,
1010 GtkWidget
* notebook
;
1012 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1013 notebook
= lookup_widget((GtkWidget
*)menuitem
, "MNotebook");
1014 if(notebook
== NULL
){
1015 g_printf("Notebook does not exist\n");
1019 if(mw_data
->tab
== mw_data
->current_tab
){
1020 // tmp = mw_data->current_tb;
1021 // mw_data->tab = mw_data->current_tab->next;
1022 g_printf("The default TAB can not be deleted\n");
1026 while(tmp
!= mw_data
->current_tab
){
1032 gtk_notebook_remove_page((GtkNotebook
*)notebook
, count
);
1033 list
= gtk_container_get_children(GTK_CONTAINER(notebook
));
1034 if(g_list_length(list
)==1)
1035 gtk_notebook_set_show_tabs((GtkNotebook
*)notebook
, FALSE
);
1040 on_add_trace_activate (GtkMenuItem
*menuitem
,
1043 add_trace((GtkWidget
*)menuitem
, user_data
);
1048 on_remove_trace_activate (GtkMenuItem
*menuitem
,
1051 remove_trace((GtkWidget
*)menuitem
, user_data
);
1056 on_save_activate (GtkMenuItem
*menuitem
,
1059 save((GtkWidget
*)menuitem
, user_data
);
1064 on_save_as_activate (GtkMenuItem
*menuitem
,
1067 save_as((GtkWidget
*)menuitem
, user_data
);
1072 on_quit_activate (GtkMenuItem
*menuitem
,
1080 on_cut_activate (GtkMenuItem
*menuitem
,
1088 on_copy_activate (GtkMenuItem
*menuitem
,
1091 g_printf("Copye\n");
1096 on_paste_activate (GtkMenuItem
*menuitem
,
1099 g_printf("Paste\n");
1104 on_delete_activate (GtkMenuItem
*menuitem
,
1107 g_printf("Delete\n");
1112 on_zoom_in_activate (GtkMenuItem
*menuitem
,
1115 zoom_in((GtkWidget
*)menuitem
, user_data
);
1120 on_zoom_out_activate (GtkMenuItem
*menuitem
,
1123 zoom_out((GtkWidget
*)menuitem
, user_data
);
1128 on_zoom_extended_activate (GtkMenuItem
*menuitem
,
1131 zoom_extended((GtkWidget
*)menuitem
, user_data
);
1136 on_go_to_time_activate (GtkMenuItem
*menuitem
,
1139 go_to_time((GtkWidget
*)menuitem
, user_data
);
1144 on_show_time_frame_activate (GtkMenuItem
*menuitem
,
1147 show_time_frame((GtkWidget
*)menuitem
, user_data
);
1152 on_move_viewer_up_activate (GtkMenuItem
*menuitem
,
1155 move_up_viewer((GtkWidget
*)menuitem
, user_data
);
1160 on_move_viewer_down_activate (GtkMenuItem
*menuitem
,
1163 move_down_viewer((GtkWidget
*)menuitem
, user_data
);
1168 on_remove_viewer_activate (GtkMenuItem
*menuitem
,
1171 delete_viewer((GtkWidget
*)menuitem
, user_data
);
1175 on_trace_filter_activate (GtkMenuItem
*menuitem
,
1178 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1179 LttvTracesetSelector
* s
;
1180 GtkWidget
* w
= gtk_multi_vpaned_get_widget(mw_data
->current_tab
->multi_vpaned
);
1182 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
1184 g_printf("There is no viewer yet\n");
1187 if(get_filter_selection(s
, "Configure trace and tracefile filter", "Select traces and tracefiles")){
1188 //FIXME report filter change
1189 //update_traceset(mw_data);
1190 //call_pending_read_hooks(mw_data);
1191 //lttvwindow_report_current_time(mw_data,&(mw_data->current_tab->current_time));
1196 on_trace_facility_activate (GtkMenuItem
*menuitem
,
1199 g_printf("Trace facility selector: %s\n");
1203 /* Dispaly a file selection dialogue to let user select a module, then call
1204 * lttv_module_load(), finally insert tool button and menu entry in the main window
1205 * for the loaded module
1209 on_load_module_activate (GtkMenuItem
*menuitem
,
1214 char str
[PATH_LENGTH
], *str1
;
1215 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1216 GtkFileSelection
* file_selector
= (GtkFileSelection
*)gtk_file_selection_new("Select a module");
1217 if(remember_plugins_dir
[0] != '\0')
1218 gtk_file_selection_set_filename(file_selector
, remember_plugins_dir
);
1219 gtk_file_selection_hide_fileop_buttons(file_selector
);
1222 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
1224 case GTK_RESPONSE_ACCEPT
:
1225 case GTK_RESPONSE_OK
:
1226 dir
= gtk_file_selection_get_selections (file_selector
);
1227 strncpy(str
,dir
[0],PATH_LENGTH
);
1228 strncpy(remember_plugins_dir
,dir
[0],PATH_LENGTH
);
1229 str1
= strrchr(str
,'/');
1232 str1
= strrchr(str
,'\\');
1235 lttv_module_require(str1
, NULL
);
1236 g_slist_foreach(g_main_window_list
, (gpointer
)insert_menu_toolbar_item
,
1239 case GTK_RESPONSE_REJECT
:
1240 case GTK_RESPONSE_CANCEL
:
1242 gtk_widget_destroy((GtkWidget
*)file_selector
);
1245 g_printf("Load module: %s\n", str
);
1249 /* Display all loaded modules, let user to select a module to unload
1250 * by calling lttv_module_unload
1254 on_unload_module_activate (GtkMenuItem
*menuitem
,
1259 char *unload_module_name
;
1261 LttvLibrary
*library
;
1262 LttvLibraryInfo library_info
;
1263 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1265 name
= g_ptr_array_new();
1266 nb
= lttv_library_number();
1269 library
= lttv_library_get(i
);
1270 lttv_library_info(library
, &library_info
);
1271 if(library_info
.load_count
> 0) g_ptr_array_add(name
, library_info
.name
);
1274 unload_module_name
=get_unload_module((char **)(name
->pdata
), name
->len
);
1276 if(unload_module_name
){
1278 library
= lttv_library_get(i
);
1279 lttv_library_info(library
, &library_info
);
1280 if(strcmp(unload_module_name
, library_info
.name
) == 0){
1281 lttv_library_unload(library
);
1287 g_ptr_array_free(name
, TRUE
);
1291 /* Display a directory dialogue to let user select a path for module searching
1295 on_add_module_search_path_activate (GtkMenuItem
*menuitem
,
1298 GtkDirSelection
* file_selector
= (GtkDirSelection
*)gtk_dir_selection_new("Select module path");
1302 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1303 if(remember_plugins_dir
[0] != '\0')
1304 gtk_dir_selection_set_filename(file_selector
, remember_plugins_dir
);
1306 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
1308 case GTK_RESPONSE_ACCEPT
:
1309 case GTK_RESPONSE_OK
:
1310 dir
= gtk_dir_selection_get_dir (file_selector
);
1311 strncpy(remember_plugins_dir
,dir
,PATH_LENGTH
);
1312 strncat(remember_plugins_dir
,"/",PATH_LENGTH
);
1313 lttv_library_path_add(dir
);
1314 case GTK_RESPONSE_REJECT
:
1315 case GTK_RESPONSE_CANCEL
:
1317 gtk_widget_destroy((GtkWidget
*)file_selector
);
1324 on_color_activate (GtkMenuItem
*menuitem
,
1327 g_printf("Color\n");
1332 on_filter_activate (GtkMenuItem
*menuitem
,
1335 g_printf("Filter\n");
1340 on_save_configuration_activate (GtkMenuItem
*menuitem
,
1343 g_printf("Save configuration\n");
1348 on_content_activate (GtkMenuItem
*menuitem
,
1351 g_printf("Content\n");
1356 on_about_activate (GtkMenuItem
*menuitem
,
1359 g_printf("About...\n");
1364 on_button_new_clicked (GtkButton
*button
,
1367 create_new_window((GtkWidget
*)button
, user_data
, TRUE
);
1371 on_button_new_tab_clicked (GtkButton
*button
,
1374 create_new_tab((GtkWidget
*)button
, user_data
);
1378 on_button_open_clicked (GtkButton
*button
,
1381 open_traceset((GtkWidget
*)button
, user_data
);
1386 on_button_add_trace_clicked (GtkButton
*button
,
1389 add_trace((GtkWidget
*)button
, user_data
);
1394 on_button_remove_trace_clicked (GtkButton
*button
,
1397 remove_trace((GtkWidget
*)button
, user_data
);
1402 on_button_save_clicked (GtkButton
*button
,
1405 save((GtkWidget
*)button
, user_data
);
1410 on_button_save_as_clicked (GtkButton
*button
,
1413 save_as((GtkWidget
*)button
, user_data
);
1418 on_button_zoom_in_clicked (GtkButton
*button
,
1421 zoom_in((GtkWidget
*)button
, user_data
);
1426 on_button_zoom_out_clicked (GtkButton
*button
,
1429 zoom_out((GtkWidget
*)button
, user_data
);
1434 on_button_zoom_extended_clicked (GtkButton
*button
,
1437 zoom_extended((GtkWidget
*)button
, user_data
);
1442 on_button_go_to_time_clicked (GtkButton
*button
,
1445 go_to_time((GtkWidget
*)button
, user_data
);
1450 on_button_show_time_frame_clicked (GtkButton
*button
,
1453 show_time_frame((GtkWidget
*)button
, user_data
);
1458 on_button_move_up_clicked (GtkButton
*button
,
1461 move_up_viewer((GtkWidget
*)button
, user_data
);
1466 on_button_move_down_clicked (GtkButton
*button
,
1469 move_down_viewer((GtkWidget
*)button
, user_data
);
1474 on_button_delete_viewer_clicked (GtkButton
*button
,
1477 delete_viewer((GtkWidget
*)button
, user_data
);
1481 on_MWindow_destroy (GtkObject
*object
,
1484 MainWindow
*Main_Window
= get_window_data_struct((GtkWidget
*)object
);
1486 Tab
*tab
= Main_Window
->tab
;
1488 g_printf("There are : %d windows\n",g_slist_length(g_main_window_list
));
1491 if(g_win_count
== 0)
1496 on_MWindow_configure (GtkWidget
*widget
,
1497 GdkEventConfigure
*event
,
1500 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)widget
);
1501 float width
= event
->width
;
1502 Tab
* tab
= mw_data
->tab
;
1503 TimeWindow time_win
;
1505 TimeInterval
*time_span
;
1508 // MD : removed time width modification upon resizing of the main window.
1509 // The viewers will redraw themselves completely, without time interval
1512 if(mw_data->window_width){
1513 time_span = LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->Time_Span ;
1514 time_win = tab->time_window;
1515 ratio = width / mw_data->window_width;
1516 tab->time_window.time_width = ltt_time_mul(time_win.time_width,ratio);
1517 time = ltt_time_sub(time_span->endTime, time_win.start_time);
1518 if(ltt_time_compare(time, tab->time_window.time_width) < 0){
1519 tab->time_window.time_width = time;
1525 mw_data->window_width = (int)width;
1534 on_MNotebook_switch_page (GtkNotebook
*notebook
,
1535 GtkNotebookPage
*page
,
1539 MainWindow
* mw
= get_window_data_struct((GtkWidget
*)notebook
);
1540 Tab
* tab
= mw
->tab
;
1546 mw
->current_tab
= tab
;
1550 /* callback function to check or uncheck the check box (filter)
1553 void checkbox_changed(GtkTreeView
*treeview
,
1555 GtkTreeViewColumn
*arg2
,
1558 GtkTreeStore
* store
= (GtkTreeStore
*)gtk_tree_view_get_model (treeview
);
1562 if (gtk_tree_model_get_iter ((GtkTreeModel
*)store
, &iter
, arg1
)){
1563 gtk_tree_model_get ((GtkTreeModel
*)store
, &iter
, CHECKBOX_COLUMN
, &value
, -1);
1564 value
= value
? FALSE
: TRUE
;
1565 gtk_tree_store_set (GTK_TREE_STORE (store
), &iter
, CHECKBOX_COLUMN
, value
, -1);
1571 /* According to user's selection, update selector(filter)
1574 void update_filter(LttvTracesetSelector
*s
, GtkTreeStore
*store
)
1576 GtkTreeIter iter
, child_iter
, child_iter1
, child_iter2
;
1577 int i
, j
, k
, nb_eventtype
;
1578 LttvTraceSelector
* trace
;
1579 LttvTracefileSelector
* tracefile
;
1580 LttvEventtypeSelector
* eventtype
;
1581 gboolean value
, value1
, value2
;
1583 if(gtk_tree_model_get_iter_first((GtkTreeModel
*)store
, &iter
)){
1586 trace
= lttv_traceset_selector_trace_get(s
, i
);
1587 nb_eventtype
= lttv_trace_selector_eventtype_number(trace
);
1588 gtk_tree_model_get ((GtkTreeModel
*)store
, &iter
, CHECKBOX_COLUMN
, &value
,-1);
1591 if(gtk_tree_model_iter_children ((GtkTreeModel
*)store
, &child_iter
, &iter
)){
1593 if(j
<1){//eventtype selector for trace
1594 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter
, CHECKBOX_COLUMN
, &value2
,-1);
1597 if(gtk_tree_model_iter_children ((GtkTreeModel
*)store
, &child_iter1
, &child_iter
)){
1599 eventtype
= lttv_trace_selector_eventtype_get(trace
,k
);
1600 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter1
, CHECKBOX_COLUMN
, &value2
,-1);
1601 lttv_eventtype_selector_set_selected(eventtype
,value2
);
1603 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &child_iter1
));
1606 }else{ //tracefile selector
1607 tracefile
= lttv_trace_selector_tracefile_get(trace
, j
- 1);
1608 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter
, CHECKBOX_COLUMN
, &value1
,-1);
1609 lttv_tracefile_selector_set_selected(tracefile
,value1
);
1611 gtk_tree_model_iter_children((GtkTreeModel
*)store
, &child_iter1
, &child_iter
); //eventtype selector
1612 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter1
, CHECKBOX_COLUMN
, &value2
,-1);
1615 if(gtk_tree_model_iter_children ((GtkTreeModel
*)store
, &child_iter2
, &child_iter1
)){
1616 do{//eventtype selector for tracefile
1617 eventtype
= lttv_tracefile_selector_eventtype_get(tracefile
,k
);
1618 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter2
, CHECKBOX_COLUMN
, &value2
,-1);
1619 lttv_eventtype_selector_set_selected(eventtype
,value2
);
1621 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &child_iter2
));
1627 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &child_iter
));
1630 lttv_trace_selector_set_selected(trace
,value
);
1632 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &iter
));
1637 /* Display a dialogue showing all eventtypes and traces, let user to select the interested
1638 * eventtypes, tracefiles and traces (filter)
1641 gboolean
get_filter_selection(LttvTracesetSelector
*s
,char *title
, char * column_title
)
1643 GtkWidget
* dialogue
;
1644 GtkTreeStore
* store
;
1646 GtkWidget
* scroll_win
;
1647 GtkCellRenderer
* renderer
;
1648 GtkTreeViewColumn
* column
;
1649 GtkTreeIter iter
, child_iter
, child_iter1
, child_iter2
;
1650 int i
, j
, k
, id
, nb_trace
, nb_tracefile
, nb_eventtype
;
1651 LttvTraceSelector
* trace
;
1652 LttvTracefileSelector
* tracefile
;
1653 LttvEventtypeSelector
* eventtype
;
1657 dialogue
= gtk_dialog_new_with_buttons(title
,
1660 GTK_STOCK_OK
,GTK_RESPONSE_ACCEPT
,
1661 GTK_STOCK_CANCEL
,GTK_RESPONSE_REJECT
,
1663 gtk_window_set_default_size((GtkWindow
*)dialogue
, 300, 500);
1665 store
= gtk_tree_store_new (TOTAL_COLUMNS
, G_TYPE_BOOLEAN
, G_TYPE_STRING
);
1666 tree
= gtk_tree_view_new_with_model (GTK_TREE_MODEL (store
));
1667 g_object_unref (G_OBJECT (store
));
1668 g_signal_connect (G_OBJECT (tree
), "row-activated",
1669 G_CALLBACK (checkbox_changed
),
1673 renderer
= gtk_cell_renderer_toggle_new ();
1674 gtk_cell_renderer_toggle_set_radio((GtkCellRendererToggle
*)renderer
, FALSE
);
1676 g_object_set (G_OBJECT (renderer
),"activatable", TRUE
, NULL
);
1678 column
= gtk_tree_view_column_new_with_attributes ("Checkbox",
1680 "active", CHECKBOX_COLUMN
,
1682 gtk_tree_view_column_set_alignment (column
, 0.5);
1683 gtk_tree_view_column_set_fixed_width (column
, 20);
1684 gtk_tree_view_append_column (GTK_TREE_VIEW (tree
), column
);
1686 renderer
= gtk_cell_renderer_text_new ();
1687 column
= gtk_tree_view_column_new_with_attributes (column_title
,
1689 "text", NAME_COLUMN
,
1691 gtk_tree_view_column_set_alignment (column
, 0.0);
1692 gtk_tree_view_append_column (GTK_TREE_VIEW (tree
), column
);
1693 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW (tree
), FALSE
);
1695 scroll_win
= gtk_scrolled_window_new (NULL
, NULL
);
1696 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win
),
1697 GTK_POLICY_AUTOMATIC
,GTK_POLICY_AUTOMATIC
);
1698 gtk_container_add (GTK_CONTAINER (scroll_win
), tree
);
1700 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), scroll_win
,TRUE
, TRUE
,0);
1702 gtk_widget_show(scroll_win
);
1703 gtk_widget_show(tree
);
1705 nb_trace
= lttv_traceset_selector_trace_number(s
);
1706 for(i
=0;i
<nb_trace
;i
++){
1707 trace
= lttv_traceset_selector_trace_get(s
, i
);
1708 name
= lttv_trace_selector_get_name(trace
);
1709 gtk_tree_store_append (store
, &iter
, NULL
);
1710 checked
= lttv_trace_selector_get_selected(trace
);
1711 gtk_tree_store_set (store
, &iter
,
1712 CHECKBOX_COLUMN
,checked
,
1716 gtk_tree_store_append (store
, &child_iter
, &iter
);
1717 gtk_tree_store_set (store
, &child_iter
,
1718 CHECKBOX_COLUMN
, checked
,
1719 NAME_COLUMN
,"eventtype",
1722 nb_eventtype
= lttv_trace_selector_eventtype_number(trace
);
1723 for(j
=0;j
<nb_eventtype
;j
++){
1724 eventtype
= lttv_trace_selector_eventtype_get(trace
,j
);
1725 name
= lttv_eventtype_selector_get_name(eventtype
);
1726 checked
= lttv_eventtype_selector_get_selected(eventtype
);
1727 gtk_tree_store_append (store
, &child_iter1
, &child_iter
);
1728 gtk_tree_store_set (store
, &child_iter1
,
1729 CHECKBOX_COLUMN
, checked
,
1734 nb_tracefile
= lttv_trace_selector_tracefile_number(trace
);
1735 for(j
=0;j
<nb_tracefile
;j
++){
1736 tracefile
= lttv_trace_selector_tracefile_get(trace
, j
);
1737 name
= lttv_tracefile_selector_get_name(tracefile
);
1738 gtk_tree_store_append (store
, &child_iter
, &iter
);
1739 checked
= lttv_tracefile_selector_get_selected(tracefile
);
1740 gtk_tree_store_set (store
, &child_iter
,
1741 CHECKBOX_COLUMN
, checked
,
1745 gtk_tree_store_append (store
, &child_iter1
, &child_iter
);
1746 gtk_tree_store_set (store
, &child_iter1
,
1747 CHECKBOX_COLUMN
, checked
,
1748 NAME_COLUMN
,"eventtype",
1751 for(k
=0;k
<nb_eventtype
;k
++){
1752 eventtype
= lttv_tracefile_selector_eventtype_get(tracefile
,k
);
1753 name
= lttv_eventtype_selector_get_name(eventtype
);
1754 checked
= lttv_eventtype_selector_get_selected(eventtype
);
1755 gtk_tree_store_append (store
, &child_iter2
, &child_iter1
);
1756 gtk_tree_store_set (store
, &child_iter2
,
1757 CHECKBOX_COLUMN
, checked
,
1764 id
= gtk_dialog_run(GTK_DIALOG(dialogue
));
1766 case GTK_RESPONSE_ACCEPT
:
1767 case GTK_RESPONSE_OK
:
1768 update_filter(s
, store
);
1769 gtk_widget_destroy(dialogue
);
1771 case GTK_RESPONSE_REJECT
:
1772 case GTK_RESPONSE_CANCEL
:
1774 gtk_widget_destroy(dialogue
);
1781 /* Select a trace which will be removed from traceset
1784 char * get_remove_trace(char ** all_trace_name
, int nb_trace
)
1786 return get_selection(all_trace_name
, nb_trace
,
1787 "Select a trace", "Trace pathname");
1791 /* Select a module which will be unloaded
1794 char * get_unload_module(char ** loaded_module_name
, int nb_module
)
1796 return get_selection(loaded_module_name
, nb_module
,
1797 "Select an unload module", "Module pathname");
1801 /* Display a dialogue which shows all selectable items, let user to
1802 * select one of them
1805 char * get_selection(char ** loaded_module_name
, int nb_module
,
1806 char *title
, char * column_title
)
1808 GtkWidget
* dialogue
;
1809 GtkWidget
* scroll_win
;
1811 GtkListStore
* store
;
1812 GtkTreeViewColumn
* column
;
1813 GtkCellRenderer
* renderer
;
1814 GtkTreeSelection
* select
;
1817 char * unload_module_name
= NULL
;
1819 dialogue
= gtk_dialog_new_with_buttons(title
,
1822 GTK_STOCK_OK
,GTK_RESPONSE_ACCEPT
,
1823 GTK_STOCK_CANCEL
,GTK_RESPONSE_REJECT
,
1825 gtk_window_set_default_size((GtkWindow
*)dialogue
, 500, 200);
1827 scroll_win
= gtk_scrolled_window_new (NULL
, NULL
);
1828 gtk_widget_show ( scroll_win
);
1829 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win
),
1830 GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
1832 store
= gtk_list_store_new (N_COLUMNS
,G_TYPE_STRING
);
1833 tree
= gtk_tree_view_new_with_model(GTK_TREE_MODEL (store
));
1834 gtk_widget_show ( tree
);
1835 g_object_unref (G_OBJECT (store
));
1837 renderer
= gtk_cell_renderer_text_new ();
1838 column
= gtk_tree_view_column_new_with_attributes (column_title
,
1840 "text", MODULE_COLUMN
,
1842 gtk_tree_view_column_set_alignment (column
, 0.5);
1843 gtk_tree_view_column_set_fixed_width (column
, 150);
1844 gtk_tree_view_append_column (GTK_TREE_VIEW (tree
), column
);
1846 select
= gtk_tree_view_get_selection (GTK_TREE_VIEW (tree
));
1847 gtk_tree_selection_set_mode (select
, GTK_SELECTION_SINGLE
);
1849 gtk_container_add (GTK_CONTAINER (scroll_win
), tree
);
1851 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), scroll_win
,TRUE
, TRUE
,0);
1853 for(i
=0;i
<nb_module
;i
++){
1854 gtk_list_store_append (store
, &iter
);
1855 gtk_list_store_set (store
, &iter
, MODULE_COLUMN
,loaded_module_name
[i
],-1);
1858 id
= gtk_dialog_run(GTK_DIALOG(dialogue
));
1860 case GTK_RESPONSE_ACCEPT
:
1861 case GTK_RESPONSE_OK
:
1862 if (gtk_tree_selection_get_selected (select
, (GtkTreeModel
**)&store
, &iter
)){
1863 gtk_tree_model_get ((GtkTreeModel
*)store
, &iter
, MODULE_COLUMN
, &unload_module_name
, -1);
1865 case GTK_RESPONSE_REJECT
:
1866 case GTK_RESPONSE_CANCEL
:
1868 gtk_widget_destroy(dialogue
);
1872 return unload_module_name
;
1879 void main_window_destroy_hash_key(gpointer key
)
1884 void main_window_destroy_hash_data(gpointer data
)
1889 /* Insert menu entry and tool button into all main windows for modules
1890 * It checks whether the menu entry or tool button exists or not,
1891 * if they do not exist, then construct the widget and insert them
1892 * into all main windows
1895 void insert_menu_toolbar_item(MainWindow
* mw
, gpointer user_data
)
1899 lttvwindow_viewer_constructor constructor
;
1901 LttvToolbars
* toolbar
;
1902 lttv_menu_closure
*menu_item
;
1903 lttv_toolbar_closure
*toolbar_item
;
1904 LttvAttributeValue value
;
1905 LttvIAttribute
*attributes
= LTTV_IATTRIBUTE(lttv_global_attributes());
1906 GtkWidget
* tool_menu_title_menu
, *insert_view
, *pixmap
, *tmp
;
1908 g_assert(lttv_iattribute_find_by_path(attributes
,
1909 "viewers/menu", LTTV_POINTER
, &value
));
1910 menu
= (LttvMenus
*)*(value
.v_pointer
);
1913 for(i
=0;i
<menu
->len
;i
++){
1914 menu_item
= &g_array_index(menu
, lttv_menu_closure
, i
);
1915 tmp
= g_hash_table_lookup(mw
->hash_menu_item
, g_strdup(menu_item
->menuText
));
1917 constructor
= menu_item
->con
;
1918 tool_menu_title_menu
= lookup_widget(mw
->mwindow
,"ToolMenuTitle_menu");
1919 insert_view
= gtk_menu_item_new_with_mnemonic (menu_item
->menuText
);
1920 gtk_widget_show (insert_view
);
1921 gtk_container_add (GTK_CONTAINER (tool_menu_title_menu
), insert_view
);
1922 g_signal_connect ((gpointer
) insert_view
, "activate",
1923 G_CALLBACK (insert_viewer_wrap
),
1925 g_hash_table_insert(mw
->hash_menu_item
, g_strdup(menu_item
->menuText
),
1930 g_assert(lttv_iattribute_find_by_path(attributes
,
1931 "viewers/toolbar", LTTV_POINTER
, &value
));
1932 toolbar
= (LttvToolbars
*)*(value
.v_pointer
);
1935 for(i
=0;i
<toolbar
->len
;i
++){
1936 toolbar_item
= &g_array_index(toolbar
, lttv_toolbar_closure
, i
);
1937 tmp
= g_hash_table_lookup(mw
->hash_toolbar_item
, g_strdup(toolbar_item
->tooltip
));
1939 constructor
= toolbar_item
->con
;
1940 tool_menu_title_menu
= lookup_widget(mw
->mwindow
,"MToolbar1");
1941 pixbuf
= gdk_pixbuf_new_from_xpm_data ((const char**)toolbar_item
->pixmap
);
1942 pixmap
= gtk_image_new_from_pixbuf(pixbuf
);
1943 insert_view
= gtk_toolbar_append_element (GTK_TOOLBAR (tool_menu_title_menu
),
1944 GTK_TOOLBAR_CHILD_BUTTON
,
1947 toolbar_item
->tooltip
, NULL
,
1948 pixmap
, NULL
, NULL
);
1949 gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild
*) (g_list_last (GTK_TOOLBAR (tool_menu_title_menu
)->children
)->data
))->label
), TRUE
);
1950 gtk_widget_show (insert_view
);
1951 gtk_container_set_border_width (GTK_CONTAINER (insert_view
), 1);
1952 g_signal_connect ((gpointer
) insert_view
, "clicked",G_CALLBACK (insert_viewer_wrap
),constructor
);
1953 g_hash_table_insert(mw
->hash_toolbar_item
, g_strdup(toolbar_item
->tooltip
),
1960 /* Create a main window
1963 void construct_main_window(MainWindow
* parent
)
1965 g_debug("construct_main_window()");
1966 GtkWidget
* new_window
; /* New generated main window */
1967 MainWindow
* new_m_window
;/* New main window structure */
1968 GtkNotebook
* notebook
;
1969 LttvIAttribute
*attributes
=
1970 LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
));
1971 LttvAttributeValue value
;
1973 new_m_window
= g_new(MainWindow
, 1);
1975 // Add the object's information to the module's array
1976 g_main_window_list
= g_slist_append(g_main_window_list
, new_m_window
);
1979 new_window
= create_MWindow();
1980 gtk_widget_show (new_window
);
1982 new_m_window
->mwindow
= new_window
;
1983 new_m_window
->tab
= NULL
;
1984 new_m_window
->current_tab
= NULL
;
1985 new_m_window
->attributes
= attributes
;
1987 new_m_window
->hash_menu_item
= g_hash_table_new_full (g_str_hash
, g_str_equal
,
1988 main_window_destroy_hash_key
,
1989 main_window_destroy_hash_data
);
1990 new_m_window
->hash_toolbar_item
= g_hash_table_new_full (g_str_hash
, g_str_equal
,
1991 main_window_destroy_hash_key
,
1992 main_window_destroy_hash_data
);
1994 insert_menu_toolbar_item(new_m_window
, NULL
);
1996 g_object_set_data(G_OBJECT(new_window
), "mainWindow", (gpointer
)new_m_window
);
1997 //create a default tab
1998 notebook
= (GtkNotebook
*)lookup_widget(new_m_window
->mwindow
, "MNotebook");
1999 if(notebook
== NULL
){
2000 g_printf("Notebook does not exist\n");
2003 //for now there is no name field in LttvTraceset structure
2004 //Use "Traceset" as the label for the default tab
2005 create_tab(parent
, new_m_window
, notebook
, "Traceset");
2007 g_object_set_data_full(
2008 G_OBJECT(new_m_window
->mwindow
),
2011 (GDestroyNotify
)main_window_free
);
2017 /* Free the memory occupied by a tab structure
2021 void tab_destructor(Tab
* tab_instance
)
2023 int i
, nb
, ref_count
;
2026 if(tab_instance
->attributes
)
2027 g_object_unref(tab_instance
->attributes
);
2029 if(tab_instance
->mw
->tab
== tab_instance
){
2030 tab_instance
->mw
->tab
= tab_instance
->next
;
2032 Tab
* tmp1
, *tmp
= tab_instance
->mw
->tab
;
2033 while(tmp
!= tab_instance
){
2037 tmp1
->next
= tab_instance
->next
;
2040 if(tab_instance
->traceset_info
->traceset_context
!= NULL
){
2041 //remove state update hooks
2042 lttv_state_remove_event_hooks(
2043 (LttvTracesetState
*)tab_instance
->traceset_info
->
2045 lttv_context_fini(LTTV_TRACESET_CONTEXT(tab_instance
->traceset_info
->
2047 g_object_unref(tab_instance
->traceset_info
->traceset_context
);
2049 if(tab_instance
->traceset_info
->traceset
!= NULL
) {
2050 nb
= lttv_traceset_number(tab_instance
->traceset_info
->traceset
);
2051 for(i
= 0 ; i
< nb
; i
++) {
2052 trace
= lttv_traceset_get(tab_instance
->traceset_info
->traceset
, i
);
2053 ref_count
= lttv_trace_get_ref_number(trace
);
2055 ltt_trace_close(lttv_trace(trace
));
2056 lttv_trace_destroy(trace
);
2058 // lttv_trace_destroy(trace);
2061 lttv_traceset_destroy(tab_instance
->traceset_info
->traceset
);
2062 g_array_free(tab_instance
->time_requests
, TRUE
);
2063 g_free(tab_instance
->traceset_info
);
2064 g_free(tab_instance
);
2068 /* Create a tab and insert it into the current main window
2071 void * create_tab(MainWindow
* parent
, MainWindow
* current_window
,
2072 GtkNotebook
* notebook
, char * label
)
2076 MainWindow
* mw_data
= current_window
;
2079 //create a new tab data structure
2080 tmp_tab
= mw_data
->tab
;
2081 while(tmp_tab
&& tmp_tab
->next
) tmp_tab
= tmp_tab
->next
;
2083 mw_data
->current_tab
= NULL
;
2084 tmp_tab
= g_new(Tab
,1);
2085 mw_data
->tab
= tmp_tab
;
2087 tmp_tab
->next
= g_new(Tab
,1);
2088 tmp_tab
= tmp_tab
->next
;
2091 //construct and initialize the traceset_info
2092 tmp_tab
->traceset_info
= g_new(TracesetInfo
,1);
2094 if(parent
->current_tab
){
2095 tmp_tab
->traceset_info
->traceset
=
2096 lttv_traceset_new();
2097 //FIXME lttv_traceset_copy(parent->current_tab->traceset_info->traceset);
2099 tmp_tab
->traceset_info
->traceset
= lttv_traceset_new();
2102 }else{ /* Initial window */
2103 if(mw_data
->current_tab
){
2104 tmp_tab
->traceset_info
->traceset
=
2105 lttv_traceset_new();
2106 //FIXME lttv_traceset_copy(mw_data->current_tab->traceset_info->traceset);
2108 tmp_tab
->traceset_info
->traceset
= lttv_traceset_new();
2109 /* Add the command line trace */
2110 if(g_init_trace
!= NULL
){
2111 lttv_traceset_add(tmp_tab
->traceset_info
->traceset
, g_init_trace
);
2116 //FIXME copy not implemented in lower level
2117 tmp_tab
->traceset_info
->traceset_context
=
2118 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
2119 g_assert(tmp_tab
->traceset_info
->traceset_context
!= NULL
);
2121 LTTV_TRACESET_CONTEXT(tmp_tab
->traceset_info
->traceset_context
),
2122 tmp_tab
->traceset_info
->traceset
);
2123 //add state update hooks
2124 lttv_state_add_event_hooks(
2125 (LttvTracesetState
*)tmp_tab
->traceset_info
->traceset_context
);
2127 //determine the current_time and time_window of the tab
2128 if(mw_data
->current_tab
){
2129 // Will have to read directly at the main window level, as we want
2130 // to be able to modify a traceset on the fly.
2131 tmp_tab
->time_window
= mw_data
->current_tab
->time_window
;
2132 tmp_tab
->current_time
= mw_data
->current_tab
->current_time
;
2134 // Will have to read directly at the main window level, as we want
2135 // to be able to modify a traceset on the fly.
2136 // get_traceset_time_span(mw_data,&tmp_tab->traceStartTime, &tmp_tab->traceEndTime);
2137 tmp_tab
->time_window
.start_time
=
2138 LTTV_TRACESET_CONTEXT(tmp_tab
->traceset_info
->traceset_context
)->Time_Span
->startTime
;
2139 if(DEFAULT_TIME_WIDTH_S
<
2140 LTTV_TRACESET_CONTEXT(tmp_tab
->traceset_info
->traceset_context
)->Time_Span
->endTime
.tv_sec
)
2141 tmp_time
.tv_sec
= DEFAULT_TIME_WIDTH_S
;
2144 LTTV_TRACESET_CONTEXT(tmp_tab
->traceset_info
->traceset_context
)->Time_Span
->endTime
.tv_sec
;
2145 tmp_time
.tv_nsec
= 0;
2146 tmp_tab
->time_window
.time_width
= tmp_time
;
2147 tmp_tab
->current_time
.tv_sec
=
2148 LTTV_TRACESET_CONTEXT(tmp_tab
->traceset_info
->traceset_context
)->Time_Span
->startTime
.tv_sec
;
2149 tmp_tab
->current_time
.tv_nsec
=
2150 LTTV_TRACESET_CONTEXT(tmp_tab
->traceset_info
->traceset_context
)->Time_Span
->startTime
.tv_nsec
;
2152 /* Become the current tab */
2153 mw_data
->current_tab
= tmp_tab
;
2155 tmp_tab
->attributes
= LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
));
2156 tmp_tab
->multi_vpaned
= (GtkMultiVPaned
*)gtk_multi_vpaned_new();
2157 tmp_tab
->multi_vpaned
->mw
= mw_data
;
2158 gtk_widget_show((GtkWidget
*)tmp_tab
->multi_vpaned
);
2159 tmp_tab
->next
= NULL
;
2160 tmp_tab
->mw
= mw_data
;
2162 tmp_tab
->label
= gtk_label_new (label
);
2163 gtk_widget_show (tmp_tab
->label
);
2165 tmp_tab
->time_requests
= g_array_new(FALSE
, FALSE
, sizeof(TimeRequest
));
2166 tmp_tab
->time_request_pending
= FALSE
;
2168 g_object_set_data_full(
2169 G_OBJECT(tmp_tab
->multi_vpaned
),
2172 (GDestroyNotify
)tab_destructor
);
2174 //insert tab into notebook
2175 gtk_notebook_append_page(notebook
, (GtkWidget
*)tmp_tab
->multi_vpaned
, tmp_tab
->label
);
2176 list
= gtk_container_get_children(GTK_CONTAINER(notebook
));
2177 gtk_notebook_set_current_page(notebook
,g_list_length(list
)-1);
2178 // always show : not if(g_list_length(list)>1)
2179 gtk_notebook_set_show_tabs(notebook
, TRUE
);
2184 /* Remove menu entry and tool button from main window for the
2188 void remove_menu_item(gpointer main_win
, gpointer user_data
)
2190 MainWindow
* mw
= (MainWindow
*) main_win
;
2191 lttv_menu_closure
*menu_item
= (lttv_menu_closure
*)user_data
;
2192 GtkWidget
* tool_menu_title_menu
, *insert_view
;
2194 tool_menu_title_menu
= lookup_widget(mw
->mwindow
,"ToolMenuTitle_menu");
2195 insert_view
= (GtkWidget
*)g_hash_table_lookup(mw
->hash_menu_item
,
2196 menu_item
->menuText
);
2198 g_hash_table_remove(mw
->hash_menu_item
, menu_item
->menuText
);
2199 gtk_container_remove (GTK_CONTAINER (tool_menu_title_menu
), insert_view
);
2203 void remove_toolbar_item(gpointer main_win
, gpointer user_data
)
2205 MainWindow
* mw
= (MainWindow
*) main_win
;
2206 lttv_toolbar_closure
*toolbar_item
= (lttv_toolbar_closure
*)user_data
;
2207 GtkWidget
* tool_menu_title_menu
, *insert_view
;
2210 tool_menu_title_menu
= lookup_widget(mw
->mwindow
,"MToolbar1");
2211 insert_view
= (GtkWidget
*)g_hash_table_lookup(mw
->hash_toolbar_item
,
2212 toolbar_item
->tooltip
);
2214 g_hash_table_remove(mw
->hash_toolbar_item
, toolbar_item
->tooltip
);
2215 gtk_container_remove (GTK_CONTAINER (tool_menu_title_menu
), insert_view
);
2220 * Remove menu and toolbar item when a module unloaded from all
2224 void main_window_remove_menu_item(lttvwindow_viewer_constructor constructor
)
2228 lttv_menu_closure
*menu_item
;
2229 LttvAttributeValue value
;
2230 LttvIAttribute
*attributes
= LTTV_IATTRIBUTE(lttv_global_attributes());
2232 g_assert(lttv_iattribute_find_by_path(attributes
,
2233 "viewers/menu", LTTV_POINTER
, &value
));
2234 menu
= (LttvMenus
*)*(value
.v_pointer
);
2237 for(i
=0;i
<menu
->len
;i
++){
2238 menu_item
= &g_array_index(menu
, lttv_menu_closure
, i
);
2239 if(menu_item
->con
!= constructor
) continue;
2240 if(g_main_window_list
){
2241 g_slist_foreach(g_main_window_list
, remove_menu_item
, menu_item
);
2249 void main_window_remove_toolbar_item(lttvwindow_viewer_constructor constructor
)
2252 LttvToolbars
* toolbar
;
2253 lttv_toolbar_closure
*toolbar_item
;
2254 LttvAttributeValue value
;
2255 LttvIAttribute
*attributes
= LTTV_IATTRIBUTE(lttv_global_attributes());
2257 g_assert(lttv_iattribute_find_by_path(attributes
,
2258 "viewers/toolbar", LTTV_POINTER
, &value
));
2259 toolbar
= (LttvToolbars
*)*(value
.v_pointer
);
2262 for(i
=0;i
<toolbar
->len
;i
++){
2263 toolbar_item
= &g_array_index(toolbar
, lttv_toolbar_closure
, i
);
2264 if(toolbar_item
->con
!= constructor
) continue;
2265 if(g_main_window_list
){
2266 g_slist_foreach(g_main_window_list
, remove_toolbar_item
, toolbar_item
);
2274 * Function to show each viewer in the current tab.
2275 * It will be called by main window, call show on each registered viewer,
2276 * will call process traceset and then it will
2277 * @param main_win the main window the viewer belongs to.
2279 //FIXME Only one time request maximum for now!
2280 void show_viewer(MainWindow
*main_win
)
2282 LttvAttributeValue value
;
2285 LttvTracesetContext
* tsc
=
2286 (LttvTracesetContext
*)main_win
->current_tab
->
2287 traceset_info
->traceset_context
;
2289 g_assert(lttv_iattribute_find_by_path(main_win
->current_tab
->attributes
,
2290 "hooks/showviewer", LTTV_POINTER
, &value
));
2291 tmp
= (LttvHooks
*)*(value
.v_pointer
);
2294 g_warning("The viewer(s) did not add any show hook");
2299 // Call the show, where viewers add hooks to context and fill the
2300 // time and number of events requested it the time_requests GArray.
2301 lttv_hooks_call(tmp
, NULL
);
2307 gboolean
execute_time_requests(MainWindow
* mw
)
2309 call_pending_read_hooks(mw
);
2311 return FALSE
; // automatically removed from the list of event sources