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 * Function to set/update traceset for the viewers
209 * @param tab viewer's tab
210 * @param traceset traceset of the main window.
212 * 0 : traceset updated
213 * 1 : no traceset hooks to update; not an error.
216 int SetTraceset(Tab
* tab
, LttvTraceset
*traceset
)
219 LttvAttributeValue value
;
221 g_assert( lttv_iattribute_find_by_path(tab
->attributes
,
222 "hooks/updatetraceset", LTTV_POINTER
, &value
));
224 tmp
= (LttvHooks
*)*(value
.v_pointer
);
225 if(tmp
== NULL
) return 1;
227 lttv_hooks_call(tmp
,traceset
);
233 * Function to set/update filter for the viewers
234 * @param tab viewer's tab
235 * @param filter filter of the main window.
238 * 0 : filters updated
239 * 1 : no filter hooks to update; not an error.
242 int SetFilter(Tab
* tab
, gpointer filter
)
245 LttvAttributeValue value
;
247 g_assert(lttv_iattribute_find_by_path(tab
->attributes
,
248 "hooks/updatefilter", LTTV_POINTER
, &value
));
250 tmp
= (LttvHooks
*)*(value
.v_pointer
);
252 if(tmp
== NULL
) return 1;
253 lttv_hooks_call(tmp
,filter
);
261 * Function to redraw each viewer belonging to the current tab
262 * @param tab viewer's tab
265 void update_traceset(Tab
*tab
)
267 LttvAttributeValue value
;
269 g_assert(lttv_iattribute_find_by_path(tab
->attributes
,
270 "hooks/updatetraceset", LTTV_POINTER
, &value
));
271 tmp
= (LttvHooks
*)*(value
.v_pointer
);
272 if(tmp
== NULL
) return;
273 lttv_hooks_call(tmp
, NULL
);
277 /* get_label function is used to get user input, it displays an input
278 * box, which allows user to input a string
281 void get_label_string (GtkWidget
* text
, gchar
* label
)
283 GtkEntry
* entry
= (GtkEntry
*)text
;
284 if(strlen(gtk_entry_get_text(entry
))!=0)
285 strcpy(label
,gtk_entry_get_text(entry
));
288 gboolean
get_label(MainWindow
* mw
, gchar
* str
, gchar
* dialogue_title
, gchar
* label_str
)
290 GtkWidget
* dialogue
;
295 dialogue
= gtk_dialog_new_with_buttons(dialogue_title
,NULL
,
297 GTK_STOCK_OK
,GTK_RESPONSE_ACCEPT
,
298 GTK_STOCK_CANCEL
,GTK_RESPONSE_REJECT
,
301 label
= gtk_label_new(label_str
);
302 gtk_widget_show(label
);
304 text
= gtk_entry_new();
305 gtk_widget_show(text
);
307 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), label
,TRUE
, TRUE
,0);
308 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), text
,FALSE
, FALSE
,0);
310 id
= gtk_dialog_run(GTK_DIALOG(dialogue
));
312 case GTK_RESPONSE_ACCEPT
:
313 get_label_string(text
,str
);
314 gtk_widget_destroy(dialogue
);
316 case GTK_RESPONSE_REJECT
:
318 gtk_widget_destroy(dialogue
);
325 /* get_window_data_struct function is actually a lookup function,
326 * given a widget which is in the tree of the main window, it will
327 * return the MainWindow data structure associated with main window
330 MainWindow
* get_window_data_struct(GtkWidget
* widget
)
333 MainWindow
* mw_data
;
335 mw
= lookup_widget(widget
, "MWindow");
337 g_printf("Main window does not exist\n");
341 mw_data
= (MainWindow
*) g_object_get_data(G_OBJECT(mw
),"main_window_data");
343 g_printf("Main window data does not exist\n");
350 /* create_new_window function, just constructs a new main window
353 void create_new_window(GtkWidget
* widget
, gpointer user_data
, gboolean clone
)
355 MainWindow
* parent
= get_window_data_struct(widget
);
358 g_printf("Clone : use the same traceset\n");
359 construct_main_window(parent
);
361 g_printf("Empty : traceset is set to NULL\n");
362 construct_main_window(NULL
);
367 /* move_*_viewer functions move the selected view up/down in
371 void move_up_viewer(GtkWidget
* widget
, gpointer user_data
)
373 MainWindow
* mw
= get_window_data_struct(widget
);
374 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
376 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
377 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
384 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
387 gtk_multi_vpaned_widget_move_up(tab
->multi_vpaned
);
390 void move_down_viewer(GtkWidget
* widget
, gpointer user_data
)
392 MainWindow
* mw
= get_window_data_struct(widget
);
393 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
395 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
396 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
402 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
405 gtk_multi_vpaned_widget_move_down(tab
->multi_vpaned
);
409 /* delete_viewer deletes the selected viewer in the current tab
412 void delete_viewer(GtkWidget
* widget
, gpointer user_data
)
414 MainWindow
* mw
= get_window_data_struct(widget
);
415 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
417 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
418 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
424 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
427 gtk_multi_vpaned_widget_delete(tab
->multi_vpaned
);
431 /* open_traceset will open a traceset saved in a file
432 * Right now, it is not finished yet, (not working)
436 void open_traceset(GtkWidget
* widget
, gpointer user_data
)
440 LttvTraceset
* traceset
;
441 MainWindow
* mw_data
= get_window_data_struct(widget
);
442 GtkFileSelection
* file_selector
=
443 (GtkFileSelection
*)gtk_file_selection_new("Select a traceset");
445 gtk_file_selection_hide_fileop_buttons(file_selector
);
447 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
449 case GTK_RESPONSE_ACCEPT
:
450 case GTK_RESPONSE_OK
:
451 dir
= gtk_file_selection_get_selections (file_selector
);
452 traceset
= lttv_traceset_load(dir
[0]);
453 g_printf("Open a trace set %s\n", dir
[0]);
456 case GTK_RESPONSE_REJECT
:
457 case GTK_RESPONSE_CANCEL
:
459 gtk_widget_destroy((GtkWidget
*)file_selector
);
466 /* lttvwindow_process_pending_requests
468 * This internal function gets called by g_idle, taking care of the pending
469 * requests. It is responsible for concatenation of time intervals and position
470 * requests. It does it with the following algorithm organizing process traceset
471 * calls. Here is the detailed description of the way it works :
473 * - Events Requests Servicing Algorithm
475 * Data structures necessary :
477 * List of requests added to context : list_in
478 * List of requests not added to context : list_out
483 * list_out : many events requests
485 * FIXME : insert rest of algorithm here
489 #define list_out tab->events_requests
491 gboolean
lttvwindow_process_pending_requests(Tab
*tab
)
493 unsigned max_nb_events
;
497 LttvTracesetContext
*tsc
;
498 LttvTracefileContext
*tfc
;
499 GSList
*list_in
= NULL
;
503 LttvTracesetContextPosition
*end_position
;
508 /* There is no events requests pending : we should never have been called! */
509 g_assert(g_slist_length(list_out
) != 0);
511 tsc
= LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
513 //set the cursor to be X shape, indicating that the computer is busy in doing its job
515 new = gdk_cursor_new(GDK_X_CURSOR
);
516 widget
= lookup_widget(tab
->mw
->mwindow
, "MToolbar1");
517 win
= gtk_widget_get_parent_window(widget
);
518 gdk_window_set_cursor(win
, new);
519 gdk_cursor_unref(new);
520 gdk_window_stick(win
);
521 gdk_window_unstick(win
);
524 g_debug("SIZE events req len : %d", g_slist_length(list_out
));
526 /* Preliminary check for no trace in traceset */
527 /* Unregister the routine if empty, empty list_out too */
528 if(lttv_traceset_number(tsc
->ts
) == 0) {
530 /* - For each req in list_out */
531 GSList
*iter
= list_out
;
533 while(iter
!= NULL
) {
535 gboolean remove
= FALSE
;
536 gboolean free_data
= FALSE
;
537 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
539 /* - Call end request for req */
540 if(events_request
->servicing
== TRUE
)
541 lttv_hooks_call(events_request
->after_request
, (gpointer
)tsc
);
543 /* - remove req from list_out */
544 /* Destroy the request */
551 GSList
*remove_iter
= iter
;
553 iter
= g_slist_next(iter
);
554 if(free_data
) g_free(remove_iter
->data
);
555 list_out
= g_slist_remove_link(list_out
, remove_iter
);
556 } else { // not remove
557 iter
= g_slist_next(iter
);
562 /* Events processing algorithm implementation */
563 /* A. Servicing loop */
564 while( (g_slist_length(list_in
) != 0 || g_slist_length(list_out
) != 0)) {
565 /* && !gtk_events_pending() ) */
567 /* 1. If list_in is empty (need a seek) */
568 if( g_slist_length(list_in
) == 0 ) {
570 /* list in is empty, need a seek */
572 /* 1.1 Add requests to list_in */
573 GSList
*ltime
= NULL
;
577 /* 1.1.1 Find all time requests with the lowest start time in list_out
580 if(g_slist_length(list_out
) > 0)
581 ltime
= g_slist_append(ltime
, g_slist_nth_data(list_out
, 0));
582 for(iter
=g_slist_nth(list_out
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
583 /* Find all time requests with the lowest start time in list_out */
584 guint index_ltime
= g_array_index(ltime
, guint
, 0);
585 EventsRequest
*event_request_ltime
= (EventsRequest
*)g_slist_nth_data(ltime
, 0);
586 EventsRequest
*event_request_list_out
= (EventsRequest
*)iter
->data
;
589 comp
= ltt_time_compare(event_request_ltime
->start_time
,
590 event_request_list_out
->start_time
);
592 ltime
= g_slist_append(ltime
, event_request_list_out
);
594 /* Remove all elements from ltime, and add current */
596 ltime
= g_slist_delete_link(ltime
, g_slist_nth(ltime
, 0));
597 ltime
= g_slist_append(ltime
, event_request_list_out
);
601 /* 1.1.2 Find all position requests with the lowest position in list_out
604 if(g_slist_length(list_out
) > 0)
605 lpos
= g_slist_append(lpos
, g_slist_nth_data(list_out
, 0));
606 for(iter
=g_slist_nth(list_out
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
607 /* Find all position requests with the lowest position in list_out */
608 EventsRequest
*event_request_lpos
= (EventsRequest
*)g_slist_nth_data(lpos
, 0);
609 EventsRequest
*event_request_list_out
= (EventsRequest
*)iter
->data
;
612 if(event_request_lpos
->start_position
!= NULL
613 && event_request_list_out
->start_position
!= NULL
)
615 comp
= lttv_traceset_context_pos_pos_compare
616 (event_request_lpos
->start_position
,
617 event_request_list_out
->start_position
);
622 lpos
= g_slist_append(lpos
, event_request_list_out
);
624 /* Remove all elements from lpos, and add current */
626 lpos
= g_slist_delete_link(lpos
, g_slist_nth(lpos
, 0));
627 lpos
= g_slist_append(lpos
, event_request_list_out
);
632 EventsRequest
*event_request_lpos
= (EventsRequest
*)g_slist_nth_data(lpos
, 0);
633 EventsRequest
*event_request_ltime
= (EventsRequest
*)g_slist_nth_data(ltime
, 0);
634 LttTime lpos_start_time
;
636 if(event_request_lpos
!= NULL
637 && event_request_lpos
->start_position
!= NULL
) {
638 lpos_start_time
= lttv_traceset_context_position_get_time(
639 event_request_lpos
->start_position
);
642 /* 1.1.3 If lpos.start time < ltime */
643 if(event_request_lpos
!= NULL
644 && event_request_lpos
->start_position
!= NULL
645 && ltt_time_compare(lpos_start_time
,
646 event_request_ltime
->start_time
)<0) {
647 /* Add lpos to list_in, remove them from list_out */
648 for(iter
=lpos
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
650 EventsRequest
*event_request_lpos
=
651 (EventsRequest
*)iter
->data
;
653 list_in
= g_slist_append(list_in
, event_request_lpos
);
654 /* Remove from list_out */
655 list_out
= g_slist_remove(list_out
, event_request_lpos
);
658 /* 1.1.4 (lpos.start time >= ltime) */
659 /* Add ltime to list_in, remove them from list_out */
661 for(iter
=ltime
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
663 EventsRequest
*event_request_ltime
=
664 (EventsRequest
*)iter
->data
;
666 list_in
= g_slist_append(list_in
, event_request_ltime
);
667 /* Remove from list_out */
668 list_out
= g_slist_remove(list_out
, event_request_ltime
);
678 tfc
= lttv_traceset_context_get_current_tfc(tsc
);
679 g_assert(g_slist_length(list_in
)>0);
680 EventsRequest
*events_request
= g_slist_nth_data(list_in
, 0);
683 /* 1.2.1 If first request in list_in is a time request */
684 if(events_request
->start_position
== NULL
) {
685 /* - If first req in list_in start time != current time */
686 if(tfc
== NULL
|| ltt_time_compare(events_request
->start_time
,
687 tfc
->timestamp
) != 0)
688 /* - Seek to that time */
689 g_debug("SEEK TIME : %lu, %lu", events_request
->start_time
.tv_sec
,
690 events_request
->start_time
.tv_nsec
);
691 //lttv_process_traceset_seek_time(tsc, events_request->start_time);
692 lttv_state_traceset_seek_time_closest(LTTV_TRACESET_STATE(tsc
),
693 events_request
->start_time
);
695 /* Process the traceset with only state hooks */
697 lttv_process_traceset_middle(tsc
,
698 events_request
->start_time
,
704 /* Else, the first request in list_in is a position request */
705 /* If first req in list_in pos != current pos */
706 g_assert(events_request
->start_position
!= NULL
);
707 g_debug("SEEK POS time : %lu, %lu",
708 lttv_traceset_context_position_get_time(events_request
->start_position
).tv_sec
,
709 lttv_traceset_context_position_get_time(events_request
->start_position
).tv_nsec
);
711 g_debug("SEEK POS context time : %lu, %lu",
712 lttv_traceset_context_get_current_tfc(tsc
)->timestamp
.tv_sec
,
713 lttv_traceset_context_get_current_tfc(tsc
)->timestamp
.tv_nsec
);
714 if(lttv_traceset_context_ctx_pos_compare(tsc
,
715 events_request
->start_position
) != 0) {
716 /* 1.2.2.1 Seek to that position */
717 g_debug("SEEK POSITION");
718 //lttv_process_traceset_seek_position(tsc, events_request->start_position);
719 pos_time
= lttv_traceset_context_position_get_time(events_request
->start_position
);
721 lttv_state_traceset_seek_time_closest(LTTV_TRACESET_STATE(tsc
),
724 /* Process the traceset with only state hooks */
726 lttv_process_traceset_middle(tsc
,
729 events_request
->start_position
);
736 /* 1.3 Add hooks and call before request for all list_in members */
740 for(iter
=list_in
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
741 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
742 /* 1.3.1 If !servicing */
743 if(events_request
->servicing
== FALSE
) {
744 /* - begin request hooks called
747 lttv_hooks_call(events_request
->before_request
, (gpointer
)tsc
);
748 events_request
->servicing
= TRUE
;
750 /* 1.3.2 call before chunk
751 * 1.3.3 events hooks added
753 lttv_process_traceset_begin(tsc
, events_request
->before_chunk_traceset
,
754 events_request
->before_chunk_trace
,
755 events_request
->before_chunk_tracefile
,
756 events_request
->event
,
757 events_request
->event_by_id
);
761 /* 2. Else, list_in is not empty, we continue a read */
764 /* 2.0 For each req of list_in */
765 GSList
*iter
= list_in
;
767 while(iter
!= NULL
) {
769 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
771 /* - Call before chunk
772 * - events hooks added
774 lttv_process_traceset_begin(tsc
, events_request
->before_chunk_traceset
,
775 events_request
->before_chunk_trace
,
776 events_request
->before_chunk_tracefile
,
777 events_request
->event
,
778 events_request
->event_by_id
);
780 iter
= g_slist_next(iter
);
785 tfc
= lttv_traceset_context_get_current_tfc(tsc
);
787 /* 2.1 For each req of list_out */
788 GSList
*iter
= list_out
;
790 while(iter
!= NULL
) {
792 gboolean remove
= FALSE
;
793 gboolean free_data
= FALSE
;
794 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
796 /* if req.start time == current context time
797 * or req.start position == current position*/
798 if( ltt_time_compare(events_request
->start_time
,
801 (events_request
->start_position
!= NULL
803 lttv_traceset_context_ctx_pos_compare(tsc
,
804 events_request
->start_position
) == 0)
806 /* - Add to list_in, remove from list_out */
807 list_in
= g_slist_append(list_in
, events_request
);
811 /* - If !servicing */
812 if(events_request
->servicing
== FALSE
) {
813 /* - begin request hooks called
816 lttv_hooks_call(events_request
->before_request
, (gpointer
)tsc
);
817 events_request
->servicing
= TRUE
;
822 lttv_process_traceset_begin(tsc
, events_request
->before_chunk_traceset
,
823 events_request
->before_chunk_trace
,
824 events_request
->before_chunk_tracefile
,
825 events_request
->event
,
826 events_request
->event_by_id
);
832 GSList
*remove_iter
= iter
;
834 iter
= g_slist_next(iter
);
835 if(free_data
) g_free(remove_iter
->data
);
836 list_out
= g_slist_remove_link(list_out
, remove_iter
);
837 } else { // not remove
838 iter
= g_slist_next(iter
);
844 /* 3. Find end criterions */
849 /* 3.1.1 Find lowest end time in list_in */
850 g_assert(g_slist_length(list_in
)>0);
851 end_time
= ((EventsRequest
*)g_slist_nth_data(list_in
,0))->end_time
;
853 for(iter
=g_slist_nth(list_in
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
854 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
856 if(ltt_time_compare(events_request
->end_time
,
858 end_time
= events_request
->end_time
;
861 /* 3.1.2 Find lowest start time in list_out */
862 for(iter
=list_out
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
863 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
865 if(ltt_time_compare(events_request
->start_time
,
867 end_time
= events_request
->start_time
;
872 /* 3.2 Number of events */
874 /* 3.2.1 Find lowest number of events in list_in */
877 end_nb_events
= ((EventsRequest
*)g_slist_nth_data(list_in
,0))->num_events
;
879 for(iter
=g_slist_nth(list_in
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
880 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
882 if(events_request
->num_events
< end_nb_events
)
883 end_nb_events
= events_request
->num_events
;
886 /* 3.2.2 Use min(CHUNK_NUM_EVENTS, min num events in list_in) as
889 end_nb_events
= MIN(CHUNK_NUM_EVENTS
, end_nb_events
);
893 /* 3.3 End position */
895 /* 3.3.1 Find lowest end position in list_in */
898 end_position
=((EventsRequest
*)g_slist_nth_data(list_in
,0))->end_position
;
900 for(iter
=g_slist_nth(list_in
,1);iter
!=NULL
;iter
=g_slist_next(iter
)) {
901 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
903 if(events_request
->end_position
!= NULL
&& end_position
!= NULL
&&
904 lttv_traceset_context_pos_pos_compare(events_request
->end_position
,
906 end_position
= events_request
->end_position
;
911 /* 3.3.2 Find lowest start position in list_out */
914 for(iter
=list_out
;iter
!=NULL
;iter
=g_slist_next(iter
)) {
915 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
917 if(events_request
->end_position
!= NULL
&& end_position
!= NULL
&&
918 lttv_traceset_context_pos_pos_compare(events_request
->end_position
,
920 end_position
= events_request
->end_position
;
925 /* 4. Call process traceset middle */
926 g_critical("Calling process traceset middle with %p, %lu sec %lu nsec, %lu nb ev, %p end pos", tsc
, end_time
.tv_sec
, end_time
.tv_nsec
, end_nb_events
, end_position
);
927 count
= lttv_process_traceset_middle(tsc
, end_time
, end_nb_events
, end_position
);
929 tfc
= lttv_traceset_context_get_current_tfc(tsc
);
930 g_critical("Context time after middle : %lu, %lu", tfc
->timestamp
.tv_sec
,
931 tfc
->timestamp
.tv_nsec
);
935 /* 5. After process traceset middle */
936 tfc
= lttv_traceset_context_get_current_tfc(tsc
);
938 /* - if current context time > traceset.end time */
939 if(tfc
== NULL
|| ltt_time_compare(tfc
->timestamp
,
940 tsc
->time_span
.end_time
) > 0) {
941 /* - For each req in list_in */
942 GSList
*iter
= list_in
;
944 while(iter
!= NULL
) {
946 gboolean remove
= FALSE
;
947 gboolean free_data
= FALSE
;
948 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
950 /* - Remove events hooks for req
951 * - Call end chunk for req
953 lttv_process_traceset_end(tsc
, events_request
->after_chunk_traceset
,
954 events_request
->after_chunk_trace
,
955 events_request
->after_chunk_tracefile
,
956 events_request
->event
,
957 events_request
->event_by_id
);
958 /* - Call end request for req */
959 lttv_hooks_call(events_request
->after_request
, (gpointer
)tsc
);
961 /* - remove req from list_in */
962 /* Destroy the request */
969 GSList
*remove_iter
= iter
;
971 iter
= g_slist_next(iter
);
972 if(free_data
) g_free(remove_iter
->data
);
973 list_in
= g_slist_remove_link(list_in
, remove_iter
);
974 } else { // not remove
975 iter
= g_slist_next(iter
);
980 /* 5.1 For each req in list_in */
981 GSList
*iter
= list_in
;
983 while(iter
!= NULL
) {
985 gboolean remove
= FALSE
;
986 gboolean free_data
= FALSE
;
987 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
989 /* - Remove events hooks for req
990 * - Call end chunk for req
992 lttv_process_traceset_end(tsc
, events_request
->after_chunk_traceset
,
993 events_request
->after_chunk_trace
,
994 events_request
->after_chunk_tracefile
,
995 events_request
->event
,
996 events_request
->event_by_id
);
998 /* - req.num -= count */
999 g_assert(events_request
->num_events
>= count
);
1000 events_request
->num_events
-= count
;
1002 g_assert(tfc
!= NULL
);
1003 /* - if req.num == 0
1005 * current context time >= req.end time
1007 * req.end pos == current pos
1009 * req.stop_flag == TRUE
1011 if( events_request
->num_events
== 0
1013 events_request
->stop_flag
== TRUE
1015 ltt_time_compare(tfc
->timestamp
,
1016 events_request
->end_time
) >= 0
1018 (events_request
->end_position
!= NULL
1020 lttv_traceset_context_ctx_pos_compare(tsc
,
1021 events_request
->end_position
) != 0)
1024 g_assert(events_request
->servicing
== TRUE
);
1025 /* - Call end request for req
1026 * - remove req from list_in */
1027 lttv_hooks_call(events_request
->after_request
, (gpointer
)tsc
);
1028 /* - remove req from list_in */
1029 /* Destroy the request */
1037 GSList
*remove_iter
= iter
;
1039 iter
= g_slist_next(iter
);
1040 if(free_data
) g_free(remove_iter
->data
);
1041 list_in
= g_slist_remove_link(list_in
, remove_iter
);
1042 } else { // not remove
1043 iter
= g_slist_next(iter
);
1049 if(gtk_events_pending()) break;
1052 /* B. When interrupted between chunks */
1055 GSList
*iter
= list_in
;
1057 /* 1. for each request in list_in */
1058 while(iter
!= NULL
) {
1060 gboolean remove
= FALSE
;
1061 gboolean free_data
= FALSE
;
1062 EventsRequest
*events_request
= (EventsRequest
*)iter
->data
;
1064 /* 1.1. Use current postition as start position */
1065 if(events_request
->start_position
!= NULL
)
1066 lttv_traceset_context_position_destroy(events_request
->start_position
);
1067 events_request
->start_position
= ltt_traceset_context_position_new();
1068 lttv_traceset_context_position_save(tsc
, events_request
->start_position
);
1070 /* 1.2. Remove start time */
1071 events_request
->start_time
.tv_sec
= G_MAXUINT
;
1072 events_request
->start_time
.tv_nsec
= G_MAXUINT
;
1074 /* 1.3. Move from list_in to list_out */
1077 list_out
= g_slist_append(list_out
, events_request
);
1082 GSList
*remove_iter
= iter
;
1084 iter
= g_slist_next(iter
);
1085 if(free_data
) g_free(remove_iter
->data
);
1086 list_in
= g_slist_remove_link(list_in
, remove_iter
);
1087 } else { // not remove
1088 iter
= g_slist_next(iter
);
1096 //set the cursor back to normal
1097 gdk_window_set_cursor(win
, NULL
);
1100 g_assert(g_slist_length(list_in
) == 0);
1102 if( g_slist_length(list_out
) == 0 ) {
1103 /* Put tab's request pending flag back to normal */
1104 tab
->events_request_pending
= FALSE
;
1105 g_critical("remove the idle fct");
1106 return FALSE
; /* Remove the idle function */
1108 g_critical("leave the idle fct");
1109 return TRUE
; /* Leave the idle function */
1115 /* add_trace_into_traceset_selector, each instance of a viewer has an associated
1116 * selector (filter), when a trace is added into traceset, the selector should
1117 * reflect the change. The function is used to update the selector
1120 void add_trace_into_traceset_selector(GtkMultiVPaned
* paned
, LttTrace
* t
)
1122 int j
, k
, m
, nb_tracefile
, nb_control
, nb_per_cpu
, nb_facility
, nb_event
;
1123 LttvTracesetSelector
* s
;
1124 LttvTraceSelector
* trace
;
1125 LttvTracefileSelector
* tracefile
;
1126 LttvEventtypeSelector
* eventtype
;
1132 w
= gtk_multi_vpaned_get_first_widget(paned
);
1134 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
1137 trace
= lttv_trace_selector_new(t
);
1138 lttv_traceset_selector_trace_add(s
, trace
);
1140 nb_facility
= ltt_trace_facility_number(t
);
1141 for(k
=0;k
<nb_facility
;k
++){
1142 fac
= ltt_trace_facility_get(t
,k
);
1143 nb_event
= (int) ltt_facility_eventtype_number(fac
);
1144 for(m
=0;m
<nb_event
;m
++){
1145 et
= ltt_facility_eventtype_get(fac
,m
);
1146 eventtype
= lttv_eventtype_selector_new(et
);
1147 lttv_trace_selector_eventtype_add(trace
, eventtype
);
1151 nb_control
= ltt_trace_control_tracefile_number(t
);
1152 nb_per_cpu
= ltt_trace_per_cpu_tracefile_number(t
);
1153 nb_tracefile
= nb_control
+ nb_per_cpu
;
1155 for(j
= 0 ; j
< nb_tracefile
; j
++) {
1157 tf
= ltt_trace_control_tracefile_get(t
, j
);
1159 tf
= ltt_trace_per_cpu_tracefile_get(t
, j
- nb_control
);
1160 tracefile
= lttv_tracefile_selector_new(tf
);
1161 lttv_trace_selector_tracefile_add(trace
, tracefile
);
1162 lttv_eventtype_selector_copy(trace
, tracefile
);
1164 }else g_warning("Module does not support filtering\n");
1166 w
= gtk_multi_vpaned_get_next_widget(paned
);
1171 static void lttvwindow_add_trace(Tab
*tab
, LttvTrace
*trace_v
)
1173 LttvTraceset
*traceset
= tab
->traceset_info
->traceset
;
1176 //Verify if trace is already present.
1177 for(i
=0; i
<lttv_traceset_number(traceset
); i
++)
1179 LttvTrace
* trace
= lttv_traceset_get(traceset
, i
);
1180 if(trace
== trace_v
)
1184 //Keep a reference to the traces so they are not freed.
1185 for(i
=0; i
<lttv_traceset_number(traceset
); i
++)
1187 LttvTrace
* trace
= lttv_traceset_get(traceset
, i
);
1188 lttv_trace_ref(trace
);
1191 //remove state update hooks
1192 lttv_state_remove_event_hooks(
1193 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1195 lttv_context_fini(LTTV_TRACESET_CONTEXT(
1196 tab
->traceset_info
->traceset_context
));
1197 g_object_unref(tab
->traceset_info
->traceset_context
);
1199 lttv_traceset_add(traceset
, trace_v
);
1200 lttv_trace_ref(trace_v
); /* local ref */
1202 /* Create new context */
1203 tab
->traceset_info
->traceset_context
=
1204 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
1206 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->
1210 /* Set the tab's time window and current time if currently 0, 0 */
1211 if(tab
->time_window
.start_time
.tv_sec
== 0 &&
1212 tab
->time_window
.start_time
.tv_nsec
== 0)
1213 tab
->time_window
.start_time
=
1214 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
1215 time_span
.start_time
;
1216 if(tab
->time_window
.time_width
.tv_sec
== 0 &&
1217 tab
->time_window
.time_width
.tv_nsec
== 0) {
1220 if(DEFAULT_TIME_WIDTH_S
<
1221 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
1222 time_span
.end_time
.tv_sec
)
1223 tmp_time
.tv_sec
= DEFAULT_TIME_WIDTH_S
;
1226 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
1227 time_span
.end_time
.tv_sec
;
1228 tmp_time
.tv_nsec
= 0;
1229 tab
->time_window
.time_width
= tmp_time
;
1231 if(tab
->current_time
.tv_sec
== 0 && tab
->current_time
.tv_nsec
== 0) {
1232 tab
->current_time
.tv_sec
=
1233 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
1234 time_span
.start_time
.tv_sec
;
1235 tab
->current_time
.tv_nsec
=
1236 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
1237 time_span
.start_time
.tv_nsec
;
1241 //add state update hooks
1242 lttv_state_add_event_hooks(
1243 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1244 //Remove local reference to the traces.
1245 for(i
=0; i
<lttv_traceset_number(traceset
); i
++)
1247 LttvTrace
* trace
= lttv_traceset_get(traceset
, i
);
1248 lttv_trace_unref(trace
);
1251 add_trace_into_traceset_selector(tab
->multi_vpaned
, lttv_trace(trace_v
));
1254 /* add_trace adds a trace into the current traceset. It first displays a
1255 * directory selection dialogue to let user choose a trace, then recreates
1256 * tracset_context, and redraws all the viewer of the current tab
1259 void add_trace(GtkWidget
* widget
, gpointer user_data
)
1262 LttvTrace
* trace_v
;
1263 LttvTraceset
* traceset
;
1265 char abs_path
[PATH_MAX
];
1268 MainWindow
* mw_data
= get_window_data_struct(widget
);
1269 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
1271 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1272 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1276 tab
= create_new_tab(widget
, NULL
);
1278 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1281 GtkDirSelection
* file_selector
= (GtkDirSelection
*)gtk_dir_selection_new("Select a trace");
1282 gtk_dir_selection_hide_fileop_buttons(file_selector
);
1284 if(remember_trace_dir
[0] != '\0')
1285 gtk_dir_selection_set_filename(file_selector
, remember_trace_dir
);
1287 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
1289 case GTK_RESPONSE_ACCEPT
:
1290 case GTK_RESPONSE_OK
:
1291 dir
= gtk_dir_selection_get_dir (file_selector
);
1292 strncpy(remember_trace_dir
, dir
, PATH_MAX
);
1293 if(!dir
|| strlen(dir
) == 0){
1294 gtk_widget_destroy((GtkWidget
*)file_selector
);
1297 get_absolute_pathname(dir
, abs_path
);
1298 trace_v
= lttvwindowtraces_get_trace_by_name(abs_path
);
1299 if(trace_v
== NULL
) {
1300 trace
= ltt_trace_open(abs_path
);
1302 g_warning("cannot open trace %s", abs_path
);
1304 trace_v
= lttv_trace_new(trace
);
1305 lttvwindowtraces_add_trace(trace_v
);
1306 lttvwindow_add_trace(tab
, trace_v
);
1309 lttvwindow_add_trace(tab
, trace_v
);
1312 gtk_widget_destroy((GtkWidget
*)file_selector
);
1314 //update current tab
1315 //update_traceset(mw_data);
1317 /* Call the updatetraceset hooks */
1319 traceset
= tab
->traceset_info
->traceset
;
1320 SetTraceset(tab
, traceset
);
1321 // in expose now call_pending_read_hooks(mw_data);
1323 //lttvwindow_report_current_time(mw_data,&(tab->current_time));
1325 case GTK_RESPONSE_REJECT
:
1326 case GTK_RESPONSE_CANCEL
:
1328 gtk_widget_destroy((GtkWidget
*)file_selector
);
1334 /* remove_trace_into_traceset_selector, each instance of a viewer has an associated
1335 * selector (filter), when a trace is remove from traceset, the selector should
1336 * reflect the change. The function is used to update the selector
1339 void remove_trace_from_traceset_selector(GtkMultiVPaned
* paned
, unsigned i
)
1341 LttvTracesetSelector
* s
;
1342 LttvTraceSelector
* t
;
1345 w
= gtk_multi_vpaned_get_first_widget(paned
);
1347 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
1349 t
= lttv_traceset_selector_trace_get(s
,i
);
1350 lttv_traceset_selector_trace_remove(s
, i
);
1351 lttv_trace_selector_destroy(t
);
1352 }g_warning("Module dose not support filtering\n");
1353 w
= gtk_multi_vpaned_get_next_widget(paned
);
1358 /* remove_trace removes a trace from the current traceset if all viewers in
1359 * the current tab are not interested in the trace. It first displays a
1360 * dialogue, which shows all traces in the current traceset, to let user choose
1361 * a trace, then it checks if all viewers unselect the trace, if it is true,
1362 * it will remove the trace, recreate the traceset_contex,
1363 * and redraws all the viewer of the current tab. If there is on trace in the
1364 * current traceset, it will delete all viewers of the current tab
1367 void remove_trace(GtkWidget
* widget
, gpointer user_data
)
1370 LttvTrace
* trace_v
;
1371 LttvTraceset
* traceset
;
1372 gint i
, j
, nb_trace
;
1373 char ** name
, *remove_trace_name
;
1374 MainWindow
* mw_data
= get_window_data_struct(widget
);
1375 LttvTracesetSelector
* s
;
1376 LttvTraceSelector
* t
;
1379 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
1381 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1382 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1388 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1391 nb_trace
=lttv_traceset_number(tab
->traceset_info
->traceset
);
1392 name
= g_new(char*,nb_trace
);
1393 for(i
= 0; i
< nb_trace
; i
++){
1394 trace_v
= lttv_traceset_get(tab
->traceset_info
->traceset
, i
);
1395 trace
= lttv_trace(trace_v
);
1396 name
[i
] = ltt_trace_name(trace
);
1399 remove_trace_name
= get_remove_trace(name
, nb_trace
);
1401 if(remove_trace_name
){
1402 for(i
=0; i
<nb_trace
; i
++){
1403 if(strcmp(remove_trace_name
,name
[i
]) == 0){
1404 //unselect the trace from the current viewer
1405 w
= gtk_multi_vpaned_get_widget(tab
->multi_vpaned
);
1407 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
1409 t
= lttv_traceset_selector_trace_get(s
,i
);
1410 lttv_trace_selector_set_selected(t
, FALSE
);
1413 //check if other viewers select the trace
1414 w
= gtk_multi_vpaned_get_first_widget(tab
->multi_vpaned
);
1416 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
1418 t
= lttv_traceset_selector_trace_get(s
,i
);
1419 selected
= lttv_trace_selector_get_selected(t
);
1422 w
= gtk_multi_vpaned_get_next_widget(tab
->multi_vpaned
);
1424 }else selected
= FALSE
;
1426 //if no viewer selects the trace, remove it
1428 remove_trace_from_traceset_selector(tab
->multi_vpaned
, i
);
1430 traceset
= tab
->traceset_info
->traceset
;
1431 //Keep a reference to the traces so they are not freed.
1432 for(j
=0; j
<lttv_traceset_number(traceset
); j
++)
1434 LttvTrace
* trace
= lttv_traceset_get(traceset
, j
);
1435 lttv_trace_ref(trace
);
1438 //remove state update hooks
1439 lttv_state_remove_event_hooks(
1440 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1441 lttv_context_fini(LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
));
1442 g_object_unref(tab
->traceset_info
->traceset_context
);
1445 trace_v
= lttv_traceset_get(traceset
, i
);
1447 if(lttv_trace_get_ref_number(trace_v
) <= 2) {
1448 /* ref 2 : traceset, local */
1449 lttvwindowtraces_remove_trace(trace_v
);
1450 ltt_trace_close(lttv_trace(trace_v
));
1453 lttv_traceset_remove(traceset
, i
);
1454 lttv_trace_unref(trace_v
); // Remove local reference
1456 if(!lttv_trace_get_ref_number(trace_v
))
1457 lttv_trace_destroy(trace_v
);
1459 tab
->traceset_info
->traceset_context
=
1460 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
1462 LTTV_TRACESET_CONTEXT(tab
->
1463 traceset_info
->traceset_context
),traceset
);
1464 //add state update hooks
1465 lttv_state_add_event_hooks(
1466 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
1468 //Remove local reference to the traces.
1469 for(j
=0; j
<lttv_traceset_number(traceset
); j
++)
1471 LttvTrace
* trace
= lttv_traceset_get(traceset
, j
);
1472 lttv_trace_unref(trace
);
1476 //update current tab
1477 //update_traceset(mw_data);
1480 SetTraceset(tab
, (gpointer
)traceset
);
1481 // in expose now call_pending_read_hooks(mw_data);
1483 //lttvwindow_report_current_time(mw_data,&(tab->current_time));
1486 // while(tab->multi_vpaned->num_children){
1487 // gtk_multi_vpaned_widget_delete(tab->multi_vpaned);
1501 /* Redraw all the viewers in the current tab */
1502 void redraw(GtkWidget
*widget
, gpointer user_data
)
1504 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
1505 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1506 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1511 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1515 LttvAttributeValue value
;
1517 g_assert(lttv_iattribute_find_by_path(tab
->attributes
, "hooks/redraw", LTTV_POINTER
, &value
));
1519 tmp
= (LttvHooks
*)*(value
.v_pointer
);
1521 lttv_hooks_call(tmp
,NULL
);
1525 void continue_processing(GtkWidget
*widget
, gpointer user_data
)
1527 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
1528 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1529 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1534 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1538 LttvAttributeValue value
;
1540 g_assert(lttv_iattribute_find_by_path(tab
->attributes
,
1541 "hooks/continue", LTTV_POINTER
, &value
));
1543 tmp
= (LttvHooks
*)*(value
.v_pointer
);
1545 lttv_hooks_call(tmp
,NULL
);
1548 /* Stop the processing for the calling main window's current tab.
1549 * It removes every processing requests that are in its list. It does not call
1550 * the end request hooks, because the request is not finished.
1553 void stop_processing(GtkWidget
*widget
, gpointer user_data
)
1555 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
1556 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1557 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1562 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1564 GSList
*iter
= tab
->events_requests
;
1566 while(iter
!= NULL
) {
1567 GSList
*remove_iter
= iter
;
1568 iter
= g_slist_next(iter
);
1570 g_free(remove_iter
->data
);
1571 tab
->events_requests
=
1572 g_slist_remove_link(tab
->events_requests
, remove_iter
);
1574 tab
->events_request_pending
= FALSE
;
1575 g_idle_remove_by_data(tab
);
1576 g_assert(g_slist_length(tab
->events_requests
) == 0);
1580 /* save will save the traceset to a file
1581 * Not implemented yet FIXME
1584 void save(GtkWidget
* widget
, gpointer user_data
)
1589 void save_as(GtkWidget
* widget
, gpointer user_data
)
1591 g_printf("Save as\n");
1595 /* zoom will change the time_window of all the viewers of the
1596 * current tab, and redisplay them. The main functionality is to
1597 * determine the new time_window of the current tab
1600 void zoom(GtkWidget
* widget
, double size
)
1602 TimeInterval
*time_span
;
1603 TimeWindow new_time_window
;
1604 LttTime current_time
, time_delta
, time_s
, time_e
, time_tmp
;
1605 MainWindow
* mw_data
= get_window_data_struct(widget
);
1606 LttvTracesetContext
*tsc
;
1607 GtkWidget
* notebook
= lookup_widget(widget
, "MNotebook");
1609 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1610 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1616 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1619 if(size
== 1) return;
1621 tsc
= LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
);
1622 time_span
= &tsc
->time_span
;
1623 new_time_window
= tab
->time_window
;
1624 current_time
= tab
->current_time
;
1626 time_delta
= ltt_time_sub(time_span
->end_time
,time_span
->start_time
);
1628 new_time_window
.start_time
= time_span
->start_time
;
1629 new_time_window
.time_width
= time_delta
;
1631 new_time_window
.time_width
= ltt_time_div(new_time_window
.time_width
, size
);
1632 if(ltt_time_compare(new_time_window
.time_width
,time_delta
) > 0)
1633 { /* Case where zoom out is bigger than trace length */
1634 new_time_window
.start_time
= time_span
->start_time
;
1635 new_time_window
.time_width
= time_delta
;
1639 /* Center the image on the current time */
1640 new_time_window
.start_time
=
1641 ltt_time_sub(current_time
, ltt_time_div(new_time_window
.time_width
, 2.0));
1642 /* If on borders, don't fall off */
1643 if(ltt_time_compare(new_time_window
.start_time
, time_span
->start_time
) <0)
1645 new_time_window
.start_time
= time_span
->start_time
;
1649 if(ltt_time_compare(
1650 ltt_time_add(new_time_window
.start_time
, new_time_window
.time_width
),
1651 time_span
->end_time
) > 0)
1653 new_time_window
.start_time
=
1654 ltt_time_sub(time_span
->end_time
, new_time_window
.time_width
);
1662 //time_tmp = ltt_time_div(new_time_window.time_width, 2);
1663 //if(ltt_time_compare(current_time, time_tmp) < 0){
1664 // time_s = time_span->startTime;
1666 // time_s = ltt_time_sub(current_time,time_tmp);
1668 //time_e = ltt_time_add(current_time,time_tmp);
1669 //if(ltt_time_compare(time_span->startTime, time_s) > 0){
1670 // time_s = time_span->startTime;
1671 //}else if(ltt_time_compare(time_span->endTime, time_e) < 0){
1672 // time_e = time_span->endTime;
1673 // time_s = ltt_time_sub(time_e,new_time_window.time_width);
1675 //new_time_window.start_time = time_s;
1678 //lttvwindow_report_time_window(mw_data, &new_time_window);
1679 //call_pending_read_hooks(mw_data);
1681 //lttvwindow_report_current_time(mw_data,&(tab->current_time));
1682 set_time_window(tab
, &new_time_window
);
1683 // in expose now call_pending_read_hooks(mw_data);
1684 gtk_multi_vpaned_set_adjust(tab
->multi_vpaned
, &new_time_window
, FALSE
);
1687 void zoom_in(GtkWidget
* widget
, gpointer user_data
)
1692 void zoom_out(GtkWidget
* widget
, gpointer user_data
)
1697 void zoom_extended(GtkWidget
* widget
, gpointer user_data
)
1702 void go_to_time(GtkWidget
* widget
, gpointer user_data
)
1704 g_printf("Go to time\n");
1707 void show_time_frame(GtkWidget
* widget
, gpointer user_data
)
1709 g_printf("Show time frame\n");
1713 /* callback function */
1716 on_empty_traceset_activate (GtkMenuItem
*menuitem
,
1719 create_new_window((GtkWidget
*)menuitem
, user_data
, FALSE
);
1724 on_clone_traceset_activate (GtkMenuItem
*menuitem
,
1727 create_new_window((GtkWidget
*)menuitem
, user_data
, TRUE
);
1731 /* create_new_tab calls create_tab to construct a new tab in the main window
1734 Tab
*create_new_tab(GtkWidget
* widget
, gpointer user_data
){
1735 gchar label
[PATH_MAX
];
1736 MainWindow
* mw_data
= get_window_data_struct(widget
);
1738 GtkNotebook
* notebook
= (GtkNotebook
*)lookup_widget(widget
, "MNotebook");
1739 if(notebook
== NULL
){
1740 g_printf("Notebook does not exist\n");
1743 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1744 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1750 copy_tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1753 strcpy(label
,"Page");
1754 if(get_label(mw_data
, label
,"Get the name of the tab","Please input tab's name"))
1755 return (create_tab (mw_data
, copy_tab
, notebook
, label
));
1759 on_tab_activate (GtkMenuItem
*menuitem
,
1762 create_new_tab((GtkWidget
*)menuitem
, user_data
);
1767 on_open_activate (GtkMenuItem
*menuitem
,
1770 open_traceset((GtkWidget
*)menuitem
, user_data
);
1775 on_close_activate (GtkMenuItem
*menuitem
,
1778 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1779 main_window_destructor(mw_data
);
1783 /* remove the current tab from the main window
1787 on_close_tab_activate (GtkWidget
*widget
,
1791 GtkWidget
* notebook
;
1793 MainWindow
* mw_data
= get_window_data_struct(widget
);
1794 notebook
= lookup_widget(widget
, "MNotebook");
1795 if(notebook
== NULL
){
1796 g_printf("Notebook does not exist\n");
1800 page_num
= gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
));
1802 gtk_notebook_remove_page(GTK_NOTEBOOK(notebook
), page_num
);
1807 on_close_tab_X_clicked (GtkWidget
*widget
,
1811 GtkWidget
*notebook
= lookup_widget(widget
, "MNotebook");
1812 if(notebook
== NULL
){
1813 g_printf("Notebook does not exist\n");
1817 if((page_num
= gtk_notebook_page_num(GTK_NOTEBOOK(notebook
), widget
)) != -1)
1818 gtk_notebook_remove_page(GTK_NOTEBOOK(notebook
), page_num
);
1824 on_add_trace_activate (GtkMenuItem
*menuitem
,
1827 add_trace((GtkWidget
*)menuitem
, user_data
);
1832 on_remove_trace_activate (GtkMenuItem
*menuitem
,
1835 remove_trace((GtkWidget
*)menuitem
, user_data
);
1840 on_save_activate (GtkMenuItem
*menuitem
,
1843 save((GtkWidget
*)menuitem
, user_data
);
1848 on_save_as_activate (GtkMenuItem
*menuitem
,
1851 save_as((GtkWidget
*)menuitem
, user_data
);
1856 on_quit_activate (GtkMenuItem
*menuitem
,
1864 on_cut_activate (GtkMenuItem
*menuitem
,
1872 on_copy_activate (GtkMenuItem
*menuitem
,
1875 g_printf("Copye\n");
1880 on_paste_activate (GtkMenuItem
*menuitem
,
1883 g_printf("Paste\n");
1888 on_delete_activate (GtkMenuItem
*menuitem
,
1891 g_printf("Delete\n");
1896 on_zoom_in_activate (GtkMenuItem
*menuitem
,
1899 zoom_in((GtkWidget
*)menuitem
, user_data
);
1904 on_zoom_out_activate (GtkMenuItem
*menuitem
,
1907 zoom_out((GtkWidget
*)menuitem
, user_data
);
1912 on_zoom_extended_activate (GtkMenuItem
*menuitem
,
1915 zoom_extended((GtkWidget
*)menuitem
, user_data
);
1920 on_go_to_time_activate (GtkMenuItem
*menuitem
,
1923 go_to_time((GtkWidget
*)menuitem
, user_data
);
1928 on_show_time_frame_activate (GtkMenuItem
*menuitem
,
1931 show_time_frame((GtkWidget
*)menuitem
, user_data
);
1936 on_move_viewer_up_activate (GtkMenuItem
*menuitem
,
1939 move_up_viewer((GtkWidget
*)menuitem
, user_data
);
1944 on_move_viewer_down_activate (GtkMenuItem
*menuitem
,
1947 move_down_viewer((GtkWidget
*)menuitem
, user_data
);
1952 on_remove_viewer_activate (GtkMenuItem
*menuitem
,
1955 delete_viewer((GtkWidget
*)menuitem
, user_data
);
1959 on_trace_filter_activate (GtkMenuItem
*menuitem
,
1962 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
1963 LttvTracesetSelector
* s
;
1965 GtkWidget
* notebook
= lookup_widget(GTK_WIDGET(menuitem
), "MNotebook");
1967 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook
),
1968 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook
)));
1974 tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
1977 w
= gtk_multi_vpaned_get_widget(tab
->multi_vpaned
);
1979 s
= g_object_get_data(G_OBJECT(w
), "Traceset_Selector");
1981 g_printf("There is no viewer yet\n");
1984 if(get_filter_selection(s
, "Configure trace and tracefile filter", "Select traces and tracefiles")){
1985 //FIXME report filter change
1986 //update_traceset(mw_data);
1987 //call_pending_read_hooks(mw_data);
1988 //lttvwindow_report_current_time(mw_data,&(tab->current_time));
1993 on_trace_facility_activate (GtkMenuItem
*menuitem
,
1996 g_printf("Trace facility selector: %s\n");
2000 /* Dispaly a file selection dialogue to let user select a module, then call
2001 * lttv_module_load(), finally insert tool button and menu entry in the main window
2002 * for the loaded module
2006 on_load_module_activate (GtkMenuItem
*menuitem
,
2011 char str
[PATH_MAX
], *str1
;
2012 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2013 GtkFileSelection
* file_selector
= (GtkFileSelection
*)gtk_file_selection_new("Select a module");
2014 if(remember_plugins_dir
[0] != '\0')
2015 gtk_file_selection_set_filename(file_selector
, remember_plugins_dir
);
2016 gtk_file_selection_hide_fileop_buttons(file_selector
);
2019 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
2021 case GTK_RESPONSE_ACCEPT
:
2022 case GTK_RESPONSE_OK
:
2023 dir
= gtk_file_selection_get_selections (file_selector
);
2024 strncpy(str
,dir
[0],PATH_MAX
);
2025 strncpy(remember_plugins_dir
,dir
[0],PATH_MAX
);
2026 str1
= strrchr(str
,'/');
2029 str1
= strrchr(str
,'\\');
2032 lttv_module_require(str1
, NULL
);
2034 case GTK_RESPONSE_REJECT
:
2035 case GTK_RESPONSE_CANCEL
:
2037 gtk_widget_destroy((GtkWidget
*)file_selector
);
2040 g_printf("Load module: %s\n", str
);
2044 /* Display all loaded modules, let user to select a module to unload
2045 * by calling lttv_module_unload
2049 on_unload_module_activate (GtkMenuItem
*menuitem
,
2054 char *unload_module_name
;
2056 LttvLibrary
*library
;
2057 LttvLibraryInfo library_info
;
2058 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2060 name
= g_ptr_array_new();
2061 nb
= lttv_library_number();
2064 library
= lttv_library_get(i
);
2065 lttv_library_info(library
, &library_info
);
2066 if(library_info
.load_count
> 0) g_ptr_array_add(name
, library_info
.name
);
2069 unload_module_name
=get_unload_module((char **)(name
->pdata
), name
->len
);
2071 if(unload_module_name
){
2073 library
= lttv_library_get(i
);
2074 lttv_library_info(library
, &library_info
);
2075 if(strcmp(unload_module_name
, library_info
.name
) == 0){
2076 lttv_library_unload(library
);
2082 g_ptr_array_free(name
, TRUE
);
2086 /* Display a directory dialogue to let user select a path for module searching
2090 on_add_module_search_path_activate (GtkMenuItem
*menuitem
,
2093 GtkDirSelection
* file_selector
= (GtkDirSelection
*)gtk_dir_selection_new("Select module path");
2097 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)menuitem
);
2098 if(remember_plugins_dir
[0] != '\0')
2099 gtk_dir_selection_set_filename(file_selector
, remember_plugins_dir
);
2101 id
= gtk_dialog_run(GTK_DIALOG(file_selector
));
2103 case GTK_RESPONSE_ACCEPT
:
2104 case GTK_RESPONSE_OK
:
2105 dir
= gtk_dir_selection_get_dir (file_selector
);
2106 strncpy(remember_plugins_dir
,dir
,PATH_MAX
);
2107 strncat(remember_plugins_dir
,"/",PATH_MAX
);
2108 lttv_library_path_add(dir
);
2109 case GTK_RESPONSE_REJECT
:
2110 case GTK_RESPONSE_CANCEL
:
2112 gtk_widget_destroy((GtkWidget
*)file_selector
);
2119 on_color_activate (GtkMenuItem
*menuitem
,
2122 g_printf("Color\n");
2127 on_filter_activate (GtkMenuItem
*menuitem
,
2130 g_printf("Filter\n");
2135 on_save_configuration_activate (GtkMenuItem
*menuitem
,
2138 g_printf("Save configuration\n");
2143 on_content_activate (GtkMenuItem
*menuitem
,
2146 g_printf("Content\n");
2151 on_about_activate (GtkMenuItem
*menuitem
,
2154 g_printf("About...\n");
2159 on_button_new_clicked (GtkButton
*button
,
2162 create_new_window((GtkWidget
*)button
, user_data
, TRUE
);
2166 on_button_new_tab_clicked (GtkButton
*button
,
2169 create_new_tab((GtkWidget
*)button
, user_data
);
2173 on_button_open_clicked (GtkButton
*button
,
2176 open_traceset((GtkWidget
*)button
, user_data
);
2181 on_button_add_trace_clicked (GtkButton
*button
,
2184 add_trace((GtkWidget
*)button
, user_data
);
2189 on_button_remove_trace_clicked (GtkButton
*button
,
2192 remove_trace((GtkWidget
*)button
, user_data
);
2196 on_button_redraw_clicked (GtkButton
*button
,
2199 redraw((GtkWidget
*)button
, user_data
);
2203 on_button_continue_processing_clicked (GtkButton
*button
,
2206 continue_processing((GtkWidget
*)button
, user_data
);
2210 on_button_stop_processing_clicked (GtkButton
*button
,
2213 stop_processing((GtkWidget
*)button
, user_data
);
2219 on_button_save_clicked (GtkButton
*button
,
2222 save((GtkWidget
*)button
, user_data
);
2227 on_button_save_as_clicked (GtkButton
*button
,
2230 save_as((GtkWidget
*)button
, user_data
);
2235 on_button_zoom_in_clicked (GtkButton
*button
,
2238 zoom_in((GtkWidget
*)button
, user_data
);
2243 on_button_zoom_out_clicked (GtkButton
*button
,
2246 zoom_out((GtkWidget
*)button
, user_data
);
2251 on_button_zoom_extended_clicked (GtkButton
*button
,
2254 zoom_extended((GtkWidget
*)button
, user_data
);
2259 on_button_go_to_time_clicked (GtkButton
*button
,
2262 go_to_time((GtkWidget
*)button
, user_data
);
2267 on_button_show_time_frame_clicked (GtkButton
*button
,
2270 show_time_frame((GtkWidget
*)button
, user_data
);
2275 on_button_move_up_clicked (GtkButton
*button
,
2278 move_up_viewer((GtkWidget
*)button
, user_data
);
2283 on_button_move_down_clicked (GtkButton
*button
,
2286 move_down_viewer((GtkWidget
*)button
, user_data
);
2291 on_button_delete_viewer_clicked (GtkButton
*button
,
2294 delete_viewer((GtkWidget
*)button
, user_data
);
2298 on_MWindow_destroy (GtkWidget
*widget
,
2301 MainWindow
*main_window
= get_window_data_struct(widget
);
2302 LttvIAttribute
*attributes
= main_window
->attributes
;
2303 LttvAttributeValue value
;
2305 //This is unnecessary, since widgets will be destroyed
2306 //by the main window widget anyway.
2307 //remove_all_menu_toolbar_constructors(main_window, NULL);
2309 g_assert(lttv_iattribute_find_by_path(attributes
,
2310 "viewers/menu", LTTV_POINTER
, &value
));
2311 lttv_menus_destroy((LttvMenus
*)*(value
.v_pointer
));
2313 g_assert(lttv_iattribute_find_by_path(attributes
,
2314 "viewers/toolbar", LTTV_POINTER
, &value
));
2315 lttv_toolbars_destroy((LttvToolbars
*)*(value
.v_pointer
));
2317 g_object_unref(main_window
->attributes
);
2318 g_main_window_list
= g_slist_remove(g_main_window_list
, main_window
);
2320 g_printf("There are now : %d windows\n",g_slist_length(g_main_window_list
));
2321 if(g_slist_length(g_main_window_list
) == 0)
2326 on_MWindow_configure (GtkWidget
*widget
,
2327 GdkEventConfigure
*event
,
2330 MainWindow
* mw_data
= get_window_data_struct((GtkWidget
*)widget
);
2331 float width
= event
->width
;
2332 TimeWindow time_win
;
2334 TimeInterval
*time_span
;
2337 // MD : removed time width modification upon resizing of the main window.
2338 // The viewers will redraw themselves completely, without time interval
2341 if(mw_data->window_width){
2342 time_span = LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->Time_Span ;
2343 time_win = tab->time_window;
2344 ratio = width / mw_data->window_width;
2345 tab->time_window.time_width = ltt_time_mul(time_win.time_width,ratio);
2346 time = ltt_time_sub(time_span->endTime, time_win.start_time);
2347 if(ltt_time_compare(time, tab->time_window.time_width) < 0){
2348 tab->time_window.time_width = time;
2354 mw_data->window_width = (int)width;
2363 on_MNotebook_switch_page (GtkNotebook
*notebook
,
2364 GtkNotebookPage
*page
,
2372 /* callback function to check or uncheck the check box (filter)
2375 void checkbox_changed(GtkTreeView
*treeview
,
2377 GtkTreeViewColumn
*arg2
,
2380 GtkTreeStore
* store
= (GtkTreeStore
*)gtk_tree_view_get_model (treeview
);
2384 if (gtk_tree_model_get_iter ((GtkTreeModel
*)store
, &iter
, arg1
)){
2385 gtk_tree_model_get ((GtkTreeModel
*)store
, &iter
, CHECKBOX_COLUMN
, &value
, -1);
2386 value
= value
? FALSE
: TRUE
;
2387 gtk_tree_store_set (GTK_TREE_STORE (store
), &iter
, CHECKBOX_COLUMN
, value
, -1);
2393 /* According to user's selection, update selector(filter)
2396 void update_filter(LttvTracesetSelector
*s
, GtkTreeStore
*store
)
2398 GtkTreeIter iter
, child_iter
, child_iter1
, child_iter2
;
2399 int i
, j
, k
, nb_eventtype
;
2400 LttvTraceSelector
* trace
;
2401 LttvTracefileSelector
* tracefile
;
2402 LttvEventtypeSelector
* eventtype
;
2403 gboolean value
, value1
, value2
;
2405 if(gtk_tree_model_get_iter_first((GtkTreeModel
*)store
, &iter
)){
2408 trace
= lttv_traceset_selector_trace_get(s
, i
);
2409 nb_eventtype
= lttv_trace_selector_eventtype_number(trace
);
2410 gtk_tree_model_get ((GtkTreeModel
*)store
, &iter
, CHECKBOX_COLUMN
, &value
,-1);
2413 if(gtk_tree_model_iter_children ((GtkTreeModel
*)store
, &child_iter
, &iter
)){
2415 if(j
<1){//eventtype selector for trace
2416 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter
, CHECKBOX_COLUMN
, &value2
,-1);
2419 if(gtk_tree_model_iter_children ((GtkTreeModel
*)store
, &child_iter1
, &child_iter
)){
2421 eventtype
= lttv_trace_selector_eventtype_get(trace
,k
);
2422 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter1
, CHECKBOX_COLUMN
, &value2
,-1);
2423 lttv_eventtype_selector_set_selected(eventtype
,value2
);
2425 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &child_iter1
));
2428 }else{ //tracefile selector
2429 tracefile
= lttv_trace_selector_tracefile_get(trace
, j
- 1);
2430 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter
, CHECKBOX_COLUMN
, &value1
,-1);
2431 lttv_tracefile_selector_set_selected(tracefile
,value1
);
2433 gtk_tree_model_iter_children((GtkTreeModel
*)store
, &child_iter1
, &child_iter
); //eventtype selector
2434 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter1
, CHECKBOX_COLUMN
, &value2
,-1);
2437 if(gtk_tree_model_iter_children ((GtkTreeModel
*)store
, &child_iter2
, &child_iter1
)){
2438 do{//eventtype selector for tracefile
2439 eventtype
= lttv_tracefile_selector_eventtype_get(tracefile
,k
);
2440 gtk_tree_model_get ((GtkTreeModel
*)store
, &child_iter2
, CHECKBOX_COLUMN
, &value2
,-1);
2441 lttv_eventtype_selector_set_selected(eventtype
,value2
);
2443 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &child_iter2
));
2449 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &child_iter
));
2452 lttv_trace_selector_set_selected(trace
,value
);
2454 }while(gtk_tree_model_iter_next((GtkTreeModel
*)store
, &iter
));
2459 /* Display a dialogue showing all eventtypes and traces, let user to select the interested
2460 * eventtypes, tracefiles and traces (filter)
2463 gboolean
get_filter_selection(LttvTracesetSelector
*s
,char *title
, char * column_title
)
2465 GtkWidget
* dialogue
;
2466 GtkTreeStore
* store
;
2468 GtkWidget
* scroll_win
;
2469 GtkCellRenderer
* renderer
;
2470 GtkTreeViewColumn
* column
;
2471 GtkTreeIter iter
, child_iter
, child_iter1
, child_iter2
;
2472 int i
, j
, k
, id
, nb_trace
, nb_tracefile
, nb_eventtype
;
2473 LttvTraceSelector
* trace
;
2474 LttvTracefileSelector
* tracefile
;
2475 LttvEventtypeSelector
* eventtype
;
2479 dialogue
= gtk_dialog_new_with_buttons(title
,
2482 GTK_STOCK_OK
,GTK_RESPONSE_ACCEPT
,
2483 GTK_STOCK_CANCEL
,GTK_RESPONSE_REJECT
,
2485 gtk_window_set_default_size((GtkWindow
*)dialogue
, 300, 500);
2487 store
= gtk_tree_store_new (TOTAL_COLUMNS
, G_TYPE_BOOLEAN
, G_TYPE_STRING
);
2488 tree
= gtk_tree_view_new_with_model (GTK_TREE_MODEL (store
));
2489 g_object_unref (G_OBJECT (store
));
2490 g_signal_connect (G_OBJECT (tree
), "row-activated",
2491 G_CALLBACK (checkbox_changed
),
2495 renderer
= gtk_cell_renderer_toggle_new ();
2496 gtk_cell_renderer_toggle_set_radio((GtkCellRendererToggle
*)renderer
, FALSE
);
2498 g_object_set (G_OBJECT (renderer
),"activatable", TRUE
, NULL
);
2500 column
= gtk_tree_view_column_new_with_attributes ("Checkbox",
2502 "active", CHECKBOX_COLUMN
,
2504 gtk_tree_view_column_set_alignment (column
, 0.5);
2505 gtk_tree_view_column_set_fixed_width (column
, 20);
2506 gtk_tree_view_append_column (GTK_TREE_VIEW (tree
), column
);
2508 renderer
= gtk_cell_renderer_text_new ();
2509 column
= gtk_tree_view_column_new_with_attributes (column_title
,
2511 "text", NAME_COLUMN
,
2513 gtk_tree_view_column_set_alignment (column
, 0.0);
2514 gtk_tree_view_append_column (GTK_TREE_VIEW (tree
), column
);
2515 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW (tree
), FALSE
);
2517 scroll_win
= gtk_scrolled_window_new (NULL
, NULL
);
2518 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win
),
2519 GTK_POLICY_AUTOMATIC
,GTK_POLICY_AUTOMATIC
);
2520 gtk_container_add (GTK_CONTAINER (scroll_win
), tree
);
2522 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), scroll_win
,TRUE
, TRUE
,0);
2524 gtk_widget_show(scroll_win
);
2525 gtk_widget_show(tree
);
2527 nb_trace
= lttv_traceset_selector_trace_number(s
);
2528 for(i
=0;i
<nb_trace
;i
++){
2529 trace
= lttv_traceset_selector_trace_get(s
, i
);
2530 name
= lttv_trace_selector_get_name(trace
);
2531 gtk_tree_store_append (store
, &iter
, NULL
);
2532 checked
= lttv_trace_selector_get_selected(trace
);
2533 gtk_tree_store_set (store
, &iter
,
2534 CHECKBOX_COLUMN
,checked
,
2538 gtk_tree_store_append (store
, &child_iter
, &iter
);
2539 gtk_tree_store_set (store
, &child_iter
,
2540 CHECKBOX_COLUMN
, checked
,
2541 NAME_COLUMN
,"eventtype",
2544 nb_eventtype
= lttv_trace_selector_eventtype_number(trace
);
2545 for(j
=0;j
<nb_eventtype
;j
++){
2546 eventtype
= lttv_trace_selector_eventtype_get(trace
,j
);
2547 name
= lttv_eventtype_selector_get_name(eventtype
);
2548 checked
= lttv_eventtype_selector_get_selected(eventtype
);
2549 gtk_tree_store_append (store
, &child_iter1
, &child_iter
);
2550 gtk_tree_store_set (store
, &child_iter1
,
2551 CHECKBOX_COLUMN
, checked
,
2556 nb_tracefile
= lttv_trace_selector_tracefile_number(trace
);
2557 for(j
=0;j
<nb_tracefile
;j
++){
2558 tracefile
= lttv_trace_selector_tracefile_get(trace
, j
);
2559 name
= lttv_tracefile_selector_get_name(tracefile
);
2560 gtk_tree_store_append (store
, &child_iter
, &iter
);
2561 checked
= lttv_tracefile_selector_get_selected(tracefile
);
2562 gtk_tree_store_set (store
, &child_iter
,
2563 CHECKBOX_COLUMN
, checked
,
2567 gtk_tree_store_append (store
, &child_iter1
, &child_iter
);
2568 gtk_tree_store_set (store
, &child_iter1
,
2569 CHECKBOX_COLUMN
, checked
,
2570 NAME_COLUMN
,"eventtype",
2573 for(k
=0;k
<nb_eventtype
;k
++){
2574 eventtype
= lttv_tracefile_selector_eventtype_get(tracefile
,k
);
2575 name
= lttv_eventtype_selector_get_name(eventtype
);
2576 checked
= lttv_eventtype_selector_get_selected(eventtype
);
2577 gtk_tree_store_append (store
, &child_iter2
, &child_iter1
);
2578 gtk_tree_store_set (store
, &child_iter2
,
2579 CHECKBOX_COLUMN
, checked
,
2586 id
= gtk_dialog_run(GTK_DIALOG(dialogue
));
2588 case GTK_RESPONSE_ACCEPT
:
2589 case GTK_RESPONSE_OK
:
2590 update_filter(s
, store
);
2591 gtk_widget_destroy(dialogue
);
2593 case GTK_RESPONSE_REJECT
:
2594 case GTK_RESPONSE_CANCEL
:
2596 gtk_widget_destroy(dialogue
);
2603 /* Select a trace which will be removed from traceset
2606 char * get_remove_trace(char ** all_trace_name
, int nb_trace
)
2608 return get_selection(all_trace_name
, nb_trace
,
2609 "Select a trace", "Trace pathname");
2613 /* Select a module which will be unloaded
2616 char * get_unload_module(char ** loaded_module_name
, int nb_module
)
2618 return get_selection(loaded_module_name
, nb_module
,
2619 "Select an unload module", "Module pathname");
2623 /* Display a dialogue which shows all selectable items, let user to
2624 * select one of them
2627 char * get_selection(char ** loaded_module_name
, int nb_module
,
2628 char *title
, char * column_title
)
2630 GtkWidget
* dialogue
;
2631 GtkWidget
* scroll_win
;
2633 GtkListStore
* store
;
2634 GtkTreeViewColumn
* column
;
2635 GtkCellRenderer
* renderer
;
2636 GtkTreeSelection
* select
;
2639 char * unload_module_name
= NULL
;
2641 dialogue
= gtk_dialog_new_with_buttons(title
,
2644 GTK_STOCK_OK
,GTK_RESPONSE_ACCEPT
,
2645 GTK_STOCK_CANCEL
,GTK_RESPONSE_REJECT
,
2647 gtk_window_set_default_size((GtkWindow
*)dialogue
, 500, 200);
2649 scroll_win
= gtk_scrolled_window_new (NULL
, NULL
);
2650 gtk_widget_show ( scroll_win
);
2651 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win
),
2652 GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
2654 store
= gtk_list_store_new (N_COLUMNS
,G_TYPE_STRING
);
2655 tree
= gtk_tree_view_new_with_model(GTK_TREE_MODEL (store
));
2656 gtk_widget_show ( tree
);
2657 g_object_unref (G_OBJECT (store
));
2659 renderer
= gtk_cell_renderer_text_new ();
2660 column
= gtk_tree_view_column_new_with_attributes (column_title
,
2662 "text", MODULE_COLUMN
,
2664 gtk_tree_view_column_set_alignment (column
, 0.5);
2665 gtk_tree_view_column_set_fixed_width (column
, 150);
2666 gtk_tree_view_append_column (GTK_TREE_VIEW (tree
), column
);
2668 select
= gtk_tree_view_get_selection (GTK_TREE_VIEW (tree
));
2669 gtk_tree_selection_set_mode (select
, GTK_SELECTION_SINGLE
);
2671 gtk_container_add (GTK_CONTAINER (scroll_win
), tree
);
2673 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue
)->vbox
), scroll_win
,TRUE
, TRUE
,0);
2675 for(i
=0;i
<nb_module
;i
++){
2676 gtk_list_store_append (store
, &iter
);
2677 gtk_list_store_set (store
, &iter
, MODULE_COLUMN
,loaded_module_name
[i
],-1);
2680 id
= gtk_dialog_run(GTK_DIALOG(dialogue
));
2682 case GTK_RESPONSE_ACCEPT
:
2683 case GTK_RESPONSE_OK
:
2684 if (gtk_tree_selection_get_selected (select
, (GtkTreeModel
**)&store
, &iter
)){
2685 gtk_tree_model_get ((GtkTreeModel
*)store
, &iter
, MODULE_COLUMN
, &unload_module_name
, -1);
2687 case GTK_RESPONSE_REJECT
:
2688 case GTK_RESPONSE_CANCEL
:
2690 gtk_widget_destroy(dialogue
);
2694 return unload_module_name
;
2698 /* Insert all menu entry and tool buttons into this main window
2703 void add_all_menu_toolbar_constructors(MainWindow
* mw
, gpointer user_data
)
2707 lttvwindow_viewer_constructor constructor
;
2708 LttvMenus
* global_menu
, * instance_menu
;
2709 LttvToolbars
* global_toolbar
, * instance_toolbar
;
2710 LttvMenuClosure
*menu_item
;
2711 LttvToolbarClosure
*toolbar_item
;
2712 LttvAttributeValue value
;
2713 LttvIAttribute
*global_attributes
= LTTV_IATTRIBUTE(lttv_global_attributes());
2714 LttvIAttribute
*attributes
= mw
->attributes
;
2715 GtkWidget
* tool_menu_title_menu
, *new_widget
, *pixmap
;
2717 g_assert(lttv_iattribute_find_by_path(global_attributes
,
2718 "viewers/menu", LTTV_POINTER
, &value
));
2719 if(*(value
.v_pointer
) == NULL
)
2720 *(value
.v_pointer
) = lttv_menus_new();
2721 global_menu
= (LttvMenus
*)*(value
.v_pointer
);
2723 g_assert(lttv_iattribute_find_by_path(attributes
,
2724 "viewers/menu", LTTV_POINTER
, &value
));
2725 if(*(value
.v_pointer
) == NULL
)
2726 *(value
.v_pointer
) = lttv_menus_new();
2727 instance_menu
= (LttvMenus
*)*(value
.v_pointer
);
2731 g_assert(lttv_iattribute_find_by_path(global_attributes
,
2732 "viewers/toolbar", LTTV_POINTER
, &value
));
2733 if(*(value
.v_pointer
) == NULL
)
2734 *(value
.v_pointer
) = lttv_toolbars_new();
2735 global_toolbar
= (LttvToolbars
*)*(value
.v_pointer
);
2737 g_assert(lttv_iattribute_find_by_path(attributes
,
2738 "viewers/toolbar", LTTV_POINTER
, &value
));
2739 if(*(value
.v_pointer
) == NULL
)
2740 *(value
.v_pointer
) = lttv_toolbars_new();
2741 instance_toolbar
= (LttvToolbars
*)*(value
.v_pointer
);
2743 /* Add missing menu entries to window instance */
2744 for(i
=0;i
<global_menu
->len
;i
++) {
2745 menu_item
= &g_array_index(global_menu
, LttvMenuClosure
, i
);
2747 //add menu_item to window instance;
2748 constructor
= menu_item
->con
;
2749 tool_menu_title_menu
= lookup_widget(mw
->mwindow
,"ToolMenuTitle_menu");
2751 gtk_menu_item_new_with_mnemonic (menu_item
->menu_text
);
2752 gtk_container_add (GTK_CONTAINER (tool_menu_title_menu
),
2754 g_signal_connect ((gpointer
) new_widget
, "activate",
2755 G_CALLBACK (insert_viewer_wrap
),
2757 gtk_widget_show (new_widget
);
2758 lttv_menus_add(instance_menu
, menu_item
->con
,
2759 menu_item
->menu_path
,
2760 menu_item
->menu_text
,
2765 /* Add missing toolbar entries to window instance */
2766 for(i
=0;i
<global_toolbar
->len
;i
++) {
2767 toolbar_item
= &g_array_index(global_toolbar
, LttvToolbarClosure
, i
);
2769 //add toolbar_item to window instance;
2770 constructor
= toolbar_item
->con
;
2771 tool_menu_title_menu
= lookup_widget(mw
->mwindow
,"MToolbar1");
2772 pixbuf
= gdk_pixbuf_new_from_xpm_data((const char**)toolbar_item
->pixmap
);
2773 pixmap
= gtk_image_new_from_pixbuf(pixbuf
);
2775 gtk_toolbar_append_element (GTK_TOOLBAR (tool_menu_title_menu
),
2776 GTK_TOOLBAR_CHILD_BUTTON
,
2779 toolbar_item
->tooltip
, NULL
,
2780 pixmap
, NULL
, NULL
);
2781 gtk_label_set_use_underline(
2782 GTK_LABEL (((GtkToolbarChild
*) (
2783 g_list_last (GTK_TOOLBAR
2784 (tool_menu_title_menu
)->children
)->data
))->label
),
2786 gtk_container_set_border_width (GTK_CONTAINER (new_widget
), 1);
2787 g_signal_connect ((gpointer
) new_widget
,
2789 G_CALLBACK (insert_viewer_wrap
),
2791 gtk_widget_show (new_widget
);
2793 lttv_toolbars_add(instance_toolbar
, toolbar_item
->con
,
2794 toolbar_item
->tooltip
,
2795 toolbar_item
->pixmap
,
2803 /* Create a main window
2806 void construct_main_window(MainWindow
* parent
)
2808 g_debug("construct_main_window()");
2809 GtkWidget
* new_window
; /* New generated main window */
2810 MainWindow
* new_m_window
;/* New main window structure */
2811 GtkNotebook
* notebook
;
2812 LttvIAttribute
*attributes
=
2813 LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
));
2814 LttvAttributeValue value
;
2817 new_m_window
= g_new(MainWindow
, 1);
2819 // Add the object's information to the module's array
2820 g_main_window_list
= g_slist_append(g_main_window_list
, new_m_window
);
2823 new_window
= create_MWindow();
2824 gtk_widget_show (new_window
);
2826 new_m_window
->mwindow
= new_window
;
2827 new_m_window
->attributes
= attributes
;
2829 g_assert(lttv_iattribute_find_by_path(attributes
,
2830 "viewers/menu", LTTV_POINTER
, &value
));
2831 *(value
.v_pointer
) = lttv_menus_new();
2833 g_assert(lttv_iattribute_find_by_path(attributes
,
2834 "viewers/toolbar", LTTV_POINTER
, &value
));
2835 *(value
.v_pointer
) = lttv_toolbars_new();
2837 add_all_menu_toolbar_constructors(new_m_window
, NULL
);
2839 g_object_set_data_full(G_OBJECT(new_window
),
2841 (gpointer
)new_m_window
,
2842 (GDestroyNotify
)g_free
);
2843 //create a default tab
2844 notebook
= (GtkNotebook
*)lookup_widget(new_m_window
->mwindow
, "MNotebook");
2845 if(notebook
== NULL
){
2846 g_printf("Notebook does not exist\n");
2849 gtk_notebook_popup_enable (GTK_NOTEBOOK(notebook
));
2850 //for now there is no name field in LttvTraceset structure
2851 //Use "Traceset" as the label for the default tab
2853 GtkWidget
* parent_notebook
= lookup_widget(parent
->mwindow
, "MNotebook");
2854 GtkWidget
*page
= gtk_notebook_get_nth_page(GTK_NOTEBOOK(parent_notebook
),
2855 gtk_notebook_get_current_page(GTK_NOTEBOOK(parent_notebook
)));
2861 parent_tab
= (Tab
*)g_object_get_data(G_OBJECT(page
), "Tab_Info");
2863 new_tab
= create_tab(new_m_window
, parent_tab
, notebook
, "Traceset");
2865 new_tab
= create_tab(new_m_window
, NULL
, notebook
, "Traceset");
2866 if(g_init_trace
!= NULL
){
2867 lttvwindow_add_trace(new_tab
,
2872 g_printf("There are now : %d windows\n",g_slist_length(g_main_window_list
));
2876 /* Free the memory occupied by a tab structure
2880 void tab_destructor(Tab
* tab_instance
)
2882 int i
, nb
, ref_count
;
2885 if(tab_instance
->attributes
)
2886 g_object_unref(tab_instance
->attributes
);
2888 if(tab_instance
->interrupted_state
)
2889 g_object_unref(tab_instance
->interrupted_state
);
2892 if(tab_instance
->traceset_info
->traceset_context
!= NULL
){
2893 //remove state update hooks
2894 lttv_state_remove_event_hooks(
2895 (LttvTracesetState
*)tab_instance
->traceset_info
->
2897 lttv_context_fini(LTTV_TRACESET_CONTEXT(tab_instance
->traceset_info
->
2899 g_object_unref(tab_instance
->traceset_info
->traceset_context
);
2901 if(tab_instance
->traceset_info
->traceset
!= NULL
) {
2902 nb
= lttv_traceset_number(tab_instance
->traceset_info
->traceset
);
2903 for(i
= 0 ; i
< nb
; i
++) {
2904 trace
= lttv_traceset_get(tab_instance
->traceset_info
->traceset
, i
);
2905 ref_count
= lttv_trace_get_ref_number(trace
);
2907 ltt_trace_close(lttv_trace(trace
));
2911 lttv_traceset_destroy(tab_instance
->traceset_info
->traceset
);
2912 /* Remove the idle events requests processing function of the tab */
2913 g_idle_remove_by_data(tab_instance
);
2915 g_slist_free(tab_instance
->events_requests
);
2916 g_free(tab_instance
->traceset_info
);
2917 g_free(tab_instance
);
2921 /* Create a tab and insert it into the current main window
2924 Tab
* create_tab(MainWindow
* mw
, Tab
*copy_tab
,
2925 GtkNotebook
* notebook
, char * label
)
2931 //create a new tab data structure
2934 //construct and initialize the traceset_info
2935 tab
->traceset_info
= g_new(TracesetInfo
,1);
2938 tab
->traceset_info
->traceset
=
2939 lttv_traceset_copy(copy_tab
->traceset_info
->traceset
);
2941 tab
->traceset_info
->traceset
= lttv_traceset_new();
2944 //FIXME : this is g_debug level
2945 lttv_attribute_write_xml(
2946 lttv_traceset_attribute(tab
->traceset_info
->traceset
),
2952 //FIXME copy not implemented in lower level
2953 tab
->traceset_info
->traceset_context
=
2954 g_object_new(LTTV_TRACESET_STATS_TYPE
, NULL
);
2955 g_assert(tab
->traceset_info
->traceset_context
!= NULL
);
2957 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
),
2958 tab
->traceset_info
->traceset
);
2959 //add state update hooks
2960 lttv_state_add_event_hooks(
2961 (LttvTracesetState
*)tab
->traceset_info
->traceset_context
);
2963 //determine the current_time and time_window of the tab
2964 if(copy_tab
!= NULL
){
2965 tab
->time_window
= copy_tab
->time_window
;
2966 tab
->current_time
= copy_tab
->current_time
;
2968 tab
->time_window
.start_time
=
2969 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
2970 time_span
.start_time
;
2971 if(DEFAULT_TIME_WIDTH_S
<
2972 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
2973 time_span
.end_time
.tv_sec
)
2974 tmp_time
.tv_sec
= DEFAULT_TIME_WIDTH_S
;
2977 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
2978 time_span
.end_time
.tv_sec
;
2979 tmp_time
.tv_nsec
= 0;
2980 tab
->time_window
.time_width
= tmp_time
;
2981 tab
->current_time
.tv_sec
=
2982 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
2983 time_span
.start_time
.tv_sec
;
2984 tab
->current_time
.tv_nsec
=
2985 LTTV_TRACESET_CONTEXT(tab
->traceset_info
->traceset_context
)->
2986 time_span
.start_time
.tv_nsec
;
2988 tab
->attributes
= LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
));
2989 tab
->interrupted_state
= g_object_new(LTTV_ATTRIBUTE_TYPE
, NULL
);
2990 tab
->multi_vpaned
= (GtkMultiVPaned
*)gtk_multi_vpaned_new();
2991 gtk_widget_show((GtkWidget
*)tab
->multi_vpaned
);
2995 // Display a label with a X
2996 GtkWidget *w_hbox = gtk_hbox_new(FALSE, 4);
2997 GtkWidget *w_label = gtk_label_new (label);
2998 GtkWidget *pixmap = create_pixmap(GTK_WIDGET(notebook), "close.png");
2999 GtkWidget *w_button = gtk_button_new ();
3000 gtk_container_add(GTK_CONTAINER(w_button), pixmap);
3001 //GtkWidget *w_button = gtk_button_new_with_label("x");
3003 gtk_button_set_relief(GTK_BUTTON(w_button), GTK_RELIEF_NONE);
3005 gtk_box_pack_start(GTK_BOX(w_hbox), w_label, TRUE, TRUE, 0);
3006 gtk_box_pack_end(GTK_BOX(w_hbox), w_button, FALSE,
3009 g_signal_connect_swapped (w_button, "clicked",
3010 G_CALLBACK (on_close_tab_X_clicked),
3013 gtk_widget_set_state(w_button, GTK_STATE_ACTIVE);
3015 gtk_widget_show (w_label);
3016 gtk_widget_show (pixmap);
3017 gtk_widget_show (w_button);
3018 gtk_widget_show (w_hbox);
3020 tab->label = w_hbox;
3024 tab
->label
= gtk_label_new (label
);
3025 gtk_widget_show (tab
->label
);
3028 /* Start with empty events requests list */
3029 tab
->events_requests
= NULL
;
3030 tab
->events_request_pending
= FALSE
;
3032 g_object_set_data_full(
3033 G_OBJECT(tab
->multi_vpaned
),
3036 (GDestroyNotify
)tab_destructor
);
3038 //insert tab into notebook
3039 gtk_notebook_append_page(notebook
,
3040 (GtkWidget
*)tab
->multi_vpaned
,
3042 list
= gtk_container_get_children(GTK_CONTAINER(notebook
));
3043 gtk_notebook_set_current_page(notebook
,g_list_length(list
)-1);
3044 // always show : not if(g_list_length(list)>1)
3045 gtk_notebook_set_show_tabs(notebook
, TRUE
);
3051 * execute_events_requests
3053 * Idle function that executes the pending requests for a tab.
3055 * @return return value : TRUE : keep the idle function, FALSE : remove it.
3057 gboolean
execute_events_requests(Tab
*tab
)
3059 return ( lttvwindow_process_pending_requests(tab
) );