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