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