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