X-Git-Url: http://git.liburcu.org/?a=blobdiff_plain;f=ltt%2Fbranches%2Fpoly%2Flttv%2Fmodules%2Fgui%2Flttvwindow%2Flttvwindow%2Fcallbacks.c;h=f586cb0eca7541117f7424189160cae2f2b294e2;hb=4266dc7ffbe6bbe54435272af4f8d2bf217c9157;hp=c4568cf49498bc3af206c4b6afc7a702fa35b883;hpb=c2619a30c1b4614c45c9f54a5725680b8c931cb1;p=lttv.git diff --git a/ltt/branches/poly/lttv/modules/gui/lttvwindow/lttvwindow/callbacks.c b/ltt/branches/poly/lttv/modules/gui/lttvwindow/lttvwindow/callbacks.c index c4568cf4..f586cb0e 100644 --- a/ltt/branches/poly/lttv/modules/gui/lttvwindow/lttvwindow/callbacks.c +++ b/ltt/branches/poly/lttv/modules/gui/lttvwindow/lttvwindow/callbacks.c @@ -25,17 +25,21 @@ #include "callbacks.h" #include "interface.h" #include "support.h" +#include +#include +#include +#include #include +#include +#include +#include #include +#include #include #include -#include -#include +#include #include -#include #include -#include -#include #define PATH_LENGTH 256 #define DEFAULT_TIME_WIDTH_S 1 @@ -46,9 +50,7 @@ extern LttvTrace *g_init_trace ; /** Array containing instanced objects. */ extern GSList * g_main_window_list; -static int g_win_count = 0; - -// MD : keep old directory +/** MD : keep old directory. */ static char remember_plugins_dir[PATH_LENGTH] = ""; static char remember_trace_dir[PATH_LENGTH] = ""; @@ -58,10 +60,10 @@ char * get_unload_module(char ** loaded_module_name, int nb_module); char * get_remove_trace(char ** all_trace_name, int nb_trace); char * get_selection(char ** all_name, int nb, char *title, char * column_title); gboolean get_filter_selection(LttvTracesetSelector *s, char *title, char * column_title); -void * create_tab(MainWindow * parent, MainWindow * current_window, +void * create_tab(MainWindow * mw, Tab *copy_tab, GtkNotebook * notebook, char * label); -void insert_viewer(GtkWidget* widget, lttvwindow_viewer_constructor constructor); +static void insert_viewer(GtkWidget* widget, lttvwindow_viewer_constructor constructor); void update_filter(LttvTracesetSelector *s, GtkTreeStore *store ); void checkbox_changed(GtkTreeView *treeview, @@ -70,11 +72,11 @@ void checkbox_changed(GtkTreeView *treeview, gpointer user_data); void remove_trace_from_traceset_selector(GtkMultiVPaned * paned, unsigned i); void add_trace_into_traceset_selector(GtkMultiVPaned * paned, LttTrace * trace); +void create_new_tab(GtkWidget* widget, gpointer user_data); LttvTracesetSelector * construct_traceset_selector(LttvTraceset * traceset); -void redraw_viewer(MainWindow * mw_data, TimeWindow * time_window); -unsigned get_max_event_number(MainWindow * mw_data); +static gboolean lttvwindow_process_pending_requests(Tab *tab); enum { CHECKBOX_COLUMN, @@ -162,37 +164,31 @@ insert_viewer_wrap(GtkWidget *menuitem, gpointer user_data) void insert_viewer(GtkWidget* widget, lttvwindow_viewer_constructor constructor) { GtkMultiVPaned * multi_vpaned; - MainWindow * mw_data; + MainWindow * mw_data = get_window_data_struct(widget); GtkWidget * viewer; LttvTracesetSelector * s; TimeInterval * time_interval; - TimeWindow time_window, t; + Tab *tab = mw_data->current_tab; - mw_data = get_window_data_struct(widget); - if(!mw_data->current_tab) return; - multi_vpaned = mw_data->current_tab->multi_vpaned; + if(!tab) create_new_tab(widget, NULL); + multi_vpaned = tab->multi_vpaned; - s = construct_traceset_selector(mw_data->current_tab->traceset_info->traceset); - viewer = (GtkWidget*)constructor(mw_data, s, "Traceset_Selector"); + s = construct_traceset_selector(tab->traceset_info->traceset); + viewer = (GtkWidget*)constructor(tab, s, "Traceset_Selector"); if(viewer) { gtk_multi_vpaned_widget_add(multi_vpaned, viewer); - // Added by MD - // g_object_unref(G_OBJECT(viewer)); - - time_window = mw_data->current_tab->time_window; - time_interval = (TimeInterval*)g_object_get_data(G_OBJECT(viewer), TRACESET_TIME_SPAN); - if(time_interval){ - t = time_window; - time_window.start_time = time_interval->startTime; - time_window.time_width = ltt_time_sub(time_interval->endTime,time_interval->startTime); - } - - redraw_viewer(mw_data,&time_window); - lttvwindow_report_current_time(mw_data,&(mw_data->current_tab->current_time)); - if(time_interval){ - lttvwindow_report_time_window(mw_data,&t); - } + // We unref here, because it is now referenced by the multi_vpaned! + g_object_unref(G_OBJECT(viewer)); + + // The viewer will show itself when it receives a show notify + // So we call the show notify hooks here. It will + // typically add hooks for reading, we call process trace, and the + // end of reading hook will call gtk_widget_show and unregister the + // hooks. + // Note that show notify gets the time_requested through the call_data. + //show_viewer(mw_data); + // in expose now call_pending_read_hooks(mw_data); } } @@ -258,13 +254,13 @@ MainWindow * get_window_data_struct(GtkWidget * widget) mw = lookup_widget(widget, "MWindow"); if(mw == NULL){ g_printf("Main window does not exist\n"); - return; + return NULL; } - mw_data = (MainWindow *) g_object_get_data(G_OBJECT(mw),"mainWindow"); + mw_data = (MainWindow *) g_object_get_data(G_OBJECT(mw),"main_window_data"); if(mw_data == NULL){ g_printf("Main window data does not exist\n"); - return; + return NULL; } return mw_data; } @@ -319,6 +315,7 @@ void delete_viewer(GtkWidget * widget, gpointer user_data) /* open_traceset will open a traceset saved in a file * Right now, it is not finished yet, (not working) + * FIXME */ void open_traceset(GtkWidget * widget, gpointer user_data) @@ -351,74 +348,530 @@ void open_traceset(GtkWidget * widget, gpointer user_data) } -/* get_max_event_number returns the event number limit used by - * lttv_process_traceset(LttvTracesetContext, endTime, maxNumEvents) - * each viewer can set the limit +/* lttvwindow_process_pending_requests + * + * This internal function gets called by g_idle, taking care of the pending + * requests. It is responsible for concatenation of time intervals and position + * requests. It does it with the following algorithm organizing process traceset + * calls. Here is the detailed description of the way it works : + * + * - Events Requests Servicing Algorithm + * + * Data structures necessary : + * + * List of requests added to context : list_in + * List of requests not added to context : list_out + * + * Initial state : + * + * list_in : empty + * list_out : many events requests + * + * FIXME : insert rest of algorithm here + * */ -unsigned get_max_event_number(MainWindow * mw_data) -{ - unsigned nb = 0, *size; - GtkWidget * w; - - w = gtk_multi_vpaned_get_first_widget(mw_data->current_tab->multi_vpaned); - while(w){ - size = (unsigned*)g_object_get_data(G_OBJECT(w), MAX_NUMBER_EVENT); - if(size == NULL){ - nb = G_MAXULONG; - break; - }else{ - if(nb < *size) - nb = *size; - } - w = gtk_multi_vpaned_get_next_widget(mw_data->current_tab->multi_vpaned); - } - return nb; -} - -/* redraw_viewer parses the traceset first by calling - * process_traceset, then display all viewers of - * the current tab - */ - -void redraw_viewer(MainWindow * mw_data, TimeWindow * time_window) +gboolean lttvwindow_process_pending_requests(Tab *tab) { unsigned max_nb_events; GdkWindow * win; GdkCursor * new; GtkWidget* widget; - LttvTracesetContext *tsc = - LTTV_TRACESET_CONTEXT(mw_data->current_tab->traceset_info-> - traceset_context); + LttvTracesetContext *tsc; + LttvTracefileContext *tfc; + GSList *events_requests = tab->events_requests; + GSList *list_out = events_requests; + GSList *list_in = NULL; + LttTime end_time; + guint end_nb_events; + guint count; + LttvTracesetContextPosition *end_position; + + + /* Current tab check : if no current tab is present, no hooks to call. */ + /* (Xang Xiu) It makes the expose works.. MD:? */ + if(tab == NULL) + return FALSE; + + /* There is no events requests pending : we should never have been called! */ + g_assert(g_slist_length(events_requests) != 0); + + tsc = LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context); //set the cursor to be X shape, indicating that the computer is busy in doing its job new = gdk_cursor_new(GDK_X_CURSOR); - widget = lookup_widget(mw_data->mwindow, "MToolbar1"); + widget = lookup_widget(tab->mw->mwindow, "MToolbar1"); win = gtk_widget_get_parent_window(widget); gdk_window_set_cursor(win, new); gdk_cursor_unref(new); gdk_window_stick(win); gdk_window_unstick(win); - - //update time window of each viewer, let viewer insert hooks needed by process_traceset - lttvwindow_report_time_window(mw_data, time_window); + + g_debug("SIZE events req len : %d", g_slist_length(events_requests)); - max_nb_events = get_max_event_number(mw_data); + /* Events processing algorithm implementation */ + /* A. Servicing loop */ + while( (g_slist_length(list_in) != 0 || g_slist_length(list_out) != 0) + && !gtk_events_pending() ) { + + /* 1. If list_in is empty (need a seek) */ + if( g_slist_length(list_in) == 0 ) { + + /* list in is empty, need a seek */ + { + /* 1.1 Add requests to list_in */ + GSList *ltime = NULL; + GSList *lpos = NULL; + GSList *iter = NULL; + + /* 1.1.1 Find all time requests with the lowest start time in list_out + * (ltime) + */ + if(g_slist_length(list_out) > 0) + ltime = g_slist_append(ltime, g_slist_nth_data(list_out, 0)); + for(iter=g_slist_nth(list_out,1);iter!=NULL;iter=g_slist_next(iter)) { + /* Find all time requests with the lowest start time in list_out */ + guint index_ltime = g_array_index(ltime, guint, 0); + EventsRequest *event_request_ltime = (EventsRequest*)g_slist_nth_data(ltime, 0); + EventsRequest *event_request_list_out = (EventsRequest*)iter->data; + + int comp; + comp = ltt_time_compare(event_request_ltime->start_time, + event_request_list_out->start_time); + if(comp == 0) + ltime = g_slist_append(ltime, event_request_list_out); + else if(comp > 0) { + /* Remove all elements from ltime, and add current */ + while(ltime != NULL) + ltime = g_slist_delete_link(ltime, g_slist_nth(ltime, 0)); + ltime = g_slist_append(ltime, event_request_list_out); + } + } + + /* 1.1.2 Find all position requests with the lowest position in list_out + * (lpos) + */ + if(g_slist_length(list_out) > 0) + lpos = g_slist_append(lpos, g_slist_nth_data(list_out, 0)); + for(iter=g_slist_nth(list_out,1);iter!=NULL;iter=g_slist_next(iter)) { + /* Find all position requests with the lowest position in list_out */ + guint index_lpos = g_array_index(lpos, guint, 0); + EventsRequest *event_request_lpos = (EventsRequest*)g_slist_nth_data(lpos, 0); + EventsRequest *event_request_list_out = (EventsRequest*)iter->data; + + int comp; + if(event_request_lpos->start_position != NULL + && event_request_list_out->start_position != NULL) + { + comp = lttv_traceset_context_pos_pos_compare + (event_request_lpos->start_position, + event_request_list_out->start_position); + } else { + comp = -1; + } + if(comp == 0) + lpos = g_slist_append(lpos, event_request_list_out); + else if(comp > 0) { + /* Remove all elements from lpos, and add current */ + while(lpos != NULL) + lpos = g_slist_delete_link(lpos, g_slist_nth(lpos, 0)); + lpos = g_slist_append(lpos, event_request_list_out); + } + } + + /* 1.1.3 If lpos.start time < ltime */ + { + EventsRequest *event_request_lpos = (EventsRequest*)g_slist_nth_data(lpos, 0); + EventsRequest *event_request_ltime = (EventsRequest*)g_slist_nth_data(ltime, 0); + LttTime lpos_start_time; + + if(event_request_lpos != NULL + && event_request_lpos->start_position != NULL) { + + lpos_start_time = lttv_traceset_context_position_get_time( + event_request_lpos->start_position); + if(ltt_time_compare(lpos_start_time, + event_request_ltime->start_time)<0) { + /* Add lpos to list_in, remove them from list_out */ + + for(iter=lpos;iter!=NULL;iter=g_slist_next(iter)) { + /* Add to list_in */ + EventsRequest *event_request_lpos = + (EventsRequest*)iter->data; + + g_slist_append(list_in, event_request_lpos); + /* Remove from list_out */ + g_slist_remove(list_out, event_request_lpos); + } + } + } else { + /* 1.1.4 (lpos.start time >= ltime) */ + /* Add ltime to list_in, remove them from list_out */ + + for(iter=ltime;iter!=NULL;iter=g_slist_next(iter)) { + /* Add to list_in */ + EventsRequest *event_request_ltime = + (EventsRequest*)iter->data; + + g_slist_append(list_in, event_request_ltime); + /* Remove from list_out */ + g_slist_remove(list_out, event_request_ltime); + } + } + } + g_slist_free(lpos); + g_slist_free(ltime); + } + + /* 1.2 Seek */ + { + tfc = lttv_traceset_context_get_current_tfc(tsc); + g_assert(g_slist_length(list_in)>0); + EventsRequest *events_request = g_slist_nth_data(list_in, 0); + + /* 1.2.1 If first request in list_in is a time request */ + if(events_request->start_position == NULL) { + /* - If first req in list_in start time != current time */ + if(tfc != NULL && ltt_time_compare(events_request->start_time, + tfc->timestamp) != 0) + /* - Seek to that time */ + lttv_process_traceset_seek_time(tsc, events_request->start_time); + } else { + /* Else, the first request in list_in is a position request */ + /* If first req in list_in pos != current pos */ + g_assert(events_request->start_position != NULL); + if(lttv_traceset_context_ctx_pos_compare(tsc, + events_request->start_position) != 0) { + /* 1.2.2.1 Seek to that position */ + lttv_process_traceset_seek_position(tsc, events_request->start_position); + } + } + } + + /* 1.3 Add hooks and call before request for all list_in members */ + { + GSList *iter = NULL; + + for(iter=list_in;iter!=NULL;iter=g_slist_next(iter)) { + EventsRequest *events_request = (EventsRequest*)iter->data; + /* 1.3.1 If !servicing */ + if(events_request->servicing == FALSE) { + /* - begin request hooks called + * - servicing = TRUE + */ + lttv_hooks_call(events_request->before_request, NULL); + events_request->servicing = TRUE; + } + /* 1.3.2 call before chunk + * 1.3.3 events hooks added + */ + lttv_process_traceset_begin(tsc, events_request->before_chunk_traceset, + events_request->before_chunk_trace, + events_request->before_chunk_tracefile, + events_request->event, + events_request->event_by_id); + } + } + } else { + /* 2. Else, list_in is not empty, we continue a read */ + GSList *iter = NULL; + tfc = lttv_traceset_context_get_current_tfc(tsc); + + /* 2.1 For each req of list_out */ + for(iter=list_out;iter!=NULL;iter=g_slist_next(iter)) { + EventsRequest *events_request = (EventsRequest*)iter->data; + + /* if req.start time == current context time + * or req.start position == current position*/ + if( ltt_time_compare(events_request->start_time, + tfc->timestamp) == 0 + || + (events_request->start_position != NULL + && + lttv_traceset_context_ctx_pos_compare(tsc, + events_request->start_position) == 0) + ) { + /* - Add to list_in, remove from list_out */ + g_slist_append(list_in, events_request); + g_slist_remove(list_out, events_request); + + /* - If !servicing */ + if(events_request->servicing == FALSE) { + /* - begin request hooks called + * - servicing = TRUE + */ + lttv_hooks_call(events_request->before_request, NULL); + events_request->servicing = TRUE; + } + /* call before chunk + * events hooks added + */ + lttv_process_traceset_begin(tsc, events_request->before_chunk_traceset, + events_request->before_chunk_trace, + events_request->before_chunk_tracefile, + events_request->event, + events_request->event_by_id); + } + } + } + + /* 3. Find end criterions */ + { + /* 3.1 End time */ + GSList *iter; + + /* 3.1.1 Find lowest end time in list_in */ + g_assert(g_slist_length(list_in)>0); + end_time = ((EventsRequest*)g_slist_nth_data(list_in,0))->end_time; + + for(iter=g_slist_nth(list_in,1);iter!=NULL;iter=g_slist_next(iter)) { + EventsRequest *events_request = (EventsRequest*)iter->data; + + if(ltt_time_compare(events_request->end_time, + end_time) < 0) + end_time = events_request->end_time; + } + + /* 3.1.2 Find lowest start time in list_out */ + for(iter=list_out;iter!=NULL;iter=g_slist_next(iter)) { + EventsRequest *events_request = (EventsRequest*)iter->data; + + if(ltt_time_compare(events_request->start_time, + end_time) < 0) + end_time = events_request->start_time; + } + } + + { + /* 3.2 Number of events */ + + /* 3.2.1 Find lowest number of events in list_in */ + GSList *iter; + + end_nb_events = ((EventsRequest*)g_slist_nth_data(list_in,0))->num_events; + + for(iter=g_slist_nth(list_in,1);iter!=NULL;iter=g_slist_next(iter)) { + EventsRequest *events_request = (EventsRequest*)iter->data; + + if(events_request->num_events < end_nb_events) + end_nb_events = events_request->num_events; + } + + /* 3.2.2 Use min(CHUNK_NUM_EVENTS, min num events in list_in) as + * num_events */ + + end_nb_events = MIN(CHUNK_NUM_EVENTS, end_nb_events); + } + + { + /* 3.3 End position */ - lttv_process_traceset_seek_time(tsc, time_window->start_time); - lttv_process_traceset(tsc, - ltt_time_add(time_window->start_time,time_window->time_width), - max_nb_events); + /* 3.3.1 Find lowest end position in list_in */ + GSList *iter; - //call hooks to show each viewer and let them remove hooks - show_viewer(mw_data); + end_position =((EventsRequest*)g_slist_nth_data(list_in,0))->end_position; + + for(iter=g_slist_nth(list_in,1);iter!=NULL;iter=g_slist_next(iter)) { + EventsRequest *events_request = (EventsRequest*)iter->data; + + if(events_request->end_position != NULL && end_position != NULL && + lttv_traceset_context_pos_pos_compare(events_request->end_position, + end_position) <0) + end_position = events_request->end_position; + } + } + + { + /* 3.3.2 Find lowest start position in list_out */ + GSList *iter; + + for(iter=list_out;iter!=NULL;iter=g_slist_next(iter)) { + EventsRequest *events_request = (EventsRequest*)iter->data; + + if(events_request->end_position != NULL && end_position != NULL && + lttv_traceset_context_pos_pos_compare(events_request->end_position, + end_position) <0) + end_position = events_request->end_position; + } + } + + { + /* 4. Call process traceset middle */ + count = lttv_process_traceset_middle(tsc, end_time, end_nb_events, end_position); + } + { + /* 5. After process traceset middle */ + tfc = lttv_traceset_context_get_current_tfc(tsc); + + /* - if current context time > traceset.end time */ + if(tfc == NULL || ltt_time_compare(tfc->timestamp, + tsc->time_span.end_time) > 0) { + /* - For each req in list_in */ + GSList *iter = list_in; + + while(iter != NULL) { + + gboolean remove = FALSE; + gboolean free_data = FALSE; + EventsRequest *events_request = (EventsRequest *)iter->data; + + /* - Remove events hooks for req + * - Call end chunk for req + */ + lttv_process_traceset_end(tsc, events_request->after_chunk_traceset, + events_request->after_chunk_trace, + events_request->after_chunk_tracefile, + events_request->event, + events_request->event_by_id); + /* - Call end request for req */ + lttv_hooks_call(events_request->after_request, NULL); + + /* - remove req from list_in */ + /* Destroy the request */ + remove = TRUE; + free_data = TRUE; + + /* Go to next */ + if(remove) + { + GSList *remove_iter = iter; + + iter = g_slist_next(iter); + if(free_data) g_free(remove_iter->data); + list_in = g_slist_remove_link(list_in, remove_iter); + } else { // not remove + iter = g_slist_next(iter); + } + } + } + + { + /* 5.1 For each req in list_in */ + GSList *iter = list_in; + + while(iter != NULL) { + + gboolean remove = FALSE; + gboolean free_data = FALSE; + EventsRequest *events_request = (EventsRequest *)iter->data; + + /* - Remove events hooks for req + * - Call end chunk for req + */ + lttv_process_traceset_end(tsc, events_request->after_chunk_traceset, + events_request->after_chunk_trace, + events_request->after_chunk_tracefile, + events_request->event, + events_request->event_by_id); + + /* - req.num -= count */ + g_assert(events_request->num_events >= count); + events_request->num_events -= count; + + g_assert(tfc != NULL); + /* - if req.num == 0 + * or + * current context time > req.end time + * or + * req.end pos == current pos + * or + * req.stop_flag == TRUE + */ + if( events_request->num_events == 0 + || + events_request->stop_flag == TRUE + || + ltt_time_compare(tfc->timestamp, + events_request->end_time) > 0 + || + (events_request->start_position != NULL + && + lttv_traceset_context_ctx_pos_compare(tsc, + events_request->start_position) != 0) + + ) { + /* - Call end request for req + * - remove req from list_in */ + lttv_hooks_call(events_request->after_request, NULL); + /* - remove req from list_in */ + /* Destroy the request */ + remove = TRUE; + free_data = TRUE; + } + + /* Go to next */ + if(remove) + { + GSList *remove_iter = iter; + + iter = g_slist_next(iter); + if(free_data) g_free(remove_iter->data); + list_in = g_slist_remove_link(list_in, remove_iter); + } else { // not remove + iter = g_slist_next(iter); + } + } + } + } + } + + /* B. When interrupted between chunks */ + + { + GSList *iter = list_in; + + /* 1. for each request in list_in */ + while(iter != NULL) { + + gboolean remove = FALSE; + gboolean free_data = FALSE; + EventsRequest *events_request = (EventsRequest *)iter->data; + + /* 1.1. Use current postition as start position */ + g_free(events_request->start_position); + lttv_traceset_context_position_save(tsc, events_request->start_position); + + /* 1.2. Remove start time */ + events_request->start_time.tv_sec = G_MAXUINT; + events_request->start_time.tv_nsec = G_MAXUINT; + + /* 1.3. Move from list_in to list_out */ + remove = TRUE; + free_data = FALSE; + list_out = g_slist_append(list_out, events_request); + + /* Go to next */ + if(remove) + { + GSList *remove_iter = iter; + + iter = g_slist_next(iter); + if(free_data) g_free(remove_iter->data); + list_in = g_slist_remove_link(list_in, remove_iter); + } else { // not remove + iter = g_slist_next(iter); + } + } + + + } //set the cursor back to normal gdk_window_set_cursor(win, NULL); + + + g_assert(g_slist_length(list_in) == 0); + if( g_slist_length(list_out) == 0 ) { + /* Put tab's request pending flag back to normal */ + tab->events_request_pending = FALSE; + return FALSE; /* Remove the idle function */ + } + return TRUE; /* Leave the idle function */ } + /* add_trace_into_traceset_selector, each instance of a viewer has an associated * selector (filter), when a trace is added into traceset, the selector should * reflect the change. The function is used to update the selector @@ -475,6 +928,48 @@ void add_trace_into_traceset_selector(GtkMultiVPaned * paned, LttTrace * t) } +static void lttvwindow_add_trace(Tab *tab, LttvTrace *trace_v) +{ + LttvTraceset *traceset = tab->traceset_info->traceset; + guint i; + + //Keep a reference to the traces so they are not freed. + for(i=0; itraceset_info->traceset_context); + + lttv_context_fini(LTTV_TRACESET_CONTEXT( + tab->traceset_info->traceset_context)); + g_object_unref(tab->traceset_info->traceset_context); + + lttv_traceset_add(traceset, trace_v); + + /* Create new context */ + tab->traceset_info->traceset_context = + g_object_new(LTTV_TRACESET_STATS_TYPE, NULL); + lttv_context_init( + LTTV_TRACESET_CONTEXT(tab->traceset_info-> + traceset_context), + traceset); + //add state update hooks + lttv_state_add_event_hooks( + (LttvTracesetState*)tab->traceset_info->traceset_context); + //Remove local reference to the traces. + for(i=0; imulti_vpaned, lttv_trace(trace_v)); +} + /* add_trace adds a trace into the current traceset. It first displays a * directory selection dialogue to let user choose a trace, then recreates * tracset_context, and redraws all the viewer of the current tab @@ -485,12 +980,17 @@ void add_trace(GtkWidget * widget, gpointer user_data) LttTrace *trace; LttvTrace * trace_v; LttvTraceset * traceset; - LttvTracesetStats* tmp_context; const char * dir; gint id; + gint i; MainWindow * mw_data = get_window_data_struct(widget); + Tab *tab = mw_data->current_tab; + GtkDirSelection * file_selector = (GtkDirSelection *)gtk_dir_selection_new("Select a trace"); gtk_dir_selection_hide_fileop_buttons(file_selector); + + if(!tab) create_new_tab(widget, NULL); + if(remember_trace_dir[0] != '\0') gtk_dir_selection_set_filename(file_selector, remember_trace_dir); @@ -500,60 +1000,28 @@ void add_trace(GtkWidget * widget, gpointer user_data) case GTK_RESPONSE_OK: dir = gtk_dir_selection_get_dir (file_selector); strncpy(remember_trace_dir, dir, PATH_LENGTH); - if(!dir || strlen(dir) ==0){ - gtk_widget_destroy((GtkWidget*)file_selector); - break; + if(!dir || strlen(dir) == 0){ + gtk_widget_destroy((GtkWidget*)file_selector); + break; } trace = ltt_trace_open(dir); if(trace == NULL) g_critical("cannot open trace %s", dir); trace_v = lttv_trace_new(trace); - traceset = mw_data->current_tab->traceset_info->traceset; - - // Keep the context until the new one is created. - tmp_context = mw_data->current_tab->traceset_info->traceset_context; - mw_data->current_tab->traceset_info->traceset_context = NULL; - - lttv_traceset_add(traceset, trace_v); - mw_data->current_tab->traceset_info->traceset_context = - g_object_new(LTTV_TRACESET_STATS_TYPE, NULL); - lttv_context_init( - LTTV_TRACESET_CONTEXT(mw_data->current_tab->traceset_info-> - traceset_context), - traceset); - //add state update hooks - lttv_state_add_event_hooks( - (LttvTracesetState*)mw_data->current_tab->traceset_info->traceset_context); - if(tmp_context != NULL) - { - //remove state update hooks - lttv_state_remove_event_hooks( - (LttvTracesetState*)tmp_context); - lttv_context_fini(LTTV_TRACESET_CONTEXT(tmp_context)); - g_object_unref(tmp_context); - } - - - add_trace_into_traceset_selector(mw_data->current_tab->multi_vpaned, trace); + lttvwindow_add_trace(tab, trace_v); gtk_widget_destroy((GtkWidget*)file_selector); //update current tab - update_traceset(mw_data); - - //get_traceset_time_span(mw_data,LTTV_TRACESET_CONTEXT(mw_data->current_tab->traceset_info->traceset_context)->Time_Span); - if(lttv_traceset_number(mw_data->current_tab->traceset_info->traceset) == 1 || - ltt_time_compare(mw_data->current_tab->current_time, - LTTV_TRACESET_CONTEXT(mw_data->current_tab->traceset_info->traceset_context)->Time_Span->startTime)<0){ - mw_data->current_tab->current_time = - LTTV_TRACESET_CONTEXT(mw_data->current_tab->traceset_info->traceset_context)->Time_Span->startTime; - mw_data->current_tab->time_window.start_time = mw_data->current_tab->current_time; - mw_data->current_tab->time_window.time_width.tv_sec = DEFAULT_TIME_WIDTH_S; - mw_data->current_tab->time_window.time_width.tv_nsec = 0; - } - - redraw_viewer(mw_data, &(mw_data->current_tab->time_window)); - lttvwindow_report_current_time(mw_data,&(mw_data->current_tab->current_time)); + //update_traceset(mw_data); + + /* Call the updatetraceset hooks */ + + traceset = tab->traceset_info->traceset; + SetTraceset(tab, traceset); + // in expose now call_pending_read_hooks(mw_data); + + //lttvwindow_report_current_time(mw_data,&(tab->current_time)); break; case GTK_RESPONSE_REJECT: case GTK_RESPONSE_CANCEL: @@ -602,20 +1070,21 @@ void remove_trace(GtkWidget * widget, gpointer user_data) LttTrace *trace; LttvTrace * trace_v; LttvTraceset * traceset; - LttvTracesetStats* tmp_context; - gint i, nb_trace; + gint i, j, nb_trace; char ** name, *remove_trace_name; MainWindow * mw_data = get_window_data_struct(widget); + Tab *tab = mw_data->current_tab; LttvTracesetSelector * s; LttvTraceSelector * t; GtkWidget * w; gboolean selected; - nb_trace =lttv_traceset_number(mw_data->current_tab->traceset_info->traceset); + if(!tab) return; + + nb_trace =lttv_traceset_number(tab->traceset_info->traceset); name = g_new(char*,nb_trace); for(i = 0; i < nb_trace; i++){ - trace_v = lttv_traceset_get(mw_data->current_tab-> - traceset_info->traceset, i); + trace_v = lttv_traceset_get(tab->traceset_info->traceset, i); trace = lttv_trace(trace_v); name[i] = ltt_trace_name(trace); } @@ -626,7 +1095,7 @@ void remove_trace(GtkWidget * widget, gpointer user_data) for(i=0; icurrent_tab->multi_vpaned); + w = gtk_multi_vpaned_get_widget(tab->multi_vpaned); if(w){ s = g_object_get_data(G_OBJECT(w), "Traceset_Selector"); if(s){ @@ -635,7 +1104,7 @@ void remove_trace(GtkWidget * widget, gpointer user_data) } //check if other viewers select the trace - w = gtk_multi_vpaned_get_first_widget(mw_data->current_tab->multi_vpaned); + w = gtk_multi_vpaned_get_first_widget(tab->multi_vpaned); while(w){ s = g_object_get_data(G_OBJECT(w), "Traceset_Selector"); if(s){ @@ -643,53 +1112,67 @@ void remove_trace(GtkWidget * widget, gpointer user_data) selected = lttv_trace_selector_get_selected(t); if(selected)break; } - w = gtk_multi_vpaned_get_next_widget(mw_data->current_tab->multi_vpaned); + w = gtk_multi_vpaned_get_next_widget(tab->multi_vpaned); } }else selected = FALSE; //if no viewer selects the trace, remove it if(!selected){ - remove_trace_from_traceset_selector(mw_data->current_tab->multi_vpaned, i); + remove_trace_from_traceset_selector(tab->multi_vpaned, i); - traceset = mw_data->current_tab->traceset_info->traceset; + traceset = tab->traceset_info->traceset; trace_v = lttv_traceset_get(traceset, i); if(lttv_trace_get_ref_number(trace_v) <= 1) ltt_trace_close(lttv_trace(trace_v)); - - // Keep the context until the new one is created. - tmp_context = mw_data->current_tab->traceset_info->traceset_context; - mw_data->current_tab->traceset_info->traceset_context = NULL; + + //Keep a reference to the traces so they are not freed. + for(j=0; jtraceset_info->traceset_context); + lttv_context_fini(LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)); + g_object_unref(tab->traceset_info->traceset_context); + lttv_traceset_remove(traceset, i); + lttv_trace_unref(trace_v); // Remove local reference if(!lttv_trace_get_ref_number(trace_v)) lttv_trace_destroy(trace_v); - mw_data->current_tab->traceset_info->traceset_context = + + tab->traceset_info->traceset_context = g_object_new(LTTV_TRACESET_STATS_TYPE, NULL); - lttv_context_init( - LTTV_TRACESET_CONTEXT(mw_data->current_tab-> + lttv_context_init( + LTTV_TRACESET_CONTEXT(tab-> traceset_info->traceset_context),traceset); //add state update hooks - lttv_state_add_event_hooks( - (LttvTracesetState*)mw_data->current_tab->traceset_info->traceset_context); - - if(tmp_context != NULL){ - //remove state update hooks - lttv_state_remove_event_hooks( - (LttvTracesetState*)tmp_context); - lttv_context_fini(LTTV_TRACESET_CONTEXT(tmp_context)); - g_object_unref(tmp_context); - } + lttv_state_add_event_hooks( + (LttvTracesetState*)tab->traceset_info->traceset_context); + + //Remove local reference to the traces. + for(j=0; j 1){ - redraw_viewer(mw_data, &(mw_data->current_tab->time_window)); - lttvwindow_report_current_time(mw_data,&(mw_data->current_tab->current_time)); + + SetTraceset(mw_data, (gpointer)traceset); + // in expose now call_pending_read_hooks(mw_data); + + //lttvwindow_report_current_time(mw_data,&(tab->current_time)); }else{ - if(mw_data->current_tab){ - while(mw_data->current_tab->multi_vpaned->num_children){ - gtk_multi_vpaned_widget_delete(mw_data->current_tab->multi_vpaned); + if(tab){ + while(tab->multi_vpaned->num_children){ + gtk_multi_vpaned_widget_delete(tab->multi_vpaned); } } } @@ -704,7 +1187,7 @@ void remove_trace(GtkWidget * widget, gpointer user_data) /* save will save the traceset to a file - * Not implemented yet + * Not implemented yet FIXME */ void save(GtkWidget * widget, gpointer user_data) @@ -726,44 +1209,80 @@ void save_as(GtkWidget * widget, gpointer user_data) void zoom(GtkWidget * widget, double size) { TimeInterval *time_span; - TimeWindow time_window; - LttTime current_time, time_delta, time_s, time_e, time_t; + TimeWindow new_time_window; + LttTime current_time, time_delta, time_s, time_e, time_tmp; MainWindow * mw_data = get_window_data_struct(widget); + Tab *tab = mw_data->current_tab; + LttvTracesetContext *tsc; + if(tab==NULL) return; if(size == 1) return; - time_span = LTTV_TRACESET_CONTEXT(mw_data->current_tab-> - traceset_info->traceset_context)->Time_Span; - time_window = mw_data->current_tab->time_window; - current_time = mw_data->current_tab->current_time; + tsc = LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context); + time_span = &tsc->time_span; + new_time_window = tab->time_window; + current_time = tab->current_time; - time_delta = ltt_time_sub(time_span->endTime,time_span->startTime); + time_delta = ltt_time_sub(time_span->end_time,time_span->start_time); if(size == 0){ - time_window.start_time = time_span->startTime; - time_window.time_width = time_delta; + new_time_window.start_time = time_span->start_time; + new_time_window.time_width = time_delta; }else{ - time_window.time_width = ltt_time_div(time_window.time_width, size); - if(ltt_time_compare(time_window.time_width,time_delta) > 0) - time_window.time_width = time_delta; - - time_t = ltt_time_div(time_window.time_width, 2); - if(ltt_time_compare(current_time, time_t) < 0){ - time_s = time_span->startTime; - } else { - time_s = ltt_time_sub(current_time,time_t); + new_time_window.time_width = ltt_time_div(new_time_window.time_width, size); + if(ltt_time_compare(new_time_window.time_width,time_delta) > 0) + { /* Case where zoom out is bigger than trace length */ + new_time_window.start_time = time_span->start_time; + new_time_window.time_width = time_delta; } - time_e = ltt_time_add(current_time,time_t); - if(ltt_time_compare(time_span->startTime, time_s) > 0){ - time_s = time_span->startTime; - }else if(ltt_time_compare(time_span->endTime, time_e) < 0){ - time_e = time_span->endTime; - time_s = ltt_time_sub(time_e,time_window.time_width); + else + { + /* Center the image on the current time */ + g_critical("update is HERE"); + new_time_window.start_time = + ltt_time_sub(current_time, ltt_time_div(new_time_window.time_width, 2.0)); + /* If on borders, don't fall off */ + if(ltt_time_compare(new_time_window.start_time, time_span->start_time) <0) + { + new_time_window.start_time = time_span->start_time; + } + else + { + if(ltt_time_compare( + ltt_time_add(new_time_window.start_time, new_time_window.time_width), + time_span->end_time) > 0) + { + new_time_window.start_time = + ltt_time_sub(time_span->end_time, new_time_window.time_width); + } + } + } - time_window.start_time = time_s; + + + + //time_tmp = ltt_time_div(new_time_window.time_width, 2); + //if(ltt_time_compare(current_time, time_tmp) < 0){ + // time_s = time_span->startTime; + //} else { + // time_s = ltt_time_sub(current_time,time_tmp); + //} + //time_e = ltt_time_add(current_time,time_tmp); + //if(ltt_time_compare(time_span->startTime, time_s) > 0){ + // time_s = time_span->startTime; + //}else if(ltt_time_compare(time_span->endTime, time_e) < 0){ + // time_e = time_span->endTime; + // time_s = ltt_time_sub(time_e,new_time_window.time_width); + //} + //new_time_window.start_time = time_s; } - redraw_viewer(mw_data, &time_window); - lttvwindow_report_current_time(mw_data,&(mw_data->current_tab->current_time)); - gtk_multi_vpaned_set_adjust(mw_data->current_tab->multi_vpaned, FALSE); + + //lttvwindow_report_time_window(mw_data, &new_time_window); + //call_pending_read_hooks(mw_data); + + //lttvwindow_report_current_time(mw_data,&(tab->current_time)); + set_time_window(tab, &new_time_window); + // in expose now call_pending_read_hooks(mw_data); + gtk_multi_vpaned_set_adjust(tab->multi_vpaned, &new_time_window, FALSE); } void zoom_in(GtkWidget * widget, gpointer user_data) @@ -816,15 +1335,17 @@ on_clone_traceset_activate (GtkMenuItem *menuitem, void create_new_tab(GtkWidget* widget, gpointer user_data){ gchar label[PATH_LENGTH]; MainWindow * mw_data = get_window_data_struct(widget); + GtkNotebook * notebook = (GtkNotebook *)lookup_widget(widget, "MNotebook"); if(notebook == NULL){ g_printf("Notebook does not exist\n"); return; } - + + strcpy(label,"Page"); if(get_label(mw_data, label,"Get the name of the tab","Please input tab's name")) - create_tab (mw_data, mw_data, notebook, label); + create_tab (mw_data, NULL, notebook, label); } void @@ -852,41 +1373,35 @@ on_close_activate (GtkMenuItem *menuitem, } -/* remove the current tab from the main window if it is not the default tab +/* remove the current tab from the main window */ void on_close_tab_activate (GtkMenuItem *menuitem, gpointer user_data) { - GList * list; - int count = 0; + gint page_num; GtkWidget * notebook; - Tab * tmp; + GtkWidget * page; MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem); notebook = lookup_widget((GtkWidget*)menuitem, "MNotebook"); if(notebook == NULL){ g_printf("Notebook does not exist\n"); return; } + + page_num = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook)); - if(mw_data->tab == mw_data->current_tab){ - // tmp = mw_data->current_tb; - // mw_data->tab = mw_data->current_tab->next; - g_printf("The default TAB can not be deleted\n"); - return; - }else{ - tmp = mw_data->tab; - while(tmp != mw_data->current_tab){ - tmp = tmp->next; - count++; - } - } + gtk_notebook_remove_page(GTK_NOTEBOOK(notebook), page_num); - gtk_notebook_remove_page((GtkNotebook*)notebook, count); - list = gtk_container_get_children(GTK_CONTAINER(notebook)); - if(g_list_length(list)==1) - gtk_notebook_set_show_tabs((GtkNotebook*)notebook, FALSE); + if( gtk_notebook_get_n_pages(GTK_NOTEBOOK(notebook)) == 0 ) + mw_data->current_tab = NULL; + else { + page = gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), + gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook))); + mw_data->current_tab = + (Tab *)g_object_get_data(G_OBJECT(page), "Tab_Info"); + } } @@ -1031,7 +1546,12 @@ on_trace_filter_activate (GtkMenuItem *menuitem, { MainWindow * mw_data = get_window_data_struct((GtkWidget*)menuitem); LttvTracesetSelector * s; - GtkWidget * w = gtk_multi_vpaned_get_widget(mw_data->current_tab->multi_vpaned); + Tab *tab = mw_data->current_tab; + GtkWidget * w; + + if(tab == NULL) return ; + + w = gtk_multi_vpaned_get_widget(tab->multi_vpaned); s = g_object_get_data(G_OBJECT(w), "Traceset_Selector"); if(!s){ @@ -1039,9 +1559,10 @@ on_trace_filter_activate (GtkMenuItem *menuitem, return; } if(get_filter_selection(s, "Configure trace and tracefile filter", "Select traces and tracefiles")){ - update_traceset(mw_data); - redraw_viewer(mw_data, &(mw_data->current_tab->time_window)); - lttvwindow_report_current_time(mw_data,&(mw_data->current_tab->current_time)); + //FIXME report filter change + //update_traceset(mw_data); + //call_pending_read_hooks(mw_data); + //lttvwindow_report_current_time(mw_data,&(tab->current_time)); } } @@ -1086,8 +1607,6 @@ on_load_module_activate (GtkMenuItem *menuitem, str1++; } lttv_module_require(str1, NULL); - g_slist_foreach(g_main_window_list, (gpointer)insert_menu_toolbar_item, - NULL); g_strfreev(dir); case GTK_RESPONSE_REJECT: case GTK_RESPONSE_CANCEL: @@ -1131,7 +1650,7 @@ on_unload_module_activate (GtkMenuItem *menuitem, library = lttv_library_get(i); lttv_library_info(library, &library_info); if(strcmp(unload_module_name, library_info.name) == 0){ - lttv_library_unload(library); + lttv_library_unload(library); break; } } @@ -1331,17 +1850,30 @@ on_button_delete_viewer_clicked (GtkButton *button, } void -on_MWindow_destroy (GtkObject *object, +on_MWindow_destroy (GtkWidget *widget, gpointer user_data) { - MainWindow *Main_Window = get_window_data_struct((GtkWidget*)object); - GtkWidget *widget; - Tab *tab = Main_Window->tab; + MainWindow *main_window = get_window_data_struct(widget); + LttvIAttribute *attributes = main_window->attributes; + LttvAttributeValue value; - g_printf("There are : %d windows\n",g_slist_length(g_main_window_list)); + //This is unnecessary, since widgets will be destroyed + //by the main window widget anyway. + //remove_all_menu_toolbar_constructors(main_window, NULL); + + g_assert(lttv_iattribute_find_by_path(attributes, + "viewers/menu", LTTV_POINTER, &value)); + lttv_menus_destroy((LttvMenus*)*(value.v_pointer)); + + g_assert(lttv_iattribute_find_by_path(attributes, + "viewers/toolbar", LTTV_POINTER, &value)); + lttv_toolbars_destroy((LttvToolbars*)*(value.v_pointer)); + + g_object_unref(main_window->attributes); + g_main_window_list = g_slist_remove(g_main_window_list, main_window); - g_win_count--; - if(g_win_count == 0) + g_printf("There are now : %d windows\n",g_slist_length(g_main_window_list)); + if(g_slist_length(g_main_window_list) == 0) gtk_main_quit (); } @@ -1380,7 +1912,6 @@ on_MWindow_configure (GtkWidget *widget, return FALSE; } - /* Set current tab */ @@ -1727,87 +2258,108 @@ char * get_selection(char ** loaded_module_name, int nb_module, } -/* hash funtions - */ - -void main_window_destroy_hash_key(gpointer key) -{ - g_free(key); -} - -void main_window_destroy_hash_data(gpointer data) -{ -} - - -/* Insert menu entry and tool button into all main windows for modules - * It checks whether the menu entry or tool button exists or not, - * if they do not exist, then construct the widget and insert them - * into all main windows +/* Insert all menu entry and tool buttons into this main window + * for modules. + * */ -void insert_menu_toolbar_item(MainWindow * mw, gpointer user_data) +void add_all_menu_toolbar_constructors(MainWindow * mw, gpointer user_data) { int i; GdkPixbuf *pixbuf; lttvwindow_viewer_constructor constructor; - LttvMenus * menu; - LttvToolbars * toolbar; - lttv_menu_closure *menu_item; - lttv_toolbar_closure *toolbar_item; + LttvMenus * global_menu, * instance_menu; + LttvToolbars * global_toolbar, * instance_toolbar; + LttvMenuClosure *menu_item; + LttvToolbarClosure *toolbar_item; LttvAttributeValue value; - LttvIAttribute *attributes = LTTV_IATTRIBUTE(lttv_global_attributes()); - GtkWidget * tool_menu_title_menu, *insert_view, *pixmap, *tmp; + LttvIAttribute *global_attributes = LTTV_IATTRIBUTE(lttv_global_attributes()); + LttvIAttribute *attributes = mw->attributes; + GtkWidget * tool_menu_title_menu, *new_widget, *pixmap; + + g_assert(lttv_iattribute_find_by_path(global_attributes, + "viewers/menu", LTTV_POINTER, &value)); + if(*(value.v_pointer) == NULL) + *(value.v_pointer) = lttv_menus_new(); + global_menu = (LttvMenus*)*(value.v_pointer); g_assert(lttv_iattribute_find_by_path(attributes, "viewers/menu", LTTV_POINTER, &value)); - menu = (LttvMenus*)*(value.v_pointer); - - if(menu){ - for(i=0;ilen;i++){ - menu_item = &g_array_index(menu, lttv_menu_closure, i); - tmp = g_hash_table_lookup(mw->hash_menu_item, g_strdup(menu_item->menuText)); - if(tmp)continue; - constructor = menu_item->con; - tool_menu_title_menu = lookup_widget(mw->mwindow,"ToolMenuTitle_menu"); - insert_view = gtk_menu_item_new_with_mnemonic (menu_item->menuText); - gtk_widget_show (insert_view); - gtk_container_add (GTK_CONTAINER (tool_menu_title_menu), insert_view); - g_signal_connect ((gpointer) insert_view, "activate", - G_CALLBACK (insert_viewer_wrap), - constructor); - g_hash_table_insert(mw->hash_menu_item, g_strdup(menu_item->menuText), - insert_view); - } - } + if(*(value.v_pointer) == NULL) + *(value.v_pointer) = lttv_menus_new(); + instance_menu = (LttvMenus*)*(value.v_pointer); + + + + g_assert(lttv_iattribute_find_by_path(global_attributes, + "viewers/toolbar", LTTV_POINTER, &value)); + if(*(value.v_pointer) == NULL) + *(value.v_pointer) = lttv_toolbars_new(); + global_toolbar = (LttvToolbars*)*(value.v_pointer); g_assert(lttv_iattribute_find_by_path(attributes, "viewers/toolbar", LTTV_POINTER, &value)); - toolbar = (LttvToolbars*)*(value.v_pointer); - - if(toolbar){ - for(i=0;ilen;i++){ - toolbar_item = &g_array_index(toolbar, lttv_toolbar_closure, i); - tmp = g_hash_table_lookup(mw->hash_toolbar_item, g_strdup(toolbar_item->tooltip)); - if(tmp)continue; - constructor = toolbar_item->con; - tool_menu_title_menu = lookup_widget(mw->mwindow,"MToolbar1"); - pixbuf = gdk_pixbuf_new_from_xpm_data ((const char**)toolbar_item->pixmap); - pixmap = gtk_image_new_from_pixbuf(pixbuf); - insert_view = gtk_toolbar_append_element (GTK_TOOLBAR (tool_menu_title_menu), - GTK_TOOLBAR_CHILD_BUTTON, - NULL, - "", - toolbar_item->tooltip, NULL, - pixmap, NULL, NULL); - gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (tool_menu_title_menu)->children)->data))->label), TRUE); - gtk_widget_show (insert_view); - gtk_container_set_border_width (GTK_CONTAINER (insert_view), 1); - g_signal_connect ((gpointer) insert_view, "clicked",G_CALLBACK (insert_viewer_wrap),constructor); - g_hash_table_insert(mw->hash_toolbar_item, g_strdup(toolbar_item->tooltip), - insert_view); - } + if(*(value.v_pointer) == NULL) + *(value.v_pointer) = lttv_toolbars_new(); + instance_toolbar = (LttvToolbars*)*(value.v_pointer); + + /* Add missing menu entries to window instance */ + for(i=0;ilen;i++) { + menu_item = &g_array_index(global_menu, LttvMenuClosure, i); + + //add menu_item to window instance; + constructor = menu_item->con; + tool_menu_title_menu = lookup_widget(mw->mwindow,"ToolMenuTitle_menu"); + new_widget = + gtk_menu_item_new_with_mnemonic (menu_item->menu_text); + gtk_container_add (GTK_CONTAINER (tool_menu_title_menu), + new_widget); + g_signal_connect ((gpointer) new_widget, "activate", + G_CALLBACK (insert_viewer_wrap), + constructor); + gtk_widget_show (new_widget); + lttv_menus_add(instance_menu, menu_item->con, + menu_item->menu_path, + menu_item->menu_text, + new_widget); + + } + + /* Add missing toolbar entries to window instance */ + for(i=0;ilen;i++) { + toolbar_item = &g_array_index(global_toolbar, LttvToolbarClosure, i); + + //add toolbar_item to window instance; + constructor = toolbar_item->con; + tool_menu_title_menu = lookup_widget(mw->mwindow,"MToolbar1"); + pixbuf = gdk_pixbuf_new_from_xpm_data((const char**)toolbar_item->pixmap); + pixmap = gtk_image_new_from_pixbuf(pixbuf); + new_widget = + gtk_toolbar_append_element (GTK_TOOLBAR (tool_menu_title_menu), + GTK_TOOLBAR_CHILD_BUTTON, + NULL, + "", + toolbar_item->tooltip, NULL, + pixmap, NULL, NULL); + gtk_label_set_use_underline( + GTK_LABEL (((GtkToolbarChild*) ( + g_list_last (GTK_TOOLBAR + (tool_menu_title_menu)->children)->data))->label), + TRUE); + gtk_container_set_border_width (GTK_CONTAINER (new_widget), 1); + g_signal_connect ((gpointer) new_widget, + "clicked", + G_CALLBACK (insert_viewer_wrap), + constructor); + gtk_widget_show (new_widget); + + lttv_toolbars_add(instance_toolbar, toolbar_item->con, + toolbar_item->tooltip, + toolbar_item->pixmap, + new_widget); + } + } @@ -1833,24 +2385,25 @@ void construct_main_window(MainWindow * parent) new_window = create_MWindow(); gtk_widget_show (new_window); - new_m_window->attributes = attributes; - new_m_window->mwindow = new_window; new_m_window->tab = NULL; new_m_window->current_tab = NULL; - new_m_window->attributes = LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE, NULL)); + new_m_window->attributes = attributes; - new_m_window->hash_menu_item = g_hash_table_new_full (g_str_hash, g_str_equal, - main_window_destroy_hash_key, - main_window_destroy_hash_data); - new_m_window->hash_toolbar_item = g_hash_table_new_full (g_str_hash, g_str_equal, - main_window_destroy_hash_key, - main_window_destroy_hash_data); + g_assert(lttv_iattribute_find_by_path(attributes, + "viewers/menu", LTTV_POINTER, &value)); + *(value.v_pointer) = lttv_menus_new(); - insert_menu_toolbar_item(new_m_window, NULL); - - g_object_set_data(G_OBJECT(new_window), "mainWindow", (gpointer)new_m_window); + g_assert(lttv_iattribute_find_by_path(attributes, + "viewers/toolbar", LTTV_POINTER, &value)); + *(value.v_pointer) = lttv_toolbars_new(); + add_all_menu_toolbar_constructors(new_m_window, NULL); + + g_object_set_data_full(G_OBJECT(new_window), + "main_window_data", + (gpointer)new_m_window, + (GDestroyNotify)g_free); //create a default tab notebook = (GtkNotebook *)lookup_widget(new_m_window->mwindow, "MNotebook"); if(notebook == NULL){ @@ -1859,15 +2412,17 @@ void construct_main_window(MainWindow * parent) } //for now there is no name field in LttvTraceset structure //Use "Traceset" as the label for the default tab - create_tab(parent, new_m_window, notebook,"Traceset"); - - g_object_set_data_full( - G_OBJECT(new_m_window->mwindow), - "Main_Window_Data", - new_m_window, - (GDestroyNotify)main_window_free); + if(parent) + create_tab(new_m_window, parent->current_tab, notebook, "Traceset"); + else { + create_tab(new_m_window, NULL, notebook, "Traceset"); + if(g_init_trace != NULL){ + lttvwindow_add_trace(new_m_window->current_tab, + g_init_trace); + } + } - g_win_count++; + g_printf("There are now : %d windows\n",g_slist_length(g_main_window_list)); } @@ -1881,7 +2436,11 @@ void tab_destructor(Tab * tab_instance) LttvTrace * trace; if(tab_instance->attributes) - g_object_unref(tab_instance->attributes); + g_object_unref(tab_instance->attributes); + + if(tab_instance->interrupted_state) + g_object_unref(tab_instance->interrupted_state); + if(tab_instance->mw->tab == tab_instance){ tab_instance->mw->tab = tab_instance->next; @@ -1915,7 +2474,11 @@ void tab_destructor(Tab * tab_instance) // lttv_trace_destroy(trace); } } - lttv_traceset_destroy(tab_instance->traceset_info->traceset); + lttv_traceset_destroy(tab_instance->traceset_info->traceset); + /* Remove the idle events requests processing function of the tab */ + g_idle_remove_by_data(tab_instance); + + g_slist_free(tab_instance->events_requests); g_free(tab_instance->traceset_info); g_free(tab_instance); } @@ -1924,21 +2487,20 @@ void tab_destructor(Tab * tab_instance) /* Create a tab and insert it into the current main window */ -void * create_tab(MainWindow * parent, MainWindow* current_window, +void * create_tab(MainWindow * mw, Tab *copy_tab, GtkNotebook * notebook, char * label) { GList * list; Tab * tmp_tab; - MainWindow * mw_data = current_window; LttTime tmp_time; - + //create a new tab data structure - tmp_tab = mw_data->tab; + tmp_tab = mw->tab; while(tmp_tab && tmp_tab->next) tmp_tab = tmp_tab->next; if(!tmp_tab){ - mw_data->current_tab = NULL; + mw->current_tab = NULL; tmp_tab = g_new(Tab,1); - mw_data->tab = tmp_tab; + mw->tab = tmp_tab; }else{ tmp_tab->next = g_new(Tab,1); tmp_tab = tmp_tab->next; @@ -1946,23 +2508,26 @@ void * create_tab(MainWindow * parent, MainWindow* current_window, //construct and initialize the traceset_info tmp_tab->traceset_info = g_new(TracesetInfo,1); - if(parent){ + + if(copy_tab) { tmp_tab->traceset_info->traceset = - lttv_traceset_copy(parent->current_tab->traceset_info->traceset); - }else{ - if(mw_data->current_tab){ - tmp_tab->traceset_info->traceset = - lttv_traceset_copy(mw_data->current_tab->traceset_info->traceset); - }else{ - tmp_tab->traceset_info->traceset = lttv_traceset_new(); - /* Add the command line trace */ - if(g_init_trace != NULL) - lttv_traceset_add(tmp_tab->traceset_info->traceset, g_init_trace); - } + lttv_traceset_copy(copy_tab->traceset_info->traceset); + } else { + tmp_tab->traceset_info->traceset = lttv_traceset_new(); } + +//FIXME : this is g_debug level + lttv_attribute_write_xml( + lttv_traceset_attribute(tmp_tab->traceset_info->traceset), + stdout, + 0, 4); + fflush(stdout); + + //FIXME copy not implemented in lower level tmp_tab->traceset_info->traceset_context = g_object_new(LTTV_TRACESET_STATS_TYPE, NULL); + g_assert(tmp_tab->traceset_info->traceset_context != NULL); lttv_context_init( LTTV_TRACESET_CONTEXT(tmp_tab->traceset_info->traceset_context), tmp_tab->traceset_info->traceset); @@ -1970,43 +2535,49 @@ void * create_tab(MainWindow * parent, MainWindow* current_window, lttv_state_add_event_hooks( (LttvTracesetState*)tmp_tab->traceset_info->traceset_context); - //determine the current_time and time_window of the tab - if(mw_data->current_tab){ + if(mw->current_tab){ // Will have to read directly at the main window level, as we want // to be able to modify a traceset on the fly. - tmp_tab->time_window = mw_data->current_tab->time_window; - tmp_tab->current_time = mw_data->current_tab->current_time; + tmp_tab->time_window = mw->current_tab->time_window; + tmp_tab->current_time = mw->current_tab->current_time; }else{ // Will have to read directly at the main window level, as we want // to be able to modify a traceset on the fly. // get_traceset_time_span(mw_data,&tmp_tab->traceStartTime, &tmp_tab->traceEndTime); tmp_tab->time_window.start_time = - LTTV_TRACESET_CONTEXT(tmp_tab->traceset_info->traceset_context)->Time_Span->startTime; + LTTV_TRACESET_CONTEXT(tmp_tab->traceset_info->traceset_context)->time_span.start_time; if(DEFAULT_TIME_WIDTH_S < - LTTV_TRACESET_CONTEXT(tmp_tab->traceset_info->traceset_context)->Time_Span->endTime.tv_sec) + LTTV_TRACESET_CONTEXT(tmp_tab->traceset_info->traceset_context)->time_span.end_time.tv_sec) tmp_time.tv_sec = DEFAULT_TIME_WIDTH_S; else tmp_time.tv_sec = - LTTV_TRACESET_CONTEXT(tmp_tab->traceset_info->traceset_context)->Time_Span->endTime.tv_sec; + LTTV_TRACESET_CONTEXT(tmp_tab->traceset_info->traceset_context)->time_span.end_time.tv_sec; tmp_time.tv_nsec = 0; tmp_tab->time_window.time_width = tmp_time ; tmp_tab->current_time.tv_sec = - LTTV_TRACESET_CONTEXT(tmp_tab->traceset_info->traceset_context)->Time_Span->startTime.tv_sec; + LTTV_TRACESET_CONTEXT(tmp_tab->traceset_info->traceset_context)->time_span.start_time.tv_sec; tmp_tab->current_time.tv_nsec = - LTTV_TRACESET_CONTEXT(tmp_tab->traceset_info->traceset_context)->Time_Span->startTime.tv_nsec; + LTTV_TRACESET_CONTEXT(tmp_tab->traceset_info->traceset_context)->time_span.start_time.tv_nsec; } + /* Become the current tab */ + mw->current_tab = tmp_tab; + tmp_tab->attributes = LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE, NULL)); - // mw_data->current_tab = tmp_tab; + tmp_tab->interrupted_state = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL); tmp_tab->multi_vpaned = (GtkMultiVPaned*)gtk_multi_vpaned_new(); - tmp_tab->multi_vpaned->mw = mw_data; + tmp_tab->multi_vpaned->tab = mw->current_tab; gtk_widget_show((GtkWidget*)tmp_tab->multi_vpaned); tmp_tab->next = NULL; - tmp_tab->mw = mw_data; + tmp_tab->mw = mw; tmp_tab->label = gtk_label_new (label); gtk_widget_show (tmp_tab->label); + /* Start with empty events requests list */ + tmp_tab->events_requests = NULL; + tmp_tab->events_request_pending = FALSE; + g_object_set_data_full( G_OBJECT(tmp_tab->multi_vpaned), "Tab_Info", @@ -2017,96 +2588,56 @@ void * create_tab(MainWindow * parent, MainWindow* current_window, gtk_notebook_append_page(notebook, (GtkWidget*)tmp_tab->multi_vpaned, tmp_tab->label); list = gtk_container_get_children(GTK_CONTAINER(notebook)); gtk_notebook_set_current_page(notebook,g_list_length(list)-1); - if(g_list_length(list)>1) - gtk_notebook_set_show_tabs(notebook, TRUE); + // always show : not if(g_list_length(list)>1) + gtk_notebook_set_show_tabs(notebook, TRUE); + } - -/* Remove menu entry and tool button from main window for the - * unloaded module +/** + * Function to show each viewer in the current tab. + * It will be called by main window, call show on each registered viewer, + * will call process traceset and then it will + * @param main_win the main window the viewer belongs to. */ - -void remove_menu_item(gpointer main_win, gpointer user_data) +//FIXME Only one time request maximum for now! +void show_viewer(MainWindow *main_win) { - MainWindow * mw = (MainWindow *) main_win; - lttv_menu_closure *menu_item = (lttv_menu_closure *)user_data; - GtkWidget * tool_menu_title_menu, *insert_view; - - tool_menu_title_menu = lookup_widget(mw->mwindow,"ToolMenuTitle_menu"); - insert_view = (GtkWidget*)g_hash_table_lookup(mw->hash_menu_item, - menu_item->menuText); - if(insert_view){ - g_hash_table_remove(mw->hash_menu_item, menu_item->menuText); - gtk_container_remove (GTK_CONTAINER (tool_menu_title_menu), insert_view); + LttvAttributeValue value; + LttvHooks * tmp; + int i; + LttvTracesetContext * tsc; + Tab *tab = main_win->current_tab; + + if(tab == NULL) return ; + + tsc =(LttvTracesetContext*)tab->traceset_info->traceset_context; + + g_assert(lttv_iattribute_find_by_path(tab->attributes, + "hooks/showviewer", LTTV_POINTER, &value)); + tmp = (LttvHooks*)*(value.v_pointer); + if(tmp == NULL) + { + g_warning("The viewer(s) did not add any show hook"); + return; } -} - -void remove_toolbar_item(gpointer main_win, gpointer user_data) -{ - MainWindow * mw = (MainWindow *) main_win; - lttv_toolbar_closure *toolbar_item = (lttv_toolbar_closure *)user_data; - GtkWidget * tool_menu_title_menu, *insert_view; + + // Call the show, where viewers add hooks to context and fill the + // time and number of events requested it the time_requests GArray. + lttv_hooks_call(tmp, NULL); - tool_menu_title_menu = lookup_widget(mw->mwindow,"MToolbar1"); - insert_view = (GtkWidget*)g_hash_table_lookup(mw->hash_toolbar_item, - toolbar_item->tooltip); - if(insert_view){ - g_hash_table_remove(mw->hash_toolbar_item, toolbar_item->tooltip); - gtk_container_remove (GTK_CONTAINER (tool_menu_title_menu), insert_view); - } + } -/** - * Remove menu and toolbar item when a module unloaded from all - * main windows +/* + * execute_events_requests + * + * Idle function that executes the pending requests for a tab. + * + * @return return value : TRUE : keep the idle function, FALSE : remove it. */ - -void main_window_remove_menu_item(lttvwindow_viewer_constructor constructor) +gboolean execute_events_requests(Tab *tab) { - int i; - LttvMenus * menu; - lttv_menu_closure *menu_item; - LttvAttributeValue value; - LttvIAttribute *attributes = LTTV_IATTRIBUTE(lttv_global_attributes()); - - g_assert(lttv_iattribute_find_by_path(attributes, - "viewers/menu", LTTV_POINTER, &value)); - menu = (LttvMenus*)*(value.v_pointer); - - if(menu){ - for(i=0;ilen;i++){ - menu_item = &g_array_index(menu, lttv_menu_closure, i); - if(menu_item->con != constructor) continue; - if(g_main_window_list){ - g_slist_foreach(g_main_window_list, remove_menu_item, menu_item); - } - break; - } - } - + return ( lttvwindow_process_pending_requests(tab) ); } -void main_window_remove_toolbar_item(lttvwindow_viewer_constructor constructor) -{ - int i; - LttvToolbars * toolbar; - lttv_toolbar_closure *toolbar_item; - LttvAttributeValue value; - LttvIAttribute *attributes = LTTV_IATTRIBUTE(lttv_global_attributes()); - - g_assert(lttv_iattribute_find_by_path(attributes, - "viewers/toolbar", LTTV_POINTER, &value)); - toolbar = (LttvToolbars*)*(value.v_pointer); - - if(toolbar){ - for(i=0;ilen;i++){ - toolbar_item = &g_array_index(toolbar, lttv_toolbar_closure, i); - if(toolbar_item->con != constructor) continue; - if(g_main_window_list){ - g_slist_foreach(g_main_window_list, remove_toolbar_item, toolbar_item); - } - break; - } - } -}