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