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