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