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