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