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