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/lttvwindow.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 static gboolean
lttvwindow_process_pending_requests(Tab
*tab
);
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 static void insert_viewer(GtkWidget
* widget
, lttvwindow_viewer_constructor constructor
)
167 GtkMultiVPaned
* multi_vpaned
;
168 MainWindow
* mw_data
= get_window_data_struct(widget
);
170 LttvTracesetSelector
* s
;
171 TimeInterval
* time_interval
;
172 Tab
*tab
= mw_data
->current_tab
;
175 multi_vpaned
= tab
->multi_vpaned
;
177 s
= construct_traceset_selector(tab
->traceset_info
->traceset
);
178 viewer
= (GtkWidget
*)constructor(tab
, 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 /* lttvwindow_process_pending_requests
380 * This internal function gets called by g_idle, taking care of the pending
381 * requests. It is responsible for concatenation of time intervals and position
382 * requests. It does it with the following algorithm organizing process traceset
383 * calls. Here is the detailed description of the way it works :
385 * - Events Requests Servicing Algorithm
387 * Data structures necessary :
389 * List of requests added to context : list_in
390 * List of requests not added to context : list_out
395 * list_out : many events requests
397 * FIXME : insert rest of algorithm here
402 gboolean
lttvwindow_process_pending_requests(Tab
*tab
)
404 unsigned max_nb_events
;
408 LttvTracesetContext
*tsc
;
409 LttvTracefileContext
*tfc
;
410 GSList
*events_requests
= tab
->events_requests
;
411 GSList
*list_out
= events_requests
;
412 GSList
*list_in
= NULL
;
415 LttvTracesetContextPosition
*end_position
;
418 /* Current tab check : if no current tab is present, no hooks to call. */
419 /* (Xang Xiu) It makes the expose works.. MD:? */
423 /* There is no events requests pending : we should never have been called! */
424 g_assert(g_slist_length(events_requests
) != 0);
426 tsc
= LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
428 //set the cursor to be X shape, indicating that the computer is busy in doing its job
429 new = gdk_cursor_new(GDK_X_CURSOR
);
430 widget
= lookup_widget(tab
->mw_data
->mwindow
, "MToolbar1");
431 win
= gtk_widget_get_parent_window(widget
);
432 gdk_window_set_cursor(win
, new);
433 gdk_cursor_unref(new);
434 gdk_window_stick(win
);
435 gdk_window_unstick(win
);
437 g_debug("SIZE events req len : %d", g_slist_length(events_request
));
439 /* Events processing algorithm implementation */
440 /* A. Servicing loop */
441 while( (g_slist_length(list_in
) != 0 || g_slist_length(list_out
) != 0)
442 && !gtk_events_pending() ) {
444 /* 1. If list_in is empty (need a seek) */
445 if( g_slist_length(list_in
) == 0 ) {
447 /* list in is empty, need a seek */
449 /* 1.1 Add requests to list_in */
450 GArray
*ltime
= g_array_new(FALSE
, FALSE
, sizeof(guint
));
451 GArray
*lpos
= g_array_new(FALSE
, FALSE
, sizeof(guint
));
454 /* 1.1.1 Find all time requests with the lowest start time in list_out
457 if(list_out
->len
> 0)
458 g_array_append_val(ltime
, 0);
459 for(i
=1;i
<list_out
->len
;i
++) {
460 /* Find all time requests with the lowest start time in list_out */
461 guint index_ltime
= g_array_index(ltime
, guint
, 0);
462 EventsRequest
*event_request_ltime
= &g_array_index(list_out
,
465 EventsRequest
*event_request_list_out
= &g_array_index(list_out
,
469 comp
= ltt_time_compare(event_request_ltime
->start_time
,
470 event_request_list_out
->start_time
);
472 g_array_append_val(ltime
, i
);
474 /* Remove all elements from ltime, and add current */
475 g_array_remove_range(ltime
, 0, ltime
->len
);
476 g_array_append_val(ltime
, i
);
481 /* 1.1.2 Find all position requests with the lowest position in list_out
484 if(list_out
->len
> 0)
485 g_array_append(lpos
, 0);
486 for(i
=1;i
<list_out
->len
;i
++) {
487 /* Find all position requests with the lowest position in list_out */
488 guint index_lpos
= g_array_index(lpos
, guint
, 0);
489 EventsRequest
*event_request_lpos
= &g_array_index(lpos
,
492 EventsRequest
*event_request_list_out
= &g_array_index(list_out
,
496 comp
= lttv_traceset_context_pos_pos_compare
497 (event_request_pos
->start_position
,
498 event_request_list_out
->start_position
);
500 g_array_append_val(lpos
, i
);
502 /* Remove all elements from lpos, and add current */
503 g_array_remove_range(lpos
, 0, lpos
->len
);
504 g_array_append_val(lpos
, i
);
508 /* 1.1.3 If lpos.start time < ltime */
511 EventsRequest
*event_request_lpos
= &g_array_index(lpos
, 0);
512 EventsRequest
*event_request_ltime
= &g_array_index(ltime
,0);
513 LttTime lpos_start_time
=
514 lttv_traceset_context_position_get_time(event_request_lpos
);
516 if(ltt_time_compare(lpos_start_time
,
517 event_request_ltime
->start_time
)<0) {
518 /* Add lpos to list_in, remove them from list_out */
520 for(i
=0;i
<lpos
->len
;i
++) {
522 guint index_lpos
= g_array_index(lpos
, guint
, i
);
523 EventsRequest
*event_request_lpos
=
524 &g_array_index(lpos
,index_lpos
);
526 g_array_append_val(list_in
, *event_request_lpos
);
530 for(i
=0;i
<lpos
->len
;i
++) {
531 /* Remove from list_out */
532 guint index_lpos
= g_array_index(lpos
, guint
, i
);
534 g_array_remove_index_fast(list_out
, index_lpos
);
538 /* 1.1.4 (lpos.start time >= ltime) */
539 /* Add ltime to list_in, remove them from list_out */
541 for(i
=0;i
<ltime
->len
;i
++) {
543 guint index_ltime
= g_array_index(ltime
, guint
, i
);
544 EventsRequest
*event_request_ltime
=
545 &g_array_index(ltime
,index_ltime
);
547 g_array_append_val(list_in
, *event_request_ltime
);
550 for(i
=0;i
<ltime
->len
;i
++) {
551 /* Remove from list_out */
552 guint index_ltime
= g_array_index(ltime
, guint
, i
);
554 g_array_remove_index_fast(list_out
, index_ltime
);
558 g_array_free(lpos
, TRUE
);
559 g_array_free(ltime
, TRUE
);
564 EventsRequest
*events_request
= &g_array_index(list_in
,
568 /* 1.2.1 If first request in list_in is a time request */
569 if(events_request
->start_position
== NULL
) {
570 /* 1.2.1.1 Seek to that time */
571 lttv_process_traceset_seek_time(tsc
, events_request
->start_time
);
573 /* Else, the first request in list_in is a position request */
574 /* 1.2.2.1 Seek to that position */
575 lttv_process_traceset_seek_position(tsc
, events_request
->start_position
);
579 /* 1.3 Call begin for all list_in members */
583 for(i
=0;i
<list_in
->len
;i
++) {
584 EventsRequest
*events_request
= &g_array_index(list_in
,
587 /* (1.3.1 begin hooks called) */
588 /* (1.3.2 middle hooks added) */
589 lttv_process_traceset_begin(tsc
, events_request
->before_traceset
,
590 events_request
->before_trace
,
591 events_request
->before_tracefile
,
592 events_request
->event
,
593 events_request
->event_by_id
);
597 /* 2. Else, list_in is not empty, we continue a read */
599 tfc
= lttv_traceset_context_get_current_tfc(tsc
);
601 /* 2.1 For each req of list_out */
602 for(i
=0;i
<list_out
->len
;i
++) {
603 EventsRequest
*events_request
= &g_array_index(list_out
,
606 if(ltt_time_compare(events_request
->start_time
,
607 tfc
->timestamp
) == 0) {
608 /* if req.start time == current context time */
610 lttv_process_traceset_begin(tsc
, events_request
->before_traceset
,
611 events_request
->before_trace
,
612 events_request
->before_tracefile
,
613 events_request
->event
,
614 events_request
->event_by_id
);
618 g_array_append_val(list_in
, *events_request
);
619 } else if(events_request
->start_position
!= NULL
&&
620 lttv_traceset_context_ctx_pos_compare(tsc
,
621 events_request
->start_position
) == 0) {
622 /* if req.start position == current position */
624 lttv_process_traceset_begin(tsc
, events_request
->before_traceset
,
625 events_request
->before_trace
,
626 events_request
->before_tracefile
,
627 events_request
->event
,
628 events_request
->event_by_id
);
632 g_array_append_val(list_in
, *events_request
);
639 for(i
=0;i
<list_out
->len
;i
++) {
640 EventsRequest
*events_request
= &g_array_index(list_out
,
643 if(ltt_time_compare(events_request
->start_time
,
644 tfc
->timestamp
) == 0) {
645 /* if req.start time == current context time */
646 /* Remove from list_out */
647 g_array_remove_index_fast(list_out
, i
);
648 } else if(events_request
->start_position
!= NULL
&&
649 lttv_traceset_context_ctx_pos_compare(tsc
,
650 events_request
->start_position
) == 0) {
651 /* if req.start position == current position */
652 /* Remove from list_out */
653 g_array_remove_index_fast(list_out
, i
);
661 /* 3. Find end criterions */
666 /* 3.1.1 Find lowest end time in list_in */
667 end_time
= g_array_index(list_in
, EventsRequest
,0).end_time
;
669 for(i
=1;i
<list_in
->len
;i
++) {
670 EventsRequest
*events_request
= &g_array_index(list_in
,
673 if(ltt_time_compare(events_request
->end_time
,
675 end_time
= events_request
->end_time
;
678 /* 3.1.2 Find lowest start time in list_out */
679 for(i
=0;i
<list_out
->len
;i
++) {
680 EventsRequest
*events_request
= &g_array_index(list_out
,
683 if(ltt_time_compare(events_request
->start_time
,
685 end_time
= events_request
->start_time
;
690 /* 3.2 Number of events */
692 /* 3.2.1 Find lowest number of events in list_in */
695 end_nb_events
= g_array_index(list_in
, EventsRequest
, 0).num_events
;
697 for(i
=1;i
<list_in
->len
;i
++) {
698 EventsRequest
*events_request
= &g_array_index(list_in
,
701 if(events_request
->num_events
< end_nb_events
)
702 end_nb_events
= events_request
->num_events
;
707 /* 3.3 End position */
709 /* 3.3.1 Find lowest end position in list_in */
712 end_position
= g_array_index(list_in
, EventsRequest
, 0).end_position
;
714 for(i
=1;i
<list_in
->len
;i
++) {
715 EventsRequest
*events_request
= &g_array_index(list_in
,
719 if(lttv_traceset_context_pos_pos_compare(events_request
->end_position
,
721 end_position
= events_request
->end_position
;
726 /* 3.3.2 Find lowest start position in list_out */
729 for(i
=0;i
<list_out
->len
;i
++) {
730 EventsRequest
*events_request
= &g_array_index(list_out
,
734 if(lttv_traceset_context_pos_pos_compare(events_request
->end_position
,
736 end_position
= events_request
->end_position
;
743 /* B. When interrupted */
745 /* 1. for each request in list_in */
747 GSList
*iter
= list_in
;
749 while(iter
!= NULL
) {
751 gboolean remove
= FALSE
;
752 gboolean free_data
= FALSE
;
753 EventsRequest events_request
= (EventsRequest
*)iter
->data
;
755 /* 1.1. Use current postition as start position */
756 g_free(events_request
->start_position
);
757 lttv_traceset_context_position_save(tsc
, events_request
->start_position
);
759 /* 1.2. Remove start time */
760 events_request
->start_time
= { G_MAXUINT
, G_MAXUINT
};
762 /* 1.3. Call after_traceset */
763 /* 1.4. Remove event hooks */
764 lttv_process_traceset_end(tsc
, events_request
->after_traceset
,
765 events_request
->after_trace
,
766 events_request
->after_tracefile
,
767 events_request
->event
,
768 events_request
->event_by_id
);
770 /* 1.5. Put it back in list_out */
773 list_out
= g_slist_append(list_out
, events_request
);
779 GSList
*remove_iter
= iter
;
781 iter
= g_slist_next(iter
);
782 if(free_data
) g_free(remove_iter
->data
);
783 list_in
= g_slist_remove_link(list_in
, remove_iter
);
784 } else { // not remove
785 iter
= g_slist_next(iter
);
792 /* 2. Save current state into saved_state. */
794 /* 2.1 Free old saved state. */
795 //FIXME : free will need to be able to remove state for a traceset
796 //with changed traces!
797 //FIXME lttv_state_state_saved_free( , tab->interrupted_state);
799 /* 2.2 save current state. */
801 //lttv_state_save( ,tab->interrupted_state);
805 //set the cursor back to normal
806 gdk_window_set_cursor(win
, NULL
);
810 if( g_slist_length(list_in
) == 0 && g_slist_length(list_out
) == 0 ) {
811 /* Put tab's request pending flag back to normal */
812 tab
->time_request_pending
= FALSE
;
813 return FALSE
; /* Remove the idle function */
816 return TRUE
; /* Leave the idle function */
821 GSList
*iter
= list_in
;
823 /* 1. for each request in list_in */
824 while(iter
!= NULL
) {
826 gboolean remove
= FALSE
;
827 gboolean free_data
= FALSE
;
834 GSList
*remove_iter
= iter
;
836 iter
= g_slist_next(iter
);
837 if(free_data
) g_free(remove_iter
->data
);
838 list_in
= g_slist_remove_link(list_in
, remove_iter
);
839 } else { // not remove
840 iter
= g_slist_next(iter
);
847 /* add_trace_into_traceset_selector, each instance of a viewer has an associated
848 * selector (filter), when a trace is added into traceset, the selector should
849 * reflect the change. The function is used to update the selector
852 void add_trace_into_traceset_selector(GtkMultiVPaned
* paned
, LttTrace
* t
)
854 int j
, k
, m
, nb_tracefile
, nb_control
, nb_per_cpu
, nb_facility
, nb_event
;
855 LttvTracesetSelector
* s
;
856 LttvTraceSelector
* trace
;
857 LttvTracefileSelector
* tracefile
;
858 LttvEventtypeSelector
* eventtype
;
864 w
= gtk_multi_vpaned_get_first_widget(paned
);
866 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
869 trace
= lttv_trace_selector_new(t
);
870 lttv_traceset_selector_trace_add(s
, trace
);
872 nb_facility
= ltt_trace_facility_number(t
);
873 for(k
=0;k
<nb_facility
;k
++){
874 fac
= ltt_trace_facility_get(t
,k
);
875 nb_event
= (int) ltt_facility_eventtype_number(fac
);
876 for(m
=0;m
<nb_event
;m
++){
877 et
= ltt_facility_eventtype_get(fac
,m
);
878 eventtype
= lttv_eventtype_selector_new(et
);
879 lttv_trace_selector_eventtype_add(trace
, eventtype
);
883 nb_control
= ltt_trace_control_tracefile_number(t
);
884 nb_per_cpu
= ltt_trace_per_cpu_tracefile_number(t
);
885 nb_tracefile
= nb_control
+ nb_per_cpu
;
887 for(j
= 0 ; j
< nb_tracefile
; j
++) {
889 tf
= ltt_trace_control_tracefile_get(t
, j
);
891 tf
= ltt_trace_per_cpu_tracefile_get(t
, j
- nb_control
);
892 tracefile
= lttv_tracefile_selector_new(tf
);
893 lttv_trace_selector_tracefile_add(trace
, tracefile
);
894 lttv_eventtype_selector_copy(trace
, tracefile
);
896 }else g_warning("Module does not support filtering\n");
898 w
= gtk_multi_vpaned_get_next_widget(paned
);
903 /* add_trace adds a trace into the current traceset. It first displays a
904 * directory selection dialogue to let user choose a trace, then recreates
905 * tracset_context, and redraws all the viewer of the current tab
908 void add_trace(GtkWidget
* widget
, gpointer user_data
)
912 LttvTraceset
* traceset
;
916 MainWindow
* mw_data
= get_window_data_struct(widget
);
917 GtkDirSelection
* file_selector
= (GtkDirSelection
*)gtk_dir_selection_new("Select a trace");
918 gtk_dir_selection_hide_fileop_buttons(file_selector
);
919 if(remember_trace_dir
[0] != '\0')
920 gtk_dir_selection_set_filename(file_selector
, remember_trace_dir
);
922 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
924 case GTK_RESPONSE_ACCEPT
:
925 case GTK_RESPONSE_OK
:
926 dir
= gtk_dir_selection_get_dir (file_selector
);
927 strncpy(remember_trace_dir
, dir
, PATH_LENGTH
);
928 if(!dir
|| strlen(dir
) == 0){
929 gtk_widget_destroy((GtkWidget
*)file_selector
);
932 trace
= ltt_trace_open(dir
);
933 if(trace
== NULL
) g_critical("cannot open trace %s", dir
);
934 trace_v
= lttv_trace_new(trace
);
935 traceset
= mw_data
->current_tab
->traceset_info
->traceset
;
937 //Keep a reference to the traces so they are not freed.
938 for(i
=0; i
<lttv_traceset_number(traceset
); i
++)
940 LttvTrace
* trace
= lttv_traceset_get(traceset
, i
);
941 lttv_trace_ref(trace
);
944 //remove state update hooks
945 lttv_state_remove_event_hooks(
946 (LttvTracesetState
*)mw_data
->current_tab
->traceset_info
->traceset_context
);
948 lttv_context_fini(LTTV_TRACESET_CONTEXT(
949 mw_data
->current_tab
->traceset_info
->traceset_context
));
950 g_object_unref(mw_data
->current_tab
->traceset_info
->traceset_context
);
953 lttv_traceset_add(traceset
, trace_v
);
955 /* Create new context */
956 mw_data
->current_tab
->traceset_info
->traceset_context
=
957 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
959 LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->traceset_info
->
962 //add state update hooks
963 lttv_state_add_event_hooks(
964 (LttvTracesetState
*)mw_data
->current_tab
->traceset_info
->traceset_context
);
965 //Remove local reference to the traces.
966 for(i
=0; i
<lttv_traceset_number(traceset
); i
++)
968 LttvTrace
* trace
= lttv_traceset_get(traceset
, i
);
969 lttv_trace_unref(trace
);
973 add_trace_into_traceset_selector(mw_data
->current_tab
->multi_vpaned
, trace
);
975 gtk_widget_destroy((GtkWidget
*)file_selector
);
978 //update_traceset(mw_data);
980 //get_traceset_time_span(mw_data,LTTV_TRACESET_CONTEXT(mw_data->current_tab->traceset_info->traceset_context)->Time_Span);
982 lttv_traceset_number(mw_data
->current_tab
->traceset_info
->traceset
) == 1
983 || ltt_time_compare(mw_data
->current_tab
->current_time
,
984 LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->traceset_info
->
985 traceset_context
)->time_span
.start_time
)<0)
987 /* Set initial time if this is the first trace in the traceset */
988 mw_data
->current_tab
->current_time
=
989 LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->traceset_info
->
990 traceset_context
)->time_span
.start_time
;
991 mw_data
->current_tab
->time_window
.start_time
=
992 mw_data
->current_tab
->current_time
;
993 mw_data
->current_tab
->time_window
.time_width
.tv_sec
=
994 DEFAULT_TIME_WIDTH_S
;
995 mw_data
->current_tab
->time_window
.time_width
.tv_nsec
= 0;
998 /* Call the updatetraceset hooks */
1000 SetTraceset(mw_data
, (gpointer
)traceset
);
1001 // in expose now call_pending_read_hooks(mw_data);
1003 //lttvwindow_report_current_time(mw_data,&(mw_data->current_tab->current_time));
1005 case GTK_RESPONSE_REJECT
:
1006 case GTK_RESPONSE_CANCEL
:
1008 gtk_widget_destroy((GtkWidget
*)file_selector
);
1014 /* remove_trace_into_traceset_selector, each instance of a viewer has an associated
1015 * selector (filter), when a trace is remove from traceset, the selector should
1016 * reflect the change. The function is used to update the selector
1019 void remove_trace_from_traceset_selector(GtkMultiVPaned
* paned
, unsigned i
)
1021 LttvTracesetSelector
* s
;
1022 LttvTraceSelector
* t
;
1025 w
= gtk_multi_vpaned_get_first_widget(paned
);
1027 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
1029 t
= lttv_traceset_selector_trace_get(s
,i
);
1030 lttv_traceset_selector_trace_remove(s
, i
);
1031 lttv_trace_selector_destroy(t
);
1032 }g_warning("Module dose not support filtering\n");
1033 w
= gtk_multi_vpaned_get_next_widget(paned
);
1038 /* remove_trace removes a trace from the current traceset if all viewers in
1039 * the current tab are not interested in the trace. It first displays a
1040 * dialogue, which shows all traces in the current traceset, to let user choose
1041 * a trace, then it checks if all viewers unselect the trace, if it is true,
1042 * it will remove the trace, recreate the traceset_contex,
1043 * and redraws all the viewer of the current tab. If there is on trace in the
1044 * current traceset, it will delete all viewers of the current tab
1047 void remove_trace(GtkWidget
* widget
, gpointer user_data
)
1050 LttvTrace
* trace_v
;
1051 LttvTraceset
* traceset
;
1052 gint i
, j
, nb_trace
;
1053 char ** name
, *remove_trace_name
;
1054 MainWindow
* mw_data
= get_window_data_struct(widget
);
1055 LttvTracesetSelector
* s
;
1056 LttvTraceSelector
* t
;
1060 nb_trace
=lttv_traceset_number(mw_data
->current_tab
->traceset_info
->traceset
);
1061 name
= g_new(char*,nb_trace
);
1062 for(i
= 0; i
< nb_trace
; i
++){
1063 trace_v
= lttv_traceset_get(mw_data
->current_tab
->
1064 traceset_info
->traceset
, i
);
1065 trace
= lttv_trace(trace_v
);
1066 name
[i
] = ltt_trace_name(trace
);
1069 remove_trace_name
= get_remove_trace(name
, nb_trace
);
1071 if(remove_trace_name
){
1072 for(i
=0; i
<nb_trace
; i
++){
1073 if(strcmp(remove_trace_name
,name
[i
]) == 0){
1074 //unselect the trace from the current viewer
1075 w
= gtk_multi_vpaned_get_widget(mw_data
->current_tab
->multi_vpaned
);
1077 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
1079 t
= lttv_traceset_selector_trace_get(s
,i
);
1080 lttv_trace_selector_set_selected(t
, FALSE
);
1083 //check if other viewers select the trace
1084 w
= gtk_multi_vpaned_get_first_widget(mw_data
->current_tab
->multi_vpaned
);
1086 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
1088 t
= lttv_traceset_selector_trace_get(s
,i
);
1089 selected
= lttv_trace_selector_get_selected(t
);
1092 w
= gtk_multi_vpaned_get_next_widget(mw_data
->current_tab
->multi_vpaned
);
1094 }else selected
= FALSE
;
1096 //if no viewer selects the trace, remove it
1098 remove_trace_from_traceset_selector(mw_data
->current_tab
->multi_vpaned
, i
);
1100 traceset
= mw_data
->current_tab
->traceset_info
->traceset
;
1101 trace_v
= lttv_traceset_get(traceset
, i
);
1102 if(lttv_trace_get_ref_number(trace_v
) <= 1)
1103 ltt_trace_close(lttv_trace(trace_v
));
1105 //Keep a reference to the traces so they are not freed.
1106 for(j
=0; j
<lttv_traceset_number(traceset
); j
++)
1108 LttvTrace
* trace
= lttv_traceset_get(traceset
, j
);
1109 lttv_trace_ref(trace
);
1112 //remove state update hooks
1113 lttv_state_remove_event_hooks(
1114 (LttvTracesetState
*)mw_data
->current_tab
->traceset_info
->traceset_context
);
1115 lttv_context_fini(LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->traceset_info
->traceset_context
));
1116 g_object_unref(mw_data
->current_tab
->traceset_info
->traceset_context
);
1119 lttv_traceset_remove(traceset
, i
);
1120 lttv_trace_unref(trace_v
); // Remove local reference
1121 if(!lttv_trace_get_ref_number(trace_v
))
1122 lttv_trace_destroy(trace_v
);
1124 mw_data
->current_tab
->traceset_info
->traceset_context
=
1125 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
1127 LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->
1128 traceset_info
->traceset_context
),traceset
);
1129 //add state update hooks
1130 lttv_state_add_event_hooks(
1131 (LttvTracesetState
*)mw_data
->current_tab
->traceset_info
->traceset_context
);
1133 //Remove local reference to the traces.
1134 for(j
=0; j
<lttv_traceset_number(traceset
); j
++)
1136 LttvTrace
* trace
= lttv_traceset_get(traceset
, j
);
1137 lttv_trace_unref(trace
);
1141 //update current tab
1142 //update_traceset(mw_data);
1145 SetTraceset(mw_data
, (gpointer
)traceset
);
1146 // in expose now call_pending_read_hooks(mw_data);
1148 //lttvwindow_report_current_time(mw_data,&(mw_data->current_tab->current_time));
1150 if(mw_data
->current_tab
){
1151 while(mw_data
->current_tab
->multi_vpaned
->num_children
){
1152 gtk_multi_vpaned_widget_delete(mw_data
->current_tab
->multi_vpaned
);
1166 /* save will save the traceset to a file
1167 * Not implemented yet FIXME
1170 void save(GtkWidget
* widget
, gpointer user_data
)
1175 void save_as(GtkWidget
* widget
, gpointer user_data
)
1177 g_printf("Save as\n");
1181 /* zoom will change the time_window of all the viewers of the
1182 * current tab, and redisplay them. The main functionality is to
1183 * determine the new time_window of the current tab
1186 void zoom(GtkWidget
* widget
, double size
)
1188 TimeInterval
*time_span
;
1189 TimeWindow new_time_window
;
1190 LttTime current_time
, time_delta
, time_s
, time_e
, time_tmp
;
1191 MainWindow
* mw_data
= get_window_data_struct(widget
);
1192 Tab
*tab
= mw_data
->current_tab
;
1193 LttvTracesetContext
*tsc
=
1194 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
1196 if(size
== 1) return;
1198 time_span
= &tsc
->time_span
;
1199 new_time_window
= tab
->time_window
;
1200 current_time
= tab
->current_time
;
1202 time_delta
= ltt_time_sub(time_span
->end_time
,time_span
->start_time
);
1204 new_time_window
.start_time
= time_span
->start_time
;
1205 new_time_window
.time_width
= time_delta
;
1207 new_time_window
.time_width
= ltt_time_div(new_time_window
.time_width
, size
);
1208 if(ltt_time_compare(new_time_window
.time_width
,time_delta
) > 0)
1209 { /* Case where zoom out is bigger than trace length */
1210 new_time_window
.start_time
= time_span
->start_time
;
1211 new_time_window
.time_width
= time_delta
;
1215 /* Center the image on the current time */
1216 g_critical("update is HERE");
1217 new_time_window
.start_time
=
1218 ltt_time_sub(current_time
, ltt_time_div(new_time_window
.time_width
, 2.0));
1219 /* If on borders, don't fall off */
1220 if(ltt_time_compare(new_time_window
.start_time
, time_span
->start_time
) <0)
1222 new_time_window
.start_time
= time_span
->start_time
;
1226 if(ltt_time_compare(
1227 ltt_time_add(new_time_window
.start_time
, new_time_window
.time_width
),
1228 time_span
->end_time
) > 0)
1230 new_time_window
.start_time
=
1231 ltt_time_sub(time_span
->end_time
, new_time_window
.time_width
);
1239 //time_tmp = ltt_time_div(new_time_window.time_width, 2);
1240 //if(ltt_time_compare(current_time, time_tmp) < 0){
1241 // time_s = time_span->startTime;
1243 // time_s = ltt_time_sub(current_time,time_tmp);
1245 //time_e = ltt_time_add(current_time,time_tmp);
1246 //if(ltt_time_compare(time_span->startTime, time_s) > 0){
1247 // time_s = time_span->startTime;
1248 //}else if(ltt_time_compare(time_span->endTime, time_e) < 0){
1249 // time_e = time_span->endTime;
1250 // time_s = ltt_time_sub(time_e,new_time_window.time_width);
1252 //new_time_window.start_time = time_s;
1255 //lttvwindow_report_time_window(mw_data, &new_time_window);
1256 //call_pending_read_hooks(mw_data);
1258 //lttvwindow_report_current_time(mw_data,&(mw_data->current_tab->current_time));
1259 set_time_window(tab
, &new_time_window
);
1260 // in expose now call_pending_read_hooks(mw_data);
1261 gtk_multi_vpaned_set_adjust(tab
->multi_vpaned
, &new_time_window
, FALSE
);
1264 void zoom_in(GtkWidget
* widget
, gpointer user_data
)
1269 void zoom_out(GtkWidget
* widget
, gpointer user_data
)
1274 void zoom_extended(GtkWidget
* widget
, gpointer user_data
)
1279 void go_to_time(GtkWidget
* widget
, gpointer user_data
)
1281 g_printf("Go to time\n");
1284 void show_time_frame(GtkWidget
* widget
, gpointer user_data
)
1286 g_printf("Show time frame\n");
1290 /* callback function */
1293 on_empty_traceset_activate (GtkMenuItem
*menuitem
,
1296 create_new_window((GtkWidget
*)menuitem
, user_data
, FALSE
);
1301 on_clone_traceset_activate (GtkMenuItem
*menuitem
,
1304 create_new_window((GtkWidget
*)menuitem
, user_data
, TRUE
);
1308 /* create_new_tab calls create_tab to construct a new tab in the main window
1311 void create_new_tab(GtkWidget
* widget
, gpointer user_data
){
1312 gchar label
[PATH_LENGTH
];
1313 MainWindow
* mw_data
= get_window_data_struct(widget
);
1314 GtkNotebook
* notebook
= (GtkNotebook
*)lookup_widget(widget
, "MNotebook");
1315 if(notebook
== NULL
){
1316 g_printf("Notebook does not exist\n");
1320 strcpy(label
,"Page");
1321 if(get_label(mw_data
, label
,"Get the name of the tab","Please input tab's name"))
1322 create_tab (NULL
, mw_data
, notebook
, label
);
1326 on_tab_activate (GtkMenuItem
*menuitem
,
1329 create_new_tab((GtkWidget
*)menuitem
, user_data
);
1334 on_open_activate (GtkMenuItem
*menuitem
,
1337 open_traceset((GtkWidget
*)menuitem
, user_data
);
1342 on_close_activate (GtkMenuItem
*menuitem
,
1345 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1346 main_window_destructor(mw_data
);
1350 /* remove the current tab from the main window if it is not the default tab
1354 on_close_tab_activate (GtkMenuItem
*menuitem
,
1359 GtkWidget
* notebook
;
1361 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1362 notebook
= lookup_widget((GtkWidget
*)menuitem
, "MNotebook");
1363 if(notebook
== NULL
){
1364 g_printf("Notebook does not exist\n");
1368 if(mw_data
->tab
== mw_data
->current_tab
){
1369 // tmp = mw_data->current_tb;
1370 // mw_data->tab = mw_data->current_tab->next;
1371 g_printf("The default TAB can not be deleted\n");
1375 while(tmp
!= mw_data
->current_tab
){
1381 gtk_notebook_remove_page((GtkNotebook
*)notebook
, count
);
1382 list
= gtk_container_get_children(GTK_CONTAINER(notebook
));
1383 if(g_list_length(list
)==1)
1384 gtk_notebook_set_show_tabs((GtkNotebook
*)notebook
, FALSE
);
1389 on_add_trace_activate (GtkMenuItem
*menuitem
,
1392 add_trace((GtkWidget
*)menuitem
, user_data
);
1397 on_remove_trace_activate (GtkMenuItem
*menuitem
,
1400 remove_trace((GtkWidget
*)menuitem
, user_data
);
1405 on_save_activate (GtkMenuItem
*menuitem
,
1408 save((GtkWidget
*)menuitem
, user_data
);
1413 on_save_as_activate (GtkMenuItem
*menuitem
,
1416 save_as((GtkWidget
*)menuitem
, user_data
);
1421 on_quit_activate (GtkMenuItem
*menuitem
,
1429 on_cut_activate (GtkMenuItem
*menuitem
,
1437 on_copy_activate (GtkMenuItem
*menuitem
,
1440 g_printf("Copye\n");
1445 on_paste_activate (GtkMenuItem
*menuitem
,
1448 g_printf("Paste\n");
1453 on_delete_activate (GtkMenuItem
*menuitem
,
1456 g_printf("Delete\n");
1461 on_zoom_in_activate (GtkMenuItem
*menuitem
,
1464 zoom_in((GtkWidget
*)menuitem
, user_data
);
1469 on_zoom_out_activate (GtkMenuItem
*menuitem
,
1472 zoom_out((GtkWidget
*)menuitem
, user_data
);
1477 on_zoom_extended_activate (GtkMenuItem
*menuitem
,
1480 zoom_extended((GtkWidget
*)menuitem
, user_data
);
1485 on_go_to_time_activate (GtkMenuItem
*menuitem
,
1488 go_to_time((GtkWidget
*)menuitem
, user_data
);
1493 on_show_time_frame_activate (GtkMenuItem
*menuitem
,
1496 show_time_frame((GtkWidget
*)menuitem
, user_data
);
1501 on_move_viewer_up_activate (GtkMenuItem
*menuitem
,
1504 move_up_viewer((GtkWidget
*)menuitem
, user_data
);
1509 on_move_viewer_down_activate (GtkMenuItem
*menuitem
,
1512 move_down_viewer((GtkWidget
*)menuitem
, user_data
);
1517 on_remove_viewer_activate (GtkMenuItem
*menuitem
,
1520 delete_viewer((GtkWidget
*)menuitem
, user_data
);
1524 on_trace_filter_activate (GtkMenuItem
*menuitem
,
1527 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1528 LttvTracesetSelector
* s
;
1529 GtkWidget
* w
= gtk_multi_vpaned_get_widget(mw_data
->current_tab
->multi_vpaned
);
1531 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
1533 g_printf("There is no viewer yet\n");
1536 if(get_filter_selection(s
, "Configure trace and tracefile filter", "Select traces and tracefiles")){
1537 //FIXME report filter change
1538 //update_traceset(mw_data);
1539 //call_pending_read_hooks(mw_data);
1540 //lttvwindow_report_current_time(mw_data,&(mw_data->current_tab->current_time));
1545 on_trace_facility_activate (GtkMenuItem
*menuitem
,
1548 g_printf("Trace facility selector: %s\n");
1552 /* Dispaly a file selection dialogue to let user select a module, then call
1553 * lttv_module_load(), finally insert tool button and menu entry in the main window
1554 * for the loaded module
1558 on_load_module_activate (GtkMenuItem
*menuitem
,
1563 char str
[PATH_LENGTH
], *str1
;
1564 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1565 GtkFileSelection
* file_selector
= (GtkFileSelection
*)gtk_file_selection_new("Select a module");
1566 if(remember_plugins_dir
[0] != '\0')
1567 gtk_file_selection_set_filename(file_selector
, remember_plugins_dir
);
1568 gtk_file_selection_hide_fileop_buttons(file_selector
);
1571 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
1573 case GTK_RESPONSE_ACCEPT
:
1574 case GTK_RESPONSE_OK
:
1575 dir
= gtk_file_selection_get_selections (file_selector
);
1576 strncpy(str
,dir
[0],PATH_LENGTH
);
1577 strncpy(remember_plugins_dir
,dir
[0],PATH_LENGTH
);
1578 str1
= strrchr(str
,'/');
1581 str1
= strrchr(str
,'\\');
1584 lttv_module_require(str1
, NULL
);
1586 case GTK_RESPONSE_REJECT
:
1587 case GTK_RESPONSE_CANCEL
:
1589 gtk_widget_destroy((GtkWidget
*)file_selector
);
1592 g_printf("Load module: %s\n", str
);
1596 /* Display all loaded modules, let user to select a module to unload
1597 * by calling lttv_module_unload
1601 on_unload_module_activate (GtkMenuItem
*menuitem
,
1606 char *unload_module_name
;
1608 LttvLibrary
*library
;
1609 LttvLibraryInfo library_info
;
1610 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1612 name
= g_ptr_array_new();
1613 nb
= lttv_library_number();
1616 library
= lttv_library_get(i
);
1617 lttv_library_info(library
, &library_info
);
1618 if(library_info
.load_count
> 0) g_ptr_array_add(name
, library_info
.name
);
1621 unload_module_name
=get_unload_module((char **)(name
->pdata
), name
->len
);
1623 if(unload_module_name
){
1625 library
= lttv_library_get(i
);
1626 lttv_library_info(library
, &library_info
);
1627 if(strcmp(unload_module_name
, library_info
.name
) == 0){
1628 lttv_library_unload(library
);
1634 g_ptr_array_free(name
, TRUE
);
1638 /* Display a directory dialogue to let user select a path for module searching
1642 on_add_module_search_path_activate (GtkMenuItem
*menuitem
,
1645 GtkDirSelection
* file_selector
= (GtkDirSelection
*)gtk_dir_selection_new("Select module path");
1649 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1650 if(remember_plugins_dir
[0] != '\0')
1651 gtk_dir_selection_set_filename(file_selector
, remember_plugins_dir
);
1653 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
1655 case GTK_RESPONSE_ACCEPT
:
1656 case GTK_RESPONSE_OK
:
1657 dir
= gtk_dir_selection_get_dir (file_selector
);
1658 strncpy(remember_plugins_dir
,dir
,PATH_LENGTH
);
1659 strncat(remember_plugins_dir
,"/",PATH_LENGTH
);
1660 lttv_library_path_add(dir
);
1661 case GTK_RESPONSE_REJECT
:
1662 case GTK_RESPONSE_CANCEL
:
1664 gtk_widget_destroy((GtkWidget
*)file_selector
);
1671 on_color_activate (GtkMenuItem
*menuitem
,
1674 g_printf("Color\n");
1679 on_filter_activate (GtkMenuItem
*menuitem
,
1682 g_printf("Filter\n");
1687 on_save_configuration_activate (GtkMenuItem
*menuitem
,
1690 g_printf("Save configuration\n");
1695 on_content_activate (GtkMenuItem
*menuitem
,
1698 g_printf("Content\n");
1703 on_about_activate (GtkMenuItem
*menuitem
,
1706 g_printf("About...\n");
1711 on_button_new_clicked (GtkButton
*button
,
1714 create_new_window((GtkWidget
*)button
, user_data
, TRUE
);
1718 on_button_new_tab_clicked (GtkButton
*button
,
1721 create_new_tab((GtkWidget
*)button
, user_data
);
1725 on_button_open_clicked (GtkButton
*button
,
1728 open_traceset((GtkWidget
*)button
, user_data
);
1733 on_button_add_trace_clicked (GtkButton
*button
,
1736 add_trace((GtkWidget
*)button
, user_data
);
1741 on_button_remove_trace_clicked (GtkButton
*button
,
1744 remove_trace((GtkWidget
*)button
, user_data
);
1749 on_button_save_clicked (GtkButton
*button
,
1752 save((GtkWidget
*)button
, user_data
);
1757 on_button_save_as_clicked (GtkButton
*button
,
1760 save_as((GtkWidget
*)button
, user_data
);
1765 on_button_zoom_in_clicked (GtkButton
*button
,
1768 zoom_in((GtkWidget
*)button
, user_data
);
1773 on_button_zoom_out_clicked (GtkButton
*button
,
1776 zoom_out((GtkWidget
*)button
, user_data
);
1781 on_button_zoom_extended_clicked (GtkButton
*button
,
1784 zoom_extended((GtkWidget
*)button
, user_data
);
1789 on_button_go_to_time_clicked (GtkButton
*button
,
1792 go_to_time((GtkWidget
*)button
, user_data
);
1797 on_button_show_time_frame_clicked (GtkButton
*button
,
1800 show_time_frame((GtkWidget
*)button
, user_data
);
1805 on_button_move_up_clicked (GtkButton
*button
,
1808 move_up_viewer((GtkWidget
*)button
, user_data
);
1813 on_button_move_down_clicked (GtkButton
*button
,
1816 move_down_viewer((GtkWidget
*)button
, user_data
);
1821 on_button_delete_viewer_clicked (GtkButton
*button
,
1824 delete_viewer((GtkWidget
*)button
, user_data
);
1828 on_MWindow_destroy (GtkObject
*object
,
1831 MainWindow
*main_window
= get_window_data_struct((GtkWidget
*)object
);
1833 Tab
*tab
= main_window
->tab
;
1834 LttvIAttribute
*attributes
= main_window
->attributes
;
1835 LttvAttributeValue value
;
1837 //This is unnecessary, since widgets will be destroyed
1838 //by the main window widget anyway.
1839 //remove_all_menu_toolbar_constructors(main_window, NULL);
1841 g_assert(lttv_iattribute_find_by_path(attributes
,
1842 "viewers/menu", LTTV_POINTER
, &value
));
1843 lttv_menus_destroy((LttvMenus
*)*(value
.v_pointer
));
1845 g_assert(lttv_iattribute_find_by_path(attributes
,
1846 "viewers/toolbar", LTTV_POINTER
, &value
));
1847 lttv_toolbars_destroy((LttvToolbars
*)*(value
.v_pointer
));
1849 while(main_window
->tab
){
1850 lttv_state_remove_event_hooks(
1851 (LttvTracesetState
*)main_window
->tab
->traceset_info
->traceset_context
);
1852 main_window
->tab
= main_window
->tab
->next
;
1854 g_object_unref(main_window
->attributes
);
1855 g_main_window_list
= g_slist_remove(g_main_window_list
, main_window
);
1858 g_printf("There are now : %d windows\n",g_slist_length(g_main_window_list
));
1859 if(g_win_count
== 0)
1864 on_MWindow_configure (GtkWidget
*widget
,
1865 GdkEventConfigure
*event
,
1868 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)widget
);
1869 float width
= event
->width
;
1870 Tab
* tab
= mw_data
->tab
;
1871 TimeWindow time_win
;
1873 TimeInterval
*time_span
;
1876 // MD : removed time width modification upon resizing of the main window.
1877 // The viewers will redraw themselves completely, without time interval
1880 if(mw_data->window_width){
1881 time_span = LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->Time_Span ;
1882 time_win = tab->time_window;
1883 ratio = width / mw_data->window_width;
1884 tab->time_window.time_width = ltt_time_mul(time_win.time_width,ratio);
1885 time = ltt_time_sub(time_span->endTime, time_win.start_time);
1886 if(ltt_time_compare(time, tab->time_window.time_width) < 0){
1887 tab->time_window.time_width = time;
1893 mw_data->window_width = (int)width;
1902 on_MNotebook_switch_page (GtkNotebook
*notebook
,
1903 GtkNotebookPage
*page
,
1907 MainWindow
* mw
= get_window_data_struct((GtkWidget
*)notebook
);
1908 Tab
* tab
= mw
->tab
;
1914 mw
->current_tab
= tab
;
1918 /* callback function to check or uncheck the check box (filter)
1921 void checkbox_changed(GtkTreeView
*treeview
,
1923 GtkTreeViewColumn
*arg2
,
1926 GtkTreeStore
* store
= (GtkTreeStore
*)gtk_tree_view_get_model (treeview
);
1930 if (gtk_tree_model_get_iter ((GtkTreeModel
*)store
, &iter
, arg1
)){
1931 gtk_tree_model_get ((GtkTreeModel
*)store
, &iter
, CHECKBOX_COLUMN
, &value
, -1);
1932 value
= value
? FALSE
: TRUE
;
1933 gtk_tree_store_set (GTK_TREE_STORE (store
), &iter
, CHECKBOX_COLUMN
, value
, -1);
1939 /* According to user's selection, update selector(filter)
1942 void update_filter(LttvTracesetSelector
*s
, GtkTreeStore
*store
)
1944 GtkTreeIter iter
, child_iter
, child_iter1
, child_iter2
;
1945 int i
, j
, k
, nb_eventtype
;
1946 LttvTraceSelector
* trace
;
1947 LttvTracefileSelector
* tracefile
;
1948 LttvEventtypeSelector
* eventtype
;
1949 gboolean value
, value1
, value2
;
1951 if(gtk_tree_model_get_iter_first((GtkTreeModel
*)store
, &iter
)){
1954 trace
= lttv_traceset_selector_trace_get(s
, i
);
1955 nb_eventtype
= lttv_trace_selector_eventtype_number(trace
);
1956 gtk_tree_model_get ((GtkTreeModel
*)store
, &iter
, CHECKBOX_COLUMN
, &value
,-1);
1959 if(gtk_tree_model_iter_children ((GtkTreeModel
*)store
, &child_iter
, &iter
)){
1961 if(j
<1){//eventtype selector for trace
1962 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter
, CHECKBOX_COLUMN
, &value2
,-1);
1965 if(gtk_tree_model_iter_children ((GtkTreeModel
*)store
, &child_iter1
, &child_iter
)){
1967 eventtype
= lttv_trace_selector_eventtype_get(trace
,k
);
1968 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter1
, CHECKBOX_COLUMN
, &value2
,-1);
1969 lttv_eventtype_selector_set_selected(eventtype
,value2
);
1971 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &child_iter1
));
1974 }else{ //tracefile selector
1975 tracefile
= lttv_trace_selector_tracefile_get(trace
, j
- 1);
1976 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter
, CHECKBOX_COLUMN
, &value1
,-1);
1977 lttv_tracefile_selector_set_selected(tracefile
,value1
);
1979 gtk_tree_model_iter_children((GtkTreeModel
*)store
, &child_iter1
, &child_iter
); //eventtype selector
1980 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter1
, CHECKBOX_COLUMN
, &value2
,-1);
1983 if(gtk_tree_model_iter_children ((GtkTreeModel
*)store
, &child_iter2
, &child_iter1
)){
1984 do{//eventtype selector for tracefile
1985 eventtype
= lttv_tracefile_selector_eventtype_get(tracefile
,k
);
1986 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter2
, CHECKBOX_COLUMN
, &value2
,-1);
1987 lttv_eventtype_selector_set_selected(eventtype
,value2
);
1989 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &child_iter2
));
1995 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &child_iter
));
1998 lttv_trace_selector_set_selected(trace
,value
);
2000 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &iter
));
2005 /* Display a dialogue showing all eventtypes and traces, let user to select the interested
2006 * eventtypes, tracefiles and traces (filter)
2009 gboolean
get_filter_selection(LttvTracesetSelector
*s
,char *title
, char * column_title
)
2011 GtkWidget
* dialogue
;
2012 GtkTreeStore
* store
;
2014 GtkWidget
* scroll_win
;
2015 GtkCellRenderer
* renderer
;
2016 GtkTreeViewColumn
* column
;
2017 GtkTreeIter iter
, child_iter
, child_iter1
, child_iter2
;
2018 int i
, j
, k
, id
, nb_trace
, nb_tracefile
, nb_eventtype
;
2019 LttvTraceSelector
* trace
;
2020 LttvTracefileSelector
* tracefile
;
2021 LttvEventtypeSelector
* eventtype
;
2025 dialogue
= gtk_dialog_new_with_buttons(title
,
2028 GTK_STOCK_OK
,GTK_RESPONSE_ACCEPT
,
2029 GTK_STOCK_CANCEL
,GTK_RESPONSE_REJECT
,
2031 gtk_window_set_default_size((GtkWindow
*)dialogue
, 300, 500);
2033 store
= gtk_tree_store_new (TOTAL_COLUMNS
, G_TYPE_BOOLEAN
, G_TYPE_STRING
);
2034 tree
= gtk_tree_view_new_with_model (GTK_TREE_MODEL (store
));
2035 g_object_unref (G_OBJECT (store
));
2036 g_signal_connect (G_OBJECT (tree
), "row-activated",
2037 G_CALLBACK (checkbox_changed
),
2041 renderer
= gtk_cell_renderer_toggle_new ();
2042 gtk_cell_renderer_toggle_set_radio((GtkCellRendererToggle
*)renderer
, FALSE
);
2044 g_object_set (G_OBJECT (renderer
),"activatable", TRUE
, NULL
);
2046 column
= gtk_tree_view_column_new_with_attributes ("Checkbox",
2048 "active", CHECKBOX_COLUMN
,
2050 gtk_tree_view_column_set_alignment (column
, 0.5);
2051 gtk_tree_view_column_set_fixed_width (column
, 20);
2052 gtk_tree_view_append_column (GTK_TREE_VIEW (tree
), column
);
2054 renderer
= gtk_cell_renderer_text_new ();
2055 column
= gtk_tree_view_column_new_with_attributes (column_title
,
2057 "text", NAME_COLUMN
,
2059 gtk_tree_view_column_set_alignment (column
, 0.0);
2060 gtk_tree_view_append_column (GTK_TREE_VIEW (tree
), column
);
2061 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW (tree
), FALSE
);
2063 scroll_win
= gtk_scrolled_window_new (NULL
, NULL
);
2064 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win
),
2065 GTK_POLICY_AUTOMATIC
,GTK_POLICY_AUTOMATIC
);
2066 gtk_container_add (GTK_CONTAINER (scroll_win
), tree
);
2068 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), scroll_win
,TRUE
, TRUE
,0);
2070 gtk_widget_show(scroll_win
);
2071 gtk_widget_show(tree
);
2073 nb_trace
= lttv_traceset_selector_trace_number(s
);
2074 for(i
=0;i
<nb_trace
;i
++){
2075 trace
= lttv_traceset_selector_trace_get(s
, i
);
2076 name
= lttv_trace_selector_get_name(trace
);
2077 gtk_tree_store_append (store
, &iter
, NULL
);
2078 checked
= lttv_trace_selector_get_selected(trace
);
2079 gtk_tree_store_set (store
, &iter
,
2080 CHECKBOX_COLUMN
,checked
,
2084 gtk_tree_store_append (store
, &child_iter
, &iter
);
2085 gtk_tree_store_set (store
, &child_iter
,
2086 CHECKBOX_COLUMN
, checked
,
2087 NAME_COLUMN
,"eventtype",
2090 nb_eventtype
= lttv_trace_selector_eventtype_number(trace
);
2091 for(j
=0;j
<nb_eventtype
;j
++){
2092 eventtype
= lttv_trace_selector_eventtype_get(trace
,j
);
2093 name
= lttv_eventtype_selector_get_name(eventtype
);
2094 checked
= lttv_eventtype_selector_get_selected(eventtype
);
2095 gtk_tree_store_append (store
, &child_iter1
, &child_iter
);
2096 gtk_tree_store_set (store
, &child_iter1
,
2097 CHECKBOX_COLUMN
, checked
,
2102 nb_tracefile
= lttv_trace_selector_tracefile_number(trace
);
2103 for(j
=0;j
<nb_tracefile
;j
++){
2104 tracefile
= lttv_trace_selector_tracefile_get(trace
, j
);
2105 name
= lttv_tracefile_selector_get_name(tracefile
);
2106 gtk_tree_store_append (store
, &child_iter
, &iter
);
2107 checked
= lttv_tracefile_selector_get_selected(tracefile
);
2108 gtk_tree_store_set (store
, &child_iter
,
2109 CHECKBOX_COLUMN
, checked
,
2113 gtk_tree_store_append (store
, &child_iter1
, &child_iter
);
2114 gtk_tree_store_set (store
, &child_iter1
,
2115 CHECKBOX_COLUMN
, checked
,
2116 NAME_COLUMN
,"eventtype",
2119 for(k
=0;k
<nb_eventtype
;k
++){
2120 eventtype
= lttv_tracefile_selector_eventtype_get(tracefile
,k
);
2121 name
= lttv_eventtype_selector_get_name(eventtype
);
2122 checked
= lttv_eventtype_selector_get_selected(eventtype
);
2123 gtk_tree_store_append (store
, &child_iter2
, &child_iter1
);
2124 gtk_tree_store_set (store
, &child_iter2
,
2125 CHECKBOX_COLUMN
, checked
,
2132 id
= gtk_dialog_run(GTK_DIALOG(dialogue
));
2134 case GTK_RESPONSE_ACCEPT
:
2135 case GTK_RESPONSE_OK
:
2136 update_filter(s
, store
);
2137 gtk_widget_destroy(dialogue
);
2139 case GTK_RESPONSE_REJECT
:
2140 case GTK_RESPONSE_CANCEL
:
2142 gtk_widget_destroy(dialogue
);
2149 /* Select a trace which will be removed from traceset
2152 char * get_remove_trace(char ** all_trace_name
, int nb_trace
)
2154 return get_selection(all_trace_name
, nb_trace
,
2155 "Select a trace", "Trace pathname");
2159 /* Select a module which will be unloaded
2162 char * get_unload_module(char ** loaded_module_name
, int nb_module
)
2164 return get_selection(loaded_module_name
, nb_module
,
2165 "Select an unload module", "Module pathname");
2169 /* Display a dialogue which shows all selectable items, let user to
2170 * select one of them
2173 char * get_selection(char ** loaded_module_name
, int nb_module
,
2174 char *title
, char * column_title
)
2176 GtkWidget
* dialogue
;
2177 GtkWidget
* scroll_win
;
2179 GtkListStore
* store
;
2180 GtkTreeViewColumn
* column
;
2181 GtkCellRenderer
* renderer
;
2182 GtkTreeSelection
* select
;
2185 char * unload_module_name
= NULL
;
2187 dialogue
= gtk_dialog_new_with_buttons(title
,
2190 GTK_STOCK_OK
,GTK_RESPONSE_ACCEPT
,
2191 GTK_STOCK_CANCEL
,GTK_RESPONSE_REJECT
,
2193 gtk_window_set_default_size((GtkWindow
*)dialogue
, 500, 200);
2195 scroll_win
= gtk_scrolled_window_new (NULL
, NULL
);
2196 gtk_widget_show ( scroll_win
);
2197 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win
),
2198 GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
2200 store
= gtk_list_store_new (N_COLUMNS
,G_TYPE_STRING
);
2201 tree
= gtk_tree_view_new_with_model(GTK_TREE_MODEL (store
));
2202 gtk_widget_show ( tree
);
2203 g_object_unref (G_OBJECT (store
));
2205 renderer
= gtk_cell_renderer_text_new ();
2206 column
= gtk_tree_view_column_new_with_attributes (column_title
,
2208 "text", MODULE_COLUMN
,
2210 gtk_tree_view_column_set_alignment (column
, 0.5);
2211 gtk_tree_view_column_set_fixed_width (column
, 150);
2212 gtk_tree_view_append_column (GTK_TREE_VIEW (tree
), column
);
2214 select
= gtk_tree_view_get_selection (GTK_TREE_VIEW (tree
));
2215 gtk_tree_selection_set_mode (select
, GTK_SELECTION_SINGLE
);
2217 gtk_container_add (GTK_CONTAINER (scroll_win
), tree
);
2219 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), scroll_win
,TRUE
, TRUE
,0);
2221 for(i
=0;i
<nb_module
;i
++){
2222 gtk_list_store_append (store
, &iter
);
2223 gtk_list_store_set (store
, &iter
, MODULE_COLUMN
,loaded_module_name
[i
],-1);
2226 id
= gtk_dialog_run(GTK_DIALOG(dialogue
));
2228 case GTK_RESPONSE_ACCEPT
:
2229 case GTK_RESPONSE_OK
:
2230 if (gtk_tree_selection_get_selected (select
, (GtkTreeModel
**)&store
, &iter
)){
2231 gtk_tree_model_get ((GtkTreeModel
*)store
, &iter
, MODULE_COLUMN
, &unload_module_name
, -1);
2233 case GTK_RESPONSE_REJECT
:
2234 case GTK_RESPONSE_CANCEL
:
2236 gtk_widget_destroy(dialogue
);
2240 return unload_module_name
;
2244 /* Insert all menu entry and tool buttons into this main window
2249 void add_all_menu_toolbar_constructors(MainWindow
* mw
, gpointer user_data
)
2253 lttvwindow_viewer_constructor constructor
;
2254 LttvMenus
* global_menu
, * instance_menu
;
2255 LttvToolbars
* global_toolbar
, * instance_toolbar
;
2256 LttvMenuClosure
*menu_item
;
2257 LttvToolbarClosure
*toolbar_item
;
2258 LttvAttributeValue value
;
2259 LttvIAttribute
*global_attributes
= LTTV_IATTRIBUTE(lttv_global_attributes());
2260 LttvIAttribute
*attributes
= mw
->attributes
;
2261 GtkWidget
* tool_menu_title_menu
, *new_widget
, *pixmap
;
2263 g_assert(lttv_iattribute_find_by_path(global_attributes
,
2264 "viewers/menu", LTTV_POINTER
, &value
));
2265 if(*(value
.v_pointer
) == NULL
)
2266 *(value
.v_pointer
) = lttv_menus_new();
2267 global_menu
= (LttvMenus
*)*(value
.v_pointer
);
2269 g_assert(lttv_iattribute_find_by_path(attributes
,
2270 "viewers/menu", LTTV_POINTER
, &value
));
2271 if(*(value
.v_pointer
) == NULL
)
2272 *(value
.v_pointer
) = lttv_menus_new();
2273 instance_menu
= (LttvMenus
*)*(value
.v_pointer
);
2277 g_assert(lttv_iattribute_find_by_path(global_attributes
,
2278 "viewers/toolbar", LTTV_POINTER
, &value
));
2279 if(*(value
.v_pointer
) == NULL
)
2280 *(value
.v_pointer
) = lttv_toolbars_new();
2281 global_toolbar
= (LttvToolbars
*)*(value
.v_pointer
);
2283 g_assert(lttv_iattribute_find_by_path(attributes
,
2284 "viewers/toolbar", LTTV_POINTER
, &value
));
2285 if(*(value
.v_pointer
) == NULL
)
2286 *(value
.v_pointer
) = lttv_toolbars_new();
2287 instance_toolbar
= (LttvToolbars
*)*(value
.v_pointer
);
2289 /* Add missing menu entries to window instance */
2290 for(i
=0;i
<global_menu
->len
;i
++) {
2291 menu_item
= &g_array_index(global_menu
, LttvMenuClosure
, i
);
2293 //add menu_item to window instance;
2294 constructor
= menu_item
->con
;
2295 tool_menu_title_menu
= lookup_widget(mw
->mwindow
,"ToolMenuTitle_menu");
2297 gtk_menu_item_new_with_mnemonic (menu_item
->menu_text
);
2298 gtk_container_add (GTK_CONTAINER (tool_menu_title_menu
),
2300 g_signal_connect ((gpointer
) new_widget
, "activate",
2301 G_CALLBACK (insert_viewer_wrap
),
2303 gtk_widget_show (new_widget
);
2304 lttv_menus_add(instance_menu
, menu_item
->con
,
2305 menu_item
->menu_path
,
2306 menu_item
->menu_text
,
2311 /* Add missing toolbar entries to window instance */
2312 for(i
=0;i
<global_toolbar
->len
;i
++) {
2313 toolbar_item
= &g_array_index(global_toolbar
, LttvToolbarClosure
, i
);
2315 //add toolbar_item to window instance;
2316 constructor
= toolbar_item
->con
;
2317 tool_menu_title_menu
= lookup_widget(mw
->mwindow
,"MToolbar1");
2318 pixbuf
= gdk_pixbuf_new_from_xpm_data((const char**)toolbar_item
->pixmap
);
2319 pixmap
= gtk_image_new_from_pixbuf(pixbuf
);
2321 gtk_toolbar_append_element (GTK_TOOLBAR (tool_menu_title_menu
),
2322 GTK_TOOLBAR_CHILD_BUTTON
,
2325 toolbar_item
->tooltip
, NULL
,
2326 pixmap
, NULL
, NULL
);
2327 gtk_label_set_use_underline(
2328 GTK_LABEL (((GtkToolbarChild
*) (
2329 g_list_last (GTK_TOOLBAR
2330 (tool_menu_title_menu
)->children
)->data
))->label
),
2332 gtk_container_set_border_width (GTK_CONTAINER (new_widget
), 1);
2333 g_signal_connect ((gpointer
) new_widget
,
2335 G_CALLBACK (insert_viewer_wrap
),
2337 gtk_widget_show (new_widget
);
2339 lttv_toolbars_add(instance_toolbar
, toolbar_item
->con
,
2340 toolbar_item
->tooltip
,
2341 toolbar_item
->pixmap
,
2349 /* Create a main window
2352 void construct_main_window(MainWindow
* parent
)
2354 g_debug("construct_main_window()");
2355 GtkWidget
* new_window
; /* New generated main window */
2356 MainWindow
* new_m_window
;/* New main window structure */
2357 GtkNotebook
* notebook
;
2358 LttvIAttribute
*attributes
=
2359 LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
));
2360 LttvAttributeValue value
;
2362 new_m_window
= g_new(MainWindow
, 1);
2364 // Add the object's information to the module's array
2365 g_main_window_list
= g_slist_append(g_main_window_list
, new_m_window
);
2368 new_window
= create_MWindow();
2369 gtk_widget_show (new_window
);
2371 new_m_window
->mwindow
= new_window
;
2372 new_m_window
->tab
= NULL
;
2373 new_m_window
->current_tab
= NULL
;
2374 new_m_window
->attributes
= attributes
;
2376 g_assert(lttv_iattribute_find_by_path(attributes
,
2377 "viewers/menu", LTTV_POINTER
, &value
));
2378 *(value
.v_pointer
) = lttv_menus_new();
2380 g_assert(lttv_iattribute_find_by_path(attributes
,
2381 "viewers/toolbar", LTTV_POINTER
, &value
));
2382 *(value
.v_pointer
) = lttv_toolbars_new();
2384 add_all_menu_toolbar_constructors(new_m_window
, NULL
);
2386 g_object_set_data(G_OBJECT(new_window
), "mainWindow", (gpointer
)new_m_window
);
2387 //create a default tab
2388 notebook
= (GtkNotebook
*)lookup_widget(new_m_window
->mwindow
, "MNotebook");
2389 if(notebook
== NULL
){
2390 g_printf("Notebook does not exist\n");
2393 //for now there is no name field in LttvTraceset structure
2394 //Use "Traceset" as the label for the default tab
2395 create_tab(parent
, new_m_window
, notebook
, "Traceset");
2397 g_object_set_data_full(
2398 G_OBJECT(new_m_window
->mwindow
),
2404 g_printf("There are now : %d windows\n",g_slist_length(g_main_window_list
));
2408 /* Free the memory occupied by a tab structure
2412 void tab_destructor(Tab
* tab_instance
)
2414 int i
, nb
, ref_count
;
2417 if(tab_instance
->attributes
)
2418 g_object_unref(tab_instance
->attributes
);
2420 if(tab_instance
->interrupted_state
)
2421 g_object_unref(tab_instance
->interrupted_state
);
2424 if(tab_instance
->mw
->tab
== tab_instance
){
2425 tab_instance
->mw
->tab
= tab_instance
->next
;
2427 Tab
* tmp1
, *tmp
= tab_instance
->mw
->tab
;
2428 while(tmp
!= tab_instance
){
2432 tmp1
->next
= tab_instance
->next
;
2435 if(tab_instance
->traceset_info
->traceset_context
!= NULL
){
2436 //remove state update hooks
2437 lttv_state_remove_event_hooks(
2438 (LttvTracesetState
*)tab_instance
->traceset_info
->
2440 lttv_context_fini(LTTV_TRACESET_CONTEXT(tab_instance
->traceset_info
->
2442 g_object_unref(tab_instance
->traceset_info
->traceset_context
);
2444 if(tab_instance
->traceset_info
->traceset
!= NULL
) {
2445 nb
= lttv_traceset_number(tab_instance
->traceset_info
->traceset
);
2446 for(i
= 0 ; i
< nb
; i
++) {
2447 trace
= lttv_traceset_get(tab_instance
->traceset_info
->traceset
, i
);
2448 ref_count
= lttv_trace_get_ref_number(trace
);
2450 ltt_trace_close(lttv_trace(trace
));
2451 lttv_trace_destroy(trace
);
2453 // lttv_trace_destroy(trace);
2456 lttv_traceset_destroy(tab_instance
->traceset_info
->traceset
);
2457 /* Remove the idle events requests processing function of the tab */
2458 g_idle_remove_by_data(tab_instance
);
2460 g_slist_free(tab_instance
->events_requests
);
2461 g_free(tab_instance
->traceset_info
);
2462 g_free(tab_instance
);
2466 /* Create a tab and insert it into the current main window
2469 void * create_tab(MainWindow
* parent
, MainWindow
* current_window
,
2470 GtkNotebook
* notebook
, char * label
)
2474 MainWindow
* mw_data
= current_window
;
2477 //create a new tab data structure
2478 tmp_tab
= mw_data
->tab
;
2479 while(tmp_tab
&& tmp_tab
->next
) tmp_tab
= tmp_tab
->next
;
2481 mw_data
->current_tab
= NULL
;
2482 tmp_tab
= g_new(Tab
,1);
2483 mw_data
->tab
= tmp_tab
;
2485 tmp_tab
->next
= g_new(Tab
,1);
2486 tmp_tab
= tmp_tab
->next
;
2489 //construct and initialize the traceset_info
2490 tmp_tab
->traceset_info
= g_new(TracesetInfo
,1);
2492 if(parent
->current_tab
){
2493 tmp_tab
->traceset_info
->traceset
=
2494 lttv_traceset_new();
2495 //FIXME lttv_traceset_copy(parent->current_tab->traceset_info->traceset);
2497 tmp_tab
->traceset_info
->traceset
= lttv_traceset_new();
2500 }else{ /* Initial window */
2501 if(mw_data
->current_tab
){
2502 tmp_tab
->traceset_info
->traceset
=
2503 lttv_traceset_new();
2504 //FIXME lttv_traceset_copy(mw_data->current_tab->traceset_info->traceset);
2506 tmp_tab
->traceset_info
->traceset
= lttv_traceset_new();
2507 /* Add the command line trace */
2508 if(g_init_trace
!= NULL
){
2509 lttv_traceset_add(tmp_tab
->traceset_info
->traceset
, g_init_trace
);
2514 //FIXME copy not implemented in lower level
2515 tmp_tab
->traceset_info
->traceset_context
=
2516 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
2517 g_assert(tmp_tab
->traceset_info
->traceset_context
!= NULL
);
2519 LTTV_TRACESET_CONTEXT(tmp_tab
->traceset_info
->traceset_context
),
2520 tmp_tab
->traceset_info
->traceset
);
2521 //add state update hooks
2522 lttv_state_add_event_hooks(
2523 (LttvTracesetState
*)tmp_tab
->traceset_info
->traceset_context
);
2525 //determine the current_time and time_window of the tab
2526 if(mw_data
->current_tab
){
2527 // Will have to read directly at the main window level, as we want
2528 // to be able to modify a traceset on the fly.
2529 tmp_tab
->time_window
= mw_data
->current_tab
->time_window
;
2530 tmp_tab
->current_time
= mw_data
->current_tab
->current_time
;
2532 // Will have to read directly at the main window level, as we want
2533 // to be able to modify a traceset on the fly.
2534 // get_traceset_time_span(mw_data,&tmp_tab->traceStartTime, &tmp_tab->traceEndTime);
2535 tmp_tab
->time_window
.start_time
=
2536 LTTV_TRACESET_CONTEXT(tmp_tab
->traceset_info
->traceset_context
)->time_span
.start_time
;
2537 if(DEFAULT_TIME_WIDTH_S
<
2538 LTTV_TRACESET_CONTEXT(tmp_tab
->traceset_info
->traceset_context
)->time_span
.end_time
.tv_sec
)
2539 tmp_time
.tv_sec
= DEFAULT_TIME_WIDTH_S
;
2542 LTTV_TRACESET_CONTEXT(tmp_tab
->traceset_info
->traceset_context
)->time_span
.end_time
.tv_sec
;
2543 tmp_time
.tv_nsec
= 0;
2544 tmp_tab
->time_window
.time_width
= tmp_time
;
2545 tmp_tab
->current_time
.tv_sec
=
2546 LTTV_TRACESET_CONTEXT(tmp_tab
->traceset_info
->traceset_context
)->time_span
.start_time
.tv_sec
;
2547 tmp_tab
->current_time
.tv_nsec
=
2548 LTTV_TRACESET_CONTEXT(tmp_tab
->traceset_info
->traceset_context
)->time_span
.start_time
.tv_nsec
;
2550 /* Become the current tab */
2551 mw_data
->current_tab
= tmp_tab
;
2553 tmp_tab
->attributes
= LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
));
2554 tmp_tab
->interrupted_state
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
2555 tmp_tab
->multi_vpaned
= (GtkMultiVPaned
*)gtk_multi_vpaned_new();
2556 tmp_tab
->multi_vpaned
->tab
= mw_data
->current_tab
;
2557 gtk_widget_show((GtkWidget
*)tmp_tab
->multi_vpaned
);
2558 tmp_tab
->next
= NULL
;
2559 tmp_tab
->mw
= mw_data
;
2561 tmp_tab
->label
= gtk_label_new (label
);
2562 gtk_widget_show (tmp_tab
->label
);
2564 /* Start with empty events requests list */
2565 tmp_tab
->events_requests
= NULL
;
2566 tmp_tab
->events_request_pending
= FALSE
;
2568 g_object_set_data_full(
2569 G_OBJECT(tmp_tab
->multi_vpaned
),
2572 (GDestroyNotify
)tab_destructor
);
2574 //insert tab into notebook
2575 gtk_notebook_append_page(notebook
, (GtkWidget
*)tmp_tab
->multi_vpaned
, tmp_tab
->label
);
2576 list
= gtk_container_get_children(GTK_CONTAINER(notebook
));
2577 gtk_notebook_set_current_page(notebook
,g_list_length(list
)-1);
2578 // always show : not if(g_list_length(list)>1)
2579 gtk_notebook_set_show_tabs(notebook
, TRUE
);
2584 * Function to show each viewer in the current tab.
2585 * It will be called by main window, call show on each registered viewer,
2586 * will call process traceset and then it will
2587 * @param main_win the main window the viewer belongs to.
2589 //FIXME Only one time request maximum for now!
2590 void show_viewer(MainWindow
*main_win
)
2592 LttvAttributeValue value
;
2595 LttvTracesetContext
* tsc
=
2596 (LttvTracesetContext
*)main_win
->current_tab
->
2597 traceset_info
->traceset_context
;
2599 g_assert(lttv_iattribute_find_by_path(main_win
->current_tab
->attributes
,
2600 "hooks/showviewer", LTTV_POINTER
, &value
));
2601 tmp
= (LttvHooks
*)*(value
.v_pointer
);
2604 g_warning("The viewer(s) did not add any show hook");
2609 // Call the show, where viewers add hooks to context and fill the
2610 // time and number of events requested it the time_requests GArray.
2611 lttv_hooks_call(tmp
, NULL
);
2617 * execute_events_requests
2619 * Idle function that executes the pending requests for a tab.
2621 * @return return value : TRUE : keep the idle function, FALSE : remove it.
2623 gboolean
execute_events_requests(Tab
*tab
)
2625 return ( lttvwindow_process_pending_requests(tab
) );