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