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