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