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