projects / lttv.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
viewer -> lttvwindow name change
[lttv.git] / ltt / branches / poly / lttv / modules / gui / lttvwindow / lttvwindow / callbacks.c
CommitLineData
e076699e 1/* This file is part of the Linux Trace Toolkit viewer
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>
561eba2a 24
25#include "callbacks.h"
26#include "interface.h"
27#include "support.h"
a43d67ba 28#include <ltt/trace.h>
29#include <ltt/facility.h>
30#include <ltt/time.h>
31#include <ltt/event.h>
2a2fa4f0 32#include <lttv/lttv.h>
a43d67ba 33#include <lttv/module.h>
34#include <lttv/iattribute.h>
35#include <lttv/stats.h>
13f86ce2 36#include <lttvwindow/mainwindow.h>
37#include <lttvwindow/menu.h>
38#include <lttvwindow/toolbar.h>
501e4e70 39#include <lttvwindow/lttvwindow.h>
13f86ce2 40#include <lttvwindow/gtkdirsel.h>
13f86ce2 41#include <lttvwindow/lttvfilter.h>
6b1d3120 42
f7afe191 43#define PATH_LENGTH 256
44#define DEFAULT_TIME_WIDTH_S 1
45
49bf71b5 46extern LttvTrace *g_init_trace ;
561eba2a 47
ec25ff5e 48
49/** Array containing instanced objects. */
68b48a45 50extern GSList * g_main_window_list;
561eba2a 51
68b48a45 52static int g_win_count = 0;
7a859036 53
a43d67ba 54/** MD : keep old directory. */
3658a338 55static char remember_plugins_dir[PATH_LENGTH] = "";
56static char remember_trace_dir[PATH_LENGTH] = "";
6fbb1ddf 57
58
bca3b81f 59MainWindow * get_window_data_struct(GtkWidget * widget);
36b3c068 60char * get_unload_module(char ** loaded_module_name, int nb_module);
2176f952 61char * get_remove_trace(char ** all_trace_name, int nb_trace);
62char * get_selection(char ** all_name, int nb, char *title, char * column_title);
a8c0f09d 63gboolean get_filter_selection(LttvTracesetSelector *s, char *title, char * column_title);
716e4367 64void * create_tab(MainWindow * parent, MainWindow * current_window,
65 GtkNotebook * notebook, char * label);
561eba2a 66
42fcbb71 67void insert_viewer(GtkWidget* widget, lttvwindow_viewer_constructor constructor);
49bf71b5 68void update_filter(LttvTracesetSelector *s, GtkTreeStore *store );
69
70void checkbox_changed(GtkTreeView *treeview,
71 GtkTreePath *arg1,
72 GtkTreeViewColumn *arg2,
73 gpointer user_data);
74void remove_trace_from_traceset_selector(GtkMultiVPaned * paned, unsigned i);
75void add_trace_into_traceset_selector(GtkMultiVPaned * paned, LttTrace * trace);
76
77LttvTracesetSelector * construct_traceset_selector(LttvTraceset * traceset);
78
501e4e70 79static gboolean lttvwindow_process_pending_requests(Tab *tab);
a8c0f09d 80unsigned get_max_event_number(MainWindow * mw_data);
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
abe346a3 94/* Construct a selector(filter), which will be associated with a viewer,
95 * and provides an interface for user to select interested events and traces
96 */
561eba2a 97
49bf71b5 98LttvTracesetSelector * construct_traceset_selector(LttvTraceset * traceset)
99{
100 LttvTracesetSelector * s;
101 LttvTraceSelector * trace;
102 LttvTracefileSelector * tracefile;
ed3b99b6 103 LttvEventtypeSelector * eventtype;
104 int i, j, k, m;
105 int nb_trace, nb_tracefile, nb_control, nb_per_cpu, nb_facility, nb_event;
49bf71b5 106 LttvTrace * trace_v;
107 LttTrace * t;
108 LttTracefile *tf;
ed3b99b6 109 LttFacility * fac;
110 LttEventType * et;
49bf71b5 111
112 s = lttv_traceset_selector_new(lttv_traceset_name(traceset));
113 nb_trace = lttv_traceset_number(traceset);
114 for(i=0;i<nb_trace;i++){
115 trace_v = lttv_traceset_get(traceset, i);
116 t = lttv_trace(trace_v);
117 trace = lttv_trace_selector_new(t);
ed3b99b6 118 lttv_traceset_selector_trace_add(s, trace);
119
120 nb_facility = ltt_trace_facility_number(t);
121 for(k=0;k<nb_facility;k++){
122 fac = ltt_trace_facility_get(t,k);
123 nb_event = (int) ltt_facility_eventtype_number(fac);
124 for(m=0;m<nb_event;m++){
125 et = ltt_facility_eventtype_get(fac,m);
126 eventtype = lttv_eventtype_selector_new(et);
127 lttv_trace_selector_eventtype_add(trace, eventtype);
128 }
129 }
130
49bf71b5 131 nb_control = ltt_trace_control_tracefile_number(t);
132 nb_per_cpu = ltt_trace_per_cpu_tracefile_number(t);
133 nb_tracefile = nb_control + nb_per_cpu;
134
135 for(j = 0 ; j < nb_tracefile ; j++) {
136 if(j < nb_control)
137 tf = ltt_trace_control_tracefile_get(t, j);
138 else
139 tf = ltt_trace_per_cpu_tracefile_get(t, j - nb_control);
140 tracefile = lttv_tracefile_selector_new(tf);
ed3b99b6 141 lttv_trace_selector_tracefile_add(trace, tracefile);
142 lttv_eventtype_selector_copy(trace, tracefile);
49bf71b5 143 }
144 }
145 return s;
146}
147
abe346a3 148
149/* insert_viewer function constructs an instance of a viewer first,
150 * then inserts the widget of the instance into the container of the
151 * main window
152 */
153
561eba2a 154void
606309a4 155insert_viewer_wrap(GtkWidget *menuitem, gpointer user_data)
561eba2a 156{
157 guint val = 20;
606309a4 158
42fcbb71 159 insert_viewer((GtkWidget*)menuitem, (lttvwindow_viewer_constructor)user_data);
37d0eca6 160 // selected_hook(&val);
561eba2a 161}
162
561eba2a 163
164/* internal functions */
501e4e70 165static void insert_viewer(GtkWidget* widget, lttvwindow_viewer_constructor constructor)
561eba2a 166{
daecc161 167 GtkMultiVPaned * multi_vpaned;
501e4e70 168 MainWindow * mw_data = get_window_data_struct(widget);
f9334f6f 169 GtkWidget * viewer;
49bf71b5 170 LttvTracesetSelector * s;
202f6c8f 171 TimeInterval * time_interval;
501e4e70 172 Tab *tab = mw_data->current_tab;
561eba2a 173
501e4e70 174 if(!tab) return;
175 multi_vpaned = tab->multi_vpaned;
561eba2a 176
501e4e70 177 s = construct_traceset_selector(tab->traceset_info->traceset);
178 viewer = (GtkWidget*)constructor(tab, s, "Traceset_Selector");
f9334f6f 179 if(viewer)
f0d936c0 180 {
daecc161 181 gtk_multi_vpaned_widget_add(multi_vpaned, viewer);
a43d67ba 182 // We unref here, because it is now referenced by the multi_vpaned!
183 g_object_unref(G_OBJECT(viewer));
184
185 // The viewer will show itself when it receives a show notify
186 // So we call the show notify hooks here. It will
187 // typically add hooks for reading, we call process trace, and the
188 // end of reading hook will call gtk_widget_show and unregister the
189 // hooks.
190 // Note that show notify gets the time_requested through the call_data.
191 //show_viewer(mw_data);
192 // in expose now call_pending_read_hooks(mw_data);
f0d936c0 193 }
561eba2a 194}
195
abe346a3 196
197/* get_label function is used to get user input, it displays an input
198 * box, which allows user to input a string
199 */
200
561eba2a 201void get_label_string (GtkWidget * text, gchar * label)
202{
203 GtkEntry * entry = (GtkEntry*)text;
204 if(strlen(gtk_entry_get_text(entry))!=0)
205 strcpy(label,gtk_entry_get_text(entry));
206}
207
eb38aea5 208gboolean get_label(MainWindow * mw, gchar * str, gchar* dialogue_title, gchar * label_str)
561eba2a 209{
210 GtkWidget * dialogue;
211 GtkWidget * text;
212 GtkWidget * label;
213 gint id;
214
5723fa24 215 dialogue = gtk_dialog_new_with_buttons(dialogue_title,NULL,
561eba2a 216 GTK_DIALOG_MODAL,
217 GTK_STOCK_OK,GTK_RESPONSE_ACCEPT,
218 GTK_STOCK_CANCEL,GTK_RESPONSE_REJECT,
219 NULL);
220
6b1d3120 221 label = gtk_label_new(label_str);
561eba2a 222 gtk_widget_show(label);
223
224 text = gtk_entry_new();
225 gtk_widget_show(text);
226
227 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), label,TRUE, TRUE,0);
228 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), text,FALSE, FALSE,0);
229
230 id = gtk_dialog_run(GTK_DIALOG(dialogue));
231 switch(id){
232 case GTK_RESPONSE_ACCEPT:
233 get_label_string(text,str);
234 gtk_widget_destroy(dialogue);
235 break;
236 case GTK_RESPONSE_REJECT:
237 default:
238 gtk_widget_destroy(dialogue);
eb38aea5 239 return FALSE;
561eba2a 240 }
eb38aea5 241 return TRUE;
561eba2a 242}
243
abe346a3 244
245/* get_window_data_struct function is actually a lookup function,
246 * given a widget which is in the tree of the main window, it will
247 * return the MainWindow data structure associated with main window
248 */
249
bca3b81f 250MainWindow * get_window_data_struct(GtkWidget * widget)
561eba2a 251{
252 GtkWidget * mw;
bca3b81f 253 MainWindow * mw_data;
561eba2a 254
255 mw = lookup_widget(widget, "MWindow");
256 if(mw == NULL){
257 g_printf("Main window does not exist\n");
258 return;
259 }
260
bca3b81f 261 mw_data = (MainWindow *) g_object_get_data(G_OBJECT(mw),"mainWindow");
68b48a45 262 if(mw_data == NULL){
561eba2a 263 g_printf("Main window data does not exist\n");
264 return;
265 }
68b48a45 266 return mw_data;
561eba2a 267}
268
abe346a3 269
270/* create_new_window function, just constructs a new main window
271 */
272
68b48a45 273void create_new_window(GtkWidget* widget, gpointer user_data, gboolean clone)
561eba2a 274{
bca3b81f 275 MainWindow * parent = get_window_data_struct(widget);
561eba2a 276
561eba2a 277 if(clone){
278 g_printf("Clone : use the same traceset\n");
08b1c66e 279 construct_main_window(parent);
561eba2a 280 }else{
281 g_printf("Empty : traceset is set to NULL\n");
08b1c66e 282 construct_main_window(NULL);
561eba2a 283 }
284}
285
abe346a3 286
287/* move_*_viewer functions move the selected view up/down in
288 * the current tab
289 */
290
561eba2a 291void move_up_viewer(GtkWidget * widget, gpointer user_data)
292{
bca3b81f 293 MainWindow * mw = get_window_data_struct(widget);
294 if(!mw->current_tab) return;
daecc161 295 gtk_multi_vpaned_widget_move_up(mw->current_tab->multi_vpaned);
561eba2a 296}
297
298void move_down_viewer(GtkWidget * widget, gpointer user_data)
299{
bca3b81f 300 MainWindow * mw = get_window_data_struct(widget);
301 if(!mw->current_tab) return;
daecc161 302 gtk_multi_vpaned_widget_move_down(mw->current_tab->multi_vpaned);
561eba2a 303}
304
abe346a3 305
306/* delete_viewer deletes the selected viewer in the current tab
307 */
308
561eba2a 309void delete_viewer(GtkWidget * widget, gpointer user_data)
310{
bca3b81f 311 MainWindow * mw = get_window_data_struct(widget);
312 if(!mw->current_tab) return;
daecc161 313 gtk_multi_vpaned_widget_delete(mw->current_tab->multi_vpaned);
561eba2a 314}
315
abe346a3 316
317/* open_traceset will open a traceset saved in a file
318 * Right now, it is not finished yet, (not working)
a43d67ba 319 * FIXME
abe346a3 320 */
321
561eba2a 322void open_traceset(GtkWidget * widget, gpointer user_data)
323{
2176f952 324 char ** dir;
325 gint id;
326 LttvTraceset * traceset;
bca3b81f 327 MainWindow * mw_data = get_window_data_struct(widget);
68b48a45 328 GtkFileSelection * file_selector =
2176f952 329 (GtkFileSelection *)gtk_file_selection_new("Select a traceset");
330
68b48a45 331 gtk_file_selection_hide_fileop_buttons(file_selector);
c64c7ea1 332
68b48a45 333 id = gtk_dialog_run(GTK_DIALOG(file_selector));
2176f952 334 switch(id){
335 case GTK_RESPONSE_ACCEPT:
336 case GTK_RESPONSE_OK:
68b48a45 337 dir = gtk_file_selection_get_selections (file_selector);
2176f952 338 traceset = lttv_traceset_load(dir[0]);
339 g_printf("Open a trace set %s\n", dir[0]);
340 //Not finished yet
341 g_strfreev(dir);
342 case GTK_RESPONSE_REJECT:
343 case GTK_RESPONSE_CANCEL:
344 default:
68b48a45 345 gtk_widget_destroy((GtkWidget*)file_selector);
2176f952 346 break;
347 }
c64c7ea1 348
561eba2a 349}
350
abe346a3 351
352/* get_max_event_number returns the event number limit used by
353 * lttv_process_traceset(LttvTracesetContext, endTime, maxNumEvents)
354 * each viewer can set the limit
355 */
356
a8c0f09d 357unsigned get_max_event_number(MainWindow * mw_data)
202f6c8f 358{
a8c0f09d 359 unsigned nb = 0, *size;
360 GtkWidget * w;
361
362 w = gtk_multi_vpaned_get_first_widget(mw_data->current_tab->multi_vpaned);
363 while(w){
364 size = (unsigned*)g_object_get_data(G_OBJECT(w), MAX_NUMBER_EVENT);
365 if(size == NULL){
366 nb = G_MAXULONG;
367 break;
368 }else{
369 if(nb < *size)
370 nb = *size;
371 }
372 w = gtk_multi_vpaned_get_next_widget(mw_data->current_tab->multi_vpaned);
373 }
374 return nb;
375}
376
abe346a3 377
501e4e70 378/* lttvwindow_process_pending_requests
379 *
380 * This internal function gets called by g_idle, taking care of the pending
381 * requests. It is responsible for concatenation of time intervals and position
382 * requests. It does it with the following algorithm organizing process traceset
383 * calls. Here is the detailed description of the way it works :
384 *
385 * - Events Requests Servicing Algorithm
386 *
387 * Data structures necessary :
388 *
389 * List of requests added to context : list_in
390 * List of requests not added to context : list_out
391 *
392 * Initial state :
393 *
394 * list_in : empty
395 * list_out : many events requests
396 *
397 * FIXME : insert rest of algorithm here
398 *
abe346a3 399 */
400
a43d67ba 401
501e4e70 402gboolean lttvwindow_process_pending_requests(Tab *tab)
a8c0f09d 403{
404 unsigned max_nb_events;
405 GdkWindow * win;
406 GdkCursor * new;
407 GtkWidget* widget;
a43d67ba 408 LttvTracesetContext *tsc;
501e4e70 409 LttvTracefileContext *tfc;
410 GSList *events_requests = tab->events_requests;
411 GSList *list_out = events_requests;
412 GSList *list_in = NULL;
413 LttTime end_time;
414 guint end_nb_events;
415 LttvTracesetContextPosition *end_position;
416
a43d67ba 417
418 /* Current tab check : if no current tab is present, no hooks to call. */
501e4e70 419 /* (Xang Xiu) It makes the expose works.. MD:? */
420 if(tab == NULL)
421 return FALSE;
a43d67ba 422
501e4e70 423 /* There is no events requests pending : we should never have been called! */
424 g_assert(g_slist_length(events_requests) != 0);
a43d67ba 425
501e4e70 426 tsc = LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context);
a8c0f09d 427
abe346a3 428 //set the cursor to be X shape, indicating that the computer is busy in doing its job
a8c0f09d 429 new = gdk_cursor_new(GDK_X_CURSOR);
501e4e70 430 widget = lookup_widget(tab->mw_data->mwindow, "MToolbar1");
a8c0f09d 431 win = gtk_widget_get_parent_window(widget);
432 gdk_window_set_cursor(win, new);
433 gdk_cursor_unref(new);
434 gdk_window_stick(win);
435 gdk_window_unstick(win);
a43d67ba 436
501e4e70 437 g_debug("SIZE events req len : %d", g_slist_length(events_request));
438
439 /* Events processing algorithm implementation */
440 /* A. Servicing loop */
441 while( (g_slist_length(list_in) != 0 || g_slist_length(list_out) != 0)
442 && !gtk_events_pending() ) {
443
444 /* 1. If list_in is empty (need a seek) */
445 if( g_slist_length(list_in) == 0 ) {
a43d67ba 446
501e4e70 447 /* list in is empty, need a seek */
448 {
449 /* 1.1 Add requests to list_in */
450 GArray *ltime = g_array_new(FALSE, FALSE, sizeof(guint));
451 GArray *lpos = g_array_new(FALSE, FALSE, sizeof(guint));
452 guint i;
453
454 /* 1.1.1 Find all time requests with the lowest start time in list_out
455 * (ltime)
456 */
457 if(list_out->len > 0)
458 g_array_append_val(ltime, 0);
459 for(i=1;i<list_out->len;i++) {
460 /* Find all time requests with the lowest start time in list_out */
461 guint index_ltime = g_array_index(ltime, guint, 0);
462 EventsRequest *event_request_ltime = &g_array_index(list_out,
463 EventsRequest,
464 index_ltime);
465 EventsRequest *event_request_list_out = &g_array_index(list_out,
466 EventsRequest,
467 i);
468 int comp;
469 comp = ltt_time_compare(event_request_ltime->start_time,
470 event_request_list_out->start_time);
471 if(comp == 0)
472 g_array_append_val(ltime, i);
473 else if(comp > 0) {
474 /* Remove all elements from ltime, and add current */
475 g_array_remove_range(ltime, 0, ltime->len);
476 g_array_append_val(ltime, i);
477
478 }
479 }
480
481 /* 1.1.2 Find all position requests with the lowest position in list_out
482 * (lpos)
483 */
484 if(list_out->len > 0)
485 g_array_append(lpos, 0);
486 for(i=1;i<list_out->len;i++) {
487 /* Find all position requests with the lowest position in list_out */
488 guint index_lpos = g_array_index(lpos, guint, 0);
489 EventsRequest *event_request_lpos = &g_array_index(lpos,
490 EventsRequest,
491 index_lpos);
492 EventsRequest *event_request_list_out = &g_array_index(list_out,
493 EventsRequest,
494 i);
495 int comp;
496 comp = lttv_traceset_context_pos_pos_compare
497 (event_request_pos->start_position,
498 event_request_list_out->start_position);
499 if(comp == 0)
500 g_array_append_val(lpos, i);
501 else if(comp > 0) {
502 /* Remove all elements from lpos, and add current */
503 g_array_remove_range(lpos, 0, lpos->len);
504 g_array_append_val(lpos, i);
505 }
506 }
507
508 /* 1.1.3 If lpos.start time < ltime */
509 {
510 guint i;
511 EventsRequest *event_request_lpos = &g_array_index(lpos, 0);
512 EventsRequest *event_request_ltime = &g_array_index(ltime,0);
513 LttTime lpos_start_time =
514 lttv_traceset_context_position_get_time(event_request_lpos);
515
516 if(ltt_time_compare(lpos_start_time,
517 event_request_ltime->start_time)<0) {
518 /* Add lpos to list_in, remove them from list_out */
519
520 for(i=0;i<lpos->len;i++) {
521 /* Add to list_in */
522 guint index_lpos = g_array_index(lpos, guint, i);
523 EventsRequest *event_request_lpos =
524 &g_array_index(lpos,index_lpos);
525
526 g_array_append_val(list_in, *event_request_lpos);
527
528 }
529
530 for(i=0;i<lpos->len;i++) {
531 /* Remove from list_out */
532 guint index_lpos = g_array_index(lpos, guint, i);
533
534 g_array_remove_index_fast(list_out, index_lpos);
535 }
536
537 } else {
538 /* 1.1.4 (lpos.start time >= ltime) */
539 /* Add ltime to list_in, remove them from list_out */
540
541 for(i=0;i<ltime->len;i++) {
542 /* Add to list_in */
543 guint index_ltime = g_array_index(ltime, guint, i);
544 EventsRequest *event_request_ltime =
545 &g_array_index(ltime,index_ltime);
546
547 g_array_append_val(list_in, *event_request_ltime);
548 }
549
550 for(i=0;i<ltime->len;i++) {
551 /* Remove from list_out */
552 guint index_ltime = g_array_index(ltime, guint, i);
553
554 g_array_remove_index_fast(list_out, index_ltime);
555 }
556 }
557 }
558 g_array_free(lpos, TRUE);
559 g_array_free(ltime, TRUE);
560 }
a43d67ba 561
501e4e70 562 /* 1.2 Seek */
563 {
564 EventsRequest *events_request = &g_array_index(list_in,
565 EventsRequest,
566 0);
567
568 /* 1.2.1 If first request in list_in is a time request */
569 if(events_request->start_position == NULL) {
570 /* 1.2.1.1 Seek to that time */
571 lttv_process_traceset_seek_time(tsc, events_request->start_time);
572 } else {
573 /* Else, the first request in list_in is a position request */
574 /* 1.2.2.1 Seek to that position */
575 lttv_process_traceset_seek_position(tsc, events_request->start_position);
576 }
577 }
a43d67ba 578
501e4e70 579 /* 1.3 Call begin for all list_in members */
580 {
581 guint i;
582
583 for(i=0;i<list_in->len;i++) {
584 EventsRequest *events_request = &g_array_index(list_in,
585 EventsRequest,
586 i);
587 /* (1.3.1 begin hooks called) */
588 /* (1.3.2 middle hooks added) */
589 lttv_process_traceset_begin(tsc, events_request->before_traceset,
590 events_request->before_trace,
591 events_request->before_tracefile,
592 events_request->event,
593 events_request->event_by_id);
594 }
595 }
596 } else {
597 /* 2. Else, list_in is not empty, we continue a read */
598 guint i;
599 tfc = lttv_traceset_context_get_current_tfc(tsc);
600
601 /* 2.1 For each req of list_out */
602 for(i=0;i<list_out->len;i++) {
603 EventsRequest *events_request = &g_array_index(list_out,
604 EventsRequest,
605 i);
606 if(ltt_time_compare(events_request->start_time,
607 tfc->timestamp) == 0) {
608 /* if req.start time == current context time */
609 /* Call Begin */
610 lttv_process_traceset_begin(tsc, events_request->before_traceset,
611 events_request->before_trace,
612 events_request->before_tracefile,
613 events_request->event,
614 events_request->event_by_id);
615
616
617 /* Add to list_in */
618 g_array_append_val(list_in, *events_request);
619 } else if(events_request->start_position != NULL &&
620 lttv_traceset_context_ctx_pos_compare(tsc,
621 events_request->start_position) == 0) {
622 /* if req.start position == current position */
623 /* Call Begin */
624 lttv_process_traceset_begin(tsc, events_request->before_traceset,
625 events_request->before_trace,
626 events_request->before_tracefile,
627 events_request->event,
628 events_request->event_by_id);
629
202f6c8f 630
501e4e70 631 /* Add to list_in */
632 g_array_append_val(list_in, *events_request);
a8c0f09d 633
501e4e70 634 }
635
636 }
a43d67ba 637
501e4e70 638
639 for(i=0;i<list_out->len;i++) {
640 EventsRequest *events_request = &g_array_index(list_out,
641 EventsRequest,
642 i);
643 if(ltt_time_compare(events_request->start_time,
644 tfc->timestamp) == 0) {
645 /* if req.start time == current context time */
646 /* Remove from list_out */
647 g_array_remove_index_fast(list_out, i);
648 } else if(events_request->start_position != NULL &&
649 lttv_traceset_context_ctx_pos_compare(tsc,
650 events_request->start_position) == 0) {
651 /* if req.start position == current position */
652 /* Remove from list_out */
653 g_array_remove_index_fast(list_out, i);
654
655 }
656 }
657 }
658
659
660
661 /* 3. Find end criterions */
a43d67ba 662 {
501e4e70 663 /* 3.1 End time */
664 guint i;
665
666 /* 3.1.1 Find lowest end time in list_in */
667 end_time = g_array_index(list_in, EventsRequest,0).end_time;
668
669 for(i=1;i<list_in->len;i++) {
670 EventsRequest *events_request = &g_array_index(list_in,
671 EventsRequest,
672 i);
673 if(ltt_time_compare(events_request->end_time,
674 end_time) < 0)
675 end_time = events_request->end_time;
676 }
677
678 /* 3.1.2 Find lowest start time in list_out */
679 for(i=0;i<list_out->len;i++) {
680 EventsRequest *events_request = &g_array_index(list_out,
681 EventsRequest,
682 i);
683 if(ltt_time_compare(events_request->start_time,
684 end_time) < 0)
685 end_time = events_request->start_time;
686 }
a43d67ba 687 }
501e4e70 688
8f2872f4 689 {
501e4e70 690 /* 3.2 Number of events */
691
692 /* 3.2.1 Find lowest number of events in list_in */
693 guint i;
8f2872f4 694
501e4e70 695 end_nb_events = g_array_index(list_in, EventsRequest, 0).num_events;
696
697 for(i=1;i<list_in->len;i++) {
698 EventsRequest *events_request = &g_array_index(list_in,
699 EventsRequest,
700 i);
701 if(events_request->num_events < end_nb_events)
702 end_nb_events = events_request->num_events;
8f2872f4 703 }
501e4e70 704 }
705
706 {
707 /* 3.3 End position */
708
709 /* 3.3.1 Find lowest end position in list_in */
710 guint i;
711
712 end_position = g_array_index(list_in, EventsRequest, 0).end_position;
713
714 for(i=1;i<list_in->len;i++) {
715 EventsRequest *events_request = &g_array_index(list_in,
716 EventsRequest,
717 i);
718
719 if(lttv_traceset_context_pos_pos_compare(events_request->end_position,
720 end_position) <0)
721 end_position = events_request->end_position;
722 }
723 }
724
725 {
726 /* 3.3.2 Find lowest start position in list_out */
727 guint i;
728
729 for(i=0;i<list_out->len;i++) {
730 EventsRequest *events_request = &g_array_index(list_out,
731 EventsRequest,
732 i);
733
734 if(lttv_traceset_context_pos_pos_compare(events_request->end_position,
735 end_position) <0)
736 end_position = events_request->end_position;
737 }
738 }
739
740
741 }
742
743 /* B. When interrupted */
744
745 /* 1. for each request in list_in */
746 {
747 GSList *iter = list_in;
748
749 while(iter != NULL) {
750
751 gboolean remove = FALSE;
752 gboolean free_data = FALSE;
753 EventsRequest events_request = (EventsRequest *)iter->data;
754
755 /* 1.1. Use current postition as start position */
756 g_free(events_request->start_position);
757 lttv_traceset_context_position_save(tsc, events_request->start_position);
758
759 /* 1.2. Remove start time */
760 events_request->start_time = { G_MAXUINT, G_MAXUINT };
761
762 /* 1.3. Call after_traceset */
763 /* 1.4. Remove event hooks */
764 lttv_process_traceset_end(tsc, events_request->after_traceset,
765 events_request->after_trace,
766 events_request->after_tracefile,
767 events_request->event,
768 events_request->event_by_id);
769
770 /* 1.5. Put it back in list_out */
771 remove = TRUE;
772 free_data = FALSE;
773 list_out = g_slist_append(list_out, events_request);
774
775
776 /* Go to next */
777 if(remove)
8f2872f4 778 {
501e4e70 779 GSList *remove_iter = iter;
780
781 iter = g_slist_next(iter);
782 if(free_data) g_free(remove_iter->data);
783 list_in = g_slist_remove_link(list_in, remove_iter);
784 } else { // not remove
785 iter = g_slist_next(iter);
8f2872f4 786 }
787 }
a43d67ba 788
501e4e70 789
790 }
791
792 /* 2. Save current state into saved_state. */
793 {
794 /* 2.1 Free old saved state. */
795 //FIXME : free will need to be able to remove state for a traceset
796 //with changed traces!
797 //FIXME lttv_state_state_saved_free( , tab->interrupted_state);
798
799 /* 2.2 save current state. */
800 //FIXME
801 //lttv_state_save( ,tab->interrupted_state);
802
a43d67ba 803 }
a43d67ba 804
abe346a3 805 //set the cursor back to normal
a8c0f09d 806 gdk_window_set_cursor(win, NULL);
501e4e70 807
808
809
810 if( g_slist_length(list_in) == 0 && g_slist_length(list_out) == 0 ) {
811 /* Put tab's request pending flag back to normal */
812 tab->time_request_pending = FALSE;
813 return FALSE; /* Remove the idle function */
814 }
815
816 return TRUE; /* Leave the idle function */
817
202f6c8f 818}
819
501e4e70 820#ifdef TESTCODE
821 GSList *iter = list_in;
822
823 /* 1. for each request in list_in */
824 while(iter != NULL) {
825
826 gboolean remove = FALSE;
827 gboolean free_data = FALSE;
828
829
830
831 /* Go to next */
832 if(remove)
833 {
834 GSList *remove_iter = iter;
835
836 iter = g_slist_next(iter);
837 if(free_data) g_free(remove_iter->data);
838 list_in = g_slist_remove_link(list_in, remove_iter);
839 } else { // not remove
840 iter = g_slist_next(iter);
841 }
842 }
843#endif //TESTCODE
844
845
abe346a3 846
847/* add_trace_into_traceset_selector, each instance of a viewer has an associated
848 * selector (filter), when a trace is added into traceset, the selector should
849 * reflect the change. The function is used to update the selector
850 */
851
49bf71b5 852void add_trace_into_traceset_selector(GtkMultiVPaned * paned, LttTrace * t)
853{
ed3b99b6 854 int j, k, m, nb_tracefile, nb_control, nb_per_cpu, nb_facility, nb_event;
49bf71b5 855 LttvTracesetSelector * s;
856 LttvTraceSelector * trace;
857 LttvTracefileSelector * tracefile;
ed3b99b6 858 LttvEventtypeSelector * eventtype;
49bf71b5 859 LttTracefile * tf;
860 GtkWidget * w;
ed3b99b6 861 LttFacility * fac;
862 LttEventType * et;
49bf71b5 863
864 w = gtk_multi_vpaned_get_first_widget(paned);
865 while(w){
866 s = g_object_get_data(G_OBJECT(w), "Traceset_Selector");
49bf71b5 867
abe346a3 868 if(s){
869 trace = lttv_trace_selector_new(t);
870 lttv_traceset_selector_trace_add(s, trace);
871
872 nb_facility = ltt_trace_facility_number(t);
873 for(k=0;k<nb_facility;k++){
874 fac = ltt_trace_facility_get(t,k);
875 nb_event = (int) ltt_facility_eventtype_number(fac);
876 for(m=0;m<nb_event;m++){
877 et = ltt_facility_eventtype_get(fac,m);
878 eventtype = lttv_eventtype_selector_new(et);
879 lttv_trace_selector_eventtype_add(trace, eventtype);
880 }
881 }
882
883 nb_control = ltt_trace_control_tracefile_number(t);
884 nb_per_cpu = ltt_trace_per_cpu_tracefile_number(t);
885 nb_tracefile = nb_control + nb_per_cpu;
886
887 for(j = 0 ; j < nb_tracefile ; j++) {
888 if(j < nb_control)
889 tf = ltt_trace_control_tracefile_get(t, j);
890 else
891 tf = ltt_trace_per_cpu_tracefile_get(t, j - nb_control);
892 tracefile = lttv_tracefile_selector_new(tf);
893 lttv_trace_selector_tracefile_add(trace, tracefile);
894 lttv_eventtype_selector_copy(trace, tracefile);
895 }
896 }else g_warning("Module does not support filtering\n");
49bf71b5 897
898 w = gtk_multi_vpaned_get_next_widget(paned);
899 }
900}
901
abe346a3 902
903/* add_trace adds a trace into the current traceset. It first displays a
904 * directory selection dialogue to let user choose a trace, then recreates
905 * tracset_context, and redraws all the viewer of the current tab
906 */
907
561eba2a 908void add_trace(GtkWidget * widget, gpointer user_data)
909{
2176f952 910 LttTrace *trace;
911 LttvTrace * trace_v;
912 LttvTraceset * traceset;
94dcfb9e 913 const char * dir;
2176f952 914 gint id;
a43d67ba 915 gint i;
bca3b81f 916 MainWindow * mw_data = get_window_data_struct(widget);
68b48a45 917 GtkDirSelection * file_selector = (GtkDirSelection *)gtk_dir_selection_new("Select a trace");
918 gtk_dir_selection_hide_fileop_buttons(file_selector);
3658a338 919 if(remember_trace_dir[0] != '\0')
920 gtk_dir_selection_set_filename(file_selector, remember_trace_dir);
2176f952 921
68b48a45 922 id = gtk_dialog_run(GTK_DIALOG(file_selector));
2176f952 923 switch(id){
924 case GTK_RESPONSE_ACCEPT:
925 case GTK_RESPONSE_OK:
68b48a45 926 dir = gtk_dir_selection_get_dir (file_selector);
3658a338 927 strncpy(remember_trace_dir, dir, PATH_LENGTH);
a43d67ba 928 if(!dir || strlen(dir) == 0){
929 gtk_widget_destroy((GtkWidget*)file_selector);
930 break;
284675e3 931 }
2176f952 932 trace = ltt_trace_open(dir);
933 if(trace == NULL) g_critical("cannot open trace %s", dir);
934 trace_v = lttv_trace_new(trace);
716e4367 935 traceset = mw_data->current_tab->traceset_info->traceset;
c2619a30 936
a43d67ba 937 //Keep a reference to the traces so they are not freed.
938 for(i=0; i<lttv_traceset_number(traceset); i++)
939 {
940 LttvTrace * trace = lttv_traceset_get(traceset, i);
941 lttv_trace_ref(trace);
942 }
943
944 //remove state update hooks
945 lttv_state_remove_event_hooks(
946 (LttvTracesetState*)mw_data->current_tab->traceset_info->traceset_context);
947
948 lttv_context_fini(LTTV_TRACESET_CONTEXT(
949 mw_data->current_tab->traceset_info->traceset_context));
950 g_object_unref(mw_data->current_tab->traceset_info->traceset_context);
951
c2619a30 952
2176f952 953 lttv_traceset_add(traceset, trace_v);
a43d67ba 954
955 /* Create new context */
716e4367 956 mw_data->current_tab->traceset_info->traceset_context =
c2619a30 957 g_object_new(LTTV_TRACESET_STATS_TYPE, NULL);
2176f952 958 lttv_context_init(
c2619a30 959 LTTV_TRACESET_CONTEXT(mw_data->current_tab->traceset_info->
960 traceset_context),
961 traceset);
784705cc 962 //add state update hooks
963 lttv_state_add_event_hooks(
964 (LttvTracesetState*)mw_data->current_tab->traceset_info->traceset_context);
a43d67ba 965 //Remove local reference to the traces.
966 for(i=0; i<lttv_traceset_number(traceset); i++)
c2619a30 967 {
a43d67ba 968 LttvTrace * trace = lttv_traceset_get(traceset, i);
969 lttv_trace_unref(trace);
c2619a30 970 }
971
972
49bf71b5 973 add_trace_into_traceset_selector(mw_data->current_tab->multi_vpaned, trace);
974
975 gtk_widget_destroy((GtkWidget*)file_selector);
976
977 //update current tab
a43d67ba 978 //update_traceset(mw_data);
21e8c385 979
297f7a48 980 //get_traceset_time_span(mw_data,LTTV_TRACESET_CONTEXT(mw_data->current_tab->traceset_info->traceset_context)->Time_Span);
a43d67ba 981 if(
982 lttv_traceset_number(mw_data->current_tab->traceset_info->traceset) == 1
983 || ltt_time_compare(mw_data->current_tab->current_time,
984 LTTV_TRACESET_CONTEXT(mw_data->current_tab->traceset_info->
501e4e70 985 traceset_context)->time_span.start_time)<0)
a43d67ba 986 {
987 /* Set initial time if this is the first trace in the traceset */
988 mw_data->current_tab->current_time =
989 LTTV_TRACESET_CONTEXT(mw_data->current_tab->traceset_info->
501e4e70 990 traceset_context)->time_span.start_time;
a43d67ba 991 mw_data->current_tab->time_window.start_time =
992 mw_data->current_tab->current_time;
993 mw_data->current_tab->time_window.time_width.tv_sec =
994 DEFAULT_TIME_WIDTH_S;
995 mw_data->current_tab->time_window.time_width.tv_nsec = 0;
21e8c385 996 }
997
a43d67ba 998 /* Call the updatetraceset hooks */
999
1000 SetTraceset(mw_data, (gpointer)traceset);
1001 // in expose now call_pending_read_hooks(mw_data);
1002
1003 //lttvwindow_report_current_time(mw_data,&(mw_data->current_tab->current_time));
49bf71b5 1004 break;
2176f952 1005 case GTK_RESPONSE_REJECT:
1006 case GTK_RESPONSE_CANCEL:
1007 default:
68b48a45 1008 gtk_widget_destroy((GtkWidget*)file_selector);
2176f952 1009 break;
1010 }
49bf71b5 1011}
1012
abe346a3 1013
1014/* remove_trace_into_traceset_selector, each instance of a viewer has an associated
1015 * selector (filter), when a trace is remove from traceset, the selector should
1016 * reflect the change. The function is used to update the selector
1017 */
1018
49bf71b5 1019void remove_trace_from_traceset_selector(GtkMultiVPaned * paned, unsigned i)
1020{
1021 LttvTracesetSelector * s;
1022 LttvTraceSelector * t;
1023 GtkWidget * w;
1024
1025 w = gtk_multi_vpaned_get_first_widget(paned);
1026 while(w){
1027 s = g_object_get_data(G_OBJECT(w), "Traceset_Selector");
abe346a3 1028 if(s){
1029 t = lttv_traceset_selector_trace_get(s,i);
1030 lttv_traceset_selector_trace_remove(s, i);
1031 lttv_trace_selector_destroy(t);
1032 }g_warning("Module dose not support filtering\n");
49bf71b5 1033 w = gtk_multi_vpaned_get_next_widget(paned);
1034 }
561eba2a 1035}
1036
abe346a3 1037
1038/* remove_trace removes a trace from the current traceset if all viewers in
1039 * the current tab are not interested in the trace. It first displays a
1040 * dialogue, which shows all traces in the current traceset, to let user choose
1041 * a trace, then it checks if all viewers unselect the trace, if it is true,
1042 * it will remove the trace, recreate the traceset_contex,
1043 * and redraws all the viewer of the current tab. If there is on trace in the
1044 * current traceset, it will delete all viewers of the current tab
1045 */
1046
561eba2a 1047void remove_trace(GtkWidget * widget, gpointer user_data)
1048{
2176f952 1049 LttTrace *trace;
1050 LttvTrace * trace_v;
1051 LttvTraceset * traceset;
a43d67ba 1052 gint i, j, nb_trace;
2176f952 1053 char ** name, *remove_trace_name;
bca3b81f 1054 MainWindow * mw_data = get_window_data_struct(widget);
49bf71b5 1055 LttvTracesetSelector * s;
1056 LttvTraceSelector * t;
1057 GtkWidget * w;
1058 gboolean selected;
2176f952 1059
716e4367 1060 nb_trace =lttv_traceset_number(mw_data->current_tab->traceset_info->traceset);
2176f952 1061 name = g_new(char*,nb_trace);
1062 for(i = 0; i < nb_trace; i++){
716e4367 1063 trace_v = lttv_traceset_get(mw_data->current_tab->
1064 traceset_info->traceset, i);
2176f952 1065 trace = lttv_trace(trace_v);
a5dcde2f 1066 name[i] = ltt_trace_name(trace);
2176f952 1067 }
1068
1069 remove_trace_name = get_remove_trace(name, nb_trace);
1070
1071 if(remove_trace_name){
1072 for(i=0; i<nb_trace; i++){
1073 if(strcmp(remove_trace_name,name[i]) == 0){
49bf71b5 1074 //unselect the trace from the current viewer
1075 w = gtk_multi_vpaned_get_widget(mw_data->current_tab->multi_vpaned);
9f0a7b47 1076 if(w){
49bf71b5 1077 s = g_object_get_data(G_OBJECT(w), "Traceset_Selector");
abe346a3 1078 if(s){
1079 t = lttv_traceset_selector_trace_get(s,i);
1080 lttv_trace_selector_set_selected(t, FALSE);
1081 }
9f0a7b47 1082
1083 //check if other viewers select the trace
1084 w = gtk_multi_vpaned_get_first_widget(mw_data->current_tab->multi_vpaned);
1085 while(w){
1086 s = g_object_get_data(G_OBJECT(w), "Traceset_Selector");
abe346a3 1087 if(s){
1088 t = lttv_traceset_selector_trace_get(s,i);
1089 selected = lttv_trace_selector_get_selected(t);
1090 if(selected)break;
1091 }
9f0a7b47 1092 w = gtk_multi_vpaned_get_next_widget(mw_data->current_tab->multi_vpaned);
1093 }
1094 }else selected = FALSE;
49bf71b5 1095
1096 //if no viewer selects the trace, remove it
1097 if(!selected){
1098 remove_trace_from_traceset_selector(mw_data->current_tab->multi_vpaned, i);
1099
1100 traceset = mw_data->current_tab->traceset_info->traceset;
1101 trace_v = lttv_traceset_get(traceset, i);
1102 if(lttv_trace_get_ref_number(trace_v) <= 1)
1103 ltt_trace_close(lttv_trace(trace_v));
a43d67ba 1104
1105 //Keep a reference to the traces so they are not freed.
1106 for(j=0; j<lttv_traceset_number(traceset); j++)
1107 {
1108 LttvTrace * trace = lttv_traceset_get(traceset, j);
1109 lttv_trace_ref(trace);
1110 }
1111
1112 //remove state update hooks
1113 lttv_state_remove_event_hooks(
1114 (LttvTracesetState*)mw_data->current_tab->traceset_info->traceset_context);
1115 lttv_context_fini(LTTV_TRACESET_CONTEXT(mw_data->current_tab->traceset_info->traceset_context));
1116 g_object_unref(mw_data->current_tab->traceset_info->traceset_context);
1117
c2619a30 1118
49bf71b5 1119 lttv_traceset_remove(traceset, i);
a43d67ba 1120 lttv_trace_unref(trace_v); // Remove local reference
912be9a5 1121 if(!lttv_trace_get_ref_number(trace_v))
1122 lttv_trace_destroy(trace_v);
a43d67ba 1123
49bf71b5 1124 mw_data->current_tab->traceset_info->traceset_context =
1125 g_object_new(LTTV_TRACESET_STATS_TYPE, NULL);
a43d67ba 1126 lttv_context_init(
49bf71b5 1127 LTTV_TRACESET_CONTEXT(mw_data->current_tab->
1128 traceset_info->traceset_context),traceset);
784705cc 1129 //add state update hooks
a43d67ba 1130 lttv_state_add_event_hooks(
784705cc 1131 (LttvTracesetState*)mw_data->current_tab->traceset_info->traceset_context);
c2619a30 1132
a43d67ba 1133 //Remove local reference to the traces.
1134 for(j=0; j<lttv_traceset_number(traceset); j++)
1135 {
1136 LttvTrace * trace = lttv_traceset_get(traceset, j);
1137 lttv_trace_unref(trace);
1138 }
1139
c2619a30 1140
49bf71b5 1141 //update current tab
a43d67ba 1142 //update_traceset(mw_data);
912be9a5 1143 if(nb_trace > 1){
a43d67ba 1144
1145 SetTraceset(mw_data, (gpointer)traceset);
1146 // in expose now call_pending_read_hooks(mw_data);
1147
1148 //lttvwindow_report_current_time(mw_data,&(mw_data->current_tab->current_time));
912be9a5 1149 }else{
1150 if(mw_data->current_tab){
1151 while(mw_data->current_tab->multi_vpaned->num_children){
1152 gtk_multi_vpaned_widget_delete(mw_data->current_tab->multi_vpaned);
1153 }
1154 }
1155 }
2176f952 1156 }
2176f952 1157 break;
1158 }
1159 }
1160 }
1161
1162 g_free(name);
561eba2a 1163}
1164
abe346a3 1165
1166/* save will save the traceset to a file
a43d67ba 1167 * Not implemented yet FIXME
abe346a3 1168 */
1169
561eba2a 1170void save(GtkWidget * widget, gpointer user_data)
1171{
1172 g_printf("Save\n");
1173}
1174
1175void save_as(GtkWidget * widget, gpointer user_data)
1176{
1177 g_printf("Save as\n");
1178}
1179
abe346a3 1180
1181/* zoom will change the time_window of all the viewers of the
1182 * current tab, and redisplay them. The main functionality is to
1183 * determine the new time_window of the current tab
1184 */
1185
1f1ae829 1186void zoom(GtkWidget * widget, double size)
1187{
1188 TimeInterval *time_span;
a43d67ba 1189 TimeWindow new_time_window;
1190 LttTime current_time, time_delta, time_s, time_e, time_tmp;
1f1ae829 1191 MainWindow * mw_data = get_window_data_struct(widget);
501e4e70 1192 Tab *tab = mw_data->current_tab;
1193 LttvTracesetContext *tsc =
1194 LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context);
1f1ae829 1195
fda16332 1196 if(size == 1) return;
1197
501e4e70 1198 time_span = &tsc->time_span;
1199 new_time_window = tab->time_window;
1200 current_time = tab->current_time;
1f1ae829 1201
501e4e70 1202 time_delta = ltt_time_sub(time_span->end_time,time_span->start_time);
1f1ae829 1203 if(size == 0){
501e4e70 1204 new_time_window.start_time = time_span->start_time;
a43d67ba 1205 new_time_window.time_width = time_delta;
1f1ae829 1206 }else{
a43d67ba 1207 new_time_window.time_width = ltt_time_div(new_time_window.time_width, size);
1208 if(ltt_time_compare(new_time_window.time_width,time_delta) > 0)
1209 { /* Case where zoom out is bigger than trace length */
501e4e70 1210 new_time_window.start_time = time_span->start_time;
a43d67ba 1211 new_time_window.time_width = time_delta;
a8c0f09d 1212 }
a43d67ba 1213 else
1214 {
1215 /* Center the image on the current time */
1216 g_critical("update is HERE");
1217 new_time_window.start_time =
1218 ltt_time_sub(current_time, ltt_time_div(new_time_window.time_width, 2.0));
1219 /* If on borders, don't fall off */
501e4e70 1220 if(ltt_time_compare(new_time_window.start_time, time_span->start_time) <0)
a43d67ba 1221 {
501e4e70 1222 new_time_window.start_time = time_span->start_time;
a43d67ba 1223 }
1224 else
1225 {
1226 if(ltt_time_compare(
1227 ltt_time_add(new_time_window.start_time, new_time_window.time_width),
501e4e70 1228 time_span->end_time) > 0)
a43d67ba 1229 {
1230 new_time_window.start_time =
501e4e70 1231 ltt_time_sub(time_span->end_time, new_time_window.time_width);
a43d67ba 1232 }
1233 }
1234
1f1ae829 1235 }
a43d67ba 1236
1237
1238
1239 //time_tmp = ltt_time_div(new_time_window.time_width, 2);
1240 //if(ltt_time_compare(current_time, time_tmp) < 0){
1241 // time_s = time_span->startTime;
1242 //} else {
1243 // time_s = ltt_time_sub(current_time,time_tmp);
1244 //}
1245 //time_e = ltt_time_add(current_time,time_tmp);
1246 //if(ltt_time_compare(time_span->startTime, time_s) > 0){
1247 // time_s = time_span->startTime;
1248 //}else if(ltt_time_compare(time_span->endTime, time_e) < 0){
1249 // time_e = time_span->endTime;
1250 // time_s = ltt_time_sub(time_e,new_time_window.time_width);
1251 //}
1252 //new_time_window.start_time = time_s;
1f1ae829 1253 }
a43d67ba 1254
1255 //lttvwindow_report_time_window(mw_data, &new_time_window);
1256 //call_pending_read_hooks(mw_data);
1257
1258 //lttvwindow_report_current_time(mw_data,&(mw_data->current_tab->current_time));
501e4e70 1259 set_time_window(tab, &new_time_window);
a43d67ba 1260 // in expose now call_pending_read_hooks(mw_data);
501e4e70 1261 gtk_multi_vpaned_set_adjust(tab->multi_vpaned, &new_time_window, FALSE);
1f1ae829 1262}
1263
561eba2a 1264void zoom_in(GtkWidget * widget, gpointer user_data)
1265{
1f1ae829 1266 zoom(widget, 2);
561eba2a 1267}
1268
1269void zoom_out(GtkWidget * widget, gpointer user_data)
1270{
1f1ae829 1271 zoom(widget, 0.5);
561eba2a 1272}
1273
1274void zoom_extended(GtkWidget * widget, gpointer user_data)
1275{
1f1ae829 1276 zoom(widget, 0);
561eba2a 1277}
1278
1279void go_to_time(GtkWidget * widget, gpointer user_data)
1280{
1281 g_printf("Go to time\n");
1282}
1283
1284void show_time_frame(GtkWidget * widget, gpointer user_data)
1285{
1286 g_printf("Show time frame\n");
1287}
1288
1289
1290/* callback function */
1291
1292void
1293on_empty_traceset_activate (GtkMenuItem *menuitem,
1294 gpointer user_data)
1295{
68b48a45 1296 create_new_window((GtkWidget*)menuitem, user_data, FALSE);
561eba2a 1297}
1298
1299
1300void
1301on_clone_traceset_activate (GtkMenuItem *menuitem,
1302 gpointer user_data)
1303{
68b48a45 1304 create_new_window((GtkWidget*)menuitem, user_data, TRUE);
561eba2a 1305}
1306
abe346a3 1307
1308/* create_new_tab calls create_tab to construct a new tab in the main window
1309 */
1310
2901f314 1311void create_new_tab(GtkWidget* widget, gpointer user_data){
6b1d3120 1312 gchar label[PATH_LENGTH];
2901f314 1313 MainWindow * mw_data = get_window_data_struct(widget);
1314 GtkNotebook * notebook = (GtkNotebook *)lookup_widget(widget, "MNotebook");
561eba2a 1315 if(notebook == NULL){
1316 g_printf("Notebook does not exist\n");
1317 return;
1318 }
1319
6b1d3120 1320 strcpy(label,"Page");
eb38aea5 1321 if(get_label(mw_data, label,"Get the name of the tab","Please input tab's name"))
a43d67ba 1322 create_tab (NULL, mw_data, notebook, label);
561eba2a 1323}
1324
2901f314 1325void
1326on_tab_activate (GtkMenuItem *menuitem,
1327 gpointer user_data)
1328{
1329 create_new_tab((GtkWidget*)menuitem, user_data);
1330}
1331
561eba2a 1332
1333void
1334on_open_activate (GtkMenuItem *menuitem,
1335 gpointer user_data)
1336{
1337 open_traceset((GtkWidget*)menuitem, user_data);
1338}
1339
1340
1341void
1342on_close_activate (GtkMenuItem *menuitem,
1343 gpointer user_data)
1344{
bca3b81f 1345 MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
68b48a45 1346 main_window_destructor(mw_data);
561eba2a 1347}
1348
1349
abe346a3 1350/* remove the current tab from the main window if it is not the default tab
1351 */
1352
561eba2a 1353void
1354on_close_tab_activate (GtkMenuItem *menuitem,
1355 gpointer user_data)
1356{
efde9138 1357 GList * list;
2061e03d 1358 int count = 0;
1359 GtkWidget * notebook;
bca3b81f 1360 Tab * tmp;
1361 MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
2061e03d 1362 notebook = lookup_widget((GtkWidget*)menuitem, "MNotebook");
1363 if(notebook == NULL){
1364 g_printf("Notebook does not exist\n");
1365 return;
1366 }
1367
bca3b81f 1368 if(mw_data->tab == mw_data->current_tab){
1369 // tmp = mw_data->current_tb;
1370 // mw_data->tab = mw_data->current_tab->next;
2061e03d 1371 g_printf("The default TAB can not be deleted\n");
1372 return;
1373 }else{
bca3b81f 1374 tmp = mw_data->tab;
1375 while(tmp != mw_data->current_tab){
1376 tmp = tmp->next;
abe346a3 1377 count++;
2061e03d 1378 }
1379 }
1380
1381 gtk_notebook_remove_page((GtkNotebook*)notebook, count);
efde9138 1382 list = gtk_container_get_children(GTK_CONTAINER(notebook));
1383 if(g_list_length(list)==1)
1384 gtk_notebook_set_show_tabs((GtkNotebook*)notebook, FALSE);
561eba2a 1385}
1386
1387
1388void
1389on_add_trace_activate (GtkMenuItem *menuitem,
1390 gpointer user_data)
1391{
1392 add_trace((GtkWidget*)menuitem, user_data);
1393}
1394
1395
1396void
1397on_remove_trace_activate (GtkMenuItem *menuitem,
1398 gpointer user_data)
1399{
1400 remove_trace((GtkWidget*)menuitem, user_data);
1401}
1402
1403
1404void
1405on_save_activate (GtkMenuItem *menuitem,
1406 gpointer user_data)
1407{
1408 save((GtkWidget*)menuitem, user_data);
1409}
1410
1411
1412void
1413on_save_as_activate (GtkMenuItem *menuitem,
1414 gpointer user_data)
1415{
1416 save_as((GtkWidget*)menuitem, user_data);
1417}
1418
1419
1420void
1421on_quit_activate (GtkMenuItem *menuitem,
1422 gpointer user_data)
1423{
2061e03d 1424 gtk_main_quit ();
561eba2a 1425}
1426
1427
1428void
1429on_cut_activate (GtkMenuItem *menuitem,
1430 gpointer user_data)
1431{
1432 g_printf("Cut\n");
1433}
1434
1435
1436void
1437on_copy_activate (GtkMenuItem *menuitem,
1438 gpointer user_data)
1439{
1440 g_printf("Copye\n");
1441}
1442
1443
1444void
1445on_paste_activate (GtkMenuItem *menuitem,
1446 gpointer user_data)
1447{
1448 g_printf("Paste\n");
1449}
1450
1451
1452void
1453on_delete_activate (GtkMenuItem *menuitem,
1454 gpointer user_data)
1455{
1456 g_printf("Delete\n");
1457}
1458
1459
1460void
1461on_zoom_in_activate (GtkMenuItem *menuitem,
1462 gpointer user_data)
1463{
1464 zoom_in((GtkWidget*)menuitem, user_data);
1465}
1466
1467
1468void
1469on_zoom_out_activate (GtkMenuItem *menuitem,
1470 gpointer user_data)
1471{
1472 zoom_out((GtkWidget*)menuitem, user_data);
1473}
1474
1475
1476void
1477on_zoom_extended_activate (GtkMenuItem *menuitem,
1478 gpointer user_data)
1479{
1480 zoom_extended((GtkWidget*)menuitem, user_data);
1481}
1482
1483
1484void
1485on_go_to_time_activate (GtkMenuItem *menuitem,
1486 gpointer user_data)
1487{
1488 go_to_time((GtkWidget*)menuitem, user_data);
1489}
1490
1491
1492void
1493on_show_time_frame_activate (GtkMenuItem *menuitem,
1494 gpointer user_data)
1495{
1496 show_time_frame((GtkWidget*)menuitem, user_data);
1497}
1498
1499
1500void
1501on_move_viewer_up_activate (GtkMenuItem *menuitem,
1502 gpointer user_data)
1503{
1504 move_up_viewer((GtkWidget*)menuitem, user_data);
1505}
1506
1507
1508void
1509on_move_viewer_down_activate (GtkMenuItem *menuitem,
1510 gpointer user_data)
1511{
1512 move_down_viewer((GtkWidget*)menuitem, user_data);
1513}
1514
1515
1516void
1517on_remove_viewer_activate (GtkMenuItem *menuitem,
1518 gpointer user_data)
1519{
1520 delete_viewer((GtkWidget*)menuitem, user_data);
1521}
1522
49bf71b5 1523void
1524on_trace_filter_activate (GtkMenuItem *menuitem,
1525 gpointer user_data)
1526{
1527 MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
1528 LttvTracesetSelector * s;
1529 GtkWidget * w = gtk_multi_vpaned_get_widget(mw_data->current_tab->multi_vpaned);
1530
1531 s = g_object_get_data(G_OBJECT(w), "Traceset_Selector");
1532 if(!s){
1533 g_printf("There is no viewer yet\n");
1534 return;
1535 }
a8c0f09d 1536 if(get_filter_selection(s, "Configure trace and tracefile filter", "Select traces and tracefiles")){
a43d67ba 1537 //FIXME report filter change
1538 //update_traceset(mw_data);
1539 //call_pending_read_hooks(mw_data);
1540 //lttvwindow_report_current_time(mw_data,&(mw_data->current_tab->current_time));
a8c0f09d 1541 }
49bf71b5 1542}
1543
1544void
1545on_trace_facility_activate (GtkMenuItem *menuitem,
1546 gpointer user_data)
1547{
1548 g_printf("Trace facility selector: %s\n");
1549}
561eba2a 1550
abe346a3 1551
1552/* Dispaly a file selection dialogue to let user select a module, then call
1553 * lttv_module_load(), finally insert tool button and menu entry in the main window
1554 * for the loaded module
1555 */
1556
561eba2a 1557void
1558on_load_module_activate (GtkMenuItem *menuitem,
1559 gpointer user_data)
1560{
36b3c068 1561 char ** dir;
1562 gint id;
3872a20e 1563 char str[PATH_LENGTH], *str1;
bca3b81f 1564 MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
68b48a45 1565 GtkFileSelection * file_selector = (GtkFileSelection *)gtk_file_selection_new("Select a module");
3658a338 1566 if(remember_plugins_dir[0] != '\0')
1567 gtk_file_selection_set_filename(file_selector, remember_plugins_dir);
68b48a45 1568 gtk_file_selection_hide_fileop_buttons(file_selector);
36b3c068 1569
1570 str[0] = '\0';
68b48a45 1571 id = gtk_dialog_run(GTK_DIALOG(file_selector));
36b3c068 1572 switch(id){
1573 case GTK_RESPONSE_ACCEPT:
1574 case GTK_RESPONSE_OK:
68b48a45 1575 dir = gtk_file_selection_get_selections (file_selector);
6fbb1ddf 1576 strncpy(str,dir[0],PATH_LENGTH);
3658a338 1577 strncpy(remember_plugins_dir,dir[0],PATH_LENGTH);
3872a20e 1578 str1 = strrchr(str,'/');
1579 if(str1)str1++;
1580 else{
1581 str1 = strrchr(str,'\\');
1582 str1++;
1583 }
08b1c66e 1584 lttv_module_require(str1, NULL);
36b3c068 1585 g_strfreev(dir);
1586 case GTK_RESPONSE_REJECT:
1587 case GTK_RESPONSE_CANCEL:
1588 default:
68b48a45 1589 gtk_widget_destroy((GtkWidget*)file_selector);
36b3c068 1590 break;
1591 }
1592 g_printf("Load module: %s\n", str);
561eba2a 1593}
1594
1595
abe346a3 1596/* Display all loaded modules, let user to select a module to unload
1597 * by calling lttv_module_unload
1598 */
1599
561eba2a 1600void
1601on_unload_module_activate (GtkMenuItem *menuitem,
1602 gpointer user_data)
1603{
36b3c068 1604 int i;
08b1c66e 1605 GPtrArray *name;
1606 char *unload_module_name;
36b3c068 1607 guint nb;
08b1c66e 1608 LttvLibrary *library;
1609 LttvLibraryInfo library_info;
bca3b81f 1610 MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
36b3c068 1611
08b1c66e 1612 name = g_ptr_array_new();
1613 nb = lttv_library_number();
1614
36b3c068 1615 for(i=0;i<nb;i++){
08b1c66e 1616 library = lttv_library_get(i);
1617 lttv_library_info(library, &library_info);
1618 if(library_info.load_count > 0) g_ptr_array_add(name, library_info.name);
36b3c068 1619 }
1620
08b1c66e 1621 unload_module_name =get_unload_module((char **)(name->pdata), name->len);
36b3c068 1622
1623 if(unload_module_name){
1624 for(i=0;i<nb;i++){
08b1c66e 1625 library = lttv_library_get(i);
1626 lttv_library_info(library, &library_info);
1627 if(strcmp(unload_module_name, library_info.name) == 0){
001d8606 1628 lttv_library_unload(library);
36b3c068 1629 break;
1630 }
1631 }
1632 }
1633
08b1c66e 1634 g_ptr_array_free(name, TRUE);
561eba2a 1635}
1636
1637
abe346a3 1638/* Display a directory dialogue to let user select a path for module searching
1639 */
1640
561eba2a 1641void
1642on_add_module_search_path_activate (GtkMenuItem *menuitem,
1643 gpointer user_data)
1644{
68b48a45 1645 GtkDirSelection * file_selector = (GtkDirSelection *)gtk_dir_selection_new("Select module path");
67b98724 1646 const char * dir;
fc188b78 1647 gint id;
1648
bca3b81f 1649 MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
3658a338 1650 if(remember_plugins_dir[0] != '\0')
1651 gtk_dir_selection_set_filename(file_selector, remember_plugins_dir);
fc188b78 1652
68b48a45 1653 id = gtk_dialog_run(GTK_DIALOG(file_selector));
fc188b78 1654 switch(id){
1655 case GTK_RESPONSE_ACCEPT:
1656 case GTK_RESPONSE_OK:
68b48a45 1657 dir = gtk_dir_selection_get_dir (file_selector);
3658a338 1658 strncpy(remember_plugins_dir,dir,PATH_LENGTH);
1659 strncat(remember_plugins_dir,"/",PATH_LENGTH);
08b1c66e 1660 lttv_library_path_add(dir);
fc188b78 1661 case GTK_RESPONSE_REJECT:
1662 case GTK_RESPONSE_CANCEL:
1663 default:
68b48a45 1664 gtk_widget_destroy((GtkWidget*)file_selector);
fc188b78 1665 break;
6b1d3120 1666 }
561eba2a 1667}
1668
1669
1670void
1671on_color_activate (GtkMenuItem *menuitem,
1672 gpointer user_data)
1673{
1674 g_printf("Color\n");
1675}
1676
1677
1678void
1679on_filter_activate (GtkMenuItem *menuitem,
1680 gpointer user_data)
1681{
1682 g_printf("Filter\n");
1683}
1684
1685
1686void
1687on_save_configuration_activate (GtkMenuItem *menuitem,
1688 gpointer user_data)
1689{
1690 g_printf("Save configuration\n");
1691}
1692
1693
1694void
1695on_content_activate (GtkMenuItem *menuitem,
1696 gpointer user_data)
1697{
1698 g_printf("Content\n");
1699}
1700
1701
1702void
1703on_about_activate (GtkMenuItem *menuitem,
1704 gpointer user_data)
1705{
1706 g_printf("About...\n");
1707}
1708
1709
1710void
1711on_button_new_clicked (GtkButton *button,
1712 gpointer user_data)
1713{
6f7ad7ae 1714 create_new_window((GtkWidget*)button, user_data, TRUE);
561eba2a 1715}
1716
2901f314 1717void
1718on_button_new_tab_clicked (GtkButton *button,
1719 gpointer user_data)
1720{
1721 create_new_tab((GtkWidget*)button, user_data);
1722}
561eba2a 1723
1724void
1725on_button_open_clicked (GtkButton *button,
1726 gpointer user_data)
1727{
1728 open_traceset((GtkWidget*)button, user_data);
1729}
1730
1731
1732void
1733on_button_add_trace_clicked (GtkButton *button,
1734 gpointer user_data)
1735{
1736 add_trace((GtkWidget*)button, user_data);
1737}
1738
1739
1740void
1741on_button_remove_trace_clicked (GtkButton *button,
1742 gpointer user_data)
1743{
1744 remove_trace((GtkWidget*)button, user_data);
1745}
1746
1747
1748void
1749on_button_save_clicked (GtkButton *button,
1750 gpointer user_data)
1751{
1752 save((GtkWidget*)button, user_data);
1753}
1754
1755
1756void
1757on_button_save_as_clicked (GtkButton *button,
1758 gpointer user_data)
1759{
1760 save_as((GtkWidget*)button, user_data);
1761}
1762
1763
1764void
1765on_button_zoom_in_clicked (GtkButton *button,
1766 gpointer user_data)
1767{
1768 zoom_in((GtkWidget*)button, user_data);
1769}
1770
1771
1772void
1773on_button_zoom_out_clicked (GtkButton *button,
1774 gpointer user_data)
1775{
1776 zoom_out((GtkWidget*)button, user_data);
1777}
1778
1779
1780void
1781on_button_zoom_extended_clicked (GtkButton *button,
1782 gpointer user_data)
1783{
1784 zoom_extended((GtkWidget*)button, user_data);
1785}
1786
1787
1788void
1789on_button_go_to_time_clicked (GtkButton *button,
1790 gpointer user_data)
1791{
1792 go_to_time((GtkWidget*)button, user_data);
1793}
1794
1795
1796void
1797on_button_show_time_frame_clicked (GtkButton *button,
1798 gpointer user_data)
1799{
1800 show_time_frame((GtkWidget*)button, user_data);
1801}
1802
1803
1804void
1805on_button_move_up_clicked (GtkButton *button,
1806 gpointer user_data)
1807{
1808 move_up_viewer((GtkWidget*)button, user_data);
1809}
1810
1811
1812void
1813on_button_move_down_clicked (GtkButton *button,
1814 gpointer user_data)
1815{
1816 move_down_viewer((GtkWidget*)button, user_data);
1817}
1818
1819
1820void
1821on_button_delete_viewer_clicked (GtkButton *button,
1822 gpointer user_data)
1823{
1824 delete_viewer((GtkWidget*)button, user_data);
1825}
1826
1827void
1828on_MWindow_destroy (GtkObject *object,
1829 gpointer user_data)
1830{
ef68c3ac 1831 MainWindow *main_window = get_window_data_struct((GtkWidget*)object);
e4d09234 1832 GtkWidget *widget;
ef68c3ac 1833 Tab *tab = main_window->tab;
1834 LttvIAttribute *attributes = main_window->attributes;
1835 LttvAttributeValue value;
e4d09234 1836
ef68c3ac 1837 //This is unnecessary, since widgets will be destroyed
1838 //by the main window widget anyway.
1839 //remove_all_menu_toolbar_constructors(main_window, NULL);
1840
1841 g_assert(lttv_iattribute_find_by_path(attributes,
1842 "viewers/menu", LTTV_POINTER, &value));
1843 lttv_menus_destroy((LttvMenus*)*(value.v_pointer));
1844
501e4e70 1845 g_assert(lttv_iattribute_find_by_path(attributes,
ef68c3ac 1846 "viewers/toolbar", LTTV_POINTER, &value));
1847 lttv_toolbars_destroy((LttvToolbars*)*(value.v_pointer));
1848
1849 while(main_window->tab){
1850 lttv_state_remove_event_hooks(
1851 (LttvTracesetState*)main_window->tab->traceset_info->traceset_context);
1852 main_window->tab = main_window->tab->next;
1853 }
1854 g_object_unref(main_window->attributes);
1855 g_main_window_list = g_slist_remove(g_main_window_list, main_window);
561eba2a 1856
68b48a45 1857 g_win_count--;
ef68c3ac 1858 g_printf("There are now : %d windows\n",g_slist_length(g_main_window_list));
68b48a45 1859 if(g_win_count == 0)
7a859036 1860 gtk_main_quit ();
561eba2a 1861}
1862
58eecf4a 1863gboolean
1864on_MWindow_configure (GtkWidget *widget,
1865 GdkEventConfigure *event,
1866 gpointer user_data)
1867{
1868 MainWindow * mw_data = get_window_data_struct((GtkWidget*)widget);
1869 float width = event->width;
1870 Tab * tab = mw_data->tab;
1871 TimeWindow time_win;
1872 double ratio;
1873 TimeInterval *time_span;
1874 LttTime time;
bd24a9af 1875
1876 // MD : removed time width modification upon resizing of the main window.
1877 // The viewers will redraw themselves completely, without time interval
1878 // modification.
1879/* while(tab){
58eecf4a 1880 if(mw_data->window_width){
1881 time_span = LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->Time_Span ;
1882 time_win = tab->time_window;
1883 ratio = width / mw_data->window_width;
1884 tab->time_window.time_width = ltt_time_mul(time_win.time_width,ratio);
1885 time = ltt_time_sub(time_span->endTime, time_win.start_time);
1886 if(ltt_time_compare(time, tab->time_window.time_width) < 0){
1887 tab->time_window.time_width = time;
1888 }
1889 }
1890 tab = tab->next;
1891 }
1892
1893 mw_data->window_width = (int)width;
bd24a9af 1894 */
58eecf4a 1895 return FALSE;
1896}
561eba2a 1897
abe346a3 1898/* Set current tab
1899 */
1900
561eba2a 1901void
1902on_MNotebook_switch_page (GtkNotebook *notebook,
1903 GtkNotebookPage *page,
1904 guint page_num,
1905 gpointer user_data)
1906{
bca3b81f 1907 MainWindow * mw = get_window_data_struct((GtkWidget*)notebook);
1908 Tab * tab = mw->tab;
561eba2a 1909
1910 while(page_num){
bca3b81f 1911 tab = tab->next;
561eba2a 1912 page_num--;
1913 }
bca3b81f 1914 mw->current_tab = tab;
561eba2a 1915}
1916
abe346a3 1917
1918/* callback function to check or uncheck the check box (filter)
1919 */
1920
49bf71b5 1921void checkbox_changed(GtkTreeView *treeview,
1922 GtkTreePath *arg1,
1923 GtkTreeViewColumn *arg2,
1924 gpointer user_data)
1925{
1926 GtkTreeStore * store = (GtkTreeStore *)gtk_tree_view_get_model (treeview);
1927 GtkTreeIter iter;
1928 gboolean value;
1929
1930 if (gtk_tree_model_get_iter ((GtkTreeModel *)store, &iter, arg1)){
1931 gtk_tree_model_get ((GtkTreeModel *)store, &iter, CHECKBOX_COLUMN, &value, -1);
1932 value = value? FALSE : TRUE;
1933 gtk_tree_store_set (GTK_TREE_STORE (store), &iter, CHECKBOX_COLUMN, value, -1);
1934 }
1935
1936}
1937
abe346a3 1938
1939/* According to user's selection, update selector(filter)
1940 */
1941
49bf71b5 1942void update_filter(LttvTracesetSelector *s, GtkTreeStore *store )
1943{
ed3b99b6 1944 GtkTreeIter iter, child_iter, child_iter1, child_iter2;
1945 int i, j, k, nb_eventtype;
49bf71b5 1946 LttvTraceSelector * trace;
1947 LttvTracefileSelector * tracefile;
ed3b99b6 1948 LttvEventtypeSelector * eventtype;
1949 gboolean value, value1, value2;
49bf71b5 1950
1951 if(gtk_tree_model_get_iter_first((GtkTreeModel*)store, &iter)){
1952 i = 0;
1953 do{
ed3b99b6 1954 trace = lttv_traceset_selector_trace_get(s, i);
1955 nb_eventtype = lttv_trace_selector_eventtype_number(trace);
49bf71b5 1956 gtk_tree_model_get ((GtkTreeModel*)store, &iter, CHECKBOX_COLUMN, &value,-1);
1957 if(value){
1958 j = 0;
1959 if(gtk_tree_model_iter_children ((GtkTreeModel*)store, &child_iter, &iter)){
1960 do{
ed3b99b6 1961 if(j<1){//eventtype selector for trace
1962 gtk_tree_model_get ((GtkTreeModel*)store, &child_iter, CHECKBOX_COLUMN, &value2,-1);
1963 if(value2){
1964 k=0;
1965 if(gtk_tree_model_iter_children ((GtkTreeModel*)store, &child_iter1, &child_iter)){
1966 do{
1967 eventtype = lttv_trace_selector_eventtype_get(trace,k);
1968 gtk_tree_model_get ((GtkTreeModel*)store, &child_iter1, CHECKBOX_COLUMN, &value2,-1);
1969 lttv_eventtype_selector_set_selected(eventtype,value2);
1970 k++;
1971 }while(gtk_tree_model_iter_next((GtkTreeModel*)store, &child_iter1));
1972 }
1973 }
1974 }else{ //tracefile selector
1975 tracefile = lttv_trace_selector_tracefile_get(trace, j - 1);
1976 gtk_tree_model_get ((GtkTreeModel*)store, &child_iter, CHECKBOX_COLUMN, &value1,-1);
1977 lttv_tracefile_selector_set_selected(tracefile,value1);
1978 if(value1){
1979 gtk_tree_model_iter_children((GtkTreeModel*)store, &child_iter1, &child_iter); //eventtype selector
1980 gtk_tree_model_get ((GtkTreeModel*)store, &child_iter1, CHECKBOX_COLUMN, &value2,-1);
1981 if(value2){
1982 k = 0;
1983 if(gtk_tree_model_iter_children ((GtkTreeModel*)store, &child_iter2, &child_iter1)){
1984 do{//eventtype selector for tracefile
1985 eventtype = lttv_tracefile_selector_eventtype_get(tracefile,k);
1986 gtk_tree_model_get ((GtkTreeModel*)store, &child_iter2, CHECKBOX_COLUMN, &value2,-1);
1987 lttv_eventtype_selector_set_selected(eventtype,value2);
1988 k++;
1989 }while(gtk_tree_model_iter_next((GtkTreeModel*)store, &child_iter2));
1990 }
1991 }
1992 }
1993 }
49bf71b5 1994 j++;
1995 }while(gtk_tree_model_iter_next((GtkTreeModel*)store, &child_iter));
1996 }
1997 }
1998 lttv_trace_selector_set_selected(trace,value);
1999 i++;
2000 }while(gtk_tree_model_iter_next((GtkTreeModel*)store, &iter));
2001 }
2002}
2003
abe346a3 2004
2005/* Display a dialogue showing all eventtypes and traces, let user to select the interested
2006 * eventtypes, tracefiles and traces (filter)
2007 */
2008
a8c0f09d 2009gboolean get_filter_selection(LttvTracesetSelector *s,char *title, char * column_title)
49bf71b5 2010{
2011 GtkWidget * dialogue;
2012 GtkTreeStore * store;
2013 GtkWidget * tree;
2014 GtkWidget * scroll_win;
2015 GtkCellRenderer * renderer;
2016 GtkTreeViewColumn * column;
ed3b99b6 2017 GtkTreeIter iter, child_iter, child_iter1, child_iter2;
2018 int i, j, k, id, nb_trace, nb_tracefile, nb_eventtype;
49bf71b5 2019 LttvTraceSelector * trace;
2020 LttvTracefileSelector * tracefile;
ed3b99b6 2021 LttvEventtypeSelector * eventtype;
49bf71b5 2022 char * name;
2023 gboolean checked;
2024
2025 dialogue = gtk_dialog_new_with_buttons(title,
2026 NULL,
2027 GTK_DIALOG_MODAL,
2028 GTK_STOCK_OK,GTK_RESPONSE_ACCEPT,
2029 GTK_STOCK_CANCEL,GTK_RESPONSE_REJECT,
2030 NULL);
ed3b99b6 2031 gtk_window_set_default_size((GtkWindow*)dialogue, 300, 500);
49bf71b5 2032
2033 store = gtk_tree_store_new (TOTAL_COLUMNS, G_TYPE_BOOLEAN, G_TYPE_STRING);
2034 tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
2035 g_object_unref (G_OBJECT (store));
2036 g_signal_connect (G_OBJECT (tree), "row-activated",
2037 G_CALLBACK (checkbox_changed),
2038 NULL);
2039
2040
2041 renderer = gtk_cell_renderer_toggle_new ();
2042 gtk_cell_renderer_toggle_set_radio((GtkCellRendererToggle *)renderer, FALSE);
2043
2044 g_object_set (G_OBJECT (renderer),"activatable", TRUE, NULL);
2045
2046 column = gtk_tree_view_column_new_with_attributes ("Checkbox",
2047 renderer,
2048 "active", CHECKBOX_COLUMN,
2049 NULL);
2050 gtk_tree_view_column_set_alignment (column, 0.5);
2051 gtk_tree_view_column_set_fixed_width (column, 20);
2052 gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
2053
2054 renderer = gtk_cell_renderer_text_new ();
2055 column = gtk_tree_view_column_new_with_attributes (column_title,
2056 renderer,
2057 "text", NAME_COLUMN,
2058 NULL);
2059 gtk_tree_view_column_set_alignment (column, 0.0);
2060 gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
2061 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW (tree), FALSE);
2062
2063 scroll_win = gtk_scrolled_window_new (NULL, NULL);
2064 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win),
2065 GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
2066 gtk_container_add (GTK_CONTAINER (scroll_win), tree);
2067
2068 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), scroll_win,TRUE, TRUE,0);
2069
2070 gtk_widget_show(scroll_win);
2071 gtk_widget_show(tree);
2072
ed3b99b6 2073 nb_trace = lttv_traceset_selector_trace_number(s);
49bf71b5 2074 for(i=0;i<nb_trace;i++){
ed3b99b6 2075 trace = lttv_traceset_selector_trace_get(s, i);
49bf71b5 2076 name = lttv_trace_selector_get_name(trace);
2077 gtk_tree_store_append (store, &iter, NULL);
2078 checked = lttv_trace_selector_get_selected(trace);
2079 gtk_tree_store_set (store, &iter,
2080 CHECKBOX_COLUMN,checked,
2081 NAME_COLUMN,name,
2082 -1);
ed3b99b6 2083
2084 gtk_tree_store_append (store, &child_iter, &iter);
2085 gtk_tree_store_set (store, &child_iter,
2086 CHECKBOX_COLUMN, checked,
2087 NAME_COLUMN,"eventtype",
2088 -1);
2089
2090 nb_eventtype = lttv_trace_selector_eventtype_number(trace);
2091 for(j=0;j<nb_eventtype;j++){
2092 eventtype = lttv_trace_selector_eventtype_get(trace,j);
2093 name = lttv_eventtype_selector_get_name(eventtype);
2094 checked = lttv_eventtype_selector_get_selected(eventtype);
2095 gtk_tree_store_append (store, &child_iter1, &child_iter);
2096 gtk_tree_store_set (store, &child_iter1,
2097 CHECKBOX_COLUMN, checked,
2098 NAME_COLUMN,name,
2099 -1);
2100 }
2101
2102 nb_tracefile = lttv_trace_selector_tracefile_number(trace);
49bf71b5 2103 for(j=0;j<nb_tracefile;j++){
ed3b99b6 2104 tracefile = lttv_trace_selector_tracefile_get(trace, j);
49bf71b5 2105 name = lttv_tracefile_selector_get_name(tracefile);
2106 gtk_tree_store_append (store, &child_iter, &iter);
2107 checked = lttv_tracefile_selector_get_selected(tracefile);
2108 gtk_tree_store_set (store, &child_iter,
2109 CHECKBOX_COLUMN, checked,
2110 NAME_COLUMN,name,
2111 -1);
ed3b99b6 2112
2113 gtk_tree_store_append (store, &child_iter1, &child_iter);
2114 gtk_tree_store_set (store, &child_iter1,
2115 CHECKBOX_COLUMN, checked,
2116 NAME_COLUMN,"eventtype",
2117 -1);
2118
2119 for(k=0;k<nb_eventtype;k++){
2120 eventtype = lttv_tracefile_selector_eventtype_get(tracefile,k);
2121 name = lttv_eventtype_selector_get_name(eventtype);
2122 checked = lttv_eventtype_selector_get_selected(eventtype);
2123 gtk_tree_store_append (store, &child_iter2, &child_iter1);
2124 gtk_tree_store_set (store, &child_iter2,
2125 CHECKBOX_COLUMN, checked,
2126 NAME_COLUMN,name,
2127 -1);
2128 }
49bf71b5 2129 }
2130 }
2131
2132 id = gtk_dialog_run(GTK_DIALOG(dialogue));
2133 switch(id){
2134 case GTK_RESPONSE_ACCEPT:
2135 case GTK_RESPONSE_OK:
2136 update_filter(s, store);
a8c0f09d 2137 gtk_widget_destroy(dialogue);
2138 return TRUE;
49bf71b5 2139 case GTK_RESPONSE_REJECT:
2140 case GTK_RESPONSE_CANCEL:
2141 default:
2142 gtk_widget_destroy(dialogue);
2143 break;
2144 }
a8c0f09d 2145 return FALSE;
49bf71b5 2146}
2147
abe346a3 2148
2149/* Select a trace which will be removed from traceset
2150 */
2151
2176f952 2152char * get_remove_trace(char ** all_trace_name, int nb_trace)
2153{
2154 return get_selection(all_trace_name, nb_trace,
2155 "Select a trace", "Trace pathname");
2156}
abe346a3 2157
2158
2159/* Select a module which will be unloaded
2160 */
2161
36b3c068 2162char * get_unload_module(char ** loaded_module_name, int nb_module)
2176f952 2163{
2164 return get_selection(loaded_module_name, nb_module,
2165 "Select an unload module", "Module pathname");
2166}
2167
abe346a3 2168
2169/* Display a dialogue which shows all selectable items, let user to
2170 * select one of them
2171 */
2172
2176f952 2173char * get_selection(char ** loaded_module_name, int nb_module,
2174 char *title, char * column_title)
36b3c068 2175{
2176 GtkWidget * dialogue;
2177 GtkWidget * scroll_win;
2178 GtkWidget * tree;
2179 GtkListStore * store;
2180 GtkTreeViewColumn * column;
2181 GtkCellRenderer * renderer;
2182 GtkTreeSelection * select;
2183 GtkTreeIter iter;
2184 gint id, i;
2185 char * unload_module_name = NULL;
2186
2176f952 2187 dialogue = gtk_dialog_new_with_buttons(title,
36b3c068 2188 NULL,
2189 GTK_DIALOG_MODAL,
2190 GTK_STOCK_OK,GTK_RESPONSE_ACCEPT,
2191 GTK_STOCK_CANCEL,GTK_RESPONSE_REJECT,
2192 NULL);
2193 gtk_window_set_default_size((GtkWindow*)dialogue, 500, 200);
2194
2195 scroll_win = gtk_scrolled_window_new (NULL, NULL);
2196 gtk_widget_show ( scroll_win);
2197 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win),
2198 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2199
2200 store = gtk_list_store_new (N_COLUMNS,G_TYPE_STRING);
2201 tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL (store));
2202 gtk_widget_show ( tree);
2203 g_object_unref (G_OBJECT (store));
2204
2205 renderer = gtk_cell_renderer_text_new ();
2176f952 2206 column = gtk_tree_view_column_new_with_attributes (column_title,
36b3c068 2207 renderer,
2208 "text", MODULE_COLUMN,
2209 NULL);
2210 gtk_tree_view_column_set_alignment (column, 0.5);
2211 gtk_tree_view_column_set_fixed_width (column, 150);
2212 gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
2213
2214 select = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree));
2215 gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE);
2216
2217 gtk_container_add (GTK_CONTAINER (scroll_win), tree);
2218
2219 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), scroll_win,TRUE, TRUE,0);
2220
2221 for(i=0;i<nb_module;i++){
2222 gtk_list_store_append (store, &iter);
2223 gtk_list_store_set (store, &iter, MODULE_COLUMN,loaded_module_name[i],-1);
2224 }
2225
2226 id = gtk_dialog_run(GTK_DIALOG(dialogue));
2227 switch(id){
2228 case GTK_RESPONSE_ACCEPT:
2229 case GTK_RESPONSE_OK:
2230 if (gtk_tree_selection_get_selected (select, (GtkTreeModel**)&store, &iter)){
2231 gtk_tree_model_get ((GtkTreeModel*)store, &iter, MODULE_COLUMN, &unload_module_name, -1);
2232 }
2233 case GTK_RESPONSE_REJECT:
2234 case GTK_RESPONSE_CANCEL:
2235 default:
2236 gtk_widget_destroy(dialogue);
2237 break;
2238 }
2239
2240 return unload_module_name;
2241}
5723fa24 2242
abe346a3 2243
ef68c3ac 2244/* Insert all menu entry and tool buttons into this main window
001d8606 2245 * for modules.
2246 *
abe346a3 2247 */
2248
6c9d86dd 2249void add_all_menu_toolbar_constructors(MainWindow * mw, gpointer user_data)
5723fa24 2250{
2251 int i;
2252 GdkPixbuf *pixbuf;
42fcbb71 2253 lttvwindow_viewer_constructor constructor;
001d8606 2254 LttvMenus * global_menu, * instance_menu;
2255 LttvToolbars * global_toolbar, * instance_toolbar;
6c9d86dd 2256 LttvMenuClosure *menu_item;
2257 LttvToolbarClosure *toolbar_item;
5723fa24 2258 LttvAttributeValue value;
001d8606 2259 LttvIAttribute *global_attributes = LTTV_IATTRIBUTE(lttv_global_attributes());
501e4e70 2260 LttvIAttribute *attributes = mw->attributes;
001d8606 2261 GtkWidget * tool_menu_title_menu, *new_widget, *pixmap;
2262
2263 g_assert(lttv_iattribute_find_by_path(global_attributes,
2264 "viewers/menu", LTTV_POINTER, &value));
2265 if(*(value.v_pointer) == NULL)
501e4e70 2266 *(value.v_pointer) = lttv_menus_new();
001d8606 2267 global_menu = (LttvMenus*)*(value.v_pointer);
5723fa24 2268
2269 g_assert(lttv_iattribute_find_by_path(attributes,
2270 "viewers/menu", LTTV_POINTER, &value));
001d8606 2271 if(*(value.v_pointer) == NULL)
501e4e70 2272 *(value.v_pointer) = lttv_menus_new();
001d8606 2273 instance_menu = (LttvMenus*)*(value.v_pointer);
5723fa24 2274
001d8606 2275
2276
2277 g_assert(lttv_iattribute_find_by_path(global_attributes,
2278 "viewers/toolbar", LTTV_POINTER, &value));
2279 if(*(value.v_pointer) == NULL)
501e4e70 2280 *(value.v_pointer) = lttv_toolbars_new();
001d8606 2281 global_toolbar = (LttvToolbars*)*(value.v_pointer);
2282
2283 g_assert(lttv_iattribute_find_by_path(attributes,
2284 "viewers/toolbar", LTTV_POINTER, &value));
2285 if(*(value.v_pointer) == NULL)
501e4e70 2286 *(value.v_pointer) = lttv_toolbars_new();
001d8606 2287 instance_toolbar = (LttvToolbars*)*(value.v_pointer);
2288
2289 /* Add missing menu entries to window instance */
2290 for(i=0;i<global_menu->len;i++) {
6c9d86dd 2291 menu_item = &g_array_index(global_menu, LttvMenuClosure, i);
2292
2293 //add menu_item to window instance;
2294 constructor = menu_item->con;
2295 tool_menu_title_menu = lookup_widget(mw->mwindow,"ToolMenuTitle_menu");
2296 new_widget =
501e4e70 2297 gtk_menu_item_new_with_mnemonic (menu_item->menu_text);
6c9d86dd 2298 gtk_container_add (GTK_CONTAINER (tool_menu_title_menu),
2299 new_widget);
2300 g_signal_connect ((gpointer) new_widget, "activate",
2301 G_CALLBACK (insert_viewer_wrap),
2302 constructor);
2303 gtk_widget_show (new_widget);
2304 lttv_menus_add(instance_menu, menu_item->con,
2305 menu_item->menu_path,
2306 menu_item->menu_text,
2307 new_widget);
001d8606 2308
001d8606 2309 }
2310
2311 /* Add missing toolbar entries to window instance */
2312 for(i=0;i<global_toolbar->len;i++) {
6c9d86dd 2313 toolbar_item = &g_array_index(global_toolbar, LttvToolbarClosure, i);
2314
2315 //add toolbar_item to window instance;
2316 constructor = toolbar_item->con;
2317 tool_menu_title_menu = lookup_widget(mw->mwindow,"MToolbar1");
2318 pixbuf = gdk_pixbuf_new_from_xpm_data((const char**)toolbar_item->pixmap);
2319 pixmap = gtk_image_new_from_pixbuf(pixbuf);
2320 new_widget =
2321 gtk_toolbar_append_element (GTK_TOOLBAR (tool_menu_title_menu),
2322 GTK_TOOLBAR_CHILD_BUTTON,
2323 NULL,
2324 "",
2325 toolbar_item->tooltip, NULL,
2326 pixmap, NULL, NULL);
2327 gtk_label_set_use_underline(
2328 GTK_LABEL (((GtkToolbarChild*) (
2329 g_list_last (GTK_TOOLBAR
2330 (tool_menu_title_menu)->children)->data))->label),
2331 TRUE);
2332 gtk_container_set_border_width (GTK_CONTAINER (new_widget), 1);
2333 g_signal_connect ((gpointer) new_widget,
2334 "clicked",
2335 G_CALLBACK (insert_viewer_wrap),
2336 constructor);
2337 gtk_widget_show (new_widget);
001d8606 2338
6c9d86dd 2339 lttv_toolbars_add(instance_toolbar, toolbar_item->con,
2340 toolbar_item->tooltip,
2341 toolbar_item->pixmap,
2342 new_widget);
001d8606 2343
5723fa24 2344 }
6c9d86dd 2345
5723fa24 2346}
2347
abe346a3 2348
2349/* Create a main window
2350 */
2351
08b1c66e 2352void construct_main_window(MainWindow * parent)
5723fa24 2353{
2a2fa4f0 2354 g_debug("construct_main_window()");
68b48a45 2355 GtkWidget * new_window; /* New generated main window */
bca3b81f 2356 MainWindow * new_m_window;/* New main window structure */
5723fa24 2357 GtkNotebook * notebook;
f7afe191 2358 LttvIAttribute *attributes =
2359 LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE, NULL));
2360 LttvAttributeValue value;
2061e03d 2361
bca3b81f 2362 new_m_window = g_new(MainWindow, 1);
5723fa24 2363
2364 // Add the object's information to the module's array
68b48a45 2365 g_main_window_list = g_slist_append(g_main_window_list, new_m_window);
5723fa24 2366
f7afe191 2367
68b48a45 2368 new_window = create_MWindow();
2369 gtk_widget_show (new_window);
5723fa24 2370
bca3b81f 2371 new_m_window->mwindow = new_window;
2372 new_m_window->tab = NULL;
2373 new_m_window->current_tab = NULL;
a43d67ba 2374 new_m_window->attributes = attributes;
5723fa24 2375
001d8606 2376 g_assert(lttv_iattribute_find_by_path(attributes,
2377 "viewers/menu", LTTV_POINTER, &value));
501e4e70 2378 *(value.v_pointer) = lttv_menus_new();
001d8606 2379
501e4e70 2380 g_assert(lttv_iattribute_find_by_path(attributes,
001d8606 2381 "viewers/toolbar", LTTV_POINTER, &value));
501e4e70 2382 *(value.v_pointer) = lttv_toolbars_new();
2061e03d 2383
6c9d86dd 2384 add_all_menu_toolbar_constructors(new_m_window, NULL);
5723fa24 2385
68b48a45 2386 g_object_set_data(G_OBJECT(new_window), "mainWindow", (gpointer)new_m_window);
5723fa24 2387 //create a default tab
bca3b81f 2388 notebook = (GtkNotebook *)lookup_widget(new_m_window->mwindow, "MNotebook");
5723fa24 2389 if(notebook == NULL){
2390 g_printf("Notebook does not exist\n");
2391 return;
2392 }
2393 //for now there is no name field in LttvTraceset structure
2394 //Use "Traceset" as the label for the default tab
a43d67ba 2395 create_tab(parent, new_m_window, notebook, "Traceset");
5723fa24 2396
7a859036 2397 g_object_set_data_full(
bca3b81f 2398 G_OBJECT(new_m_window->mwindow),
7a859036 2399 "Main_Window_Data",
68b48a45 2400 new_m_window,
ef68c3ac 2401 NULL);
7a859036 2402
68b48a45 2403 g_win_count++;
ef68c3ac 2404 g_printf("There are now : %d windows\n",g_slist_length(g_main_window_list));
5723fa24 2405}
2406
abe346a3 2407
2408/* Free the memory occupied by a tab structure
2409 * destroy the tab
2410 */
2411
bca3b81f 2412void tab_destructor(Tab * tab_instance)
f7afe191 2413{
716e4367 2414 int i, nb, ref_count;
2415 LttvTrace * trace;
2416
bca3b81f 2417 if(tab_instance->attributes)
501e4e70 2418 g_object_unref(tab_instance->attributes);
2419
2420 if(tab_instance->interrupted_state)
2421 g_object_unref(tab_instance->interrupted_state);
2422
2061e03d 2423
bca3b81f 2424 if(tab_instance->mw->tab == tab_instance){
2425 tab_instance->mw->tab = tab_instance->next;
2061e03d 2426 }else{
bca3b81f 2427 Tab * tmp1, *tmp = tab_instance->mw->tab;
68b48a45 2428 while(tmp != tab_instance){
2061e03d 2429 tmp1 = tmp;
bca3b81f 2430 tmp = tmp->next;
2061e03d 2431 }
bca3b81f 2432 tmp1->next = tab_instance->next;
2061e03d 2433 }
716e4367 2434
2435 if(tab_instance->traceset_info->traceset_context != NULL){
784705cc 2436 //remove state update hooks
2437 lttv_state_remove_event_hooks(
2438 (LttvTracesetState*)tab_instance->traceset_info->
2439 traceset_context);
716e4367 2440 lttv_context_fini(LTTV_TRACESET_CONTEXT(tab_instance->traceset_info->
2441 traceset_context));
2442 g_object_unref(tab_instance->traceset_info->traceset_context);
2443 }
2444 if(tab_instance->traceset_info->traceset != NULL) {
2445 nb = lttv_traceset_number(tab_instance->traceset_info->traceset);
2446 for(i = 0 ; i < nb ; i++) {
2447 trace = lttv_traceset_get(tab_instance->traceset_info->traceset, i);
2448 ref_count = lttv_trace_get_ref_number(trace);
49bf71b5 2449 if(ref_count <= 1){
716e4367 2450 ltt_trace_close(lttv_trace(trace));
6f7ad7ae 2451 lttv_trace_destroy(trace);
49bf71b5 2452 }
6f7ad7ae 2453 // lttv_trace_destroy(trace);
716e4367 2454 }
2455 }
a43d67ba 2456 lttv_traceset_destroy(tab_instance->traceset_info->traceset);
501e4e70 2457 /* Remove the idle events requests processing function of the tab */
2458 g_idle_remove_by_data(tab_instance);
2459
2460 g_slist_free(tab_instance->events_requests);
716e4367 2461 g_free(tab_instance->traceset_info);
68b48a45 2462 g_free(tab_instance);
f7afe191 2463}
2464
abe346a3 2465
2466/* Create a tab and insert it into the current main window
2467 */
2468
716e4367 2469void * create_tab(MainWindow * parent, MainWindow* current_window,
2470 GtkNotebook * notebook, char * label)
5723fa24 2471{
2472 GList * list;
bca3b81f 2473 Tab * tmp_tab;
716e4367 2474 MainWindow * mw_data = current_window;
68b48a45 2475 LttTime tmp_time;
a43d67ba 2476
abe346a3 2477 //create a new tab data structure
bca3b81f 2478 tmp_tab = mw_data->tab;
2479 while(tmp_tab && tmp_tab->next) tmp_tab = tmp_tab->next;
68b48a45 2480 if(!tmp_tab){
bca3b81f 2481 mw_data->current_tab = NULL;
2482 tmp_tab = g_new(Tab,1);
2483 mw_data->tab = tmp_tab;
5723fa24 2484 }else{
bca3b81f 2485 tmp_tab->next = g_new(Tab,1);
2486 tmp_tab = tmp_tab->next;
5723fa24 2487 }
716e4367 2488
abe346a3 2489 //construct and initialize the traceset_info
716e4367 2490 tmp_tab->traceset_info = g_new(TracesetInfo,1);
2491 if(parent){
a43d67ba 2492 if(parent->current_tab){
2493 tmp_tab->traceset_info->traceset =
2494 lttv_traceset_new();
2495 //FIXME lttv_traceset_copy(parent->current_tab->traceset_info->traceset);
2496 }else{
2497 tmp_tab->traceset_info->traceset = lttv_traceset_new();
2498 }
2499
2500 }else{ /* Initial window */
716e4367 2501 if(mw_data->current_tab){
2502 tmp_tab->traceset_info->traceset =
a43d67ba 2503 lttv_traceset_new();
2504 //FIXME lttv_traceset_copy(mw_data->current_tab->traceset_info->traceset);
716e4367 2505 }else{
2506 tmp_tab->traceset_info->traceset = lttv_traceset_new();
49bf71b5 2507 /* Add the command line trace */
a43d67ba 2508 if(g_init_trace != NULL){
49bf71b5 2509 lttv_traceset_add(tmp_tab->traceset_info->traceset, g_init_trace);
a43d67ba 2510 }
716e4367 2511 }
716e4367 2512 }
a43d67ba 2513
716e4367 2514 //FIXME copy not implemented in lower level
2515 tmp_tab->traceset_info->traceset_context =
2516 g_object_new(LTTV_TRACESET_STATS_TYPE, NULL);
a43d67ba 2517 g_assert(tmp_tab->traceset_info->traceset_context != NULL);
716e4367 2518 lttv_context_init(
2519 LTTV_TRACESET_CONTEXT(tmp_tab->traceset_info->traceset_context),
2520 tmp_tab->traceset_info->traceset);
784705cc 2521 //add state update hooks
2522 lttv_state_add_event_hooks(
2523 (LttvTracesetState*)tmp_tab->traceset_info->traceset_context);
2524
abe346a3 2525 //determine the current_time and time_window of the tab
bca3b81f 2526 if(mw_data->current_tab){
716e4367 2527 // Will have to read directly at the main window level, as we want
2528 // to be able to modify a traceset on the fly.
bca3b81f 2529 tmp_tab->time_window = mw_data->current_tab->time_window;
2530 tmp_tab->current_time = mw_data->current_tab->current_time;
5723fa24 2531 }else{
716e4367 2532 // Will have to read directly at the main window level, as we want
2533 // to be able to modify a traceset on the fly.
2534 // get_traceset_time_span(mw_data,&tmp_tab->traceStartTime, &tmp_tab->traceEndTime);
bca3b81f 2535 tmp_tab->time_window.start_time =
501e4e70 2536 LTTV_TRACESET_CONTEXT(tmp_tab->traceset_info->traceset_context)->time_span.start_time;
f7afe191 2537 if(DEFAULT_TIME_WIDTH_S <
501e4e70 2538 LTTV_TRACESET_CONTEXT(tmp_tab->traceset_info->traceset_context)->time_span.end_time.tv_sec)
68b48a45 2539 tmp_time.tv_sec = DEFAULT_TIME_WIDTH_S;
f7afe191 2540 else
68b48a45 2541 tmp_time.tv_sec =
501e4e70 2542 LTTV_TRACESET_CONTEXT(tmp_tab->traceset_info->traceset_context)->time_span.end_time.tv_sec;
68b48a45 2543 tmp_time.tv_nsec = 0;
bca3b81f 2544 tmp_tab->time_window.time_width = tmp_time ;
a8c0f09d 2545 tmp_tab->current_time.tv_sec =
501e4e70 2546 LTTV_TRACESET_CONTEXT(tmp_tab->traceset_info->traceset_context)->time_span.start_time.tv_sec;
a8c0f09d 2547 tmp_tab->current_time.tv_nsec =
501e4e70 2548 LTTV_TRACESET_CONTEXT(tmp_tab->traceset_info->traceset_context)->time_span.start_time.tv_nsec;
5723fa24 2549 }
a43d67ba 2550 /* Become the current tab */
2551 mw_data->current_tab = tmp_tab;
2552
bca3b81f 2553 tmp_tab->attributes = LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE, NULL));
501e4e70 2554 tmp_tab->interrupted_state = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
daecc161 2555 tmp_tab->multi_vpaned = (GtkMultiVPaned*)gtk_multi_vpaned_new();
501e4e70 2556 tmp_tab->multi_vpaned->tab = mw_data->current_tab;
daecc161 2557 gtk_widget_show((GtkWidget*)tmp_tab->multi_vpaned);
bca3b81f 2558 tmp_tab->next = NULL;
68b48a45 2559 tmp_tab->mw = mw_data;
5723fa24 2560
68b48a45 2561 tmp_tab->label = gtk_label_new (label);
2562 gtk_widget_show (tmp_tab->label);
5723fa24 2563
501e4e70 2564 /* Start with empty events requests list */
2565 tmp_tab->events_requests = NULL;
2566 tmp_tab->events_request_pending = FALSE;
a43d67ba 2567
f7afe191 2568 g_object_set_data_full(
daecc161 2569 G_OBJECT(tmp_tab->multi_vpaned),
f7afe191 2570 "Tab_Info",
68b48a45 2571 tmp_tab,
2572 (GDestroyNotify)tab_destructor);
540edb40 2573
784705cc 2574 //insert tab into notebook
daecc161 2575 gtk_notebook_append_page(notebook, (GtkWidget*)tmp_tab->multi_vpaned, tmp_tab->label);
5723fa24 2576 list = gtk_container_get_children(GTK_CONTAINER(notebook));
2577 gtk_notebook_set_current_page(notebook,g_list_length(list)-1);
a43d67ba 2578 // always show : not if(g_list_length(list)>1)
2579 gtk_notebook_set_show_tabs(notebook, TRUE);
2580
5723fa24 2581}
2061e03d 2582
a43d67ba 2583/**
2584 * Function to show each viewer in the current tab.
2585 * It will be called by main window, call show on each registered viewer,
2586 * will call process traceset and then it will
2587 * @param main_win the main window the viewer belongs to.
2588 */
2589//FIXME Only one time request maximum for now!
2590void show_viewer(MainWindow *main_win)
2591{
2592 LttvAttributeValue value;
2593 LttvHooks * tmp;
2594 int i;
2595 LttvTracesetContext * tsc =
2596 (LttvTracesetContext*)main_win->current_tab->
2597 traceset_info->traceset_context;
2598
2599 g_assert(lttv_iattribute_find_by_path(main_win->current_tab->attributes,
2600 "hooks/showviewer", LTTV_POINTER, &value));
2601 tmp = (LttvHooks*)*(value.v_pointer);
2602 if(tmp == NULL)
2603 {
2604 g_warning("The viewer(s) did not add any show hook");
2605 return;
2606 }
2607
2608
2609 // Call the show, where viewers add hooks to context and fill the
2610 // time and number of events requested it the time_requests GArray.
2611 lttv_hooks_call(tmp, NULL);
2612
2613
2614}
2615
501e4e70 2616/*
2617 * execute_events_requests
2618 *
2619 * Idle function that executes the pending requests for a tab.
2620 *
2621 * @return return value : TRUE : keep the idle function, FALSE : remove it.
2622 */
2623gboolean execute_events_requests(Tab *tab)
a43d67ba 2624{
501e4e70 2625 return ( lttvwindow_process_pending_requests(tab) );
a43d67ba 2626}
2627
LTTng 2.x Viewer (LTTV)
This page took 0.177156 seconds and 4 git commands to generate.