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