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