projects / lttv.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
git-svn-id: http://ltt.polymtl.ca/svn@489 04897980-b3bd-0310-b5e0-8ef037075253
[lttv.git] / ltt / branches / poly / lttv / modules / gui / main / src / callbacks.c
CommitLineData
e076699e 1/* This file is part of the Linux Trace Toolkit viewer
2 * Copyright (C) 2003-2004 XangXiu Yang
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
23#include <gtk/gtk.h>
24#include <gmodule.h>
25
26#include "callbacks.h"
27#include "interface.h"
28#include "support.h"
637bd544 29#include <lttv/mainwindow.h>
37d0eca6 30#include <lttv/menu.h>
31#include <lttv/toolbar.h>
cef97e7c 32#include <lttv/gtktraceset.h>
6b1d3120 33#include <lttv/module.h>
fc188b78 34#include <lttv/gtkdirsel.h>
f7afe191 35#include <lttv/iattribute.h>
49bf71b5 36#include <lttv/lttvfilter.h>
a5dcde2f 37#include <ltt/trace.h>
ed3b99b6 38#include <ltt/facility.h>
6b1d3120 39
f7afe191 40#define PATH_LENGTH 256
41#define DEFAULT_TIME_WIDTH_S 1
42
49bf71b5 43extern LttvTrace *g_init_trace ;
561eba2a 44
ec25ff5e 45
46/** Array containing instanced objects. */
68b48a45 47extern GSList * g_main_window_list;
561eba2a 48
68b48a45 49static int g_win_count = 0;
7a859036 50
bca3b81f 51MainWindow * get_window_data_struct(GtkWidget * widget);
36b3c068 52char * get_unload_module(char ** loaded_module_name, int nb_module);
2176f952 53char * get_remove_trace(char ** all_trace_name, int nb_trace);
54char * get_selection(char ** all_name, int nb, char *title, char * column_title);
a8c0f09d 55gboolean get_filter_selection(LttvTracesetSelector *s, char *title, char * column_title);
716e4367 56void * create_tab(MainWindow * parent, MainWindow * current_window,
57 GtkNotebook * notebook, char * label);
561eba2a 58
68b48a45 59void insert_viewer(GtkWidget* widget, view_constructor constructor);
49bf71b5 60void update_filter(LttvTracesetSelector *s, GtkTreeStore *store );
61
62void checkbox_changed(GtkTreeView *treeview,
63 GtkTreePath *arg1,
64 GtkTreeViewColumn *arg2,
65 gpointer user_data);
66void remove_trace_from_traceset_selector(GtkMultiVPaned * paned, unsigned i);
67void add_trace_into_traceset_selector(GtkMultiVPaned * paned, LttTrace * trace);
68
69LttvTracesetSelector * construct_traceset_selector(LttvTraceset * traceset);
70
a8c0f09d 71void redraw_viewer(MainWindow * mw_data, TimeWindow * time_window);
72unsigned get_max_event_number(MainWindow * mw_data);
202f6c8f 73
49bf71b5 74enum {
75 CHECKBOX_COLUMN,
76 NAME_COLUMN,
77 TOTAL_COLUMNS
78};
561eba2a 79
36b3c068 80enum
81{
82 MODULE_COLUMN,
83 N_COLUMNS
84};
85
abe346a3 86/* Construct a selector(filter), which will be associated with a viewer,
87 * and provides an interface for user to select interested events and traces
88 */
561eba2a 89
49bf71b5 90LttvTracesetSelector * construct_traceset_selector(LttvTraceset * traceset)
91{
92 LttvTracesetSelector * s;
93 LttvTraceSelector * trace;
94 LttvTracefileSelector * tracefile;
ed3b99b6 95 LttvEventtypeSelector * eventtype;
96 int i, j, k, m;
97 int nb_trace, nb_tracefile, nb_control, nb_per_cpu, nb_facility, nb_event;
49bf71b5 98 LttvTrace * trace_v;
99 LttTrace * t;
100 LttTracefile *tf;
ed3b99b6 101 LttFacility * fac;
102 LttEventType * et;
49bf71b5 103
104 s = lttv_traceset_selector_new(lttv_traceset_name(traceset));
105 nb_trace = lttv_traceset_number(traceset);
106 for(i=0;i<nb_trace;i++){
107 trace_v = lttv_traceset_get(traceset, i);
108 t = lttv_trace(trace_v);
109 trace = lttv_trace_selector_new(t);
ed3b99b6 110 lttv_traceset_selector_trace_add(s, trace);
111
112 nb_facility = ltt_trace_facility_number(t);
113 for(k=0;k<nb_facility;k++){
114 fac = ltt_trace_facility_get(t,k);
115 nb_event = (int) ltt_facility_eventtype_number(fac);
116 for(m=0;m<nb_event;m++){
117 et = ltt_facility_eventtype_get(fac,m);
118 eventtype = lttv_eventtype_selector_new(et);
119 lttv_trace_selector_eventtype_add(trace, eventtype);
120 }
121 }
122
49bf71b5 123 nb_control = ltt_trace_control_tracefile_number(t);
124 nb_per_cpu = ltt_trace_per_cpu_tracefile_number(t);
125 nb_tracefile = nb_control + nb_per_cpu;
126
127 for(j = 0 ; j < nb_tracefile ; j++) {
128 if(j < nb_control)
129 tf = ltt_trace_control_tracefile_get(t, j);
130 else
131 tf = ltt_trace_per_cpu_tracefile_get(t, j - nb_control);
132 tracefile = lttv_tracefile_selector_new(tf);
ed3b99b6 133 lttv_trace_selector_tracefile_add(trace, tracefile);
134 lttv_eventtype_selector_copy(trace, tracefile);
49bf71b5 135 }
136 }
137 return s;
138}
139
abe346a3 140
141/* insert_viewer function constructs an instance of a viewer first,
142 * then inserts the widget of the instance into the container of the
143 * main window
144 */
145
561eba2a 146void
606309a4 147insert_viewer_wrap(GtkWidget *menuitem, gpointer user_data)
561eba2a 148{
149 guint val = 20;
606309a4 150
68b48a45 151 insert_viewer((GtkWidget*)menuitem, (view_constructor)user_data);
37d0eca6 152 // selected_hook(&val);
561eba2a 153}
154
561eba2a 155
156/* internal functions */
68b48a45 157void insert_viewer(GtkWidget* widget, view_constructor constructor)
561eba2a 158{
daecc161 159 GtkMultiVPaned * multi_vpaned;
bca3b81f 160 MainWindow * mw_data;
f9334f6f 161 GtkWidget * viewer;
49bf71b5 162 LttvTracesetSelector * s;
202f6c8f 163 TimeInterval * time_interval;
58eecf4a 164 TimeWindow time_window, t;
561eba2a 165
68b48a45 166 mw_data = get_window_data_struct(widget);
bca3b81f 167 if(!mw_data->current_tab) return;
daecc161 168 multi_vpaned = mw_data->current_tab->multi_vpaned;
561eba2a 169
49bf71b5 170 s = construct_traceset_selector(mw_data->current_tab->traceset_info->traceset);
171 viewer = (GtkWidget*)constructor(mw_data, s, "Traceset_Selector");
f9334f6f 172 if(viewer)
f0d936c0 173 {
daecc161 174 gtk_multi_vpaned_widget_add(multi_vpaned, viewer);
f0d936c0 175 // Added by MD
8af8e4c5 176 // g_object_unref(G_OBJECT(viewer));
202f6c8f 177
202f6c8f 178 time_window = mw_data->current_tab->time_window;
179 time_interval = (TimeInterval*)g_object_get_data(G_OBJECT(viewer), TRACESET_TIME_SPAN);
180 if(time_interval){
58eecf4a 181 t = time_window;
202f6c8f 182 time_window.start_time = time_interval->startTime;
183 time_window.time_width = ltt_time_sub(time_interval->endTime,time_interval->startTime);
184 }
185
a8c0f09d 186 redraw_viewer(mw_data,&time_window);
202f6c8f 187 set_current_time(mw_data,&(mw_data->current_tab->current_time));
58eecf4a 188 if(time_interval){
189 set_time_window(mw_data,&t);
190 }
f0d936c0 191 }
561eba2a 192}
193
abe346a3 194
195/* get_label function is used to get user input, it displays an input
196 * box, which allows user to input a string
197 */
198
561eba2a 199void get_label_string (GtkWidget * text, gchar * label)
200{
201 GtkEntry * entry = (GtkEntry*)text;
202 if(strlen(gtk_entry_get_text(entry))!=0)
203 strcpy(label,gtk_entry_get_text(entry));
204}
205
eb38aea5 206gboolean get_label(MainWindow * mw, gchar * str, gchar* dialogue_title, gchar * label_str)
561eba2a 207{
208 GtkWidget * dialogue;
209 GtkWidget * text;
210 GtkWidget * label;
211 gint id;
212
5723fa24 213 dialogue = gtk_dialog_new_with_buttons(dialogue_title,NULL,
561eba2a 214 GTK_DIALOG_MODAL,
215 GTK_STOCK_OK,GTK_RESPONSE_ACCEPT,
216 GTK_STOCK_CANCEL,GTK_RESPONSE_REJECT,
217 NULL);
218
6b1d3120 219 label = gtk_label_new(label_str);
561eba2a 220 gtk_widget_show(label);
221
222 text = gtk_entry_new();
223 gtk_widget_show(text);
224
225 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), label,TRUE, TRUE,0);
226 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), text,FALSE, FALSE,0);
227
228 id = gtk_dialog_run(GTK_DIALOG(dialogue));
229 switch(id){
230 case GTK_RESPONSE_ACCEPT:
231 get_label_string(text,str);
232 gtk_widget_destroy(dialogue);
233 break;
234 case GTK_RESPONSE_REJECT:
235 default:
236 gtk_widget_destroy(dialogue);
eb38aea5 237 return FALSE;
561eba2a 238 }
eb38aea5 239 return TRUE;
561eba2a 240}
241
abe346a3 242
243/* get_window_data_struct function is actually a lookup function,
244 * given a widget which is in the tree of the main window, it will
245 * return the MainWindow data structure associated with main window
246 */
247
bca3b81f 248MainWindow * get_window_data_struct(GtkWidget * widget)
561eba2a 249{
250 GtkWidget * mw;
bca3b81f 251 MainWindow * mw_data;
561eba2a 252
253 mw = lookup_widget(widget, "MWindow");
254 if(mw == NULL){
255 g_printf("Main window does not exist\n");
256 return;
257 }
258
bca3b81f 259 mw_data = (MainWindow *) g_object_get_data(G_OBJECT(mw),"mainWindow");
68b48a45 260 if(mw_data == NULL){
561eba2a 261 g_printf("Main window data does not exist\n");
262 return;
263 }
68b48a45 264 return mw_data;
561eba2a 265}
266
abe346a3 267
268/* create_new_window function, just constructs a new main window
269 */
270
68b48a45 271void create_new_window(GtkWidget* widget, gpointer user_data, gboolean clone)
561eba2a 272{
bca3b81f 273 MainWindow * parent = get_window_data_struct(widget);
561eba2a 274
561eba2a 275 if(clone){
276 g_printf("Clone : use the same traceset\n");
716e4367 277 construct_main_window(parent, NULL);
561eba2a 278 }else{
279 g_printf("Empty : traceset is set to NULL\n");
716e4367 280 construct_main_window(NULL, parent->win_creation_data);
561eba2a 281 }
282}
283
abe346a3 284
285/* move_*_viewer functions move the selected view up/down in
286 * the current tab
287 */
288
561eba2a 289void move_up_viewer(GtkWidget * widget, gpointer user_data)
290{
bca3b81f 291 MainWindow * mw = get_window_data_struct(widget);
292 if(!mw->current_tab) return;
daecc161 293 gtk_multi_vpaned_widget_move_up(mw->current_tab->multi_vpaned);
561eba2a 294}
295
296void move_down_viewer(GtkWidget * widget, gpointer user_data)
297{
bca3b81f 298 MainWindow * mw = get_window_data_struct(widget);
299 if(!mw->current_tab) return;
daecc161 300 gtk_multi_vpaned_widget_move_down(mw->current_tab->multi_vpaned);
561eba2a 301}
302
abe346a3 303
304/* delete_viewer deletes the selected viewer in the current tab
305 */
306
561eba2a 307void delete_viewer(GtkWidget * widget, gpointer user_data)
308{
bca3b81f 309 MainWindow * mw = get_window_data_struct(widget);
310 if(!mw->current_tab) return;
daecc161 311 gtk_multi_vpaned_widget_delete(mw->current_tab->multi_vpaned);
561eba2a 312}
313
abe346a3 314
315/* open_traceset will open a traceset saved in a file
316 * Right now, it is not finished yet, (not working)
317 */
318
561eba2a 319void open_traceset(GtkWidget * widget, gpointer user_data)
320{
2176f952 321 char ** dir;
322 gint id;
323 LttvTraceset * traceset;
bca3b81f 324 MainWindow * mw_data = get_window_data_struct(widget);
68b48a45 325 GtkFileSelection * file_selector =
2176f952 326 (GtkFileSelection *)gtk_file_selection_new("Select a traceset");
327
68b48a45 328 gtk_file_selection_hide_fileop_buttons(file_selector);
c64c7ea1 329
68b48a45 330 id = gtk_dialog_run(GTK_DIALOG(file_selector));
2176f952 331 switch(id){
332 case GTK_RESPONSE_ACCEPT:
333 case GTK_RESPONSE_OK:
68b48a45 334 dir = gtk_file_selection_get_selections (file_selector);
2176f952 335 traceset = lttv_traceset_load(dir[0]);
336 g_printf("Open a trace set %s\n", dir[0]);
337 //Not finished yet
338 g_strfreev(dir);
339 case GTK_RESPONSE_REJECT:
340 case GTK_RESPONSE_CANCEL:
341 default:
68b48a45 342 gtk_widget_destroy((GtkWidget*)file_selector);
2176f952 343 break;
344 }
c64c7ea1 345
561eba2a 346}
347
abe346a3 348
349/* get_max_event_number returns the event number limit used by
350 * lttv_process_traceset(LttvTracesetContext, endTime, maxNumEvents)
351 * each viewer can set the limit
352 */
353
a8c0f09d 354unsigned get_max_event_number(MainWindow * mw_data)
202f6c8f 355{
a8c0f09d 356 unsigned nb = 0, *size;
357 GtkWidget * w;
358
359 w = gtk_multi_vpaned_get_first_widget(mw_data->current_tab->multi_vpaned);
360 while(w){
361 size = (unsigned*)g_object_get_data(G_OBJECT(w), MAX_NUMBER_EVENT);
362 if(size == NULL){
363 nb = G_MAXULONG;
364 break;
365 }else{
366 if(nb < *size)
367 nb = *size;
368 }
369 w = gtk_multi_vpaned_get_next_widget(mw_data->current_tab->multi_vpaned);
370 }
371 return nb;
372}
373
abe346a3 374
375/* redraw_viewer parses the traceset first by calling
376 * process_traceset_api, then display all viewers of
377 * the current tab
378 */
379
a8c0f09d 380void redraw_viewer(MainWindow * mw_data, TimeWindow * time_window)
381{
382 unsigned max_nb_events;
383 GdkWindow * win;
384 GdkCursor * new;
385 GtkWidget* widget;
386
abe346a3 387 //set the cursor to be X shape, indicating that the computer is busy in doing its job
a8c0f09d 388 new = gdk_cursor_new(GDK_X_CURSOR);
efde9138 389 widget = lookup_widget(mw_data->mwindow, "MToolbar1");
a8c0f09d 390 win = gtk_widget_get_parent_window(widget);
391 gdk_window_set_cursor(win, new);
392 gdk_cursor_unref(new);
393 gdk_window_stick(win);
394 gdk_window_unstick(win);
395
202f6c8f 396 //update time window of each viewer, let viewer insert hooks needed by process_traceset
397 set_time_window(mw_data, time_window);
a8c0f09d 398
399 max_nb_events = get_max_event_number(mw_data);
202f6c8f 400
401 process_traceset_api(mw_data, time_window->start_time,
402 ltt_time_add(time_window->start_time,time_window->time_width),
a8c0f09d 403 max_nb_events);
202f6c8f 404
405 //call hooks to show each viewer and let them remove hooks
406 show_viewer(mw_data);
a8c0f09d 407
abe346a3 408 //set the cursor back to normal
a8c0f09d 409 gdk_window_set_cursor(win, NULL);
202f6c8f 410}
411
abe346a3 412
413/* add_trace_into_traceset_selector, each instance of a viewer has an associated
414 * selector (filter), when a trace is added into traceset, the selector should
415 * reflect the change. The function is used to update the selector
416 */
417
49bf71b5 418void add_trace_into_traceset_selector(GtkMultiVPaned * paned, LttTrace * t)
419{
ed3b99b6 420 int j, k, m, nb_tracefile, nb_control, nb_per_cpu, nb_facility, nb_event;
49bf71b5 421 LttvTracesetSelector * s;
422 LttvTraceSelector * trace;
423 LttvTracefileSelector * tracefile;
ed3b99b6 424 LttvEventtypeSelector * eventtype;
49bf71b5 425 LttTracefile * tf;
426 GtkWidget * w;
ed3b99b6 427 LttFacility * fac;
428 LttEventType * et;
49bf71b5 429
430 w = gtk_multi_vpaned_get_first_widget(paned);
431 while(w){
432 s = g_object_get_data(G_OBJECT(w), "Traceset_Selector");
49bf71b5 433
abe346a3 434 if(s){
435 trace = lttv_trace_selector_new(t);
436 lttv_traceset_selector_trace_add(s, trace);
437
438 nb_facility = ltt_trace_facility_number(t);
439 for(k=0;k<nb_facility;k++){
440 fac = ltt_trace_facility_get(t,k);
441 nb_event = (int) ltt_facility_eventtype_number(fac);
442 for(m=0;m<nb_event;m++){
443 et = ltt_facility_eventtype_get(fac,m);
444 eventtype = lttv_eventtype_selector_new(et);
445 lttv_trace_selector_eventtype_add(trace, eventtype);
446 }
447 }
448
449 nb_control = ltt_trace_control_tracefile_number(t);
450 nb_per_cpu = ltt_trace_per_cpu_tracefile_number(t);
451 nb_tracefile = nb_control + nb_per_cpu;
452
453 for(j = 0 ; j < nb_tracefile ; j++) {
454 if(j < nb_control)
455 tf = ltt_trace_control_tracefile_get(t, j);
456 else
457 tf = ltt_trace_per_cpu_tracefile_get(t, j - nb_control);
458 tracefile = lttv_tracefile_selector_new(tf);
459 lttv_trace_selector_tracefile_add(trace, tracefile);
460 lttv_eventtype_selector_copy(trace, tracefile);
461 }
462 }else g_warning("Module does not support filtering\n");
49bf71b5 463
464 w = gtk_multi_vpaned_get_next_widget(paned);
465 }
466}
467
abe346a3 468
469/* add_trace adds a trace into the current traceset. It first displays a
470 * directory selection dialogue to let user choose a trace, then recreates
471 * tracset_context, and redraws all the viewer of the current tab
472 */
473
561eba2a 474void add_trace(GtkWidget * widget, gpointer user_data)
475{
2176f952 476 LttTrace *trace;
477 LttvTrace * trace_v;
478 LttvTraceset * traceset;
94dcfb9e 479 const char * dir;
2176f952 480 gint id;
bca3b81f 481 MainWindow * mw_data = get_window_data_struct(widget);
68b48a45 482 GtkDirSelection * file_selector = (GtkDirSelection *)gtk_dir_selection_new("Select a trace");
483 gtk_dir_selection_hide_fileop_buttons(file_selector);
2176f952 484
68b48a45 485 id = gtk_dialog_run(GTK_DIALOG(file_selector));
2176f952 486 switch(id){
487 case GTK_RESPONSE_ACCEPT:
488 case GTK_RESPONSE_OK:
68b48a45 489 dir = gtk_dir_selection_get_dir (file_selector);
284675e3 490 if(!dir || strlen(dir) ==0){
491 gtk_widget_destroy((GtkWidget*)file_selector);
492 break;
493 }
2176f952 494 trace = ltt_trace_open(dir);
495 if(trace == NULL) g_critical("cannot open trace %s", dir);
496 trace_v = lttv_trace_new(trace);
716e4367 497 traceset = mw_data->current_tab->traceset_info->traceset;
498 if(mw_data->current_tab->traceset_info->traceset_context != NULL){
499 lttv_context_fini(LTTV_TRACESET_CONTEXT(mw_data->current_tab->
500 traceset_info->traceset_context));
501 g_object_unref(mw_data->current_tab->traceset_info->traceset_context);
2176f952 502 }
503 lttv_traceset_add(traceset, trace_v);
716e4367 504 mw_data->current_tab->traceset_info->traceset_context =
2176f952 505 g_object_new(LTTV_TRACESET_STATS_TYPE, NULL);
506 lttv_context_init(
716e4367 507 LTTV_TRACESET_CONTEXT(mw_data->current_tab->traceset_info->
49bf71b5 508 traceset_context),traceset);
509 add_trace_into_traceset_selector(mw_data->current_tab->multi_vpaned, trace);
510
511 gtk_widget_destroy((GtkWidget*)file_selector);
512
513 //update current tab
a8c0f09d 514 update_traceset(mw_data);
21e8c385 515
516 get_traceset_time_span(mw_data,LTTV_TRACESET_CONTEXT(mw_data->current_tab->traceset_info->traceset_context)->Time_Span);
517 if(lttv_traceset_number(mw_data->current_tab->traceset_info->traceset) == 1 ||
518 ltt_time_compare(mw_data->current_tab->current_time,
519 LTTV_TRACESET_CONTEXT(mw_data->current_tab->traceset_info->traceset_context)->Time_Span->startTime)<0){
520 mw_data->current_tab->current_time =
521 LTTV_TRACESET_CONTEXT(mw_data->current_tab->traceset_info->traceset_context)->Time_Span->startTime;
522 mw_data->current_tab->time_window.start_time = mw_data->current_tab->current_time;
523 mw_data->current_tab->time_window.time_width.tv_sec = DEFAULT_TIME_WIDTH_S;
524 mw_data->current_tab->time_window.time_width.tv_nsec = 0;
525 }
526
a8c0f09d 527 redraw_viewer(mw_data, &(mw_data->current_tab->time_window));
202f6c8f 528 set_current_time(mw_data,&(mw_data->current_tab->current_time));
49bf71b5 529 break;
2176f952 530 case GTK_RESPONSE_REJECT:
531 case GTK_RESPONSE_CANCEL:
532 default:
68b48a45 533 gtk_widget_destroy((GtkWidget*)file_selector);
2176f952 534 break;
535 }
49bf71b5 536}
537
abe346a3 538
539/* remove_trace_into_traceset_selector, each instance of a viewer has an associated
540 * selector (filter), when a trace is remove from traceset, the selector should
541 * reflect the change. The function is used to update the selector
542 */
543
49bf71b5 544void remove_trace_from_traceset_selector(GtkMultiVPaned * paned, unsigned i)
545{
546 LttvTracesetSelector * s;
547 LttvTraceSelector * t;
548 GtkWidget * w;
549
550 w = gtk_multi_vpaned_get_first_widget(paned);
551 while(w){
552 s = g_object_get_data(G_OBJECT(w), "Traceset_Selector");
abe346a3 553 if(s){
554 t = lttv_traceset_selector_trace_get(s,i);
555 lttv_traceset_selector_trace_remove(s, i);
556 lttv_trace_selector_destroy(t);
557 }g_warning("Module dose not support filtering\n");
49bf71b5 558 w = gtk_multi_vpaned_get_next_widget(paned);
559 }
561eba2a 560}
561
abe346a3 562
563/* remove_trace removes a trace from the current traceset if all viewers in
564 * the current tab are not interested in the trace. It first displays a
565 * dialogue, which shows all traces in the current traceset, to let user choose
566 * a trace, then it checks if all viewers unselect the trace, if it is true,
567 * it will remove the trace, recreate the traceset_contex,
568 * and redraws all the viewer of the current tab. If there is on trace in the
569 * current traceset, it will delete all viewers of the current tab
570 */
571
561eba2a 572void remove_trace(GtkWidget * widget, gpointer user_data)
573{
2176f952 574 LttTrace *trace;
575 LttvTrace * trace_v;
576 LttvTraceset * traceset;
577 gint i, nb_trace;
578 char ** name, *remove_trace_name;
bca3b81f 579 MainWindow * mw_data = get_window_data_struct(widget);
49bf71b5 580 LttvTracesetSelector * s;
581 LttvTraceSelector * t;
582 GtkWidget * w;
583 gboolean selected;
2176f952 584
716e4367 585 nb_trace =lttv_traceset_number(mw_data->current_tab->traceset_info->traceset);
2176f952 586 name = g_new(char*,nb_trace);
587 for(i = 0; i < nb_trace; i++){
716e4367 588 trace_v = lttv_traceset_get(mw_data->current_tab->
589 traceset_info->traceset, i);
2176f952 590 trace = lttv_trace(trace_v);
a5dcde2f 591 name[i] = ltt_trace_name(trace);
2176f952 592 }
593
594 remove_trace_name = get_remove_trace(name, nb_trace);
595
596 if(remove_trace_name){
597 for(i=0; i<nb_trace; i++){
598 if(strcmp(remove_trace_name,name[i]) == 0){
49bf71b5 599 //unselect the trace from the current viewer
600 w = gtk_multi_vpaned_get_widget(mw_data->current_tab->multi_vpaned);
9f0a7b47 601 if(w){
49bf71b5 602 s = g_object_get_data(G_OBJECT(w), "Traceset_Selector");
abe346a3 603 if(s){
604 t = lttv_traceset_selector_trace_get(s,i);
605 lttv_trace_selector_set_selected(t, FALSE);
606 }
9f0a7b47 607
608 //check if other viewers select the trace
609 w = gtk_multi_vpaned_get_first_widget(mw_data->current_tab->multi_vpaned);
610 while(w){
611 s = g_object_get_data(G_OBJECT(w), "Traceset_Selector");
abe346a3 612 if(s){
613 t = lttv_traceset_selector_trace_get(s,i);
614 selected = lttv_trace_selector_get_selected(t);
615 if(selected)break;
616 }
9f0a7b47 617 w = gtk_multi_vpaned_get_next_widget(mw_data->current_tab->multi_vpaned);
618 }
619 }else selected = FALSE;
49bf71b5 620
621 //if no viewer selects the trace, remove it
622 if(!selected){
623 remove_trace_from_traceset_selector(mw_data->current_tab->multi_vpaned, i);
624
625 traceset = mw_data->current_tab->traceset_info->traceset;
626 trace_v = lttv_traceset_get(traceset, i);
627 if(lttv_trace_get_ref_number(trace_v) <= 1)
628 ltt_trace_close(lttv_trace(trace_v));
629
630 if(mw_data->current_tab->traceset_info->traceset_context != NULL){
631 lttv_context_fini(LTTV_TRACESET_CONTEXT(mw_data->current_tab->
632 traceset_info->traceset_context));
633 g_object_unref(mw_data->current_tab->traceset_info->traceset_context);
634 }
635 lttv_traceset_remove(traceset, i);
912be9a5 636 if(!lttv_trace_get_ref_number(trace_v))
637 lttv_trace_destroy(trace_v);
49bf71b5 638 mw_data->current_tab->traceset_info->traceset_context =
639 g_object_new(LTTV_TRACESET_STATS_TYPE, NULL);
640 lttv_context_init(
641 LTTV_TRACESET_CONTEXT(mw_data->current_tab->
642 traceset_info->traceset_context),traceset);
643 //update current tab
a8c0f09d 644 update_traceset(mw_data);
912be9a5 645 if(nb_trace > 1){
646 redraw_viewer(mw_data, &(mw_data->current_tab->time_window));
647 set_current_time(mw_data,&(mw_data->current_tab->current_time));
648 }else{
649 if(mw_data->current_tab){
650 while(mw_data->current_tab->multi_vpaned->num_children){
651 gtk_multi_vpaned_widget_delete(mw_data->current_tab->multi_vpaned);
652 }
653 }
654 }
2176f952 655 }
2176f952 656 break;
657 }
658 }
659 }
660
661 g_free(name);
561eba2a 662}
663
abe346a3 664
665/* save will save the traceset to a file
666 * Not implemented yet
667 */
668
561eba2a 669void save(GtkWidget * widget, gpointer user_data)
670{
671 g_printf("Save\n");
672}
673
674void save_as(GtkWidget * widget, gpointer user_data)
675{
676 g_printf("Save as\n");
677}
678
abe346a3 679
680/* zoom will change the time_window of all the viewers of the
681 * current tab, and redisplay them. The main functionality is to
682 * determine the new time_window of the current tab
683 */
684
1f1ae829 685void zoom(GtkWidget * widget, double size)
686{
687 TimeInterval *time_span;
688 TimeWindow time_window;
a8c0f09d 689 LttTime current_time, time_delta, time_s, time_e, time_t;
1f1ae829 690 MainWindow * mw_data = get_window_data_struct(widget);
691
fda16332 692 if(size == 1) return;
693
716e4367 694 time_span = LTTV_TRACESET_CONTEXT(mw_data->current_tab->
695 traceset_info->traceset_context)->Time_Span;
1f1ae829 696 time_window = mw_data->current_tab->time_window;
697 current_time = mw_data->current_tab->current_time;
698
699 time_delta = ltt_time_sub(time_span->endTime,time_span->startTime);
700 if(size == 0){
701 time_window.start_time = time_span->startTime;
702 time_window.time_width = time_delta;
703 }else{
704 time_window.time_width = ltt_time_div(time_window.time_width, size);
705 if(ltt_time_compare(time_window.time_width,time_delta) > 0)
fda16332 706 time_window.time_width = time_delta;
1f1ae829 707
a8c0f09d 708 time_t = ltt_time_div(time_window.time_width, 2);
709 if(ltt_time_compare(current_time, time_t) < 0){
710 time_s = time_span->startTime;
711 } else {
712 time_s = ltt_time_sub(current_time,time_t);
713 }
714 time_e = ltt_time_add(current_time,time_t);
1f1ae829 715 if(ltt_time_compare(time_span->startTime, time_s) > 0){
716 time_s = time_span->startTime;
717 }else if(ltt_time_compare(time_span->endTime, time_e) < 0){
718 time_e = time_span->endTime;
719 time_s = ltt_time_sub(time_e,time_window.time_width);
720 }
721 time_window.start_time = time_s;
722 }
a8c0f09d 723 redraw_viewer(mw_data, &time_window);
202f6c8f 724 set_current_time(mw_data,&(mw_data->current_tab->current_time));
daecc161 725 gtk_multi_vpaned_set_adjust(mw_data->current_tab->multi_vpaned, FALSE);
1f1ae829 726}
727
561eba2a 728void zoom_in(GtkWidget * widget, gpointer user_data)
729{
1f1ae829 730 zoom(widget, 2);
561eba2a 731}
732
733void zoom_out(GtkWidget * widget, gpointer user_data)
734{
1f1ae829 735 zoom(widget, 0.5);
561eba2a 736}
737
738void zoom_extended(GtkWidget * widget, gpointer user_data)
739{
1f1ae829 740 zoom(widget, 0);
561eba2a 741}
742
743void go_to_time(GtkWidget * widget, gpointer user_data)
744{
745 g_printf("Go to time\n");
746}
747
748void show_time_frame(GtkWidget * widget, gpointer user_data)
749{
750 g_printf("Show time frame\n");
751}
752
753
754/* callback function */
755
756void
757on_empty_traceset_activate (GtkMenuItem *menuitem,
758 gpointer user_data)
759{
68b48a45 760 create_new_window((GtkWidget*)menuitem, user_data, FALSE);
561eba2a 761}
762
763
764void
765on_clone_traceset_activate (GtkMenuItem *menuitem,
766 gpointer user_data)
767{
68b48a45 768 create_new_window((GtkWidget*)menuitem, user_data, TRUE);
561eba2a 769}
770
abe346a3 771
772/* create_new_tab calls create_tab to construct a new tab in the main window
773 */
774
2901f314 775void create_new_tab(GtkWidget* widget, gpointer user_data){
6b1d3120 776 gchar label[PATH_LENGTH];
2901f314 777 MainWindow * mw_data = get_window_data_struct(widget);
778 GtkNotebook * notebook = (GtkNotebook *)lookup_widget(widget, "MNotebook");
561eba2a 779 if(notebook == NULL){
780 g_printf("Notebook does not exist\n");
781 return;
782 }
783
6b1d3120 784 strcpy(label,"Page");
eb38aea5 785 if(get_label(mw_data, label,"Get the name of the tab","Please input tab's name"))
786 create_tab (mw_data, mw_data, notebook, label);
561eba2a 787}
788
2901f314 789void
790on_tab_activate (GtkMenuItem *menuitem,
791 gpointer user_data)
792{
793 create_new_tab((GtkWidget*)menuitem, user_data);
794}
795
561eba2a 796
797void
798on_open_activate (GtkMenuItem *menuitem,
799 gpointer user_data)
800{
801 open_traceset((GtkWidget*)menuitem, user_data);
802}
803
804
805void
806on_close_activate (GtkMenuItem *menuitem,
807 gpointer user_data)
808{
bca3b81f 809 MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
68b48a45 810 main_window_destructor(mw_data);
561eba2a 811}
812
813
abe346a3 814/* remove the current tab from the main window if it is not the default tab
815 */
816
561eba2a 817void
818on_close_tab_activate (GtkMenuItem *menuitem,
819 gpointer user_data)
820{
efde9138 821 GList * list;
2061e03d 822 int count = 0;
823 GtkWidget * notebook;
bca3b81f 824 Tab * tmp;
825 MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
2061e03d 826 notebook = lookup_widget((GtkWidget*)menuitem, "MNotebook");
827 if(notebook == NULL){
828 g_printf("Notebook does not exist\n");
829 return;
830 }
831
bca3b81f 832 if(mw_data->tab == mw_data->current_tab){
833 // tmp = mw_data->current_tb;
834 // mw_data->tab = mw_data->current_tab->next;
2061e03d 835 g_printf("The default TAB can not be deleted\n");
836 return;
837 }else{
bca3b81f 838 tmp = mw_data->tab;
839 while(tmp != mw_data->current_tab){
840 tmp = tmp->next;
abe346a3 841 count++;
2061e03d 842 }
843 }
844
845 gtk_notebook_remove_page((GtkNotebook*)notebook, count);
efde9138 846 list = gtk_container_get_children(GTK_CONTAINER(notebook));
847 if(g_list_length(list)==1)
848 gtk_notebook_set_show_tabs((GtkNotebook*)notebook, FALSE);
561eba2a 849}
850
851
852void
853on_add_trace_activate (GtkMenuItem *menuitem,
854 gpointer user_data)
855{
856 add_trace((GtkWidget*)menuitem, user_data);
857}
858
859
860void
861on_remove_trace_activate (GtkMenuItem *menuitem,
862 gpointer user_data)
863{
864 remove_trace((GtkWidget*)menuitem, user_data);
865}
866
867
868void
869on_save_activate (GtkMenuItem *menuitem,
870 gpointer user_data)
871{
872 save((GtkWidget*)menuitem, user_data);
873}
874
875
876void
877on_save_as_activate (GtkMenuItem *menuitem,
878 gpointer user_data)
879{
880 save_as((GtkWidget*)menuitem, user_data);
881}
882
883
884void
885on_quit_activate (GtkMenuItem *menuitem,
886 gpointer user_data)
887{
2061e03d 888 gtk_main_quit ();
561eba2a 889}
890
891
892void
893on_cut_activate (GtkMenuItem *menuitem,
894 gpointer user_data)
895{
896 g_printf("Cut\n");
897}
898
899
900void
901on_copy_activate (GtkMenuItem *menuitem,
902 gpointer user_data)
903{
904 g_printf("Copye\n");
905}
906
907
908void
909on_paste_activate (GtkMenuItem *menuitem,
910 gpointer user_data)
911{
912 g_printf("Paste\n");
913}
914
915
916void
917on_delete_activate (GtkMenuItem *menuitem,
918 gpointer user_data)
919{
920 g_printf("Delete\n");
921}
922
923
924void
925on_zoom_in_activate (GtkMenuItem *menuitem,
926 gpointer user_data)
927{
928 zoom_in((GtkWidget*)menuitem, user_data);
929}
930
931
932void
933on_zoom_out_activate (GtkMenuItem *menuitem,
934 gpointer user_data)
935{
936 zoom_out((GtkWidget*)menuitem, user_data);
937}
938
939
940void
941on_zoom_extended_activate (GtkMenuItem *menuitem,
942 gpointer user_data)
943{
944 zoom_extended((GtkWidget*)menuitem, user_data);
945}
946
947
948void
949on_go_to_time_activate (GtkMenuItem *menuitem,
950 gpointer user_data)
951{
952 go_to_time((GtkWidget*)menuitem, user_data);
953}
954
955
956void
957on_show_time_frame_activate (GtkMenuItem *menuitem,
958 gpointer user_data)
959{
960 show_time_frame((GtkWidget*)menuitem, user_data);
961}
962
963
964void
965on_move_viewer_up_activate (GtkMenuItem *menuitem,
966 gpointer user_data)
967{
968 move_up_viewer((GtkWidget*)menuitem, user_data);
969}
970
971
972void
973on_move_viewer_down_activate (GtkMenuItem *menuitem,
974 gpointer user_data)
975{
976 move_down_viewer((GtkWidget*)menuitem, user_data);
977}
978
979
980void
981on_remove_viewer_activate (GtkMenuItem *menuitem,
982 gpointer user_data)
983{
984 delete_viewer((GtkWidget*)menuitem, user_data);
985}
986
49bf71b5 987void
988on_trace_filter_activate (GtkMenuItem *menuitem,
989 gpointer user_data)
990{
991 MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
992 LttvTracesetSelector * s;
993 GtkWidget * w = gtk_multi_vpaned_get_widget(mw_data->current_tab->multi_vpaned);
994
995 s = g_object_get_data(G_OBJECT(w), "Traceset_Selector");
996 if(!s){
997 g_printf("There is no viewer yet\n");
998 return;
999 }
a8c0f09d 1000 if(get_filter_selection(s, "Configure trace and tracefile filter", "Select traces and tracefiles")){
1001 update_traceset(mw_data);
1002 redraw_viewer(mw_data, &(mw_data->current_tab->time_window));
1003 set_current_time(mw_data,&(mw_data->current_tab->current_time));
1004 }
49bf71b5 1005}
1006
1007void
1008on_trace_facility_activate (GtkMenuItem *menuitem,
1009 gpointer user_data)
1010{
1011 g_printf("Trace facility selector: %s\n");
1012}
561eba2a 1013
abe346a3 1014
1015/* Dispaly a file selection dialogue to let user select a module, then call
1016 * lttv_module_load(), finally insert tool button and menu entry in the main window
1017 * for the loaded module
1018 */
1019
561eba2a 1020void
1021on_load_module_activate (GtkMenuItem *menuitem,
1022 gpointer user_data)
1023{
36b3c068 1024 char ** dir;
1025 gint id;
3872a20e 1026 char str[PATH_LENGTH], *str1;
bca3b81f 1027 MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
68b48a45 1028 GtkFileSelection * file_selector = (GtkFileSelection *)gtk_file_selection_new("Select a module");
1029 gtk_file_selection_hide_fileop_buttons(file_selector);
36b3c068 1030
1031 str[0] = '\0';
68b48a45 1032 id = gtk_dialog_run(GTK_DIALOG(file_selector));
36b3c068 1033 switch(id){
1034 case GTK_RESPONSE_ACCEPT:
1035 case GTK_RESPONSE_OK:
68b48a45 1036 dir = gtk_file_selection_get_selections (file_selector);
36b3c068 1037 sprintf(str,dir[0]);
3872a20e 1038 str1 = strrchr(str,'/');
1039 if(str1)str1++;
1040 else{
1041 str1 = strrchr(str,'\\');
1042 str1++;
1043 }
bca3b81f 1044 if(mw_data->win_creation_data)
1045 lttv_module_load(str1, mw_data->win_creation_data->argc,mw_data->win_creation_data->argv);
36b3c068 1046 else
3872a20e 1047 lttv_module_load(str1, 0,NULL);
f2d17b4d 1048 g_slist_foreach(g_main_window_list, (gpointer)insert_menu_toolbar_item,
1049 NULL);
36b3c068 1050 g_strfreev(dir);
1051 case GTK_RESPONSE_REJECT:
1052 case GTK_RESPONSE_CANCEL:
1053 default:
68b48a45 1054 gtk_widget_destroy((GtkWidget*)file_selector);
36b3c068 1055 break;
1056 }
1057 g_printf("Load module: %s\n", str);
561eba2a 1058}
1059
1060
abe346a3 1061/* Display all loaded modules, let user to select a module to unload
1062 * by calling lttv_module_unload
1063 */
1064
561eba2a 1065void
1066on_unload_module_activate (GtkMenuItem *menuitem,
1067 gpointer user_data)
1068{
36b3c068 1069 int i;
1070 char **name, *unload_module_name;
1071 guint nb;
1072 LttvModule ** modules, *module;
bca3b81f 1073 MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
36b3c068 1074
1075 modules = lttv_module_list(&nb);
1076 name = g_new(char*, nb);
1077 for(i=0;i<nb;i++){
1078 module = modules[i];
1079 name[i] = lttv_module_name(module);
1080 }
1081
1082 unload_module_name =get_unload_module(name,nb);
1083
1084 if(unload_module_name){
1085 for(i=0;i<nb;i++){
1086 if(strcmp(unload_module_name, name[i]) == 0){
1087 lttv_module_unload(modules[i]);
1088 break;
1089 }
1090 }
1091 }
1092
1093 g_free(name);
561eba2a 1094}
1095
1096
abe346a3 1097/* Display a directory dialogue to let user select a path for module searching
1098 */
1099
561eba2a 1100void
1101on_add_module_search_path_activate (GtkMenuItem *menuitem,
1102 gpointer user_data)
1103{
68b48a45 1104 GtkDirSelection * file_selector = (GtkDirSelection *)gtk_dir_selection_new("Select module path");
67b98724 1105 const char * dir;
fc188b78 1106 gint id;
1107
bca3b81f 1108 MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
fc188b78 1109
68b48a45 1110 id = gtk_dialog_run(GTK_DIALOG(file_selector));
fc188b78 1111 switch(id){
1112 case GTK_RESPONSE_ACCEPT:
1113 case GTK_RESPONSE_OK:
68b48a45 1114 dir = gtk_dir_selection_get_dir (file_selector);
fc188b78 1115 lttv_module_path_add(dir);
1116 case GTK_RESPONSE_REJECT:
1117 case GTK_RESPONSE_CANCEL:
1118 default:
68b48a45 1119 gtk_widget_destroy((GtkWidget*)file_selector);
fc188b78 1120 break;
6b1d3120 1121 }
561eba2a 1122}
1123
1124
1125void
1126on_color_activate (GtkMenuItem *menuitem,
1127 gpointer user_data)
1128{
1129 g_printf("Color\n");
1130}
1131
1132
1133void
1134on_filter_activate (GtkMenuItem *menuitem,
1135 gpointer user_data)
1136{
1137 g_printf("Filter\n");
1138}
1139
1140
1141void
1142on_save_configuration_activate (GtkMenuItem *menuitem,
1143 gpointer user_data)
1144{
1145 g_printf("Save configuration\n");
1146}
1147
1148
1149void
1150on_content_activate (GtkMenuItem *menuitem,
1151 gpointer user_data)
1152{
1153 g_printf("Content\n");
1154}
1155
1156
1157void
1158on_about_activate (GtkMenuItem *menuitem,
1159 gpointer user_data)
1160{
1161 g_printf("About...\n");
1162}
1163
1164
1165void
1166on_button_new_clicked (GtkButton *button,
1167 gpointer user_data)
1168{
6f7ad7ae 1169 create_new_window((GtkWidget*)button, user_data, TRUE);
561eba2a 1170}
1171
2901f314 1172void
1173on_button_new_tab_clicked (GtkButton *button,
1174 gpointer user_data)
1175{
1176 create_new_tab((GtkWidget*)button, user_data);
1177}
561eba2a 1178
1179void
1180on_button_open_clicked (GtkButton *button,
1181 gpointer user_data)
1182{
1183 open_traceset((GtkWidget*)button, user_data);
1184}
1185
1186
1187void
1188on_button_add_trace_clicked (GtkButton *button,
1189 gpointer user_data)
1190{
1191 add_trace((GtkWidget*)button, user_data);
1192}
1193
1194
1195void
1196on_button_remove_trace_clicked (GtkButton *button,
1197 gpointer user_data)
1198{
1199 remove_trace((GtkWidget*)button, user_data);
1200}
1201
1202
1203void
1204on_button_save_clicked (GtkButton *button,
1205 gpointer user_data)
1206{
1207 save((GtkWidget*)button, user_data);
1208}
1209
1210
1211void
1212on_button_save_as_clicked (GtkButton *button,
1213 gpointer user_data)
1214{
1215 save_as((GtkWidget*)button, user_data);
1216}
1217
1218
1219void
1220on_button_zoom_in_clicked (GtkButton *button,
1221 gpointer user_data)
1222{
1223 zoom_in((GtkWidget*)button, user_data);
1224}
1225
1226
1227void
1228on_button_zoom_out_clicked (GtkButton *button,
1229 gpointer user_data)
1230{
1231 zoom_out((GtkWidget*)button, user_data);
1232}
1233
1234
1235void
1236on_button_zoom_extended_clicked (GtkButton *button,
1237 gpointer user_data)
1238{
1239 zoom_extended((GtkWidget*)button, user_data);
1240}
1241
1242
1243void
1244on_button_go_to_time_clicked (GtkButton *button,
1245 gpointer user_data)
1246{
1247 go_to_time((GtkWidget*)button, user_data);
1248}
1249
1250
1251void
1252on_button_show_time_frame_clicked (GtkButton *button,
1253 gpointer user_data)
1254{
1255 show_time_frame((GtkWidget*)button, user_data);
1256}
1257
1258
1259void
1260on_button_move_up_clicked (GtkButton *button,
1261 gpointer user_data)
1262{
1263 move_up_viewer((GtkWidget*)button, user_data);
1264}
1265
1266
1267void
1268on_button_move_down_clicked (GtkButton *button,
1269 gpointer user_data)
1270{
1271 move_down_viewer((GtkWidget*)button, user_data);
1272}
1273
1274
1275void
1276on_button_delete_viewer_clicked (GtkButton *button,
1277 gpointer user_data)
1278{
1279 delete_viewer((GtkWidget*)button, user_data);
1280}
1281
1282void
1283on_MWindow_destroy (GtkObject *object,
1284 gpointer user_data)
1285{
e4d09234 1286 MainWindow *Main_Window = get_window_data_struct((GtkWidget*)object);
1287 GtkWidget *widget;
1288 Tab *tab = Main_Window->tab;
1289
68b48a45 1290 g_printf("There are : %d windows\n",g_slist_length(g_main_window_list));
561eba2a 1291
68b48a45 1292 g_win_count--;
1293 if(g_win_count == 0)
7a859036 1294 gtk_main_quit ();
561eba2a 1295}
1296
58eecf4a 1297gboolean
1298on_MWindow_configure (GtkWidget *widget,
1299 GdkEventConfigure *event,
1300 gpointer user_data)
1301{
1302 MainWindow * mw_data = get_window_data_struct((GtkWidget*)widget);
1303 float width = event->width;
1304 Tab * tab = mw_data->tab;
1305 TimeWindow time_win;
1306 double ratio;
1307 TimeInterval *time_span;
1308 LttTime time;
bd24a9af 1309
1310 // MD : removed time width modification upon resizing of the main window.
1311 // The viewers will redraw themselves completely, without time interval
1312 // modification.
1313/* while(tab){
58eecf4a 1314 if(mw_data->window_width){
1315 time_span = LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->Time_Span ;
1316 time_win = tab->time_window;
1317 ratio = width / mw_data->window_width;
1318 tab->time_window.time_width = ltt_time_mul(time_win.time_width,ratio);
1319 time = ltt_time_sub(time_span->endTime, time_win.start_time);
1320 if(ltt_time_compare(time, tab->time_window.time_width) < 0){
1321 tab->time_window.time_width = time;
1322 }
1323 }
1324 tab = tab->next;
1325 }
1326
1327 mw_data->window_width = (int)width;
bd24a9af 1328 */
58eecf4a 1329 return FALSE;
1330}
561eba2a 1331
abe346a3 1332
1333/* Set current tab
1334 */
1335
561eba2a 1336void
1337on_MNotebook_switch_page (GtkNotebook *notebook,
1338 GtkNotebookPage *page,
1339 guint page_num,
1340 gpointer user_data)
1341{
bca3b81f 1342 MainWindow * mw = get_window_data_struct((GtkWidget*)notebook);
1343 Tab * tab = mw->tab;
561eba2a 1344
1345 while(page_num){
bca3b81f 1346 tab = tab->next;
561eba2a 1347 page_num--;
1348 }
bca3b81f 1349 mw->current_tab = tab;
561eba2a 1350}
1351
abe346a3 1352
1353/* callback function to check or uncheck the check box (filter)
1354 */
1355
49bf71b5 1356void checkbox_changed(GtkTreeView *treeview,
1357 GtkTreePath *arg1,
1358 GtkTreeViewColumn *arg2,
1359 gpointer user_data)
1360{
1361 GtkTreeStore * store = (GtkTreeStore *)gtk_tree_view_get_model (treeview);
1362 GtkTreeIter iter;
1363 gboolean value;
1364
1365 if (gtk_tree_model_get_iter ((GtkTreeModel *)store, &iter, arg1)){
1366 gtk_tree_model_get ((GtkTreeModel *)store, &iter, CHECKBOX_COLUMN, &value, -1);
1367 value = value? FALSE : TRUE;
1368 gtk_tree_store_set (GTK_TREE_STORE (store), &iter, CHECKBOX_COLUMN, value, -1);
1369 }
1370
1371}
1372
abe346a3 1373
1374/* According to user's selection, update selector(filter)
1375 */
1376
49bf71b5 1377void update_filter(LttvTracesetSelector *s, GtkTreeStore *store )
1378{
ed3b99b6 1379 GtkTreeIter iter, child_iter, child_iter1, child_iter2;
1380 int i, j, k, nb_eventtype;
49bf71b5 1381 LttvTraceSelector * trace;
1382 LttvTracefileSelector * tracefile;
ed3b99b6 1383 LttvEventtypeSelector * eventtype;
1384 gboolean value, value1, value2;
49bf71b5 1385
1386 if(gtk_tree_model_get_iter_first((GtkTreeModel*)store, &iter)){
1387 i = 0;
1388 do{
ed3b99b6 1389 trace = lttv_traceset_selector_trace_get(s, i);
1390 nb_eventtype = lttv_trace_selector_eventtype_number(trace);
49bf71b5 1391 gtk_tree_model_get ((GtkTreeModel*)store, &iter, CHECKBOX_COLUMN, &value,-1);
1392 if(value){
1393 j = 0;
1394 if(gtk_tree_model_iter_children ((GtkTreeModel*)store, &child_iter, &iter)){
1395 do{
ed3b99b6 1396 if(j<1){//eventtype selector for trace
1397 gtk_tree_model_get ((GtkTreeModel*)store, &child_iter, CHECKBOX_COLUMN, &value2,-1);
1398 if(value2){
1399 k=0;
1400 if(gtk_tree_model_iter_children ((GtkTreeModel*)store, &child_iter1, &child_iter)){
1401 do{
1402 eventtype = lttv_trace_selector_eventtype_get(trace,k);
1403 gtk_tree_model_get ((GtkTreeModel*)store, &child_iter1, CHECKBOX_COLUMN, &value2,-1);
1404 lttv_eventtype_selector_set_selected(eventtype,value2);
1405 k++;
1406 }while(gtk_tree_model_iter_next((GtkTreeModel*)store, &child_iter1));
1407 }
1408 }
1409 }else{ //tracefile selector
1410 tracefile = lttv_trace_selector_tracefile_get(trace, j - 1);
1411 gtk_tree_model_get ((GtkTreeModel*)store, &child_iter, CHECKBOX_COLUMN, &value1,-1);
1412 lttv_tracefile_selector_set_selected(tracefile,value1);
1413 if(value1){
1414 gtk_tree_model_iter_children((GtkTreeModel*)store, &child_iter1, &child_iter); //eventtype selector
1415 gtk_tree_model_get ((GtkTreeModel*)store, &child_iter1, CHECKBOX_COLUMN, &value2,-1);
1416 if(value2){
1417 k = 0;
1418 if(gtk_tree_model_iter_children ((GtkTreeModel*)store, &child_iter2, &child_iter1)){
1419 do{//eventtype selector for tracefile
1420 eventtype = lttv_tracefile_selector_eventtype_get(tracefile,k);
1421 gtk_tree_model_get ((GtkTreeModel*)store, &child_iter2, CHECKBOX_COLUMN, &value2,-1);
1422 lttv_eventtype_selector_set_selected(eventtype,value2);
1423 k++;
1424 }while(gtk_tree_model_iter_next((GtkTreeModel*)store, &child_iter2));
1425 }
1426 }
1427 }
1428 }
49bf71b5 1429 j++;
1430 }while(gtk_tree_model_iter_next((GtkTreeModel*)store, &child_iter));
1431 }
1432 }
1433 lttv_trace_selector_set_selected(trace,value);
1434 i++;
1435 }while(gtk_tree_model_iter_next((GtkTreeModel*)store, &iter));
1436 }
1437}
1438
abe346a3 1439
1440/* Display a dialogue showing all eventtypes and traces, let user to select the interested
1441 * eventtypes, tracefiles and traces (filter)
1442 */
1443
a8c0f09d 1444gboolean get_filter_selection(LttvTracesetSelector *s,char *title, char * column_title)
49bf71b5 1445{
1446 GtkWidget * dialogue;
1447 GtkTreeStore * store;
1448 GtkWidget * tree;
1449 GtkWidget * scroll_win;
1450 GtkCellRenderer * renderer;
1451 GtkTreeViewColumn * column;
ed3b99b6 1452 GtkTreeIter iter, child_iter, child_iter1, child_iter2;
1453 int i, j, k, id, nb_trace, nb_tracefile, nb_eventtype;
49bf71b5 1454 LttvTraceSelector * trace;
1455 LttvTracefileSelector * tracefile;
ed3b99b6 1456 LttvEventtypeSelector * eventtype;
49bf71b5 1457 char * name;
1458 gboolean checked;
1459
1460 dialogue = gtk_dialog_new_with_buttons(title,
1461 NULL,
1462 GTK_DIALOG_MODAL,
1463 GTK_STOCK_OK,GTK_RESPONSE_ACCEPT,
1464 GTK_STOCK_CANCEL,GTK_RESPONSE_REJECT,
1465 NULL);
ed3b99b6 1466 gtk_window_set_default_size((GtkWindow*)dialogue, 300, 500);
49bf71b5 1467
1468 store = gtk_tree_store_new (TOTAL_COLUMNS, G_TYPE_BOOLEAN, G_TYPE_STRING);
1469 tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
1470 g_object_unref (G_OBJECT (store));
1471 g_signal_connect (G_OBJECT (tree), "row-activated",
1472 G_CALLBACK (checkbox_changed),
1473 NULL);
1474
1475
1476 renderer = gtk_cell_renderer_toggle_new ();
1477 gtk_cell_renderer_toggle_set_radio((GtkCellRendererToggle *)renderer, FALSE);
1478
1479 g_object_set (G_OBJECT (renderer),"activatable", TRUE, NULL);
1480
1481 column = gtk_tree_view_column_new_with_attributes ("Checkbox",
1482 renderer,
1483 "active", CHECKBOX_COLUMN,
1484 NULL);
1485 gtk_tree_view_column_set_alignment (column, 0.5);
1486 gtk_tree_view_column_set_fixed_width (column, 20);
1487 gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
1488
1489 renderer = gtk_cell_renderer_text_new ();
1490 column = gtk_tree_view_column_new_with_attributes (column_title,
1491 renderer,
1492 "text", NAME_COLUMN,
1493 NULL);
1494 gtk_tree_view_column_set_alignment (column, 0.0);
1495 gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
1496 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW (tree), FALSE);
1497
1498 scroll_win = gtk_scrolled_window_new (NULL, NULL);
1499 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win),
1500 GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
1501 gtk_container_add (GTK_CONTAINER (scroll_win), tree);
1502
1503 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), scroll_win,TRUE, TRUE,0);
1504
1505 gtk_widget_show(scroll_win);
1506 gtk_widget_show(tree);
1507
ed3b99b6 1508 nb_trace = lttv_traceset_selector_trace_number(s);
49bf71b5 1509 for(i=0;i<nb_trace;i++){
ed3b99b6 1510 trace = lttv_traceset_selector_trace_get(s, i);
49bf71b5 1511 name = lttv_trace_selector_get_name(trace);
1512 gtk_tree_store_append (store, &iter, NULL);
1513 checked = lttv_trace_selector_get_selected(trace);
1514 gtk_tree_store_set (store, &iter,
1515 CHECKBOX_COLUMN,checked,
1516 NAME_COLUMN,name,
1517 -1);
ed3b99b6 1518
1519 gtk_tree_store_append (store, &child_iter, &iter);
1520 gtk_tree_store_set (store, &child_iter,
1521 CHECKBOX_COLUMN, checked,
1522 NAME_COLUMN,"eventtype",
1523 -1);
1524
1525 nb_eventtype = lttv_trace_selector_eventtype_number(trace);
1526 for(j=0;j<nb_eventtype;j++){
1527 eventtype = lttv_trace_selector_eventtype_get(trace,j);
1528 name = lttv_eventtype_selector_get_name(eventtype);
1529 checked = lttv_eventtype_selector_get_selected(eventtype);
1530 gtk_tree_store_append (store, &child_iter1, &child_iter);
1531 gtk_tree_store_set (store, &child_iter1,
1532 CHECKBOX_COLUMN, checked,
1533 NAME_COLUMN,name,
1534 -1);
1535 }
1536
1537 nb_tracefile = lttv_trace_selector_tracefile_number(trace);
49bf71b5 1538 for(j=0;j<nb_tracefile;j++){
ed3b99b6 1539 tracefile = lttv_trace_selector_tracefile_get(trace, j);
49bf71b5 1540 name = lttv_tracefile_selector_get_name(tracefile);
1541 gtk_tree_store_append (store, &child_iter, &iter);
1542 checked = lttv_tracefile_selector_get_selected(tracefile);
1543 gtk_tree_store_set (store, &child_iter,
1544 CHECKBOX_COLUMN, checked,
1545 NAME_COLUMN,name,
1546 -1);
ed3b99b6 1547
1548 gtk_tree_store_append (store, &child_iter1, &child_iter);
1549 gtk_tree_store_set (store, &child_iter1,
1550 CHECKBOX_COLUMN, checked,
1551 NAME_COLUMN,"eventtype",
1552 -1);
1553
1554 for(k=0;k<nb_eventtype;k++){
1555 eventtype = lttv_tracefile_selector_eventtype_get(tracefile,k);
1556 name = lttv_eventtype_selector_get_name(eventtype);
1557 checked = lttv_eventtype_selector_get_selected(eventtype);
1558 gtk_tree_store_append (store, &child_iter2, &child_iter1);
1559 gtk_tree_store_set (store, &child_iter2,
1560 CHECKBOX_COLUMN, checked,
1561 NAME_COLUMN,name,
1562 -1);
1563 }
49bf71b5 1564 }
1565 }
1566
1567 id = gtk_dialog_run(GTK_DIALOG(dialogue));
1568 switch(id){
1569 case GTK_RESPONSE_ACCEPT:
1570 case GTK_RESPONSE_OK:
1571 update_filter(s, store);
a8c0f09d 1572 gtk_widget_destroy(dialogue);
1573 return TRUE;
49bf71b5 1574 case GTK_RESPONSE_REJECT:
1575 case GTK_RESPONSE_CANCEL:
1576 default:
1577 gtk_widget_destroy(dialogue);
1578 break;
1579 }
a8c0f09d 1580 return FALSE;
49bf71b5 1581}
1582
abe346a3 1583
1584/* Select a trace which will be removed from traceset
1585 */
1586
2176f952 1587char * get_remove_trace(char ** all_trace_name, int nb_trace)
1588{
1589 return get_selection(all_trace_name, nb_trace,
1590 "Select a trace", "Trace pathname");
1591}
abe346a3 1592
1593
1594/* Select a module which will be unloaded
1595 */
1596
36b3c068 1597char * get_unload_module(char ** loaded_module_name, int nb_module)
2176f952 1598{
1599 return get_selection(loaded_module_name, nb_module,
1600 "Select an unload module", "Module pathname");
1601}
1602
abe346a3 1603
1604/* Display a dialogue which shows all selectable items, let user to
1605 * select one of them
1606 */
1607
2176f952 1608char * get_selection(char ** loaded_module_name, int nb_module,
1609 char *title, char * column_title)
36b3c068 1610{
1611 GtkWidget * dialogue;
1612 GtkWidget * scroll_win;
1613 GtkWidget * tree;
1614 GtkListStore * store;
1615 GtkTreeViewColumn * column;
1616 GtkCellRenderer * renderer;
1617 GtkTreeSelection * select;
1618 GtkTreeIter iter;
1619 gint id, i;
1620 char * unload_module_name = NULL;
1621
2176f952 1622 dialogue = gtk_dialog_new_with_buttons(title,
36b3c068 1623 NULL,
1624 GTK_DIALOG_MODAL,
1625 GTK_STOCK_OK,GTK_RESPONSE_ACCEPT,
1626 GTK_STOCK_CANCEL,GTK_RESPONSE_REJECT,
1627 NULL);
1628 gtk_window_set_default_size((GtkWindow*)dialogue, 500, 200);
1629
1630 scroll_win = gtk_scrolled_window_new (NULL, NULL);
1631 gtk_widget_show ( scroll_win);
1632 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win),
1633 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1634
1635 store = gtk_list_store_new (N_COLUMNS,G_TYPE_STRING);
1636 tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL (store));
1637 gtk_widget_show ( tree);
1638 g_object_unref (G_OBJECT (store));
1639
1640 renderer = gtk_cell_renderer_text_new ();
2176f952 1641 column = gtk_tree_view_column_new_with_attributes (column_title,
36b3c068 1642 renderer,
1643 "text", MODULE_COLUMN,
1644 NULL);
1645 gtk_tree_view_column_set_alignment (column, 0.5);
1646 gtk_tree_view_column_set_fixed_width (column, 150);
1647 gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
1648
1649 select = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree));
1650 gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE);
1651
1652 gtk_container_add (GTK_CONTAINER (scroll_win), tree);
1653
1654 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), scroll_win,TRUE, TRUE,0);
1655
1656 for(i=0;i<nb_module;i++){
1657 gtk_list_store_append (store, &iter);
1658 gtk_list_store_set (store, &iter, MODULE_COLUMN,loaded_module_name[i],-1);
1659 }
1660
1661 id = gtk_dialog_run(GTK_DIALOG(dialogue));
1662 switch(id){
1663 case GTK_RESPONSE_ACCEPT:
1664 case GTK_RESPONSE_OK:
1665 if (gtk_tree_selection_get_selected (select, (GtkTreeModel**)&store, &iter)){
1666 gtk_tree_model_get ((GtkTreeModel*)store, &iter, MODULE_COLUMN, &unload_module_name, -1);
1667 }
1668 case GTK_RESPONSE_REJECT:
1669 case GTK_RESPONSE_CANCEL:
1670 default:
1671 gtk_widget_destroy(dialogue);
1672 break;
1673 }
1674
1675 return unload_module_name;
1676}
5723fa24 1677
abe346a3 1678
1679/* hash funtions
1680 */
1681
2176f952 1682void main_window_destroy_hash_key(gpointer key)
2061e03d 1683{
1684 g_free(key);
1685}
1686
2176f952 1687void main_window_destroy_hash_data(gpointer data)
2061e03d 1688{
1689}
1690
1691
abe346a3 1692/* Insert menu entry and tool button into all main windows for modules
1693 * It checks whether the menu entry or tool button exists or not,
1694 * if they do not exist, then construct the widget and insert them
1695 * into all main windows
1696 */
1697
bca3b81f 1698void insert_menu_toolbar_item(MainWindow * mw, gpointer user_data)
5723fa24 1699{
1700 int i;
1701 GdkPixbuf *pixbuf;
1702 view_constructor constructor;
1703 LttvMenus * menu;
1704 LttvToolbars * toolbar;
68b48a45 1705 lttv_menu_closure *menu_item;
1706 lttv_toolbar_closure *toolbar_item;
5723fa24 1707 LttvAttributeValue value;
1708 LttvIAttribute *attributes = LTTV_IATTRIBUTE(lttv_global_attributes());
68b48a45 1709 GtkWidget * tool_menu_title_menu, *insert_view, *pixmap, *tmp;
5723fa24 1710
1711 g_assert(lttv_iattribute_find_by_path(attributes,
1712 "viewers/menu", LTTV_POINTER, &value));
1713 menu = (LttvMenus*)*(value.v_pointer);
1714
1715 if(menu){
1716 for(i=0;i<menu->len;i++){
68b48a45 1717 menu_item = &g_array_index(menu, lttv_menu_closure, i);
1718 tmp = g_hash_table_lookup(mw->hash_menu_item, g_strdup(menu_item->menuText));
3872a20e 1719 if(tmp)continue;
68b48a45 1720 constructor = menu_item->con;
bca3b81f 1721 tool_menu_title_menu = lookup_widget(mw->mwindow,"ToolMenuTitle_menu");
68b48a45 1722 insert_view = gtk_menu_item_new_with_mnemonic (menu_item->menuText);
5723fa24 1723 gtk_widget_show (insert_view);
68b48a45 1724 gtk_container_add (GTK_CONTAINER (tool_menu_title_menu), insert_view);
5723fa24 1725 g_signal_connect ((gpointer) insert_view, "activate",
68b48a45 1726 G_CALLBACK (insert_viewer_wrap),
5723fa24 1727 constructor);
68b48a45 1728 g_hash_table_insert(mw->hash_menu_item, g_strdup(menu_item->menuText),
2061e03d 1729 insert_view);
5723fa24 1730 }
1731 }
1732
1733 g_assert(lttv_iattribute_find_by_path(attributes,
1734 "viewers/toolbar", LTTV_POINTER, &value));
1735 toolbar = (LttvToolbars*)*(value.v_pointer);
1736
1737 if(toolbar){
1738 for(i=0;i<toolbar->len;i++){
68b48a45 1739 toolbar_item = &g_array_index(toolbar, lttv_toolbar_closure, i);
1740 tmp = g_hash_table_lookup(mw->hash_toolbar_item, g_strdup(toolbar_item->tooltip));
3872a20e 1741 if(tmp)continue;
68b48a45 1742 constructor = toolbar_item->con;
efde9138 1743 tool_menu_title_menu = lookup_widget(mw->mwindow,"MToolbar1");
68b48a45 1744 pixbuf = gdk_pixbuf_new_from_xpm_data ((const char**)toolbar_item->pixmap);
5723fa24 1745 pixmap = gtk_image_new_from_pixbuf(pixbuf);
68b48a45 1746 insert_view = gtk_toolbar_append_element (GTK_TOOLBAR (tool_menu_title_menu),
5723fa24 1747 GTK_TOOLBAR_CHILD_BUTTON,
1748 NULL,
1749 "",
68b48a45 1750 toolbar_item->tooltip, NULL,
5723fa24 1751 pixmap, NULL, NULL);
68b48a45 1752 gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (tool_menu_title_menu)->children)->data))->label), TRUE);
5723fa24 1753 gtk_widget_show (insert_view);
1754 gtk_container_set_border_width (GTK_CONTAINER (insert_view), 1);
68b48a45 1755 g_signal_connect ((gpointer) insert_view, "clicked",G_CALLBACK (insert_viewer_wrap),constructor);
1756 g_hash_table_insert(mw->hash_toolbar_item, g_strdup(toolbar_item->tooltip),
2061e03d 1757 insert_view);
5723fa24 1758 }
1759 }
1760}
1761
abe346a3 1762
1763/* Create a main window
1764 */
1765
716e4367 1766void construct_main_window(MainWindow * parent, WindowCreationData * win_creation_data)
5723fa24 1767{
68b48a45 1768 g_critical("construct_main_window()");
1769 GtkWidget * new_window; /* New generated main window */
bca3b81f 1770 MainWindow * new_m_window;/* New main window structure */
5723fa24 1771 GtkNotebook * notebook;
f7afe191 1772 LttvIAttribute *attributes =
1773 LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE, NULL));
1774 LttvAttributeValue value;
2061e03d 1775
bca3b81f 1776 new_m_window = g_new(MainWindow, 1);
5723fa24 1777
1778 // Add the object's information to the module's array
68b48a45 1779 g_main_window_list = g_slist_append(g_main_window_list, new_m_window);
5723fa24 1780
f7afe191 1781
68b48a45 1782 new_window = create_MWindow();
1783 gtk_widget_show (new_window);
5723fa24 1784
bca3b81f 1785 new_m_window->attributes = attributes;
f7afe191 1786
bca3b81f 1787 new_m_window->mwindow = new_window;
1788 new_m_window->tab = NULL;
1789 new_m_window->current_tab = NULL;
1790 new_m_window->attributes = LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE, NULL));
5723fa24 1791 if(parent){
bca3b81f 1792 new_m_window->win_creation_data = parent->win_creation_data;
5723fa24 1793 }else{
bca3b81f 1794 new_m_window->win_creation_data = win_creation_data;
5723fa24 1795 }
1796
68b48a45 1797 new_m_window->hash_menu_item = g_hash_table_new_full (g_str_hash, g_str_equal,
2176f952 1798 main_window_destroy_hash_key,
1799 main_window_destroy_hash_data);
68b48a45 1800 new_m_window->hash_toolbar_item = g_hash_table_new_full (g_str_hash, g_str_equal,
2176f952 1801 main_window_destroy_hash_key,
1802 main_window_destroy_hash_data);
2061e03d 1803
68b48a45 1804 insert_menu_toolbar_item(new_m_window, NULL);
5723fa24 1805
68b48a45 1806 g_object_set_data(G_OBJECT(new_window), "mainWindow", (gpointer)new_m_window);
5723fa24 1807
1808 //create a default tab
bca3b81f 1809 notebook = (GtkNotebook *)lookup_widget(new_m_window->mwindow, "MNotebook");
5723fa24 1810 if(notebook == NULL){
1811 g_printf("Notebook does not exist\n");
1812 return;
1813 }
1814 //for now there is no name field in LttvTraceset structure
1815 //Use "Traceset" as the label for the default tab
6f7ad7ae 1816 create_tab(parent, new_m_window, notebook,"Traceset");
5723fa24 1817
7a859036 1818 g_object_set_data_full(
bca3b81f 1819 G_OBJECT(new_m_window->mwindow),
7a859036 1820 "Main_Window_Data",
68b48a45 1821 new_m_window,
1822 (GDestroyNotify)main_window_free);
7a859036 1823
68b48a45 1824 g_win_count++;
5723fa24 1825}
1826
abe346a3 1827
1828/* Free the memory occupied by a tab structure
1829 * destroy the tab
1830 */
1831
bca3b81f 1832void tab_destructor(Tab * tab_instance)
f7afe191 1833{
716e4367 1834 int i, nb, ref_count;
1835 LttvTrace * trace;
1836
bca3b81f 1837 if(tab_instance->attributes)
1838 g_object_unref(tab_instance->attributes);
2061e03d 1839
bca3b81f 1840 if(tab_instance->mw->tab == tab_instance){
1841 tab_instance->mw->tab = tab_instance->next;
2061e03d 1842 }else{
bca3b81f 1843 Tab * tmp1, *tmp = tab_instance->mw->tab;
68b48a45 1844 while(tmp != tab_instance){
2061e03d 1845 tmp1 = tmp;
bca3b81f 1846 tmp = tmp->next;
2061e03d 1847 }
bca3b81f 1848 tmp1->next = tab_instance->next;
2061e03d 1849 }
716e4367 1850
1851 if(tab_instance->traceset_info->traceset_context != NULL){
1852 lttv_context_fini(LTTV_TRACESET_CONTEXT(tab_instance->traceset_info->
1853 traceset_context));
1854 g_object_unref(tab_instance->traceset_info->traceset_context);
1855 }
1856 if(tab_instance->traceset_info->traceset != NULL) {
1857 nb = lttv_traceset_number(tab_instance->traceset_info->traceset);
1858 for(i = 0 ; i < nb ; i++) {
1859 trace = lttv_traceset_get(tab_instance->traceset_info->traceset, i);
1860 ref_count = lttv_trace_get_ref_number(trace);
49bf71b5 1861 if(ref_count <= 1){
716e4367 1862 ltt_trace_close(lttv_trace(trace));
6f7ad7ae 1863 lttv_trace_destroy(trace);
49bf71b5 1864 }
6f7ad7ae 1865 // lttv_trace_destroy(trace);
716e4367 1866 }
1867 }
1868 lttv_traceset_destroy(tab_instance->traceset_info->traceset);
1869 g_free(tab_instance->traceset_info);
68b48a45 1870 g_free(tab_instance);
f7afe191 1871}
1872
abe346a3 1873
1874/* Create a tab and insert it into the current main window
1875 */
1876
716e4367 1877void * create_tab(MainWindow * parent, MainWindow* current_window,
1878 GtkNotebook * notebook, char * label)
5723fa24 1879{
1880 GList * list;
bca3b81f 1881 Tab * tmp_tab;
716e4367 1882 MainWindow * mw_data = current_window;
68b48a45 1883 LttTime tmp_time;
1884
abe346a3 1885 //create a new tab data structure
bca3b81f 1886 tmp_tab = mw_data->tab;
1887 while(tmp_tab && tmp_tab->next) tmp_tab = tmp_tab->next;
68b48a45 1888 if(!tmp_tab){
bca3b81f 1889 mw_data->current_tab = NULL;
1890 tmp_tab = g_new(Tab,1);
1891 mw_data->tab = tmp_tab;
5723fa24 1892 }else{
bca3b81f 1893 tmp_tab->next = g_new(Tab,1);
1894 tmp_tab = tmp_tab->next;
5723fa24 1895 }
716e4367 1896
abe346a3 1897 //construct and initialize the traceset_info
716e4367 1898 tmp_tab->traceset_info = g_new(TracesetInfo,1);
1899 if(parent){
1900 tmp_tab->traceset_info->traceset =
1901 lttv_traceset_copy(parent->current_tab->traceset_info->traceset);
1902 }else{
1903 if(mw_data->current_tab){
1904 tmp_tab->traceset_info->traceset =
1905 lttv_traceset_copy(mw_data->current_tab->traceset_info->traceset);
1906 }else{
1907 tmp_tab->traceset_info->traceset = lttv_traceset_new();
49bf71b5 1908 /* Add the command line trace */
1909 if(g_init_trace != NULL)
1910 lttv_traceset_add(tmp_tab->traceset_info->traceset, g_init_trace);
716e4367 1911 }
716e4367 1912 }
1913 //FIXME copy not implemented in lower level
1914 tmp_tab->traceset_info->traceset_context =
1915 g_object_new(LTTV_TRACESET_STATS_TYPE, NULL);
1916 lttv_context_init(
1917 LTTV_TRACESET_CONTEXT(tmp_tab->traceset_info->traceset_context),
1918 tmp_tab->traceset_info->traceset);
1919
abe346a3 1920 //determine the current_time and time_window of the tab
bca3b81f 1921 if(mw_data->current_tab){
716e4367 1922 // Will have to read directly at the main window level, as we want
1923 // to be able to modify a traceset on the fly.
bca3b81f 1924 tmp_tab->time_window = mw_data->current_tab->time_window;
1925 tmp_tab->current_time = mw_data->current_tab->current_time;
5723fa24 1926 }else{
716e4367 1927 // Will have to read directly at the main window level, as we want
1928 // to be able to modify a traceset on the fly.
1929 // get_traceset_time_span(mw_data,&tmp_tab->traceStartTime, &tmp_tab->traceEndTime);
bca3b81f 1930 tmp_tab->time_window.start_time =
716e4367 1931 LTTV_TRACESET_CONTEXT(tmp_tab->traceset_info->traceset_context)->Time_Span->startTime;
f7afe191 1932 if(DEFAULT_TIME_WIDTH_S <
716e4367 1933 LTTV_TRACESET_CONTEXT(tmp_tab->traceset_info->traceset_context)->Time_Span->endTime.tv_sec)
68b48a45 1934 tmp_time.tv_sec = DEFAULT_TIME_WIDTH_S;
f7afe191 1935 else
68b48a45 1936 tmp_time.tv_sec =
716e4367 1937 LTTV_TRACESET_CONTEXT(tmp_tab->traceset_info->traceset_context)->Time_Span->endTime.tv_sec;
68b48a45 1938 tmp_time.tv_nsec = 0;
bca3b81f 1939 tmp_tab->time_window.time_width = tmp_time ;
a8c0f09d 1940 tmp_tab->current_time.tv_sec =
1941 LTTV_TRACESET_CONTEXT(tmp_tab->traceset_info->traceset_context)->Time_Span->startTime.tv_sec;
1942 tmp_tab->current_time.tv_nsec =
1943 LTTV_TRACESET_CONTEXT(tmp_tab->traceset_info->traceset_context)->Time_Span->startTime.tv_nsec;
5723fa24 1944 }
bca3b81f 1945 tmp_tab->attributes = LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE, NULL));
1946 // mw_data->current_tab = tmp_tab;
daecc161 1947 tmp_tab->multi_vpaned = (GtkMultiVPaned*)gtk_multi_vpaned_new();
1948 tmp_tab->multi_vpaned->mw = mw_data;
1949 gtk_widget_show((GtkWidget*)tmp_tab->multi_vpaned);
bca3b81f 1950 tmp_tab->next = NULL;
68b48a45 1951 tmp_tab->mw = mw_data;
5723fa24 1952
68b48a45 1953 tmp_tab->label = gtk_label_new (label);
1954 gtk_widget_show (tmp_tab->label);
5723fa24 1955
f7afe191 1956 g_object_set_data_full(
daecc161 1957 G_OBJECT(tmp_tab->multi_vpaned),
f7afe191 1958 "Tab_Info",
68b48a45 1959 tmp_tab,
1960 (GDestroyNotify)tab_destructor);
540edb40 1961
abe346a3 1962 //add state update hooks
540edb40 1963 lttv_state_add_event_hooks(
1964 (LttvTracesetState*)tmp_tab->traceset_info->traceset_context);
5723fa24 1965
abe346a3 1966 //insert tab into notebook
daecc161 1967 gtk_notebook_append_page(notebook, (GtkWidget*)tmp_tab->multi_vpaned, tmp_tab->label);
5723fa24 1968 list = gtk_container_get_children(GTK_CONTAINER(notebook));
1969 gtk_notebook_set_current_page(notebook,g_list_length(list)-1);
efde9138 1970 if(g_list_length(list)>1)
1971 gtk_notebook_set_show_tabs(notebook, TRUE);
5723fa24 1972}
2061e03d 1973
abe346a3 1974
1975/* Remove menu entry and tool button from main window for the
1976 * unloaded module
1977 */
1978
2061e03d 1979void remove_menu_item(gpointer main_win, gpointer user_data)
1980{
bca3b81f 1981 MainWindow * mw = (MainWindow *) main_win;
68b48a45 1982 lttv_menu_closure *menu_item = (lttv_menu_closure *)user_data;
1983 GtkWidget * tool_menu_title_menu, *insert_view;
2061e03d 1984
bca3b81f 1985 tool_menu_title_menu = lookup_widget(mw->mwindow,"ToolMenuTitle_menu");
2061e03d 1986 insert_view = (GtkWidget*)g_hash_table_lookup(mw->hash_menu_item,
68b48a45 1987 menu_item->menuText);
2061e03d 1988 if(insert_view){
68b48a45 1989 g_hash_table_remove(mw->hash_menu_item, menu_item->menuText);
1990 gtk_container_remove (GTK_CONTAINER (tool_menu_title_menu), insert_view);
2061e03d 1991 }
1992}
1993
1994void remove_toolbar_item(gpointer main_win, gpointer user_data)
1995{
bca3b81f 1996 MainWindow * mw = (MainWindow *) main_win;
68b48a45 1997 lttv_toolbar_closure *toolbar_item = (lttv_toolbar_closure *)user_data;
1998 GtkWidget * tool_menu_title_menu, *insert_view;
2061e03d 1999
2000
efde9138 2001 tool_menu_title_menu = lookup_widget(mw->mwindow,"MToolbar1");
2061e03d 2002 insert_view = (GtkWidget*)g_hash_table_lookup(mw->hash_toolbar_item,
68b48a45 2003 toolbar_item->tooltip);
2061e03d 2004 if(insert_view){
68b48a45 2005 g_hash_table_remove(mw->hash_toolbar_item, toolbar_item->tooltip);
2006 gtk_container_remove (GTK_CONTAINER (tool_menu_title_menu), insert_view);
2061e03d 2007 }
2008}
2009
2010/**
abe346a3 2011 * Remove menu and toolbar item when a module unloaded from all
2012 * main windows
2061e03d 2013 */
2176f952 2014
2061e03d 2015void main_window_remove_menu_item(lttv_constructor constructor)
2016{
2017 int i;
2018 LttvMenus * menu;
68b48a45 2019 lttv_menu_closure *menu_item;
2061e03d 2020 LttvAttributeValue value;
2021 LttvIAttribute *attributes = LTTV_IATTRIBUTE(lttv_global_attributes());
2022
2023 g_assert(lttv_iattribute_find_by_path(attributes,
2024 "viewers/menu", LTTV_POINTER, &value));
2025 menu = (LttvMenus*)*(value.v_pointer);
2026
2027 if(menu){
2028 for(i=0;i<menu->len;i++){
68b48a45 2029 menu_item = &g_array_index(menu, lttv_menu_closure, i);
2030 if(menu_item->con != constructor) continue;
2031 if(g_main_window_list){
2032 g_slist_foreach(g_main_window_list, remove_menu_item, menu_item);
2176f952 2033 }
2061e03d 2034 break;
2035 }
2036 }
2037
2038}
2039
2040void main_window_remove_toolbar_item(lttv_constructor constructor)
2041{
2042 int i;
2043 LttvToolbars * toolbar;
68b48a45 2044 lttv_toolbar_closure *toolbar_item;
2061e03d 2045 LttvAttributeValue value;
2046 LttvIAttribute *attributes = LTTV_IATTRIBUTE(lttv_global_attributes());
2047
2048 g_assert(lttv_iattribute_find_by_path(attributes,
2049 "viewers/toolbar", LTTV_POINTER, &value));
2050 toolbar = (LttvToolbars*)*(value.v_pointer);
2051
2052 if(toolbar){
2053 for(i=0;i<toolbar->len;i++){
68b48a45 2054 toolbar_item = &g_array_index(toolbar, lttv_toolbar_closure, i);
2055 if(toolbar_item->con != constructor) continue;
2056 if(g_main_window_list){
2057 g_slist_foreach(g_main_window_list, remove_toolbar_item, toolbar_item);
2176f952 2058 }
2061e03d 2059 break;
2060 }
2061 }
2062}
LTTng 2.x Viewer (LTTV)
This page took 0.134508 seconds and 4 git commands to generate.