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