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