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/mainwindow-private.h>
38 #include <lttvwindow/menu.h>
39 #include <lttvwindow/toolbar.h>
40 #include <lttvwindow/lttvwindow.h>
41 #include <lttvwindow/gtkdirsel.h>
42 #include <lttvwindow/lttvfilter.h>
44 #define PATH_LENGTH 256
45 #define DEFAULT_TIME_WIDTH_S 1
47 extern LttvTrace
*g_init_trace
;
50 /** Array containing instanced objects. */
51 extern GSList
* g_main_window_list
;
53 /** MD : keep old directory. */
54 static char remember_plugins_dir
[PATH_LENGTH
] = "";
55 static char remember_trace_dir
[PATH_LENGTH
] = "";
58 MainWindow
* get_window_data_struct(GtkWidget
* widget
);
59 char * get_unload_module(char ** loaded_module_name
, int nb_module
);
60 char * get_remove_trace(char ** all_trace_name
, int nb_trace
);
61 char * get_selection(char ** all_name
, int nb
, char *title
, char * column_title
);
62 gboolean
get_filter_selection(LttvTracesetSelector
*s
, char *title
, char * column_title
);
63 void * create_tab(MainWindow
* parent
, MainWindow
* current_window
,
64 GtkNotebook
* notebook
, char * label
);
66 static void insert_viewer(GtkWidget
* widget
, lttvwindow_viewer_constructor constructor
);
67 void update_filter(LttvTracesetSelector
*s
, GtkTreeStore
*store
);
69 void checkbox_changed(GtkTreeView
*treeview
,
71 GtkTreeViewColumn
*arg2
,
73 void remove_trace_from_traceset_selector(GtkMultiVPaned
* paned
, unsigned i
);
74 void add_trace_into_traceset_selector(GtkMultiVPaned
* paned
, LttTrace
* trace
);
76 LttvTracesetSelector
* construct_traceset_selector(LttvTraceset
* traceset
);
78 static gboolean
lttvwindow_process_pending_requests(Tab
*tab
);
92 /* Construct a selector(filter), which will be associated with a viewer,
93 * and provides an interface for user to select interested events and traces
96 LttvTracesetSelector
* construct_traceset_selector(LttvTraceset
* traceset
)
98 LttvTracesetSelector
* s
;
99 LttvTraceSelector
* trace
;
100 LttvTracefileSelector
* tracefile
;
101 LttvEventtypeSelector
* eventtype
;
103 int nb_trace
, nb_tracefile
, nb_control
, nb_per_cpu
, nb_facility
, nb_event
;
110 s
= lttv_traceset_selector_new(lttv_traceset_name(traceset
));
111 nb_trace
= lttv_traceset_number(traceset
);
112 for(i
=0;i
<nb_trace
;i
++){
113 trace_v
= lttv_traceset_get(traceset
, i
);
114 t
= lttv_trace(trace_v
);
115 trace
= lttv_trace_selector_new(t
);
116 lttv_traceset_selector_trace_add(s
, trace
);
118 nb_facility
= ltt_trace_facility_number(t
);
119 for(k
=0;k
<nb_facility
;k
++){
120 fac
= ltt_trace_facility_get(t
,k
);
121 nb_event
= (int) ltt_facility_eventtype_number(fac
);
122 for(m
=0;m
<nb_event
;m
++){
123 et
= ltt_facility_eventtype_get(fac
,m
);
124 eventtype
= lttv_eventtype_selector_new(et
);
125 lttv_trace_selector_eventtype_add(trace
, eventtype
);
129 nb_control
= ltt_trace_control_tracefile_number(t
);
130 nb_per_cpu
= ltt_trace_per_cpu_tracefile_number(t
);
131 nb_tracefile
= nb_control
+ nb_per_cpu
;
133 for(j
= 0 ; j
< nb_tracefile
; j
++) {
135 tf
= ltt_trace_control_tracefile_get(t
, j
);
137 tf
= ltt_trace_per_cpu_tracefile_get(t
, j
- nb_control
);
138 tracefile
= lttv_tracefile_selector_new(tf
);
139 lttv_trace_selector_tracefile_add(trace
, tracefile
);
140 lttv_eventtype_selector_copy(trace
, tracefile
);
147 /* insert_viewer function constructs an instance of a viewer first,
148 * then inserts the widget of the instance into the container of the
153 insert_viewer_wrap(GtkWidget
*menuitem
, gpointer user_data
)
157 insert_viewer((GtkWidget
*)menuitem
, (lttvwindow_viewer_constructor
)user_data
);
158 // selected_hook(&val);
162 /* internal functions */
163 void insert_viewer(GtkWidget
* widget
, lttvwindow_viewer_constructor constructor
)
165 GtkMultiVPaned
* multi_vpaned
;
166 MainWindow
* mw_data
= get_window_data_struct(widget
);
168 LttvTracesetSelector
* s
;
169 TimeInterval
* time_interval
;
170 Tab
*tab
= mw_data
->current_tab
;
173 multi_vpaned
= tab
->multi_vpaned
;
175 s
= construct_traceset_selector(tab
->traceset_info
->traceset
);
176 viewer
= (GtkWidget
*)constructor(tab
, s
, "Traceset_Selector");
179 gtk_multi_vpaned_widget_add(multi_vpaned
, viewer
);
180 // We unref here, because it is now referenced by the multi_vpaned!
181 g_object_unref(G_OBJECT(viewer
));
183 // The viewer will show itself when it receives a show notify
184 // So we call the show notify hooks here. It will
185 // typically add hooks for reading, we call process trace, and the
186 // end of reading hook will call gtk_widget_show and unregister the
188 // Note that show notify gets the time_requested through the call_data.
189 //show_viewer(mw_data);
190 // in expose now call_pending_read_hooks(mw_data);
195 /* get_label function is used to get user input, it displays an input
196 * box, which allows user to input a string
199 void get_label_string (GtkWidget
* text
, gchar
* label
)
201 GtkEntry
* entry
= (GtkEntry
*)text
;
202 if(strlen(gtk_entry_get_text(entry
))!=0)
203 strcpy(label
,gtk_entry_get_text(entry
));
206 gboolean
get_label(MainWindow
* mw
, gchar
* str
, gchar
* dialogue_title
, gchar
* label_str
)
208 GtkWidget
* dialogue
;
213 dialogue
= gtk_dialog_new_with_buttons(dialogue_title
,NULL
,
215 GTK_STOCK_OK
,GTK_RESPONSE_ACCEPT
,
216 GTK_STOCK_CANCEL
,GTK_RESPONSE_REJECT
,
219 label
= gtk_label_new(label_str
);
220 gtk_widget_show(label
);
222 text
= gtk_entry_new();
223 gtk_widget_show(text
);
225 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), label
,TRUE
, TRUE
,0);
226 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), text
,FALSE
, FALSE
,0);
228 id
= gtk_dialog_run(GTK_DIALOG(dialogue
));
230 case GTK_RESPONSE_ACCEPT
:
231 get_label_string(text
,str
);
232 gtk_widget_destroy(dialogue
);
234 case GTK_RESPONSE_REJECT
:
236 gtk_widget_destroy(dialogue
);
243 /* get_window_data_struct function is actually a lookup function,
244 * given a widget which is in the tree of the main window, it will
245 * return the MainWindow data structure associated with main window
248 MainWindow
* get_window_data_struct(GtkWidget
* widget
)
251 MainWindow
* mw_data
;
253 mw
= lookup_widget(widget
, "MWindow");
255 g_printf("Main window does not exist\n");
259 mw_data
= (MainWindow
*) g_object_get_data(G_OBJECT(mw
),"main_window_data");
261 g_printf("Main window data does not exist\n");
268 /* create_new_window function, just constructs a new main window
271 void create_new_window(GtkWidget
* widget
, gpointer user_data
, gboolean clone
)
273 MainWindow
* parent
= get_window_data_struct(widget
);
276 g_printf("Clone : use the same traceset\n");
277 construct_main_window(parent
);
279 g_printf("Empty : traceset is set to NULL\n");
280 construct_main_window(NULL
);
285 /* move_*_viewer functions move the selected view up/down in
289 void move_up_viewer(GtkWidget
* widget
, gpointer user_data
)
291 MainWindow
* mw
= get_window_data_struct(widget
);
292 if(!mw
->current_tab
) return;
293 gtk_multi_vpaned_widget_move_up(mw
->current_tab
->multi_vpaned
);
296 void move_down_viewer(GtkWidget
* widget
, gpointer user_data
)
298 MainWindow
* mw
= get_window_data_struct(widget
);
299 if(!mw
->current_tab
) return;
300 gtk_multi_vpaned_widget_move_down(mw
->current_tab
->multi_vpaned
);
304 /* delete_viewer deletes the selected viewer in the current tab
307 void delete_viewer(GtkWidget
* widget
, gpointer user_data
)
309 MainWindow
* mw
= get_window_data_struct(widget
);
310 if(!mw
->current_tab
) return;
311 gtk_multi_vpaned_widget_delete(mw
->current_tab
->multi_vpaned
);
315 /* open_traceset will open a traceset saved in a file
316 * Right now, it is not finished yet, (not working)
320 void open_traceset(GtkWidget
* widget
, gpointer user_data
)
324 LttvTraceset
* traceset
;
325 MainWindow
* mw_data
= get_window_data_struct(widget
);
326 GtkFileSelection
* file_selector
=
327 (GtkFileSelection
*)gtk_file_selection_new("Select a traceset");
329 gtk_file_selection_hide_fileop_buttons(file_selector
);
331 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
333 case GTK_RESPONSE_ACCEPT
:
334 case GTK_RESPONSE_OK
:
335 dir
= gtk_file_selection_get_selections (file_selector
);
336 traceset
= lttv_traceset_load(dir
[0]);
337 g_printf("Open a trace set %s\n", dir
[0]);
340 case GTK_RESPONSE_REJECT
:
341 case GTK_RESPONSE_CANCEL
:
343 gtk_widget_destroy((GtkWidget
*)file_selector
);
350 /* lttvwindow_process_pending_requests
352 * This internal function gets called by g_idle, taking care of the pending
353 * requests. It is responsible for concatenation of time intervals and position
354 * requests. It does it with the following algorithm organizing process traceset
355 * calls. Here is the detailed description of the way it works :
357 * - Events Requests Servicing Algorithm
359 * Data structures necessary :
361 * List of requests added to context : list_in
362 * List of requests not added to context : list_out
367 * list_out : many events requests
369 * FIXME : insert rest of algorithm here
374 gboolean
lttvwindow_process_pending_requests(Tab
*tab
)
376 unsigned max_nb_events
;
380 LttvTracesetContext
*tsc
;
381 LttvTracefileContext
*tfc
;
382 GSList
*events_requests
= tab
->events_requests
;
383 GSList
*list_out
= events_requests
;
384 GSList
*list_in
= NULL
;
388 LttvTracesetContextPosition
*end_position
;
391 /* Current tab check : if no current tab is present, no hooks to call. */
392 /* (Xang Xiu) It makes the expose works.. MD:? */
396 /* There is no events requests pending : we should never have been called! */
397 g_assert(g_slist_length(events_requests
) != 0);
399 tsc
= LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
401 //set the cursor to be X shape, indicating that the computer is busy in doing its job
402 new = gdk_cursor_new(GDK_X_CURSOR
);
403 widget
= lookup_widget(tab
->mw
->mwindow
, "MToolbar1");
404 win
= gtk_widget_get_parent_window(widget
);
405 gdk_window_set_cursor(win
, new);
406 gdk_cursor_unref(new);
407 gdk_window_stick(win
);
408 gdk_window_unstick(win
);
410 g_debug("SIZE events req len : %d", g_slist_length(events_requests
));
412 /* Events processing algorithm implementation */
413 /* A. Servicing loop */
414 while( (g_slist_length(list_in
) != 0 || g_slist_length(list_out
) != 0)
415 && !gtk_events_pending() ) {
417 /* 1. If list_in is empty (need a seek) */
418 if( g_slist_length(list_in
) == 0 ) {
420 /* list in is empty, need a seek */
422 /* 1.1 Add requests to list_in */
423 GSList
*ltime
= NULL
;
427 /* 1.1.1 Find all time requests with the lowest start time in list_out
430 if(g_slist_length(list_out
) > 0)
431 ltime
= g_slist_append(ltime
, g_slist_nth_data(list_out
, 0));
432 for(iter
=g_slist_nth(list_out
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
433 /* Find all time requests with the lowest start time in list_out */
434 guint index_ltime
= g_array_index(ltime
, guint
, 0);
435 EventsRequest
*event_request_ltime
= (EventsRequest
*)g_slist_nth_data(ltime
, 0);
436 EventsRequest
*event_request_list_out
= (EventsRequest
*)iter
->data
;
439 comp
= ltt_time_compare(event_request_ltime
->start_time
,
440 event_request_list_out
->start_time
);
442 ltime
= g_slist_append(ltime
, event_request_list_out
);
444 /* Remove all elements from ltime, and add current */
446 ltime
= g_slist_delete_link(ltime
, g_slist_nth(ltime
, 0));
447 ltime
= g_slist_append(ltime
, event_request_list_out
);
451 /* 1.1.2 Find all position requests with the lowest position in list_out
454 if(g_slist_length(list_out
) > 0)
455 lpos
= g_slist_append(lpos
, g_slist_nth_data(list_out
, 0));
456 for(iter
=g_slist_nth(list_out
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
457 /* Find all position requests with the lowest position in list_out */
458 guint index_lpos
= g_array_index(lpos
, guint
, 0);
459 EventsRequest
*event_request_lpos
= (EventsRequest
*)g_slist_nth_data(lpos
, 0);
460 EventsRequest
*event_request_list_out
= (EventsRequest
*)iter
->data
;
463 if(event_request_lpos
->start_position
!= NULL
464 && event_request_list_out
->start_position
!= NULL
)
466 comp
= lttv_traceset_context_pos_pos_compare
467 (event_request_lpos
->start_position
,
468 event_request_list_out
->start_position
);
473 lpos
= g_slist_append(lpos
, event_request_list_out
);
475 /* Remove all elements from lpos, and add current */
477 lpos
= g_slist_delete_link(lpos
, g_slist_nth(lpos
, 0));
478 lpos
= g_slist_append(lpos
, event_request_list_out
);
482 /* 1.1.3 If lpos.start time < ltime */
484 EventsRequest
*event_request_lpos
= (EventsRequest
*)g_slist_nth_data(lpos
, 0);
485 EventsRequest
*event_request_ltime
= (EventsRequest
*)g_slist_nth_data(ltime
, 0);
486 LttTime lpos_start_time
;
488 if(event_request_lpos
!= NULL
489 && event_request_lpos
->start_position
!= NULL
) {
491 lpos_start_time
= lttv_traceset_context_position_get_time(
492 event_request_lpos
->start_position
);
493 if(ltt_time_compare(lpos_start_time
,
494 event_request_ltime
->start_time
)<0) {
495 /* Add lpos to list_in, remove them from list_out */
497 for(iter
=lpos
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
499 EventsRequest
*event_request_lpos
=
500 (EventsRequest
*)iter
->data
;
502 g_slist_append(list_in
, event_request_lpos
);
503 /* Remove from list_out */
504 g_slist_remove(list_out
, event_request_lpos
);
508 /* 1.1.4 (lpos.start time >= ltime) */
509 /* Add ltime to list_in, remove them from list_out */
511 for(iter
=ltime
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
513 EventsRequest
*event_request_ltime
=
514 (EventsRequest
*)iter
->data
;
516 g_slist_append(list_in
, event_request_ltime
);
517 /* Remove from list_out */
518 g_slist_remove(list_out
, event_request_ltime
);
528 tfc
= lttv_traceset_context_get_current_tfc(tsc
);
529 g_assert(g_slist_length(list_in
)>0);
530 EventsRequest
*events_request
= g_slist_nth_data(list_in
, 0);
532 /* 1.2.1 If first request in list_in is a time request */
533 if(events_request
->start_position
== NULL
) {
534 /* - If first req in list_in start time != current time */
535 if(tfc
!= NULL
&& ltt_time_compare(events_request
->start_time
,
536 tfc
->timestamp
) != 0)
537 /* - Seek to that time */
538 lttv_process_traceset_seek_time(tsc
, events_request
->start_time
);
540 /* Else, the first request in list_in is a position request */
541 /* If first req in list_in pos != current pos */
542 g_assert(events_request
->start_position
!= NULL
);
543 if(lttv_traceset_context_ctx_pos_compare(tsc
,
544 events_request
->start_position
) != 0) {
545 /* 1.2.2.1 Seek to that position */
546 lttv_process_traceset_seek_position(tsc
, events_request
->start_position
);
551 /* 1.3 Add hooks and call before request for all list_in members */
555 for(iter
=list_in
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
556 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
557 /* 1.3.1 If !servicing */
558 if(events_request
->servicing
== FALSE
) {
559 /* - begin request hooks called
562 lttv_hooks_call(events_request
->before_request
, NULL
);
563 events_request
->servicing
= TRUE
;
565 /* 1.3.2 call before chunk
566 * 1.3.3 events hooks added
568 lttv_process_traceset_begin(tsc
, events_request
->before_chunk_traceset
,
569 events_request
->before_chunk_trace
,
570 events_request
->before_chunk_tracefile
,
571 events_request
->event
,
572 events_request
->event_by_id
);
576 /* 2. Else, list_in is not empty, we continue a read */
578 tfc
= lttv_traceset_context_get_current_tfc(tsc
);
580 /* 2.1 For each req of list_out */
581 for(iter
=list_out
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
582 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
584 /* if req.start time == current context time
585 * or req.start position == current position*/
586 if( ltt_time_compare(events_request
->start_time
,
589 (events_request
->start_position
!= NULL
591 lttv_traceset_context_ctx_pos_compare(tsc
,
592 events_request
->start_position
) == 0)
594 /* - Add to list_in, remove from list_out */
595 g_slist_append(list_in
, events_request
);
596 g_slist_remove(list_out
, events_request
);
598 /* - If !servicing */
599 if(events_request
->servicing
== FALSE
) {
600 /* - begin request hooks called
603 lttv_hooks_call(events_request
->before_request
, NULL
);
604 events_request
->servicing
= TRUE
;
609 lttv_process_traceset_begin(tsc
, events_request
->before_chunk_traceset
,
610 events_request
->before_chunk_trace
,
611 events_request
->before_chunk_tracefile
,
612 events_request
->event
,
613 events_request
->event_by_id
);
618 /* 3. Find end criterions */
623 /* 3.1.1 Find lowest end time in list_in */
624 g_assert(g_slist_length(list_in
)>0);
625 end_time
= ((EventsRequest
*)g_slist_nth_data(list_in
,0))->end_time
;
627 for(iter
=g_slist_nth(list_in
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
628 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
630 if(ltt_time_compare(events_request
->end_time
,
632 end_time
= events_request
->end_time
;
635 /* 3.1.2 Find lowest start time in list_out */
636 for(iter
=list_out
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
637 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
639 if(ltt_time_compare(events_request
->start_time
,
641 end_time
= events_request
->start_time
;
646 /* 3.2 Number of events */
648 /* 3.2.1 Find lowest number of events in list_in */
651 end_nb_events
= ((EventsRequest
*)g_slist_nth_data(list_in
,0))->num_events
;
653 for(iter
=g_slist_nth(list_in
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
654 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
656 if(events_request
->num_events
< end_nb_events
)
657 end_nb_events
= events_request
->num_events
;
660 /* 3.2.2 Use min(CHUNK_NUM_EVENTS, min num events in list_in) as
663 end_nb_events
= MIN(CHUNK_NUM_EVENTS
, end_nb_events
);
667 /* 3.3 End position */
669 /* 3.3.1 Find lowest end position in list_in */
672 end_position
=((EventsRequest
*)g_slist_nth_data(list_in
,0))->end_position
;
674 for(iter
=g_slist_nth(list_in
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
675 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
677 if(events_request
->end_position
!= NULL
&& end_position
!= NULL
&&
678 lttv_traceset_context_pos_pos_compare(events_request
->end_position
,
680 end_position
= events_request
->end_position
;
685 /* 3.3.2 Find lowest start position in list_out */
688 for(iter
=list_out
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
689 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
691 if(events_request
->end_position
!= NULL
&& end_position
!= NULL
&&
692 lttv_traceset_context_pos_pos_compare(events_request
->end_position
,
694 end_position
= events_request
->end_position
;
699 /* 4. Call process traceset middle */
700 count
= lttv_process_traceset_middle(tsc
, end_time
, end_nb_events
, end_position
);
703 /* 5. After process traceset middle */
704 tfc
= lttv_traceset_context_get_current_tfc(tsc
);
706 /* - if current context time > traceset.end time */
707 if(tfc
== NULL
|| ltt_time_compare(tfc
->timestamp
,
708 tsc
->time_span
.end_time
) > 0) {
709 /* - For each req in list_in */
710 GSList
*iter
= list_in
;
712 while(iter
!= NULL
) {
714 gboolean remove
= FALSE
;
715 gboolean free_data
= FALSE
;
716 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
718 /* - Remove events hooks for req
719 * - Call end chunk for req
721 lttv_process_traceset_end(tsc
, events_request
->after_chunk_traceset
,
722 events_request
->after_chunk_trace
,
723 events_request
->after_chunk_tracefile
,
724 events_request
->event
,
725 events_request
->event_by_id
);
726 /* - Call end request for req */
727 lttv_hooks_call(events_request
->after_request
, NULL
);
729 /* - remove req from list_in */
730 /* Destroy the request */
737 GSList
*remove_iter
= iter
;
739 iter
= g_slist_next(iter
);
740 if(free_data
) g_free(remove_iter
->data
);
741 list_in
= g_slist_remove_link(list_in
, remove_iter
);
742 } else { // not remove
743 iter
= g_slist_next(iter
);
749 /* 5.1 For each req in list_in */
750 GSList
*iter
= list_in
;
752 while(iter
!= NULL
) {
754 gboolean remove
= FALSE
;
755 gboolean free_data
= FALSE
;
756 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
758 /* - Remove events hooks for req
759 * - Call end chunk for req
761 lttv_process_traceset_end(tsc
, events_request
->after_chunk_traceset
,
762 events_request
->after_chunk_trace
,
763 events_request
->after_chunk_tracefile
,
764 events_request
->event
,
765 events_request
->event_by_id
);
767 /* - req.num -= count */
768 g_assert(events_request
->num_events
>= count
);
769 events_request
->num_events
-= count
;
771 g_assert(tfc
!= NULL
);
774 * current context time > req.end time
776 * req.end pos == current pos
778 * req.stop_flag == TRUE
780 if( events_request
->num_events
== 0
782 events_request
->stop_flag
== TRUE
784 ltt_time_compare(tfc
->timestamp
,
785 events_request
->end_time
) > 0
787 (events_request
->start_position
!= NULL
789 lttv_traceset_context_ctx_pos_compare(tsc
,
790 events_request
->start_position
) != 0)
793 /* - Call end request for req
794 * - remove req from list_in */
795 lttv_hooks_call(events_request
->after_request
, NULL
);
796 /* - remove req from list_in */
797 /* Destroy the request */
805 GSList
*remove_iter
= iter
;
807 iter
= g_slist_next(iter
);
808 if(free_data
) g_free(remove_iter
->data
);
809 list_in
= g_slist_remove_link(list_in
, remove_iter
);
810 } else { // not remove
811 iter
= g_slist_next(iter
);
818 /* B. When interrupted between chunks */
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
;
828 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
830 /* 1.1. Use current postition as start position */
831 g_free(events_request
->start_position
);
832 lttv_traceset_context_position_save(tsc
, events_request
->start_position
);
834 /* 1.2. Remove start time */
835 events_request
->start_time
.tv_sec
= G_MAXUINT
;
836 events_request
->start_time
.tv_nsec
= G_MAXUINT
;
838 /* 1.3. Move from list_in to list_out */
841 list_out
= g_slist_append(list_out
, events_request
);
846 GSList
*remove_iter
= iter
;
848 iter
= g_slist_next(iter
);
849 if(free_data
) g_free(remove_iter
->data
);
850 list_in
= g_slist_remove_link(list_in
, remove_iter
);
851 } else { // not remove
852 iter
= g_slist_next(iter
);
859 //set the cursor back to normal
860 gdk_window_set_cursor(win
, NULL
);
863 g_assert(g_slist_length(list_in
) == 0);
864 if( g_slist_length(list_out
) == 0 ) {
865 /* Put tab's request pending flag back to normal */
866 tab
->events_request_pending
= FALSE
;
867 return FALSE
; /* Remove the idle function */
869 return TRUE
; /* Leave the idle function */
874 /* add_trace_into_traceset_selector, each instance of a viewer has an associated
875 * selector (filter), when a trace is added into traceset, the selector should
876 * reflect the change. The function is used to update the selector
879 void add_trace_into_traceset_selector(GtkMultiVPaned
* paned
, LttTrace
* t
)
881 int j
, k
, m
, nb_tracefile
, nb_control
, nb_per_cpu
, nb_facility
, nb_event
;
882 LttvTracesetSelector
* s
;
883 LttvTraceSelector
* trace
;
884 LttvTracefileSelector
* tracefile
;
885 LttvEventtypeSelector
* eventtype
;
891 w
= gtk_multi_vpaned_get_first_widget(paned
);
893 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
896 trace
= lttv_trace_selector_new(t
);
897 lttv_traceset_selector_trace_add(s
, trace
);
899 nb_facility
= ltt_trace_facility_number(t
);
900 for(k
=0;k
<nb_facility
;k
++){
901 fac
= ltt_trace_facility_get(t
,k
);
902 nb_event
= (int) ltt_facility_eventtype_number(fac
);
903 for(m
=0;m
<nb_event
;m
++){
904 et
= ltt_facility_eventtype_get(fac
,m
);
905 eventtype
= lttv_eventtype_selector_new(et
);
906 lttv_trace_selector_eventtype_add(trace
, eventtype
);
910 nb_control
= ltt_trace_control_tracefile_number(t
);
911 nb_per_cpu
= ltt_trace_per_cpu_tracefile_number(t
);
912 nb_tracefile
= nb_control
+ nb_per_cpu
;
914 for(j
= 0 ; j
< nb_tracefile
; j
++) {
916 tf
= ltt_trace_control_tracefile_get(t
, j
);
918 tf
= ltt_trace_per_cpu_tracefile_get(t
, j
- nb_control
);
919 tracefile
= lttv_tracefile_selector_new(tf
);
920 lttv_trace_selector_tracefile_add(trace
, tracefile
);
921 lttv_eventtype_selector_copy(trace
, tracefile
);
923 }else g_warning("Module does not support filtering\n");
925 w
= gtk_multi_vpaned_get_next_widget(paned
);
930 /* add_trace adds a trace into the current traceset. It first displays a
931 * directory selection dialogue to let user choose a trace, then recreates
932 * tracset_context, and redraws all the viewer of the current tab
935 void add_trace(GtkWidget
* widget
, gpointer user_data
)
939 LttvTraceset
* traceset
;
943 MainWindow
* mw_data
= get_window_data_struct(widget
);
944 GtkDirSelection
* file_selector
= (GtkDirSelection
*)gtk_dir_selection_new("Select a trace");
945 gtk_dir_selection_hide_fileop_buttons(file_selector
);
946 if(remember_trace_dir
[0] != '\0')
947 gtk_dir_selection_set_filename(file_selector
, remember_trace_dir
);
949 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
951 case GTK_RESPONSE_ACCEPT
:
952 case GTK_RESPONSE_OK
:
953 dir
= gtk_dir_selection_get_dir (file_selector
);
954 strncpy(remember_trace_dir
, dir
, PATH_LENGTH
);
955 if(!dir
|| strlen(dir
) == 0){
956 gtk_widget_destroy((GtkWidget
*)file_selector
);
959 trace
= ltt_trace_open(dir
);
960 if(trace
== NULL
) g_critical("cannot open trace %s", dir
);
961 trace_v
= lttv_trace_new(trace
);
962 traceset
= mw_data
->current_tab
->traceset_info
->traceset
;
964 //Keep a reference to the traces so they are not freed.
965 for(i
=0; i
<lttv_traceset_number(traceset
); i
++)
967 LttvTrace
* trace
= lttv_traceset_get(traceset
, i
);
968 lttv_trace_ref(trace
);
971 //remove state update hooks
972 lttv_state_remove_event_hooks(
973 (LttvTracesetState
*)mw_data
->current_tab
->traceset_info
->traceset_context
);
975 lttv_context_fini(LTTV_TRACESET_CONTEXT(
976 mw_data
->current_tab
->traceset_info
->traceset_context
));
977 g_object_unref(mw_data
->current_tab
->traceset_info
->traceset_context
);
980 lttv_traceset_add(traceset
, trace_v
);
982 /* Create new context */
983 mw_data
->current_tab
->traceset_info
->traceset_context
=
984 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
986 LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->traceset_info
->
989 //add state update hooks
990 lttv_state_add_event_hooks(
991 (LttvTracesetState
*)mw_data
->current_tab
->traceset_info
->traceset_context
);
992 //Remove local reference to the traces.
993 for(i
=0; i
<lttv_traceset_number(traceset
); i
++)
995 LttvTrace
* trace
= lttv_traceset_get(traceset
, i
);
996 lttv_trace_unref(trace
);
1000 add_trace_into_traceset_selector(mw_data
->current_tab
->multi_vpaned
, trace
);
1002 gtk_widget_destroy((GtkWidget
*)file_selector
);
1004 //update current tab
1005 //update_traceset(mw_data);
1007 //get_traceset_time_span(mw_data,LTTV_TRACESET_CONTEXT(mw_data->current_tab->traceset_info->traceset_context)->Time_Span);
1009 lttv_traceset_number(mw_data
->current_tab
->traceset_info
->traceset
) == 1
1010 || ltt_time_compare(mw_data
->current_tab
->current_time
,
1011 LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->traceset_info
->
1012 traceset_context
)->time_span
.start_time
)<0)
1014 /* Set initial time if this is the first trace in the traceset */
1015 mw_data
->current_tab
->current_time
=
1016 LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->traceset_info
->
1017 traceset_context
)->time_span
.start_time
;
1018 mw_data
->current_tab
->time_window
.start_time
=
1019 mw_data
->current_tab
->current_time
;
1020 mw_data
->current_tab
->time_window
.time_width
.tv_sec
=
1021 DEFAULT_TIME_WIDTH_S
;
1022 mw_data
->current_tab
->time_window
.time_width
.tv_nsec
= 0;
1025 /* Call the updatetraceset hooks */
1027 SetTraceset(mw_data
->current_tab
, traceset
);
1028 // in expose now call_pending_read_hooks(mw_data);
1030 //lttvwindow_report_current_time(mw_data,&(mw_data->current_tab->current_time));
1032 case GTK_RESPONSE_REJECT
:
1033 case GTK_RESPONSE_CANCEL
:
1035 gtk_widget_destroy((GtkWidget
*)file_selector
);
1041 /* remove_trace_into_traceset_selector, each instance of a viewer has an associated
1042 * selector (filter), when a trace is remove from traceset, the selector should
1043 * reflect the change. The function is used to update the selector
1046 void remove_trace_from_traceset_selector(GtkMultiVPaned
* paned
, unsigned i
)
1048 LttvTracesetSelector
* s
;
1049 LttvTraceSelector
* t
;
1052 w
= gtk_multi_vpaned_get_first_widget(paned
);
1054 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
1056 t
= lttv_traceset_selector_trace_get(s
,i
);
1057 lttv_traceset_selector_trace_remove(s
, i
);
1058 lttv_trace_selector_destroy(t
);
1059 }g_warning("Module dose not support filtering\n");
1060 w
= gtk_multi_vpaned_get_next_widget(paned
);
1065 /* remove_trace removes a trace from the current traceset if all viewers in
1066 * the current tab are not interested in the trace. It first displays a
1067 * dialogue, which shows all traces in the current traceset, to let user choose
1068 * a trace, then it checks if all viewers unselect the trace, if it is true,
1069 * it will remove the trace, recreate the traceset_contex,
1070 * and redraws all the viewer of the current tab. If there is on trace in the
1071 * current traceset, it will delete all viewers of the current tab
1074 void remove_trace(GtkWidget
* widget
, gpointer user_data
)
1077 LttvTrace
* trace_v
;
1078 LttvTraceset
* traceset
;
1079 gint i
, j
, nb_trace
;
1080 char ** name
, *remove_trace_name
;
1081 MainWindow
* mw_data
= get_window_data_struct(widget
);
1082 LttvTracesetSelector
* s
;
1083 LttvTraceSelector
* t
;
1087 nb_trace
=lttv_traceset_number(mw_data
->current_tab
->traceset_info
->traceset
);
1088 name
= g_new(char*,nb_trace
);
1089 for(i
= 0; i
< nb_trace
; i
++){
1090 trace_v
= lttv_traceset_get(mw_data
->current_tab
->
1091 traceset_info
->traceset
, i
);
1092 trace
= lttv_trace(trace_v
);
1093 name
[i
] = ltt_trace_name(trace
);
1096 remove_trace_name
= get_remove_trace(name
, nb_trace
);
1098 if(remove_trace_name
){
1099 for(i
=0; i
<nb_trace
; i
++){
1100 if(strcmp(remove_trace_name
,name
[i
]) == 0){
1101 //unselect the trace from the current viewer
1102 w
= gtk_multi_vpaned_get_widget(mw_data
->current_tab
->multi_vpaned
);
1104 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
1106 t
= lttv_traceset_selector_trace_get(s
,i
);
1107 lttv_trace_selector_set_selected(t
, FALSE
);
1110 //check if other viewers select the trace
1111 w
= gtk_multi_vpaned_get_first_widget(mw_data
->current_tab
->multi_vpaned
);
1113 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
1115 t
= lttv_traceset_selector_trace_get(s
,i
);
1116 selected
= lttv_trace_selector_get_selected(t
);
1119 w
= gtk_multi_vpaned_get_next_widget(mw_data
->current_tab
->multi_vpaned
);
1121 }else selected
= FALSE
;
1123 //if no viewer selects the trace, remove it
1125 remove_trace_from_traceset_selector(mw_data
->current_tab
->multi_vpaned
, i
);
1127 traceset
= mw_data
->current_tab
->traceset_info
->traceset
;
1128 trace_v
= lttv_traceset_get(traceset
, i
);
1129 if(lttv_trace_get_ref_number(trace_v
) <= 1)
1130 ltt_trace_close(lttv_trace(trace_v
));
1132 //Keep a reference to the traces so they are not freed.
1133 for(j
=0; j
<lttv_traceset_number(traceset
); j
++)
1135 LttvTrace
* trace
= lttv_traceset_get(traceset
, j
);
1136 lttv_trace_ref(trace
);
1139 //remove state update hooks
1140 lttv_state_remove_event_hooks(
1141 (LttvTracesetState
*)mw_data
->current_tab
->traceset_info
->traceset_context
);
1142 lttv_context_fini(LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->traceset_info
->traceset_context
));
1143 g_object_unref(mw_data
->current_tab
->traceset_info
->traceset_context
);
1146 lttv_traceset_remove(traceset
, i
);
1147 lttv_trace_unref(trace_v
); // Remove local reference
1148 if(!lttv_trace_get_ref_number(trace_v
))
1149 lttv_trace_destroy(trace_v
);
1151 mw_data
->current_tab
->traceset_info
->traceset_context
=
1152 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
1154 LTTV_TRACESET_CONTEXT(mw_data
->current_tab
->
1155 traceset_info
->traceset_context
),traceset
);
1156 //add state update hooks
1157 lttv_state_add_event_hooks(
1158 (LttvTracesetState
*)mw_data
->current_tab
->traceset_info
->traceset_context
);
1160 //Remove local reference to the traces.
1161 for(j
=0; j
<lttv_traceset_number(traceset
); j
++)
1163 LttvTrace
* trace
= lttv_traceset_get(traceset
, j
);
1164 lttv_trace_unref(trace
);
1168 //update current tab
1169 //update_traceset(mw_data);
1172 SetTraceset(mw_data
, (gpointer
)traceset
);
1173 // in expose now call_pending_read_hooks(mw_data);
1175 //lttvwindow_report_current_time(mw_data,&(mw_data->current_tab->current_time));
1177 if(mw_data
->current_tab
){
1178 while(mw_data
->current_tab
->multi_vpaned
->num_children
){
1179 gtk_multi_vpaned_widget_delete(mw_data
->current_tab
->multi_vpaned
);
1193 /* save will save the traceset to a file
1194 * Not implemented yet FIXME
1197 void save(GtkWidget
* widget
, gpointer user_data
)
1202 void save_as(GtkWidget
* widget
, gpointer user_data
)
1204 g_printf("Save as\n");
1208 /* zoom will change the time_window of all the viewers of the
1209 * current tab, and redisplay them. The main functionality is to
1210 * determine the new time_window of the current tab
1213 void zoom(GtkWidget
* widget
, double size
)
1215 TimeInterval
*time_span
;
1216 TimeWindow new_time_window
;
1217 LttTime current_time
, time_delta
, time_s
, time_e
, time_tmp
;
1218 MainWindow
* mw_data
= get_window_data_struct(widget
);
1219 Tab
*tab
= mw_data
->current_tab
;
1220 LttvTracesetContext
*tsc
=
1221 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
1223 if(size
== 1) return;
1225 time_span
= &tsc
->time_span
;
1226 new_time_window
= tab
->time_window
;
1227 current_time
= tab
->current_time
;
1229 time_delta
= ltt_time_sub(time_span
->end_time
,time_span
->start_time
);
1231 new_time_window
.start_time
= time_span
->start_time
;
1232 new_time_window
.time_width
= time_delta
;
1234 new_time_window
.time_width
= ltt_time_div(new_time_window
.time_width
, size
);
1235 if(ltt_time_compare(new_time_window
.time_width
,time_delta
) > 0)
1236 { /* Case where zoom out is bigger than trace length */
1237 new_time_window
.start_time
= time_span
->start_time
;
1238 new_time_window
.time_width
= time_delta
;
1242 /* Center the image on the current time */
1243 g_critical("update is HERE");
1244 new_time_window
.start_time
=
1245 ltt_time_sub(current_time
, ltt_time_div(new_time_window
.time_width
, 2.0));
1246 /* If on borders, don't fall off */
1247 if(ltt_time_compare(new_time_window
.start_time
, time_span
->start_time
) <0)
1249 new_time_window
.start_time
= time_span
->start_time
;
1253 if(ltt_time_compare(
1254 ltt_time_add(new_time_window
.start_time
, new_time_window
.time_width
),
1255 time_span
->end_time
) > 0)
1257 new_time_window
.start_time
=
1258 ltt_time_sub(time_span
->end_time
, new_time_window
.time_width
);
1266 //time_tmp = ltt_time_div(new_time_window.time_width, 2);
1267 //if(ltt_time_compare(current_time, time_tmp) < 0){
1268 // time_s = time_span->startTime;
1270 // time_s = ltt_time_sub(current_time,time_tmp);
1272 //time_e = ltt_time_add(current_time,time_tmp);
1273 //if(ltt_time_compare(time_span->startTime, time_s) > 0){
1274 // time_s = time_span->startTime;
1275 //}else if(ltt_time_compare(time_span->endTime, time_e) < 0){
1276 // time_e = time_span->endTime;
1277 // time_s = ltt_time_sub(time_e,new_time_window.time_width);
1279 //new_time_window.start_time = time_s;
1282 //lttvwindow_report_time_window(mw_data, &new_time_window);
1283 //call_pending_read_hooks(mw_data);
1285 //lttvwindow_report_current_time(mw_data,&(mw_data->current_tab->current_time));
1286 set_time_window(tab
, &new_time_window
);
1287 // in expose now call_pending_read_hooks(mw_data);
1288 gtk_multi_vpaned_set_adjust(tab
->multi_vpaned
, &new_time_window
, FALSE
);
1291 void zoom_in(GtkWidget
* widget
, gpointer user_data
)
1296 void zoom_out(GtkWidget
* widget
, gpointer user_data
)
1301 void zoom_extended(GtkWidget
* widget
, gpointer user_data
)
1306 void go_to_time(GtkWidget
* widget
, gpointer user_data
)
1308 g_printf("Go to time\n");
1311 void show_time_frame(GtkWidget
* widget
, gpointer user_data
)
1313 g_printf("Show time frame\n");
1317 /* callback function */
1320 on_empty_traceset_activate (GtkMenuItem
*menuitem
,
1323 create_new_window((GtkWidget
*)menuitem
, user_data
, FALSE
);
1328 on_clone_traceset_activate (GtkMenuItem
*menuitem
,
1331 create_new_window((GtkWidget
*)menuitem
, user_data
, TRUE
);
1335 /* create_new_tab calls create_tab to construct a new tab in the main window
1338 void create_new_tab(GtkWidget
* widget
, gpointer user_data
){
1339 gchar label
[PATH_LENGTH
];
1340 MainWindow
* mw_data
= get_window_data_struct(widget
);
1341 GtkNotebook
* notebook
= (GtkNotebook
*)lookup_widget(widget
, "MNotebook");
1342 if(notebook
== NULL
){
1343 g_printf("Notebook does not exist\n");
1347 strcpy(label
,"Page");
1348 if(get_label(mw_data
, label
,"Get the name of the tab","Please input tab's name"))
1349 create_tab (NULL
, mw_data
, notebook
, label
);
1353 on_tab_activate (GtkMenuItem
*menuitem
,
1356 create_new_tab((GtkWidget
*)menuitem
, user_data
);
1361 on_open_activate (GtkMenuItem
*menuitem
,
1364 open_traceset((GtkWidget
*)menuitem
, user_data
);
1369 on_close_activate (GtkMenuItem
*menuitem
,
1372 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1373 main_window_destructor(mw_data
);
1377 /* remove the current tab from the main window if it is not the default tab
1381 on_close_tab_activate (GtkMenuItem
*menuitem
,
1386 GtkWidget
* notebook
;
1388 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1389 notebook
= lookup_widget((GtkWidget
*)menuitem
, "MNotebook");
1390 if(notebook
== NULL
){
1391 g_printf("Notebook does not exist\n");
1395 if(mw_data
->tab
== mw_data
->current_tab
){
1396 // tmp = mw_data->current_tb;
1397 // mw_data->tab = mw_data->current_tab->next;
1398 g_printf("The default TAB can not be deleted\n");
1402 while(tmp
!= mw_data
->current_tab
){
1408 gtk_notebook_remove_page((GtkNotebook
*)notebook
, count
);
1409 list
= gtk_container_get_children(GTK_CONTAINER(notebook
));
1410 if(g_list_length(list
)==1)
1411 gtk_notebook_set_show_tabs((GtkNotebook
*)notebook
, FALSE
);
1416 on_add_trace_activate (GtkMenuItem
*menuitem
,
1419 add_trace((GtkWidget
*)menuitem
, user_data
);
1424 on_remove_trace_activate (GtkMenuItem
*menuitem
,
1427 remove_trace((GtkWidget
*)menuitem
, user_data
);
1432 on_save_activate (GtkMenuItem
*menuitem
,
1435 save((GtkWidget
*)menuitem
, user_data
);
1440 on_save_as_activate (GtkMenuItem
*menuitem
,
1443 save_as((GtkWidget
*)menuitem
, user_data
);
1448 on_quit_activate (GtkMenuItem
*menuitem
,
1456 on_cut_activate (GtkMenuItem
*menuitem
,
1464 on_copy_activate (GtkMenuItem
*menuitem
,
1467 g_printf("Copye\n");
1472 on_paste_activate (GtkMenuItem
*menuitem
,
1475 g_printf("Paste\n");
1480 on_delete_activate (GtkMenuItem
*menuitem
,
1483 g_printf("Delete\n");
1488 on_zoom_in_activate (GtkMenuItem
*menuitem
,
1491 zoom_in((GtkWidget
*)menuitem
, user_data
);
1496 on_zoom_out_activate (GtkMenuItem
*menuitem
,
1499 zoom_out((GtkWidget
*)menuitem
, user_data
);
1504 on_zoom_extended_activate (GtkMenuItem
*menuitem
,
1507 zoom_extended((GtkWidget
*)menuitem
, user_data
);
1512 on_go_to_time_activate (GtkMenuItem
*menuitem
,
1515 go_to_time((GtkWidget
*)menuitem
, user_data
);
1520 on_show_time_frame_activate (GtkMenuItem
*menuitem
,
1523 show_time_frame((GtkWidget
*)menuitem
, user_data
);
1528 on_move_viewer_up_activate (GtkMenuItem
*menuitem
,
1531 move_up_viewer((GtkWidget
*)menuitem
, user_data
);
1536 on_move_viewer_down_activate (GtkMenuItem
*menuitem
,
1539 move_down_viewer((GtkWidget
*)menuitem
, user_data
);
1544 on_remove_viewer_activate (GtkMenuItem
*menuitem
,
1547 delete_viewer((GtkWidget
*)menuitem
, user_data
);
1551 on_trace_filter_activate (GtkMenuItem
*menuitem
,
1554 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1555 LttvTracesetSelector
* s
;
1556 GtkWidget
* w
= gtk_multi_vpaned_get_widget(mw_data
->current_tab
->multi_vpaned
);
1558 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
1560 g_printf("There is no viewer yet\n");
1563 if(get_filter_selection(s
, "Configure trace and tracefile filter", "Select traces and tracefiles")){
1564 //FIXME report filter change
1565 //update_traceset(mw_data);
1566 //call_pending_read_hooks(mw_data);
1567 //lttvwindow_report_current_time(mw_data,&(mw_data->current_tab->current_time));
1572 on_trace_facility_activate (GtkMenuItem
*menuitem
,
1575 g_printf("Trace facility selector: %s\n");
1579 /* Dispaly a file selection dialogue to let user select a module, then call
1580 * lttv_module_load(), finally insert tool button and menu entry in the main window
1581 * for the loaded module
1585 on_load_module_activate (GtkMenuItem
*menuitem
,
1590 char str
[PATH_LENGTH
], *str1
;
1591 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1592 GtkFileSelection
* file_selector
= (GtkFileSelection
*)gtk_file_selection_new("Select a module");
1593 if(remember_plugins_dir
[0] != '\0')
1594 gtk_file_selection_set_filename(file_selector
, remember_plugins_dir
);
1595 gtk_file_selection_hide_fileop_buttons(file_selector
);
1598 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
1600 case GTK_RESPONSE_ACCEPT
:
1601 case GTK_RESPONSE_OK
:
1602 dir
= gtk_file_selection_get_selections (file_selector
);
1603 strncpy(str
,dir
[0],PATH_LENGTH
);
1604 strncpy(remember_plugins_dir
,dir
[0],PATH_LENGTH
);
1605 str1
= strrchr(str
,'/');
1608 str1
= strrchr(str
,'\\');
1611 lttv_module_require(str1
, NULL
);
1613 case GTK_RESPONSE_REJECT
:
1614 case GTK_RESPONSE_CANCEL
:
1616 gtk_widget_destroy((GtkWidget
*)file_selector
);
1619 g_printf("Load module: %s\n", str
);
1623 /* Display all loaded modules, let user to select a module to unload
1624 * by calling lttv_module_unload
1628 on_unload_module_activate (GtkMenuItem
*menuitem
,
1633 char *unload_module_name
;
1635 LttvLibrary
*library
;
1636 LttvLibraryInfo library_info
;
1637 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1639 name
= g_ptr_array_new();
1640 nb
= lttv_library_number();
1643 library
= lttv_library_get(i
);
1644 lttv_library_info(library
, &library_info
);
1645 if(library_info
.load_count
> 0) g_ptr_array_add(name
, library_info
.name
);
1648 unload_module_name
=get_unload_module((char **)(name
->pdata
), name
->len
);
1650 if(unload_module_name
){
1652 library
= lttv_library_get(i
);
1653 lttv_library_info(library
, &library_info
);
1654 if(strcmp(unload_module_name
, library_info
.name
) == 0){
1655 lttv_library_unload(library
);
1661 g_ptr_array_free(name
, TRUE
);
1665 /* Display a directory dialogue to let user select a path for module searching
1669 on_add_module_search_path_activate (GtkMenuItem
*menuitem
,
1672 GtkDirSelection
* file_selector
= (GtkDirSelection
*)gtk_dir_selection_new("Select module path");
1676 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1677 if(remember_plugins_dir
[0] != '\0')
1678 gtk_dir_selection_set_filename(file_selector
, remember_plugins_dir
);
1680 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
1682 case GTK_RESPONSE_ACCEPT
:
1683 case GTK_RESPONSE_OK
:
1684 dir
= gtk_dir_selection_get_dir (file_selector
);
1685 strncpy(remember_plugins_dir
,dir
,PATH_LENGTH
);
1686 strncat(remember_plugins_dir
,"/",PATH_LENGTH
);
1687 lttv_library_path_add(dir
);
1688 case GTK_RESPONSE_REJECT
:
1689 case GTK_RESPONSE_CANCEL
:
1691 gtk_widget_destroy((GtkWidget
*)file_selector
);
1698 on_color_activate (GtkMenuItem
*menuitem
,
1701 g_printf("Color\n");
1706 on_filter_activate (GtkMenuItem
*menuitem
,
1709 g_printf("Filter\n");
1714 on_save_configuration_activate (GtkMenuItem
*menuitem
,
1717 g_printf("Save configuration\n");
1722 on_content_activate (GtkMenuItem
*menuitem
,
1725 g_printf("Content\n");
1730 on_about_activate (GtkMenuItem
*menuitem
,
1733 g_printf("About...\n");
1738 on_button_new_clicked (GtkButton
*button
,
1741 create_new_window((GtkWidget
*)button
, user_data
, TRUE
);
1745 on_button_new_tab_clicked (GtkButton
*button
,
1748 create_new_tab((GtkWidget
*)button
, user_data
);
1752 on_button_open_clicked (GtkButton
*button
,
1755 open_traceset((GtkWidget
*)button
, user_data
);
1760 on_button_add_trace_clicked (GtkButton
*button
,
1763 add_trace((GtkWidget
*)button
, user_data
);
1768 on_button_remove_trace_clicked (GtkButton
*button
,
1771 remove_trace((GtkWidget
*)button
, user_data
);
1776 on_button_save_clicked (GtkButton
*button
,
1779 save((GtkWidget
*)button
, user_data
);
1784 on_button_save_as_clicked (GtkButton
*button
,
1787 save_as((GtkWidget
*)button
, user_data
);
1792 on_button_zoom_in_clicked (GtkButton
*button
,
1795 zoom_in((GtkWidget
*)button
, user_data
);
1800 on_button_zoom_out_clicked (GtkButton
*button
,
1803 zoom_out((GtkWidget
*)button
, user_data
);
1808 on_button_zoom_extended_clicked (GtkButton
*button
,
1811 zoom_extended((GtkWidget
*)button
, user_data
);
1816 on_button_go_to_time_clicked (GtkButton
*button
,
1819 go_to_time((GtkWidget
*)button
, user_data
);
1824 on_button_show_time_frame_clicked (GtkButton
*button
,
1827 show_time_frame((GtkWidget
*)button
, user_data
);
1832 on_button_move_up_clicked (GtkButton
*button
,
1835 move_up_viewer((GtkWidget
*)button
, user_data
);
1840 on_button_move_down_clicked (GtkButton
*button
,
1843 move_down_viewer((GtkWidget
*)button
, user_data
);
1848 on_button_delete_viewer_clicked (GtkButton
*button
,
1851 delete_viewer((GtkWidget
*)button
, user_data
);
1855 on_MWindow_destroy (GtkWidget
*widget
,
1858 MainWindow
*main_window
= get_window_data_struct(widget
);
1859 LttvIAttribute
*attributes
= main_window
->attributes
;
1860 LttvAttributeValue value
;
1862 //This is unnecessary, since widgets will be destroyed
1863 //by the main window widget anyway.
1864 //remove_all_menu_toolbar_constructors(main_window, NULL);
1866 g_assert(lttv_iattribute_find_by_path(attributes
,
1867 "viewers/menu", LTTV_POINTER
, &value
));
1868 lttv_menus_destroy((LttvMenus
*)*(value
.v_pointer
));
1870 g_assert(lttv_iattribute_find_by_path(attributes
,
1871 "viewers/toolbar", LTTV_POINTER
, &value
));
1872 lttv_toolbars_destroy((LttvToolbars
*)*(value
.v_pointer
));
1874 g_object_unref(main_window
->attributes
);
1875 g_main_window_list
= g_slist_remove(g_main_window_list
, main_window
);
1877 g_printf("There are now : %d windows\n",g_slist_length(g_main_window_list
));
1878 if(g_slist_length(g_main_window_list
) == 0)
1883 on_MWindow_configure (GtkWidget
*widget
,
1884 GdkEventConfigure
*event
,
1887 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)widget
);
1888 float width
= event
->width
;
1889 Tab
* tab
= mw_data
->tab
;
1890 TimeWindow time_win
;
1892 TimeInterval
*time_span
;
1895 // MD : removed time width modification upon resizing of the main window.
1896 // The viewers will redraw themselves completely, without time interval
1899 if(mw_data->window_width){
1900 time_span = LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->Time_Span ;
1901 time_win = tab->time_window;
1902 ratio = width / mw_data->window_width;
1903 tab->time_window.time_width = ltt_time_mul(time_win.time_width,ratio);
1904 time = ltt_time_sub(time_span->endTime, time_win.start_time);
1905 if(ltt_time_compare(time, tab->time_window.time_width) < 0){
1906 tab->time_window.time_width = time;
1912 mw_data->window_width = (int)width;
1921 on_MNotebook_switch_page (GtkNotebook
*notebook
,
1922 GtkNotebookPage
*page
,
1926 MainWindow
* mw
= get_window_data_struct((GtkWidget
*)notebook
);
1927 Tab
* tab
= mw
->tab
;
1933 mw
->current_tab
= tab
;
1937 /* callback function to check or uncheck the check box (filter)
1940 void checkbox_changed(GtkTreeView
*treeview
,
1942 GtkTreeViewColumn
*arg2
,
1945 GtkTreeStore
* store
= (GtkTreeStore
*)gtk_tree_view_get_model (treeview
);
1949 if (gtk_tree_model_get_iter ((GtkTreeModel
*)store
, &iter
, arg1
)){
1950 gtk_tree_model_get ((GtkTreeModel
*)store
, &iter
, CHECKBOX_COLUMN
, &value
, -1);
1951 value
= value
? FALSE
: TRUE
;
1952 gtk_tree_store_set (GTK_TREE_STORE (store
), &iter
, CHECKBOX_COLUMN
, value
, -1);
1958 /* According to user's selection, update selector(filter)
1961 void update_filter(LttvTracesetSelector
*s
, GtkTreeStore
*store
)
1963 GtkTreeIter iter
, child_iter
, child_iter1
, child_iter2
;
1964 int i
, j
, k
, nb_eventtype
;
1965 LttvTraceSelector
* trace
;
1966 LttvTracefileSelector
* tracefile
;
1967 LttvEventtypeSelector
* eventtype
;
1968 gboolean value
, value1
, value2
;
1970 if(gtk_tree_model_get_iter_first((GtkTreeModel
*)store
, &iter
)){
1973 trace
= lttv_traceset_selector_trace_get(s
, i
);
1974 nb_eventtype
= lttv_trace_selector_eventtype_number(trace
);
1975 gtk_tree_model_get ((GtkTreeModel
*)store
, &iter
, CHECKBOX_COLUMN
, &value
,-1);
1978 if(gtk_tree_model_iter_children ((GtkTreeModel
*)store
, &child_iter
, &iter
)){
1980 if(j
<1){//eventtype selector for trace
1981 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter
, CHECKBOX_COLUMN
, &value2
,-1);
1984 if(gtk_tree_model_iter_children ((GtkTreeModel
*)store
, &child_iter1
, &child_iter
)){
1986 eventtype
= lttv_trace_selector_eventtype_get(trace
,k
);
1987 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter1
, CHECKBOX_COLUMN
, &value2
,-1);
1988 lttv_eventtype_selector_set_selected(eventtype
,value2
);
1990 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &child_iter1
));
1993 }else{ //tracefile selector
1994 tracefile
= lttv_trace_selector_tracefile_get(trace
, j
- 1);
1995 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter
, CHECKBOX_COLUMN
, &value1
,-1);
1996 lttv_tracefile_selector_set_selected(tracefile
,value1
);
1998 gtk_tree_model_iter_children((GtkTreeModel
*)store
, &child_iter1
, &child_iter
); //eventtype selector
1999 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter1
, CHECKBOX_COLUMN
, &value2
,-1);
2002 if(gtk_tree_model_iter_children ((GtkTreeModel
*)store
, &child_iter2
, &child_iter1
)){
2003 do{//eventtype selector for tracefile
2004 eventtype
= lttv_tracefile_selector_eventtype_get(tracefile
,k
);
2005 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter2
, CHECKBOX_COLUMN
, &value2
,-1);
2006 lttv_eventtype_selector_set_selected(eventtype
,value2
);
2008 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &child_iter2
));
2014 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &child_iter
));
2017 lttv_trace_selector_set_selected(trace
,value
);
2019 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &iter
));
2024 /* Display a dialogue showing all eventtypes and traces, let user to select the interested
2025 * eventtypes, tracefiles and traces (filter)
2028 gboolean
get_filter_selection(LttvTracesetSelector
*s
,char *title
, char * column_title
)
2030 GtkWidget
* dialogue
;
2031 GtkTreeStore
* store
;
2033 GtkWidget
* scroll_win
;
2034 GtkCellRenderer
* renderer
;
2035 GtkTreeViewColumn
* column
;
2036 GtkTreeIter iter
, child_iter
, child_iter1
, child_iter2
;
2037 int i
, j
, k
, id
, nb_trace
, nb_tracefile
, nb_eventtype
;
2038 LttvTraceSelector
* trace
;
2039 LttvTracefileSelector
* tracefile
;
2040 LttvEventtypeSelector
* eventtype
;
2044 dialogue
= gtk_dialog_new_with_buttons(title
,
2047 GTK_STOCK_OK
,GTK_RESPONSE_ACCEPT
,
2048 GTK_STOCK_CANCEL
,GTK_RESPONSE_REJECT
,
2050 gtk_window_set_default_size((GtkWindow
*)dialogue
, 300, 500);
2052 store
= gtk_tree_store_new (TOTAL_COLUMNS
, G_TYPE_BOOLEAN
, G_TYPE_STRING
);
2053 tree
= gtk_tree_view_new_with_model (GTK_TREE_MODEL (store
));
2054 g_object_unref (G_OBJECT (store
));
2055 g_signal_connect (G_OBJECT (tree
), "row-activated",
2056 G_CALLBACK (checkbox_changed
),
2060 renderer
= gtk_cell_renderer_toggle_new ();
2061 gtk_cell_renderer_toggle_set_radio((GtkCellRendererToggle
*)renderer
, FALSE
);
2063 g_object_set (G_OBJECT (renderer
),"activatable", TRUE
, NULL
);
2065 column
= gtk_tree_view_column_new_with_attributes ("Checkbox",
2067 "active", CHECKBOX_COLUMN
,
2069 gtk_tree_view_column_set_alignment (column
, 0.5);
2070 gtk_tree_view_column_set_fixed_width (column
, 20);
2071 gtk_tree_view_append_column (GTK_TREE_VIEW (tree
), column
);
2073 renderer
= gtk_cell_renderer_text_new ();
2074 column
= gtk_tree_view_column_new_with_attributes (column_title
,
2076 "text", NAME_COLUMN
,
2078 gtk_tree_view_column_set_alignment (column
, 0.0);
2079 gtk_tree_view_append_column (GTK_TREE_VIEW (tree
), column
);
2080 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW (tree
), FALSE
);
2082 scroll_win
= gtk_scrolled_window_new (NULL
, NULL
);
2083 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win
),
2084 GTK_POLICY_AUTOMATIC
,GTK_POLICY_AUTOMATIC
);
2085 gtk_container_add (GTK_CONTAINER (scroll_win
), tree
);
2087 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), scroll_win
,TRUE
, TRUE
,0);
2089 gtk_widget_show(scroll_win
);
2090 gtk_widget_show(tree
);
2092 nb_trace
= lttv_traceset_selector_trace_number(s
);
2093 for(i
=0;i
<nb_trace
;i
++){
2094 trace
= lttv_traceset_selector_trace_get(s
, i
);
2095 name
= lttv_trace_selector_get_name(trace
);
2096 gtk_tree_store_append (store
, &iter
, NULL
);
2097 checked
= lttv_trace_selector_get_selected(trace
);
2098 gtk_tree_store_set (store
, &iter
,
2099 CHECKBOX_COLUMN
,checked
,
2103 gtk_tree_store_append (store
, &child_iter
, &iter
);
2104 gtk_tree_store_set (store
, &child_iter
,
2105 CHECKBOX_COLUMN
, checked
,
2106 NAME_COLUMN
,"eventtype",
2109 nb_eventtype
= lttv_trace_selector_eventtype_number(trace
);
2110 for(j
=0;j
<nb_eventtype
;j
++){
2111 eventtype
= lttv_trace_selector_eventtype_get(trace
,j
);
2112 name
= lttv_eventtype_selector_get_name(eventtype
);
2113 checked
= lttv_eventtype_selector_get_selected(eventtype
);
2114 gtk_tree_store_append (store
, &child_iter1
, &child_iter
);
2115 gtk_tree_store_set (store
, &child_iter1
,
2116 CHECKBOX_COLUMN
, checked
,
2121 nb_tracefile
= lttv_trace_selector_tracefile_number(trace
);
2122 for(j
=0;j
<nb_tracefile
;j
++){
2123 tracefile
= lttv_trace_selector_tracefile_get(trace
, j
);
2124 name
= lttv_tracefile_selector_get_name(tracefile
);
2125 gtk_tree_store_append (store
, &child_iter
, &iter
);
2126 checked
= lttv_tracefile_selector_get_selected(tracefile
);
2127 gtk_tree_store_set (store
, &child_iter
,
2128 CHECKBOX_COLUMN
, checked
,
2132 gtk_tree_store_append (store
, &child_iter1
, &child_iter
);
2133 gtk_tree_store_set (store
, &child_iter1
,
2134 CHECKBOX_COLUMN
, checked
,
2135 NAME_COLUMN
,"eventtype",
2138 for(k
=0;k
<nb_eventtype
;k
++){
2139 eventtype
= lttv_tracefile_selector_eventtype_get(tracefile
,k
);
2140 name
= lttv_eventtype_selector_get_name(eventtype
);
2141 checked
= lttv_eventtype_selector_get_selected(eventtype
);
2142 gtk_tree_store_append (store
, &child_iter2
, &child_iter1
);
2143 gtk_tree_store_set (store
, &child_iter2
,
2144 CHECKBOX_COLUMN
, checked
,
2151 id
= gtk_dialog_run(GTK_DIALOG(dialogue
));
2153 case GTK_RESPONSE_ACCEPT
:
2154 case GTK_RESPONSE_OK
:
2155 update_filter(s
, store
);
2156 gtk_widget_destroy(dialogue
);
2158 case GTK_RESPONSE_REJECT
:
2159 case GTK_RESPONSE_CANCEL
:
2161 gtk_widget_destroy(dialogue
);
2168 /* Select a trace which will be removed from traceset
2171 char * get_remove_trace(char ** all_trace_name
, int nb_trace
)
2173 return get_selection(all_trace_name
, nb_trace
,
2174 "Select a trace", "Trace pathname");
2178 /* Select a module which will be unloaded
2181 char * get_unload_module(char ** loaded_module_name
, int nb_module
)
2183 return get_selection(loaded_module_name
, nb_module
,
2184 "Select an unload module", "Module pathname");
2188 /* Display a dialogue which shows all selectable items, let user to
2189 * select one of them
2192 char * get_selection(char ** loaded_module_name
, int nb_module
,
2193 char *title
, char * column_title
)
2195 GtkWidget
* dialogue
;
2196 GtkWidget
* scroll_win
;
2198 GtkListStore
* store
;
2199 GtkTreeViewColumn
* column
;
2200 GtkCellRenderer
* renderer
;
2201 GtkTreeSelection
* select
;
2204 char * unload_module_name
= NULL
;
2206 dialogue
= gtk_dialog_new_with_buttons(title
,
2209 GTK_STOCK_OK
,GTK_RESPONSE_ACCEPT
,
2210 GTK_STOCK_CANCEL
,GTK_RESPONSE_REJECT
,
2212 gtk_window_set_default_size((GtkWindow
*)dialogue
, 500, 200);
2214 scroll_win
= gtk_scrolled_window_new (NULL
, NULL
);
2215 gtk_widget_show ( scroll_win
);
2216 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win
),
2217 GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
2219 store
= gtk_list_store_new (N_COLUMNS
,G_TYPE_STRING
);
2220 tree
= gtk_tree_view_new_with_model(GTK_TREE_MODEL (store
));
2221 gtk_widget_show ( tree
);
2222 g_object_unref (G_OBJECT (store
));
2224 renderer
= gtk_cell_renderer_text_new ();
2225 column
= gtk_tree_view_column_new_with_attributes (column_title
,
2227 "text", MODULE_COLUMN
,
2229 gtk_tree_view_column_set_alignment (column
, 0.5);
2230 gtk_tree_view_column_set_fixed_width (column
, 150);
2231 gtk_tree_view_append_column (GTK_TREE_VIEW (tree
), column
);
2233 select
= gtk_tree_view_get_selection (GTK_TREE_VIEW (tree
));
2234 gtk_tree_selection_set_mode (select
, GTK_SELECTION_SINGLE
);
2236 gtk_container_add (GTK_CONTAINER (scroll_win
), tree
);
2238 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), scroll_win
,TRUE
, TRUE
,0);
2240 for(i
=0;i
<nb_module
;i
++){
2241 gtk_list_store_append (store
, &iter
);
2242 gtk_list_store_set (store
, &iter
, MODULE_COLUMN
,loaded_module_name
[i
],-1);
2245 id
= gtk_dialog_run(GTK_DIALOG(dialogue
));
2247 case GTK_RESPONSE_ACCEPT
:
2248 case GTK_RESPONSE_OK
:
2249 if (gtk_tree_selection_get_selected (select
, (GtkTreeModel
**)&store
, &iter
)){
2250 gtk_tree_model_get ((GtkTreeModel
*)store
, &iter
, MODULE_COLUMN
, &unload_module_name
, -1);
2252 case GTK_RESPONSE_REJECT
:
2253 case GTK_RESPONSE_CANCEL
:
2255 gtk_widget_destroy(dialogue
);
2259 return unload_module_name
;
2263 /* Insert all menu entry and tool buttons into this main window
2268 void add_all_menu_toolbar_constructors(MainWindow
* mw
, gpointer user_data
)
2272 lttvwindow_viewer_constructor constructor
;
2273 LttvMenus
* global_menu
, * instance_menu
;
2274 LttvToolbars
* global_toolbar
, * instance_toolbar
;
2275 LttvMenuClosure
*menu_item
;
2276 LttvToolbarClosure
*toolbar_item
;
2277 LttvAttributeValue value
;
2278 LttvIAttribute
*global_attributes
= LTTV_IATTRIBUTE(lttv_global_attributes());
2279 LttvIAttribute
*attributes
= mw
->attributes
;
2280 GtkWidget
* tool_menu_title_menu
, *new_widget
, *pixmap
;
2282 g_assert(lttv_iattribute_find_by_path(global_attributes
,
2283 "viewers/menu", LTTV_POINTER
, &value
));
2284 if(*(value
.v_pointer
) == NULL
)
2285 *(value
.v_pointer
) = lttv_menus_new();
2286 global_menu
= (LttvMenus
*)*(value
.v_pointer
);
2288 g_assert(lttv_iattribute_find_by_path(attributes
,
2289 "viewers/menu", LTTV_POINTER
, &value
));
2290 if(*(value
.v_pointer
) == NULL
)
2291 *(value
.v_pointer
) = lttv_menus_new();
2292 instance_menu
= (LttvMenus
*)*(value
.v_pointer
);
2296 g_assert(lttv_iattribute_find_by_path(global_attributes
,
2297 "viewers/toolbar", LTTV_POINTER
, &value
));
2298 if(*(value
.v_pointer
) == NULL
)
2299 *(value
.v_pointer
) = lttv_toolbars_new();
2300 global_toolbar
= (LttvToolbars
*)*(value
.v_pointer
);
2302 g_assert(lttv_iattribute_find_by_path(attributes
,
2303 "viewers/toolbar", LTTV_POINTER
, &value
));
2304 if(*(value
.v_pointer
) == NULL
)
2305 *(value
.v_pointer
) = lttv_toolbars_new();
2306 instance_toolbar
= (LttvToolbars
*)*(value
.v_pointer
);
2308 /* Add missing menu entries to window instance */
2309 for(i
=0;i
<global_menu
->len
;i
++) {
2310 menu_item
= &g_array_index(global_menu
, LttvMenuClosure
, i
);
2312 //add menu_item to window instance;
2313 constructor
= menu_item
->con
;
2314 tool_menu_title_menu
= lookup_widget(mw
->mwindow
,"ToolMenuTitle_menu");
2316 gtk_menu_item_new_with_mnemonic (menu_item
->menu_text
);
2317 gtk_container_add (GTK_CONTAINER (tool_menu_title_menu
),
2319 g_signal_connect ((gpointer
) new_widget
, "activate",
2320 G_CALLBACK (insert_viewer_wrap
),
2322 gtk_widget_show (new_widget
);
2323 lttv_menus_add(instance_menu
, menu_item
->con
,
2324 menu_item
->menu_path
,
2325 menu_item
->menu_text
,
2330 /* Add missing toolbar entries to window instance */
2331 for(i
=0;i
<global_toolbar
->len
;i
++) {
2332 toolbar_item
= &g_array_index(global_toolbar
, LttvToolbarClosure
, i
);
2334 //add toolbar_item to window instance;
2335 constructor
= toolbar_item
->con
;
2336 tool_menu_title_menu
= lookup_widget(mw
->mwindow
,"MToolbar1");
2337 pixbuf
= gdk_pixbuf_new_from_xpm_data((const char**)toolbar_item
->pixmap
);
2338 pixmap
= gtk_image_new_from_pixbuf(pixbuf
);
2340 gtk_toolbar_append_element (GTK_TOOLBAR (tool_menu_title_menu
),
2341 GTK_TOOLBAR_CHILD_BUTTON
,
2344 toolbar_item
->tooltip
, NULL
,
2345 pixmap
, NULL
, NULL
);
2346 gtk_label_set_use_underline(
2347 GTK_LABEL (((GtkToolbarChild
*) (
2348 g_list_last (GTK_TOOLBAR
2349 (tool_menu_title_menu
)->children
)->data
))->label
),
2351 gtk_container_set_border_width (GTK_CONTAINER (new_widget
), 1);
2352 g_signal_connect ((gpointer
) new_widget
,
2354 G_CALLBACK (insert_viewer_wrap
),
2356 gtk_widget_show (new_widget
);
2358 lttv_toolbars_add(instance_toolbar
, toolbar_item
->con
,
2359 toolbar_item
->tooltip
,
2360 toolbar_item
->pixmap
,
2368 /* Create a main window
2371 void construct_main_window(MainWindow
* parent
)
2373 g_debug("construct_main_window()");
2374 GtkWidget
* new_window
; /* New generated main window */
2375 MainWindow
* new_m_window
;/* New main window structure */
2376 GtkNotebook
* notebook
;
2377 LttvIAttribute
*attributes
=
2378 LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
));
2379 LttvAttributeValue value
;
2381 new_m_window
= g_new(MainWindow
, 1);
2383 // Add the object's information to the module's array
2384 g_main_window_list
= g_slist_append(g_main_window_list
, new_m_window
);
2387 new_window
= create_MWindow();
2388 gtk_widget_show (new_window
);
2390 new_m_window
->mwindow
= new_window
;
2391 new_m_window
->tab
= NULL
;
2392 new_m_window
->current_tab
= NULL
;
2393 new_m_window
->attributes
= attributes
;
2395 g_assert(lttv_iattribute_find_by_path(attributes
,
2396 "viewers/menu", LTTV_POINTER
, &value
));
2397 *(value
.v_pointer
) = lttv_menus_new();
2399 g_assert(lttv_iattribute_find_by_path(attributes
,
2400 "viewers/toolbar", LTTV_POINTER
, &value
));
2401 *(value
.v_pointer
) = lttv_toolbars_new();
2403 add_all_menu_toolbar_constructors(new_m_window
, NULL
);
2405 g_object_set_data_full(G_OBJECT(new_window
),
2407 (gpointer
)new_m_window
,
2408 (GDestroyNotify
)g_free
);
2409 //create a default tab
2410 notebook
= (GtkNotebook
*)lookup_widget(new_m_window
->mwindow
, "MNotebook");
2411 if(notebook
== NULL
){
2412 g_printf("Notebook does not exist\n");
2415 //for now there is no name field in LttvTraceset structure
2416 //Use "Traceset" as the label for the default tab
2417 create_tab(parent
, new_m_window
, notebook
, "Traceset");
2419 g_printf("There are now : %d windows\n",g_slist_length(g_main_window_list
));
2423 /* Free the memory occupied by a tab structure
2427 void tab_destructor(Tab
* tab_instance
)
2429 int i
, nb
, ref_count
;
2432 if(tab_instance
->attributes
)
2433 g_object_unref(tab_instance
->attributes
);
2435 if(tab_instance
->interrupted_state
)
2436 g_object_unref(tab_instance
->interrupted_state
);
2439 if(tab_instance
->mw
->tab
== tab_instance
){
2440 tab_instance
->mw
->tab
= tab_instance
->next
;
2442 Tab
* tmp1
, *tmp
= tab_instance
->mw
->tab
;
2443 while(tmp
!= tab_instance
){
2447 tmp1
->next
= tab_instance
->next
;
2450 if(tab_instance
->traceset_info
->traceset_context
!= NULL
){
2451 //remove state update hooks
2452 lttv_state_remove_event_hooks(
2453 (LttvTracesetState
*)tab_instance
->traceset_info
->
2455 lttv_context_fini(LTTV_TRACESET_CONTEXT(tab_instance
->traceset_info
->
2457 g_object_unref(tab_instance
->traceset_info
->traceset_context
);
2459 if(tab_instance
->traceset_info
->traceset
!= NULL
) {
2460 nb
= lttv_traceset_number(tab_instance
->traceset_info
->traceset
);
2461 for(i
= 0 ; i
< nb
; i
++) {
2462 trace
= lttv_traceset_get(tab_instance
->traceset_info
->traceset
, i
);
2463 ref_count
= lttv_trace_get_ref_number(trace
);
2465 ltt_trace_close(lttv_trace(trace
));
2466 lttv_trace_destroy(trace
);
2468 // lttv_trace_destroy(trace);
2471 lttv_traceset_destroy(tab_instance
->traceset_info
->traceset
);
2472 /* Remove the idle events requests processing function of the tab */
2473 g_idle_remove_by_data(tab_instance
);
2475 g_slist_free(tab_instance
->events_requests
);
2476 g_free(tab_instance
->traceset_info
);
2477 g_free(tab_instance
);
2481 /* Create a tab and insert it into the current main window
2484 void * create_tab(MainWindow
* parent
, MainWindow
* current_window
,
2485 GtkNotebook
* notebook
, char * label
)
2489 MainWindow
* mw_data
= current_window
;
2492 //create a new tab data structure
2493 tmp_tab
= mw_data
->tab
;
2494 while(tmp_tab
&& tmp_tab
->next
) tmp_tab
= tmp_tab
->next
;
2496 mw_data
->current_tab
= NULL
;
2497 tmp_tab
= g_new(Tab
,1);
2498 mw_data
->tab
= tmp_tab
;
2500 tmp_tab
->next
= g_new(Tab
,1);
2501 tmp_tab
= tmp_tab
->next
;
2504 //construct and initialize the traceset_info
2505 tmp_tab
->traceset_info
= g_new(TracesetInfo
,1);
2507 if(parent
->current_tab
){
2508 tmp_tab
->traceset_info
->traceset
=
2509 lttv_traceset_new();
2510 //FIXME lttv_traceset_copy(parent->current_tab->traceset_info->traceset);
2512 tmp_tab
->traceset_info
->traceset
= lttv_traceset_new();
2515 }else{ /* Initial window */
2516 if(mw_data
->current_tab
){
2517 tmp_tab
->traceset_info
->traceset
=
2518 lttv_traceset_new();
2519 //FIXME lttv_traceset_copy(mw_data->current_tab->traceset_info->traceset);
2521 tmp_tab
->traceset_info
->traceset
= lttv_traceset_new();
2522 /* Add the command line trace */
2523 if(g_init_trace
!= NULL
){
2524 lttv_traceset_add(tmp_tab
->traceset_info
->traceset
, g_init_trace
);
2529 //FIXME copy not implemented in lower level
2530 tmp_tab
->traceset_info
->traceset_context
=
2531 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
2532 g_assert(tmp_tab
->traceset_info
->traceset_context
!= NULL
);
2534 LTTV_TRACESET_CONTEXT(tmp_tab
->traceset_info
->traceset_context
),
2535 tmp_tab
->traceset_info
->traceset
);
2536 //add state update hooks
2537 lttv_state_add_event_hooks(
2538 (LttvTracesetState
*)tmp_tab
->traceset_info
->traceset_context
);
2540 //determine the current_time and time_window of the tab
2541 if(mw_data
->current_tab
){
2542 // Will have to read directly at the main window level, as we want
2543 // to be able to modify a traceset on the fly.
2544 tmp_tab
->time_window
= mw_data
->current_tab
->time_window
;
2545 tmp_tab
->current_time
= mw_data
->current_tab
->current_time
;
2547 // Will have to read directly at the main window level, as we want
2548 // to be able to modify a traceset on the fly.
2549 // get_traceset_time_span(mw_data,&tmp_tab->traceStartTime, &tmp_tab->traceEndTime);
2550 tmp_tab
->time_window
.start_time
=
2551 LTTV_TRACESET_CONTEXT(tmp_tab
->traceset_info
->traceset_context
)->time_span
.start_time
;
2552 if(DEFAULT_TIME_WIDTH_S
<
2553 LTTV_TRACESET_CONTEXT(tmp_tab
->traceset_info
->traceset_context
)->time_span
.end_time
.tv_sec
)
2554 tmp_time
.tv_sec
= DEFAULT_TIME_WIDTH_S
;
2557 LTTV_TRACESET_CONTEXT(tmp_tab
->traceset_info
->traceset_context
)->time_span
.end_time
.tv_sec
;
2558 tmp_time
.tv_nsec
= 0;
2559 tmp_tab
->time_window
.time_width
= tmp_time
;
2560 tmp_tab
->current_time
.tv_sec
=
2561 LTTV_TRACESET_CONTEXT(tmp_tab
->traceset_info
->traceset_context
)->time_span
.start_time
.tv_sec
;
2562 tmp_tab
->current_time
.tv_nsec
=
2563 LTTV_TRACESET_CONTEXT(tmp_tab
->traceset_info
->traceset_context
)->time_span
.start_time
.tv_nsec
;
2565 /* Become the current tab */
2566 mw_data
->current_tab
= tmp_tab
;
2568 tmp_tab
->attributes
= LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
));
2569 tmp_tab
->interrupted_state
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
2570 tmp_tab
->multi_vpaned
= (GtkMultiVPaned
*)gtk_multi_vpaned_new();
2571 tmp_tab
->multi_vpaned
->tab
= mw_data
->current_tab
;
2572 gtk_widget_show((GtkWidget
*)tmp_tab
->multi_vpaned
);
2573 tmp_tab
->next
= NULL
;
2574 tmp_tab
->mw
= mw_data
;
2576 tmp_tab
->label
= gtk_label_new (label
);
2577 gtk_widget_show (tmp_tab
->label
);
2579 /* Start with empty events requests list */
2580 tmp_tab
->events_requests
= NULL
;
2581 tmp_tab
->events_request_pending
= FALSE
;
2583 g_object_set_data_full(
2584 G_OBJECT(tmp_tab
->multi_vpaned
),
2587 (GDestroyNotify
)tab_destructor
);
2589 //insert tab into notebook
2590 gtk_notebook_append_page(notebook
, (GtkWidget
*)tmp_tab
->multi_vpaned
, tmp_tab
->label
);
2591 list
= gtk_container_get_children(GTK_CONTAINER(notebook
));
2592 gtk_notebook_set_current_page(notebook
,g_list_length(list
)-1);
2593 // always show : not if(g_list_length(list)>1)
2594 gtk_notebook_set_show_tabs(notebook
, TRUE
);
2599 * Function to show each viewer in the current tab.
2600 * It will be called by main window, call show on each registered viewer,
2601 * will call process traceset and then it will
2602 * @param main_win the main window the viewer belongs to.
2604 //FIXME Only one time request maximum for now!
2605 void show_viewer(MainWindow
*main_win
)
2607 LttvAttributeValue value
;
2610 LttvTracesetContext
* tsc
=
2611 (LttvTracesetContext
*)main_win
->current_tab
->
2612 traceset_info
->traceset_context
;
2614 g_assert(lttv_iattribute_find_by_path(main_win
->current_tab
->attributes
,
2615 "hooks/showviewer", LTTV_POINTER
, &value
));
2616 tmp
= (LttvHooks
*)*(value
.v_pointer
);
2619 g_warning("The viewer(s) did not add any show hook");
2624 // Call the show, where viewers add hooks to context and fill the
2625 // time and number of events requested it the time_requests GArray.
2626 lttv_hooks_call(tmp
, NULL
);
2632 * execute_events_requests
2634 * Idle function that executes the pending requests for a tab.
2636 * @return return value : TRUE : keep the idle function, FALSE : remove it.
2638 gboolean
execute_events_requests(Tab
*tab
)
2640 return ( lttvwindow_process_pending_requests(tab
) );