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,
23 #include <limits.h> // for PATH_MAX
28 #include "callbacks.h"
29 #include "interface.h"
31 #include <ltt/trace.h>
32 #include <ltt/facility.h>
34 #include <ltt/event.h>
35 #include <lttv/lttv.h>
36 #include <lttv/module.h>
37 #include <lttv/iattribute.h>
38 #include <lttv/stats.h>
39 #include <lttvwindow/mainwindow.h>
40 #include <lttvwindow/mainwindow-private.h>
41 #include <lttvwindow/menu.h>
42 #include <lttvwindow/toolbar.h>
43 #include <lttvwindow/lttvwindow.h>
44 #include <lttvwindow/lttvwindowtraces.h>
45 #include <lttvwindow/gtkdirsel.h>
46 #include <lttvwindow/lttvfilter.h>
49 #define DEFAULT_TIME_WIDTH_S 1
51 extern LttvTrace
*g_init_trace
;
54 /** Array containing instanced objects. */
55 extern GSList
* g_main_window_list
;
57 /** MD : keep old directory. */
58 static char remember_plugins_dir
[PATH_MAX
] = "";
59 static char remember_trace_dir
[PATH_MAX
] = "";
62 MainWindow
* get_window_data_struct(GtkWidget
* widget
);
63 char * get_unload_module(char ** loaded_module_name
, int nb_module
);
64 char * get_remove_trace(char ** all_trace_name
, int nb_trace
);
65 char * get_selection(char ** all_name
, int nb
, char *title
, char * column_title
);
66 gboolean
get_filter_selection(LttvTracesetSelector
*s
, char *title
, char * column_title
);
67 Tab
* create_tab(MainWindow
* mw
, Tab
*copy_tab
,
68 GtkNotebook
* notebook
, char * label
);
70 static void insert_viewer(GtkWidget
* widget
, lttvwindow_viewer_constructor constructor
);
71 void update_filter(LttvTracesetSelector
*s
, GtkTreeStore
*store
);
73 void checkbox_changed(GtkTreeView
*treeview
,
75 GtkTreeViewColumn
*arg2
,
77 void remove_trace_from_traceset_selector(GtkMultiVPaned
* paned
, unsigned i
);
78 void add_trace_into_traceset_selector(GtkMultiVPaned
* paned
, LttTrace
* trace
);
79 Tab
*create_new_tab(GtkWidget
* widget
, gpointer user_data
);
81 LttvTracesetSelector
* construct_traceset_selector(LttvTraceset
* traceset
);
83 static gboolean
lttvwindow_process_pending_requests(Tab
*tab
);
97 /* Construct a selector(filter), which will be associated with a viewer,
98 * and provides an interface for user to select interested events and traces
101 LttvTracesetSelector
* construct_traceset_selector(LttvTraceset
* traceset
)
103 LttvTracesetSelector
* s
;
104 LttvTraceSelector
* trace
;
105 LttvTracefileSelector
* tracefile
;
106 LttvEventtypeSelector
* eventtype
;
108 int nb_trace
, nb_tracefile
, nb_control
, nb_per_cpu
, nb_facility
, nb_event
;
115 s
= lttv_traceset_selector_new(lttv_traceset_name(traceset
));
116 nb_trace
= lttv_traceset_number(traceset
);
117 for(i
=0;i
<nb_trace
;i
++){
118 trace_v
= lttv_traceset_get(traceset
, i
);
119 t
= lttv_trace(trace_v
);
120 trace
= lttv_trace_selector_new(t
);
121 lttv_traceset_selector_trace_add(s
, trace
);
123 nb_facility
= ltt_trace_facility_number(t
);
124 for(k
=0;k
<nb_facility
;k
++){
125 fac
= ltt_trace_facility_get(t
,k
);
126 nb_event
= (int) ltt_facility_eventtype_number(fac
);
127 for(m
=0;m
<nb_event
;m
++){
128 et
= ltt_facility_eventtype_get(fac
,m
);
129 eventtype
= lttv_eventtype_selector_new(et
);
130 lttv_trace_selector_eventtype_add(trace
, eventtype
);
134 nb_control
= ltt_trace_control_tracefile_number(t
);
135 nb_per_cpu
= ltt_trace_per_cpu_tracefile_number(t
);
136 nb_tracefile
= nb_control
+ nb_per_cpu
;
138 for(j
= 0 ; j
< nb_tracefile
; j
++) {
140 tf
= ltt_trace_control_tracefile_get(t
, j
);
142 tf
= ltt_trace_per_cpu_tracefile_get(t
, j
- nb_control
);
143 tracefile
= lttv_tracefile_selector_new(tf
);
144 lttv_trace_selector_tracefile_add(trace
, tracefile
);
145 lttv_eventtype_selector_copy(trace
, tracefile
);
152 /* insert_viewer function constructs an instance of a viewer first,
153 * then inserts the widget of the instance into the container of the
158 insert_viewer_wrap(GtkWidget
*menuitem
, gpointer user_data
)
162 insert_viewer((GtkWidget
*)menuitem
, (lttvwindow_viewer_constructor
)user_data
);
163 // selected_hook(&val);
167 /* internal functions */
168 void insert_viewer(GtkWidget
* widget
, lttvwindow_viewer_constructor constructor
)
170 GtkMultiVPaned
* multi_vpaned
;
171 MainWindow
* mw_data
= get_window_data_struct(widget
);
172 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
174 LttvTracesetSelector
* s
;
175 TimeInterval
* time_interval
;
176 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
177 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
181 tab
= create_new_tab(widget
, NULL
);
183 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
186 multi_vpaned
= tab
->multi_vpaned
;
188 s
= construct_traceset_selector(tab
->traceset_info
->traceset
);
189 viewer
= (GtkWidget
*)constructor(tab
, s
, "Traceset_Selector");
192 gtk_multi_vpaned_widget_add(multi_vpaned
, viewer
);
193 // We unref here, because it is now referenced by the multi_vpaned!
194 g_object_unref(G_OBJECT(viewer
));
196 // The viewer will show itself when it receives a show notify
197 // So we call the show notify hooks here. It will
198 // typically add hooks for reading, we call process trace, and the
199 // end of reading hook will call gtk_widget_show and unregister the
201 // Note that show notify gets the time_requested through the call_data.
202 //show_viewer(mw_data);
203 // in expose now call_pending_read_hooks(mw_data);
208 /* get_label function is used to get user input, it displays an input
209 * box, which allows user to input a string
212 void get_label_string (GtkWidget
* text
, gchar
* label
)
214 GtkEntry
* entry
= (GtkEntry
*)text
;
215 if(strlen(gtk_entry_get_text(entry
))!=0)
216 strcpy(label
,gtk_entry_get_text(entry
));
219 gboolean
get_label(MainWindow
* mw
, gchar
* str
, gchar
* dialogue_title
, gchar
* label_str
)
221 GtkWidget
* dialogue
;
226 dialogue
= gtk_dialog_new_with_buttons(dialogue_title
,NULL
,
228 GTK_STOCK_OK
,GTK_RESPONSE_ACCEPT
,
229 GTK_STOCK_CANCEL
,GTK_RESPONSE_REJECT
,
232 label
= gtk_label_new(label_str
);
233 gtk_widget_show(label
);
235 text
= gtk_entry_new();
236 gtk_widget_show(text
);
238 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), label
,TRUE
, TRUE
,0);
239 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), text
,FALSE
, FALSE
,0);
241 id
= gtk_dialog_run(GTK_DIALOG(dialogue
));
243 case GTK_RESPONSE_ACCEPT
:
244 get_label_string(text
,str
);
245 gtk_widget_destroy(dialogue
);
247 case GTK_RESPONSE_REJECT
:
249 gtk_widget_destroy(dialogue
);
256 /* get_window_data_struct function is actually a lookup function,
257 * given a widget which is in the tree of the main window, it will
258 * return the MainWindow data structure associated with main window
261 MainWindow
* get_window_data_struct(GtkWidget
* widget
)
264 MainWindow
* mw_data
;
266 mw
= lookup_widget(widget
, "MWindow");
268 g_printf("Main window does not exist\n");
272 mw_data
= (MainWindow
*) g_object_get_data(G_OBJECT(mw
),"main_window_data");
274 g_printf("Main window data does not exist\n");
281 /* create_new_window function, just constructs a new main window
284 void create_new_window(GtkWidget
* widget
, gpointer user_data
, gboolean clone
)
286 MainWindow
* parent
= get_window_data_struct(widget
);
289 g_printf("Clone : use the same traceset\n");
290 construct_main_window(parent
);
292 g_printf("Empty : traceset is set to NULL\n");
293 construct_main_window(NULL
);
298 /* move_*_viewer functions move the selected view up/down in
302 void move_up_viewer(GtkWidget
* widget
, gpointer user_data
)
304 MainWindow
* mw
= get_window_data_struct(widget
);
305 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
307 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
308 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
315 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
318 gtk_multi_vpaned_widget_move_up(tab
->multi_vpaned
);
321 void move_down_viewer(GtkWidget
* widget
, gpointer user_data
)
323 MainWindow
* mw
= get_window_data_struct(widget
);
324 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
326 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
327 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
333 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
336 gtk_multi_vpaned_widget_move_down(tab
->multi_vpaned
);
340 /* delete_viewer deletes the selected viewer in the current tab
343 void delete_viewer(GtkWidget
* widget
, gpointer user_data
)
345 MainWindow
* mw
= get_window_data_struct(widget
);
346 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
348 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
349 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
355 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
358 gtk_multi_vpaned_widget_delete(tab
->multi_vpaned
);
362 /* open_traceset will open a traceset saved in a file
363 * Right now, it is not finished yet, (not working)
367 void open_traceset(GtkWidget
* widget
, gpointer user_data
)
371 LttvTraceset
* traceset
;
372 MainWindow
* mw_data
= get_window_data_struct(widget
);
373 GtkFileSelection
* file_selector
=
374 (GtkFileSelection
*)gtk_file_selection_new("Select a traceset");
376 gtk_file_selection_hide_fileop_buttons(file_selector
);
378 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
380 case GTK_RESPONSE_ACCEPT
:
381 case GTK_RESPONSE_OK
:
382 dir
= gtk_file_selection_get_selections (file_selector
);
383 traceset
= lttv_traceset_load(dir
[0]);
384 g_printf("Open a trace set %s\n", dir
[0]);
387 case GTK_RESPONSE_REJECT
:
388 case GTK_RESPONSE_CANCEL
:
390 gtk_widget_destroy((GtkWidget
*)file_selector
);
397 /* lttvwindow_process_pending_requests
399 * This internal function gets called by g_idle, taking care of the pending
400 * requests. It is responsible for concatenation of time intervals and position
401 * requests. It does it with the following algorithm organizing process traceset
402 * calls. Here is the detailed description of the way it works :
404 * - Events Requests Servicing Algorithm
406 * Data structures necessary :
408 * List of requests added to context : list_in
409 * List of requests not added to context : list_out
414 * list_out : many events requests
416 * FIXME : insert rest of algorithm here
421 gboolean
lttvwindow_process_pending_requests(Tab
*tab
)
423 unsigned max_nb_events
;
427 LttvTracesetContext
*tsc
;
428 LttvTracefileContext
*tfc
;
429 GSList
*events_requests
= tab
->events_requests
;
430 GSList
*list_out
= events_requests
;
431 GSList
*list_in
= NULL
;
435 LttvTracesetContextPosition
*end_position
;
441 /* There is no events requests pending : we should never have been called! */
442 g_assert(g_slist_length(events_requests
) != 0);
444 tsc
= LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
446 //set the cursor to be X shape, indicating that the computer is busy in doing its job
447 new = gdk_cursor_new(GDK_X_CURSOR
);
448 widget
= lookup_widget(tab
->mw
->mwindow
, "MToolbar1");
449 win
= gtk_widget_get_parent_window(widget
);
450 gdk_window_set_cursor(win
, new);
451 gdk_cursor_unref(new);
452 gdk_window_stick(win
);
453 gdk_window_unstick(win
);
455 g_debug("SIZE events req len : %d", g_slist_length(events_requests
));
457 /* Events processing algorithm implementation */
458 /* A. Servicing loop */
459 while( (g_slist_length(list_in
) != 0 || g_slist_length(list_out
) != 0)
460 && !gtk_events_pending() ) {
462 /* 1. If list_in is empty (need a seek) */
463 if( g_slist_length(list_in
) == 0 ) {
465 /* list in is empty, need a seek */
467 /* 1.1 Add requests to list_in */
468 GSList
*ltime
= NULL
;
472 /* 1.1.1 Find all time requests with the lowest start time in list_out
475 if(g_slist_length(list_out
) > 0)
476 ltime
= g_slist_append(ltime
, g_slist_nth_data(list_out
, 0));
477 for(iter
=g_slist_nth(list_out
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
478 /* Find all time requests with the lowest start time in list_out */
479 guint index_ltime
= g_array_index(ltime
, guint
, 0);
480 EventsRequest
*event_request_ltime
= (EventsRequest
*)g_slist_nth_data(ltime
, 0);
481 EventsRequest
*event_request_list_out
= (EventsRequest
*)iter
->data
;
484 comp
= ltt_time_compare(event_request_ltime
->start_time
,
485 event_request_list_out
->start_time
);
487 ltime
= g_slist_append(ltime
, event_request_list_out
);
489 /* Remove all elements from ltime, and add current */
491 ltime
= g_slist_delete_link(ltime
, g_slist_nth(ltime
, 0));
492 ltime
= g_slist_append(ltime
, event_request_list_out
);
496 /* 1.1.2 Find all position requests with the lowest position in list_out
499 if(g_slist_length(list_out
) > 0)
500 lpos
= g_slist_append(lpos
, g_slist_nth_data(list_out
, 0));
501 for(iter
=g_slist_nth(list_out
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
502 /* Find all position requests with the lowest position in list_out */
503 guint index_lpos
= g_array_index(lpos
, guint
, 0);
504 EventsRequest
*event_request_lpos
= (EventsRequest
*)g_slist_nth_data(lpos
, 0);
505 EventsRequest
*event_request_list_out
= (EventsRequest
*)iter
->data
;
508 if(event_request_lpos
->start_position
!= NULL
509 && event_request_list_out
->start_position
!= NULL
)
511 comp
= lttv_traceset_context_pos_pos_compare
512 (event_request_lpos
->start_position
,
513 event_request_list_out
->start_position
);
518 lpos
= g_slist_append(lpos
, event_request_list_out
);
520 /* Remove all elements from lpos, and add current */
522 lpos
= g_slist_delete_link(lpos
, g_slist_nth(lpos
, 0));
523 lpos
= g_slist_append(lpos
, event_request_list_out
);
527 /* 1.1.3 If lpos.start time < ltime */
529 EventsRequest
*event_request_lpos
= (EventsRequest
*)g_slist_nth_data(lpos
, 0);
530 EventsRequest
*event_request_ltime
= (EventsRequest
*)g_slist_nth_data(ltime
, 0);
531 LttTime lpos_start_time
;
533 if(event_request_lpos
!= NULL
534 && event_request_lpos
->start_position
!= NULL
) {
536 lpos_start_time
= lttv_traceset_context_position_get_time(
537 event_request_lpos
->start_position
);
538 if(ltt_time_compare(lpos_start_time
,
539 event_request_ltime
->start_time
)<0) {
540 /* Add lpos to list_in, remove them from list_out */
542 for(iter
=lpos
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
544 EventsRequest
*event_request_lpos
=
545 (EventsRequest
*)iter
->data
;
547 g_slist_append(list_in
, event_request_lpos
);
548 /* Remove from list_out */
549 g_slist_remove(list_out
, event_request_lpos
);
553 /* 1.1.4 (lpos.start time >= ltime) */
554 /* Add ltime to list_in, remove them from list_out */
556 for(iter
=ltime
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
558 EventsRequest
*event_request_ltime
=
559 (EventsRequest
*)iter
->data
;
561 g_slist_append(list_in
, event_request_ltime
);
562 /* Remove from list_out */
563 g_slist_remove(list_out
, event_request_ltime
);
573 tfc
= lttv_traceset_context_get_current_tfc(tsc
);
574 g_assert(g_slist_length(list_in
)>0);
575 EventsRequest
*events_request
= g_slist_nth_data(list_in
, 0);
577 /* 1.2.1 If first request in list_in is a time request */
578 if(events_request
->start_position
== NULL
) {
579 /* - If first req in list_in start time != current time */
580 if(tfc
!= NULL
&& ltt_time_compare(events_request
->start_time
,
581 tfc
->timestamp
) != 0)
582 /* - Seek to that time */
583 lttv_process_traceset_seek_time(tsc
, events_request
->start_time
);
585 /* Else, the first request in list_in is a position request */
586 /* If first req in list_in pos != current pos */
587 g_assert(events_request
->start_position
!= NULL
);
588 if(lttv_traceset_context_ctx_pos_compare(tsc
,
589 events_request
->start_position
) != 0) {
590 /* 1.2.2.1 Seek to that position */
591 lttv_process_traceset_seek_position(tsc
, events_request
->start_position
);
596 /* 1.3 Add hooks and call before request for all list_in members */
600 for(iter
=list_in
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
601 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
602 /* 1.3.1 If !servicing */
603 if(events_request
->servicing
== FALSE
) {
604 /* - begin request hooks called
607 lttv_hooks_call(events_request
->before_request
, NULL
);
608 events_request
->servicing
= TRUE
;
610 /* 1.3.2 call before chunk
611 * 1.3.3 events hooks added
613 lttv_process_traceset_begin(tsc
, events_request
->before_chunk_traceset
,
614 events_request
->before_chunk_trace
,
615 events_request
->before_chunk_tracefile
,
616 events_request
->event
,
617 events_request
->event_by_id
);
621 /* 2. Else, list_in is not empty, we continue a read */
623 tfc
= lttv_traceset_context_get_current_tfc(tsc
);
625 /* 2.1 For each req of list_out */
626 for(iter
=list_out
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
627 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
629 /* if req.start time == current context time
630 * or req.start position == current position*/
631 if( ltt_time_compare(events_request
->start_time
,
634 (events_request
->start_position
!= NULL
636 lttv_traceset_context_ctx_pos_compare(tsc
,
637 events_request
->start_position
) == 0)
639 /* - Add to list_in, remove from list_out */
640 g_slist_append(list_in
, events_request
);
641 g_slist_remove(list_out
, events_request
);
643 /* - If !servicing */
644 if(events_request
->servicing
== FALSE
) {
645 /* - begin request hooks called
648 lttv_hooks_call(events_request
->before_request
, NULL
);
649 events_request
->servicing
= TRUE
;
654 lttv_process_traceset_begin(tsc
, events_request
->before_chunk_traceset
,
655 events_request
->before_chunk_trace
,
656 events_request
->before_chunk_tracefile
,
657 events_request
->event
,
658 events_request
->event_by_id
);
663 /* 3. Find end criterions */
668 /* 3.1.1 Find lowest end time in list_in */
669 g_assert(g_slist_length(list_in
)>0);
670 end_time
= ((EventsRequest
*)g_slist_nth_data(list_in
,0))->end_time
;
672 for(iter
=g_slist_nth(list_in
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
673 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
675 if(ltt_time_compare(events_request
->end_time
,
677 end_time
= events_request
->end_time
;
680 /* 3.1.2 Find lowest start time in list_out */
681 for(iter
=list_out
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
682 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
684 if(ltt_time_compare(events_request
->start_time
,
686 end_time
= events_request
->start_time
;
691 /* 3.2 Number of events */
693 /* 3.2.1 Find lowest number of events in list_in */
696 end_nb_events
= ((EventsRequest
*)g_slist_nth_data(list_in
,0))->num_events
;
698 for(iter
=g_slist_nth(list_in
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
699 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
701 if(events_request
->num_events
< end_nb_events
)
702 end_nb_events
= events_request
->num_events
;
705 /* 3.2.2 Use min(CHUNK_NUM_EVENTS, min num events in list_in) as
708 end_nb_events
= MIN(CHUNK_NUM_EVENTS
, end_nb_events
);
712 /* 3.3 End position */
714 /* 3.3.1 Find lowest end position in list_in */
717 end_position
=((EventsRequest
*)g_slist_nth_data(list_in
,0))->end_position
;
719 for(iter
=g_slist_nth(list_in
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
720 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
722 if(events_request
->end_position
!= NULL
&& end_position
!= NULL
&&
723 lttv_traceset_context_pos_pos_compare(events_request
->end_position
,
725 end_position
= events_request
->end_position
;
730 /* 3.3.2 Find lowest start position in list_out */
733 for(iter
=list_out
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
734 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
736 if(events_request
->end_position
!= NULL
&& end_position
!= NULL
&&
737 lttv_traceset_context_pos_pos_compare(events_request
->end_position
,
739 end_position
= events_request
->end_position
;
744 /* 4. Call process traceset middle */
745 count
= lttv_process_traceset_middle(tsc
, end_time
, end_nb_events
, end_position
);
748 /* 5. After process traceset middle */
749 tfc
= lttv_traceset_context_get_current_tfc(tsc
);
751 /* - if current context time > traceset.end time */
752 if(tfc
== NULL
|| ltt_time_compare(tfc
->timestamp
,
753 tsc
->time_span
.end_time
) > 0) {
754 /* - For each req in list_in */
755 GSList
*iter
= list_in
;
757 while(iter
!= NULL
) {
759 gboolean remove
= FALSE
;
760 gboolean free_data
= FALSE
;
761 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
763 /* - Remove events hooks for req
764 * - Call end chunk for req
766 lttv_process_traceset_end(tsc
, events_request
->after_chunk_traceset
,
767 events_request
->after_chunk_trace
,
768 events_request
->after_chunk_tracefile
,
769 events_request
->event
,
770 events_request
->event_by_id
);
771 /* - Call end request for req */
772 lttv_hooks_call(events_request
->after_request
, NULL
);
774 /* - remove req from list_in */
775 /* Destroy the request */
782 GSList
*remove_iter
= iter
;
784 iter
= g_slist_next(iter
);
785 if(free_data
) g_free(remove_iter
->data
);
786 list_in
= g_slist_remove_link(list_in
, remove_iter
);
787 } else { // not remove
788 iter
= g_slist_next(iter
);
794 /* 5.1 For each req in list_in */
795 GSList
*iter
= list_in
;
797 while(iter
!= NULL
) {
799 gboolean remove
= FALSE
;
800 gboolean free_data
= FALSE
;
801 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
803 /* - Remove events hooks for req
804 * - Call end chunk for req
806 lttv_process_traceset_end(tsc
, events_request
->after_chunk_traceset
,
807 events_request
->after_chunk_trace
,
808 events_request
->after_chunk_tracefile
,
809 events_request
->event
,
810 events_request
->event_by_id
);
812 /* - req.num -= count */
813 g_assert(events_request
->num_events
>= count
);
814 events_request
->num_events
-= count
;
816 g_assert(tfc
!= NULL
);
819 * current context time > req.end time
821 * req.end pos == current pos
823 * req.stop_flag == TRUE
825 if( events_request
->num_events
== 0
827 events_request
->stop_flag
== TRUE
829 ltt_time_compare(tfc
->timestamp
,
830 events_request
->end_time
) > 0
832 (events_request
->start_position
!= NULL
834 lttv_traceset_context_ctx_pos_compare(tsc
,
835 events_request
->start_position
) != 0)
838 /* - Call end request for req
839 * - remove req from list_in */
840 lttv_hooks_call(events_request
->after_request
, NULL
);
841 /* - remove req from list_in */
842 /* Destroy the request */
850 GSList
*remove_iter
= iter
;
852 iter
= g_slist_next(iter
);
853 if(free_data
) g_free(remove_iter
->data
);
854 list_in
= g_slist_remove_link(list_in
, remove_iter
);
855 } else { // not remove
856 iter
= g_slist_next(iter
);
863 /* B. When interrupted between chunks */
866 GSList
*iter
= list_in
;
868 /* 1. for each request in list_in */
869 while(iter
!= NULL
) {
871 gboolean remove
= FALSE
;
872 gboolean free_data
= FALSE
;
873 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
875 /* 1.1. Use current postition as start position */
876 if(events_request
->start_position
!= NULL
)
877 lttv_traceset_context_position_destroy(events_request
->start_position
);
878 events_request
->start_position
= ltt_traceset_context_position_new();
879 lttv_traceset_context_position_save(tsc
, events_request
->start_position
);
881 /* 1.2. Remove start time */
882 events_request
->start_time
.tv_sec
= G_MAXUINT
;
883 events_request
->start_time
.tv_nsec
= G_MAXUINT
;
885 /* 1.3. Move from list_in to list_out */
888 list_out
= g_slist_append(list_out
, events_request
);
893 GSList
*remove_iter
= iter
;
895 iter
= g_slist_next(iter
);
896 if(free_data
) g_free(remove_iter
->data
);
897 list_in
= g_slist_remove_link(list_in
, remove_iter
);
898 } else { // not remove
899 iter
= g_slist_next(iter
);
906 //set the cursor back to normal
907 gdk_window_set_cursor(win
, NULL
);
910 g_assert(g_slist_length(list_in
) == 0);
911 if( g_slist_length(list_out
) == 0 ) {
912 /* Put tab's request pending flag back to normal */
913 tab
->events_request_pending
= FALSE
;
914 return FALSE
; /* Remove the idle function */
916 return TRUE
; /* Leave the idle function */
921 /* add_trace_into_traceset_selector, each instance of a viewer has an associated
922 * selector (filter), when a trace is added into traceset, the selector should
923 * reflect the change. The function is used to update the selector
926 void add_trace_into_traceset_selector(GtkMultiVPaned
* paned
, LttTrace
* t
)
928 int j
, k
, m
, nb_tracefile
, nb_control
, nb_per_cpu
, nb_facility
, nb_event
;
929 LttvTracesetSelector
* s
;
930 LttvTraceSelector
* trace
;
931 LttvTracefileSelector
* tracefile
;
932 LttvEventtypeSelector
* eventtype
;
938 w
= gtk_multi_vpaned_get_first_widget(paned
);
940 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
943 trace
= lttv_trace_selector_new(t
);
944 lttv_traceset_selector_trace_add(s
, trace
);
946 nb_facility
= ltt_trace_facility_number(t
);
947 for(k
=0;k
<nb_facility
;k
++){
948 fac
= ltt_trace_facility_get(t
,k
);
949 nb_event
= (int) ltt_facility_eventtype_number(fac
);
950 for(m
=0;m
<nb_event
;m
++){
951 et
= ltt_facility_eventtype_get(fac
,m
);
952 eventtype
= lttv_eventtype_selector_new(et
);
953 lttv_trace_selector_eventtype_add(trace
, eventtype
);
957 nb_control
= ltt_trace_control_tracefile_number(t
);
958 nb_per_cpu
= ltt_trace_per_cpu_tracefile_number(t
);
959 nb_tracefile
= nb_control
+ nb_per_cpu
;
961 for(j
= 0 ; j
< nb_tracefile
; j
++) {
963 tf
= ltt_trace_control_tracefile_get(t
, j
);
965 tf
= ltt_trace_per_cpu_tracefile_get(t
, j
- nb_control
);
966 tracefile
= lttv_tracefile_selector_new(tf
);
967 lttv_trace_selector_tracefile_add(trace
, tracefile
);
968 lttv_eventtype_selector_copy(trace
, tracefile
);
970 }else g_warning("Module does not support filtering\n");
972 w
= gtk_multi_vpaned_get_next_widget(paned
);
977 static void lttvwindow_add_trace(Tab
*tab
, LttvTrace
*trace_v
)
979 LttvTraceset
*traceset
= tab
->traceset_info
->traceset
;
982 //Verify if trace is already present.
983 for(i
=0; i
<lttv_traceset_number(traceset
); i
++)
985 LttvTrace
* trace
= lttv_traceset_get(traceset
, i
);
990 //Keep a reference to the traces so they are not freed.
991 for(i
=0; i
<lttv_traceset_number(traceset
); i
++)
993 LttvTrace
* trace
= lttv_traceset_get(traceset
, i
);
994 lttv_trace_ref(trace
);
997 //remove state update hooks
998 lttv_state_remove_event_hooks(
999 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1001 lttv_context_fini(LTTV_TRACESET_CONTEXT(
1002 tab
->traceset_info
->traceset_context
));
1003 g_object_unref(tab
->traceset_info
->traceset_context
);
1005 lttv_traceset_add(traceset
, trace_v
);
1006 lttv_trace_ref(trace_v
); /* local ref */
1008 /* Create new context */
1009 tab
->traceset_info
->traceset_context
=
1010 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
1012 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->
1015 //add state update hooks
1016 lttv_state_add_event_hooks(
1017 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1018 //Remove local reference to the traces.
1019 for(i
=0; i
<lttv_traceset_number(traceset
); i
++)
1021 LttvTrace
* trace
= lttv_traceset_get(traceset
, i
);
1022 lttv_trace_unref(trace
);
1025 add_trace_into_traceset_selector(tab
->multi_vpaned
, lttv_trace(trace_v
));
1028 /* add_trace adds a trace into the current traceset. It first displays a
1029 * directory selection dialogue to let user choose a trace, then recreates
1030 * tracset_context, and redraws all the viewer of the current tab
1033 void add_trace(GtkWidget
* widget
, gpointer user_data
)
1036 LttvTrace
* trace_v
;
1037 LttvTraceset
* traceset
;
1039 char abs_path
[PATH_MAX
];
1042 MainWindow
* mw_data
= get_window_data_struct(widget
);
1043 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
1045 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1046 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1050 tab
= create_new_tab(widget
, NULL
);
1052 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1055 GtkDirSelection
* file_selector
= (GtkDirSelection
*)gtk_dir_selection_new("Select a trace");
1056 gtk_dir_selection_hide_fileop_buttons(file_selector
);
1058 if(remember_trace_dir
[0] != '\0')
1059 gtk_dir_selection_set_filename(file_selector
, remember_trace_dir
);
1061 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
1063 case GTK_RESPONSE_ACCEPT
:
1064 case GTK_RESPONSE_OK
:
1065 dir
= gtk_dir_selection_get_dir (file_selector
);
1066 strncpy(remember_trace_dir
, dir
, PATH_MAX
);
1067 if(!dir
|| strlen(dir
) == 0){
1068 gtk_widget_destroy((GtkWidget
*)file_selector
);
1071 get_absolute_pathname(dir
, abs_path
);
1072 trace_v
= lttvwindowtraces_get_trace_by_name(abs_path
);
1073 if(trace_v
== NULL
) {
1074 trace
= ltt_trace_open(abs_path
);
1076 g_warning("cannot open trace %s", abs_path
);
1078 trace_v
= lttv_trace_new(trace
);
1079 lttvwindowtraces_add_trace(trace_v
);
1080 lttvwindow_add_trace(tab
, trace_v
);
1083 lttvwindow_add_trace(tab
, trace_v
);
1086 gtk_widget_destroy((GtkWidget
*)file_selector
);
1088 //update current tab
1089 //update_traceset(mw_data);
1091 /* Call the updatetraceset hooks */
1093 traceset
= tab
->traceset_info
->traceset
;
1094 SetTraceset(tab
, traceset
);
1095 // in expose now call_pending_read_hooks(mw_data);
1097 //lttvwindow_report_current_time(mw_data,&(tab->current_time));
1099 case GTK_RESPONSE_REJECT
:
1100 case GTK_RESPONSE_CANCEL
:
1102 gtk_widget_destroy((GtkWidget
*)file_selector
);
1108 /* remove_trace_into_traceset_selector, each instance of a viewer has an associated
1109 * selector (filter), when a trace is remove from traceset, the selector should
1110 * reflect the change. The function is used to update the selector
1113 void remove_trace_from_traceset_selector(GtkMultiVPaned
* paned
, unsigned i
)
1115 LttvTracesetSelector
* s
;
1116 LttvTraceSelector
* t
;
1119 w
= gtk_multi_vpaned_get_first_widget(paned
);
1121 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
1123 t
= lttv_traceset_selector_trace_get(s
,i
);
1124 lttv_traceset_selector_trace_remove(s
, i
);
1125 lttv_trace_selector_destroy(t
);
1126 }g_warning("Module dose not support filtering\n");
1127 w
= gtk_multi_vpaned_get_next_widget(paned
);
1132 /* remove_trace removes a trace from the current traceset if all viewers in
1133 * the current tab are not interested in the trace. It first displays a
1134 * dialogue, which shows all traces in the current traceset, to let user choose
1135 * a trace, then it checks if all viewers unselect the trace, if it is true,
1136 * it will remove the trace, recreate the traceset_contex,
1137 * and redraws all the viewer of the current tab. If there is on trace in the
1138 * current traceset, it will delete all viewers of the current tab
1141 void remove_trace(GtkWidget
* widget
, gpointer user_data
)
1144 LttvTrace
* trace_v
;
1145 LttvTraceset
* traceset
;
1146 gint i
, j
, nb_trace
;
1147 char ** name
, *remove_trace_name
;
1148 MainWindow
* mw_data
= get_window_data_struct(widget
);
1149 LttvTracesetSelector
* s
;
1150 LttvTraceSelector
* t
;
1153 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
1155 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1156 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1162 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1165 nb_trace
=lttv_traceset_number(tab
->traceset_info
->traceset
);
1166 name
= g_new(char*,nb_trace
);
1167 for(i
= 0; i
< nb_trace
; i
++){
1168 trace_v
= lttv_traceset_get(tab
->traceset_info
->traceset
, i
);
1169 trace
= lttv_trace(trace_v
);
1170 name
[i
] = ltt_trace_name(trace
);
1173 remove_trace_name
= get_remove_trace(name
, nb_trace
);
1175 if(remove_trace_name
){
1176 for(i
=0; i
<nb_trace
; i
++){
1177 if(strcmp(remove_trace_name
,name
[i
]) == 0){
1178 //unselect the trace from the current viewer
1179 w
= gtk_multi_vpaned_get_widget(tab
->multi_vpaned
);
1181 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
1183 t
= lttv_traceset_selector_trace_get(s
,i
);
1184 lttv_trace_selector_set_selected(t
, FALSE
);
1187 //check if other viewers select the trace
1188 w
= gtk_multi_vpaned_get_first_widget(tab
->multi_vpaned
);
1190 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
1192 t
= lttv_traceset_selector_trace_get(s
,i
);
1193 selected
= lttv_trace_selector_get_selected(t
);
1196 w
= gtk_multi_vpaned_get_next_widget(tab
->multi_vpaned
);
1198 }else selected
= FALSE
;
1200 //if no viewer selects the trace, remove it
1202 remove_trace_from_traceset_selector(tab
->multi_vpaned
, i
);
1204 traceset
= tab
->traceset_info
->traceset
;
1205 //Keep a reference to the traces so they are not freed.
1206 for(j
=0; j
<lttv_traceset_number(traceset
); j
++)
1208 LttvTrace
* trace
= lttv_traceset_get(traceset
, j
);
1209 lttv_trace_ref(trace
);
1212 //remove state update hooks
1213 lttv_state_remove_event_hooks(
1214 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1215 lttv_context_fini(LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
));
1216 g_object_unref(tab
->traceset_info
->traceset_context
);
1219 trace_v
= lttv_traceset_get(traceset
, i
);
1221 if(lttv_trace_get_ref_number(trace_v
) <= 2) {
1222 /* ref 2 : traceset, local */
1223 lttvwindowtraces_remove_trace(trace_v
);
1224 ltt_trace_close(lttv_trace(trace_v
));
1227 lttv_traceset_remove(traceset
, i
);
1228 lttv_trace_unref(trace_v
); // Remove local reference
1230 if(!lttv_trace_get_ref_number(trace_v
))
1231 lttv_trace_destroy(trace_v
);
1233 tab
->traceset_info
->traceset_context
=
1234 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
1236 LTTV_TRACESET_CONTEXT(tab
->
1237 traceset_info
->traceset_context
),traceset
);
1238 //add state update hooks
1239 lttv_state_add_event_hooks(
1240 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1242 //Remove local reference to the traces.
1243 for(j
=0; j
<lttv_traceset_number(traceset
); j
++)
1245 LttvTrace
* trace
= lttv_traceset_get(traceset
, j
);
1246 lttv_trace_unref(trace
);
1250 //update current tab
1251 //update_traceset(mw_data);
1254 SetTraceset(mw_data
, (gpointer
)traceset
);
1255 // in expose now call_pending_read_hooks(mw_data);
1257 //lttvwindow_report_current_time(mw_data,&(tab->current_time));
1260 while(tab
->multi_vpaned
->num_children
){
1261 gtk_multi_vpaned_widget_delete(tab
->multi_vpaned
);
1275 /* Redraw all the viewers in the current tab */
1276 void redraw(GtkWidget
*widget
, gpointer user_data
)
1278 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
1279 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1280 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1285 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1289 LttvAttributeValue value
;
1291 g_assert(lttv_iattribute_find_by_path(tab
->attributes
, "hooks/redraw", LTTV_POINTER
, &value
));
1293 tmp
= (LttvHooks
*)*(value
.v_pointer
);
1295 lttv_hooks_call(tmp
,NULL
);
1299 void continue_processing(GtkWidget
*widget
, gpointer user_data
)
1301 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
1302 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1303 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1308 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1312 LttvAttributeValue value
;
1314 g_assert(lttv_iattribute_find_by_path(tab
->attributes
,
1315 "hooks/continue", LTTV_POINTER
, &value
));
1317 tmp
= (LttvHooks
*)*(value
.v_pointer
);
1319 lttv_hooks_call(tmp
,NULL
);
1322 /* Stop the processing for the calling main window's current tab.
1323 * It removes every processing requests that are in its list. It does not call
1324 * the end request hooks, because the request is not finished.
1327 void stop_processing(GtkWidget
*widget
, gpointer user_data
)
1329 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
1330 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1331 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1336 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1338 GSList
*events_requests
= tab
->events_requests
;
1340 GSList
*iter
= events_requests
;
1342 while(iter
!= NULL
) {
1343 GSList
*remove_iter
= iter
;
1344 iter
= g_slist_next(iter
);
1346 g_free(remove_iter
->data
);
1347 events_requests
= g_slist_remove_link(events_requests
, remove_iter
);
1349 g_assert(g_slist_length(events_requests
) == 0);
1353 /* save will save the traceset to a file
1354 * Not implemented yet FIXME
1357 void save(GtkWidget
* widget
, gpointer user_data
)
1362 void save_as(GtkWidget
* widget
, gpointer user_data
)
1364 g_printf("Save as\n");
1368 /* zoom will change the time_window of all the viewers of the
1369 * current tab, and redisplay them. The main functionality is to
1370 * determine the new time_window of the current tab
1373 void zoom(GtkWidget
* widget
, double size
)
1375 TimeInterval
*time_span
;
1376 TimeWindow new_time_window
;
1377 LttTime current_time
, time_delta
, time_s
, time_e
, time_tmp
;
1378 MainWindow
* mw_data
= get_window_data_struct(widget
);
1379 LttvTracesetContext
*tsc
;
1380 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
1382 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1383 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1389 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1392 if(size
== 1) return;
1394 tsc
= LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
1395 time_span
= &tsc
->time_span
;
1396 new_time_window
= tab
->time_window
;
1397 current_time
= tab
->current_time
;
1399 time_delta
= ltt_time_sub(time_span
->end_time
,time_span
->start_time
);
1401 new_time_window
.start_time
= time_span
->start_time
;
1402 new_time_window
.time_width
= time_delta
;
1404 new_time_window
.time_width
= ltt_time_div(new_time_window
.time_width
, size
);
1405 if(ltt_time_compare(new_time_window
.time_width
,time_delta
) > 0)
1406 { /* Case where zoom out is bigger than trace length */
1407 new_time_window
.start_time
= time_span
->start_time
;
1408 new_time_window
.time_width
= time_delta
;
1412 /* Center the image on the current time */
1413 new_time_window
.start_time
=
1414 ltt_time_sub(current_time
, ltt_time_div(new_time_window
.time_width
, 2.0));
1415 /* If on borders, don't fall off */
1416 if(ltt_time_compare(new_time_window
.start_time
, time_span
->start_time
) <0)
1418 new_time_window
.start_time
= time_span
->start_time
;
1422 if(ltt_time_compare(
1423 ltt_time_add(new_time_window
.start_time
, new_time_window
.time_width
),
1424 time_span
->end_time
) > 0)
1426 new_time_window
.start_time
=
1427 ltt_time_sub(time_span
->end_time
, new_time_window
.time_width
);
1435 //time_tmp = ltt_time_div(new_time_window.time_width, 2);
1436 //if(ltt_time_compare(current_time, time_tmp) < 0){
1437 // time_s = time_span->startTime;
1439 // time_s = ltt_time_sub(current_time,time_tmp);
1441 //time_e = ltt_time_add(current_time,time_tmp);
1442 //if(ltt_time_compare(time_span->startTime, time_s) > 0){
1443 // time_s = time_span->startTime;
1444 //}else if(ltt_time_compare(time_span->endTime, time_e) < 0){
1445 // time_e = time_span->endTime;
1446 // time_s = ltt_time_sub(time_e,new_time_window.time_width);
1448 //new_time_window.start_time = time_s;
1451 //lttvwindow_report_time_window(mw_data, &new_time_window);
1452 //call_pending_read_hooks(mw_data);
1454 //lttvwindow_report_current_time(mw_data,&(tab->current_time));
1455 set_time_window(tab
, &new_time_window
);
1456 // in expose now call_pending_read_hooks(mw_data);
1457 gtk_multi_vpaned_set_adjust(tab
->multi_vpaned
, &new_time_window
, FALSE
);
1460 void zoom_in(GtkWidget
* widget
, gpointer user_data
)
1465 void zoom_out(GtkWidget
* widget
, gpointer user_data
)
1470 void zoom_extended(GtkWidget
* widget
, gpointer user_data
)
1475 void go_to_time(GtkWidget
* widget
, gpointer user_data
)
1477 g_printf("Go to time\n");
1480 void show_time_frame(GtkWidget
* widget
, gpointer user_data
)
1482 g_printf("Show time frame\n");
1486 /* callback function */
1489 on_empty_traceset_activate (GtkMenuItem
*menuitem
,
1492 create_new_window((GtkWidget
*)menuitem
, user_data
, FALSE
);
1497 on_clone_traceset_activate (GtkMenuItem
*menuitem
,
1500 create_new_window((GtkWidget
*)menuitem
, user_data
, TRUE
);
1504 /* create_new_tab calls create_tab to construct a new tab in the main window
1507 Tab
*create_new_tab(GtkWidget
* widget
, gpointer user_data
){
1508 gchar label
[PATH_MAX
];
1509 MainWindow
* mw_data
= get_window_data_struct(widget
);
1511 GtkNotebook
* notebook
= (GtkNotebook
*)lookup_widget(widget
, "MNotebook");
1512 if(notebook
== NULL
){
1513 g_printf("Notebook does not exist\n");
1516 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1517 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1523 copy_tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1526 strcpy(label
,"Page");
1527 if(get_label(mw_data
, label
,"Get the name of the tab","Please input tab's name"))
1528 return (create_tab (mw_data
, copy_tab
, notebook
, label
));
1532 on_tab_activate (GtkMenuItem
*menuitem
,
1535 create_new_tab((GtkWidget
*)menuitem
, user_data
);
1540 on_open_activate (GtkMenuItem
*menuitem
,
1543 open_traceset((GtkWidget
*)menuitem
, user_data
);
1548 on_close_activate (GtkMenuItem
*menuitem
,
1551 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1552 main_window_destructor(mw_data
);
1556 /* remove the current tab from the main window
1560 on_close_tab_activate (GtkWidget
*widget
,
1564 GtkWidget
* notebook
;
1566 MainWindow
* mw_data
= get_window_data_struct(widget
);
1567 notebook
= lookup_widget(widget
, "MNotebook");
1568 if(notebook
== NULL
){
1569 g_printf("Notebook does not exist\n");
1573 page_num
= gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
));
1575 gtk_notebook_remove_page(GTK_NOTEBOOK(notebook
), page_num
);
1580 on_close_tab_X_clicked (GtkWidget
*widget
,
1584 GtkWidget
*notebook
= lookup_widget(widget
, "MNotebook");
1585 if(notebook
== NULL
){
1586 g_printf("Notebook does not exist\n");
1590 if((page_num
= gtk_notebook_page_num(GTK_NOTEBOOK(notebook
), widget
)) != -1)
1591 gtk_notebook_remove_page(GTK_NOTEBOOK(notebook
), page_num
);
1597 on_add_trace_activate (GtkMenuItem
*menuitem
,
1600 add_trace((GtkWidget
*)menuitem
, user_data
);
1605 on_remove_trace_activate (GtkMenuItem
*menuitem
,
1608 remove_trace((GtkWidget
*)menuitem
, user_data
);
1613 on_save_activate (GtkMenuItem
*menuitem
,
1616 save((GtkWidget
*)menuitem
, user_data
);
1621 on_save_as_activate (GtkMenuItem
*menuitem
,
1624 save_as((GtkWidget
*)menuitem
, user_data
);
1629 on_quit_activate (GtkMenuItem
*menuitem
,
1637 on_cut_activate (GtkMenuItem
*menuitem
,
1645 on_copy_activate (GtkMenuItem
*menuitem
,
1648 g_printf("Copye\n");
1653 on_paste_activate (GtkMenuItem
*menuitem
,
1656 g_printf("Paste\n");
1661 on_delete_activate (GtkMenuItem
*menuitem
,
1664 g_printf("Delete\n");
1669 on_zoom_in_activate (GtkMenuItem
*menuitem
,
1672 zoom_in((GtkWidget
*)menuitem
, user_data
);
1677 on_zoom_out_activate (GtkMenuItem
*menuitem
,
1680 zoom_out((GtkWidget
*)menuitem
, user_data
);
1685 on_zoom_extended_activate (GtkMenuItem
*menuitem
,
1688 zoom_extended((GtkWidget
*)menuitem
, user_data
);
1693 on_go_to_time_activate (GtkMenuItem
*menuitem
,
1696 go_to_time((GtkWidget
*)menuitem
, user_data
);
1701 on_show_time_frame_activate (GtkMenuItem
*menuitem
,
1704 show_time_frame((GtkWidget
*)menuitem
, user_data
);
1709 on_move_viewer_up_activate (GtkMenuItem
*menuitem
,
1712 move_up_viewer((GtkWidget
*)menuitem
, user_data
);
1717 on_move_viewer_down_activate (GtkMenuItem
*menuitem
,
1720 move_down_viewer((GtkWidget
*)menuitem
, user_data
);
1725 on_remove_viewer_activate (GtkMenuItem
*menuitem
,
1728 delete_viewer((GtkWidget
*)menuitem
, user_data
);
1732 on_trace_filter_activate (GtkMenuItem
*menuitem
,
1735 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1736 LttvTracesetSelector
* s
;
1738 GtkWidget
* notebook
= lookup_widget(GTK_WIDGET(menuitem
), "MNotebook");
1740 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1741 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1747 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1750 w
= gtk_multi_vpaned_get_widget(tab
->multi_vpaned
);
1752 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
1754 g_printf("There is no viewer yet\n");
1757 if(get_filter_selection(s
, "Configure trace and tracefile filter", "Select traces and tracefiles")){
1758 //FIXME report filter change
1759 //update_traceset(mw_data);
1760 //call_pending_read_hooks(mw_data);
1761 //lttvwindow_report_current_time(mw_data,&(tab->current_time));
1766 on_trace_facility_activate (GtkMenuItem
*menuitem
,
1769 g_printf("Trace facility selector: %s\n");
1773 /* Dispaly a file selection dialogue to let user select a module, then call
1774 * lttv_module_load(), finally insert tool button and menu entry in the main window
1775 * for the loaded module
1779 on_load_module_activate (GtkMenuItem
*menuitem
,
1784 char str
[PATH_MAX
], *str1
;
1785 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1786 GtkFileSelection
* file_selector
= (GtkFileSelection
*)gtk_file_selection_new("Select a module");
1787 if(remember_plugins_dir
[0] != '\0')
1788 gtk_file_selection_set_filename(file_selector
, remember_plugins_dir
);
1789 gtk_file_selection_hide_fileop_buttons(file_selector
);
1792 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
1794 case GTK_RESPONSE_ACCEPT
:
1795 case GTK_RESPONSE_OK
:
1796 dir
= gtk_file_selection_get_selections (file_selector
);
1797 strncpy(str
,dir
[0],PATH_MAX
);
1798 strncpy(remember_plugins_dir
,dir
[0],PATH_MAX
);
1799 str1
= strrchr(str
,'/');
1802 str1
= strrchr(str
,'\\');
1805 lttv_module_require(str1
, NULL
);
1807 case GTK_RESPONSE_REJECT
:
1808 case GTK_RESPONSE_CANCEL
:
1810 gtk_widget_destroy((GtkWidget
*)file_selector
);
1813 g_printf("Load module: %s\n", str
);
1817 /* Display all loaded modules, let user to select a module to unload
1818 * by calling lttv_module_unload
1822 on_unload_module_activate (GtkMenuItem
*menuitem
,
1827 char *unload_module_name
;
1829 LttvLibrary
*library
;
1830 LttvLibraryInfo library_info
;
1831 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1833 name
= g_ptr_array_new();
1834 nb
= lttv_library_number();
1837 library
= lttv_library_get(i
);
1838 lttv_library_info(library
, &library_info
);
1839 if(library_info
.load_count
> 0) g_ptr_array_add(name
, library_info
.name
);
1842 unload_module_name
=get_unload_module((char **)(name
->pdata
), name
->len
);
1844 if(unload_module_name
){
1846 library
= lttv_library_get(i
);
1847 lttv_library_info(library
, &library_info
);
1848 if(strcmp(unload_module_name
, library_info
.name
) == 0){
1849 lttv_library_unload(library
);
1855 g_ptr_array_free(name
, TRUE
);
1859 /* Display a directory dialogue to let user select a path for module searching
1863 on_add_module_search_path_activate (GtkMenuItem
*menuitem
,
1866 GtkDirSelection
* file_selector
= (GtkDirSelection
*)gtk_dir_selection_new("Select module path");
1870 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1871 if(remember_plugins_dir
[0] != '\0')
1872 gtk_dir_selection_set_filename(file_selector
, remember_plugins_dir
);
1874 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
1876 case GTK_RESPONSE_ACCEPT
:
1877 case GTK_RESPONSE_OK
:
1878 dir
= gtk_dir_selection_get_dir (file_selector
);
1879 strncpy(remember_plugins_dir
,dir
,PATH_MAX
);
1880 strncat(remember_plugins_dir
,"/",PATH_MAX
);
1881 lttv_library_path_add(dir
);
1882 case GTK_RESPONSE_REJECT
:
1883 case GTK_RESPONSE_CANCEL
:
1885 gtk_widget_destroy((GtkWidget
*)file_selector
);
1892 on_color_activate (GtkMenuItem
*menuitem
,
1895 g_printf("Color\n");
1900 on_filter_activate (GtkMenuItem
*menuitem
,
1903 g_printf("Filter\n");
1908 on_save_configuration_activate (GtkMenuItem
*menuitem
,
1911 g_printf("Save configuration\n");
1916 on_content_activate (GtkMenuItem
*menuitem
,
1919 g_printf("Content\n");
1924 on_about_activate (GtkMenuItem
*menuitem
,
1927 g_printf("About...\n");
1932 on_button_new_clicked (GtkButton
*button
,
1935 create_new_window((GtkWidget
*)button
, user_data
, TRUE
);
1939 on_button_new_tab_clicked (GtkButton
*button
,
1942 create_new_tab((GtkWidget
*)button
, user_data
);
1946 on_button_open_clicked (GtkButton
*button
,
1949 open_traceset((GtkWidget
*)button
, user_data
);
1954 on_button_add_trace_clicked (GtkButton
*button
,
1957 add_trace((GtkWidget
*)button
, user_data
);
1962 on_button_remove_trace_clicked (GtkButton
*button
,
1965 remove_trace((GtkWidget
*)button
, user_data
);
1969 on_button_redraw_clicked (GtkButton
*button
,
1972 redraw((GtkWidget
*)button
, user_data
);
1976 on_button_continue_processing_clicked (GtkButton
*button
,
1979 continue_processing((GtkWidget
*)button
, user_data
);
1983 on_button_stop_processing_clicked (GtkButton
*button
,
1986 stop_processing((GtkWidget
*)button
, user_data
);
1992 on_button_save_clicked (GtkButton
*button
,
1995 save((GtkWidget
*)button
, user_data
);
2000 on_button_save_as_clicked (GtkButton
*button
,
2003 save_as((GtkWidget
*)button
, user_data
);
2008 on_button_zoom_in_clicked (GtkButton
*button
,
2011 zoom_in((GtkWidget
*)button
, user_data
);
2016 on_button_zoom_out_clicked (GtkButton
*button
,
2019 zoom_out((GtkWidget
*)button
, user_data
);
2024 on_button_zoom_extended_clicked (GtkButton
*button
,
2027 zoom_extended((GtkWidget
*)button
, user_data
);
2032 on_button_go_to_time_clicked (GtkButton
*button
,
2035 go_to_time((GtkWidget
*)button
, user_data
);
2040 on_button_show_time_frame_clicked (GtkButton
*button
,
2043 show_time_frame((GtkWidget
*)button
, user_data
);
2048 on_button_move_up_clicked (GtkButton
*button
,
2051 move_up_viewer((GtkWidget
*)button
, user_data
);
2056 on_button_move_down_clicked (GtkButton
*button
,
2059 move_down_viewer((GtkWidget
*)button
, user_data
);
2064 on_button_delete_viewer_clicked (GtkButton
*button
,
2067 delete_viewer((GtkWidget
*)button
, user_data
);
2071 on_MWindow_destroy (GtkWidget
*widget
,
2074 MainWindow
*main_window
= get_window_data_struct(widget
);
2075 LttvIAttribute
*attributes
= main_window
->attributes
;
2076 LttvAttributeValue value
;
2078 //This is unnecessary, since widgets will be destroyed
2079 //by the main window widget anyway.
2080 //remove_all_menu_toolbar_constructors(main_window, NULL);
2082 g_assert(lttv_iattribute_find_by_path(attributes
,
2083 "viewers/menu", LTTV_POINTER
, &value
));
2084 lttv_menus_destroy((LttvMenus
*)*(value
.v_pointer
));
2086 g_assert(lttv_iattribute_find_by_path(attributes
,
2087 "viewers/toolbar", LTTV_POINTER
, &value
));
2088 lttv_toolbars_destroy((LttvToolbars
*)*(value
.v_pointer
));
2090 g_object_unref(main_window
->attributes
);
2091 g_main_window_list
= g_slist_remove(g_main_window_list
, main_window
);
2093 g_printf("There are now : %d windows\n",g_slist_length(g_main_window_list
));
2094 if(g_slist_length(g_main_window_list
) == 0)
2099 on_MWindow_configure (GtkWidget
*widget
,
2100 GdkEventConfigure
*event
,
2103 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)widget
);
2104 float width
= event
->width
;
2105 TimeWindow time_win
;
2107 TimeInterval
*time_span
;
2110 // MD : removed time width modification upon resizing of the main window.
2111 // The viewers will redraw themselves completely, without time interval
2114 if(mw_data->window_width){
2115 time_span = LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->Time_Span ;
2116 time_win = tab->time_window;
2117 ratio = width / mw_data->window_width;
2118 tab->time_window.time_width = ltt_time_mul(time_win.time_width,ratio);
2119 time = ltt_time_sub(time_span->endTime, time_win.start_time);
2120 if(ltt_time_compare(time, tab->time_window.time_width) < 0){
2121 tab->time_window.time_width = time;
2127 mw_data->window_width = (int)width;
2136 on_MNotebook_switch_page (GtkNotebook
*notebook
,
2137 GtkNotebookPage
*page
,
2145 /* callback function to check or uncheck the check box (filter)
2148 void checkbox_changed(GtkTreeView
*treeview
,
2150 GtkTreeViewColumn
*arg2
,
2153 GtkTreeStore
* store
= (GtkTreeStore
*)gtk_tree_view_get_model (treeview
);
2157 if (gtk_tree_model_get_iter ((GtkTreeModel
*)store
, &iter
, arg1
)){
2158 gtk_tree_model_get ((GtkTreeModel
*)store
, &iter
, CHECKBOX_COLUMN
, &value
, -1);
2159 value
= value
? FALSE
: TRUE
;
2160 gtk_tree_store_set (GTK_TREE_STORE (store
), &iter
, CHECKBOX_COLUMN
, value
, -1);
2166 /* According to user's selection, update selector(filter)
2169 void update_filter(LttvTracesetSelector
*s
, GtkTreeStore
*store
)
2171 GtkTreeIter iter
, child_iter
, child_iter1
, child_iter2
;
2172 int i
, j
, k
, nb_eventtype
;
2173 LttvTraceSelector
* trace
;
2174 LttvTracefileSelector
* tracefile
;
2175 LttvEventtypeSelector
* eventtype
;
2176 gboolean value
, value1
, value2
;
2178 if(gtk_tree_model_get_iter_first((GtkTreeModel
*)store
, &iter
)){
2181 trace
= lttv_traceset_selector_trace_get(s
, i
);
2182 nb_eventtype
= lttv_trace_selector_eventtype_number(trace
);
2183 gtk_tree_model_get ((GtkTreeModel
*)store
, &iter
, CHECKBOX_COLUMN
, &value
,-1);
2186 if(gtk_tree_model_iter_children ((GtkTreeModel
*)store
, &child_iter
, &iter
)){
2188 if(j
<1){//eventtype selector for trace
2189 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter
, CHECKBOX_COLUMN
, &value2
,-1);
2192 if(gtk_tree_model_iter_children ((GtkTreeModel
*)store
, &child_iter1
, &child_iter
)){
2194 eventtype
= lttv_trace_selector_eventtype_get(trace
,k
);
2195 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter1
, CHECKBOX_COLUMN
, &value2
,-1);
2196 lttv_eventtype_selector_set_selected(eventtype
,value2
);
2198 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &child_iter1
));
2201 }else{ //tracefile selector
2202 tracefile
= lttv_trace_selector_tracefile_get(trace
, j
- 1);
2203 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter
, CHECKBOX_COLUMN
, &value1
,-1);
2204 lttv_tracefile_selector_set_selected(tracefile
,value1
);
2206 gtk_tree_model_iter_children((GtkTreeModel
*)store
, &child_iter1
, &child_iter
); //eventtype selector
2207 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter1
, CHECKBOX_COLUMN
, &value2
,-1);
2210 if(gtk_tree_model_iter_children ((GtkTreeModel
*)store
, &child_iter2
, &child_iter1
)){
2211 do{//eventtype selector for tracefile
2212 eventtype
= lttv_tracefile_selector_eventtype_get(tracefile
,k
);
2213 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter2
, CHECKBOX_COLUMN
, &value2
,-1);
2214 lttv_eventtype_selector_set_selected(eventtype
,value2
);
2216 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &child_iter2
));
2222 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &child_iter
));
2225 lttv_trace_selector_set_selected(trace
,value
);
2227 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &iter
));
2232 /* Display a dialogue showing all eventtypes and traces, let user to select the interested
2233 * eventtypes, tracefiles and traces (filter)
2236 gboolean
get_filter_selection(LttvTracesetSelector
*s
,char *title
, char * column_title
)
2238 GtkWidget
* dialogue
;
2239 GtkTreeStore
* store
;
2241 GtkWidget
* scroll_win
;
2242 GtkCellRenderer
* renderer
;
2243 GtkTreeViewColumn
* column
;
2244 GtkTreeIter iter
, child_iter
, child_iter1
, child_iter2
;
2245 int i
, j
, k
, id
, nb_trace
, nb_tracefile
, nb_eventtype
;
2246 LttvTraceSelector
* trace
;
2247 LttvTracefileSelector
* tracefile
;
2248 LttvEventtypeSelector
* eventtype
;
2252 dialogue
= gtk_dialog_new_with_buttons(title
,
2255 GTK_STOCK_OK
,GTK_RESPONSE_ACCEPT
,
2256 GTK_STOCK_CANCEL
,GTK_RESPONSE_REJECT
,
2258 gtk_window_set_default_size((GtkWindow
*)dialogue
, 300, 500);
2260 store
= gtk_tree_store_new (TOTAL_COLUMNS
, G_TYPE_BOOLEAN
, G_TYPE_STRING
);
2261 tree
= gtk_tree_view_new_with_model (GTK_TREE_MODEL (store
));
2262 g_object_unref (G_OBJECT (store
));
2263 g_signal_connect (G_OBJECT (tree
), "row-activated",
2264 G_CALLBACK (checkbox_changed
),
2268 renderer
= gtk_cell_renderer_toggle_new ();
2269 gtk_cell_renderer_toggle_set_radio((GtkCellRendererToggle
*)renderer
, FALSE
);
2271 g_object_set (G_OBJECT (renderer
),"activatable", TRUE
, NULL
);
2273 column
= gtk_tree_view_column_new_with_attributes ("Checkbox",
2275 "active", CHECKBOX_COLUMN
,
2277 gtk_tree_view_column_set_alignment (column
, 0.5);
2278 gtk_tree_view_column_set_fixed_width (column
, 20);
2279 gtk_tree_view_append_column (GTK_TREE_VIEW (tree
), column
);
2281 renderer
= gtk_cell_renderer_text_new ();
2282 column
= gtk_tree_view_column_new_with_attributes (column_title
,
2284 "text", NAME_COLUMN
,
2286 gtk_tree_view_column_set_alignment (column
, 0.0);
2287 gtk_tree_view_append_column (GTK_TREE_VIEW (tree
), column
);
2288 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW (tree
), FALSE
);
2290 scroll_win
= gtk_scrolled_window_new (NULL
, NULL
);
2291 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win
),
2292 GTK_POLICY_AUTOMATIC
,GTK_POLICY_AUTOMATIC
);
2293 gtk_container_add (GTK_CONTAINER (scroll_win
), tree
);
2295 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), scroll_win
,TRUE
, TRUE
,0);
2297 gtk_widget_show(scroll_win
);
2298 gtk_widget_show(tree
);
2300 nb_trace
= lttv_traceset_selector_trace_number(s
);
2301 for(i
=0;i
<nb_trace
;i
++){
2302 trace
= lttv_traceset_selector_trace_get(s
, i
);
2303 name
= lttv_trace_selector_get_name(trace
);
2304 gtk_tree_store_append (store
, &iter
, NULL
);
2305 checked
= lttv_trace_selector_get_selected(trace
);
2306 gtk_tree_store_set (store
, &iter
,
2307 CHECKBOX_COLUMN
,checked
,
2311 gtk_tree_store_append (store
, &child_iter
, &iter
);
2312 gtk_tree_store_set (store
, &child_iter
,
2313 CHECKBOX_COLUMN
, checked
,
2314 NAME_COLUMN
,"eventtype",
2317 nb_eventtype
= lttv_trace_selector_eventtype_number(trace
);
2318 for(j
=0;j
<nb_eventtype
;j
++){
2319 eventtype
= lttv_trace_selector_eventtype_get(trace
,j
);
2320 name
= lttv_eventtype_selector_get_name(eventtype
);
2321 checked
= lttv_eventtype_selector_get_selected(eventtype
);
2322 gtk_tree_store_append (store
, &child_iter1
, &child_iter
);
2323 gtk_tree_store_set (store
, &child_iter1
,
2324 CHECKBOX_COLUMN
, checked
,
2329 nb_tracefile
= lttv_trace_selector_tracefile_number(trace
);
2330 for(j
=0;j
<nb_tracefile
;j
++){
2331 tracefile
= lttv_trace_selector_tracefile_get(trace
, j
);
2332 name
= lttv_tracefile_selector_get_name(tracefile
);
2333 gtk_tree_store_append (store
, &child_iter
, &iter
);
2334 checked
= lttv_tracefile_selector_get_selected(tracefile
);
2335 gtk_tree_store_set (store
, &child_iter
,
2336 CHECKBOX_COLUMN
, checked
,
2340 gtk_tree_store_append (store
, &child_iter1
, &child_iter
);
2341 gtk_tree_store_set (store
, &child_iter1
,
2342 CHECKBOX_COLUMN
, checked
,
2343 NAME_COLUMN
,"eventtype",
2346 for(k
=0;k
<nb_eventtype
;k
++){
2347 eventtype
= lttv_tracefile_selector_eventtype_get(tracefile
,k
);
2348 name
= lttv_eventtype_selector_get_name(eventtype
);
2349 checked
= lttv_eventtype_selector_get_selected(eventtype
);
2350 gtk_tree_store_append (store
, &child_iter2
, &child_iter1
);
2351 gtk_tree_store_set (store
, &child_iter2
,
2352 CHECKBOX_COLUMN
, checked
,
2359 id
= gtk_dialog_run(GTK_DIALOG(dialogue
));
2361 case GTK_RESPONSE_ACCEPT
:
2362 case GTK_RESPONSE_OK
:
2363 update_filter(s
, store
);
2364 gtk_widget_destroy(dialogue
);
2366 case GTK_RESPONSE_REJECT
:
2367 case GTK_RESPONSE_CANCEL
:
2369 gtk_widget_destroy(dialogue
);
2376 /* Select a trace which will be removed from traceset
2379 char * get_remove_trace(char ** all_trace_name
, int nb_trace
)
2381 return get_selection(all_trace_name
, nb_trace
,
2382 "Select a trace", "Trace pathname");
2386 /* Select a module which will be unloaded
2389 char * get_unload_module(char ** loaded_module_name
, int nb_module
)
2391 return get_selection(loaded_module_name
, nb_module
,
2392 "Select an unload module", "Module pathname");
2396 /* Display a dialogue which shows all selectable items, let user to
2397 * select one of them
2400 char * get_selection(char ** loaded_module_name
, int nb_module
,
2401 char *title
, char * column_title
)
2403 GtkWidget
* dialogue
;
2404 GtkWidget
* scroll_win
;
2406 GtkListStore
* store
;
2407 GtkTreeViewColumn
* column
;
2408 GtkCellRenderer
* renderer
;
2409 GtkTreeSelection
* select
;
2412 char * unload_module_name
= NULL
;
2414 dialogue
= gtk_dialog_new_with_buttons(title
,
2417 GTK_STOCK_OK
,GTK_RESPONSE_ACCEPT
,
2418 GTK_STOCK_CANCEL
,GTK_RESPONSE_REJECT
,
2420 gtk_window_set_default_size((GtkWindow
*)dialogue
, 500, 200);
2422 scroll_win
= gtk_scrolled_window_new (NULL
, NULL
);
2423 gtk_widget_show ( scroll_win
);
2424 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win
),
2425 GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
2427 store
= gtk_list_store_new (N_COLUMNS
,G_TYPE_STRING
);
2428 tree
= gtk_tree_view_new_with_model(GTK_TREE_MODEL (store
));
2429 gtk_widget_show ( tree
);
2430 g_object_unref (G_OBJECT (store
));
2432 renderer
= gtk_cell_renderer_text_new ();
2433 column
= gtk_tree_view_column_new_with_attributes (column_title
,
2435 "text", MODULE_COLUMN
,
2437 gtk_tree_view_column_set_alignment (column
, 0.5);
2438 gtk_tree_view_column_set_fixed_width (column
, 150);
2439 gtk_tree_view_append_column (GTK_TREE_VIEW (tree
), column
);
2441 select
= gtk_tree_view_get_selection (GTK_TREE_VIEW (tree
));
2442 gtk_tree_selection_set_mode (select
, GTK_SELECTION_SINGLE
);
2444 gtk_container_add (GTK_CONTAINER (scroll_win
), tree
);
2446 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), scroll_win
,TRUE
, TRUE
,0);
2448 for(i
=0;i
<nb_module
;i
++){
2449 gtk_list_store_append (store
, &iter
);
2450 gtk_list_store_set (store
, &iter
, MODULE_COLUMN
,loaded_module_name
[i
],-1);
2453 id
= gtk_dialog_run(GTK_DIALOG(dialogue
));
2455 case GTK_RESPONSE_ACCEPT
:
2456 case GTK_RESPONSE_OK
:
2457 if (gtk_tree_selection_get_selected (select
, (GtkTreeModel
**)&store
, &iter
)){
2458 gtk_tree_model_get ((GtkTreeModel
*)store
, &iter
, MODULE_COLUMN
, &unload_module_name
, -1);
2460 case GTK_RESPONSE_REJECT
:
2461 case GTK_RESPONSE_CANCEL
:
2463 gtk_widget_destroy(dialogue
);
2467 return unload_module_name
;
2471 /* Insert all menu entry and tool buttons into this main window
2476 void add_all_menu_toolbar_constructors(MainWindow
* mw
, gpointer user_data
)
2480 lttvwindow_viewer_constructor constructor
;
2481 LttvMenus
* global_menu
, * instance_menu
;
2482 LttvToolbars
* global_toolbar
, * instance_toolbar
;
2483 LttvMenuClosure
*menu_item
;
2484 LttvToolbarClosure
*toolbar_item
;
2485 LttvAttributeValue value
;
2486 LttvIAttribute
*global_attributes
= LTTV_IATTRIBUTE(lttv_global_attributes());
2487 LttvIAttribute
*attributes
= mw
->attributes
;
2488 GtkWidget
* tool_menu_title_menu
, *new_widget
, *pixmap
;
2490 g_assert(lttv_iattribute_find_by_path(global_attributes
,
2491 "viewers/menu", LTTV_POINTER
, &value
));
2492 if(*(value
.v_pointer
) == NULL
)
2493 *(value
.v_pointer
) = lttv_menus_new();
2494 global_menu
= (LttvMenus
*)*(value
.v_pointer
);
2496 g_assert(lttv_iattribute_find_by_path(attributes
,
2497 "viewers/menu", LTTV_POINTER
, &value
));
2498 if(*(value
.v_pointer
) == NULL
)
2499 *(value
.v_pointer
) = lttv_menus_new();
2500 instance_menu
= (LttvMenus
*)*(value
.v_pointer
);
2504 g_assert(lttv_iattribute_find_by_path(global_attributes
,
2505 "viewers/toolbar", LTTV_POINTER
, &value
));
2506 if(*(value
.v_pointer
) == NULL
)
2507 *(value
.v_pointer
) = lttv_toolbars_new();
2508 global_toolbar
= (LttvToolbars
*)*(value
.v_pointer
);
2510 g_assert(lttv_iattribute_find_by_path(attributes
,
2511 "viewers/toolbar", LTTV_POINTER
, &value
));
2512 if(*(value
.v_pointer
) == NULL
)
2513 *(value
.v_pointer
) = lttv_toolbars_new();
2514 instance_toolbar
= (LttvToolbars
*)*(value
.v_pointer
);
2516 /* Add missing menu entries to window instance */
2517 for(i
=0;i
<global_menu
->len
;i
++) {
2518 menu_item
= &g_array_index(global_menu
, LttvMenuClosure
, i
);
2520 //add menu_item to window instance;
2521 constructor
= menu_item
->con
;
2522 tool_menu_title_menu
= lookup_widget(mw
->mwindow
,"ToolMenuTitle_menu");
2524 gtk_menu_item_new_with_mnemonic (menu_item
->menu_text
);
2525 gtk_container_add (GTK_CONTAINER (tool_menu_title_menu
),
2527 g_signal_connect ((gpointer
) new_widget
, "activate",
2528 G_CALLBACK (insert_viewer_wrap
),
2530 gtk_widget_show (new_widget
);
2531 lttv_menus_add(instance_menu
, menu_item
->con
,
2532 menu_item
->menu_path
,
2533 menu_item
->menu_text
,
2538 /* Add missing toolbar entries to window instance */
2539 for(i
=0;i
<global_toolbar
->len
;i
++) {
2540 toolbar_item
= &g_array_index(global_toolbar
, LttvToolbarClosure
, i
);
2542 //add toolbar_item to window instance;
2543 constructor
= toolbar_item
->con
;
2544 tool_menu_title_menu
= lookup_widget(mw
->mwindow
,"MToolbar1");
2545 pixbuf
= gdk_pixbuf_new_from_xpm_data((const char**)toolbar_item
->pixmap
);
2546 pixmap
= gtk_image_new_from_pixbuf(pixbuf
);
2548 gtk_toolbar_append_element (GTK_TOOLBAR (tool_menu_title_menu
),
2549 GTK_TOOLBAR_CHILD_BUTTON
,
2552 toolbar_item
->tooltip
, NULL
,
2553 pixmap
, NULL
, NULL
);
2554 gtk_label_set_use_underline(
2555 GTK_LABEL (((GtkToolbarChild
*) (
2556 g_list_last (GTK_TOOLBAR
2557 (tool_menu_title_menu
)->children
)->data
))->label
),
2559 gtk_container_set_border_width (GTK_CONTAINER (new_widget
), 1);
2560 g_signal_connect ((gpointer
) new_widget
,
2562 G_CALLBACK (insert_viewer_wrap
),
2564 gtk_widget_show (new_widget
);
2566 lttv_toolbars_add(instance_toolbar
, toolbar_item
->con
,
2567 toolbar_item
->tooltip
,
2568 toolbar_item
->pixmap
,
2576 /* Create a main window
2579 void construct_main_window(MainWindow
* parent
)
2581 g_debug("construct_main_window()");
2582 GtkWidget
* new_window
; /* New generated main window */
2583 MainWindow
* new_m_window
;/* New main window structure */
2584 GtkNotebook
* notebook
;
2585 LttvIAttribute
*attributes
=
2586 LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
));
2587 LttvAttributeValue value
;
2590 new_m_window
= g_new(MainWindow
, 1);
2592 // Add the object's information to the module's array
2593 g_main_window_list
= g_slist_append(g_main_window_list
, new_m_window
);
2596 new_window
= create_MWindow();
2597 gtk_widget_show (new_window
);
2599 new_m_window
->mwindow
= new_window
;
2600 new_m_window
->attributes
= attributes
;
2602 g_assert(lttv_iattribute_find_by_path(attributes
,
2603 "viewers/menu", LTTV_POINTER
, &value
));
2604 *(value
.v_pointer
) = lttv_menus_new();
2606 g_assert(lttv_iattribute_find_by_path(attributes
,
2607 "viewers/toolbar", LTTV_POINTER
, &value
));
2608 *(value
.v_pointer
) = lttv_toolbars_new();
2610 add_all_menu_toolbar_constructors(new_m_window
, NULL
);
2612 g_object_set_data_full(G_OBJECT(new_window
),
2614 (gpointer
)new_m_window
,
2615 (GDestroyNotify
)g_free
);
2616 //create a default tab
2617 notebook
= (GtkNotebook
*)lookup_widget(new_m_window
->mwindow
, "MNotebook");
2618 if(notebook
== NULL
){
2619 g_printf("Notebook does not exist\n");
2622 gtk_notebook_popup_enable (GTK_NOTEBOOK(notebook
));
2623 //for now there is no name field in LttvTraceset structure
2624 //Use "Traceset" as the label for the default tab
2626 GtkWidget
* parent_notebook
= lookup_widget(parent
->mwindow
, "MNotebook");
2627 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(parent_notebook
),
2628 gtk_notebook_get_current_page(GTK_NOTEBOOK(parent_notebook
)));
2634 parent_tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
2636 new_tab
= create_tab(new_m_window
, parent_tab
, notebook
, "Traceset");
2638 new_tab
= create_tab(new_m_window
, NULL
, notebook
, "Traceset");
2639 if(g_init_trace
!= NULL
){
2640 lttvwindow_add_trace(new_tab
,
2645 g_printf("There are now : %d windows\n",g_slist_length(g_main_window_list
));
2649 /* Free the memory occupied by a tab structure
2653 void tab_destructor(Tab
* tab_instance
)
2655 int i
, nb
, ref_count
;
2658 if(tab_instance
->attributes
)
2659 g_object_unref(tab_instance
->attributes
);
2661 if(tab_instance
->interrupted_state
)
2662 g_object_unref(tab_instance
->interrupted_state
);
2665 if(tab_instance
->traceset_info
->traceset_context
!= NULL
){
2666 //remove state update hooks
2667 lttv_state_remove_event_hooks(
2668 (LttvTracesetState
*)tab_instance
->traceset_info
->
2670 lttv_context_fini(LTTV_TRACESET_CONTEXT(tab_instance
->traceset_info
->
2672 g_object_unref(tab_instance
->traceset_info
->traceset_context
);
2674 if(tab_instance
->traceset_info
->traceset
!= NULL
) {
2675 nb
= lttv_traceset_number(tab_instance
->traceset_info
->traceset
);
2676 for(i
= 0 ; i
< nb
; i
++) {
2677 trace
= lttv_traceset_get(tab_instance
->traceset_info
->traceset
, i
);
2678 ref_count
= lttv_trace_get_ref_number(trace
);
2680 ltt_trace_close(lttv_trace(trace
));
2684 lttv_traceset_destroy(tab_instance
->traceset_info
->traceset
);
2685 /* Remove the idle events requests processing function of the tab */
2686 g_idle_remove_by_data(tab_instance
);
2688 g_slist_free(tab_instance
->events_requests
);
2689 g_free(tab_instance
->traceset_info
);
2690 g_free(tab_instance
);
2694 /* Create a tab and insert it into the current main window
2697 Tab
* create_tab(MainWindow
* mw
, Tab
*copy_tab
,
2698 GtkNotebook
* notebook
, char * label
)
2704 //create a new tab data structure
2707 //construct and initialize the traceset_info
2708 tab
->traceset_info
= g_new(TracesetInfo
,1);
2711 tab
->traceset_info
->traceset
=
2712 lttv_traceset_copy(copy_tab
->traceset_info
->traceset
);
2714 tab
->traceset_info
->traceset
= lttv_traceset_new();
2717 //FIXME : this is g_debug level
2718 lttv_attribute_write_xml(
2719 lttv_traceset_attribute(tab
->traceset_info
->traceset
),
2725 //FIXME copy not implemented in lower level
2726 tab
->traceset_info
->traceset_context
=
2727 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
2728 g_assert(tab
->traceset_info
->traceset_context
!= NULL
);
2730 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
),
2731 tab
->traceset_info
->traceset
);
2732 //add state update hooks
2733 lttv_state_add_event_hooks(
2734 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
2736 //determine the current_time and time_window of the tab
2737 if(copy_tab
!= NULL
){
2738 tab
->time_window
= copy_tab
->time_window
;
2739 tab
->current_time
= copy_tab
->current_time
;
2741 tab
->time_window
.start_time
=
2742 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
2743 time_span
.start_time
;
2744 if(DEFAULT_TIME_WIDTH_S
<
2745 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
2746 time_span
.end_time
.tv_sec
)
2747 tmp_time
.tv_sec
= DEFAULT_TIME_WIDTH_S
;
2750 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
2751 time_span
.end_time
.tv_sec
;
2752 tmp_time
.tv_nsec
= 0;
2753 tab
->time_window
.time_width
= tmp_time
;
2754 tab
->current_time
.tv_sec
=
2755 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
2756 time_span
.start_time
.tv_sec
;
2757 tab
->current_time
.tv_nsec
=
2758 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
2759 time_span
.start_time
.tv_nsec
;
2761 tab
->attributes
= LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
));
2762 tab
->interrupted_state
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
2763 tab
->multi_vpaned
= (GtkMultiVPaned
*)gtk_multi_vpaned_new();
2764 gtk_widget_show((GtkWidget
*)tab
->multi_vpaned
);
2768 // Display a label with a X
2769 GtkWidget *w_hbox = gtk_hbox_new(FALSE, 4);
2770 GtkWidget *w_label = gtk_label_new (label);
2771 GtkWidget *pixmap = create_pixmap(GTK_WIDGET(notebook), "close.png");
2772 GtkWidget *w_button = gtk_button_new ();
2773 gtk_container_add(GTK_CONTAINER(w_button), pixmap);
2774 //GtkWidget *w_button = gtk_button_new_with_label("x");
2776 gtk_button_set_relief(GTK_BUTTON(w_button), GTK_RELIEF_NONE);
2778 gtk_box_pack_start(GTK_BOX(w_hbox), w_label, TRUE, TRUE, 0);
2779 gtk_box_pack_end(GTK_BOX(w_hbox), w_button, FALSE,
2782 g_signal_connect_swapped (w_button, "clicked",
2783 G_CALLBACK (on_close_tab_X_clicked),
2786 gtk_widget_set_state(w_button, GTK_STATE_ACTIVE);
2788 gtk_widget_show (w_label);
2789 gtk_widget_show (pixmap);
2790 gtk_widget_show (w_button);
2791 gtk_widget_show (w_hbox);
2793 tab->label = w_hbox;
2797 tab
->label
= gtk_label_new (label
);
2798 gtk_widget_show (tab
->label
);
2801 /* Start with empty events requests list */
2802 tab
->events_requests
= NULL
;
2803 tab
->events_request_pending
= FALSE
;
2805 g_object_set_data_full(
2806 G_OBJECT(tab
->multi_vpaned
),
2809 (GDestroyNotify
)tab_destructor
);
2811 //insert tab into notebook
2812 gtk_notebook_append_page(notebook
,
2813 (GtkWidget
*)tab
->multi_vpaned
,
2815 list
= gtk_container_get_children(GTK_CONTAINER(notebook
));
2816 gtk_notebook_set_current_page(notebook
,g_list_length(list
)-1);
2817 // always show : not if(g_list_length(list)>1)
2818 gtk_notebook_set_show_tabs(notebook
, TRUE
);
2824 * execute_events_requests
2826 * Idle function that executes the pending requests for a tab.
2828 * @return return value : TRUE : keep the idle function, FALSE : remove it.
2830 gboolean
execute_events_requests(Tab
*tab
)
2832 return ( lttvwindow_process_pending_requests(tab
) );