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