projects / lttv.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Add warning popup when trying to open multiple traces
[lttv.git] / lttv / modules / gui / lttvwindow / lttvwindow / callbacks.c
1 /* This file is part of the Linux Trace Toolkit viewer
2 * Copyright (C) 2003-2004 XangXiu Yang, Mathieu Desnoyers
3 *
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;
7 *
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.
12 *
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,
16 * MA 02111-1307, USA.
17 */
18
19 #ifdef HAVE_CONFIG_H
20 # include <config.h>
21 #endif
22
23 #include <limits.h> // for PATH_MAX
24 #include <stdlib.h>
25 #include <ctype.h>
26 #include <string.h>
27 #include <stdlib.h>
28
29 #include <gtk/gtk.h>
30
31 #include "callbacks.h"
32 #include "interface.h"
33 #include "support.h"
34 #include <ltt/trace.h>
35 #include <ltt/time.h>
36 #include <ltt/event.h>
37 #include <lttv/lttv.h>
38 #include <lttv/module.h>
39 #include <lttv/iattribute.h>
40 #include <lttv/traceset.h>
41 #ifdef BABEL_CLEANUP
42 #include <lttv/stats.h>
43 #include <lttv/sync/sync_chain_lttv.h>
44 #endif /* BABEL_CLEANUP */
45 #include <lttv/filter.h>
46 #include <lttvwindow/mainwindow.h>
47 #include <lttvwindow/mainwindow-private.h>
48 #include <lttvwindow/menu.h>
49 #include <lttvwindow/timebar.h>
50 #include <lttvwindow/toolbar.h>
51 #include <lttvwindow/lttvwindow.h>
52 #include <lttvwindow/lttvwindowtraces.h>
53 #include <lttvwindow/lttv_plugin_tab.h>
54
55 #include <babeltrace/babeltrace.h>
56 #include <babeltrace/ctf/events.h>
57 #include <babeltrace/ctf/iterator.h>
58
59 static LttTime lttvwindow_default_time_width = { 1, 0 };
60 #define CLIP_BUF 256 // size of clipboard buffer
61
62 extern LttvTrace *g_init_trace ;
63
64
65 /** Array containing instanced objects. */
66 extern GSList * g_main_window_list;
67
68 /** MD : keep old directory. */
69 static char remember_plugins_dir[PATH_MAX] = "";
70 static char remember_trace_dir[PATH_MAX] = "";
71
72 void tab_destructor(LttvPluginTab * ptab);
73
74 MainWindow * get_window_data_struct(GtkWidget * widget);
75 char * get_load_module(MainWindow *mw,
76 char ** load_module_name, int nb_module);
77 char * get_unload_module(MainWindow *mw,
78 char ** loaded_module_name, int nb_module);
79 char * get_remove_trace(MainWindow *mw, char ** all_trace_name, int nb_trace);
80 char * get_selection(MainWindow *mw,
81 char ** all_name, int nb, char *title, char * column_title);
82 void init_tab(Tab *tab, MainWindow * mw, Tab *copy_tab,
83 GtkNotebook * notebook, char * label);
84
85 int update_traceset(Tab *tab, LttvTraceset *traceset);
86
87 static void insert_viewer(GtkWidget* widget, lttvwindow_viewer_constructor constructor);
88
89 LttvPluginTab *create_new_tab(GtkWidget* widget, gpointer user_data);
90
91 static gboolean lttvwindow_process_pending_requests(Tab *tab);
92
93 static void on_timebar_starttime_changed(Timebar *timebar,
94 gpointer user_data);
95 static void on_timebar_endtime_changed(Timebar *timebar,
96 gpointer user_data);
97 static void on_timebar_currenttime_changed(Timebar *timebar,
98 gpointer user_data);
99
100 enum {
101 CHECKBOX_COLUMN,
102 NAME_COLUMN,
103 TOTAL_COLUMNS
104 };
105
106 enum
107 {
108 MODULE_COLUMN,
109 N_COLUMNS
110 };
111
112
113 #if 0
114 static void on_top_notify(GObject *gobject,
115 GParamSpec *arg1,
116 gpointer user_data)
117 {
118 Tab *tab = (Tab*)user_data;
119 g_message("in on_top_notify.\n");
120
121 }
122 #endif //0
123 static gboolean viewer_grab_focus(GtkWidget *widget, GdkEventButton *event,
124 gpointer data)
125 {
126 GtkWidget *viewer = GTK_WIDGET(data);
127 GtkWidget *viewer_container = gtk_widget_get_parent(viewer);
128
129 g_debug("FOCUS GRABBED");
130 g_object_set_data(G_OBJECT(viewer_container), "focused_viewer", viewer);
131 return 0;
132 }
133
134
135 static void connect_focus_recursive(GtkWidget *widget,
136 GtkWidget *viewer)
137 {
138 if(GTK_IS_CONTAINER(widget)) {
139 gtk_container_forall(GTK_CONTAINER(widget),
140 (GtkCallback)connect_focus_recursive,
141 viewer);
142
143 }
144 if(GTK_IS_TREE_VIEW(widget)) {
145 gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(widget), TRUE);
146 }
147 gtk_widget_add_events(widget, GDK_BUTTON_PRESS_MASK);
148 g_signal_connect (G_OBJECT(widget),
149 "button-press-event",
150 G_CALLBACK (viewer_grab_focus),
151 (gpointer)viewer);
152 }
153
154 /* Stop all the processings and call gtk_main_quit() */
155 static void mainwindow_quit()
156 {
157 lttvwindowtraces_unregister_requests(g_quark_from_string("stats"));
158 lttvwindowtraces_unregister_requests(g_quark_from_string("state"));
159 lttvwindowtraces_unregister_computation_hooks(g_quark_from_string("stats"));
160 lttvwindowtraces_unregister_computation_hooks(g_quark_from_string("state"));
161
162 gtk_main_quit();
163 }
164
165
166 /* insert_viewer function constructs an instance of a viewer first,
167 * then inserts the widget of the instance into the container of the
168 * main window
169 */
170
171 void
172 insert_viewer_wrap(GtkWidget *menuitem, gpointer user_data)
173 {
174 insert_viewer((GtkWidget*)menuitem, (lttvwindow_viewer_constructor)user_data);
175 }
176
177
178 /* internal functions */
179 void insert_viewer(GtkWidget* widget, lttvwindow_viewer_constructor constructor)
180 {
181 GtkWidget * viewer_container;
182 GtkWidget * notebook = lookup_widget(widget, "MNotebook");
183 GtkWidget * viewer;
184 GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
185 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
186 LttvPluginTab *ptab;
187 Tab *tab;
188
189 if(!page) {
190 ptab = create_new_tab(widget, NULL);
191 } else {
192 ptab = (LttvPluginTab *)g_object_get_data(G_OBJECT(page), "Tab_Plugin");
193 }
194 tab = ptab->tab;
195
196 viewer_container = tab->viewer_container;
197
198 viewer = (GtkWidget*)constructor(&ptab->parent);
199 if(viewer)
200 {
201 //gtk_multivpaned_widget_add(GTK_MULTIVPANED(multivpaned), viewer);
202
203 gtk_box_pack_end(GTK_BOX(viewer_container),
204 viewer,
205 TRUE,
206 TRUE,
207 0);
208
209 /* We want to connect the viewer_grab_focus to EVERY
210 * child of this widget. The little trick is to get each child
211 * of each GTK_CONTAINER, even subchildren.
212 */
213 connect_focus_recursive(viewer, viewer);
214 }
215 }
216
217 /**
218 * Function to set/update traceset for the viewers
219 * @param tab viewer's tab
220 * @param traceset traceset of the main window.
221 * return value :
222 * 0 : traceset updated
223 * 1 : no traceset hooks to update; not an error.
224 */
225
226 int SetTraceset(Tab * tab, LttvTraceset *traceset)
227 {
228
229 TimeInterval time_span;
230 TimeWindow new_time_window;
231 LttTime new_current_time;
232
233 #ifdef BABEL_CLEANUP
234 // Perform time synchronization on the traces
235 if (syncTraceset(tsc))
236 {
237 /* There is some time-dependant information that was calculated during
238 * context initialization. Destroy the old contexts and initialize new
239 * ones.
240 * Modified from lttvwindow_add_trace()
241 */
242 // Keep a reference to the traces so they are not freed
243 for(i = 0; i < lttv_traceset_number(traceset); i++)
244 {
245 LttvTrace *trace = lttv_traceset_get(traceset, i);
246 lttv_trace_ref(trace);
247 }
248
249 // Remove state update hooks
250 lttv_state_remove_event_hooks(
251 (LttvTracesetState*)tab->traceset_info->traceset_context);
252
253 lttv_context_fini(LTTV_TRACESET_CONTEXT(
254 tab->traceset_info->traceset_context));
255 g_object_unref(tab->traceset_info->traceset_context);
256
257 for(i = 0; i < lttv_traceset_number(traceset); i++)
258 {
259 LttvTrace *trace = lttv_traceset_get(traceset, i);
260 lttvwindowtraces_remove_trace(trace);
261 lttvwindowtraces_add_trace(trace);
262 }
263
264 // Create new context
265 tab->traceset_info->traceset_context =
266 g_object_new(LTTV_TRACESET_STATS_TYPE, NULL);
267 lttv_context_init(LTTV_TRACESET_CONTEXT(tab->traceset_info->
268 traceset_context), traceset);
269
270 // Add state update hooks
271 lttv_state_add_event_hooks(
272 (LttvTracesetState*)tab->traceset_info->traceset_context);
273
274 // Remove local reference to the traces
275 for(i=0; i<lttv_traceset_number(traceset); i++)
276 {
277 LttvTrace *trace = lttv_traceset_get(traceset, i);
278 lttv_trace_unref(trace);
279 }
280
281 tsc = LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context);
282 }
283 #endif /*BABEL_CLEANUP*/
284
285 time_span = lttv_traceset_get_time_span(traceset);
286
287 tab->traceset_info->traceset = traceset;
288
289 new_time_window = tab->time_window;
290 new_current_time = tab->current_time;
291
292 /* Set the tab's time window and current time if
293 * out of bounds */
294 if(ltt_time_compare(tab->time_window.start_time, time_span.start_time) < 0
295 || ltt_time_compare(tab->time_window.end_time,
296 time_span.end_time) > 0) {
297 new_time_window.start_time = time_span.start_time;
298
299 new_current_time = time_span.start_time;
300
301 LttTime tmp_time;
302
303 if(ltt_time_compare(lttvwindow_default_time_width,
304 ltt_time_sub(time_span.end_time, time_span.start_time)) < 0
305 ||
306 ltt_time_compare(time_span.end_time, time_span.start_time) == 0)
307 tmp_time = lttvwindow_default_time_width;
308 else
309 tmp_time = time_span.end_time;
310
311 new_time_window.time_width = tmp_time ;
312 new_time_window.time_width_double = ltt_time_to_double(tmp_time);
313 new_time_window.end_time = ltt_time_add(new_time_window.start_time,
314 new_time_window.time_width) ;
315 }
316
317 /* Finally, call the update hooks of the viewers */
318 gint retval = update_traceset(tab, traceset);
319
320 time_change_manager(tab, new_time_window);
321 current_time_change_manager(tab, new_current_time);
322
323 return retval;
324
325 }
326
327 /**
328 * Function to set/update filter for the viewers
329 * @param tab viewer's tab
330 * @param filter filter of the main window.
331 * return value :
332 * -1 : error
333 * 0 : filters updated
334 * 1 : no filter hooks to update; not an error.
335 */
336 #if 0
337 int SetFilter(Tab * tab, gpointer filter)
338 {
339 LttvHooks * tmp;
340 LttvAttributeValue value;
341
342 g_assert(lttv_iattribute_find_by_path(tab->attributes,
343 "hooks/updatefilter", LTTV_POINTER, &value));
344
345 tmp = (LttvHooks*)*(value.v_pointer);
346
347 if(tmp == NULL) return 1;
348 lttv_hooks_call(tmp,filter);
349
350 return 0;
351 }
352 #endif //0
353
354
355 /**
356 * Function to redraw each viewer belonging to the current tab
357 * @param tab viewer's tab
358 */
359
360 int update_traceset(Tab *tab, LttvTraceset *traceset)
361 {
362 LttvAttributeValue value;
363 LttvHooks * tmp;
364 gboolean retval;
365
366 retval= lttv_iattribute_find_by_path(tab->attributes,
367 "hooks/updatetraceset",
368 LTTV_POINTER,
369 &value);
370 g_assert(retval);
371 tmp = (LttvHooks*)*(value.v_pointer);
372 if(tmp == NULL) {
373 retval = 1;
374 } else {
375 lttv_hooks_call(tmp, traceset);
376 }
377 return retval;
378 }
379
380 /**
381 Call hooks register to get update on traceset time span changes
382 */
383 int notify_time_span_changed(Tab *tab)
384 {
385 LttvAttributeValue value;
386 LttvHooks * tmp;
387 gboolean retval;
388
389 retval= lttv_iattribute_find_by_path(tab->attributes,
390 "hooks/updatetimespan",
391 LTTV_POINTER,
392 &value);
393 g_assert(retval);
394 tmp = (LttvHooks*)*(value.v_pointer);
395 if(tmp == NULL) {
396 retval = 1;
397 } else {
398 lttv_hooks_call(tmp, NULL);
399 }
400 return retval;
401 }
402
403 /* get_label function is used to get user input, it displays an input
404 * box, which allows user to input a string
405 */
406
407 void get_label_string (GtkWidget * text, gchar * label)
408 {
409 GtkEntry * entry = (GtkEntry*)text;
410 if(strlen(gtk_entry_get_text(entry))!=0)
411 strcpy(label,gtk_entry_get_text(entry));
412 }
413
414 gboolean get_label(MainWindow * mw, gchar * str, gchar* dialogue_title, gchar * label_str)
415 {
416 GtkWidget * dialogue;
417 GtkWidget * text;
418 GtkWidget * label;
419 gint id;
420
421 dialogue = gtk_dialog_new_with_buttons(dialogue_title,NULL,
422 GTK_DIALOG_MODAL,
423 GTK_STOCK_OK,GTK_RESPONSE_ACCEPT,
424 GTK_STOCK_CANCEL,GTK_RESPONSE_REJECT,
425 NULL);
426
427 label = gtk_label_new(label_str);
428 gtk_widget_show(label);
429
430 text = gtk_entry_new();
431 gtk_widget_show(text);
432
433 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), label,TRUE, TRUE,0);
434 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), text,FALSE, FALSE,0);
435
436 id = gtk_dialog_run(GTK_DIALOG(dialogue));
437 switch(id){
438 case GTK_RESPONSE_ACCEPT:
439 get_label_string(text,str);
440 gtk_widget_destroy(dialogue);
441 break;
442 case GTK_RESPONSE_REJECT:
443 default:
444 gtk_widget_destroy(dialogue);
445 return FALSE;
446 }
447 return TRUE;
448 }
449
450
451 /* get_window_data_struct function is actually a lookup function,
452 * given a widget which is in the tree of the main window, it will
453 * return the MainWindow data structure associated with main window
454 */
455
456 MainWindow * get_window_data_struct(GtkWidget * widget)
457 {
458 GtkWidget * mw;
459 MainWindow * mw_data;
460
461 mw = lookup_widget(widget, "MWindow");
462 if(mw == NULL){
463 g_info("Main window does not exist\n");
464 return NULL;
465 }
466
467 mw_data = (MainWindow *) g_object_get_data(G_OBJECT(mw),"main_window_data");
468 if(mw_data == NULL){
469 g_warning("Main window data does not exist\n");
470 return NULL;
471 }
472 return mw_data;
473 }
474
475
476 /* create_new_window function, just constructs a new main window
477 */
478
479 void create_new_window(GtkWidget* widget, gpointer user_data, gboolean clone)
480 {
481 MainWindow * parent = get_window_data_struct(widget);
482
483 if(clone){
484 g_info("Clone : use the same traceset\n");
485 construct_main_window(parent);
486 }else{
487 g_info("Empty : traceset is set to NULL\n");
488 construct_main_window(NULL);
489 }
490 }
491
492 /* Get the currently focused viewer.
493 * If no viewer is focused, use the first one.
494 *
495 * If no viewer available, return NULL.
496 */
497 GtkWidget *viewer_container_focus(GtkWidget *container)
498 {
499 GtkWidget *widget;
500
501 widget = (GtkWidget*)g_object_get_data(G_OBJECT(container),
502 "focused_viewer");
503
504 if(widget == NULL) {
505 g_debug("no widget focused");
506 GList *children = gtk_container_get_children(GTK_CONTAINER(container));
507
508 if(children != NULL)
509 widget = GTK_WIDGET(children->data);
510 g_object_set_data(G_OBJECT(container),
511 "focused_viewer",
512 widget);
513 }
514
515 return widget;
516
517
518 }
519
520 gint viewer_container_position(GtkWidget *container, GtkWidget *child)
521 {
522
523 if(child == NULL) return -1;
524
525 gint pos;
526 GValue value;
527 memset(&value, 0, sizeof(GValue));
528 g_value_init(&value, G_TYPE_INT);
529 gtk_container_child_get_property(GTK_CONTAINER(container),
530 child,
531 "position",
532 &value);
533 pos = g_value_get_int(&value);
534
535 return pos;
536 }
537
538
539 /* move_*_viewer functions move the selected view up/down in
540 * the current tab
541 */
542
543 void move_down_viewer(GtkWidget * widget, gpointer user_data)
544 {
545 GtkWidget * notebook = lookup_widget(widget, "MNotebook");
546
547 GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
548 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
549
550 Tab *tab;
551 if(!page) {
552 return;
553 } else {
554 LttvPluginTab *ptab;
555 ptab = g_object_get_data(G_OBJECT(page), "Tab_Plugin");
556 tab = ptab->tab;
557 }
558
559 //gtk_multivpaned_widget_move_up(GTK_MULTIVPANED(tab->multivpaned));
560
561 /* change the position in the vbox */
562 GtkWidget *focus_widget;
563 gint position;
564 focus_widget = viewer_container_focus(tab->viewer_container);
565 position = viewer_container_position(tab->viewer_container, focus_widget);
566
567 if(position > 0) {
568 /* can move up one position */
569 gtk_box_reorder_child(GTK_BOX(tab->viewer_container),
570 focus_widget,
571 position-1);
572 }
573
574 }
575
576 void move_up_viewer(GtkWidget * widget, gpointer user_data)
577 {
578 GtkWidget * notebook = lookup_widget(widget, "MNotebook");
579
580 GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
581 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
582 Tab *tab;
583
584 if(!page) {
585 return;
586 } else {
587 LttvPluginTab *ptab;
588 ptab = (LttvPluginTab *)g_object_get_data(G_OBJECT(page), "Tab_Plugin");
589 tab = ptab->tab;
590 }
591
592 //gtk_multivpaned_widget_move_down(GTK_MULTIVPANED(tab->multivpaned));
593 /* change the position in the vbox */
594 GtkWidget *focus_widget;
595 gint position;
596 focus_widget = viewer_container_focus(tab->viewer_container);
597 position = viewer_container_position(tab->viewer_container, focus_widget);
598
599 if(position != -1 &&
600 position <
601 g_list_length(gtk_container_get_children(
602 GTK_CONTAINER(tab->viewer_container)))-1
603 ) {
604 /* can move down one position */
605 gtk_box_reorder_child(GTK_BOX(tab->viewer_container),
606 focus_widget,
607 position+1);
608 }
609
610 }
611
612
613 /* delete_viewer deletes the selected viewer in the current tab
614 */
615
616 void delete_viewer(GtkWidget * widget, gpointer user_data)
617 {
618 GtkWidget * notebook = lookup_widget(widget, "MNotebook");
619
620 GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
621 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
622 Tab *tab;
623
624 if(!page) {
625 return;
626 } else {
627 LttvPluginTab *ptab;
628 ptab = g_object_get_data(G_OBJECT(page), "Tab_Plugin");
629 tab = ptab->tab;
630 }
631
632 //gtk_multivpaned_widget_delete(GTK_MULTIVPANED(tab->multivpaned));
633
634 GtkWidget *focus_widget = viewer_container_focus(tab->viewer_container);
635
636 if(focus_widget != NULL)
637 gtk_widget_destroy(focus_widget);
638
639 g_object_set_data(G_OBJECT(tab->viewer_container), "focused_viewer", NULL);
640 }
641
642 #if UNFINISHED_FEATURE
643 /* TODO ybrosseau 2012-03-15: Function is half implemented. Should be removed */
644 /* open_traceset will open a traceset saved in a file
645 * Right now, it is not finished yet, (not working)
646 * FIXME
647 */
648
649 void open_traceset(GtkWidget * widget, gpointer user_data)
650 {
651 char ** dir;
652 gint id;
653 LttvTraceset * traceset;
654 MainWindow * mw_data = get_window_data_struct(widget);
655 GtkFileSelection * file_selector =
656 (GtkFileSelection *)gtk_file_selection_new("Select a traceset");
657
658 gtk_file_selection_hide_fileop_buttons(file_selector);
659
660 gtk_window_set_transient_for(GTK_WINDOW(file_selector),
661 GTK_WINDOW(mw_data->mwindow));
662
663 id = gtk_dialog_run(GTK_DIALOG(file_selector));
664 switch(id){
665 case GTK_RESPONSE_ACCEPT:
666 case GTK_RESPONSE_OK:
667 dir = gtk_file_selection_get_selections (file_selector);
668 traceset = lttv_traceset_load(dir[0]);
669 g_info("Open a trace set %s\n", dir[0]);
670 //Not finished yet
671 g_strfreev(dir);
672 case GTK_RESPONSE_REJECT:
673 case GTK_RESPONSE_CANCEL:
674 default:
675 gtk_widget_destroy((GtkWidget*)file_selector);
676 break;
677 }
678
679 }
680 #endif
681 /* lttvwindow_process_pending_requests
682 *
683 * Process requests for parts of the trace from viewers.
684 *
685 * These requests are made by lttvwindow_events_request().
686 *
687 * This internal function gets called by g_idle, taking care of the pending
688 * requests. It is responsible for concatenation of time intervals and position
689 * requests. It does it with the following algorithm organizing process traceset
690 * calls. Here is the detailed description of the way it works :
691 *
692 * - Events Requests Servicing Algorithm
693 *
694 * Data structures necessary :
695 *
696 * List of requests added to context : list_in
697 * List of requests not added to context : list_out
698 *
699 * Initial state :
700 *
701 * list_in : empty
702 * list_out : many events requests
703 *
704 * FIXME : insert rest of algorithm here
705 *
706 */
707
708 #define list_out tab->events_requests
709
710 gboolean lttvwindow_process_pending_requests(Tab *tab)
711 {
712 #ifdef BABEL_CLEANUP
713 LttvTracesetContext *tsc;
714 LttvTracefileContext *tfc;
715 GSList *list_in = NULL;
716 LttTime end_time;
717 guint end_nb_events;
718 guint count;
719 LttvTracesetContextPosition *end_position;
720
721 if(lttvwindow_preempt_count > 0) return TRUE;
722
723 if(tab == NULL) {
724 g_critical("Foreground processing : tab does not exist. Processing removed.");
725 return FALSE;
726 }
727
728 /* There is no events requests pending : we should never have been called! */
729 g_assert(g_slist_length(list_out) != 0);
730
731 tsc = LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context);
732
733 //set the cursor to be X shape, indicating that the computer is busy in doing its job
734 #if 0
735 new = gdk_cursor_new(GDK_X_CURSOR);
736 widget = lookup_widget(tab->mw->mwindow, "MToolbar1");
737 win = gtk_widget_get_parent_window(widget);
738 gdk_window_set_cursor(win, new);
739 gdk_cursor_unref(new);
740 gdk_window_stick(win);
741 gdk_window_unstick(win);
742 #endif //0
743
744 g_debug("SIZE events req len : %d", g_slist_length(list_out));
745
746 /* Preliminary check for no trace in traceset */
747 /* Unregister the routine if empty, empty list_out too */
748 if(lttv_traceset_number(tsc->ts) == 0) {
749
750 /* - For each req in list_out */
751 GSList *iter = list_out;
752
753 while(iter != NULL) {
754
755 gboolean remove = FALSE;
756 gboolean free_data = FALSE;
757 EventsRequest *events_request = (EventsRequest *)iter->data;
758
759 /* - Call end request for req */
760 if(events_request->servicing == TRUE)
761 lttv_hooks_call(events_request->after_request, (gpointer)tsc);
762
763 /* - remove req from list_out */
764 /* Destroy the request */
765 remove = TRUE;
766 free_data = TRUE;
767
768 /* Go to next */
769 if(remove)
770 {
771 GSList *remove_iter = iter;
772
773 iter = g_slist_next(iter);
774 if(free_data) events_request_free((EventsRequest*)remove_iter->data);
775 list_out = g_slist_remove_link(list_out, remove_iter);
776 } else { // not remove
777 iter = g_slist_next(iter);
778 }
779 }
780 }
781
782 /* 0.1 Lock Traces */
783 {
784 guint iter_trace=0;
785
786 for(iter_trace=0;
787 iter_trace<lttv_traceset_number(tsc->ts);
788 iter_trace++) {
789 LttvTrace *trace_v = lttv_traceset_get(tsc->ts, iter_trace);
790
791 if(lttvwindowtraces_lock(trace_v) != 0) {
792 g_critical("Foreground processing : Unable to get trace lock");
793 return TRUE; /* Cannot get lock, try later */
794 }
795 }
796 }
797
798 /* 0.2 Seek tracefiles positions to context position */
799 //g_assert(lttv_process_traceset_seek_position(tsc, sync_position) == 0);
800 lttv_process_traceset_synchronize_tracefiles(tsc);
801
802
803 /* Events processing algorithm implementation */
804 /* Warning : the gtk_events_pending takes a LOT of cpu time. So what we do
805 * instead is to leave the control to GTK and take it back.
806 */
807 /* A. Servicing loop */
808 //while( (g_slist_length(list_in) != 0 || g_slist_length(list_out) != 0)) {
809 if((g_slist_length(list_in) != 0 || g_slist_length(list_out) != 0)) {
810 /* Servicing */
811 /* 1. If list_in is empty (need a seek) */
812 if( g_slist_length(list_in) == 0 ) {
813
814 /* list in is empty, need a seek */
815 {
816 /* 1.1 Add requests to list_in */
817 GSList *ltime = NULL;
818 GSList *lpos = NULL;
819 GSList *iter = NULL;
820
821 /* 1.1.1 Find all time requests with the lowest start time in list_out
822 * (ltime)
823 */
824 if(g_slist_length(list_out) > 0)
825 ltime = g_slist_append(ltime, g_slist_nth_data(list_out, 0));
826 for(iter=g_slist_nth(list_out,1);iter!=NULL;iter=g_slist_next(iter)) {
827 /* Find all time requests with the lowest start time in list_out */
828 EventsRequest *event_request_ltime = (EventsRequest*)g_slist_nth_data(ltime, 0);
829 EventsRequest *event_request_list_out = (EventsRequest*)iter->data;
830
831 int comp;
832 comp = ltt_time_compare(event_request_ltime->start_time,
833 event_request_list_out->start_time);
834 if(comp == 0)
835 ltime = g_slist_append(ltime, event_request_list_out);
836 else if(comp > 0) {
837 /* Remove all elements from ltime, and add current */
838 while(ltime != NULL)
839 ltime = g_slist_delete_link(ltime, g_slist_nth(ltime, 0));
840 ltime = g_slist_append(ltime, event_request_list_out);
841 }
842 }
843
844 /* 1.1.2 Find all position requests with the lowest position in list_out
845 * (lpos)
846 */
847 if(g_slist_length(list_out) > 0)
848 lpos = g_slist_append(lpos, g_slist_nth_data(list_out, 0));
849 for(iter=g_slist_nth(list_out,1);iter!=NULL;iter=g_slist_next(iter)) {
850 /* Find all position requests with the lowest position in list_out */
851 EventsRequest *event_request_lpos = (EventsRequest*)g_slist_nth_data(lpos, 0);
852 EventsRequest *event_request_list_out = (EventsRequest*)iter->data;
853
854 int comp;
855 if(event_request_lpos->start_position != NULL
856 && event_request_list_out->start_position != NULL)
857 {
858 comp = lttv_traceset_context_pos_pos_compare
859 (event_request_lpos->start_position,
860 event_request_list_out->start_position);
861 } else {
862 comp = -1;
863 }
864 if(comp == 0)
865 lpos = g_slist_append(lpos, event_request_list_out);
866 else if(comp > 0) {
867 /* Remove all elements from lpos, and add current */
868 while(lpos != NULL)
869 lpos = g_slist_delete_link(lpos, g_slist_nth(lpos, 0));
870 lpos = g_slist_append(lpos, event_request_list_out);
871 }
872 }
873
874 {
875 EventsRequest *event_request_lpos = (EventsRequest*)g_slist_nth_data(lpos, 0);
876 EventsRequest *event_request_ltime = (EventsRequest*)g_slist_nth_data(ltime, 0);
877 LttTime lpos_start_time;
878
879 if(event_request_lpos != NULL
880 && event_request_lpos->start_position != NULL) {
881 lpos_start_time = lttv_traceset_context_position_get_time(
882 event_request_lpos->start_position);
883 }
884
885 /* 1.1.3 If lpos.start time < ltime */
886 if(event_request_lpos != NULL
887 && event_request_lpos->start_position != NULL
888 && ltt_time_compare(lpos_start_time,
889 event_request_ltime->start_time)<0) {
890 /* Add lpos to list_in, remove them from list_out */
891 for(iter=lpos;iter!=NULL;iter=g_slist_next(iter)) {
892 /* Add to list_in */
893 EventsRequest *event_request_lpos =
894 (EventsRequest*)iter->data;
895
896 list_in = g_slist_append(list_in, event_request_lpos);
897 /* Remove from list_out */
898 list_out = g_slist_remove(list_out, event_request_lpos);
899 }
900 } else {
901 /* 1.1.4 (lpos.start time >= ltime) */
902 /* Add ltime to list_in, remove them from list_out */
903
904 for(iter=ltime;iter!=NULL;iter=g_slist_next(iter)) {
905 /* Add to list_in */
906 EventsRequest *event_request_ltime =
907 (EventsRequest*)iter->data;
908
909 list_in = g_slist_append(list_in, event_request_ltime);
910 /* Remove from list_out */
911 list_out = g_slist_remove(list_out, event_request_ltime);
912 }
913 }
914 }
915 g_slist_free(lpos);
916 g_slist_free(ltime);
917 }
918
919 /* 1.2 Seek */
920 {
921 tfc = lttv_traceset_context_get_current_tfc(tsc);
922 g_assert(g_slist_length(list_in)>0);
923 EventsRequest *events_request = g_slist_nth_data(list_in, 0);
924 #ifdef DEBUG
925 guint seek_count;
926 #endif
927
928 /* 1.2.1 If first request in list_in is a time request */
929 if(events_request->start_position == NULL) {
930 /* - If first req in list_in start time != current time */
931 if(tfc == NULL || ltt_time_compare(events_request->start_time,
932 tfc->timestamp) != 0)
933 /* - Seek to that time */
934 g_debug("SEEK TIME : %lu, %lu", events_request->start_time.tv_sec,
935 events_request->start_time.tv_nsec);
936 //lttv_process_traceset_seek_time(tsc, events_request->start_time);
937 lttv_state_traceset_seek_time_closest(LTTV_TRACESET_STATE(tsc),
938 events_request->start_time);
939
940 /* Process the traceset with only state hooks */
941 #ifdef DEBUG
942 seek_count =
943 #endif //DEBUG
944 lttv_process_traceset_middle(tsc,
945 events_request->start_time,
946 G_MAXUINT, NULL);
947 #ifdef DEBUG
948 g_assert(seek_count < LTTV_STATE_SAVE_INTERVAL);
949 #endif //DEBUG
950
951
952 } else {
953 LttTime pos_time;
954 LttvTracefileContext *tfc =
955 lttv_traceset_context_get_current_tfc(tsc);
956 /* Else, the first request in list_in is a position request */
957 /* If first req in list_in pos != current pos */
958 g_assert(events_request->start_position != NULL);
959 g_debug("SEEK POS time : %lu, %lu",
960 lttv_traceset_context_position_get_time(
961 events_request->start_position).tv_sec,
962 lttv_traceset_context_position_get_time(
963 events_request->start_position).tv_nsec);
964
965 if(tfc) {
966 g_debug("SEEK POS context time : %lu, %lu",
967 tfc->timestamp.tv_sec,
968 tfc->timestamp.tv_nsec);
969 } else {
970 g_debug("SEEK POS context time : %lu, %lu",
971 ltt_time_infinite.tv_sec,
972 ltt_time_infinite.tv_nsec);
973 }
974 g_assert(events_request->start_position != NULL);
975 if(lttv_traceset_context_ctx_pos_compare(tsc,
976 events_request->start_position) != 0) {
977 /* 1.2.2.1 Seek to that position */
978 g_debug("SEEK POSITION");
979 //lttv_process_traceset_seek_position(tsc, events_request->start_position);
980 pos_time = lttv_traceset_context_position_get_time(
981 events_request->start_position);
982
983 lttv_state_traceset_seek_time_closest(LTTV_TRACESET_STATE(tsc),
984 pos_time);
985
986 /* Process the traceset with only state hooks */
987 #ifdef DEBUG
988 seek_count =
989
990 lttv_process_traceset_middle(tsc,
991 ltt_time_infinite,
992 G_MAXUINT,
993 events_request->start_position);
994 #endif
995 g_assert(lttv_traceset_context_ctx_pos_compare(tsc,
996 events_request->start_position) == 0);
997
998
999 }
1000 }
1001 }
1002
1003 /* 1.3 Add hooks and call before request for all list_in members */
1004 {
1005 GSList *iter = NULL;
1006
1007 for(iter=list_in;iter!=NULL;iter=g_slist_next(iter)) {
1008 EventsRequest *events_request = (EventsRequest*)iter->data;
1009 /* 1.3.1 If !servicing */
1010 if(events_request->servicing == FALSE) {
1011 /* - begin request hooks called
1012 * - servicing = TRUE
1013 */
1014 lttv_hooks_call(events_request->before_request, (gpointer)tsc);
1015 events_request->servicing = TRUE;
1016 }
1017 /* 1.3.2 call before chunk
1018 * 1.3.3 events hooks added
1019 */
1020 if(events_request->trace == -1)
1021 lttv_process_traceset_begin(tsc,
1022 events_request->before_chunk_traceset,
1023 events_request->before_chunk_trace,
1024 events_request->before_chunk_tracefile,
1025 events_request->event,
1026 events_request->event_by_id_channel);
1027 else {
1028 guint nb_trace = lttv_traceset_number(tsc->ts);
1029 g_assert((guint)events_request->trace < nb_trace &&
1030 events_request->trace > -1);
1031 LttvTraceContext *tc = tsc->traces[events_request->trace];
1032
1033 lttv_hooks_call(events_request->before_chunk_traceset, tsc);
1034
1035 lttv_trace_context_add_hooks(tc,
1036 events_request->before_chunk_trace,
1037 events_request->before_chunk_tracefile,
1038 events_request->event,
1039 events_request->event_by_id_channel);
1040 }
1041 }
1042 }
1043 } else {
1044 /* 2. Else, list_in is not empty, we continue a read */
1045
1046 {
1047 /* 2.0 For each req of list_in */
1048 GSList *iter = list_in;
1049
1050 while(iter != NULL) {
1051
1052 EventsRequest *events_request = (EventsRequest *)iter->data;
1053
1054 /* - Call before chunk
1055 * - events hooks added
1056 */
1057 if(events_request->trace == -1)
1058 lttv_process_traceset_begin(tsc,
1059 events_request->before_chunk_traceset,
1060 events_request->before_chunk_trace,
1061 events_request->before_chunk_tracefile,
1062 events_request->event,
1063 events_request->event_by_id_channel);
1064 else {
1065 guint nb_trace = lttv_traceset_number(tsc->ts);
1066 g_assert((guint)events_request->trace < nb_trace &&
1067 events_request->trace > -1);
1068 LttvTraceContext *tc = tsc->traces[events_request->trace];
1069
1070 lttv_hooks_call(events_request->before_chunk_traceset, tsc);
1071
1072 lttv_trace_context_add_hooks(tc,
1073 events_request->before_chunk_trace,
1074 events_request->before_chunk_tracefile,
1075 events_request->event,
1076 events_request->event_by_id_channel);
1077 }
1078
1079 iter = g_slist_next(iter);
1080 }
1081 }
1082
1083 {
1084 tfc = lttv_traceset_context_get_current_tfc(tsc);
1085
1086 /* 2.1 For each req of list_out */
1087 GSList *iter = list_out;
1088
1089 while(iter != NULL) {
1090
1091 gboolean remove = FALSE;
1092 gboolean free_data = FALSE;
1093 EventsRequest *events_request = (EventsRequest *)iter->data;
1094
1095 /* if req.start time == current context time
1096 * or req.start position == current position*/
1097 if( ltt_time_compare(events_request->start_time,
1098 tfc->timestamp) == 0
1099 ||
1100 (events_request->start_position != NULL
1101 &&
1102 lttv_traceset_context_ctx_pos_compare(tsc,
1103 events_request->start_position) == 0)
1104 ) {
1105 /* - Add to list_in, remove from list_out */
1106 list_in = g_slist_append(list_in, events_request);
1107 remove = TRUE;
1108 free_data = FALSE;
1109
1110 /* - If !servicing */
1111 if(events_request->servicing == FALSE) {
1112 /* - begin request hooks called
1113 * - servicing = TRUE
1114 */
1115 lttv_hooks_call(events_request->before_request, (gpointer)tsc);
1116 events_request->servicing = TRUE;
1117 }
1118 /* call before chunk
1119 * events hooks added
1120 */
1121 if(events_request->trace == -1)
1122 lttv_process_traceset_begin(tsc,
1123 events_request->before_chunk_traceset,
1124 events_request->before_chunk_trace,
1125 events_request->before_chunk_tracefile,
1126 events_request->event,
1127 events_request->event_by_id_channel);
1128 else {
1129 guint nb_trace = lttv_traceset_number(tsc->ts);
1130 g_assert((guint)events_request->trace < nb_trace &&
1131 events_request->trace > -1);
1132 LttvTraceContext *tc = tsc->traces[events_request->trace];
1133
1134 lttv_hooks_call(events_request->before_chunk_traceset, tsc);
1135
1136 lttv_trace_context_add_hooks(tc,
1137 events_request->before_chunk_trace,
1138 events_request->before_chunk_tracefile,
1139 events_request->event,
1140 events_request->event_by_id_channel);
1141 }
1142
1143
1144 }
1145
1146 /* Go to next */
1147 if(remove)
1148 {
1149 GSList *remove_iter = iter;
1150
1151 iter = g_slist_next(iter);
1152 if(free_data) events_request_free((EventsRequest*)remove_iter->data);
1153 list_out = g_slist_remove_link(list_out, remove_iter);
1154 } else { // not remove
1155 iter = g_slist_next(iter);
1156 }
1157 }
1158 }
1159 }
1160
1161 /* 3. Find end criterions */
1162 {
1163 /* 3.1 End time */
1164 GSList *iter;
1165
1166 /* 3.1.1 Find lowest end time in list_in */
1167 g_assert(g_slist_length(list_in)>0);
1168 end_time = ((EventsRequest*)g_slist_nth_data(list_in,0))->end_time;
1169
1170 for(iter=g_slist_nth(list_in,1);iter!=NULL;iter=g_slist_next(iter)) {
1171 EventsRequest *events_request = (EventsRequest*)iter->data;
1172
1173 if(ltt_time_compare(events_request->end_time,
1174 end_time) < 0)
1175 end_time = events_request->end_time;
1176 }
1177
1178 /* 3.1.2 Find lowest start time in list_out */
1179 for(iter=list_out;iter!=NULL;iter=g_slist_next(iter)) {
1180 EventsRequest *events_request = (EventsRequest*)iter->data;
1181
1182 if(ltt_time_compare(events_request->start_time,
1183 end_time) < 0)
1184 end_time = events_request->start_time;
1185 }
1186 }
1187
1188 {
1189 /* 3.2 Number of events */
1190
1191 /* 3.2.1 Find lowest number of events in list_in */
1192 GSList *iter;
1193
1194 end_nb_events = ((EventsRequest*)g_slist_nth_data(list_in,0))->num_events;
1195
1196 for(iter=g_slist_nth(list_in,1);iter!=NULL;iter=g_slist_next(iter)) {
1197 EventsRequest *events_request = (EventsRequest*)iter->data;
1198
1199 if(events_request->num_events < end_nb_events)
1200 end_nb_events = events_request->num_events;
1201 }
1202
1203 /* 3.2.2 Use min(CHUNK_NUM_EVENTS, min num events in list_in) as
1204 * num_events */
1205
1206 end_nb_events = MIN(CHUNK_NUM_EVENTS, end_nb_events);
1207 }
1208
1209 {
1210 /* 3.3 End position */
1211
1212 /* 3.3.1 Find lowest end position in list_in */
1213 GSList *iter;
1214
1215 end_position =((EventsRequest*)g_slist_nth_data(list_in,0))->end_position;
1216
1217 for(iter=g_slist_nth(list_in,1);iter!=NULL;iter=g_slist_next(iter)) {
1218 EventsRequest *events_request = (EventsRequest*)iter->data;
1219
1220 if(events_request->end_position != NULL && end_position != NULL &&
1221 lttv_traceset_context_pos_pos_compare(events_request->end_position,
1222 end_position) <0)
1223 end_position = events_request->end_position;
1224 }
1225 }
1226
1227 {
1228 /* 3.3.2 Find lowest start position in list_out */
1229 GSList *iter;
1230
1231 for(iter=list_out;iter!=NULL;iter=g_slist_next(iter)) {
1232 EventsRequest *events_request = (EventsRequest*)iter->data;
1233
1234 if(events_request->end_position != NULL && end_position != NULL &&
1235 lttv_traceset_context_pos_pos_compare(events_request->end_position,
1236 end_position) <0)
1237 end_position = events_request->end_position;
1238 }
1239 }
1240
1241 {
1242 /* 4. Call process traceset middle */
1243 g_debug("Calling process traceset middle with %p, %lu sec %lu nsec, %u nb ev, %p end pos", tsc, end_time.tv_sec, end_time.tv_nsec, end_nb_events, end_position);
1244 count = lttv_process_traceset_middle(tsc, end_time, end_nb_events, end_position);
1245
1246 tfc = lttv_traceset_context_get_current_tfc(tsc);
1247 if(tfc != NULL)
1248 g_debug("Context time after middle : %lu, %lu", tfc->timestamp.tv_sec,
1249 tfc->timestamp.tv_nsec);
1250 else
1251 g_debug("End of trace reached after middle.");
1252
1253 }
1254 {
1255 /* 5. After process traceset middle */
1256 tfc = lttv_traceset_context_get_current_tfc(tsc);
1257
1258 /* - if current context time > traceset.end time */
1259 if(tfc == NULL || ltt_time_compare(tfc->timestamp,
1260 tsc->time_span.end_time) > 0) {
1261 /* - For each req in list_in */
1262 GSList *iter = list_in;
1263
1264 while(iter != NULL) {
1265
1266 gboolean remove = FALSE;
1267 gboolean free_data = FALSE;
1268 EventsRequest *events_request = (EventsRequest *)iter->data;
1269
1270 /* - Remove events hooks for req
1271 * - Call end chunk for req
1272 */
1273
1274 if(events_request->trace == -1)
1275 lttv_process_traceset_end(tsc,
1276 events_request->after_chunk_traceset,
1277 events_request->after_chunk_trace,
1278 events_request->after_chunk_tracefile,
1279 events_request->event,
1280 events_request->event_by_id_channel);
1281
1282 else {
1283 guint nb_trace = lttv_traceset_number(tsc->ts);
1284 g_assert(events_request->trace < nb_trace &&
1285 events_request->trace > -1);
1286 LttvTraceContext *tc = tsc->traces[events_request->trace];
1287
1288 lttv_trace_context_remove_hooks(tc,
1289 events_request->after_chunk_trace,
1290 events_request->after_chunk_tracefile,
1291 events_request->event,
1292 events_request->event_by_id_channel);
1293 lttv_hooks_call(events_request->after_chunk_traceset, tsc);
1294
1295
1296 }
1297
1298 /* - Call end request for req */
1299 lttv_hooks_call(events_request->after_request, (gpointer)tsc);
1300
1301 /* - remove req from list_in */
1302 /* Destroy the request */
1303 remove = TRUE;
1304 free_data = TRUE;
1305
1306 /* Go to next */
1307 if(remove)
1308 {
1309 GSList *remove_iter = iter;
1310
1311 iter = g_slist_next(iter);
1312 if(free_data) events_request_free((EventsRequest*)remove_iter->data);
1313 list_in = g_slist_remove_link(list_in, remove_iter);
1314 } else { // not remove
1315 iter = g_slist_next(iter);
1316 }
1317 }
1318 }
1319 {
1320 /* 5.1 For each req in list_in */
1321 GSList *iter = list_in;
1322
1323 while(iter != NULL) {
1324
1325 gboolean remove = FALSE;
1326 gboolean free_data = FALSE;
1327 EventsRequest *events_request = (EventsRequest *)iter->data;
1328
1329 /* - Remove events hooks for req
1330 * - Call end chunk for req
1331 */
1332 if(events_request->trace == -1)
1333 lttv_process_traceset_end(tsc,
1334 events_request->after_chunk_traceset,
1335 events_request->after_chunk_trace,
1336 events_request->after_chunk_tracefile,
1337 events_request->event,
1338 events_request->event_by_id_channel);
1339
1340 else {
1341 guint nb_trace = lttv_traceset_number(tsc->ts);
1342 g_assert(events_request->trace < nb_trace &&
1343 events_request->trace > -1);
1344 LttvTraceContext *tc = tsc->traces[events_request->trace];
1345
1346 lttv_trace_context_remove_hooks(tc,
1347 events_request->after_chunk_trace,
1348 events_request->after_chunk_tracefile,
1349 events_request->event,
1350 events_request->event_by_id_channel);
1351
1352 lttv_hooks_call(events_request->after_chunk_traceset, tsc);
1353 }
1354
1355 /* - req.num -= count */
1356 g_assert(events_request->num_events >= count);
1357 events_request->num_events -= count;
1358
1359 g_assert(tfc != NULL);
1360 /* - if req.num == 0
1361 * or
1362 * current context time >= req.end time
1363 * or
1364 * req.end pos == current pos
1365 * or
1366 * req.stop_flag == TRUE
1367 */
1368 if( events_request->num_events == 0
1369 ||
1370 events_request->stop_flag == TRUE
1371 ||
1372 ltt_time_compare(tfc->timestamp,
1373 events_request->end_time) >= 0
1374 ||
1375 (events_request->end_position != NULL
1376 &&
1377 lttv_traceset_context_ctx_pos_compare(tsc,
1378 events_request->end_position) == 0)
1379
1380 ) {
1381 g_assert(events_request->servicing == TRUE);
1382 /* - Call end request for req
1383 * - remove req from list_in */
1384 lttv_hooks_call(events_request->after_request, (gpointer)tsc);
1385 /* - remove req from list_in */
1386 /* Destroy the request */
1387 remove = TRUE;
1388 free_data = TRUE;
1389 }
1390
1391 /* Go to next */
1392 if(remove)
1393 {
1394 GSList *remove_iter = iter;
1395
1396 iter = g_slist_next(iter);
1397 if(free_data) events_request_free((EventsRequest*)remove_iter->data);
1398 list_in = g_slist_remove_link(list_in, remove_iter);
1399 } else { // not remove
1400 iter = g_slist_next(iter);
1401 }
1402 }
1403 }
1404 }
1405 }
1406 /* End of removed servicing loop : leave control to GTK instead. */
1407 // if(gtk_events_pending()) break;
1408 //}
1409
1410 /* B. When interrupted between chunks */
1411
1412 {
1413 GSList *iter = list_in;
1414
1415 /* 1. for each request in list_in */
1416 while(iter != NULL) {
1417
1418 gboolean remove = FALSE;
1419 gboolean free_data = FALSE;
1420 EventsRequest *events_request = (EventsRequest *)iter->data;
1421
1422 /* 1.1. Use current postition as start position */
1423 if(events_request->start_position != NULL)
1424 lttv_traceset_context_position_destroy(events_request->start_position);
1425 events_request->start_position = lttv_traceset_context_position_new(tsc);
1426 lttv_traceset_context_position_save(tsc, events_request->start_position);
1427
1428 /* 1.2. Remove start time */
1429 events_request->start_time = ltt_time_infinite;
1430
1431 /* 1.3. Move from list_in to list_out */
1432 remove = TRUE;
1433 free_data = FALSE;
1434 list_out = g_slist_append(list_out, events_request);
1435
1436 /* Go to next */
1437 if(remove)
1438 {
1439 GSList *remove_iter = iter;
1440
1441 iter = g_slist_next(iter);
1442 if(free_data) events_request_free((EventsRequest*)remove_iter->data);
1443 list_in = g_slist_remove_link(list_in, remove_iter);
1444 } else { // not remove
1445 iter = g_slist_next(iter);
1446 }
1447 }
1448
1449
1450 }
1451 /* C Unlock Traces */
1452 {
1453 lttv_process_traceset_get_sync_data(tsc);
1454 //lttv_traceset_context_position_save(tsc, sync_position);
1455
1456 guint iter_trace;
1457
1458 for(iter_trace=0;
1459 iter_trace<lttv_traceset_number(tsc->ts);
1460 iter_trace++) {
1461 LttvTrace *trace_v = lttv_traceset_get(tsc->ts, iter_trace);
1462
1463 lttvwindowtraces_unlock(trace_v);
1464 }
1465 }
1466 #if 0
1467 //set the cursor back to normal
1468 gdk_window_set_cursor(win, NULL);
1469 #endif //0
1470
1471 g_assert(g_slist_length(list_in) == 0);
1472
1473 if( g_slist_length(list_out) == 0 ) {
1474 /* Put tab's request pending flag back to normal */
1475 tab->events_request_pending = FALSE;
1476 g_debug("remove the idle fct");
1477 return FALSE; /* Remove the idle function */
1478 }
1479 g_debug("leave the idle fct");
1480 return TRUE; /* Leave the idle function */
1481
1482 /* We do not use simili-round-robin, it may require to read 1 meg buffers
1483 * again and again if many tracesets use the same tracefiles. */
1484 /* Hack for round-robin idle functions */
1485 /* It will put the idle function at the end of the pool */
1486 /*g_idle_add_full((G_PRIORITY_HIGH_IDLE + 21),
1487 (GSourceFunc)execute_events_requests,
1488 tab,
1489 NULL);
1490 return FALSE;
1491 */
1492
1493 #endif /* BABEL_CLEANUP */
1494 }
1495
1496 #undef list_out
1497 /**
1498 Manage the periodic update of a live trace
1499 */
1500 static gboolean
1501 live_trace_update_handler(Tab *tab)
1502 {
1503 #ifdef BABEL_CLEANUP
1504 unsigned int updated_count;
1505 LttvTracesetContext *tsc = LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context);
1506 TimeInterval initial_time_span = tsc->time_span;
1507 TimeInterval updated_time_span;
1508
1509 updated_count = lttv_process_traceset_update(tsc);
1510
1511 /* TODO ybrosseau 2011-01-12: Add trace resynchronization */
1512
1513 /* Get the changed period bounds */
1514 updated_time_span = tsc->time_span;
1515
1516 if(ltt_time_compare(updated_time_span.start_time,
1517 initial_time_span.start_time) != 0) {
1518 /* The initial time should not change on a live update */
1519 g_assert(FALSE);
1520 }
1521
1522 /* Notify viewers (only on updates) */
1523 if(ltt_time_compare(updated_time_span.end_time,
1524 initial_time_span.end_time) != 0) {
1525
1526 notify_time_span_changed(tab);
1527 /* TODO ybrosseau 2011-01-12: Change the timebar to register
1528 to the time_span hook */
1529 timebar_set_minmax_time(TIMEBAR(tab->MTimebar),
1530 &updated_time_span.start_time,
1531 &updated_time_span.end_time );
1532
1533 /* To update the min max */
1534 time_change_manager(tab, tab->time_window);
1535 }
1536
1537 /* Timer will be recalled as long as there is files to update */
1538 return (updated_count > 0);
1539 #endif /* BABEL_CLEANUP */
1540 }
1541
1542 static void lttvwindow_add_trace(Tab *tab, LttvTrace *trace_v)
1543 {
1544 #ifdef BABEL_CLEANUP
1545 LttvTraceset *traceset = tab->traceset_info->traceset;
1546 guint i;
1547 guint num_traces = lttv_traceset_number(traceset);
1548
1549 //Verify if trace is already present.
1550 for(i=0; i<num_traces; i++)
1551 {
1552 LttvTrace * trace = lttv_traceset_get(traceset, i);
1553 if(trace == trace_v)
1554 return;
1555 }
1556
1557 //Keep a reference to the traces so they are not freed.
1558 for(i=0; i<lttv_traceset_number(traceset); i++)
1559 {
1560 LttvTrace * trace = lttv_traceset_get(traceset, i);
1561 lttv_trace_ref(trace);
1562 }
1563
1564 //remove state update hooks
1565 lttv_state_remove_event_hooks(
1566 (LttvTracesetState*)tab->traceset_info->traceset_context);
1567
1568 lttv_context_fini(LTTV_TRACESET_CONTEXT(
1569 tab->traceset_info->traceset_context));
1570 g_object_unref(tab->traceset_info->traceset_context);
1571
1572 lttv_traceset_add(traceset, trace_v);
1573 lttv_trace_ref(trace_v); /* local ref */
1574
1575 /* Create new context */
1576 tab->traceset_info->traceset_context =
1577 g_object_new(LTTV_TRACESET_STATS_TYPE, NULL);
1578 lttv_context_init(
1579 LTTV_TRACESET_CONTEXT(tab->traceset_info->
1580 traceset_context),
1581 traceset);
1582
1583
1584 //add state update hooks
1585 lttv_state_add_event_hooks(
1586 (LttvTracesetState*)tab->traceset_info->traceset_context);
1587 //Remove local reference to the traces.
1588 for(i=0; i<lttv_traceset_number(traceset); i++)
1589 {
1590 LttvTrace * trace = lttv_traceset_get(traceset, i);
1591 lttv_trace_unref(trace);
1592 }
1593
1594 //FIXME
1595 //add_trace_into_traceset_selector(GTK_MULTIVPANED(tab->multivpaned), lttv_trace(trace_v));
1596
1597
1598 if (lttv_trace(trace_v)->is_live) {
1599 /* Add timer for live update */
1600 /* TODO ybrosseau 2011-01-12: Parametrize the hardcoded 1 seconds */
1601 g_timeout_add_seconds (1,
1602 (GSourceFunc) live_trace_update_handler,
1603 tab);
1604 }
1605 #endif /* BABEL_CLEANUP */
1606 }
1607
1608 /* add_trace adds a trace into the current traceset. It first displays a
1609 * directory selection dialogue to let user choose a trace, then recreates
1610 * tracset_context, and redraws all the viewer of the current tab
1611 */
1612
1613 void add_trace(GtkWidget * widget, gpointer user_data)
1614 {
1615
1616 LttvTraceset * traceset = NULL;
1617 const char * path;
1618 char abs_path[PATH_MAX];
1619 gint id;
1620 MainWindow * mw_data = get_window_data_struct(widget);
1621 GtkWidget * notebook = lookup_widget(widget, "MNotebook");
1622
1623 GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
1624 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
1625 LttvPluginTab *ptab;
1626 Tab *tab;
1627
1628 if(!page) {
1629 ptab = create_new_tab(widget, NULL);
1630 tab = ptab->tab;
1631 } else {
1632 ptab = (LttvPluginTab *)g_object_get_data(G_OBJECT(page), "Tab_Plugin");
1633 tab = ptab->tab;
1634 }
1635 traceset = lttvwindow_get_traceset(tab);
1636 if(traceset != NULL && traceset->traces->len > 0){
1637 GtkWidget *dialogue =
1638 gtk_message_dialog_new(
1639 GTK_WINDOW(gtk_widget_get_toplevel(widget)),
1640 GTK_DIALOG_MODAL|GTK_DIALOG_DESTROY_WITH_PARENT,
1641 GTK_MESSAGE_ERROR,
1642 GTK_BUTTONS_OK,
1643 "Loading multiple traces is not supported at the moment.");
1644 gtk_dialog_run(GTK_DIALOG(dialogue));
1645 gtk_widget_destroy(dialogue);
1646 return;
1647 }
1648
1649 /* Create a new traceset*/
1650 traceset = lttv_traceset_new();
1651 /* File open dialog management */
1652 GtkWidget *extra_live_button;
1653 GtkFileChooser * file_chooser =
1654 GTK_FILE_CHOOSER(
1655 gtk_file_chooser_dialog_new ("Select a trace",
1656 GTK_WINDOW(mw_data->mwindow),
1657 GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
1658 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1659 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
1660 NULL));
1661
1662 /* Button to indicate the opening of a live trace */
1663 extra_live_button = gtk_check_button_new_with_mnemonic ("Trace is live (currently being writen)");
1664 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (extra_live_button), FALSE);
1665 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (file_chooser), extra_live_button);
1666
1667 gtk_file_chooser_set_show_hidden (file_chooser, TRUE);
1668 if(remember_trace_dir[0] != '\0')
1669 gtk_file_chooser_set_filename(file_chooser, remember_trace_dir);
1670
1671 gboolean closeFileChooserDialog = TRUE;
1672
1673 do
1674 {
1675 id = gtk_dialog_run(GTK_DIALOG(file_chooser));
1676 switch(id){
1677 case GTK_RESPONSE_ACCEPT:
1678 case GTK_RESPONSE_OK:
1679 path = gtk_file_chooser_get_filename (file_chooser);
1680
1681 strncpy(remember_trace_dir, path, PATH_MAX);
1682 strncat(remember_trace_dir, "/", PATH_MAX);
1683 if(!path || strlen(path) == 0){
1684 break;
1685 }
1686 get_absolute_pathname(path, abs_path);
1687
1688 if(lttv_traceset_add_path(traceset,abs_path) != 0 ){ /*failure*/
1689
1690 g_warning("cannot open trace %s", abs_path);
1691 strncpy(remember_trace_dir, "\0", PATH_MAX);
1692 GtkWidget *dialogue =
1693 gtk_message_dialog_new(
1694 GTK_WINDOW(gtk_widget_get_toplevel(widget)),
1695 GTK_DIALOG_MODAL|GTK_DIALOG_DESTROY_WITH_PARENT,
1696 GTK_MESSAGE_ERROR,
1697 GTK_BUTTONS_OK,
1698 "Cannot open trace : maybe you should enter in the directory "
1699 "to select it ?");
1700 gtk_dialog_run(GTK_DIALOG(dialogue));
1701 gtk_widget_destroy(dialogue);
1702 closeFileChooserDialog = FALSE;
1703 }
1704 else{
1705 closeFileChooserDialog = TRUE;
1706 SetTraceset(tab, traceset);
1707 }
1708 break;
1709 //update current tab
1710 //update_traceset(mw_data);
1711
1712 // in expose now call_pending_read_hooks(mw_data);
1713
1714 //lttvwindow_report_current_time(mw_data,&(tab->current_time));
1715
1716 case GTK_RESPONSE_REJECT:
1717 case GTK_RESPONSE_CANCEL:
1718 default:
1719 closeFileChooserDialog = TRUE;
1720 break;
1721 }
1722 }while(!closeFileChooserDialog);
1723
1724 gtk_widget_destroy((GtkWidget*)file_chooser);
1725
1726 }
1727
1728 /* remove_trace removes a trace from the current traceset if all viewers in
1729 * the current tab are not interested in the trace. It first displays a
1730 * dialogue, which shows all traces in the current traceset, to let user choose
1731 * a trace, then it checks if all viewers unselect the trace, if it is true,
1732 * it will remove the trace, recreate the traceset_contex,
1733 * and redraws all the viewer of the current tab. If there is on trace in the
1734 * current traceset, it will delete all viewers of the current tab
1735 *
1736 * It destroys the filter tree. FIXME... we should request for an update
1737 * instead.
1738 */
1739
1740 void remove_trace(GtkWidget *widget, gpointer user_data)
1741 {
1742 #ifdef BABEL_CLEANUP
1743 LttTrace *trace;
1744 LttvTrace * trace_v;
1745 LttvTraceset * traceset;
1746 gint i, j, nb_trace, index=-1;
1747 char ** name, *remove_trace_name;
1748 MainWindow * mw_data = get_window_data_struct(widget);
1749 GtkWidget * notebook = lookup_widget(widget, "MNotebook");
1750
1751 GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
1752 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
1753 Tab *tab;
1754
1755 if(!page) {
1756 return;
1757 } else {
1758 LttvPluginTab *ptab;
1759 ptab = (LttvPluginTab *)g_object_get_data(G_OBJECT(page), "Tab_Plugin");
1760 tab = ptab->tab;
1761 }
1762
1763 nb_trace =lttv_traceset_number(tab->traceset_info->traceset);
1764 name = g_new(char*,nb_trace);
1765 for(i = 0; i < nb_trace; i++){
1766 trace_v = lttv_traceset_get(tab->traceset_info->traceset, i);
1767 trace = lttv_trace(trace_v);
1768 name[i] = (char *) g_quark_to_string(ltt_trace_name(trace));
1769 }
1770
1771 remove_trace_name = get_remove_trace(mw_data, name, nb_trace);
1772
1773
1774 if(remove_trace_name){
1775
1776 /* yuk, cut n paste from old code.. should be better (MD)*/
1777 for(i = 0; i<nb_trace; i++) {
1778 if(strcmp(remove_trace_name,name[i]) == 0){
1779 index = i;
1780 }
1781 }
1782
1783 traceset = tab->traceset_info->traceset;
1784 //Keep a reference to the traces so they are not freed.
1785 for(j=0; j<lttv_traceset_number(traceset); j++)
1786 {
1787 LttvTrace * trace = lttv_traceset_get(traceset, j);
1788 lttv_trace_ref(trace);
1789 }
1790
1791 //remove state update hooks
1792 lttv_state_remove_event_hooks(
1793 (LttvTracesetState*)tab->traceset_info->traceset_context);
1794 lttv_context_fini(LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context));
1795 g_object_unref(tab->traceset_info->traceset_context);
1796
1797 trace_v = lttv_traceset_get(traceset, index);
1798
1799 lttv_traceset_remove(traceset, index);
1800 lttv_trace_unref(trace_v); // Remove local reference
1801
1802 if(lttv_trace_get_ref_number(trace_v) <= 1) {
1803 /* ref 1 : lttvwindowtraces only*/
1804 ltt_trace_close(lttv_trace(trace_v));
1805 /* lttvwindowtraces_remove_trace takes care of destroying
1806 * the traceset linked with the trace_v and also of destroying
1807 * the trace_v at the same time.
1808 */
1809 lttvwindowtraces_remove_trace(trace_v);
1810 }
1811
1812 tab->traceset_info->traceset_context =
1813 g_object_new(LTTV_TRACESET_STATS_TYPE, NULL);
1814 lttv_context_init(
1815 LTTV_TRACESET_CONTEXT(tab->
1816 traceset_info->traceset_context),traceset);
1817 //add state update hooks
1818 lttv_state_add_event_hooks(
1819 (LttvTracesetState*)tab->traceset_info->traceset_context);
1820
1821 //Remove local reference to the traces.
1822 for(j=0; j<lttv_traceset_number(traceset); j++)
1823 {
1824 LttvTrace * trace = lttv_traceset_get(traceset, j);
1825 lttv_trace_unref(trace);
1826 }
1827
1828 SetTraceset(tab, (gpointer)traceset);
1829 }
1830 g_free(name);
1831 #endif /* BABEL_CLEANUP */
1832 }
1833
1834 #if 0
1835 void remove_trace(GtkWidget * widget, gpointer user_data)
1836 {
1837 LttTrace *trace;
1838 LttvTrace * trace_v;
1839 LttvTraceset * traceset;
1840 gint i, j, nb_trace;
1841 char ** name, *remove_trace_name;
1842 MainWindow * mw_data = get_window_data_struct(widget);
1843 LttvTracesetSelector * s;
1844 LttvTraceSelector * t;
1845 GtkWidget * w;
1846 gboolean selected;
1847 GtkWidget * notebook = lookup_widget(widget, "MNotebook");
1848
1849 GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
1850 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
1851 Tab *tab;
1852
1853 if(!page) {
1854 return;
1855 } else {
1856 tab = (Tab *)g_object_get_data(G_OBJECT(page), "Tab_Info");
1857 }
1858
1859 nb_trace =lttv_traceset_number(tab->traceset_info->traceset);
1860 name = g_new(char*,nb_trace);
1861 for(i = 0; i < nb_trace; i++){
1862 trace_v = lttv_traceset_get(tab->traceset_info->traceset, i);
1863 trace = lttv_trace(trace_v);
1864 name[i] = ltt_trace_name(trace);
1865 }
1866
1867 remove_trace_name = get_remove_trace(name, nb_trace);
1868
1869 if(remove_trace_name){
1870 for(i=0; i<nb_trace; i++){
1871 if(strcmp(remove_trace_name,name[i]) == 0){
1872 //unselect the trace from the current viewer
1873 //FIXME
1874 w = gtk_multivpaned_get_widget(GTK_MULTIVPANED(tab->multivpaned));
1875 if(w){
1876 s = g_object_get_data(G_OBJECT(w), "Traceset_Selector");
1877 if(s){
1878 t = lttv_traceset_selector_trace_get(s,i);
1879 lttv_trace_selector_set_selected(t, FALSE);
1880 }
1881
1882 //check if other viewers select the trace
1883 w = gtk_multivpaned_get_first_widget(GTK_MULTIVPANED(tab->multivpaned));
1884 while(w){
1885 s = g_object_get_data(G_OBJECT(w), "Traceset_Selector");
1886 if(s){
1887 t = lttv_traceset_selector_trace_get(s,i);
1888 selected = lttv_trace_selector_get_selected(t);
1889 if(selected)break;
1890 }
1891 w = gtk_multivpaned_get_next_widget(GTK_MULTIVPANED(tab->multivpaned));
1892 }
1893 }else selected = FALSE;
1894
1895 //if no viewer selects the trace, remove it
1896 if(!selected){
1897 remove_trace_from_traceset_selector(GTK_MULTIVPANED(tab->multivpaned), i);
1898
1899 traceset = tab->traceset_info->traceset;
1900 //Keep a reference to the traces so they are not freed.
1901 for(j=0; j<lttv_traceset_number(traceset); j++)
1902 {
1903 LttvTrace * trace = lttv_traceset_get(traceset, j);
1904 lttv_trace_ref(trace);
1905 }
1906
1907 //remove state update hooks
1908 lttv_state_remove_event_hooks(
1909 (LttvTracesetState*)tab->traceset_info->traceset_context);
1910 lttv_context_fini(LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context));
1911 g_object_unref(tab->traceset_info->traceset_context);
1912
1913
1914 trace_v = lttv_traceset_get(traceset, i);
1915
1916 if(lttv_trace_get_ref_number(trace_v) <= 2) {
1917 /* ref 2 : traceset, local */
1918 lttvwindowtraces_remove_trace(trace_v);
1919 ltt_trace_close(lttv_trace(trace_v));
1920 }
1921
1922 lttv_traceset_remove(traceset, i);
1923 lttv_trace_unref(trace_v); // Remove local reference
1924
1925 if(!lttv_trace_get_ref_number(trace_v))
1926 lttv_trace_destroy(trace_v);
1927
1928 tab->traceset_info->traceset_context =
1929 g_object_new(LTTV_TRACESET_STATS_TYPE, NULL);
1930 lttv_context_init(
1931 LTTV_TRACESET_CONTEXT(tab->
1932 traceset_info->traceset_context),traceset);
1933 //add state update hooks
1934 lttv_state_add_event_hooks(
1935 (LttvTracesetState*)tab->traceset_info->traceset_context);
1936
1937 //Remove local reference to the traces.
1938 for(j=0; j<lttv_traceset_number(traceset); j++)
1939 {
1940 LttvTrace * trace = lttv_traceset_get(traceset, j);
1941 lttv_trace_unref(trace);
1942 }
1943
1944
1945 //update current tab
1946 //update_traceset(mw_data);
1947 //if(nb_trace > 1){
1948
1949 SetTraceset(tab, (gpointer)traceset);
1950 // in expose now call_pending_read_hooks(mw_data);
1951
1952 //lttvwindow_report_current_time(mw_data,&(tab->current_time));
1953 //}else{
1954 // if(tab){
1955 // while(tab->multi_vpaned->num_children){
1956 // gtk_multi_vpaned_widget_delete(tab->multi_vpaned);
1957 // }
1958 // }
1959 //}
1960 }
1961 break;
1962 }
1963 }
1964 }
1965
1966 g_free(name);
1967 }
1968 #endif //0
1969
1970 /* Redraw all the viewers in the current tab */
1971 void redraw(GtkWidget *widget, gpointer user_data)
1972 {
1973 GtkWidget * notebook = lookup_widget(widget, "MNotebook");
1974 GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
1975 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
1976 Tab *tab;
1977 gboolean retval;
1978
1979 if(!page) {
1980 return;
1981 } else {
1982 LttvPluginTab *ptab;
1983 ptab = (LttvPluginTab *)g_object_get_data(G_OBJECT(page), "Tab_Plugin");
1984 tab = ptab->tab;
1985 }
1986
1987 LttvHooks * tmp;
1988 LttvAttributeValue value;
1989
1990 retval= lttv_iattribute_find_by_path(tab->attributes, "hooks/redraw", LTTV_POINTER, &value);
1991 g_assert(retval);
1992
1993 tmp = (LttvHooks*)*(value.v_pointer);
1994 if(tmp != NULL)
1995 lttv_hooks_call(tmp,NULL);
1996 }
1997
1998
1999 void continue_processing(GtkWidget *widget, gpointer user_data)
2000 {
2001 GtkWidget * notebook = lookup_widget(widget, "MNotebook");
2002 GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
2003 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
2004 Tab *tab;
2005 gboolean retval;
2006
2007 if(!page) {
2008 return;
2009 } else {
2010 LttvPluginTab *ptab;
2011 ptab = (LttvPluginTab *)g_object_get_data(G_OBJECT(page), "Tab_Plugin");
2012 tab = ptab->tab;
2013 }
2014
2015 LttvHooks * tmp;
2016 LttvAttributeValue value;
2017
2018 retval= lttv_iattribute_find_by_path(tab->attributes, "hooks/continue",
2019 LTTV_POINTER, &value);
2020 g_assert(retval);
2021
2022 tmp = (LttvHooks*)*(value.v_pointer);
2023 if(tmp != NULL)
2024 lttv_hooks_call(tmp,NULL);
2025 }
2026
2027 /* Stop the processing for the calling main window's current tab.
2028 * It removes every processing requests that are in its list. It does not call
2029 * the end request hooks, because the request is not finished.
2030 */
2031
2032 void stop_processing(GtkWidget *widget, gpointer user_data)
2033 {
2034 GtkWidget * notebook = lookup_widget(widget, "MNotebook");
2035 GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
2036 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
2037 Tab *tab;
2038 if(!page) {
2039 return;
2040 } else {
2041 LttvPluginTab *ptab;
2042 ptab = (LttvPluginTab *)g_object_get_data(G_OBJECT(page), "Tab_Plugin");
2043 tab = ptab->tab;
2044 }
2045 GSList *iter = tab->events_requests;
2046
2047 while(iter != NULL) {
2048 GSList *remove_iter = iter;
2049 iter = g_slist_next(iter);
2050
2051 g_free(remove_iter->data);
2052 tab->events_requests =
2053 g_slist_remove_link(tab->events_requests, remove_iter);
2054 }
2055 tab->events_request_pending = FALSE;
2056 tab->stop_foreground = TRUE;
2057 g_idle_remove_by_data(tab);
2058 g_assert(g_slist_length(tab->events_requests) == 0);
2059 }
2060
2061
2062 /* save will save the traceset to a file
2063 * Not implemented yet FIXME
2064 */
2065
2066 void save(GtkWidget * widget, gpointer user_data)
2067 {
2068 g_info("Save\n");
2069 }
2070
2071 void save_as(GtkWidget * widget, gpointer user_data)
2072 {
2073 g_info("Save as\n");
2074 }
2075
2076
2077 /* zoom will change the time_window of all the viewers of the
2078 * current tab, and redisplay them. The main functionality is to
2079 * determine the new time_window of the current tab
2080 */
2081
2082 void zoom(GtkWidget * widget, double size)
2083 {
2084 #ifdef BABEL_CLEANUP
2085 TimeInterval time_span;
2086 TimeWindow new_time_window;
2087 LttTime current_time, time_delta;
2088 LttvTracesetContext *tsc;
2089 GtkWidget * notebook = lookup_widget(widget, "MNotebook");
2090
2091 GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
2092 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
2093 Tab *tab;
2094
2095 if(!page) {
2096 return;
2097 } else {
2098 LttvPluginTab *ptab;
2099 ptab = (LttvPluginTab *)g_object_get_data(G_OBJECT(page), "Tab_Plugin");
2100 tab = ptab->tab;
2101 }
2102
2103 if(size == 1) return;
2104
2105 tsc = LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context);
2106 time_span = tsc->time_span;
2107 new_time_window = tab->time_window;
2108 current_time = tab->current_time;
2109
2110 time_delta = ltt_time_sub(time_span.end_time,time_span.start_time);
2111 if(size == 0){
2112 new_time_window.start_time = time_span.start_time;
2113 new_time_window.time_width = time_delta;
2114 new_time_window.time_width_double = ltt_time_to_double(time_delta);
2115 new_time_window.end_time = ltt_time_add(new_time_window.start_time,
2116 new_time_window.time_width) ;
2117 }else{
2118 new_time_window.time_width = ltt_time_div(new_time_window.time_width, size);
2119 new_time_window.time_width_double =
2120 ltt_time_to_double(new_time_window.time_width);
2121 if(ltt_time_compare(new_time_window.time_width,time_delta) > 0)
2122 { /* Case where zoom out is bigger than trace length */
2123 new_time_window.start_time = time_span.start_time;
2124 new_time_window.time_width = time_delta;
2125 new_time_window.time_width_double = ltt_time_to_double(time_delta);
2126 new_time_window.end_time = ltt_time_add(new_time_window.start_time,
2127 new_time_window.time_width) ;
2128 }
2129 else
2130 {
2131 /* Center the image on the current time */
2132 new_time_window.start_time =
2133 ltt_time_sub(current_time,
2134 ltt_time_from_double(new_time_window.time_width_double/2.0));
2135 new_time_window.end_time = ltt_time_add(new_time_window.start_time,
2136 new_time_window.time_width) ;
2137 /* If on borders, don't fall off */
2138 if(ltt_time_compare(new_time_window.start_time, time_span.start_time) <0
2139 || ltt_time_compare(new_time_window.start_time, time_span.end_time) >0)
2140 {
2141 new_time_window.start_time = time_span.start_time;
2142 new_time_window.end_time = ltt_time_add(new_time_window.start_time,
2143 new_time_window.time_width) ;
2144 }
2145 else
2146 {
2147 if(ltt_time_compare(new_time_window.end_time,
2148 time_span.end_time) > 0
2149 || ltt_time_compare(new_time_window.end_time,
2150 time_span.start_time) < 0)
2151 {
2152 new_time_window.start_time =
2153 ltt_time_sub(time_span.end_time, new_time_window.time_width);
2154
2155 new_time_window.end_time = ltt_time_add(new_time_window.start_time,
2156 new_time_window.time_width) ;
2157 }
2158 }
2159
2160 }
2161 }
2162
2163 if(ltt_time_compare(new_time_window.time_width, ltt_time_zero) == 0) {
2164 g_warning("Zoom more than 1 ns impossible");
2165 } else {
2166 time_change_manager(tab, new_time_window);
2167 }
2168
2169 #endif /* BABEL_CLEANUP */
2170 }
2171
2172 void zoom_in(GtkWidget * widget, gpointer user_data)
2173 {
2174 zoom(widget, 2);
2175 }
2176
2177 void zoom_out(GtkWidget * widget, gpointer user_data)
2178 {
2179 zoom(widget, 0.5);
2180 }
2181
2182 void zoom_extended(GtkWidget * widget, gpointer user_data)
2183 {
2184 zoom(widget, 0);
2185 }
2186
2187 void go_to_time(GtkWidget * widget, gpointer user_data)
2188 {
2189 g_info("Go to time\n");
2190 }
2191
2192 void show_time_frame(GtkWidget * widget, gpointer user_data)
2193 {
2194 g_info("Show time frame\n");
2195 }
2196
2197
2198 /* callback function */
2199
2200 void
2201 on_empty_traceset_activate (GtkMenuItem *menuitem,
2202 gpointer user_data)
2203 {
2204 create_new_window((GtkWidget*)menuitem, user_data, FALSE);
2205 }
2206
2207
2208 void
2209 on_clone_traceset_activate (GtkMenuItem *menuitem,
2210 gpointer user_data)
2211 {
2212 create_new_window((GtkWidget*)menuitem, user_data, TRUE);
2213 }
2214
2215
2216 /* create_new_tab calls create_tab to construct a new tab in the main window
2217 */
2218
2219 LttvPluginTab *create_new_tab(GtkWidget* widget, gpointer user_data)
2220 {
2221 gchar label[PATH_MAX];
2222 MainWindow * mw_data = get_window_data_struct(widget);
2223
2224 GtkNotebook * notebook = (GtkNotebook *)lookup_widget(widget, "MNotebook");
2225 if(notebook == NULL){
2226 g_info("Notebook does not exist\n");
2227 return NULL;
2228 }
2229 GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
2230 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
2231 Tab *copy_tab;
2232
2233 if(!page) {
2234 copy_tab = NULL;
2235 } else {
2236 LttvPluginTab *ptab;
2237 ptab = (LttvPluginTab *)g_object_get_data(G_OBJECT(page), "Tab_Plugin");
2238 copy_tab = ptab->tab;
2239 }
2240
2241 strcpy(label,"Page");
2242 if(get_label(mw_data, label,"Get the name of the tab","Please input tab's name")) {
2243 LttvPluginTab *ptab;
2244
2245 ptab = g_object_new(LTTV_TYPE_PLUGIN_TAB, NULL);
2246 init_tab (ptab->tab, mw_data, copy_tab, notebook, label);
2247 ptab->parent.top_widget = ptab->tab->top_widget;
2248 g_object_set_data_full(
2249 G_OBJECT(ptab->tab->vbox),
2250 "Tab_Plugin",
2251 ptab,
2252 (GDestroyNotify)tab_destructor);
2253 return ptab;
2254 }
2255 else return NULL;
2256 }
2257
2258 void
2259 on_tab_activate (GtkMenuItem *menuitem,
2260 gpointer user_data)
2261 {
2262 create_new_tab((GtkWidget*)menuitem, user_data);
2263 }
2264
2265
2266 void
2267 on_open_activate (GtkMenuItem *menuitem,
2268 gpointer user_data)
2269 {
2270 #ifdef UNFINISHED_FEATURE
2271 open_traceset((GtkWidget*)menuitem, user_data);
2272 #endif
2273 }
2274
2275
2276 void
2277 on_close_activate (GtkMenuItem *menuitem,
2278 gpointer user_data)
2279 {
2280 MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
2281 main_window_destructor(mw_data);
2282 }
2283
2284
2285 /* remove the current tab from the main window
2286 */
2287
2288 void
2289 on_close_tab_activate (GtkWidget *widget,
2290 gpointer user_data)
2291 {
2292 gint page_num;
2293 GtkWidget * notebook;
2294 notebook = lookup_widget(widget, "MNotebook");
2295 if(notebook == NULL){
2296 g_info("Notebook does not exist\n");
2297 return;
2298 }
2299
2300 page_num = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
2301
2302 gtk_notebook_remove_page(GTK_NOTEBOOK(notebook), page_num);
2303
2304 }
2305
2306 void
2307 on_close_tab_X_clicked (GtkWidget *widget,
2308 gpointer user_data)
2309 {
2310 gint page_num;
2311 GtkWidget *notebook = lookup_widget(widget, "MNotebook");
2312 if(notebook == NULL){
2313 g_info("Notebook does not exist\n");
2314 return;
2315 }
2316
2317 if((page_num = gtk_notebook_page_num(GTK_NOTEBOOK(notebook), widget)) != -1)
2318 gtk_notebook_remove_page(GTK_NOTEBOOK(notebook), page_num);
2319
2320 }
2321
2322
2323 void
2324 on_add_trace_activate (GtkMenuItem *menuitem,
2325 gpointer user_data)
2326 {
2327 add_trace((GtkWidget*)menuitem, user_data);
2328 }
2329
2330
2331 void
2332 on_remove_trace_activate (GtkMenuItem *menuitem,
2333 gpointer user_data)
2334 {
2335 remove_trace((GtkWidget*)menuitem, user_data);
2336 }
2337
2338
2339 void
2340 on_save_activate (GtkMenuItem *menuitem,
2341 gpointer user_data)
2342 {
2343 save((GtkWidget*)menuitem, user_data);
2344 }
2345
2346
2347 void
2348 on_save_as_activate (GtkMenuItem *menuitem,
2349 gpointer user_data)
2350 {
2351 save_as((GtkWidget*)menuitem, user_data);
2352 }
2353
2354
2355 void
2356 on_quit_activate (GtkMenuItem *menuitem,
2357 gpointer user_data)
2358 {
2359 while (g_slist_length(g_main_window_list) != 0) {
2360 on_MWindow_destroy(((MainWindow *)g_main_window_list->data)->mwindow,
2361 user_data);
2362 }
2363 }
2364
2365
2366 void
2367 on_cut_activate (GtkMenuItem *menuitem,
2368 gpointer user_data)
2369 {
2370 g_info("Cut\n");
2371 }
2372
2373
2374 void
2375 on_copy_activate (GtkMenuItem *menuitem,
2376 gpointer user_data)
2377 {
2378 g_info("Copye\n");
2379 }
2380
2381
2382 void
2383 on_paste_activate (GtkMenuItem *menuitem,
2384 gpointer user_data)
2385 {
2386 g_info("Paste\n");
2387 }
2388
2389
2390 void
2391 on_delete_activate (GtkMenuItem *menuitem,
2392 gpointer user_data)
2393 {
2394 g_info("Delete\n");
2395 }
2396
2397
2398 void
2399 on_zoom_in_activate (GtkMenuItem *menuitem,
2400 gpointer user_data)
2401 {
2402 zoom_in((GtkWidget*)menuitem, user_data);
2403 }
2404
2405
2406 void
2407 on_zoom_out_activate (GtkMenuItem *menuitem,
2408 gpointer user_data)
2409 {
2410 zoom_out((GtkWidget*)menuitem, user_data);
2411 }
2412
2413
2414 void
2415 on_zoom_extended_activate (GtkMenuItem *menuitem,
2416 gpointer user_data)
2417 {
2418 zoom_extended((GtkWidget*)menuitem, user_data);
2419 }
2420
2421
2422 void
2423 on_go_to_time_activate (GtkMenuItem *menuitem,
2424 gpointer user_data)
2425 {
2426 go_to_time((GtkWidget*)menuitem, user_data);
2427 }
2428
2429
2430 void
2431 on_show_time_frame_activate (GtkMenuItem *menuitem,
2432 gpointer user_data)
2433 {
2434 show_time_frame((GtkWidget*)menuitem, user_data);
2435 }
2436
2437
2438 void
2439 on_move_viewer_up_activate (GtkMenuItem *menuitem,
2440 gpointer user_data)
2441 {
2442 move_up_viewer((GtkWidget*)menuitem, user_data);
2443 }
2444
2445
2446 void
2447 on_move_viewer_down_activate (GtkMenuItem *menuitem,
2448 gpointer user_data)
2449 {
2450 move_down_viewer((GtkWidget*)menuitem, user_data);
2451 }
2452
2453
2454 void
2455 on_remove_viewer_activate (GtkMenuItem *menuitem,
2456 gpointer user_data)
2457 {
2458 delete_viewer((GtkWidget*)menuitem, user_data);
2459 }
2460
2461 void
2462 on_trace_facility_activate (GtkMenuItem *menuitem,
2463 gpointer user_data)
2464 {
2465 g_info("Trace facility selector: %s\n", "");
2466 }
2467
2468
2469 /* Dispaly a file selection dialogue to let user select a library, then call
2470 * lttv_library_load().
2471 */
2472
2473 void
2474 on_load_library_activate (GtkMenuItem *menuitem,
2475 gpointer user_data)
2476 {
2477 GError *error = NULL;
2478 MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
2479
2480 gchar load_module_path_alter[PATH_MAX];
2481 {
2482 GPtrArray *name;
2483 guint nb,i;
2484 gchar *load_module_path;
2485 name = g_ptr_array_new();
2486 nb = lttv_library_path_number();
2487 /* ask for the library path */
2488
2489 for(i=0;i<nb;i++){
2490 gchar *path;
2491 path = lttv_library_path_get(i);
2492 g_ptr_array_add(name, path);
2493 }
2494
2495 load_module_path = get_selection(mw_data,
2496 (char **)(name->pdata), name->len,
2497 "Select a library path", "Library paths");
2498 if(load_module_path != NULL)
2499 strncpy(load_module_path_alter, load_module_path, PATH_MAX-1); // -1 for /
2500
2501 g_ptr_array_free(name, TRUE);
2502
2503 if(load_module_path == NULL) return;
2504 }
2505
2506 {
2507 /* Make sure the module path ends with a / */
2508 gchar *ptr = load_module_path_alter;
2509
2510 ptr = strchr(ptr, '\0');
2511
2512 if(*(ptr-1) != '/') {
2513 *ptr = '/';
2514 *(ptr+1) = '\0';
2515 }
2516 }
2517
2518 {
2519 /* Ask for the library to load : list files in the previously selected
2520 * directory */
2521 gchar str[PATH_MAX];
2522 gchar ** dir;
2523 gint id;
2524 GtkFileSelection * file_selector =
2525 (GtkFileSelection *)gtk_file_selection_new("Select a module");
2526 gtk_file_selection_set_filename(file_selector, load_module_path_alter);
2527 gtk_file_selection_hide_fileop_buttons(file_selector);
2528
2529 gtk_window_set_transient_for(GTK_WINDOW(file_selector),
2530 GTK_WINDOW(mw_data->mwindow));
2531
2532 str[0] = '\0';
2533 id = gtk_dialog_run(GTK_DIALOG(file_selector));
2534 switch(id){
2535 case GTK_RESPONSE_ACCEPT:
2536 case GTK_RESPONSE_OK:
2537 dir = gtk_file_selection_get_selections (file_selector);
2538 strncpy(str,dir[0],PATH_MAX);
2539 strncpy(remember_plugins_dir,dir[0],PATH_MAX);
2540 /* only keep file name */
2541 gchar *str1;
2542 str1 = strrchr(str,'/');
2543 if(str1)str1++;
2544 else{
2545 str1 = strrchr(str,'\\');
2546 str1++;
2547 }
2548 #if 0
2549 /* remove "lib" */
2550 if(*str1 == 'l' && *(str1+1)== 'i' && *(str1+2)=='b')
2551 str1=str1+3;
2552 remove info after . */
2553 {
2554 gchar *str2 = str1;
2555
2556 str2 = strrchr(str2, '.');
2557 if(str2 != NULL) *str2 = '\0';
2558 }
2559 lttv_module_require(str1, &error);
2560 #endif //0
2561 lttv_library_load(str1, &error);
2562 if(error != NULL) g_warning("%s", error->message);
2563 else g_info("Load library: %s\n", str);
2564 g_strfreev(dir);
2565 case GTK_RESPONSE_REJECT:
2566 case GTK_RESPONSE_CANCEL:
2567 default:
2568 gtk_widget_destroy((GtkWidget*)file_selector);
2569 break;
2570 }
2571
2572 }
2573
2574
2575
2576 }
2577
2578
2579 /* Display all loaded modules, let user to select a module to unload
2580 * by calling lttv_module_unload
2581 */
2582
2583 void
2584 on_unload_library_activate (GtkMenuItem *menuitem,
2585 gpointer user_data)
2586 {
2587 MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
2588
2589 LttvLibrary *library = NULL;
2590
2591 GPtrArray *name;
2592 guint nb,i;
2593 gchar *lib_name;
2594 name = g_ptr_array_new();
2595 nb = lttv_library_number();
2596 LttvLibraryInfo *lib_info = g_new(LttvLibraryInfo,nb);
2597 /* ask for the library name */
2598
2599 for(i=0;i<nb;i++){
2600 LttvLibrary *iter_lib = lttv_library_get(i);
2601 lttv_library_info(iter_lib, &lib_info[i]);
2602
2603 gchar *path = lib_info[i].name;
2604 g_ptr_array_add(name, path);
2605 }
2606 lib_name = get_selection(mw_data, (char **)(name->pdata), name->len,
2607 "Select a library", "Libraries");
2608 if(lib_name != NULL) {
2609 for(i=0;i<nb;i++){
2610 if(strcmp(lib_name, lib_info[i].name) == 0) {
2611 library = lttv_library_get(i);
2612 break;
2613 }
2614 }
2615 }
2616 g_ptr_array_free(name, TRUE);
2617 g_free(lib_info);
2618
2619 if(lib_name == NULL) return;
2620
2621 if(library != NULL) lttv_library_unload(library);
2622 }
2623
2624
2625 /* Dispaly a file selection dialogue to let user select a module, then call
2626 * lttv_module_require().
2627 */
2628
2629 void
2630 on_load_module_activate (GtkMenuItem *menuitem,
2631 gpointer user_data)
2632 {
2633 GError *error = NULL;
2634 MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
2635
2636 LttvLibrary *library = NULL;
2637 {
2638 GPtrArray *name;
2639 guint nb,i;
2640 gchar *lib_name;
2641 name = g_ptr_array_new();
2642 nb = lttv_library_number();
2643 LttvLibraryInfo *lib_info = g_new(LttvLibraryInfo,nb);
2644 /* ask for the library name */
2645
2646 for(i=0;i<nb;i++){
2647 LttvLibrary *iter_lib = lttv_library_get(i);
2648 lttv_library_info(iter_lib, &lib_info[i]);
2649
2650 gchar *path = lib_info[i].name;
2651 g_ptr_array_add(name, path);
2652 }
2653 lib_name = get_selection(mw_data,(char **)(name->pdata), name->len,
2654 "Select a library", "Libraries");
2655 if(lib_name != NULL) {
2656 for(i=0;i<nb;i++){
2657 if(strcmp(lib_name, lib_info[i].name) == 0) {
2658 library = lttv_library_get(i);
2659 break;
2660 }
2661 }
2662 }
2663 g_ptr_array_free(name, TRUE);
2664 g_free(lib_info);
2665
2666 if(lib_name == NULL) return;
2667 }
2668
2669 //LttvModule *module;
2670 gchar module_name_out[PATH_MAX];
2671 {
2672 /* Ask for the module to load : list modules in the selected lib */
2673 GPtrArray *name;
2674 guint nb,i;
2675 gchar *module_name;
2676 nb = lttv_library_module_number(library);
2677 LttvModuleInfo *module_info = g_new(LttvModuleInfo,nb);
2678 name = g_ptr_array_new();
2679 /* ask for the module name */
2680
2681 for(i=0;i<nb;i++){
2682 LttvModule *iter_module = lttv_library_module_get(library, i);
2683 lttv_module_info(iter_module, &module_info[i]);
2684
2685 gchar *path = module_info[i].name;
2686 g_ptr_array_add(name, path);
2687 }
2688 module_name = get_selection(mw_data, (char **)(name->pdata), name->len,
2689 "Select a module", "Modules");
2690 if(module_name != NULL) {
2691 for(i=0;i<nb;i++){
2692 if(strcmp(module_name, module_info[i].name) == 0) {
2693 strncpy(module_name_out, module_name, PATH_MAX);
2694 //module = lttv_library_module_get(i);
2695 break;
2696 }
2697 }
2698 }
2699
2700 g_ptr_array_free(name, TRUE);
2701 g_free(module_info);
2702
2703 if(module_name == NULL) return;
2704 }
2705
2706 lttv_module_require(module_name_out, &error);
2707 if(error != NULL) g_warning("%s", error->message);
2708 else g_info("Load module: %s", module_name_out);
2709
2710
2711 #if 0
2712 {
2713
2714
2715 gchar str[PATH_MAX];
2716 gchar ** dir;
2717 gint id;
2718 GtkFileSelection * file_selector =
2719 (GtkFileSelection *)gtk_file_selection_new("Select a module");
2720 gtk_file_selection_set_filename(file_selector, load_module_path_alter);
2721 gtk_file_selection_hide_fileop_buttons(file_selector);
2722
2723 str[0] = '\0';
2724 id = gtk_dialog_run(GTK_DIALOG(file_selector));
2725 switch(id){
2726 case GTK_RESPONSE_ACCEPT:
2727 case GTK_RESPONSE_OK:
2728 dir = gtk_file_selection_get_selections (file_selector);
2729 strncpy(str,dir[0],PATH_MAX);
2730 strncpy(remember_plugins_dir,dir[0],PATH_MAX);
2731 {
2732 /* only keep file name */
2733 gchar *str1;
2734 str1 = strrchr(str,'/');
2735 if(str1)str1++;
2736 else{
2737 str1 = strrchr(str,'\\');
2738 str1++;
2739 }
2740 #if 0
2741 /* remove "lib" */
2742 if(*str1 == 'l' && *(str1+1)== 'i' && *(str1+2)=='b')
2743 str1=str1+3;
2744 remove info after . */
2745 {
2746 gchar *str2 = str1;
2747
2748 str2 = strrchr(str2, '.');
2749 if(str2 != NULL) *str2 = '\0';
2750 }
2751 lttv_module_require(str1, &error);
2752 #endif //0
2753 lttv_library_load(str1, &error);
2754 if(error != NULL) g_warning(error->message);
2755 else g_info("Load library: %s\n", str);
2756 g_strfreev(dir);
2757 case GTK_RESPONSE_REJECT:
2758 case GTK_RESPONSE_CANCEL:
2759 default:
2760 gtk_widget_destroy((GtkWidget*)file_selector);
2761 break;
2762 }
2763
2764 }
2765 #endif //0
2766
2767
2768 }
2769
2770
2771
2772 /* Display all loaded modules, let user to select a module to unload
2773 * by calling lttv_module_unload
2774 */
2775
2776 void
2777 on_unload_module_activate (GtkMenuItem *menuitem,
2778 gpointer user_data)
2779 {
2780 MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
2781
2782 LttvLibrary *library = NULL;
2783 {
2784 GPtrArray *name;
2785 guint nb,i;
2786 gchar *lib_name;
2787 name = g_ptr_array_new();
2788 nb = lttv_library_number();
2789 LttvLibraryInfo *lib_info = g_new(LttvLibraryInfo,nb);
2790 /* ask for the library name */
2791
2792 for(i=0;i<nb;i++){
2793 LttvLibrary *iter_lib = lttv_library_get(i);
2794 lttv_library_info(iter_lib, &lib_info[i]);
2795
2796 gchar *path = lib_info[i].name;
2797 g_ptr_array_add(name, path);
2798 }
2799 lib_name = get_selection(mw_data, (char **)(name->pdata), name->len,
2800 "Select a library", "Libraries");
2801 if(lib_name != NULL) {
2802 for(i=0;i<nb;i++){
2803 if(strcmp(lib_name, lib_info[i].name) == 0) {
2804 library = lttv_library_get(i);
2805 break;
2806 }
2807 }
2808 }
2809 g_ptr_array_free(name, TRUE);
2810 g_free(lib_info);
2811
2812 if(lib_name == NULL) return;
2813 }
2814
2815 LttvModule *module = NULL;
2816 {
2817 /* Ask for the module to load : list modules in the selected lib */
2818 GPtrArray *name;
2819 guint nb,i;
2820 gchar *module_name;
2821 nb = lttv_library_module_number(library);
2822 LttvModuleInfo *module_info = g_new(LttvModuleInfo,nb);
2823 name = g_ptr_array_new();
2824 /* ask for the module name */
2825
2826 for(i=0;i<nb;i++){
2827 LttvModule *iter_module = lttv_library_module_get(library, i);
2828 lttv_module_info(iter_module, &module_info[i]);
2829
2830 gchar *path = module_info[i].name;
2831 if(module_info[i].use_count > 0) g_ptr_array_add(name, path);
2832 }
2833 module_name = get_selection(mw_data, (char **)(name->pdata), name->len,
2834 "Select a module", "Modules");
2835 if(module_name != NULL) {
2836 for(i=0;i<nb;i++){
2837 if(strcmp(module_name, module_info[i].name) == 0) {
2838 module = lttv_library_module_get(library, i);
2839 break;
2840 }
2841 }
2842 }
2843
2844 g_ptr_array_free(name, TRUE);
2845 g_free(module_info);
2846
2847 if(module_name == NULL) return;
2848 }
2849
2850 LttvModuleInfo module_info;
2851 lttv_module_info(module, &module_info);
2852 g_info("Release module: %s\n", module_info.name);
2853
2854 lttv_module_release(module);
2855 }
2856
2857
2858 /* Display a directory dialogue to let user select a path for library searching
2859 */
2860
2861 void
2862 on_add_library_search_path_activate (GtkMenuItem *menuitem,
2863 gpointer user_data)
2864 {
2865 MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
2866 //GtkDirSelection * file_selector = (GtkDirSelection *)gtk_dir_selection_new("Select library path");
2867 GtkFileSelection * file_selector = (GtkFileSelection *)gtk_file_selection_new("Select a trace");
2868 gtk_widget_hide( (file_selector)->file_list->parent) ;
2869
2870 gtk_window_set_transient_for(GTK_WINDOW(file_selector),
2871 GTK_WINDOW(mw_data->mwindow));
2872
2873 const char * dir;
2874 gint id;
2875
2876 if(remember_plugins_dir[0] != '\0')
2877 gtk_file_selection_set_filename(file_selector, remember_plugins_dir);
2878
2879 id = gtk_dialog_run(GTK_DIALOG(file_selector));
2880 switch(id){
2881 case GTK_RESPONSE_ACCEPT:
2882 case GTK_RESPONSE_OK:
2883 dir = gtk_file_selection_get_filename (file_selector);
2884 strncpy(remember_plugins_dir,dir,PATH_MAX);
2885 strncat(remember_plugins_dir,"/",PATH_MAX);
2886 lttv_library_path_add(dir);
2887 case GTK_RESPONSE_REJECT:
2888 case GTK_RESPONSE_CANCEL:
2889 default:
2890 gtk_widget_destroy((GtkWidget*)file_selector);
2891 break;
2892 }
2893 }
2894
2895
2896 /* Display a directory dialogue to let user select a path for library searching
2897 */
2898
2899 void
2900 on_remove_library_search_path_activate (GtkMenuItem *menuitem,
2901 gpointer user_data)
2902 {
2903 MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
2904
2905 const char *lib_path;
2906 {
2907 GPtrArray *name;
2908 guint nb,i;
2909 name = g_ptr_array_new();
2910 nb = lttv_library_path_number();
2911 /* ask for the library name */
2912
2913 for(i=0;i<nb;i++){
2914 gchar *path = lttv_library_path_get(i);
2915 g_ptr_array_add(name, path);
2916 }
2917 lib_path = get_selection(mw_data, (char **)(name->pdata), name->len,
2918 "Select a library path", "Library paths");
2919
2920 g_ptr_array_free(name, TRUE);
2921
2922 if(lib_path == NULL) return;
2923 }
2924
2925 lttv_library_path_remove(lib_path);
2926 }
2927
2928 void
2929 on_color_activate (GtkMenuItem *menuitem,
2930 gpointer user_data)
2931 {
2932 g_info("Color\n");
2933 }
2934
2935
2936 void
2937 on_save_configuration_activate (GtkMenuItem *menuitem,
2938 gpointer user_data)
2939 {
2940 g_info("Save configuration\n");
2941 }
2942
2943
2944 void
2945 on_content_activate (GtkMenuItem *menuitem,
2946 gpointer user_data)
2947 {
2948 char* filename = NULL,
2949 *path;
2950 GdkScreen *screen;
2951 const char* relativePath = "doc/user/user_guide/html/index.html";
2952 filename = g_build_filename (g_get_current_dir(), relativePath, NULL);
2953 path = g_strdup_printf ("ghelp://%s", filename);
2954
2955 screen = gdk_screen_get_default();
2956 gtk_show_uri (screen, path, gtk_get_current_event_time(), NULL);
2957
2958 g_free(filename);
2959 g_free(path);
2960 g_info("Content\n");
2961 }
2962
2963
2964 static void
2965 on_about_close_activate (GtkButton *button,
2966 gpointer user_data)
2967 {
2968 GtkWidget *about_widget = GTK_WIDGET(user_data);
2969
2970 gtk_widget_destroy(about_widget);
2971 }
2972
2973 void
2974 on_about_activate (GtkMenuItem *menuitem,
2975 gpointer user_data)
2976 {
2977 MainWindow *main_window = get_window_data_struct(GTK_WIDGET(menuitem));
2978 GtkWidget *window_widget = main_window->mwindow;
2979 GtkWidget *about_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
2980 GtkWindow *about_window = GTK_WINDOW(about_widget);
2981
2982 gtk_window_set_title(about_window, "About Linux Trace Toolkit");
2983
2984 gtk_window_set_resizable(about_window, FALSE);
2985 gtk_window_set_transient_for(about_window, GTK_WINDOW(window_widget));
2986 gtk_window_set_destroy_with_parent(about_window, TRUE);
2987 gtk_window_set_modal(about_window, FALSE);
2988
2989 /* Put the about window at the center of the screen */
2990 gtk_window_set_position(about_window, GTK_WIN_POS_CENTER_ALWAYS);
2991
2992 GtkWidget *vbox = gtk_vbox_new(FALSE, 1);
2993
2994 gtk_container_add(GTK_CONTAINER(about_widget), vbox);
2995
2996 /* Text to show */
2997 GtkWidget *label1 = gtk_label_new("");
2998 gtk_misc_set_padding(GTK_MISC(label1), 10, 20);
2999 gtk_label_set_markup(GTK_LABEL(label1), "\
3000 <big>Linux Trace Toolkit " VERSION "</big>");
3001 gtk_label_set_justify(GTK_LABEL(label1), GTK_JUSTIFY_CENTER);
3002
3003 GtkWidget *label2 = gtk_label_new("");
3004 gtk_misc_set_padding(GTK_MISC(label2), 10, 20);
3005 gtk_label_set_markup(GTK_LABEL(label2), "\
3006 Contributors :\n\
3007 \n\
3008 Michel Dagenais (New trace format, lttv main)\n\
3009 Mathieu Desnoyers (Kernel Tracer, Directory structure, build with automake/conf,\n\
3010 lttv gui, control flow view, gui cooperative trace reading\n\
3011 scheduler with interruptible foreground and background\n\
3012 computation, detailed event list (rewrite), trace reading\n\
3013 library (rewrite))\n\
3014 Benoit Des Ligneris, Eric Clement (Cluster adaptation, work in progress)\n\
3015 Xang-Xiu Yang (new trace reading library and converter, lttv gui, \n\
3016 detailed event list and statistics view)\n\
3017 Tom Zanussi (RelayFS)\n\
3018 \n\
3019 Inspired from the original Linux Trace Toolkit Visualizer made by\n\
3020 Karim Yaghmour");
3021
3022 GtkWidget *label3 = gtk_label_new("");
3023 gtk_label_set_markup(GTK_LABEL(label3), "\
3024 Linux Trace Toolkit Viewer, Copyright (C) 2004, 2005, 2006\n\
3025 Michel Dagenais\n\
3026 Mathieu Desnoyers\n\
3027 Xang-Xiu Yang\n\
3028 Linux Trace Toolkit comes with ABSOLUTELY NO WARRANTY.\n\
3029 This is free software, and you are welcome to redistribute it\n\
3030 under certain conditions. See COPYING for details.");
3031 gtk_misc_set_padding(GTK_MISC(label3), 10, 20);
3032
3033 gtk_box_pack_start_defaults(GTK_BOX(vbox), label1);
3034 gtk_box_pack_start_defaults(GTK_BOX(vbox), label2);
3035 gtk_box_pack_start_defaults(GTK_BOX(vbox), label3);
3036
3037 GtkWidget *hbox = gtk_hbox_new(TRUE, 0);
3038 gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
3039 GtkWidget *close_button = gtk_button_new_with_mnemonic("_Close");
3040 gtk_box_pack_end(GTK_BOX(hbox), close_button, FALSE, FALSE, 0);
3041 gtk_container_set_border_width(GTK_CONTAINER(close_button), 20);
3042
3043 g_signal_connect(G_OBJECT(close_button), "clicked",
3044 G_CALLBACK(on_about_close_activate),
3045 (gpointer)about_widget);
3046
3047 gtk_widget_show_all(about_widget);
3048 }
3049
3050
3051 void
3052 on_button_new_clicked (GtkButton *button,
3053 gpointer user_data)
3054 {
3055 create_new_window((GtkWidget*)button, user_data, TRUE);
3056 }
3057
3058 void
3059 on_button_new_tab_clicked (GtkButton *button,
3060 gpointer user_data)
3061 {
3062 create_new_tab((GtkWidget*)button, user_data);
3063 }
3064
3065 void
3066 on_button_open_clicked (GtkButton *button,
3067 gpointer user_data)
3068 {
3069 #ifdef UNFINISHED_FEATURE
3070 open_traceset((GtkWidget*)button, user_data);
3071 #endif
3072 }
3073
3074
3075 void
3076 on_button_add_trace_clicked (GtkButton *button,
3077 gpointer user_data)
3078 {
3079 add_trace((GtkWidget*)button, user_data);
3080 }
3081
3082
3083 void
3084 on_button_remove_trace_clicked (GtkButton *button,
3085 gpointer user_data)
3086 {
3087 remove_trace((GtkWidget*)button, user_data);
3088 }
3089
3090 void
3091 on_button_redraw_clicked (GtkButton *button,
3092 gpointer user_data)
3093 {
3094 redraw((GtkWidget*)button, user_data);
3095 }
3096
3097 void
3098 on_button_continue_processing_clicked (GtkButton *button,
3099 gpointer user_data)
3100 {
3101 continue_processing((GtkWidget*)button, user_data);
3102 }
3103
3104 void
3105 on_button_stop_processing_clicked (GtkButton *button,
3106 gpointer user_data)
3107 {
3108 stop_processing((GtkWidget*)button, user_data);
3109 }
3110
3111
3112
3113 void
3114 on_button_save_clicked (GtkButton *button,
3115 gpointer user_data)
3116 {
3117 save((GtkWidget*)button, user_data);
3118 }
3119
3120
3121 void
3122 on_button_save_as_clicked (GtkButton *button,
3123 gpointer user_data)
3124 {
3125 save_as((GtkWidget*)button, user_data);
3126 }
3127
3128
3129 void
3130 on_button_zoom_in_clicked (GtkButton *button,
3131 gpointer user_data)
3132 {
3133 zoom_in((GtkWidget*)button, user_data);
3134 }
3135
3136
3137 void
3138 on_button_zoom_out_clicked (GtkButton *button,
3139 gpointer user_data)
3140 {
3141 zoom_out((GtkWidget*)button, user_data);
3142 }
3143
3144
3145 void
3146 on_button_zoom_extended_clicked (GtkButton *button,
3147 gpointer user_data)
3148 {
3149 zoom_extended((GtkWidget*)button, user_data);
3150 }
3151
3152
3153 void
3154 on_button_go_to_time_clicked (GtkButton *button,
3155 gpointer user_data)
3156 {
3157 go_to_time((GtkWidget*)button, user_data);
3158 }
3159
3160
3161 void
3162 on_button_show_time_frame_clicked (GtkButton *button,
3163 gpointer user_data)
3164 {
3165 show_time_frame((GtkWidget*)button, user_data);
3166 }
3167
3168
3169 void
3170 on_button_move_up_clicked (GtkButton *button,
3171 gpointer user_data)
3172 {
3173 move_up_viewer((GtkWidget*)button, user_data);
3174 }
3175
3176
3177 void
3178 on_button_move_down_clicked (GtkButton *button,
3179 gpointer user_data)
3180 {
3181 move_down_viewer((GtkWidget*)button, user_data);
3182 }
3183
3184
3185 void
3186 on_button_delete_viewer_clicked (GtkButton *button,
3187 gpointer user_data)
3188 {
3189 delete_viewer((GtkWidget*)button, user_data);
3190 }
3191
3192 void
3193 on_MWindow_destroy (GtkWidget *widget,
3194 gpointer user_data)
3195 {
3196 MainWindow *main_window = get_window_data_struct(widget);
3197 LttvIAttribute *attributes = main_window->attributes;
3198 LttvAttributeValue value;
3199 gboolean retval;
3200
3201 //This is unnecessary, since widgets will be destroyed
3202 //by the main window widget anyway.
3203 //remove_all_menu_toolbar_constructors(main_window, NULL);
3204
3205 retval= lttv_iattribute_find_by_path(attributes, "viewers/menu",
3206 LTTV_POINTER, &value);
3207 g_assert(retval);
3208 lttv_menus_destroy((LttvMenus*)*(value.v_pointer));
3209
3210 retval= lttv_iattribute_find_by_path(attributes, "viewers/toolbar",
3211 LTTV_POINTER, &value);
3212 g_assert(retval);
3213 lttv_toolbars_destroy((LttvToolbars*)*(value.v_pointer));
3214
3215 g_object_unref(main_window->attributes);
3216 g_main_window_list = g_slist_remove(g_main_window_list, main_window);
3217
3218 g_info("There are now : %d windows\n",g_slist_length(g_main_window_list));
3219 if(g_slist_length(g_main_window_list) == 0)
3220 mainwindow_quit();
3221 }
3222
3223 gboolean
3224 on_MWindow_configure (GtkWidget *widget,
3225 GdkEventConfigure *event,
3226 gpointer user_data)
3227 {
3228 // MD : removed time width modification upon resizing of the main window.
3229 // The viewers will redraw themselves completely, without time interval
3230 // modification.
3231 /* while(tab){
3232 if(mw_data->window_width){
3233 time_span = LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->Time_Span ;
3234 time_win = tab->time_window;
3235 ratio = width / mw_data->window_width;
3236 tab->time_window.time_width = ltt_time_mul(time_win.time_width,ratio);
3237 time = ltt_time_sub(time_span->endTime, time_win.start_time);
3238 if(ltt_time_compare(time, tab->time_window.time_width) < 0){
3239 tab->time_window.time_width = time;
3240 }
3241 }
3242 tab = tab->next;
3243 }
3244
3245 mw_data->window_width = (int)width;
3246 */
3247 return FALSE;
3248 }
3249
3250 /* Set current tab
3251 */
3252
3253 void
3254 on_MNotebook_switch_page (GtkNotebook *notebook,
3255 GtkNotebookPage *page,
3256 guint page_num,
3257 gpointer user_data)
3258 {
3259
3260 }
3261
3262
3263 void time_change_manager (Tab *tab,
3264 TimeWindow new_time_window)
3265 {
3266
3267 /* Only one source of time change */
3268 if(tab->time_manager_lock == TRUE) return;
3269
3270 tab->time_manager_lock = TRUE;
3271 TimeInterval time_span;
3272
3273 LttvTraceset *ts = tab->traceset_info->traceset;
3274 time_span.start_time =ltt_time_from_uint64( lttv_traceset_get_timestamp_begin(ts));
3275 time_span.end_time = ltt_time_from_uint64(lttv_traceset_get_timestamp_end(ts));
3276
3277
3278 LttTime start_time = new_time_window.start_time;
3279 LttTime end_time = new_time_window.end_time;
3280
3281 g_assert(ltt_time_compare(start_time, end_time) < 0);
3282
3283 /* Set scrollbar */
3284 GtkAdjustment *adjustment = gtk_range_get_adjustment(GTK_RANGE(tab->scrollbar));
3285 LttTime upper = ltt_time_sub(time_span.end_time, time_span.start_time);
3286
3287 #if 0
3288 gtk_range_set_increments(GTK_RANGE(tab->scrollbar),
3289 ltt_time_to_double(new_time_window.time_width)
3290 / SCROLL_STEP_PER_PAGE
3291 * NANOSECONDS_PER_SECOND, /* step increment */
3292 ltt_time_to_double(new_time_window.time_width)
3293 * NANOSECONDS_PER_SECOND); /* page increment */
3294 gtk_range_set_range(GTK_RANGE(tab->scrollbar),
3295 0.0, /* lower */
3296 ltt_time_to_double(upper)
3297 * NANOSECONDS_PER_SECOND); /* upper */
3298 #endif //0
3299 g_object_set(G_OBJECT(adjustment),
3300 "lower",
3301 0.0, /* lower */
3302 "upper",
3303 ltt_time_to_double(upper), /* upper */
3304 "step_increment",
3305 new_time_window.time_width_double
3306 / SCROLL_STEP_PER_PAGE, /* step increment */
3307 "page_increment",
3308 new_time_window.time_width_double,
3309 /* page increment */
3310 "page_size",
3311 new_time_window.time_width_double, /* page size */
3312 NULL);
3313 gtk_adjustment_changed(adjustment);
3314
3315 // g_object_set(G_OBJECT(adjustment),
3316 // "value",
3317 // ltt_time_to_double(
3318 // ltt_time_sub(start_time, time_span.start_time))
3319 // , /* value */
3320 // NULL);
3321 //gtk_adjustment_value_changed(adjustment);
3322 gtk_range_set_value(GTK_RANGE(tab->scrollbar),
3323 ltt_time_to_double(
3324 ltt_time_sub(start_time, time_span.start_time)) /* value */);
3325
3326 /* set the time bar. */
3327
3328
3329 timebar_set_minmax_time(TIMEBAR(tab->MTimebar),
3330 &time_span.start_time,
3331 &time_span.end_time );
3332 timebar_set_start_time(TIMEBAR(tab->MTimebar),&start_time);
3333 timebar_set_end_time(TIMEBAR(tab->MTimebar),&end_time);
3334
3335
3336
3337 /* call viewer hooks for new time window */
3338 set_time_window(tab, &new_time_window);
3339
3340 tab->time_manager_lock = FALSE;
3341
3342
3343 }
3344
3345
3346
3347
3348
3349 void current_time_change_manager (Tab *tab,
3350 LttTime new_current_time)
3351 {
3352 /* Only one source of time change */
3353 if(tab->current_time_manager_lock == TRUE) return;
3354
3355 tab->current_time_manager_lock = TRUE;
3356
3357 timebar_set_current_time(TIMEBAR(tab->MTimebar), &new_current_time);
3358
3359 set_current_time(tab, &new_current_time);
3360
3361 tab->current_time_manager_lock = FALSE;
3362 }
3363
3364 void current_position_change_manager(Tab *tab, LttvTracesetPosition *pos)
3365 {
3366 lttv_traceset_seek_to_position( pos);
3367
3368 LttTime new_time = lttv_traceset_position_get_time(pos);
3369 /* Put the context in a state coherent position */
3370 #ifdef BABEL_CLEANUP
3371 lttv_state_traceset_seek_time_closest((LttvTracesetState*)tsc, ltt_time_zero);
3372 #endif /* BABEL_CLEANUP */
3373 current_time_change_manager(tab, new_time);
3374
3375 set_current_position(tab, pos);
3376 }
3377
3378 static void on_timebar_starttime_changed(Timebar *timebar,
3379 gpointer user_data)
3380 {
3381 Tab *tab = (Tab *)user_data;
3382 LttvTraceset * ts =tab->traceset_info->traceset;
3383 TimeInterval time_span = lttv_traceset_get_time_span(ts);
3384
3385 TimeWindow new_time_window = tab->time_window;
3386 new_time_window.start_time = timebar_get_start_time(timebar);
3387
3388 LttTime end_time = new_time_window.end_time;
3389
3390 /* TODO ybrosseau 2010-12-02: This if should have been checked
3391 by the timebar already */
3392 if(ltt_time_compare(new_time_window.start_time, end_time) >= 0) {
3393 /* Then, we must push back end time : keep the same time width
3394 * if possible, else end traceset time */
3395 end_time = LTT_TIME_MIN(ltt_time_add(new_time_window.start_time,
3396 new_time_window.time_width),
3397 time_span.end_time);
3398 }
3399
3400 /* Fix the time width to fit start time and end time */
3401 new_time_window.time_width = ltt_time_sub(end_time,
3402 new_time_window.start_time);
3403
3404 new_time_window.time_width_double =
3405 ltt_time_to_double(new_time_window.time_width);
3406
3407 new_time_window.end_time = end_time;
3408
3409 /* Notify the time_manager */
3410 time_change_manager(tab, new_time_window);
3411
3412 }
3413
3414 static void on_timebar_endtime_changed(Timebar *timebar,
3415 gpointer user_data)
3416 {
3417 Tab *tab = (Tab *)user_data;
3418 LttvTraceset * ts =tab->traceset_info->traceset;
3419 TimeInterval time_span = lttv_traceset_get_time_span(ts);
3420
3421 TimeWindow new_time_window = tab->time_window;
3422
3423 LttTime end_time = timebar_get_end_time(timebar);
3424
3425 /* TODO ybrosseau 2010-12-02: This if should have been
3426 checked by the timebar already */
3427 if(ltt_time_compare(new_time_window.start_time, end_time) >= 0) {
3428 /* Then, we must push front start time : keep the same time
3429 width if possible, else end traceset time */
3430 new_time_window.start_time = LTT_TIME_MAX(
3431 ltt_time_sub(end_time,
3432 new_time_window.time_width),
3433 time_span.start_time);
3434 }
3435
3436 /* Fix the time width to fit start time and end time */
3437 new_time_window.time_width = ltt_time_sub(end_time,
3438 new_time_window.start_time);
3439
3440 new_time_window.time_width_double =
3441 ltt_time_to_double(new_time_window.time_width);
3442
3443 new_time_window.end_time = end_time;
3444
3445 /* Notify the time_manager */
3446 time_change_manager(tab, new_time_window);
3447 }
3448 static void on_timebar_currenttime_changed(Timebar *timebar,
3449 gpointer user_data)
3450 {
3451 Tab *tab = (Tab *)user_data;
3452
3453 LttTime new_current_time = timebar_get_current_time(timebar);
3454
3455 current_time_change_manager(tab, new_current_time);
3456 }
3457
3458 void scroll_value_changed_cb(GtkWidget *scrollbar,
3459 gpointer user_data)
3460 {
3461 Tab *tab = (Tab *)user_data;
3462 TimeWindow new_time_window;
3463 LttTime time;
3464 GtkAdjustment *adjust = gtk_range_get_adjustment(GTK_RANGE(scrollbar));
3465 gdouble value = gtk_adjustment_get_value(adjust);
3466 // gdouble upper, lower, ratio, page_size;
3467 gdouble page_size;
3468
3469 LttvTraceset * ts = tab->traceset_info->traceset;
3470 TimeInterval time_span = lttv_traceset_get_time_span(ts);
3471
3472 time = ltt_time_add(ltt_time_from_double(value),
3473 time_span.start_time);
3474
3475 new_time_window.start_time = time;
3476
3477 page_size = adjust->page_size;
3478
3479 new_time_window.time_width =
3480 ltt_time_from_double(page_size);
3481
3482 new_time_window.time_width_double =
3483 page_size;
3484
3485 new_time_window.end_time = ltt_time_add(new_time_window.start_time,
3486 new_time_window.time_width);
3487
3488
3489 time_change_manager(tab, new_time_window);
3490
3491 #if 0
3492 //time_window = tab->time_window;
3493
3494 lower = adjust->lower;
3495 upper = adjust->upper;
3496 ratio = (value - lower) / (upper - lower);
3497 g_info("lower %lu, upper %lu, value %lu, ratio %lu", lower, upper, value, ratio);
3498
3499 //time = ltt_time_sub(time_span->end_time, time_span->start_time);
3500 //time = ltt_time_mul(time, (float)ratio);
3501 //time = ltt_time_add(time_span->start_time, time);
3502 time = ltt_time_add(ltt_time_from_double(value),
3503 time_span.start_time);
3504
3505 time_window.start_time = time;
3506
3507 page_size = adjust->page_size;
3508
3509 time_window.time_width =
3510 ltt_time_from_double(page_size);
3511 //time = ltt_time_sub(time_span.end_time, time);
3512 //if(ltt_time_compare(time,time_window.time_width) < 0){
3513 // time_window.time_width = time;
3514 //}
3515
3516 /* call viewer hooks for new time window */
3517 set_time_window(tab, &time_window);
3518 #endif //0
3519
3520 }
3521
3522
3523 /* Display a dialogue showing all eventtypes and traces, let user to select the interested
3524 * eventtypes, tracefiles and traces (filter)
3525 */
3526
3527 /* Select a trace which will be removed from traceset
3528 */
3529
3530 char * get_remove_trace(MainWindow *mw_data,
3531 char ** all_trace_name, int nb_trace)
3532 {
3533 return get_selection(mw_data, all_trace_name, nb_trace,
3534 "Select a trace", "Trace pathname");
3535 }
3536
3537
3538 /* Select a module which will be loaded
3539 */
3540
3541 char * get_load_module(MainWindow *mw_data,
3542 char ** load_module_name, int nb_module)
3543 {
3544 return get_selection(mw_data, load_module_name, nb_module,
3545 "Select a module to load", "Module name");
3546 }
3547
3548
3549
3550
3551 /* Select a module which will be unloaded
3552 */
3553
3554 char * get_unload_module(MainWindow *mw_data,
3555 char ** loaded_module_name, int nb_module)
3556 {
3557 return get_selection(mw_data, loaded_module_name, nb_module,
3558 "Select a module to unload", "Module name");
3559 }
3560
3561
3562 /* Display a dialogue which shows all selectable items, let user to
3563 * select one of them
3564 */
3565
3566 char * get_selection(MainWindow *mw_data,
3567 char ** loaded_module_name, int nb_module,
3568 char *title, char * column_title)
3569 {
3570 GtkWidget * dialogue;
3571 GtkWidget * scroll_win;
3572 GtkWidget * tree;
3573 GtkListStore * store;
3574 GtkTreeViewColumn * column;
3575 GtkCellRenderer * renderer;
3576 GtkTreeSelection * select;
3577 GtkTreeIter iter;
3578 gint id, i;
3579 char * unload_module_name = NULL;
3580
3581 dialogue = gtk_dialog_new_with_buttons(title,
3582 NULL,
3583 GTK_DIALOG_MODAL,
3584 GTK_STOCK_OK,GTK_RESPONSE_ACCEPT,
3585 GTK_STOCK_CANCEL,GTK_RESPONSE_REJECT,
3586 NULL);
3587 gtk_window_set_default_size((GtkWindow*)dialogue, 500, 200);
3588 gtk_window_set_transient_for(GTK_WINDOW(dialogue),
3589 GTK_WINDOW(mw_data->mwindow));
3590
3591 scroll_win = gtk_scrolled_window_new (NULL, NULL);
3592 gtk_widget_show ( scroll_win);
3593 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win),
3594 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
3595
3596 store = gtk_list_store_new (N_COLUMNS,G_TYPE_STRING);
3597 tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL (store));
3598 gtk_widget_show ( tree);
3599 g_object_unref (G_OBJECT (store));
3600
3601 renderer = gtk_cell_renderer_text_new ();
3602 column = gtk_tree_view_column_new_with_attributes (column_title,
3603 renderer,
3604 "text", MODULE_COLUMN,
3605 NULL);
3606 gtk_tree_view_column_set_alignment (column, 0.5);
3607 gtk_tree_view_column_set_fixed_width (column, 150);
3608 gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
3609
3610 select = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree));
3611 gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE);
3612
3613 gtk_container_add (GTK_CONTAINER (scroll_win), tree);
3614
3615 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), scroll_win,TRUE, TRUE,0);
3616
3617 for(i=0;i<nb_module;i++){
3618 gtk_list_store_append (store, &iter);
3619 gtk_list_store_set (store, &iter, MODULE_COLUMN,loaded_module_name[i],-1);
3620 }
3621
3622 id = gtk_dialog_run(GTK_DIALOG(dialogue));
3623 GtkTreeModel **store_model = (GtkTreeModel**)&store;
3624 switch(id){
3625 case GTK_RESPONSE_ACCEPT:
3626 case GTK_RESPONSE_OK:
3627 if (gtk_tree_selection_get_selected (select, store_model, &iter)){
3628 gtk_tree_model_get ((GtkTreeModel*)store, &iter, MODULE_COLUMN, &unload_module_name, -1);
3629 }
3630 case GTK_RESPONSE_REJECT:
3631 case GTK_RESPONSE_CANCEL:
3632 default:
3633 gtk_widget_destroy(dialogue);
3634 break;
3635 }
3636
3637 return unload_module_name;
3638 }
3639
3640
3641 /* Insert all menu entry and tool buttons into this main window
3642 * for modules.
3643 *
3644 */
3645
3646 void add_all_menu_toolbar_constructors(MainWindow * mw, gpointer user_data)
3647 {
3648 guint i;
3649 GdkPixbuf *pixbuf;
3650 lttvwindow_viewer_constructor constructor;
3651 LttvMenus * global_menu, * instance_menu;
3652 LttvToolbars * global_toolbar, * instance_toolbar;
3653 LttvMenuClosure *menu_item;
3654 LttvToolbarClosure *toolbar_item;
3655 LttvAttributeValue value;
3656 LttvIAttribute *global_attributes = LTTV_IATTRIBUTE(lttv_global_attributes());
3657 LttvIAttribute *attributes = mw->attributes;
3658 GtkWidget * tool_menu_title_menu, *new_widget, *pixmap;
3659 gboolean retval;
3660
3661 retval= lttv_iattribute_find_by_path(global_attributes, "viewers/menu",
3662 LTTV_POINTER, &value);
3663 g_assert(retval);
3664 if(*(value.v_pointer) == NULL)
3665 *(value.v_pointer) = lttv_menus_new();
3666 global_menu = (LttvMenus*)*(value.v_pointer);
3667
3668 retval= lttv_iattribute_find_by_path(attributes, "viewers/menu",
3669 LTTV_POINTER, &value);
3670 g_assert(retval);
3671 if(*(value.v_pointer) == NULL)
3672 *(value.v_pointer) = lttv_menus_new();
3673 instance_menu = (LttvMenus*)*(value.v_pointer);
3674
3675 retval= lttv_iattribute_find_by_path(global_attributes, "viewers/toolbar",
3676 LTTV_POINTER, &value);
3677 g_assert(retval);
3678 if(*(value.v_pointer) == NULL)
3679 *(value.v_pointer) = lttv_toolbars_new();
3680 global_toolbar = (LttvToolbars*)*(value.v_pointer);
3681
3682 retval= lttv_iattribute_find_by_path(attributes, "viewers/toolbar",
3683 LTTV_POINTER, &value);
3684 g_assert(retval);
3685 if(*(value.v_pointer) == NULL)
3686 *(value.v_pointer) = lttv_toolbars_new();
3687 instance_toolbar = (LttvToolbars*)*(value.v_pointer);
3688
3689 /* Add missing menu entries to window instance */
3690 for(i=0;i<global_menu->len;i++) {
3691 menu_item = &g_array_index(global_menu, LttvMenuClosure, i);
3692
3693 //add menu_item to window instance;
3694 constructor = menu_item->con;
3695 tool_menu_title_menu = lookup_widget(mw->mwindow,"ToolMenuTitle_menu");
3696 new_widget =
3697 gtk_menu_item_new_with_mnemonic (menu_item->menu_text);
3698 gtk_container_add (GTK_CONTAINER (tool_menu_title_menu),
3699 new_widget);
3700 g_signal_connect ((gpointer) new_widget, "activate",
3701 G_CALLBACK (insert_viewer_wrap),
3702 constructor);
3703 gtk_widget_show (new_widget);
3704 lttv_menus_add(instance_menu, menu_item->con,
3705 menu_item->menu_path,
3706 menu_item->menu_text,
3707 new_widget);
3708
3709 }
3710
3711 /* Add missing toolbar entries to window instance */
3712 for(i=0;i<global_toolbar->len;i++) {
3713 toolbar_item = &g_array_index(global_toolbar, LttvToolbarClosure, i);
3714
3715 //add toolbar_item to window instance;
3716 constructor = toolbar_item->con;
3717 tool_menu_title_menu = lookup_widget(mw->mwindow,"MToolbar1");
3718 pixbuf = gdk_pixbuf_new_from_xpm_data((const char**)toolbar_item->pixmap);
3719 pixmap = gtk_image_new_from_pixbuf(pixbuf);
3720 new_widget =
3721 gtk_toolbar_append_element (GTK_TOOLBAR (tool_menu_title_menu),
3722 GTK_TOOLBAR_CHILD_BUTTON,
3723 NULL,
3724 "",
3725 toolbar_item->tooltip, NULL,
3726 pixmap, NULL, NULL);
3727 gtk_label_set_use_underline(
3728 GTK_LABEL (((GtkToolbarChild*) (
3729 g_list_last (GTK_TOOLBAR
3730 (tool_menu_title_menu)->children)->data))->label),
3731 TRUE);
3732 gtk_container_set_border_width (GTK_CONTAINER (new_widget), 1);
3733 g_signal_connect ((gpointer) new_widget,
3734 "clicked",
3735 G_CALLBACK (insert_viewer_wrap),
3736 constructor);
3737 gtk_widget_show (new_widget);
3738
3739 lttv_toolbars_add(instance_toolbar, toolbar_item->con,
3740 toolbar_item->tooltip,
3741 toolbar_item->pixmap,
3742 new_widget);
3743
3744 }
3745
3746 }
3747
3748
3749 /* Create a main window
3750 */
3751
3752 MainWindow *construct_main_window(MainWindow * parent)
3753 {
3754 gboolean retval;
3755
3756 g_debug("construct_main_window()");
3757 GtkWidget * new_window; /* New generated main window */
3758 MainWindow * new_m_window;/* New main window structure */
3759 GtkNotebook * notebook;
3760 LttvIAttribute *attributes =
3761 LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE, NULL));
3762 LttvAttributeValue value;
3763
3764 new_m_window = g_new(MainWindow, 1);
3765
3766 // Add the object's information to the module's array
3767 g_main_window_list = g_slist_append(g_main_window_list, new_m_window);
3768
3769 new_window = create_MWindow();
3770 gtk_widget_show (new_window);
3771
3772 new_m_window->mwindow = new_window;
3773 new_m_window->attributes = attributes;
3774
3775 retval= lttv_iattribute_find_by_path(attributes, "viewers/menu",
3776 LTTV_POINTER, &value);
3777 g_assert(retval);
3778 *(value.v_pointer) = lttv_menus_new();
3779
3780 retval= lttv_iattribute_find_by_path(attributes, "viewers/toolbar",
3781 LTTV_POINTER, &value);
3782 g_assert(retval);
3783 *(value.v_pointer) = lttv_toolbars_new();
3784
3785 add_all_menu_toolbar_constructors(new_m_window, NULL);
3786
3787 g_object_set_data_full(G_OBJECT(new_window),
3788 "main_window_data",
3789 (gpointer)new_m_window,
3790 (GDestroyNotify)g_free);
3791 //create a default tab
3792 notebook = (GtkNotebook *)lookup_widget(new_m_window->mwindow, "MNotebook");
3793 if(notebook == NULL){
3794 g_info("Notebook does not exist\n");
3795 /* FIXME : destroy partially created widgets */
3796 g_free(new_m_window);
3797 return NULL;
3798 }
3799 //gtk_notebook_popup_enable (GTK_NOTEBOOK(notebook));
3800 //for now there is no name field in LttvTraceset structure
3801 //Use "Traceset" as the label for the default tab
3802 if(parent) {
3803 GtkWidget * parent_notebook = lookup_widget(parent->mwindow, "MNotebook");
3804 GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(parent_notebook),
3805 gtk_notebook_get_current_page(GTK_NOTEBOOK(parent_notebook)));
3806 Tab *parent_tab;
3807
3808 if(!page) {
3809 parent_tab = NULL;
3810 } else {
3811 LttvPluginTab *ptab;
3812 ptab = (LttvPluginTab *)g_object_get_data(G_OBJECT(page), "Tab_Plugin");
3813 parent_tab = ptab->tab;
3814 }
3815 LttvPluginTab *ptab = g_object_new(LTTV_TYPE_PLUGIN_TAB, NULL);
3816 init_tab(ptab->tab,
3817 new_m_window, parent_tab, notebook, "Traceset");
3818 ptab->parent.top_widget = ptab->tab->top_widget;
3819 g_object_set_data_full(
3820 G_OBJECT(ptab->tab->vbox),
3821 "Tab_Plugin",
3822 ptab,
3823 (GDestroyNotify)tab_destructor);
3824 } else {
3825 LttvPluginTab *ptab = g_object_new(LTTV_TYPE_PLUGIN_TAB, NULL);
3826 init_tab(ptab->tab, new_m_window, NULL, notebook, "Traceset");
3827 ptab->parent.top_widget = ptab->tab->top_widget;
3828 g_object_set_data_full(
3829 G_OBJECT(ptab->tab->vbox),
3830 "Tab_Plugin",
3831 ptab,
3832 (GDestroyNotify)tab_destructor);
3833 }
3834
3835 /* Insert default viewers */
3836 {
3837 LttvAttributeType type;
3838 LttvAttributeName name;
3839 LttvAttributeValue value;
3840 LttvAttribute *attribute;
3841
3842 LttvIAttribute *attributes_global =
3843 LTTV_IATTRIBUTE(lttv_global_attributes());
3844
3845 attribute = LTTV_ATTRIBUTE(lttv_iattribute_find_subdir(
3846 LTTV_IATTRIBUTE(attributes_global),
3847 LTTV_VIEWER_CONSTRUCTORS));
3848 g_assert(attribute);
3849
3850 name = g_quark_from_string("guievents");
3851 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute),
3852 name, &value);
3853 if(type == LTTV_POINTER) {
3854 lttvwindow_viewer_constructor viewer_constructor =
3855 (lttvwindow_viewer_constructor)*value.v_pointer;
3856 insert_viewer(new_window, viewer_constructor);
3857 }
3858
3859 name = g_quark_from_string("guicontrolflow");
3860 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute),
3861 name, &value);
3862 if(type == LTTV_POINTER) {
3863 lttvwindow_viewer_constructor viewer_constructor =
3864 (lttvwindow_viewer_constructor)*value.v_pointer;
3865 insert_viewer(new_window, viewer_constructor);
3866 }
3867
3868 name = g_quark_from_string("guistatistics");
3869 type = lttv_iattribute_get_by_name(LTTV_IATTRIBUTE(attribute),
3870 name, &value);
3871 if(type == LTTV_POINTER) {
3872 lttvwindow_viewer_constructor viewer_constructor =
3873 (lttvwindow_viewer_constructor)*value.v_pointer;
3874 insert_viewer(new_window, viewer_constructor);
3875 }
3876 }
3877
3878 g_info("There are now : %d windows\n",g_slist_length(g_main_window_list));
3879
3880 return new_m_window;
3881 }
3882
3883
3884 /* Free the memory occupied by a tab structure
3885 * destroy the tab
3886 */
3887
3888 void tab_destructor(LttvPluginTab * ptab)
3889 {
3890 #ifdef BABEL_CLEANUP
3891 int i, nb, ref_count;
3892 LttvTrace * trace;
3893 Tab *tab = ptab->tab;
3894
3895 if(tab->attributes)
3896 g_object_unref(tab->attributes);
3897
3898 if(tab->interrupted_state)
3899 g_object_unref(tab->interrupted_state);
3900
3901
3902 if(tab->traceset_info->traceset_context != NULL){
3903 //remove state update hooks
3904 lttv_state_remove_event_hooks(
3905 (LttvTracesetState*)tab->traceset_info->
3906 traceset_context);
3907 lttv_context_fini(LTTV_TRACESET_CONTEXT(tab->traceset_info->
3908 traceset_context));
3909 g_object_unref(tab->traceset_info->traceset_context);
3910 }
3911 if(tab->traceset_info->traceset != NULL) {
3912 nb = lttv_traceset_number(tab->traceset_info->traceset);
3913 for(i = 0 ; i < nb ; i++) {
3914 trace = lttv_traceset_get(tab->traceset_info->traceset, i);
3915 ref_count = lttv_trace_get_ref_number(trace);
3916 if(ref_count <= 1){
3917 ltt_trace_close(lttv_trace(trace));
3918 }
3919 }
3920 }
3921 lttv_traceset_destroy(tab->traceset_info->traceset);
3922 /* Remove the idle events requests processing function of the tab */
3923 g_idle_remove_by_data(tab);
3924
3925 g_slist_free(tab->events_requests);
3926 g_free(tab->traceset_info);
3927 //g_free(tab);
3928 g_object_unref(ptab);
3929 #endif /* BABEL_CLEANUP */
3930 }
3931
3932
3933 /* Create a tab and insert it into the current main window
3934 */
3935
3936 void init_tab(Tab *tab, MainWindow * mw, Tab *copy_tab,
3937 GtkNotebook * notebook, char * label)
3938 {
3939
3940 GList * list;
3941 //Tab * tab;
3942 //LttvFilter *filter = NULL;
3943
3944 //create a new tab data structure
3945 //tab = g_new(Tab,1);
3946
3947 //construct and initialize the traceset_info
3948 tab->traceset_info = g_new(TracesetInfo,1);
3949
3950 if(copy_tab) {
3951 tab->traceset_info->traceset =
3952 lttv_traceset_copy(copy_tab->traceset_info->traceset);
3953
3954 /* Copy the previous tab's filter */
3955 /* We can clone the filter, as we copy the trace set also */
3956 /* The filter must always be in sync with the trace set */
3957
3958 #ifdef BABEL_CLEANUP
3959 tab->filter = lttv_filter_clone(copy_tab->filter);
3960 #endif /* BABEL_CLEANUP */
3961 } else {
3962 tab->traceset_info->traceset = lttv_traceset_new();
3963
3964 tab->filter = NULL;
3965 }
3966 #ifdef DEBUG
3967 lttv_attribute_write_xml(
3968 lttv_traceset_attribute(tab->traceset_info->traceset),
3969 stdout,
3970 0, 4);
3971 fflush(stdout);
3972 #endif //DEBUG
3973 //
3974 tab->time_manager_lock = FALSE;
3975 tab->current_time_manager_lock = FALSE;
3976 #ifdef BABEL_CLEANUP
3977 //FIXME copy not implemented in lower level
3978 tab->traceset_info->traceset_context =
3979 g_object_new(LTTV_TRACESET_STATS_TYPE, NULL);
3980 //add state update hooks
3981 lttv_state_add_event_hooks(
3982 (LttvTracesetState*)tab->traceset_info->traceset_context);
3983 #endif //BABEL_CLEANUP
3984 //determine the current_time and time_window of the tab
3985 #if 0
3986 if(copy_tab != NULL){
3987 tab->time_window = copy_tab->time_window;
3988 tab->current_time = copy_tab->current_time;
3989 }else{
3990 tab->time_window.start_time =
3991 LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->
3992 time_span.start_time;
3993 if(DEFAULT_TIME_WIDTH_S <
3994 LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->
3995 time_span.end_time.tv_sec)
3996 tmp_time.tv_sec = DEFAULT_TIME_WIDTH_S;
3997 else
3998 tmp_time.tv_sec =
3999 LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->
4000 time_span.end_time.tv_sec;
4001 tmp_time.tv_nsec = 0;
4002 tab->time_window.time_width = tmp_time ;
4003 tab->current_time.tv_sec =
4004 LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->
4005 time_span.start_time.tv_sec;
4006 tab->current_time.tv_nsec =
4007 LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->
4008 time_span.start_time.tv_nsec;
4009 }
4010 #endif //0
4011 tab->attributes = LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE, NULL));
4012 tab->interrupted_state = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
4013
4014 tab->vbox = gtk_vbox_new(FALSE, 2);
4015 tab->top_widget = tab->vbox;
4016 //g_object_set_data_full(G_OBJECT(tab->top_widget), "filter",
4017 // filter, (GDestroyNotify)lttv_filter_destroy);
4018
4019 // g_signal_connect (G_OBJECT(tab->top_widget),
4020 // "notify",
4021 // G_CALLBACK (on_top_notify),
4022 // (gpointer)tab);
4023
4024 tab->viewer_container = gtk_vbox_new(TRUE, 2);
4025 tab->scrollbar = gtk_hscrollbar_new(NULL);
4026 //tab->multivpaned = gtk_multi_vpaned_new();
4027
4028 gtk_box_pack_start(GTK_BOX(tab->vbox),
4029 tab->viewer_container,
4030 TRUE, /* expand */
4031 TRUE, /* Give the extra space to the child */
4032 0); /* No padding */
4033
4034 // if(copy_tab) {
4035 // tab->time_window = copy_tab->time_window;
4036 // tab->current_time = copy_tab->current_time;
4037 // }
4038
4039 /* Create the timebar */
4040
4041 tab->MTimebar = timebar_new();
4042
4043 gtk_box_pack_end(GTK_BOX(tab->vbox),
4044 tab->scrollbar,
4045 FALSE, /* Do not expand */
4046 FALSE, /* Fill has no effect here (expand false) */
4047 0); /* No padding */
4048
4049 gtk_box_pack_end(GTK_BOX(tab->vbox),
4050 tab->MTimebar,
4051 FALSE, /* Do not expand */
4052 FALSE, /* Fill has no effect here (expand false) */
4053 0); /* No padding */
4054
4055 g_object_set_data(G_OBJECT(tab->viewer_container), "focused_viewer", NULL);
4056
4057
4058 tab->mw = mw;
4059
4060 /*{
4061 // Display a label with a X
4062 GtkWidget *w_hbox = gtk_hbox_new(FALSE, 4);
4063 GtkWidget *w_label = gtk_label_new (label);
4064 GtkWidget *pixmap = create_pixmap(GTK_WIDGET(notebook), "close.png");
4065 GtkWidget *w_button = gtk_button_new ();
4066 gtk_container_add(GTK_CONTAINER(w_button), pixmap);
4067 //GtkWidget *w_button = gtk_button_new_with_label("x");
4068
4069 gtk_button_set_relief(GTK_BUTTON(w_button), GTK_RELIEF_NONE);
4070
4071 gtk_box_pack_start(GTK_BOX(w_hbox), w_label, TRUE, TRUE, 0);
4072 gtk_box_pack_end(GTK_BOX(w_hbox), w_button, FALSE,
4073 FALSE, 0);
4074
4075 g_signal_connect_swapped (w_button, "clicked",
4076 G_CALLBACK (on_close_tab_X_clicked),
4077 tab->multi_vpaned);
4078
4079 gtk_widget_set_state(w_button, GTK_STATE_ACTIVE);
4080
4081 gtk_widget_show (w_label);
4082 gtk_widget_show (pixmap);
4083 gtk_widget_show (w_button);
4084 gtk_widget_show (w_hbox);
4085
4086 tab->label = w_hbox;
4087 }*/
4088
4089
4090 tab->label = gtk_label_new (label);
4091
4092 gtk_widget_show(tab->label);
4093 gtk_widget_show(tab->scrollbar);
4094 gtk_widget_show(tab->MTimebar);
4095 gtk_widget_show(tab->viewer_container);
4096 gtk_widget_show(tab->vbox);
4097
4098 //gtk_widget_show(tab->multivpaned);
4099
4100
4101 /* Start with empty events requests list */
4102 tab->events_requests = NULL;
4103 tab->events_request_pending = FALSE;
4104 tab->stop_foreground = FALSE;
4105
4106
4107
4108 g_signal_connect(G_OBJECT(tab->scrollbar), "value-changed",
4109 G_CALLBACK(scroll_value_changed_cb), tab);
4110
4111
4112 /* Timebar signal handler */
4113 g_signal_connect(G_OBJECT(tab->MTimebar), "start-time-changed",
4114 G_CALLBACK(on_timebar_starttime_changed), tab);
4115 g_signal_connect(G_OBJECT(tab->MTimebar), "end-time-changed",
4116 G_CALLBACK(on_timebar_endtime_changed), tab);
4117 g_signal_connect(G_OBJECT(tab->MTimebar), "current-time-changed",
4118 G_CALLBACK(on_timebar_currenttime_changed), tab);
4119
4120 //g_signal_connect(G_OBJECT(tab->scrollbar), "changed",
4121 // G_CALLBACK(scroll_value_changed_cb), tab);
4122
4123
4124 //insert tab into notebook
4125 gtk_notebook_append_page(notebook,
4126 tab->vbox,
4127 tab->label);
4128 list = gtk_container_get_children(GTK_CONTAINER(notebook));
4129 gtk_notebook_set_current_page(notebook,g_list_length(list)-1);
4130 // always show : not if(g_list_length(list)>1)
4131 gtk_notebook_set_show_tabs(notebook, TRUE);
4132
4133 if(copy_tab) {
4134 lttvwindow_report_time_window(tab, copy_tab->time_window);
4135 lttvwindow_report_current_time(tab, copy_tab->current_time);
4136 } else {
4137 TimeWindow time_window;
4138
4139 time_window.start_time = ltt_time_zero;
4140 time_window.end_time = ltt_time_add(time_window.start_time,
4141 lttvwindow_default_time_width);
4142 time_window.time_width = lttvwindow_default_time_width;
4143 time_window.time_width_double = ltt_time_to_double(time_window.time_width);
4144
4145 lttvwindow_report_time_window(tab, time_window);
4146 lttvwindow_report_current_time(tab, ltt_time_zero);
4147 }
4148
4149 LttvTraceset *traceset = tab->traceset_info->traceset;
4150 SetTraceset(tab, traceset);
4151 }
4152
4153 /*
4154 * execute_events_requests
4155 *
4156 * Idle function that executes the pending requests for a tab.
4157 *
4158 * @return return value : TRUE : keep the idle function, FALSE : remove it.
4159 */
4160 gboolean execute_events_requests(Tab *tab)
4161 {
4162 return ( lttvwindow_process_pending_requests(tab) );
4163 }
4164
4165
4166 __EXPORT void create_main_window_with_trace_list(GSList *traces)
4167 {
4168
4169 GSList *iter = NULL;
4170
4171 /* Create window */
4172 MainWindow *mw = construct_main_window(NULL);
4173 GtkWidget *widget = mw->mwindow;
4174
4175 GtkWidget * notebook = lookup_widget(widget, "MNotebook");
4176 GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
4177 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
4178 LttvPluginTab *ptab;
4179 Tab *tab;
4180
4181 if(!page) {
4182 ptab = create_new_tab(widget, NULL);
4183 tab = ptab->tab;
4184 } else {
4185 ptab = (LttvPluginTab *)g_object_get_data(G_OBJECT(page), "Tab_Plugin");
4186 tab = ptab->tab;
4187 }
4188
4189 LttvTraceset * traceset = lttv_traceset_new();
4190 for(iter=traces; iter!=NULL; iter=g_slist_next(iter)) {
4191 gchar *path = (gchar*)iter->data;
4192 /* Add trace */
4193 gchar abs_path[PATH_MAX];
4194
4195
4196 get_absolute_pathname(path, abs_path);
4197
4198 if(lttv_traceset_add_path(traceset,abs_path) != 0 ){ /*failure*/
4199
4200 g_warning("cannot open trace %s", abs_path);
4201
4202 GtkWidget *dialogue =
4203 gtk_message_dialog_new(
4204 GTK_WINDOW(gtk_widget_get_toplevel(widget)),
4205 GTK_DIALOG_MODAL|GTK_DIALOG_DESTROY_WITH_PARENT,
4206 GTK_MESSAGE_ERROR,
4207 GTK_BUTTONS_OK,
4208 "Cannot open trace : maybe you should enter in the directory "
4209 "to select it ?");
4210 gtk_dialog_run(GTK_DIALOG(dialogue));
4211 gtk_widget_destroy(dialogue);
4212 }
4213 else{
4214 SetTraceset(tab, traceset);
4215 }
4216 }
4217 }
4218
LTTng 2.x Viewer (LTTV)
This page took 0.200401 seconds and 4 git commands to generate.