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