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