projects / lttv.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
redraw and continue fix
[lttv.git] / ltt / branches / poly / lttv / modules / gui / lttvwindow / lttvwindow / callbacks.c
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
19 #ifdef HAVE_CONFIG_H
20 # include <config.h>
21 #endif
22
23 #include <limits.h> // for PATH_MAX
24 #include <stdlib.h>
25
26 #include <gtk/gtk.h>
27
28 #include "callbacks.h"
29 #include "interface.h"
30 #include "support.h"
31 #include <ltt/trace.h>
32 #include <ltt/facility.h>
33 #include <ltt/time.h>
34 #include <ltt/event.h>
35 #include <lttv/lttv.h>
36 #include <lttv/module.h>
37 #include <lttv/iattribute.h>
38 #include <lttv/stats.h>
39 #include <lttvwindow/mainwindow.h>
40 #include <lttvwindow/mainwindow-private.h>
41 #include <lttvwindow/menu.h>
42 #include <lttvwindow/toolbar.h>
43 #include <lttvwindow/lttvwindow.h>
44 #include <lttvwindow/lttvwindowtraces.h>
45 #include <lttvwindow/gtkdirsel.h>
46 #include <lttvwindow/lttvfilter.h>
47
48
49 #define DEFAULT_TIME_WIDTH_S 1
50
51 extern LttvTrace *g_init_trace ;
52
53
54 /** Array containing instanced objects. */
55 extern GSList * g_main_window_list;
56
57 /** MD : keep old directory. */
58 static char remember_plugins_dir[PATH_MAX] = "";
59 static char remember_trace_dir[PATH_MAX] = "";
60
61
62 MainWindow * get_window_data_struct(GtkWidget * widget);
63 char * get_unload_module(char ** loaded_module_name, int nb_module);
64 char * get_remove_trace(char ** all_trace_name, int nb_trace);
65 char * get_selection(char ** all_name, int nb, char *title, char * column_title);
66 gboolean get_filter_selection(LttvTracesetSelector *s, char *title, char * column_title);
67 Tab* create_tab(MainWindow * mw, Tab *copy_tab,
68 GtkNotebook * notebook, char * label);
69
70 static void insert_viewer(GtkWidget* widget, lttvwindow_viewer_constructor constructor);
71 void update_filter(LttvTracesetSelector *s, GtkTreeStore *store );
72
73 void checkbox_changed(GtkTreeView *treeview,
74 GtkTreePath *arg1,
75 GtkTreeViewColumn *arg2,
76 gpointer user_data);
77 void remove_trace_from_traceset_selector(GtkMultiVPaned * paned, unsigned i);
78 void add_trace_into_traceset_selector(GtkMultiVPaned * paned, LttTrace * trace);
79 Tab *create_new_tab(GtkWidget* widget, gpointer user_data);
80
81 LttvTracesetSelector * construct_traceset_selector(LttvTraceset * traceset);
82
83 static gboolean lttvwindow_process_pending_requests(Tab *tab);
84
85 enum {
86 CHECKBOX_COLUMN,
87 NAME_COLUMN,
88 TOTAL_COLUMNS
89 };
90
91 enum
92 {
93 MODULE_COLUMN,
94 N_COLUMNS
95 };
96
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 */
100
101 LttvTracesetSelector * construct_traceset_selector(LttvTraceset * traceset)
102 {
103 LttvTracesetSelector * s;
104 LttvTraceSelector * trace;
105 LttvTracefileSelector * tracefile;
106 LttvEventtypeSelector * eventtype;
107 int i, j, k, m;
108 int nb_trace, nb_tracefile, nb_control, nb_per_cpu, nb_facility, nb_event;
109 LttvTrace * trace_v;
110 LttTrace * t;
111 LttTracefile *tf;
112 LttFacility * fac;
113 LttEventType * et;
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);
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
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);
144 lttv_trace_selector_tracefile_add(trace, tracefile);
145 lttv_eventtype_selector_copy(trace, tracefile);
146 }
147 }
148 return s;
149 }
150
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
157 void
158 insert_viewer_wrap(GtkWidget *menuitem, gpointer user_data)
159 {
160 guint val = 20;
161
162 insert_viewer((GtkWidget*)menuitem, (lttvwindow_viewer_constructor)user_data);
163 // selected_hook(&val);
164 }
165
166
167 /* internal functions */
168 void insert_viewer(GtkWidget* widget, lttvwindow_viewer_constructor constructor)
169 {
170 GtkMultiVPaned * multi_vpaned;
171 MainWindow * mw_data = get_window_data_struct(widget);
172 GtkWidget * notebook = lookup_widget(widget, "MNotebook");
173 GtkWidget * viewer;
174 LttvTracesetSelector * s;
175 TimeInterval * time_interval;
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");
184 }
185
186 multi_vpaned = tab->multi_vpaned;
187
188 s = construct_traceset_selector(tab->traceset_info->traceset);
189 viewer = (GtkWidget*)constructor(tab, s, "Traceset_Selector");
190 if(viewer)
191 {
192 gtk_multi_vpaned_widget_add(multi_vpaned, viewer);
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);
204 }
205 }
206
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
212 void 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
219 gboolean get_label(MainWindow * mw, gchar * str, gchar* dialogue_title, gchar * label_str)
220 {
221 GtkWidget * dialogue;
222 GtkWidget * text;
223 GtkWidget * label;
224 gint id;
225
226 dialogue = gtk_dialog_new_with_buttons(dialogue_title,NULL,
227 GTK_DIALOG_MODAL,
228 GTK_STOCK_OK,GTK_RESPONSE_ACCEPT,
229 GTK_STOCK_CANCEL,GTK_RESPONSE_REJECT,
230 NULL);
231
232 label = gtk_label_new(label_str);
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);
250 return FALSE;
251 }
252 return TRUE;
253 }
254
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
261 MainWindow * get_window_data_struct(GtkWidget * widget)
262 {
263 GtkWidget * mw;
264 MainWindow * mw_data;
265
266 mw = lookup_widget(widget, "MWindow");
267 if(mw == NULL){
268 g_printf("Main window does not exist\n");
269 return NULL;
270 }
271
272 mw_data = (MainWindow *) g_object_get_data(G_OBJECT(mw),"main_window_data");
273 if(mw_data == NULL){
274 g_printf("Main window data does not exist\n");
275 return NULL;
276 }
277 return mw_data;
278 }
279
280
281 /* create_new_window function, just constructs a new main window
282 */
283
284 void create_new_window(GtkWidget* widget, gpointer user_data, gboolean clone)
285 {
286 MainWindow * parent = get_window_data_struct(widget);
287
288 if(clone){
289 g_printf("Clone : use the same traceset\n");
290 construct_main_window(parent);
291 }else{
292 g_printf("Empty : traceset is set to NULL\n");
293 construct_main_window(NULL);
294 }
295 }
296
297
298 /* move_*_viewer functions move the selected view up/down in
299 * the current tab
300 */
301
302 void move_up_viewer(GtkWidget * widget, gpointer user_data)
303 {
304 MainWindow * mw = get_window_data_struct(widget);
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);
319 }
320
321 void move_down_viewer(GtkWidget * widget, gpointer user_data)
322 {
323 MainWindow * mw = get_window_data_struct(widget);
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);
337 }
338
339
340 /* delete_viewer deletes the selected viewer in the current tab
341 */
342
343 void delete_viewer(GtkWidget * widget, gpointer user_data)
344 {
345 MainWindow * mw = get_window_data_struct(widget);
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);
359 }
360
361
362 /* open_traceset will open a traceset saved in a file
363 * Right now, it is not finished yet, (not working)
364 * FIXME
365 */
366
367 void open_traceset(GtkWidget * widget, gpointer user_data)
368 {
369 char ** dir;
370 gint id;
371 LttvTraceset * traceset;
372 MainWindow * mw_data = get_window_data_struct(widget);
373 GtkFileSelection * file_selector =
374 (GtkFileSelection *)gtk_file_selection_new("Select a traceset");
375
376 gtk_file_selection_hide_fileop_buttons(file_selector);
377
378 id = gtk_dialog_run(GTK_DIALOG(file_selector));
379 switch(id){
380 case GTK_RESPONSE_ACCEPT:
381 case GTK_RESPONSE_OK:
382 dir = gtk_file_selection_get_selections (file_selector);
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:
390 gtk_widget_destroy((GtkWidget*)file_selector);
391 break;
392 }
393
394 }
395
396
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 *
418 */
419
420
421 gboolean lttvwindow_process_pending_requests(Tab *tab)
422 {
423 unsigned max_nb_events;
424 GdkWindow * win;
425 GdkCursor * new;
426 GtkWidget* widget;
427 LttvTracesetContext *tsc;
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;
434 guint count;
435 LttvTracesetContextPosition *end_position;
436
437
438 if(tab == NULL)
439 return FALSE;
440
441 /* There is no events requests pending : we should never have been called! */
442 g_assert(g_slist_length(events_requests) != 0);
443
444 tsc = LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context);
445
446 //set the cursor to be X shape, indicating that the computer is busy in doing its job
447 new = gdk_cursor_new(GDK_X_CURSOR);
448 widget = lookup_widget(tab->mw->mwindow, "MToolbar1");
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);
454
455 g_debug("SIZE events req len : %d", g_slist_length(events_requests));
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 ) {
464
465 /* list in is empty, need a seek */
466 {
467 /* 1.1 Add requests to list_in */
468 GSList *ltime = NULL;
469 GSList *lpos = NULL;
470 GSList *iter = NULL;
471
472 /* 1.1.1 Find all time requests with the lowest start time in list_out
473 * (ltime)
474 */
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)) {
478 /* Find all time requests with the lowest start time in list_out */
479 guint index_ltime = g_array_index(ltime, guint, 0);
480 EventsRequest *event_request_ltime = (EventsRequest*)g_slist_nth_data(ltime, 0);
481 EventsRequest *event_request_list_out = (EventsRequest*)iter->data;
482
483 int comp;
484 comp = ltt_time_compare(event_request_ltime->start_time,
485 event_request_list_out->start_time);
486 if(comp == 0)
487 ltime = g_slist_append(ltime, event_request_list_out);
488 else if(comp > 0) {
489 /* Remove all elements from ltime, and add current */
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);
493 }
494 }
495
496 /* 1.1.2 Find all position requests with the lowest position in list_out
497 * (lpos)
498 */
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)) {
502 /* Find all position requests with the lowest position in list_out */
503 guint index_lpos = g_array_index(lpos, guint, 0);
504 EventsRequest *event_request_lpos = (EventsRequest*)g_slist_nth_data(lpos, 0);
505 EventsRequest *event_request_list_out = (EventsRequest*)iter->data;
506
507 int comp;
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,
513 event_request_list_out->start_position);
514 } else {
515 comp = -1;
516 }
517 if(comp == 0)
518 lpos = g_slist_append(lpos, event_request_list_out);
519 else if(comp > 0) {
520 /* Remove all elements from lpos, and add current */
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);
524 }
525 }
526
527 /* 1.1.3 If lpos.start time < ltime */
528 {
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;
532
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 }
551 }
552 } else {
553 /* 1.1.4 (lpos.start time >= ltime) */
554 /* Add ltime to list_in, remove them from list_out */
555
556 for(iter=ltime;iter!=NULL;iter=g_slist_next(iter)) {
557 /* Add to list_in */
558 EventsRequest *event_request_ltime =
559 (EventsRequest*)iter->data;
560
561 g_slist_append(list_in, event_request_ltime);
562 /* Remove from list_out */
563 g_slist_remove(list_out, event_request_ltime);
564 }
565 }
566 }
567 g_slist_free(lpos);
568 g_slist_free(ltime);
569 }
570
571 /* 1.2 Seek */
572 {
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);
576
577 /* 1.2.1 If first request in list_in is a time request */
578 if(events_request->start_position == NULL) {
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);
584 } else {
585 /* Else, the first request in list_in is a position request */
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 }
593 }
594 }
595
596 /* 1.3 Add hooks and call before request for all list_in members */
597 {
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,
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 */
622 GSList *iter = NULL;
623 tfc = lttv_traceset_context_get_current_tfc(tsc);
624
625 /* 2.1 For each req of list_out */
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,
657 events_request->event,
658 events_request->event_by_id);
659 }
660 }
661 }
662
663 /* 3. Find end criterions */
664 {
665 /* 3.1 End time */
666 GSList *iter;
667
668 /* 3.1.1 Find lowest end time in list_in */
669 g_assert(g_slist_length(list_in)>0);
670 end_time = ((EventsRequest*)g_slist_nth_data(list_in,0))->end_time;
671
672 for(iter=g_slist_nth(list_in,1);iter!=NULL;iter=g_slist_next(iter)) {
673 EventsRequest *events_request = (EventsRequest*)iter->data;
674
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 */
681 for(iter=list_out;iter!=NULL;iter=g_slist_next(iter)) {
682 EventsRequest *events_request = (EventsRequest*)iter->data;
683
684 if(ltt_time_compare(events_request->start_time,
685 end_time) < 0)
686 end_time = events_request->start_time;
687 }
688 }
689
690 {
691 /* 3.2 Number of events */
692
693 /* 3.2.1 Find lowest number of events in list_in */
694 GSList *iter;
695
696 end_nb_events = ((EventsRequest*)g_slist_nth_data(list_in,0))->num_events;
697
698 for(iter=g_slist_nth(list_in,1);iter!=NULL;iter=g_slist_next(iter)) {
699 EventsRequest *events_request = (EventsRequest*)iter->data;
700
701 if(events_request->num_events < end_nb_events)
702 end_nb_events = events_request->num_events;
703 }
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);
709 }
710
711 {
712 /* 3.3 End position */
713
714 /* 3.3.1 Find lowest end position in list_in */
715 GSList *iter;
716
717 end_position =((EventsRequest*)g_slist_nth_data(list_in,0))->end_position;
718
719 for(iter=g_slist_nth(list_in,1);iter!=NULL;iter=g_slist_next(iter)) {
720 EventsRequest *events_request = (EventsRequest*)iter->data;
721
722 if(events_request->end_position != NULL && end_position != NULL &&
723 lttv_traceset_context_pos_pos_compare(events_request->end_position,
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 */
731 GSList *iter;
732
733 for(iter=list_out;iter!=NULL;iter=g_slist_next(iter)) {
734 EventsRequest *events_request = (EventsRequest*)iter->data;
735
736 if(events_request->end_position != NULL && end_position != NULL &&
737 lttv_traceset_context_pos_pos_compare(events_request->end_position,
738 end_position) <0)
739 end_position = events_request->end_position;
740 }
741 }
742
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);
811
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 }
861 }
862
863 /* B. When interrupted between chunks */
864
865 {
866 GSList *iter = list_in;
867
868 /* 1. for each request in list_in */
869 while(iter != NULL) {
870
871 gboolean remove = FALSE;
872 gboolean free_data = FALSE;
873 EventsRequest *events_request = (EventsRequest *)iter->data;
874
875 /* 1.1. Use current postition as start position */
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();
879 lttv_traceset_context_position_save(tsc, events_request->start_position);
880
881 /* 1.2. Remove start time */
882 events_request->start_time.tv_sec = G_MAXUINT;
883 events_request->start_time.tv_nsec = G_MAXUINT;
884
885 /* 1.3. Move from list_in to list_out */
886 remove = TRUE;
887 free_data = FALSE;
888 list_out = g_slist_append(list_out, events_request);
889
890 /* Go to next */
891 if(remove)
892 {
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);
900 }
901 }
902
903
904 }
905
906 //set the cursor back to normal
907 gdk_window_set_cursor(win, NULL);
908
909
910 g_assert(g_slist_length(list_in) == 0);
911 if( g_slist_length(list_out) == 0 ) {
912 /* Put tab's request pending flag back to normal */
913 tab->events_request_pending = FALSE;
914 return FALSE; /* Remove the idle function */
915 }
916 return TRUE; /* Leave the idle function */
917 }
918
919
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
926 void add_trace_into_traceset_selector(GtkMultiVPaned * paned, LttTrace * t)
927 {
928 int j, k, m, nb_tracefile, nb_control, nb_per_cpu, nb_facility, nb_event;
929 LttvTracesetSelector * s;
930 LttvTraceSelector * trace;
931 LttvTracefileSelector * tracefile;
932 LttvEventtypeSelector * eventtype;
933 LttTracefile * tf;
934 GtkWidget * w;
935 LttFacility * fac;
936 LttEventType * et;
937
938 w = gtk_multi_vpaned_get_first_widget(paned);
939 while(w){
940 s = g_object_get_data(G_OBJECT(w), "Traceset_Selector");
941
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");
971
972 w = gtk_multi_vpaned_get_next_widget(paned);
973 }
974 }
975
976
977 static void lttvwindow_add_trace(Tab *tab, LttvTrace *trace_v)
978 {
979 LttvTraceset *traceset = tab->traceset_info->traceset;
980 guint i;
981
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
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);
1006 lttv_trace_ref(trace_v); /* local ref */
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
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
1033 void add_trace(GtkWidget * widget, gpointer user_data)
1034 {
1035 LttTrace *trace;
1036 LttvTrace * trace_v;
1037 LttvTraceset * traceset;
1038 const char * dir;
1039 char abs_path[PATH_MAX];
1040 gint id;
1041 gint i;
1042 MainWindow * mw_data = get_window_data_struct(widget);
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 }
1054
1055 GtkDirSelection * file_selector = (GtkDirSelection *)gtk_dir_selection_new("Select a trace");
1056 gtk_dir_selection_hide_fileop_buttons(file_selector);
1057
1058 if(remember_trace_dir[0] != '\0')
1059 gtk_dir_selection_set_filename(file_selector, remember_trace_dir);
1060
1061 id = gtk_dialog_run(GTK_DIALOG(file_selector));
1062 switch(id){
1063 case GTK_RESPONSE_ACCEPT:
1064 case GTK_RESPONSE_OK:
1065 dir = gtk_dir_selection_get_dir (file_selector);
1066 strncpy(remember_trace_dir, dir, PATH_MAX);
1067 if(!dir || strlen(dir) == 0){
1068 gtk_widget_destroy((GtkWidget*)file_selector);
1069 break;
1070 }
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);
1075 if(trace == NULL) g_critical("cannot open trace %s", abs_path);
1076 trace_v = lttv_trace_new(trace);
1077 lttvwindowtraces_add_trace(trace_v);
1078 }
1079
1080 lttvwindow_add_trace(tab, trace_v);
1081
1082 gtk_widget_destroy((GtkWidget*)file_selector);
1083
1084 //update current tab
1085 //update_traceset(mw_data);
1086
1087 /* Call the updatetraceset hooks */
1088
1089 traceset = tab->traceset_info->traceset;
1090 SetTraceset(tab, traceset);
1091 // in expose now call_pending_read_hooks(mw_data);
1092
1093 //lttvwindow_report_current_time(mw_data,&(tab->current_time));
1094 break;
1095 case GTK_RESPONSE_REJECT:
1096 case GTK_RESPONSE_CANCEL:
1097 default:
1098 gtk_widget_destroy((GtkWidget*)file_selector);
1099 break;
1100 }
1101 }
1102
1103
1104 /* remove_trace_into_traceset_selector, each instance of a viewer has an associated
1105 * selector (filter), when a trace is remove from traceset, the selector should
1106 * reflect the change. The function is used to update the selector
1107 */
1108
1109 void remove_trace_from_traceset_selector(GtkMultiVPaned * paned, unsigned i)
1110 {
1111 LttvTracesetSelector * s;
1112 LttvTraceSelector * t;
1113 GtkWidget * w;
1114
1115 w = gtk_multi_vpaned_get_first_widget(paned);
1116 while(w){
1117 s = g_object_get_data(G_OBJECT(w), "Traceset_Selector");
1118 if(s){
1119 t = lttv_traceset_selector_trace_get(s,i);
1120 lttv_traceset_selector_trace_remove(s, i);
1121 lttv_trace_selector_destroy(t);
1122 }g_warning("Module dose not support filtering\n");
1123 w = gtk_multi_vpaned_get_next_widget(paned);
1124 }
1125 }
1126
1127
1128 /* remove_trace removes a trace from the current traceset if all viewers in
1129 * the current tab are not interested in the trace. It first displays a
1130 * dialogue, which shows all traces in the current traceset, to let user choose
1131 * a trace, then it checks if all viewers unselect the trace, if it is true,
1132 * it will remove the trace, recreate the traceset_contex,
1133 * and redraws all the viewer of the current tab. If there is on trace in the
1134 * current traceset, it will delete all viewers of the current tab
1135 */
1136
1137 void remove_trace(GtkWidget * widget, gpointer user_data)
1138 {
1139 LttTrace *trace;
1140 LttvTrace * trace_v;
1141 LttvTraceset * traceset;
1142 gint i, j, nb_trace;
1143 char ** name, *remove_trace_name;
1144 MainWindow * mw_data = get_window_data_struct(widget);
1145 LttvTracesetSelector * s;
1146 LttvTraceSelector * t;
1147 GtkWidget * w;
1148 gboolean selected;
1149 GtkWidget * notebook = lookup_widget(widget, "MNotebook");
1150
1151 GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
1152 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
1153 Tab *tab;
1154
1155 if(!page) {
1156 return;
1157 } else {
1158 tab = (Tab *)g_object_get_data(G_OBJECT(page), "Tab_Info");
1159 }
1160
1161 nb_trace =lttv_traceset_number(tab->traceset_info->traceset);
1162 name = g_new(char*,nb_trace);
1163 for(i = 0; i < nb_trace; i++){
1164 trace_v = lttv_traceset_get(tab->traceset_info->traceset, i);
1165 trace = lttv_trace(trace_v);
1166 name[i] = ltt_trace_name(trace);
1167 }
1168
1169 remove_trace_name = get_remove_trace(name, nb_trace);
1170
1171 if(remove_trace_name){
1172 for(i=0; i<nb_trace; i++){
1173 if(strcmp(remove_trace_name,name[i]) == 0){
1174 //unselect the trace from the current viewer
1175 w = gtk_multi_vpaned_get_widget(tab->multi_vpaned);
1176 if(w){
1177 s = g_object_get_data(G_OBJECT(w), "Traceset_Selector");
1178 if(s){
1179 t = lttv_traceset_selector_trace_get(s,i);
1180 lttv_trace_selector_set_selected(t, FALSE);
1181 }
1182
1183 //check if other viewers select the trace
1184 w = gtk_multi_vpaned_get_first_widget(tab->multi_vpaned);
1185 while(w){
1186 s = g_object_get_data(G_OBJECT(w), "Traceset_Selector");
1187 if(s){
1188 t = lttv_traceset_selector_trace_get(s,i);
1189 selected = lttv_trace_selector_get_selected(t);
1190 if(selected)break;
1191 }
1192 w = gtk_multi_vpaned_get_next_widget(tab->multi_vpaned);
1193 }
1194 }else selected = FALSE;
1195
1196 //if no viewer selects the trace, remove it
1197 if(!selected){
1198 remove_trace_from_traceset_selector(tab->multi_vpaned, i);
1199
1200 traceset = tab->traceset_info->traceset;
1201 //Keep a reference to the traces so they are not freed.
1202 for(j=0; j<lttv_traceset_number(traceset); j++)
1203 {
1204 LttvTrace * trace = lttv_traceset_get(traceset, j);
1205 lttv_trace_ref(trace);
1206 }
1207
1208 //remove state update hooks
1209 lttv_state_remove_event_hooks(
1210 (LttvTracesetState*)tab->traceset_info->traceset_context);
1211 lttv_context_fini(LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context));
1212 g_object_unref(tab->traceset_info->traceset_context);
1213
1214
1215 trace_v = lttv_traceset_get(traceset, i);
1216
1217 if(lttv_trace_get_ref_number(trace_v) <= 2) {
1218 /* ref 2 : traceset, local */
1219 lttvwindowtraces_remove_trace(trace_v);
1220 ltt_trace_close(lttv_trace(trace_v));
1221 }
1222
1223 lttv_traceset_remove(traceset, i);
1224 lttv_trace_unref(trace_v); // Remove local reference
1225
1226 if(!lttv_trace_get_ref_number(trace_v))
1227 lttv_trace_destroy(trace_v);
1228
1229 tab->traceset_info->traceset_context =
1230 g_object_new(LTTV_TRACESET_STATS_TYPE, NULL);
1231 lttv_context_init(
1232 LTTV_TRACESET_CONTEXT(tab->
1233 traceset_info->traceset_context),traceset);
1234 //add state update hooks
1235 lttv_state_add_event_hooks(
1236 (LttvTracesetState*)tab->traceset_info->traceset_context);
1237
1238 //Remove local reference to the traces.
1239 for(j=0; j<lttv_traceset_number(traceset); j++)
1240 {
1241 LttvTrace * trace = lttv_traceset_get(traceset, j);
1242 lttv_trace_unref(trace);
1243 }
1244
1245
1246 //update current tab
1247 //update_traceset(mw_data);
1248 if(nb_trace > 1){
1249
1250 SetTraceset(mw_data, (gpointer)traceset);
1251 // in expose now call_pending_read_hooks(mw_data);
1252
1253 //lttvwindow_report_current_time(mw_data,&(tab->current_time));
1254 }else{
1255 if(tab){
1256 while(tab->multi_vpaned->num_children){
1257 gtk_multi_vpaned_widget_delete(tab->multi_vpaned);
1258 }
1259 }
1260 }
1261 }
1262 break;
1263 }
1264 }
1265 }
1266
1267 g_free(name);
1268 }
1269
1270
1271 /* Redraw all the viewers in the current tab */
1272 void redraw(GtkWidget *widget, gpointer user_data)
1273 {
1274 GtkWidget * notebook = lookup_widget(widget, "MNotebook");
1275 GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
1276 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
1277 Tab *tab;
1278 if(!page) {
1279 return;
1280 } else {
1281 tab = (Tab *)g_object_get_data(G_OBJECT(page), "Tab_Info");
1282 }
1283
1284 LttvHooks * tmp;
1285 LttvAttributeValue value;
1286
1287 g_assert(lttv_iattribute_find_by_path(tab->attributes, "hooks/redraw", LTTV_POINTER, &value));
1288
1289 tmp = (LttvHooks*)*(value.v_pointer);
1290 if(tmp != NULL)
1291 lttv_hooks_call(tmp,NULL);
1292 }
1293
1294
1295 void continue_processing(GtkWidget *widget, gpointer user_data)
1296 {
1297 GtkWidget * notebook = lookup_widget(widget, "MNotebook");
1298 GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
1299 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
1300 Tab *tab;
1301 if(!page) {
1302 return;
1303 } else {
1304 tab = (Tab *)g_object_get_data(G_OBJECT(page), "Tab_Info");
1305 }
1306
1307 LttvHooks * tmp;
1308 LttvAttributeValue value;
1309
1310 g_assert(lttv_iattribute_find_by_path(tab->attributes,
1311 "hooks/continue", LTTV_POINTER, &value));
1312
1313 tmp = (LttvHooks*)*(value.v_pointer);
1314 if(tmp != NULL)
1315 lttv_hooks_call(tmp,NULL);
1316 }
1317
1318 /* Stop the processing for the calling main window's current tab.
1319 * It removes every processing requests that are in its list. It does not call
1320 * the end request hooks, because the request is not finished.
1321 */
1322
1323 void stop_processing(GtkWidget *widget, gpointer user_data)
1324 {
1325 GtkWidget * notebook = lookup_widget(widget, "MNotebook");
1326 GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
1327 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
1328 Tab *tab;
1329 if(!page) {
1330 return;
1331 } else {
1332 tab = (Tab *)g_object_get_data(G_OBJECT(page), "Tab_Info");
1333 }
1334 GSList *events_requests = tab->events_requests;
1335
1336 GSList *iter = events_requests;
1337
1338 while(iter != NULL) {
1339 GSList *remove_iter = iter;
1340 iter = g_slist_next(iter);
1341
1342 g_free(remove_iter->data);
1343 events_requests = g_slist_remove_link(events_requests, remove_iter);
1344 }
1345 g_assert(g_slist_length(events_requests) == 0);
1346 }
1347
1348
1349 /* save will save the traceset to a file
1350 * Not implemented yet FIXME
1351 */
1352
1353 void save(GtkWidget * widget, gpointer user_data)
1354 {
1355 g_printf("Save\n");
1356 }
1357
1358 void save_as(GtkWidget * widget, gpointer user_data)
1359 {
1360 g_printf("Save as\n");
1361 }
1362
1363
1364 /* zoom will change the time_window of all the viewers of the
1365 * current tab, and redisplay them. The main functionality is to
1366 * determine the new time_window of the current tab
1367 */
1368
1369 void zoom(GtkWidget * widget, double size)
1370 {
1371 TimeInterval *time_span;
1372 TimeWindow new_time_window;
1373 LttTime current_time, time_delta, time_s, time_e, time_tmp;
1374 MainWindow * mw_data = get_window_data_struct(widget);
1375 LttvTracesetContext *tsc;
1376 GtkWidget * notebook = lookup_widget(widget, "MNotebook");
1377
1378 GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
1379 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
1380 Tab *tab;
1381
1382 if(!page) {
1383 return;
1384 } else {
1385 tab = (Tab *)g_object_get_data(G_OBJECT(page), "Tab_Info");
1386 }
1387
1388 if(size == 1) return;
1389
1390 tsc = LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context);
1391 time_span = &tsc->time_span;
1392 new_time_window = tab->time_window;
1393 current_time = tab->current_time;
1394
1395 time_delta = ltt_time_sub(time_span->end_time,time_span->start_time);
1396 if(size == 0){
1397 new_time_window.start_time = time_span->start_time;
1398 new_time_window.time_width = time_delta;
1399 }else{
1400 new_time_window.time_width = ltt_time_div(new_time_window.time_width, size);
1401 if(ltt_time_compare(new_time_window.time_width,time_delta) > 0)
1402 { /* Case where zoom out is bigger than trace length */
1403 new_time_window.start_time = time_span->start_time;
1404 new_time_window.time_width = time_delta;
1405 }
1406 else
1407 {
1408 /* Center the image on the current time */
1409 g_critical("update is HERE");
1410 new_time_window.start_time =
1411 ltt_time_sub(current_time, ltt_time_div(new_time_window.time_width, 2.0));
1412 /* If on borders, don't fall off */
1413 if(ltt_time_compare(new_time_window.start_time, time_span->start_time) <0)
1414 {
1415 new_time_window.start_time = time_span->start_time;
1416 }
1417 else
1418 {
1419 if(ltt_time_compare(
1420 ltt_time_add(new_time_window.start_time, new_time_window.time_width),
1421 time_span->end_time) > 0)
1422 {
1423 new_time_window.start_time =
1424 ltt_time_sub(time_span->end_time, new_time_window.time_width);
1425 }
1426 }
1427
1428 }
1429
1430
1431
1432 //time_tmp = ltt_time_div(new_time_window.time_width, 2);
1433 //if(ltt_time_compare(current_time, time_tmp) < 0){
1434 // time_s = time_span->startTime;
1435 //} else {
1436 // time_s = ltt_time_sub(current_time,time_tmp);
1437 //}
1438 //time_e = ltt_time_add(current_time,time_tmp);
1439 //if(ltt_time_compare(time_span->startTime, time_s) > 0){
1440 // time_s = time_span->startTime;
1441 //}else if(ltt_time_compare(time_span->endTime, time_e) < 0){
1442 // time_e = time_span->endTime;
1443 // time_s = ltt_time_sub(time_e,new_time_window.time_width);
1444 //}
1445 //new_time_window.start_time = time_s;
1446 }
1447
1448 //lttvwindow_report_time_window(mw_data, &new_time_window);
1449 //call_pending_read_hooks(mw_data);
1450
1451 //lttvwindow_report_current_time(mw_data,&(tab->current_time));
1452 set_time_window(tab, &new_time_window);
1453 // in expose now call_pending_read_hooks(mw_data);
1454 gtk_multi_vpaned_set_adjust(tab->multi_vpaned, &new_time_window, FALSE);
1455 }
1456
1457 void zoom_in(GtkWidget * widget, gpointer user_data)
1458 {
1459 zoom(widget, 2);
1460 }
1461
1462 void zoom_out(GtkWidget * widget, gpointer user_data)
1463 {
1464 zoom(widget, 0.5);
1465 }
1466
1467 void zoom_extended(GtkWidget * widget, gpointer user_data)
1468 {
1469 zoom(widget, 0);
1470 }
1471
1472 void go_to_time(GtkWidget * widget, gpointer user_data)
1473 {
1474 g_printf("Go to time\n");
1475 }
1476
1477 void show_time_frame(GtkWidget * widget, gpointer user_data)
1478 {
1479 g_printf("Show time frame\n");
1480 }
1481
1482
1483 /* callback function */
1484
1485 void
1486 on_empty_traceset_activate (GtkMenuItem *menuitem,
1487 gpointer user_data)
1488 {
1489 create_new_window((GtkWidget*)menuitem, user_data, FALSE);
1490 }
1491
1492
1493 void
1494 on_clone_traceset_activate (GtkMenuItem *menuitem,
1495 gpointer user_data)
1496 {
1497 create_new_window((GtkWidget*)menuitem, user_data, TRUE);
1498 }
1499
1500
1501 /* create_new_tab calls create_tab to construct a new tab in the main window
1502 */
1503
1504 Tab *create_new_tab(GtkWidget* widget, gpointer user_data){
1505 gchar label[PATH_MAX];
1506 MainWindow * mw_data = get_window_data_struct(widget);
1507
1508 GtkNotebook * notebook = (GtkNotebook *)lookup_widget(widget, "MNotebook");
1509 if(notebook == NULL){
1510 g_printf("Notebook does not exist\n");
1511 return NULL;
1512 }
1513 GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
1514 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
1515 Tab *copy_tab;
1516
1517 if(!page) {
1518 copy_tab = NULL;
1519 } else {
1520 copy_tab = (Tab *)g_object_get_data(G_OBJECT(page), "Tab_Info");
1521 }
1522
1523 strcpy(label,"Page");
1524 if(get_label(mw_data, label,"Get the name of the tab","Please input tab's name"))
1525 return (create_tab (mw_data, copy_tab, notebook, label));
1526 }
1527
1528 void
1529 on_tab_activate (GtkMenuItem *menuitem,
1530 gpointer user_data)
1531 {
1532 create_new_tab((GtkWidget*)menuitem, user_data);
1533 }
1534
1535
1536 void
1537 on_open_activate (GtkMenuItem *menuitem,
1538 gpointer user_data)
1539 {
1540 open_traceset((GtkWidget*)menuitem, user_data);
1541 }
1542
1543
1544 void
1545 on_close_activate (GtkMenuItem *menuitem,
1546 gpointer user_data)
1547 {
1548 MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
1549 main_window_destructor(mw_data);
1550 }
1551
1552
1553 /* remove the current tab from the main window
1554 */
1555
1556 void
1557 on_close_tab_activate (GtkMenuItem *menuitem,
1558 gpointer user_data)
1559 {
1560 gint page_num;
1561 GtkWidget * notebook;
1562 GtkWidget * page;
1563 MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
1564 notebook = lookup_widget((GtkWidget*)menuitem, "MNotebook");
1565 if(notebook == NULL){
1566 g_printf("Notebook does not exist\n");
1567 return;
1568 }
1569
1570 page_num = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
1571
1572 gtk_notebook_remove_page(GTK_NOTEBOOK(notebook), page_num);
1573
1574 }
1575
1576
1577 void
1578 on_add_trace_activate (GtkMenuItem *menuitem,
1579 gpointer user_data)
1580 {
1581 add_trace((GtkWidget*)menuitem, user_data);
1582 }
1583
1584
1585 void
1586 on_remove_trace_activate (GtkMenuItem *menuitem,
1587 gpointer user_data)
1588 {
1589 remove_trace((GtkWidget*)menuitem, user_data);
1590 }
1591
1592
1593 void
1594 on_save_activate (GtkMenuItem *menuitem,
1595 gpointer user_data)
1596 {
1597 save((GtkWidget*)menuitem, user_data);
1598 }
1599
1600
1601 void
1602 on_save_as_activate (GtkMenuItem *menuitem,
1603 gpointer user_data)
1604 {
1605 save_as((GtkWidget*)menuitem, user_data);
1606 }
1607
1608
1609 void
1610 on_quit_activate (GtkMenuItem *menuitem,
1611 gpointer user_data)
1612 {
1613 gtk_main_quit ();
1614 }
1615
1616
1617 void
1618 on_cut_activate (GtkMenuItem *menuitem,
1619 gpointer user_data)
1620 {
1621 g_printf("Cut\n");
1622 }
1623
1624
1625 void
1626 on_copy_activate (GtkMenuItem *menuitem,
1627 gpointer user_data)
1628 {
1629 g_printf("Copye\n");
1630 }
1631
1632
1633 void
1634 on_paste_activate (GtkMenuItem *menuitem,
1635 gpointer user_data)
1636 {
1637 g_printf("Paste\n");
1638 }
1639
1640
1641 void
1642 on_delete_activate (GtkMenuItem *menuitem,
1643 gpointer user_data)
1644 {
1645 g_printf("Delete\n");
1646 }
1647
1648
1649 void
1650 on_zoom_in_activate (GtkMenuItem *menuitem,
1651 gpointer user_data)
1652 {
1653 zoom_in((GtkWidget*)menuitem, user_data);
1654 }
1655
1656
1657 void
1658 on_zoom_out_activate (GtkMenuItem *menuitem,
1659 gpointer user_data)
1660 {
1661 zoom_out((GtkWidget*)menuitem, user_data);
1662 }
1663
1664
1665 void
1666 on_zoom_extended_activate (GtkMenuItem *menuitem,
1667 gpointer user_data)
1668 {
1669 zoom_extended((GtkWidget*)menuitem, user_data);
1670 }
1671
1672
1673 void
1674 on_go_to_time_activate (GtkMenuItem *menuitem,
1675 gpointer user_data)
1676 {
1677 go_to_time((GtkWidget*)menuitem, user_data);
1678 }
1679
1680
1681 void
1682 on_show_time_frame_activate (GtkMenuItem *menuitem,
1683 gpointer user_data)
1684 {
1685 show_time_frame((GtkWidget*)menuitem, user_data);
1686 }
1687
1688
1689 void
1690 on_move_viewer_up_activate (GtkMenuItem *menuitem,
1691 gpointer user_data)
1692 {
1693 move_up_viewer((GtkWidget*)menuitem, user_data);
1694 }
1695
1696
1697 void
1698 on_move_viewer_down_activate (GtkMenuItem *menuitem,
1699 gpointer user_data)
1700 {
1701 move_down_viewer((GtkWidget*)menuitem, user_data);
1702 }
1703
1704
1705 void
1706 on_remove_viewer_activate (GtkMenuItem *menuitem,
1707 gpointer user_data)
1708 {
1709 delete_viewer((GtkWidget*)menuitem, user_data);
1710 }
1711
1712 void
1713 on_trace_filter_activate (GtkMenuItem *menuitem,
1714 gpointer user_data)
1715 {
1716 MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
1717 LttvTracesetSelector * s;
1718 GtkWidget * w;
1719 GtkWidget * notebook = lookup_widget(GTK_WIDGET(menuitem), "MNotebook");
1720
1721 GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook),
1722 gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)));
1723 Tab *tab;
1724
1725 if(!page) {
1726 return;
1727 } else {
1728 tab = (Tab *)g_object_get_data(G_OBJECT(page), "Tab_Info");
1729 }
1730
1731 w = gtk_multi_vpaned_get_widget(tab->multi_vpaned);
1732
1733 s = g_object_get_data(G_OBJECT(w), "Traceset_Selector");
1734 if(!s){
1735 g_printf("There is no viewer yet\n");
1736 return;
1737 }
1738 if(get_filter_selection(s, "Configure trace and tracefile filter", "Select traces and tracefiles")){
1739 //FIXME report filter change
1740 //update_traceset(mw_data);
1741 //call_pending_read_hooks(mw_data);
1742 //lttvwindow_report_current_time(mw_data,&(tab->current_time));
1743 }
1744 }
1745
1746 void
1747 on_trace_facility_activate (GtkMenuItem *menuitem,
1748 gpointer user_data)
1749 {
1750 g_printf("Trace facility selector: %s\n");
1751 }
1752
1753
1754 /* Dispaly a file selection dialogue to let user select a module, then call
1755 * lttv_module_load(), finally insert tool button and menu entry in the main window
1756 * for the loaded module
1757 */
1758
1759 void
1760 on_load_module_activate (GtkMenuItem *menuitem,
1761 gpointer user_data)
1762 {
1763 char ** dir;
1764 gint id;
1765 char str[PATH_MAX], *str1;
1766 MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
1767 GtkFileSelection * file_selector = (GtkFileSelection *)gtk_file_selection_new("Select a module");
1768 if(remember_plugins_dir[0] != '\0')
1769 gtk_file_selection_set_filename(file_selector, remember_plugins_dir);
1770 gtk_file_selection_hide_fileop_buttons(file_selector);
1771
1772 str[0] = '\0';
1773 id = gtk_dialog_run(GTK_DIALOG(file_selector));
1774 switch(id){
1775 case GTK_RESPONSE_ACCEPT:
1776 case GTK_RESPONSE_OK:
1777 dir = gtk_file_selection_get_selections (file_selector);
1778 strncpy(str,dir[0],PATH_MAX);
1779 strncpy(remember_plugins_dir,dir[0],PATH_MAX);
1780 str1 = strrchr(str,'/');
1781 if(str1)str1++;
1782 else{
1783 str1 = strrchr(str,'\\');
1784 str1++;
1785 }
1786 lttv_module_require(str1, NULL);
1787 g_strfreev(dir);
1788 case GTK_RESPONSE_REJECT:
1789 case GTK_RESPONSE_CANCEL:
1790 default:
1791 gtk_widget_destroy((GtkWidget*)file_selector);
1792 break;
1793 }
1794 g_printf("Load module: %s\n", str);
1795 }
1796
1797
1798 /* Display all loaded modules, let user to select a module to unload
1799 * by calling lttv_module_unload
1800 */
1801
1802 void
1803 on_unload_module_activate (GtkMenuItem *menuitem,
1804 gpointer user_data)
1805 {
1806 int i;
1807 GPtrArray *name;
1808 char *unload_module_name;
1809 guint nb;
1810 LttvLibrary *library;
1811 LttvLibraryInfo library_info;
1812 MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
1813
1814 name = g_ptr_array_new();
1815 nb = lttv_library_number();
1816
1817 for(i=0;i<nb;i++){
1818 library = lttv_library_get(i);
1819 lttv_library_info(library, &library_info);
1820 if(library_info.load_count > 0) g_ptr_array_add(name, library_info.name);
1821 }
1822
1823 unload_module_name =get_unload_module((char **)(name->pdata), name->len);
1824
1825 if(unload_module_name){
1826 for(i=0;i<nb;i++){
1827 library = lttv_library_get(i);
1828 lttv_library_info(library, &library_info);
1829 if(strcmp(unload_module_name, library_info.name) == 0){
1830 lttv_library_unload(library);
1831 break;
1832 }
1833 }
1834 }
1835
1836 g_ptr_array_free(name, TRUE);
1837 }
1838
1839
1840 /* Display a directory dialogue to let user select a path for module searching
1841 */
1842
1843 void
1844 on_add_module_search_path_activate (GtkMenuItem *menuitem,
1845 gpointer user_data)
1846 {
1847 GtkDirSelection * file_selector = (GtkDirSelection *)gtk_dir_selection_new("Select module path");
1848 const char * dir;
1849 gint id;
1850
1851 MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem);
1852 if(remember_plugins_dir[0] != '\0')
1853 gtk_dir_selection_set_filename(file_selector, remember_plugins_dir);
1854
1855 id = gtk_dialog_run(GTK_DIALOG(file_selector));
1856 switch(id){
1857 case GTK_RESPONSE_ACCEPT:
1858 case GTK_RESPONSE_OK:
1859 dir = gtk_dir_selection_get_dir (file_selector);
1860 strncpy(remember_plugins_dir,dir,PATH_MAX);
1861 strncat(remember_plugins_dir,"/",PATH_MAX);
1862 lttv_library_path_add(dir);
1863 case GTK_RESPONSE_REJECT:
1864 case GTK_RESPONSE_CANCEL:
1865 default:
1866 gtk_widget_destroy((GtkWidget*)file_selector);
1867 break;
1868 }
1869 }
1870
1871
1872 void
1873 on_color_activate (GtkMenuItem *menuitem,
1874 gpointer user_data)
1875 {
1876 g_printf("Color\n");
1877 }
1878
1879
1880 void
1881 on_filter_activate (GtkMenuItem *menuitem,
1882 gpointer user_data)
1883 {
1884 g_printf("Filter\n");
1885 }
1886
1887
1888 void
1889 on_save_configuration_activate (GtkMenuItem *menuitem,
1890 gpointer user_data)
1891 {
1892 g_printf("Save configuration\n");
1893 }
1894
1895
1896 void
1897 on_content_activate (GtkMenuItem *menuitem,
1898 gpointer user_data)
1899 {
1900 g_printf("Content\n");
1901 }
1902
1903
1904 void
1905 on_about_activate (GtkMenuItem *menuitem,
1906 gpointer user_data)
1907 {
1908 g_printf("About...\n");
1909 }
1910
1911
1912 void
1913 on_button_new_clicked (GtkButton *button,
1914 gpointer user_data)
1915 {
1916 create_new_window((GtkWidget*)button, user_data, TRUE);
1917 }
1918
1919 void
1920 on_button_new_tab_clicked (GtkButton *button,
1921 gpointer user_data)
1922 {
1923 create_new_tab((GtkWidget*)button, user_data);
1924 }
1925
1926 void
1927 on_button_open_clicked (GtkButton *button,
1928 gpointer user_data)
1929 {
1930 open_traceset((GtkWidget*)button, user_data);
1931 }
1932
1933
1934 void
1935 on_button_add_trace_clicked (GtkButton *button,
1936 gpointer user_data)
1937 {
1938 add_trace((GtkWidget*)button, user_data);
1939 }
1940
1941
1942 void
1943 on_button_remove_trace_clicked (GtkButton *button,
1944 gpointer user_data)
1945 {
1946 remove_trace((GtkWidget*)button, user_data);
1947 }
1948
1949 void
1950 on_button_redraw_clicked (GtkButton *button,
1951 gpointer user_data)
1952 {
1953 redraw((GtkWidget*)button, user_data);
1954 }
1955
1956 void
1957 on_button_continue_processing_clicked (GtkButton *button,
1958 gpointer user_data)
1959 {
1960 continue_processing((GtkWidget*)button, user_data);
1961 }
1962
1963 void
1964 on_button_stop_processing_clicked (GtkButton *button,
1965 gpointer user_data)
1966 {
1967 stop_processing((GtkWidget*)button, user_data);
1968 }
1969
1970
1971
1972 void
1973 on_button_save_clicked (GtkButton *button,
1974 gpointer user_data)
1975 {
1976 save((GtkWidget*)button, user_data);
1977 }
1978
1979
1980 void
1981 on_button_save_as_clicked (GtkButton *button,
1982 gpointer user_data)
1983 {
1984 save_as((GtkWidget*)button, user_data);
1985 }
1986
1987
1988 void
1989 on_button_zoom_in_clicked (GtkButton *button,
1990 gpointer user_data)
1991 {
1992 zoom_in((GtkWidget*)button, user_data);
1993 }
1994
1995
1996 void
1997 on_button_zoom_out_clicked (GtkButton *button,
1998 gpointer user_data)
1999 {
2000 zoom_out((GtkWidget*)button, user_data);
2001 }
2002
2003
2004 void
2005 on_button_zoom_extended_clicked (GtkButton *button,
2006 gpointer user_data)
2007 {
2008 zoom_extended((GtkWidget*)button, user_data);
2009 }
2010
2011
2012 void
2013 on_button_go_to_time_clicked (GtkButton *button,
2014 gpointer user_data)
2015 {
2016 go_to_time((GtkWidget*)button, user_data);
2017 }
2018
2019
2020 void
2021 on_button_show_time_frame_clicked (GtkButton *button,
2022 gpointer user_data)
2023 {
2024 show_time_frame((GtkWidget*)button, user_data);
2025 }
2026
2027
2028 void
2029 on_button_move_up_clicked (GtkButton *button,
2030 gpointer user_data)
2031 {
2032 move_up_viewer((GtkWidget*)button, user_data);
2033 }
2034
2035
2036 void
2037 on_button_move_down_clicked (GtkButton *button,
2038 gpointer user_data)
2039 {
2040 move_down_viewer((GtkWidget*)button, user_data);
2041 }
2042
2043
2044 void
2045 on_button_delete_viewer_clicked (GtkButton *button,
2046 gpointer user_data)
2047 {
2048 delete_viewer((GtkWidget*)button, user_data);
2049 }
2050
2051 void
2052 on_MWindow_destroy (GtkWidget *widget,
2053 gpointer user_data)
2054 {
2055 MainWindow *main_window = get_window_data_struct(widget);
2056 LttvIAttribute *attributes = main_window->attributes;
2057 LttvAttributeValue value;
2058
2059 //This is unnecessary, since widgets will be destroyed
2060 //by the main window widget anyway.
2061 //remove_all_menu_toolbar_constructors(main_window, NULL);
2062
2063 g_assert(lttv_iattribute_find_by_path(attributes,
2064 "viewers/menu", LTTV_POINTER, &value));
2065 lttv_menus_destroy((LttvMenus*)*(value.v_pointer));
2066
2067 g_assert(lttv_iattribute_find_by_path(attributes,
2068 "viewers/toolbar", LTTV_POINTER, &value));
2069 lttv_toolbars_destroy((LttvToolbars*)*(value.v_pointer));
2070
2071 g_object_unref(main_window->attributes);
2072 g_main_window_list = g_slist_remove(g_main_window_list, main_window);
2073
2074 g_printf("There are now : %d windows\n",g_slist_length(g_main_window_list));
2075 if(g_slist_length(g_main_window_list) == 0)
2076 gtk_main_quit ();
2077 }
2078
2079 gboolean
2080 on_MWindow_configure (GtkWidget *widget,
2081 GdkEventConfigure *event,
2082 gpointer user_data)
2083 {
2084 MainWindow * mw_data = get_window_data_struct((GtkWidget*)widget);
2085 float width = event->width;
2086 TimeWindow time_win;
2087 double ratio;
2088 TimeInterval *time_span;
2089 LttTime time;
2090
2091 // MD : removed time width modification upon resizing of the main window.
2092 // The viewers will redraw themselves completely, without time interval
2093 // modification.
2094 /* while(tab){
2095 if(mw_data->window_width){
2096 time_span = LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->Time_Span ;
2097 time_win = tab->time_window;
2098 ratio = width / mw_data->window_width;
2099 tab->time_window.time_width = ltt_time_mul(time_win.time_width,ratio);
2100 time = ltt_time_sub(time_span->endTime, time_win.start_time);
2101 if(ltt_time_compare(time, tab->time_window.time_width) < 0){
2102 tab->time_window.time_width = time;
2103 }
2104 }
2105 tab = tab->next;
2106 }
2107
2108 mw_data->window_width = (int)width;
2109 */
2110 return FALSE;
2111 }
2112
2113 /* Set current tab
2114 */
2115
2116 void
2117 on_MNotebook_switch_page (GtkNotebook *notebook,
2118 GtkNotebookPage *page,
2119 guint page_num,
2120 gpointer user_data)
2121 {
2122
2123 }
2124
2125
2126 /* callback function to check or uncheck the check box (filter)
2127 */
2128
2129 void checkbox_changed(GtkTreeView *treeview,
2130 GtkTreePath *arg1,
2131 GtkTreeViewColumn *arg2,
2132 gpointer user_data)
2133 {
2134 GtkTreeStore * store = (GtkTreeStore *)gtk_tree_view_get_model (treeview);
2135 GtkTreeIter iter;
2136 gboolean value;
2137
2138 if (gtk_tree_model_get_iter ((GtkTreeModel *)store, &iter, arg1)){
2139 gtk_tree_model_get ((GtkTreeModel *)store, &iter, CHECKBOX_COLUMN, &value, -1);
2140 value = value? FALSE : TRUE;
2141 gtk_tree_store_set (GTK_TREE_STORE (store), &iter, CHECKBOX_COLUMN, value, -1);
2142 }
2143
2144 }
2145
2146
2147 /* According to user's selection, update selector(filter)
2148 */
2149
2150 void update_filter(LttvTracesetSelector *s, GtkTreeStore *store )
2151 {
2152 GtkTreeIter iter, child_iter, child_iter1, child_iter2;
2153 int i, j, k, nb_eventtype;
2154 LttvTraceSelector * trace;
2155 LttvTracefileSelector * tracefile;
2156 LttvEventtypeSelector * eventtype;
2157 gboolean value, value1, value2;
2158
2159 if(gtk_tree_model_get_iter_first((GtkTreeModel*)store, &iter)){
2160 i = 0;
2161 do{
2162 trace = lttv_traceset_selector_trace_get(s, i);
2163 nb_eventtype = lttv_trace_selector_eventtype_number(trace);
2164 gtk_tree_model_get ((GtkTreeModel*)store, &iter, CHECKBOX_COLUMN, &value,-1);
2165 if(value){
2166 j = 0;
2167 if(gtk_tree_model_iter_children ((GtkTreeModel*)store, &child_iter, &iter)){
2168 do{
2169 if(j<1){//eventtype selector for trace
2170 gtk_tree_model_get ((GtkTreeModel*)store, &child_iter, CHECKBOX_COLUMN, &value2,-1);
2171 if(value2){
2172 k=0;
2173 if(gtk_tree_model_iter_children ((GtkTreeModel*)store, &child_iter1, &child_iter)){
2174 do{
2175 eventtype = lttv_trace_selector_eventtype_get(trace,k);
2176 gtk_tree_model_get ((GtkTreeModel*)store, &child_iter1, CHECKBOX_COLUMN, &value2,-1);
2177 lttv_eventtype_selector_set_selected(eventtype,value2);
2178 k++;
2179 }while(gtk_tree_model_iter_next((GtkTreeModel*)store, &child_iter1));
2180 }
2181 }
2182 }else{ //tracefile selector
2183 tracefile = lttv_trace_selector_tracefile_get(trace, j - 1);
2184 gtk_tree_model_get ((GtkTreeModel*)store, &child_iter, CHECKBOX_COLUMN, &value1,-1);
2185 lttv_tracefile_selector_set_selected(tracefile,value1);
2186 if(value1){
2187 gtk_tree_model_iter_children((GtkTreeModel*)store, &child_iter1, &child_iter); //eventtype selector
2188 gtk_tree_model_get ((GtkTreeModel*)store, &child_iter1, CHECKBOX_COLUMN, &value2,-1);
2189 if(value2){
2190 k = 0;
2191 if(gtk_tree_model_iter_children ((GtkTreeModel*)store, &child_iter2, &child_iter1)){
2192 do{//eventtype selector for tracefile
2193 eventtype = lttv_tracefile_selector_eventtype_get(tracefile,k);
2194 gtk_tree_model_get ((GtkTreeModel*)store, &child_iter2, CHECKBOX_COLUMN, &value2,-1);
2195 lttv_eventtype_selector_set_selected(eventtype,value2);
2196 k++;
2197 }while(gtk_tree_model_iter_next((GtkTreeModel*)store, &child_iter2));
2198 }
2199 }
2200 }
2201 }
2202 j++;
2203 }while(gtk_tree_model_iter_next((GtkTreeModel*)store, &child_iter));
2204 }
2205 }
2206 lttv_trace_selector_set_selected(trace,value);
2207 i++;
2208 }while(gtk_tree_model_iter_next((GtkTreeModel*)store, &iter));
2209 }
2210 }
2211
2212
2213 /* Display a dialogue showing all eventtypes and traces, let user to select the interested
2214 * eventtypes, tracefiles and traces (filter)
2215 */
2216
2217 gboolean get_filter_selection(LttvTracesetSelector *s,char *title, char * column_title)
2218 {
2219 GtkWidget * dialogue;
2220 GtkTreeStore * store;
2221 GtkWidget * tree;
2222 GtkWidget * scroll_win;
2223 GtkCellRenderer * renderer;
2224 GtkTreeViewColumn * column;
2225 GtkTreeIter iter, child_iter, child_iter1, child_iter2;
2226 int i, j, k, id, nb_trace, nb_tracefile, nb_eventtype;
2227 LttvTraceSelector * trace;
2228 LttvTracefileSelector * tracefile;
2229 LttvEventtypeSelector * eventtype;
2230 char * name;
2231 gboolean checked;
2232
2233 dialogue = gtk_dialog_new_with_buttons(title,
2234 NULL,
2235 GTK_DIALOG_MODAL,
2236 GTK_STOCK_OK,GTK_RESPONSE_ACCEPT,
2237 GTK_STOCK_CANCEL,GTK_RESPONSE_REJECT,
2238 NULL);
2239 gtk_window_set_default_size((GtkWindow*)dialogue, 300, 500);
2240
2241 store = gtk_tree_store_new (TOTAL_COLUMNS, G_TYPE_BOOLEAN, G_TYPE_STRING);
2242 tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
2243 g_object_unref (G_OBJECT (store));
2244 g_signal_connect (G_OBJECT (tree), "row-activated",
2245 G_CALLBACK (checkbox_changed),
2246 NULL);
2247
2248
2249 renderer = gtk_cell_renderer_toggle_new ();
2250 gtk_cell_renderer_toggle_set_radio((GtkCellRendererToggle *)renderer, FALSE);
2251
2252 g_object_set (G_OBJECT (renderer),"activatable", TRUE, NULL);
2253
2254 column = gtk_tree_view_column_new_with_attributes ("Checkbox",
2255 renderer,
2256 "active", CHECKBOX_COLUMN,
2257 NULL);
2258 gtk_tree_view_column_set_alignment (column, 0.5);
2259 gtk_tree_view_column_set_fixed_width (column, 20);
2260 gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
2261
2262 renderer = gtk_cell_renderer_text_new ();
2263 column = gtk_tree_view_column_new_with_attributes (column_title,
2264 renderer,
2265 "text", NAME_COLUMN,
2266 NULL);
2267 gtk_tree_view_column_set_alignment (column, 0.0);
2268 gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
2269 gtk_tree_view_set_headers_visible(GTK_TREE_VIEW (tree), FALSE);
2270
2271 scroll_win = gtk_scrolled_window_new (NULL, NULL);
2272 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win),
2273 GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
2274 gtk_container_add (GTK_CONTAINER (scroll_win), tree);
2275
2276 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), scroll_win,TRUE, TRUE,0);
2277
2278 gtk_widget_show(scroll_win);
2279 gtk_widget_show(tree);
2280
2281 nb_trace = lttv_traceset_selector_trace_number(s);
2282 for(i=0;i<nb_trace;i++){
2283 trace = lttv_traceset_selector_trace_get(s, i);
2284 name = lttv_trace_selector_get_name(trace);
2285 gtk_tree_store_append (store, &iter, NULL);
2286 checked = lttv_trace_selector_get_selected(trace);
2287 gtk_tree_store_set (store, &iter,
2288 CHECKBOX_COLUMN,checked,
2289 NAME_COLUMN,name,
2290 -1);
2291
2292 gtk_tree_store_append (store, &child_iter, &iter);
2293 gtk_tree_store_set (store, &child_iter,
2294 CHECKBOX_COLUMN, checked,
2295 NAME_COLUMN,"eventtype",
2296 -1);
2297
2298 nb_eventtype = lttv_trace_selector_eventtype_number(trace);
2299 for(j=0;j<nb_eventtype;j++){
2300 eventtype = lttv_trace_selector_eventtype_get(trace,j);
2301 name = lttv_eventtype_selector_get_name(eventtype);
2302 checked = lttv_eventtype_selector_get_selected(eventtype);
2303 gtk_tree_store_append (store, &child_iter1, &child_iter);
2304 gtk_tree_store_set (store, &child_iter1,
2305 CHECKBOX_COLUMN, checked,
2306 NAME_COLUMN,name,
2307 -1);
2308 }
2309
2310 nb_tracefile = lttv_trace_selector_tracefile_number(trace);
2311 for(j=0;j<nb_tracefile;j++){
2312 tracefile = lttv_trace_selector_tracefile_get(trace, j);
2313 name = lttv_tracefile_selector_get_name(tracefile);
2314 gtk_tree_store_append (store, &child_iter, &iter);
2315 checked = lttv_tracefile_selector_get_selected(tracefile);
2316 gtk_tree_store_set (store, &child_iter,
2317 CHECKBOX_COLUMN, checked,
2318 NAME_COLUMN,name,
2319 -1);
2320
2321 gtk_tree_store_append (store, &child_iter1, &child_iter);
2322 gtk_tree_store_set (store, &child_iter1,
2323 CHECKBOX_COLUMN, checked,
2324 NAME_COLUMN,"eventtype",
2325 -1);
2326
2327 for(k=0;k<nb_eventtype;k++){
2328 eventtype = lttv_tracefile_selector_eventtype_get(tracefile,k);
2329 name = lttv_eventtype_selector_get_name(eventtype);
2330 checked = lttv_eventtype_selector_get_selected(eventtype);
2331 gtk_tree_store_append (store, &child_iter2, &child_iter1);
2332 gtk_tree_store_set (store, &child_iter2,
2333 CHECKBOX_COLUMN, checked,
2334 NAME_COLUMN,name,
2335 -1);
2336 }
2337 }
2338 }
2339
2340 id = gtk_dialog_run(GTK_DIALOG(dialogue));
2341 switch(id){
2342 case GTK_RESPONSE_ACCEPT:
2343 case GTK_RESPONSE_OK:
2344 update_filter(s, store);
2345 gtk_widget_destroy(dialogue);
2346 return TRUE;
2347 case GTK_RESPONSE_REJECT:
2348 case GTK_RESPONSE_CANCEL:
2349 default:
2350 gtk_widget_destroy(dialogue);
2351 break;
2352 }
2353 return FALSE;
2354 }
2355
2356
2357 /* Select a trace which will be removed from traceset
2358 */
2359
2360 char * get_remove_trace(char ** all_trace_name, int nb_trace)
2361 {
2362 return get_selection(all_trace_name, nb_trace,
2363 "Select a trace", "Trace pathname");
2364 }
2365
2366
2367 /* Select a module which will be unloaded
2368 */
2369
2370 char * get_unload_module(char ** loaded_module_name, int nb_module)
2371 {
2372 return get_selection(loaded_module_name, nb_module,
2373 "Select an unload module", "Module pathname");
2374 }
2375
2376
2377 /* Display a dialogue which shows all selectable items, let user to
2378 * select one of them
2379 */
2380
2381 char * get_selection(char ** loaded_module_name, int nb_module,
2382 char *title, char * column_title)
2383 {
2384 GtkWidget * dialogue;
2385 GtkWidget * scroll_win;
2386 GtkWidget * tree;
2387 GtkListStore * store;
2388 GtkTreeViewColumn * column;
2389 GtkCellRenderer * renderer;
2390 GtkTreeSelection * select;
2391 GtkTreeIter iter;
2392 gint id, i;
2393 char * unload_module_name = NULL;
2394
2395 dialogue = gtk_dialog_new_with_buttons(title,
2396 NULL,
2397 GTK_DIALOG_MODAL,
2398 GTK_STOCK_OK,GTK_RESPONSE_ACCEPT,
2399 GTK_STOCK_CANCEL,GTK_RESPONSE_REJECT,
2400 NULL);
2401 gtk_window_set_default_size((GtkWindow*)dialogue, 500, 200);
2402
2403 scroll_win = gtk_scrolled_window_new (NULL, NULL);
2404 gtk_widget_show ( scroll_win);
2405 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_win),
2406 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2407
2408 store = gtk_list_store_new (N_COLUMNS,G_TYPE_STRING);
2409 tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL (store));
2410 gtk_widget_show ( tree);
2411 g_object_unref (G_OBJECT (store));
2412
2413 renderer = gtk_cell_renderer_text_new ();
2414 column = gtk_tree_view_column_new_with_attributes (column_title,
2415 renderer,
2416 "text", MODULE_COLUMN,
2417 NULL);
2418 gtk_tree_view_column_set_alignment (column, 0.5);
2419 gtk_tree_view_column_set_fixed_width (column, 150);
2420 gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
2421
2422 select = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree));
2423 gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE);
2424
2425 gtk_container_add (GTK_CONTAINER (scroll_win), tree);
2426
2427 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialogue)->vbox), scroll_win,TRUE, TRUE,0);
2428
2429 for(i=0;i<nb_module;i++){
2430 gtk_list_store_append (store, &iter);
2431 gtk_list_store_set (store, &iter, MODULE_COLUMN,loaded_module_name[i],-1);
2432 }
2433
2434 id = gtk_dialog_run(GTK_DIALOG(dialogue));
2435 switch(id){
2436 case GTK_RESPONSE_ACCEPT:
2437 case GTK_RESPONSE_OK:
2438 if (gtk_tree_selection_get_selected (select, (GtkTreeModel**)&store, &iter)){
2439 gtk_tree_model_get ((GtkTreeModel*)store, &iter, MODULE_COLUMN, &unload_module_name, -1);
2440 }
2441 case GTK_RESPONSE_REJECT:
2442 case GTK_RESPONSE_CANCEL:
2443 default:
2444 gtk_widget_destroy(dialogue);
2445 break;
2446 }
2447
2448 return unload_module_name;
2449 }
2450
2451
2452 /* Insert all menu entry and tool buttons into this main window
2453 * for modules.
2454 *
2455 */
2456
2457 void add_all_menu_toolbar_constructors(MainWindow * mw, gpointer user_data)
2458 {
2459 int i;
2460 GdkPixbuf *pixbuf;
2461 lttvwindow_viewer_constructor constructor;
2462 LttvMenus * global_menu, * instance_menu;
2463 LttvToolbars * global_toolbar, * instance_toolbar;
2464 LttvMenuClosure *menu_item;
2465 LttvToolbarClosure *toolbar_item;
2466 LttvAttributeValue value;
2467 LttvIAttribute *global_attributes = LTTV_IATTRIBUTE(lttv_global_attributes());
2468 LttvIAttribute *attributes = mw->attributes;
2469 GtkWidget * tool_menu_title_menu, *new_widget, *pixmap;
2470
2471 g_assert(lttv_iattribute_find_by_path(global_attributes,
2472 "viewers/menu", LTTV_POINTER, &value));
2473 if(*(value.v_pointer) == NULL)
2474 *(value.v_pointer) = lttv_menus_new();
2475 global_menu = (LttvMenus*)*(value.v_pointer);
2476
2477 g_assert(lttv_iattribute_find_by_path(attributes,
2478 "viewers/menu", LTTV_POINTER, &value));
2479 if(*(value.v_pointer) == NULL)
2480 *(value.v_pointer) = lttv_menus_new();
2481 instance_menu = (LttvMenus*)*(value.v_pointer);
2482
2483
2484
2485 g_assert(lttv_iattribute_find_by_path(global_attributes,
2486 "viewers/toolbar", LTTV_POINTER, &value));
2487 if(*(value.v_pointer) == NULL)
2488 *(value.v_pointer) = lttv_toolbars_new();
2489 global_toolbar = (LttvToolbars*)*(value.v_pointer);
2490
2491 g_assert(lttv_iattribute_find_by_path(attributes,
2492 "viewers/toolbar", LTTV_POINTER, &value));
2493 if(*(value.v_pointer) == NULL)
2494 *(value.v_pointer) = lttv_toolbars_new();
2495 instance_toolbar = (LttvToolbars*)*(value.v_pointer);
2496
2497 /* Add missing menu entries to window instance */
2498 for(i=0;i<global_menu->len;i++) {
2499 menu_item = &g_array_index(global_menu, LttvMenuClosure, i);
2500
2501 //add menu_item to window instance;
2502 constructor = menu_item->con;
2503 tool_menu_title_menu = lookup_widget(mw->mwindow,"ToolMenuTitle_menu");
2504 new_widget =
2505 gtk_menu_item_new_with_mnemonic (menu_item->menu_text);
2506 gtk_container_add (GTK_CONTAINER (tool_menu_title_menu),
2507 new_widget);
2508 g_signal_connect ((gpointer) new_widget, "activate",
2509 G_CALLBACK (insert_viewer_wrap),
2510 constructor);
2511 gtk_widget_show (new_widget);
2512 lttv_menus_add(instance_menu, menu_item->con,
2513 menu_item->menu_path,
2514 menu_item->menu_text,
2515 new_widget);
2516
2517 }
2518
2519 /* Add missing toolbar entries to window instance */
2520 for(i=0;i<global_toolbar->len;i++) {
2521 toolbar_item = &g_array_index(global_toolbar, LttvToolbarClosure, i);
2522
2523 //add toolbar_item to window instance;
2524 constructor = toolbar_item->con;
2525 tool_menu_title_menu = lookup_widget(mw->mwindow,"MToolbar1");
2526 pixbuf = gdk_pixbuf_new_from_xpm_data((const char**)toolbar_item->pixmap);
2527 pixmap = gtk_image_new_from_pixbuf(pixbuf);
2528 new_widget =
2529 gtk_toolbar_append_element (GTK_TOOLBAR (tool_menu_title_menu),
2530 GTK_TOOLBAR_CHILD_BUTTON,
2531 NULL,
2532 "",
2533 toolbar_item->tooltip, NULL,
2534 pixmap, NULL, NULL);
2535 gtk_label_set_use_underline(
2536 GTK_LABEL (((GtkToolbarChild*) (
2537 g_list_last (GTK_TOOLBAR
2538 (tool_menu_title_menu)->children)->data))->label),
2539 TRUE);
2540 gtk_container_set_border_width (GTK_CONTAINER (new_widget), 1);
2541 g_signal_connect ((gpointer) new_widget,
2542 "clicked",
2543 G_CALLBACK (insert_viewer_wrap),
2544 constructor);
2545 gtk_widget_show (new_widget);
2546
2547 lttv_toolbars_add(instance_toolbar, toolbar_item->con,
2548 toolbar_item->tooltip,
2549 toolbar_item->pixmap,
2550 new_widget);
2551
2552 }
2553
2554 }
2555
2556
2557 /* Create a main window
2558 */
2559
2560 void construct_main_window(MainWindow * parent)
2561 {
2562 g_debug("construct_main_window()");
2563 GtkWidget * new_window; /* New generated main window */
2564 MainWindow * new_m_window;/* New main window structure */
2565 GtkNotebook * notebook;
2566 LttvIAttribute *attributes =
2567 LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE, NULL));
2568 LttvAttributeValue value;
2569 Tab *new_tab;
2570
2571 new_m_window = g_new(MainWindow, 1);
2572
2573 // Add the object's information to the module's array
2574 g_main_window_list = g_slist_append(g_main_window_list, new_m_window);
2575
2576
2577 new_window = create_MWindow();
2578 gtk_widget_show (new_window);
2579
2580 new_m_window->mwindow = new_window;
2581 new_m_window->attributes = attributes;
2582
2583 g_assert(lttv_iattribute_find_by_path(attributes,
2584 "viewers/menu", LTTV_POINTER, &value));
2585 *(value.v_pointer) = lttv_menus_new();
2586
2587 g_assert(lttv_iattribute_find_by_path(attributes,
2588 "viewers/toolbar", LTTV_POINTER, &value));
2589 *(value.v_pointer) = lttv_toolbars_new();
2590
2591 add_all_menu_toolbar_constructors(new_m_window, NULL);
2592
2593 g_object_set_data_full(G_OBJECT(new_window),
2594 "main_window_data",
2595 (gpointer)new_m_window,
2596 (GDestroyNotify)g_free);
2597 //create a default tab
2598 notebook = (GtkNotebook *)lookup_widget(new_m_window->mwindow, "MNotebook");
2599 if(notebook == NULL){
2600 g_printf("Notebook does not exist\n");
2601 return;
2602 }
2603 //for now there is no name field in LttvTraceset structure
2604 //Use "Traceset" as the label for the default tab
2605 if(parent) {
2606 GtkWidget * parent_notebook = lookup_widget(parent->mwindow, "MNotebook");
2607 GtkWidget *page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(parent_notebook),
2608 gtk_notebook_get_current_page(GTK_NOTEBOOK(parent_notebook)));
2609 Tab *parent_tab;
2610
2611 if(!page) {
2612 parent_tab = NULL;
2613 } else {
2614 parent_tab = (Tab *)g_object_get_data(G_OBJECT(page), "Tab_Info");
2615 }
2616 new_tab = create_tab(new_m_window, parent_tab, notebook, "Traceset");
2617 } else {
2618 new_tab = create_tab(new_m_window, NULL, notebook, "Traceset");
2619 if(g_init_trace != NULL){
2620 lttvwindow_add_trace(new_tab,
2621 g_init_trace);
2622 }
2623 }
2624
2625 g_printf("There are now : %d windows\n",g_slist_length(g_main_window_list));
2626 }
2627
2628
2629 /* Free the memory occupied by a tab structure
2630 * destroy the tab
2631 */
2632
2633 void tab_destructor(Tab * tab_instance)
2634 {
2635 int i, nb, ref_count;
2636 LttvTrace * trace;
2637
2638 if(tab_instance->attributes)
2639 g_object_unref(tab_instance->attributes);
2640
2641 if(tab_instance->interrupted_state)
2642 g_object_unref(tab_instance->interrupted_state);
2643
2644
2645 if(tab_instance->traceset_info->traceset_context != NULL){
2646 //remove state update hooks
2647 lttv_state_remove_event_hooks(
2648 (LttvTracesetState*)tab_instance->traceset_info->
2649 traceset_context);
2650 lttv_context_fini(LTTV_TRACESET_CONTEXT(tab_instance->traceset_info->
2651 traceset_context));
2652 g_object_unref(tab_instance->traceset_info->traceset_context);
2653 }
2654 if(tab_instance->traceset_info->traceset != NULL) {
2655 nb = lttv_traceset_number(tab_instance->traceset_info->traceset);
2656 for(i = 0 ; i < nb ; i++) {
2657 trace = lttv_traceset_get(tab_instance->traceset_info->traceset, i);
2658 ref_count = lttv_trace_get_ref_number(trace);
2659 if(ref_count <= 1){
2660 ltt_trace_close(lttv_trace(trace));
2661 }
2662 }
2663 }
2664 lttv_traceset_destroy(tab_instance->traceset_info->traceset);
2665 /* Remove the idle events requests processing function of the tab */
2666 g_idle_remove_by_data(tab_instance);
2667
2668 g_slist_free(tab_instance->events_requests);
2669 g_free(tab_instance->traceset_info);
2670 g_free(tab_instance);
2671 }
2672
2673
2674 /* Create a tab and insert it into the current main window
2675 */
2676
2677 Tab* create_tab(MainWindow * mw, Tab *copy_tab,
2678 GtkNotebook * notebook, char * label)
2679 {
2680 GList * list;
2681 Tab * tab;
2682 LttTime tmp_time;
2683
2684 //create a new tab data structure
2685 tab = g_new(Tab,1);
2686
2687 //construct and initialize the traceset_info
2688 tab->traceset_info = g_new(TracesetInfo,1);
2689
2690 if(copy_tab) {
2691 tab->traceset_info->traceset =
2692 lttv_traceset_copy(copy_tab->traceset_info->traceset);
2693 } else {
2694 tab->traceset_info->traceset = lttv_traceset_new();
2695 }
2696
2697 //FIXME : this is g_debug level
2698 lttv_attribute_write_xml(
2699 lttv_traceset_attribute(tab->traceset_info->traceset),
2700 stdout,
2701 0, 4);
2702 fflush(stdout);
2703
2704
2705 //FIXME copy not implemented in lower level
2706 tab->traceset_info->traceset_context =
2707 g_object_new(LTTV_TRACESET_STATS_TYPE, NULL);
2708 g_assert(tab->traceset_info->traceset_context != NULL);
2709 lttv_context_init(
2710 LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context),
2711 tab->traceset_info->traceset);
2712 //add state update hooks
2713 lttv_state_add_event_hooks(
2714 (LttvTracesetState*)tab->traceset_info->traceset_context);
2715
2716 //determine the current_time and time_window of the tab
2717 if(copy_tab != NULL){
2718 tab->time_window = copy_tab->time_window;
2719 tab->current_time = copy_tab->current_time;
2720 }else{
2721 tab->time_window.start_time =
2722 LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->
2723 time_span.start_time;
2724 if(DEFAULT_TIME_WIDTH_S <
2725 LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->
2726 time_span.end_time.tv_sec)
2727 tmp_time.tv_sec = DEFAULT_TIME_WIDTH_S;
2728 else
2729 tmp_time.tv_sec =
2730 LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->
2731 time_span.end_time.tv_sec;
2732 tmp_time.tv_nsec = 0;
2733 tab->time_window.time_width = tmp_time ;
2734 tab->current_time.tv_sec =
2735 LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->
2736 time_span.start_time.tv_sec;
2737 tab->current_time.tv_nsec =
2738 LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->
2739 time_span.start_time.tv_nsec;
2740 }
2741 tab->attributes = LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE, NULL));
2742 tab->interrupted_state = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
2743 tab->multi_vpaned = (GtkMultiVPaned*)gtk_multi_vpaned_new();
2744 gtk_widget_show((GtkWidget*)tab->multi_vpaned);
2745 tab->mw = mw;
2746
2747 tab->label = gtk_label_new (label);
2748 gtk_widget_show (tab->label);
2749
2750 /* Start with empty events requests list */
2751 tab->events_requests = NULL;
2752 tab->events_request_pending = FALSE;
2753
2754 g_object_set_data_full(
2755 G_OBJECT(tab->multi_vpaned),
2756 "Tab_Info",
2757 tab,
2758 (GDestroyNotify)tab_destructor);
2759
2760 //insert tab into notebook
2761 gtk_notebook_append_page(notebook,
2762 (GtkWidget*)tab->multi_vpaned,
2763 tab->label);
2764 list = gtk_container_get_children(GTK_CONTAINER(notebook));
2765 gtk_notebook_set_current_page(notebook,g_list_length(list)-1);
2766 // always show : not if(g_list_length(list)>1)
2767 gtk_notebook_set_show_tabs(notebook, TRUE);
2768
2769 return tab;
2770 }
2771
2772 /*
2773 * execute_events_requests
2774 *
2775 * Idle function that executes the pending requests for a tab.
2776 *
2777 * @return return value : TRUE : keep the idle function, FALSE : remove it.
2778 */
2779 gboolean execute_events_requests(Tab *tab)
2780 {
2781 return ( lttvwindow_process_pending_requests(tab) );
2782 }
2783
LTTng 2.x Viewer (LTTV)
This page took 0.128077 seconds and 4 git commands to generate.