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