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