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