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