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