//guint currently_Selected_Event ;
guint number_of_process;
+ guint background_info_waiting; /* Number of background requests waited for
+ in order to have all the info ready. */
} ;
drawing_get_drawing_area(control_flow_data->drawing);
control_flow_data->number_of_process = 0;
+ control_flow_data->background_info_waiting = 0;
/* Create the Process list */
control_flow_data->process_list = processlist_construct();
#define g_info(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, format)
#define g_debug(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, format)
+
+GdkColor drawing_colors[NUM_COLORS] =
+{ /* Pixel, R, G, B */
+ { 0, 0, 0, 0 }, /* COL_BLACK */
+ { 0, 0xFFFF, 0xFFFF, 0xFFFF }, /* COL_WHITE */
+ { 0, 0x0fff, 0xffff, 0xfff0 }, /* COL_WAIT_FORK */
+ { 0, 0xffff, 0xffff, 0x0000 }, /* COL_WAIT_CPU */
+ { 0, 0xffff, 0x0000, 0xffff }, /* COL_EXIT */
+ { 0, 0xffff, 0x0000, 0x0000 }, /* COL_WAIT */
+ { 0, 0x0000, 0xffff, 0x0000 } /* COL_RUN */
+};
+
+
+
/*****************************************************************************
* drawing functions *
*****************************************************************************/
motion_notify_ruler(GtkWidget *widget, GdkEventMotion *event, gpointer user_data);
-//FIXME Colors will need to be dynamic. Graphic context part not done so far.
-typedef enum
-{
- RED,
- GREEN,
- BLUE,
- WHITE,
- BLACK
-
-} ControlFlowColors;
-
-/* Vector of unallocated colors */
-static GdkColor CF_Colors [] =
-{
- { 0, 0xffff, 0x0000, 0x0000 }, // RED
- { 0, 0x0000, 0xffff, 0x0000 }, // GREEN
- { 0, 0x0000, 0x0000, 0xffff }, // BLUE
- { 0, 0xffff, 0xffff, 0xffff }, // WHITE
- { 0, 0x0000, 0x0000, 0x0000 } // BLACK
-};
-
-
/* Function responsible for updating the exposed area.
* It must do an events request to the lttvwindow API to ask for this update.
* Note : this function cannot clear the background, because it may
LttvTracesetContext *tsc = LTTV_TRACESET_CONTEXT(tss);
LttTime current_time = lttv_traceset_context_get_current_tfc(tsc)->timestamp;
- cfd->drawing->last_start = current_time;
+ cfd->drawing->last_start = LTT_TIME_MIN(current_time,
+ events_request->end_time);
}
window_end,
&time);
- lttvwindow_report_current_time(control_flow_data->tab, &time);
+ lttvwindow_report_current_time(control_flow_data->tab, time);
}
#define SAFETY 50 // safety pixels at right and bottom of pixmap buffer
+
+typedef enum _draw_color { COL_BLACK,
+ COL_WHITE,
+ COL_WAIT_FORK,
+ COL_WAIT_CPU,
+ COL_EXIT,
+ COL_WAIT,
+ COL_RUN,
+ NUM_COLORS } draw_color;
+
+extern GdkColor drawing_colors[NUM_COLORS];
+
/* This part of the viewer does :
* Draw horizontal lines, getting graphic context as arg.
* Copy region of the screen into another.
/* drawing hook functions */
gboolean draw_text( void *hook_data, void *call_data)
{
- PropertiesText *Properties = (PropertiesText*)hook_data;
+ PropertiesText *properties = (PropertiesText*)hook_data;
DrawContext *draw_context = (DrawContext*)call_data;
PangoContext *context;
context = pango_layout_get_context(layout);
font_desc = pango_context_get_font_description(context);
- pango_font_description_set_size(font_desc, Properties->size*PANGO_SCALE);
+ pango_font_description_set_size(font_desc, properties->size*PANGO_SCALE);
pango_layout_context_changed(layout);
- pango_layout_set_text(layout, Properties->text, -1);
+ pango_layout_set_text(layout, properties->text, -1);
pango_layout_get_pixel_extents(layout, &ink_rect, NULL);
- switch(Properties->position) {
- case OVER:
- gdk_draw_layout_with_colors(draw_context->drawable,
- draw_context->gc,
- draw_context->drawinfo.modify_over.x,
- draw_context->drawinfo.modify_over.y,
- layout, Properties->foreground, Properties->background);
- draw_context->drawinfo.modify_over.x += ink_rect.width;
+ gint x=0, y=0;
+ gint *offset=NULL;
+ gboolean enough_space = FALSE;
+ gint width = ink_rect.width;
+
+ switch(properties->position.x) {
+ case POS_START:
+ x = draw_context->drawinfo.start.x;
+ switch(properties->position.y) {
+ case OVER:
+ offset = &draw_context->drawinfo.start.offset.over;
+ x += draw_context->drawinfo.start.offset.over;
+ y = draw_context->drawinfo.y.over;
+ break;
+ case MIDDLE:
+ offset = &draw_context->drawinfo.start.offset.middle;
+ x += draw_context->drawinfo.start.offset.middle;
+ y = draw_context->drawinfo.y.middle;
+ break;
+ case UNDER:
+ offset = &draw_context->drawinfo.start.offset.under;
+ x += draw_context->drawinfo.start.offset.under;
+ y = draw_context->drawinfo.y.under;
+ break;
+ }
+ /* verify if there is enough space to draw */
+ if(x + width <= draw_context->drawinfo.end.x) {
+ enough_space = TRUE;
+ *offset += width;
+ }
break;
- case MIDDLE:
- gdk_draw_layout_with_colors(draw_context->drawable,
- draw_context->gc,
- draw_context->drawinfo.modify_middle.x,
- draw_context->drawinfo.modify_middle.y,
- layout, Properties->foreground, Properties->background);
- draw_context->drawinfo.modify_middle.x += ink_rect.width;
- break;
- case UNDER:
- gdk_draw_layout_with_colors(draw_context->drawable,
- draw_context->gc,
- draw_context->drawinfo.modify_under.x,
- draw_context->drawinfo.modify_under.y,
- layout, Properties->foreground, Properties->background);
- draw_context->drawinfo.modify_under.x += ink_rect.width;
+ case POS_END:
+ x = draw_context->drawinfo.end.x;
+ switch(properties->position.y) {
+ case OVER:
+ offset = &draw_context->drawinfo.end.offset.over;
+ x += draw_context->drawinfo.end.offset.over;
+ y = draw_context->drawinfo.y.over;
+ break;
+ case MIDDLE:
+ offset = &draw_context->drawinfo.end.offset.middle;
+ x += draw_context->drawinfo.end.offset.middle;
+ y = draw_context->drawinfo.y.middle;
+ break;
+ case UNDER:
+ offset = &draw_context->drawinfo.end.offset.under;
+ x += draw_context->drawinfo.end.offset.under;
+ y = draw_context->drawinfo.y.under;
+ break;
+ }
+ /* verify if there is enough space to draw */
+ if(x - width >= draw_context->drawinfo.start.x) {
+ enough_space = TRUE;
+ *offset -= width;
+ }
break;
}
+ if(enough_space)
+ gdk_draw_layout_with_colors(draw_context->drawable,
+ draw_context->gc,
+ x,
+ y,
+ layout, properties->foreground, properties->background);
+
return 0;
}
icon_info = *(value.v_pointer);
}
- gdk_gc_set_clip_mask(draw_context->gc, icon_info->mask);
+ gint x=0, y=0;
+ gint *offset=NULL;
+ gboolean enough_space = FALSE;
+ gint width = properties->width;
- switch(properties->position) {
- case OVER:
- gdk_gc_set_clip_origin(
- draw_context->gc,
- draw_context->drawinfo.modify_over.x,
- draw_context->drawinfo.modify_over.y);
- gdk_draw_drawable(draw_context->drawable,
- draw_context->gc,
- icon_info->pixmap,
- 0, 0,
- draw_context->drawinfo.modify_over.x,
- draw_context->drawinfo.modify_over.y,
- properties->width, properties->height);
-
- draw_context->drawinfo.modify_over.x += properties->width;
-
- break;
- case MIDDLE:
- gdk_gc_set_clip_origin(
- draw_context->gc,
- draw_context->drawinfo.modify_middle.x,
- draw_context->drawinfo.modify_middle.y);
- gdk_draw_drawable(draw_context->drawable,
- draw_context->gc,
- icon_info->pixmap,
- 0, 0,
- draw_context->drawinfo.modify_middle.x,
- draw_context->drawinfo.modify_middle.y,
- properties->width, properties->height);
-
- draw_context->drawinfo.modify_middle.x += properties->width;
+ switch(properties->position.x) {
+ case POS_START:
+ x = draw_context->drawinfo.start.x;
+ switch(properties->position.y) {
+ case OVER:
+ offset = &draw_context->drawinfo.start.offset.over;
+ x += draw_context->drawinfo.start.offset.over;
+ y = draw_context->drawinfo.y.over;
+ break;
+ case MIDDLE:
+ offset = &draw_context->drawinfo.start.offset.middle;
+ x += draw_context->drawinfo.start.offset.middle;
+ y = draw_context->drawinfo.y.middle;
+ break;
+ case UNDER:
+ offset = &draw_context->drawinfo.start.offset.under;
+ x += draw_context->drawinfo.start.offset.under;
+ y = draw_context->drawinfo.y.under;
+ break;
+ }
+ /* verify if there is enough space to draw */
+ if(x + width <= draw_context->drawinfo.end.x) {
+ enough_space = TRUE;
+ *offset += width;
+ }
break;
- case UNDER:
- gdk_gc_set_clip_origin(
- draw_context->gc,
- draw_context->drawinfo.modify_under.x,
- draw_context->drawinfo.modify_under.y);
- gdk_draw_drawable(draw_context->drawable,
- draw_context->gc,
- icon_info->pixmap,
- 0, 0,
- draw_context->drawinfo.modify_under.x,
- draw_context->drawinfo.modify_under.y,
- properties->width, properties->height);
-
- draw_context->drawinfo.modify_under.x += properties->width;
+ case POS_END:
+ x = draw_context->drawinfo.end.x;
+ switch(properties->position.y) {
+ case OVER:
+ offset = &draw_context->drawinfo.end.offset.over;
+ x += draw_context->drawinfo.end.offset.over;
+ y = draw_context->drawinfo.y.over;
+ break;
+ case MIDDLE:
+ offset = &draw_context->drawinfo.end.offset.middle;
+ x += draw_context->drawinfo.end.offset.middle;
+ y = draw_context->drawinfo.y.middle;
+ break;
+ case UNDER:
+ offset = &draw_context->drawinfo.end.offset.under;
+ x += draw_context->drawinfo.end.offset.under;
+ y = draw_context->drawinfo.y.under;
+ break;
+ }
+ /* verify if there is enough space to draw */
+ if(x - width >= draw_context->drawinfo.start.x) {
+ enough_space = TRUE;
+ *offset -= width;
+ }
break;
}
- gdk_gc_set_clip_origin(draw_context->gc, 0, 0);
- gdk_gc_set_clip_mask(draw_context->gc, NULL);
-
+ if(enough_space) {
+ gdk_gc_set_clip_mask(draw_context->gc, icon_info->mask);
+
+ gdk_gc_set_clip_origin(
+ draw_context->gc,
+ x,
+ y);
+ gdk_draw_drawable(draw_context->drawable,
+ draw_context->gc,
+ icon_info->pixmap,
+ 0, 0,
+ x,
+ y,
+ properties->width, properties->height);
+
+ gdk_gc_set_clip_origin(draw_context->gc, 0, 0);
+ gdk_gc_set_clip_mask(draw_context->gc, NULL);
+ }
return 0;
}
{
PropertiesLine *properties = (PropertiesLine*)hook_data;
DrawContext *draw_context = (DrawContext*)call_data;
- //GdkGC *gc = gdk_gc_new(draw_context->drawable);
//gdk_gc_set_foreground(draw_context->gc, properties->color);
gdk_gc_set_rgb_fg_color(draw_context->gc, &properties->color);
// draw_context->drawinfo.middle.x,
// draw_context->drawinfo.middle.y);
- switch(properties->position) {
+ gint x_begin=0, x_end=0, y=0;
+
+ x_begin = draw_context->drawinfo.start.x;
+ x_end = draw_context->drawinfo.end.x;
+
+ switch(properties->y) {
case OVER:
- drawing_draw_line(
- NULL, draw_context->drawable,
- draw_context->previous->over->x,
- draw_context->previous->over->y,
- draw_context->drawinfo.over.x,
- draw_context->current->over->y,
- draw_context->gc);
+ y = draw_context->drawinfo.y.over;
break;
case MIDDLE:
- drawing_draw_line(
- NULL, draw_context->drawable,
- draw_context->previous->middle->x,
- draw_context->previous->middle->y,
- draw_context->drawinfo.middle.x,
- draw_context->drawinfo.middle.y,
- draw_context->gc);
+ y = draw_context->drawinfo.y.middle;
break;
case UNDER:
- drawing_draw_line(
- NULL, draw_context->drawable,
- draw_context->previous->under->x,
- draw_context->previous->under->y,
- draw_context->drawinfo.under.x,
- draw_context->drawinfo.under.y,
- draw_context->gc);
-
+ y = draw_context->drawinfo.y.under;
break;
}
-
- //gdk_gc_unref(gc);
+
+ drawing_draw_line(
+ NULL, draw_context->drawable,
+ x_begin,
+ y,
+ x_end,
+ y,
+ draw_context->gc);
return 0;
}
//gdk_gc_set_foreground(draw_context->gc, properties->color);
gdk_gc_set_rgb_fg_color(draw_context->gc, properties->color);
- switch(properties->position) {
- case OVER:
- gdk_draw_arc(draw_context->drawable, draw_context->gc,
- properties->filled,
- draw_context->drawinfo.modify_over.x,
- draw_context->drawinfo.modify_over.y,
- properties->size, properties->size, 0, 360*64);
- draw_context->drawinfo.modify_over.x += properties->size;
- break;
- case MIDDLE:
- gdk_draw_arc(draw_context->drawable, draw_context->gc,
- properties->filled,
- draw_context->drawinfo.modify_middle.x,
- draw_context->drawinfo.modify_middle.y,
- properties->size, properties->size, 0, 360*64);
- draw_context->drawinfo.modify_middle.x += properties->size;
-
- break;
- case UNDER:
- gdk_draw_arc(draw_context->drawable, draw_context->gc,
- properties->filled,
- draw_context->drawinfo.modify_under.x,
- draw_context->drawinfo.modify_under.y,
- properties->size, properties->size, 0, 360*64);
- draw_context->drawinfo.modify_under.x += properties->size;
+ gint x=0, y=0;
+ gint *offset=NULL;
+ gboolean enough_space = FALSE;
+ gint width = properties->size;
+ switch(properties->position.x) {
+ case POS_START:
+ x = draw_context->drawinfo.start.x;
+ switch(properties->position.y) {
+ case OVER:
+ offset = &draw_context->drawinfo.start.offset.over;
+ x += draw_context->drawinfo.start.offset.over;
+ y = draw_context->drawinfo.y.over;
+ break;
+ case MIDDLE:
+ offset = &draw_context->drawinfo.start.offset.middle;
+ x += draw_context->drawinfo.start.offset.middle;
+ y = draw_context->drawinfo.y.middle;
+ break;
+ case UNDER:
+ offset = &draw_context->drawinfo.start.offset.under;
+ x += draw_context->drawinfo.start.offset.under;
+ y = draw_context->drawinfo.y.under;
+ break;
+ }
+ /* verify if there is enough space to draw */
+ if(x + width <= draw_context->drawinfo.end.x) {
+ enough_space = TRUE;
+ *offset += width;
+ }
+ break;
+ case POS_END:
+ x = draw_context->drawinfo.end.x;
+ switch(properties->position.y) {
+ case OVER:
+ offset = &draw_context->drawinfo.end.offset.over;
+ x += draw_context->drawinfo.end.offset.over;
+ y = draw_context->drawinfo.y.over;
+ break;
+ case MIDDLE:
+ offset = &draw_context->drawinfo.end.offset.middle;
+ x += draw_context->drawinfo.end.offset.middle;
+ y = draw_context->drawinfo.y.middle;
+ break;
+ case UNDER:
+ offset = &draw_context->drawinfo.end.offset.under;
+ x += draw_context->drawinfo.end.offset.under;
+ y = draw_context->drawinfo.y.under;
+ break;
+ }
+ /* verify if there is enough space to draw */
+ if(x - width >= draw_context->drawinfo.start.x) {
+ enough_space = TRUE;
+ *offset -= width;
+ }
break;
}
+ if(enough_space)
+ gdk_draw_arc(draw_context->drawable, draw_context->gc,
+ properties->filled,
+ x,
+ y,
+ properties->size, properties->size, 0, 360*64);
return 0;
}
// draw_context->previous->over->x);
gdk_draw_rectangle(draw_context->drawable, draw_context->gc,
TRUE,
- draw_context->previous->over->x,
- draw_context->previous->over->y,
- draw_context->drawinfo.over.x - draw_context->previous->over->x,
- draw_context->previous->under->y-draw_context->previous->over->y);
+ draw_context->drawinfo.start.x,
+ draw_context->drawinfo.y.over,
+ draw_context->drawinfo.end.x - draw_context->drawinfo.start.x,
+ draw_context->drawinfo.y.under - draw_context->drawinfo.y.over);
return 0;
}
ITEM_TEXT, ITEM_ICON, ITEM_LINE, ITEM_POINT, ITEM_BACKGROUND
};
+typedef enum _RelPosX {
+ POS_START, POS_END
+} RelPosX;
-typedef enum _RelPos {
+typedef enum _RelPosY {
OVER, MIDDLE, UNDER
-} RelPos;
+} RelPosY;
/* The DrawContext keeps information about the current drawing position and
PangoLayout *pango_layout;
struct {
- gint x_start;
- gint x_end;
+ struct {
+ gint x;
+ struct {
+ gint over;
+ gint middle;
+ gint under;
+ } offset;
+ } start;
+
+ struct {
+ gint x;
+ struct {
+ gint over;
+ gint middle;
+ gint under;
+ } offset;
+ } end;
+
+ struct {
+ gint over;
+ gint middle;
+ gint under;
+ } y;
- gint y_over;
- gint y_middle;
- gint y_under;
-
- gint x_modify_over;
- gint x_modify_middle;
- gint x_modify_under;
} drawinfo;
};
struct _PropertiesText {
GdkColor *foreground;
GdkColor *background;
- gint size;
- gchar *text;
- RelPos position;
+ gint size;
+ gchar *text;
+ struct {
+ RelPosX x;
+ RelPosY y;
+ } position;
};
gchar *icon_name;
gint width;
gint height;
- RelPos position;
+ struct {
+ RelPosX x;
+ RelPosY y;
+ } position;
};
struct _PropertiesLine {
GdkColor color;
gint line_width;
GdkLineStyle style;
- RelPos position;
+ RelPosY y;
};
struct _PropertiesArc {
GdkColor *color;
gint size; /* We force circle by width = height */
gboolean filled;
- RelPos position;
+ struct {
+ RelPosX x;
+ RelPosY y;
+ } position;
};
struct _PropertiesBG {
* process_states/ "name associated with LTTV_STATE_SYSCALL"
*/
+
+#if 0
/*
* The add_operation has to do a quick sort by priority to keep the operations
* in the right order.
*/
void exec_operations( LttvIAttribute *attributes,
gchar *pathname);
-
-
-/*
- * Functions to create Properties structures.
- */
-
-PropertiesText *properties_text_create(
- GdkColor *foreground,
- GdkColor *background,
- gint size,
- gchar *text,
- RelPos position);
-
-PropertiesIcon *properties_icon_create(
- gchar *icon_name,
- gint width,
- gint height,
- RelPos position);
-
-PropertiesLine *properties_line_create(
- GdkColor *color,
- gint line_width,
- GdkLineStyle style,
- RelPos position);
-
-PropertiesArc *properties_arc_create(
- GdkColor *color,
- gint size,
- gboolean filled,
- RelPos position);
-
-PropertiesBG *properties_bg_create(
- GdkColor *color);
-
-
-
+#endif //0
/*
* Here follow the prototypes of the hook functions used to draw the
/* Action to do when background computation completed.
*
- * Eventually, will have to check that every requested traces are finished
- * before doing the redraw. It will save unnecessary processor usage.
+ * Wait for all the awaited computations to be over.
*/
gint background_ready(void *hook_data, void *call_data)
LttvTracesetContext *tsc =
lttvwindow_get_traceset_context(control_flow_data->tab);
- g_debug("control flow viewer : background computation data ready.");
+ control_flow_data->background_info_waiting--;
+
+ if(control_flow_data->background_info_waiting == 0) {
+ g_debug("control flow viewer : background computation data ready.");
- drawing_clear(control_flow_data->drawing);
- processlist_clear(control_flow_data->process_list);
-#if 0
- {
- gint num_traces = lttv_traceset_number(tsc->ts);
- gint i;
- LttvTraceState *ts;
- ProcessAddClosure closure;
- closure.cfd = control_flow_data;
-
- for(i=0;i<num_traces;i++) {
- ts = (LttvTraceState*)tsc->traces[i];
-
- closure.trace_num = i;
-
- /* add all the processes to the list */
- lttv_state_for_each_process(ts, (GHFunc)process_add, &closure);
- }
+ drawing_clear(control_flow_data->drawing);
+ processlist_clear(control_flow_data->process_list);
+ redraw_notify(control_flow_data, NULL);
}
-#endif //0
- redraw_notify(control_flow_data, NULL);
return 0;
}
/* Request background computation. Verify if it is in progress or ready first.
- *
- * Right now, for all loaded traces.
- *
- * Later : must be only for each trace in the tab's traceset.
+ * Only for each trace in the tab's traceset.
*/
void request_background_data(ControlFlowData *control_flow_data)
{
- gint num_traces = lttvwindowtraces_get_number();
+ LttvTracesetContext * tsc =
+ lttvwindow_get_traceset_context(control_flow_data->tab);
+ gint num_traces = lttv_traceset_number(tsc->ts);
gint i;
LttvTrace *trace;
lttv_hooks_new();
lttv_hooks_add(background_ready_hook, background_ready, control_flow_data,
LTTV_PRIO_DEFAULT);
+ control_flow_data->background_info_waiting = 0;
for(i=0;i<num_traces;i++) {
- trace = lttvwindowtraces_get_trace(i);
+ trace = lttv_traceset_get(tsc->ts, i);
if(lttvwindowtraces_get_ready(g_quark_from_string("state"),trace)==FALSE) {
ltt_time_infinite,
NULL,
background_ready_hook);
+ control_flow_data->background_info_waiting++;
} else { /* in progress */
lttvwindowtraces_background_notify_current(control_flow_data,
ltt_time_infinite,
NULL,
background_ready_hook);
-
+ control_flow_data->background_info_waiting++;
}
}
}
PropertiesLine prop_line;
prop_line.line_width = 2;
prop_line.style = GDK_LINE_SOLID;
- prop_line.position = MIDDLE;
+ prop_line.y = MIDDLE;
+ //GdkColormap *colormap = gdk_colormap_get_system();
g_debug("prepare_line for state : %s", g_quark_to_string(process->state->s));
/* color of line : status of the process */
if(process->state->s == LTTV_STATE_UNNAMED)
- {
- prop_line.color.red = 0xffff;
- prop_line.color.green = 0xffff;
- prop_line.color.blue = 0xffff;
- }
+ prop_line.color = drawing_colors[COL_WHITE];
else if(process->state->s == LTTV_STATE_WAIT_FORK)
- {
- prop_line.color.red = 0x0fff;
- prop_line.color.green = 0xffff;
- prop_line.color.blue = 0xfff0;
- }
+ prop_line.color = drawing_colors[COL_WAIT_FORK];
else if(process->state->s == LTTV_STATE_WAIT_CPU)
- {
- prop_line.color.red = 0xffff;
- prop_line.color.green = 0xffff;
- prop_line.color.blue = 0x0000;
- }
+ prop_line.color = drawing_colors[COL_WAIT_CPU];
else if(process->state->s == LTTV_STATE_EXIT)
- {
- prop_line.color.red = 0xffff;
- prop_line.color.green = 0x0000;
- prop_line.color.blue = 0xffff;
- }
+ prop_line.color = drawing_colors[COL_EXIT];
else if(process->state->s == LTTV_STATE_WAIT)
- {
- prop_line.color.red = 0xffff;
- prop_line.color.green = 0x0000;
- prop_line.color.blue = 0x0000;
- }
+ prop_line.color = drawing_colors[COL_WAIT];
else if(process->state->s == LTTV_STATE_RUN)
- {
- prop_line.color.red = 0x0000;
- prop_line.color.green = 0xffff;
- prop_line.color.blue = 0x0000;
- }
+ prop_line.color = drawing_colors[COL_RUN];
else
- {
- prop_line.color.red = 0xffff;
- prop_line.color.green = 0xffff;
- prop_line.color.blue = 0xffff;
- }
+ prop_line.color = drawing_colors[COL_WHITE];
+
+ //gdk_colormap_alloc_color(colormap,
+ // prop_line.color,
+ // FALSE,
+ // TRUE);
return prop_line;
*/
guint pid_out;
+ guint pid_in;
{
- guint pid_in;
LttField *f = ltt_event_field(e);
LttField *element;
element = ltt_field_member(f,0);
pid_in = ltt_event_get_long_unsigned(e,element);
g_debug("out : %u in : %u", pid_out, pid_in);
}
-
- /* First, check if the current process is in the state computation process
- * list. If it is there, that means we must add it right now and draw items
- * from the beginning of the read for it. If it is not present, it's a new
- * process and it was not present : it will be added after the state update.
- */
- LttvProcessState *process;
- process = lttv_state_find_process(tfs, pid_out);
- if(process != NULL) {
- /* Well, the process_out existed : we must get it in the process hash
- * or add it, and draw its items.
- */
- /* Add process to process list (if not present) */
- guint y = 0, height = 0, pl_height = 0;
- HashedProcessData *hashed_process_data = NULL;
- ProcessList *process_list =
- guicontrolflow_get_process_list(control_flow_data);
- LttTime birth = process->creation_time;
- const gchar *name = g_quark_to_string(process->name);
+ {
+ /* For the pid_out */
+ /* First, check if the current process is in the state computation
+ * process list. If it is there, that means we must add it right now and
+ * draw items from the beginning of the read for it. If it is not
+ * present, it's a new process and it was not present : it will
+ * be added after the state update. */
+ LttvProcessState *process;
+ process = lttv_state_find_process(tfs, pid_out);
- if(processlist_get_process_pixels(process_list,
+ if(process != NULL) {
+ /* Well, the process_out existed : we must get it in the process hash
+ * or add it, and draw its items.
+ */
+ /* Add process to process list (if not present) */
+ guint y = 0, height = 0, pl_height = 0;
+ HashedProcessData *hashed_process_data = NULL;
+ ProcessList *process_list =
+ guicontrolflow_get_process_list(control_flow_data);
+ LttTime birth = process->creation_time;
+ const gchar *name = g_quark_to_string(process->name);
+
+ if(processlist_get_process_pixels(process_list,
+ pid_out,
+ &birth,
+ tfc->t_context->index,
+ &y,
+ &height,
+ &hashed_process_data) == 1)
+ {
+ /* Process not present */
+ processlist_add(process_list,
pid_out,
&birth,
tfc->t_context->index,
- &y,
- &height,
- &hashed_process_data) == 1)
- {
- /* Process not present */
- processlist_add(process_list,
- pid_out,
- &birth,
- tfc->t_context->index,
- name,
- &pl_height,
- &hashed_process_data);
- processlist_get_process_pixels(process_list,
- pid_out,
+ name,
+ &pl_height,
+ &hashed_process_data);
+ processlist_get_process_pixels(process_list,
+ pid_out,
+ &birth,
+ tfc->t_context->index,
+ &y,
+ &height,
+ &hashed_process_data);
+ drawing_insert_square( drawing, y, height);
+ }
+
+ /* Now, the process is in the state hash and our own process hash.
+ * We definitely can draw the items related to the ending state.
+ */
+
+ /* Check if the x position is unset. In can have been left unset by
+ * a draw closure from a after chunk hook. This should never happen,
+ * because it must be set by before chunk hook to the damage_begin
+ * value.
+ */
+ g_assert(hashed_process_data->x != -1);
+ {
+ guint x;
+ DrawContext draw_context;
+
+ convert_time_to_pixels(
+ time_window.start_time,
+ end_time,
+ evtime,
+ width,
+ &x);
+
+ /* Now create the drawing context that will be used to draw
+ * items related to the last state. */
+ draw_context.drawable = drawing->pixmap;
+ draw_context.gc = drawing->gc;
+ draw_context.pango_layout = drawing->pango_layout;
+ draw_context.drawinfo.start.x = hashed_process_data->x;
+ draw_context.drawinfo.end.x = x;
+
+ draw_context.drawinfo.y.over = y;
+ draw_context.drawinfo.y.middle = y+(height/4);
+ draw_context.drawinfo.y.under = y+(height/2)+2;
+
+ draw_context.drawinfo.start.offset.over = 0;
+ draw_context.drawinfo.start.offset.middle = 0;
+ draw_context.drawinfo.start.offset.under = 0;
+ draw_context.drawinfo.end.offset.over = 0;
+ draw_context.drawinfo.end.offset.middle = 0;
+ draw_context.drawinfo.end.offset.under = 0;
+
+ {
+ /* Draw the line */
+ PropertiesLine prop_line = prepare_line(process);
+ draw_line((void*)&prop_line, (void*)&draw_context);
+
+ }
+ /* become the last x position */
+ hashed_process_data->x = x;
+ }
+ }
+ }
+
+ {
+ /* For the pid_in */
+ /* First, check if the current process is in the state computation
+ * process list. If it is there, that means we must add it right now and
+ * draw items from the beginning of the read for it. If it is not
+ * present, it's a new process and it was not present : it will
+ * be added after the state update. */
+ LttvProcessState *process;
+ process = lttv_state_find_process(tfs, pid_in);
+
+ if(process != NULL) {
+ /* Well, the process_out existed : we must get it in the process hash
+ * or add it, and draw its items.
+ */
+ /* Add process to process list (if not present) */
+ guint y = 0, height = 0, pl_height = 0;
+ HashedProcessData *hashed_process_data = NULL;
+ ProcessList *process_list =
+ guicontrolflow_get_process_list(control_flow_data);
+ LttTime birth = process->creation_time;
+ const gchar *name = g_quark_to_string(process->name);
+
+ if(processlist_get_process_pixels(process_list,
+ pid_in,
&birth,
tfc->t_context->index,
&y,
&height,
- &hashed_process_data);
- drawing_insert_square( drawing, y, height);
- }
-
- /* Now, the process is in the state hash and our own process hash.
- * We definitely can draw the items related to the ending state.
- */
+ &hashed_process_data) == 1)
+ {
+ /* Process not present */
+ processlist_add(process_list,
+ pid_in,
+ &birth,
+ tfc->t_context->index,
+ name,
+ &pl_height,
+ &hashed_process_data);
+ processlist_get_process_pixels(process_list,
+ pid_in,
+ &birth,
+ tfc->t_context->index,
+ &y,
+ &height,
+ &hashed_process_data);
+ drawing_insert_square( drawing, y, height);
+ }
- /* Check if the x position is unset. In can have been left unset by
- * a draw closure from a after chunk hook. This should never happen,
- * because it must be set by before chunk hook to the damage_begin
- * value.
- */
- g_assert(hashed_process_data->x != -1);
- {
- guint x;
- DrawContext draw_context;
-
- convert_time_to_pixels(
- time_window.start_time,
- end_time,
- evtime,
- width,
- &x);
-
- /* Now create the drawing context that will be used to draw
- * items related to the last state. */
- draw_context.drawable = drawing->pixmap;
- draw_context.gc = drawing->gc;
- draw_context.pango_layout = drawing->pango_layout;
- draw_context.drawinfo.x_start = hashed_process_data->x;
- draw_context.drawinfo.x_end = x;
-
- draw_context.drawinfo.y_over = y;
- draw_context.drawinfo.y_middle = y+(height/4);
- draw_context.drawinfo.y_under = y+(height/2)+2;
-
- draw_context.drawinfo.x_modify_over = hashed_process_data->x;
- draw_context.drawinfo.x_modify_middle = hashed_process_data->x;
- draw_context.drawinfo.x_modify_under = hashed_process_data->x;
-
+ /* Now, the process is in the state hash and our own process hash.
+ * We definitely can draw the items related to the ending state.
+ */
+
+ /* Check if the x position is unset. In can have been left unset by
+ * a draw closure from a after chunk hook. This should never happen,
+ * because it must be set by before chunk hook to the damage_begin
+ * value.
+ */
+ g_assert(hashed_process_data->x != -1);
{
- /* Draw the line */
- PropertiesLine prop_line = prepare_line(process);
- draw_line((void*)&prop_line, (void*)&draw_context);
+ guint x;
+ DrawContext draw_context;
+
+ convert_time_to_pixels(
+ time_window.start_time,
+ end_time,
+ evtime,
+ width,
+ &x);
+
+ /* Now create the drawing context that will be used to draw
+ * items related to the last state. */
+ draw_context.drawable = drawing->pixmap;
+ draw_context.gc = drawing->gc;
+ draw_context.pango_layout = drawing->pango_layout;
+ draw_context.drawinfo.start.x = hashed_process_data->x;
+ draw_context.drawinfo.end.x = x;
+
+ draw_context.drawinfo.y.over = y;
+ draw_context.drawinfo.y.middle = y+(height/4);
+ draw_context.drawinfo.y.under = y+(height/2)+2;
+
+ draw_context.drawinfo.start.offset.over = 0;
+ draw_context.drawinfo.start.offset.middle = 0;
+ draw_context.drawinfo.start.offset.under = 0;
+ draw_context.drawinfo.end.offset.over = 0;
+ draw_context.drawinfo.end.offset.middle = 0;
+ draw_context.drawinfo.end.offset.under = 0;
+
+ {
+ /* Draw the line */
+ PropertiesLine prop_line = prepare_line(process);
+ draw_line((void*)&prop_line, (void*)&draw_context);
+ }
+
+
+ /* become the last x position */
+ hashed_process_data->x = x;
}
}
}
new_time_window.start_time = time_begin;
new_time_window.time_width = width;
- lttvwindow_report_time_window(control_flow_data->tab, &new_time_window);
+ lttvwindow_report_time_window(control_flow_data->tab, new_time_window);
}
else if(ltt_time_compare(current_time, time_end) == 1)
{
new_time_window.start_time = time_begin;
new_time_window.time_width = width;
- lttvwindow_report_time_window(control_flow_data->tab, &new_time_window);
+ lttvwindow_report_time_window(control_flow_data->tab, new_time_window);
}
//gtk_widget_queue_draw(control_flow_data->drawing->drawing_area);
} ClosureData;
-void draw_closure(gpointer key, gpointer value, gpointer user_data)
+/* find_process
+ * Input : A trace and a PID.
+ *
+ * - For each CPU of the trace
+ * - Search in trace states by PID and CPU key
+ * - For each ProcessState found
+ * - If state is not LTTV_STATE_WAIT
+ * - Then this process state is the current one for this PID.
+ * - Stop search.
+ * - If no ProcessState found, return NULL.
+ * - If all ProcessState were in LTTV_STATE_WAIT state, return one of
+ * them arbitrarily.
+ * Than means state is LTTV_STATE_WAIT, CPU unknown.
+ */
+static LttvProcessState *find_process(LttvTraceState *tstate, guint pid)
{
-
- return;
+ guint cpu_num = ltt_trace_per_cpu_tracefile_number(tstate->parent.t);
+ GQuark cpu_name;
+ guint i;
+ LttvProcessState *real_state = NULL;
+
+ for(i=0;i<cpu_num;i++) {
+ cpu_name = ((LttvTracefileState*)tstate->parent.tracefiles[i])->cpu_name;
+ LttvProcessState *state = lttv_state_find_process_from_trace(tstate,
+ cpu_name,
+ pid);
+
+ if(state != NULL) {
+ real_state = state;
+ if(state->state->s != LTTV_STATE_WAIT)
+ break;
+ }
+ }
+ return real_state;
+}
-#if 0
+
+void draw_closure(gpointer key, gpointer value, gpointer user_data)
+{
ProcessInfo *process_info = (ProcessInfo*)key;
HashedProcessData *hashed_process_data = (HashedProcessData*)value;
ClosureData *closure_data = (ClosureData*)user_data;
- ControlFlowData *control_flow_data =
- closure_data->events_request->viewer_data;
-
- GtkWidget *widget = control_flow_data->drawing->drawing_area;
+ EventsRequest *events_request = closure_data->events_request;
+ ControlFlowData *control_flow_data = events_request->viewer_data;
+ Drawing_t *drawing = control_flow_data->drawing;
- /* Get y position of process */
- gint y=0, height=0;
-
- processlist_get_pixels_from_data( control_flow_data->process_list,
- process_info,
- hashed_process_data,
- &y,
- &height);
- /* Get last state of process */
- LttvTraceContext *tc =
- ((LttvTracesetContext*)closure_data->tss)->traces[process_info->trace_num];
- LttvTracesetContext *tsc = (LttvTracesetContext *)closure_data->tss;
-
- LttvTraceState *ts = (LttvTraceState*)tc;
- LttvProcessState *process;
-
- /* We do not provide a cpu_name argument assuming that this is not the
- idle job (pid 0) and thus its pid is unique across all cpus */
- process = lttv_state_find_process_from_trace(ts, 0, process_info->pid);
-
- /* Draw the closing line */
- DrawContext *draw_context = hashed_process_data->draw_context;
- if(draw_context->previous->middle->x == -1)
- {
- draw_context->previous->over->x =
- control_flow_data->drawing->damage_begin;
- draw_context->previous->middle->x =
- control_flow_data->drawing->damage_begin;
- draw_context->previous->under->x =
- control_flow_data->drawing->damage_begin;
-
- g_debug("out middle x_beg : %u",control_flow_data->drawing->damage_begin);
- }
+ LttvTracesetState *tss = closure_data->tss;
+ LttvTracesetContext *tsc = (LttvTracesetContext*)closure_data->tss;
- /* Find pixels corresponding to current time . If the time does
- * not fit in the window, show a warning, not supposed to happend. */
- guint x = 0;
- guint width = control_flow_data->drawing->width;
+ LttTime evtime = closure_data->end_time;
+ TimeWindow time_window =
+ lttvwindow_get_time_window(control_flow_data->tab);
- TimeWindow time_window =
- lttvwindow_get_time_window(control_flow_data->tab);
+ LttTime end_time = ltt_time_add(time_window.start_time,
+ time_window.time_width);
- LttTime time = lttv_traceset_context_get_current_tfc(tsc)->timestamp;
+ if(ltt_time_compare(evtime, time_window.start_time) == -1
+ || ltt_time_compare(evtime, end_time) == 1)
+ return;
- LttTime window_end = ltt_time_add(time_window.time_width,
- time_window.start_time);
-
- convert_time_to_pixels(
- time_window.start_time,
- window_end,
- time,
- width,
- &x);
-
- draw_context->current->middle->x = x;
- draw_context->current->over->x = x;
- draw_context->current->under->x = x;
- draw_context->current->middle->y = y + height/2;
- draw_context->current->over->y = y ;
- draw_context->current->under->y = y + height;
- draw_context->previous->middle->y = y + height/2;
- draw_context->previous->over->y = y ;
- draw_context->previous->under->y = y + height;
- draw_context->drawable = control_flow_data->drawing->pixmap;
- draw_context->pango_layout = control_flow_data->drawing->pango_layout;
- //draw_context->gc = widget->style->black_gc;
- //draw_context->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
- //gdk_gc_copy(draw_context->gc, widget->style->black_gc);
- draw_context->gc = control_flow_data->drawing->gc;
-
- if(process != NULL && process->state->s == LTTV_STATE_RUN)
- {
- PropertiesBG prop_bg;
- prop_bg.color = g_new(GdkColor,1);
-
- /*switch(tfc->index) {
- case 0:
- prop_bg.color->red = 0x1515;
- prop_bg.color->green = 0x1515;
- prop_bg.color->blue = 0x8c8c;
- break;
- case 1:
- prop_bg.color->red = 0x4e4e;
- prop_bg.color->green = 0xa9a9;
- prop_bg.color->blue = 0xa4a4;
- break;
- case 2:
- prop_bg.color->red = 0x7a7a;
- prop_bg.color->green = 0x4a4a;
- prop_bg.color->blue = 0x8b8b;
- break;
- case 3:
- prop_bg.color->red = 0x8080;
- prop_bg.color->green = 0x7777;
- prop_bg.color->blue = 0x4747;
- break;
- default:
- prop_bg.color->red = 0xe7e7;
- prop_bg.color->green = 0xe7e7;
- prop_bg.color->blue = 0xe7e7;
- }
- */
+ guint width = drawing->width;
- g_debug("calling from closure");
- //FIXME : I need the cpu number in process's state to draw this.
- //draw_bg((void*)&prop_bg, (void*)draw_context);
- g_free(prop_bg.color);
- }
+ {
+ /* For the process */
+ /* First, check if the current process is in the state computation
+ * process list. If it is there, that means we must add it right now and
+ * draw items from the beginning of the read for it. If it is not
+ * present, it's a new process and it was not present : it will
+ * be added after the state update. */
+ g_assert(lttv_traceset_number(tsc->ts) > 0);
+ LttvTraceState *trace_state =
+ (LttvTraceState*)tsc->traces[process_info->trace_num];
- PropertiesLine prop_line;
- prop_line.color = g_new(GdkColor,1);
- prop_line.line_width = 2;
- prop_line.style = GDK_LINE_SOLID;
- prop_line.position = MIDDLE;
+ LttvProcessState *process;
+ process = find_process(trace_state, process_info->pid);
- /* color of line : status of the process */
- if(process != NULL)
- {
- if(process->state->s == LTTV_STATE_UNNAMED)
- {
- prop_line.color->red = 0xffff;
- prop_line.color->green = 0xffff;
- prop_line.color->blue = 0xffff;
- }
- else if(process->state->s == LTTV_STATE_WAIT_FORK)
- {
- prop_line.color->red = 0x0fff;
- prop_line.color->green = 0xffff;
- prop_line.color->blue = 0xfff0;
- }
- else if(process->state->s == LTTV_STATE_WAIT_CPU)
- {
- prop_line.color->red = 0xffff;
- prop_line.color->green = 0xffff;
- prop_line.color->blue = 0x0000;
- }
- else if(process->state->s == LTTV_STATE_EXIT)
- {
- prop_line.color->red = 0xffff;
- prop_line.color->green = 0x0000;
- prop_line.color->blue = 0xffff;
- }
- else if(process->state->s == LTTV_STATE_WAIT)
- {
- prop_line.color->red = 0xffff;
- prop_line.color->green = 0x0000;
- prop_line.color->blue = 0x0000;
- }
- else if(process->state->s == LTTV_STATE_RUN)
- {
- prop_line.color->red = 0x0000;
- prop_line.color->green = 0xffff;
- prop_line.color->blue = 0x0000;
- }
- else
- {
- prop_line.color->red = 0xffff;
- prop_line.color->green = 0xffff;
- prop_line.color->blue = 0xffff;
- }
+ if(process != NULL) {
+
+ /* Only draw for processes that are currently in the trace states */
- }
- else
- {
- prop_line.color->red = 0xffff;
- prop_line.color->green = 0xffff;
- prop_line.color->blue = 0xffff;
- }
+ guint y = 0, height = 0, pl_height = 0;
+ ProcessList *process_list =
+ guicontrolflow_get_process_list(control_flow_data);
+ LttTime birth = process_info->birth;
+
+ /* Should be alike when background info is ready */
+ if(control_flow_data->background_info_waiting==0)
+ g_assert(ltt_time_compare(process->creation_time,
+ process_info->birth) == 0);
+ const gchar *name = g_quark_to_string(process->name);
+
+ /* process HAS to be present */
+ g_assert(processlist_get_process_pixels(process_list,
+ process_info->pid,
+ &birth,
+ process_info->trace_num,
+ &y,
+ &height,
+ &hashed_process_data) != 1);
+
+ /* Now, the process is in the state hash and our own process hash.
+ * We definitely can draw the items related to the ending state.
+ */
+
+ /* Check if the x position is unset. In can have been left unset by
+ * a draw closure from a after chunk hook. This should never happen,
+ * because it must be set by before chunk hook to the damage_begin
+ * value.
+ */
+ g_assert(hashed_process_data->x != -1);
+ {
+ guint x;
+ DrawContext draw_context;
- draw_line((void*)&prop_line, (void*)draw_context);
- g_free(prop_line.color);
- //gdk_gc_unref(draw_context->gc);
-
- /* Reset draw_context of the process for next request */
-
- hashed_process_data->draw_context->drawable = NULL;
- hashed_process_data->draw_context->gc = NULL;
- hashed_process_data->draw_context->pango_layout = NULL;
- hashed_process_data->draw_context->current->over->x = -1;
- hashed_process_data->draw_context->current->over->y = -1;
- hashed_process_data->draw_context->current->middle->x = -1;
- hashed_process_data->draw_context->current->middle->y = -1;
- hashed_process_data->draw_context->current->under->x = -1;
- hashed_process_data->draw_context->current->under->y = -1;
- hashed_process_data->draw_context->current->modify_over->x = -1;
- hashed_process_data->draw_context->current->modify_over->y = -1;
- hashed_process_data->draw_context->current->modify_middle->x = -1;
- hashed_process_data->draw_context->current->modify_middle->y = -1;
- hashed_process_data->draw_context->current->modify_under->x = -1;
- hashed_process_data->draw_context->current->modify_under->y = -1;
- hashed_process_data->draw_context->current->status = LTTV_STATE_UNNAMED;
- hashed_process_data->draw_context->previous->over->x = -1;
- hashed_process_data->draw_context->previous->over->y = -1;
- hashed_process_data->draw_context->previous->middle->x = -1;
- hashed_process_data->draw_context->previous->middle->y = -1;
- hashed_process_data->draw_context->previous->under->x = -1;
- hashed_process_data->draw_context->previous->under->y = -1;
- hashed_process_data->draw_context->previous->modify_over->x = -1;
- hashed_process_data->draw_context->previous->modify_over->y = -1;
- hashed_process_data->draw_context->previous->modify_middle->x = -1;
- hashed_process_data->draw_context->previous->modify_middle->y = -1;
- hashed_process_data->draw_context->previous->modify_under->x = -1;
- hashed_process_data->draw_context->previous->modify_under->y = -1;
- hashed_process_data->draw_context->previous->status = LTTV_STATE_UNNAMED;
+ convert_time_to_pixels(
+ time_window.start_time,
+ end_time,
+ evtime,
+ width,
+ &x);
-#endif //0
+ /* Now create the drawing context that will be used to draw
+ * items related to the last state. */
+ draw_context.drawable = drawing->pixmap;
+ draw_context.gc = drawing->gc;
+ draw_context.pango_layout = drawing->pango_layout;
+ draw_context.drawinfo.start.x = hashed_process_data->x;
+ draw_context.drawinfo.end.x = x;
+
+ draw_context.drawinfo.y.over = y;
+ draw_context.drawinfo.y.middle = y+(height/4);
+ draw_context.drawinfo.y.under = y+(height/2)+2;
+
+ draw_context.drawinfo.start.offset.over = 0;
+ draw_context.drawinfo.start.offset.middle = 0;
+ draw_context.drawinfo.start.offset.under = 0;
+ draw_context.drawinfo.end.offset.over = 0;
+ draw_context.drawinfo.end.offset.middle = 0;
+ draw_context.drawinfo.end.offset.under = 0;
+
+ {
+ /* Draw the line */
+ PropertiesLine prop_line = prepare_line(process);
+ draw_line((void*)&prop_line, (void*)&draw_context);
+
+ }
+
+ /* special case LTTV_STATE_WAIT : CPU is unknown. */
+
+ /* become the last x position */
+ hashed_process_data->x = x;
+ }
+ }
+ }
+ return;
}
int before_chunk(void *hook_data, void *call_data)
/*
* for each process
* draw closing line
- * expose
+ * expose
*/
int after_chunk(void *hook_data, void *call_data)
{
ProcessList *process_list =
guicontrolflow_get_process_list(control_flow_data);
- if(tfc != NULL
- && ltt_time_compare(tfc->timestamp, events_request->end_time) <= 0)
- end_time = tfc->timestamp;
+ if(tfc != NULL)
+ end_time = LTT_TIME_MIN(tfc->timestamp, events_request->end_time);
else /* end of traceset, or position now out of request : end */
end_time = events_request->end_time;
gtk_list_store_remove (process_list->list_store, &iter);
-#if 0
- g_free(hashed_process_data->draw_context->previous->modify_under);
- g_free(hashed_process_data->draw_context->previous->modify_middle);
- g_free(hashed_process_data->draw_context->previous->modify_over);
- g_free(hashed_process_data->draw_context->previous->under);
- g_free(hashed_process_data->draw_context->previous->middle);
- g_free(hashed_process_data->draw_context->previous->over);
- g_free(hashed_process_data->draw_context->previous);
- g_free(hashed_process_data->draw_context->current->modify_under);
- g_free(hashed_process_data->draw_context->current->modify_middle);
- g_free(hashed_process_data->draw_context->current->modify_over);
- g_free(hashed_process_data->draw_context->current->under);
- g_free(hashed_process_data->draw_context->current->middle);
- g_free(hashed_process_data->draw_context->current->over);
- g_free(hashed_process_data->draw_context->current);
- g_free(hashed_process_data->draw_context);
- g_free(hashed_process_data);
-#endif //0
-
-
return TRUE; /* remove the element from the hash table */
}
gtk_tree_path_free(tree_path);
gtk_list_store_remove (process_list->list_store, &iter);
-#if 0
- g_free(hashed_process_data->draw_context->previous->modify_under);
- g_free(hashed_process_data->draw_context->previous->modify_middle);
- g_free(hashed_process_data->draw_context->previous->modify_over);
- g_free(hashed_process_data->draw_context->previous->under);
- g_free(hashed_process_data->draw_context->previous->middle);
- g_free(hashed_process_data->draw_context->previous->over);
- g_free(hashed_process_data->draw_context->previous);
- g_free(hashed_process_data->draw_context->current->modify_under);
- g_free(hashed_process_data->draw_context->current->modify_middle);
- g_free(hashed_process_data->draw_context->current->modify_over);
- g_free(hashed_process_data->draw_context->current->under);
- g_free(hashed_process_data->draw_context->current->middle);
- g_free(hashed_process_data->draw_context->current->over);
- g_free(hashed_process_data->draw_context->current);
- g_free(hashed_process_data->draw_context);
- g_free(hashed_process_data);
-#endif //0
+
g_hash_table_remove(process_list->process_hash,
&Process_Info);
if(ltt_time.tv_sec != current_time.tv_sec ||
ltt_time.tv_nsec != current_time.tv_nsec){
event_viewer_data->current_time_updated = TRUE;
- lttvwindow_report_current_time(tab,<t_time);
+ lttvwindow_report_current_time(tab,ltt_time);
}
}else{
g_warning("Can not get iter\n");
LttvTracesetContext *tsc =
LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context);
TimeInterval time_span = tsc->time_span;
+ TimeWindow new_time_window;
+ LttTime new_current_time;
/* Set the tab's time window and current time if
* out of bounds */
|| ltt_time_compare( ltt_time_add(tab->time_window.start_time,
tab->time_window.time_width),
time_span.end_time) > 0) {
- tab->time_window.start_time = time_span.start_time;
- tab->current_time = time_span.start_time;
+ new_time_window.start_time = time_span.start_time;
+
+ new_current_time = time_span.start_time;
LttTime tmp_time;
else
tmp_time.tv_sec = time_span.end_time.tv_sec;
tmp_time.tv_nsec = 0;
- tab->time_window.time_width = tmp_time ;
+ new_time_window.time_width = tmp_time ;
}
-
+ time_change_manager(tab, new_time_window);
+ current_time_change_manager(tab, new_current_time);
+
+#if 0
/* Set scrollbar */
GtkAdjustment *adjustment = gtk_range_get_adjustment(GTK_RANGE(tab->scrollbar));
LttTime upper = ltt_time_sub(time_span.end_time, time_span.start_time);
NULL);
gtk_adjustment_value_changed(adjustment);
+ /* set the time bar. The value callbacks will change their nsec themself */
+ /* start seconds */
+ gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab->MEntry1),
+ (double)time_span.start_time.tv_sec,
+ (double)time_span.end_time.tv_sec);
+
+ /* end seconds */
+ gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab->MEntry3),
+ (double)time_span.start_time.tv_sec,
+ (double)time_span.end_time.tv_sec);
+
+ /* current seconds */
+ gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab->MEntry5),
+ (double)time_span.start_time.tv_sec,
+ (double)time_span.end_time.tv_sec);
+#endif //0
+
/* Finally, call the update hooks of the viewers */
LttvHooks * tmp;
LttvAttributeValue value;
== 0 ) {
g_warning("Can not zoom that far due to time nanosecond precision");
} else {
+ time_change_manager(tab, new_time_window);
+#if 0
/* Set scrollbar */
GtkAdjustment *adjustment = gtk_range_get_adjustment(GTK_RANGE(tab->scrollbar));
//gtk_adjustment_set_value(adjustment,
// ltt_time_to_double(new_time_window.start_time)
// * NANOSECONDS_PER_SECOND);
+#endif //0
}
}
void go_to_time(GtkWidget * widget, gpointer user_data)
{
- g_printf("Go to time\n");
+ g_printf("Go to time\n");
}
void show_time_frame(GtkWidget * widget, gpointer user_data)
}
+void time_change_manager (Tab *tab,
+ TimeWindow new_time_window)
+{
+ /* Only one source of time change */
+ if(tab->time_manager_lock == TRUE) return;
+
+ tab->time_manager_lock = TRUE;
+
+ LttvTracesetContext *tsc = LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context);
+ TimeInterval time_span = tsc->time_span;
+ LttTime start_time = new_time_window.start_time;
+ LttTime end_time = ltt_time_add(new_time_window.start_time,
+ new_time_window.time_width);
+
+ /* Set scrollbar */
+ GtkAdjustment *adjustment = gtk_range_get_adjustment(GTK_RANGE(tab->scrollbar));
+ LttTime upper = ltt_time_sub(time_span.end_time, time_span.start_time);
+#if 0
+ gtk_range_set_increments(GTK_RANGE(tab->scrollbar),
+ ltt_time_to_double(new_time_window.time_width)
+ / SCROLL_STEP_PER_PAGE
+ * NANOSECONDS_PER_SECOND, /* step increment */
+ ltt_time_to_double(new_time_window.time_width)
+ * NANOSECONDS_PER_SECOND); /* page increment */
+ gtk_range_set_range(GTK_RANGE(tab->scrollbar),
+ 0.0, /* lower */
+ ltt_time_to_double(upper)
+ * NANOSECONDS_PER_SECOND); /* upper */
+#endif //0
+ g_object_set(G_OBJECT(adjustment),
+ "lower",
+ 0.0, /* lower */
+ "upper",
+ ltt_time_to_double(upper)
+ * NANOSECONDS_PER_SECOND, /* upper */
+ "step_increment",
+ ltt_time_to_double(new_time_window.time_width)
+ / SCROLL_STEP_PER_PAGE
+ * NANOSECONDS_PER_SECOND, /* step increment */
+ "page_increment",
+ ltt_time_to_double(new_time_window.time_width)
+ * NANOSECONDS_PER_SECOND, /* page increment */
+ "page_size",
+ ltt_time_to_double(new_time_window.time_width)
+ * NANOSECONDS_PER_SECOND, /* page size */
+ NULL);
+ gtk_adjustment_changed(adjustment);
+
+ // g_object_set(G_OBJECT(adjustment),
+ // "value",
+ // ltt_time_to_double(
+ // ltt_time_sub(start_time, time_span.start_time))
+ // * NANOSECONDS_PER_SECOND, /* value */
+ // NULL);
+ //gtk_adjustment_value_changed(adjustment);
+ gtk_range_set_value(GTK_RANGE(tab->scrollbar),
+ ltt_time_to_double(
+ ltt_time_sub(start_time, time_span.start_time))
+ * NANOSECONDS_PER_SECOND /* value */);
+
+ /* set the time bar. */
+ /* start seconds */
+ gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab->MEntry1),
+ (double)time_span.start_time.tv_sec,
+ (double)time_span.end_time.tv_sec);
+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab->MEntry1),
+ (double)start_time.tv_sec);
+
+ /* start nanoseconds */
+ if(start_time.tv_sec == time_span.start_time.tv_sec) {
+ gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab->MEntry2),
+ (double)time_span.start_time.tv_nsec,
+ (double)NANOSECONDS_PER_SECOND-1);
+ }
+ else if(start_time.tv_sec == time_span.end_time.tv_sec) {
+ /* If we are at the end, max nsec to end.. -1 (not zero length) */
+ gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab->MEntry2),
+ 0.0,
+ (double)time_span.end_time.tv_nsec-1);
+ }
+ else /* anywhere else */
+ gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab->MEntry2),
+ 0.0,
+ (double)NANOSECONDS_PER_SECOND-1);
+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab->MEntry2),
+ (double)start_time.tv_nsec);
+
+ /* end seconds */
+ gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab->MEntry3),
+ (double)time_span.start_time.tv_sec,
+ (double)time_span.end_time.tv_sec);
+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab->MEntry3),
+ (double)end_time.tv_sec);
+
+ /* end nanoseconds */
+ if(end_time.tv_sec == time_span.start_time.tv_sec) {
+ gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab->MEntry4),
+ (double)time_span.start_time.tv_nsec+1,
+ (double)NANOSECONDS_PER_SECOND-1);
+ }
+ else if(end_time.tv_sec == time_span.end_time.tv_sec) {
+ /* If we are at the end, max nsec to end.. */
+ gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab->MEntry4),
+ 0.0,
+ (double)time_span.end_time.tv_nsec);
+ }
+ else /* anywhere else */
+ gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab->MEntry4),
+ 0.0,
+ (double)NANOSECONDS_PER_SECOND-1);
+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab->MEntry4),
+ (double)end_time.tv_nsec);
+
+ /* call viewer hooks for new time window */
+ set_time_window(tab, &new_time_window);
+
+ tab->time_manager_lock = FALSE;
+}
+
+
+/* value changed for frame start s
+ *
+ * Check time span : if ns is out of range, clip it the nearest good value.
+ */
+void
+on_MEntry1_value_changed (GtkSpinButton *spinbutton,
+ gpointer user_data)
+{
+ Tab *tab =(Tab *)user_data;
+ LttvTracesetContext * tsc =
+ LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context);
+ TimeInterval time_span = tsc->time_span;
+ gint value = gtk_spin_button_get_value_as_int(spinbutton);
+
+ TimeWindow new_time_window = tab->time_window;
+
+ LttTime end_time = ltt_time_add(new_time_window.start_time,
+ new_time_window.time_width);
+
+ new_time_window.start_time.tv_sec = value;
+
+ /* start nanoseconds */
+ if(new_time_window.start_time.tv_sec == time_span.start_time.tv_sec) {
+ if(new_time_window.start_time.tv_nsec < time_span.start_time.tv_nsec)
+ new_time_window.start_time.tv_nsec = time_span.start_time.tv_nsec;
+ }
+ else if(new_time_window.start_time.tv_sec == time_span.end_time.tv_sec) {
+ if(new_time_window.start_time.tv_nsec > time_span.end_time.tv_nsec)
+ new_time_window.start_time.tv_nsec = time_span.end_time.tv_nsec-1;
+ }
+
+ /* check if end time selected is below or equal */
+ if(ltt_time_compare(new_time_window.start_time, end_time) >= 0) {
+ /* Then, we must push back end time : keep the same time width
+ * if possible, else end traceset time */
+ end_time = LTT_TIME_MIN(time_span.end_time,
+ ltt_time_add(new_time_window.start_time,
+ new_time_window.time_width)
+ );
+ }
+
+ /* Fix the time width to fit start time and end time */
+ new_time_window.time_width = ltt_time_sub(end_time,
+ new_time_window.start_time);
+
+ time_change_manager(tab, new_time_window);
+
+}
+
+void
+on_MEntry2_value_changed (GtkSpinButton *spinbutton,
+ gpointer user_data)
+{
+ Tab *tab =(Tab *)user_data;
+ LttvTracesetContext * tsc =
+ LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context);
+ TimeInterval time_span = tsc->time_span;
+ gint value = gtk_spin_button_get_value_as_int(spinbutton);
+
+ TimeWindow new_time_window = tab->time_window;
+
+ LttTime end_time = ltt_time_add(new_time_window.start_time,
+ new_time_window.time_width);
+
+ new_time_window.start_time.tv_nsec = value;
+
+ /* check if end time selected is below or equal */
+ if(ltt_time_compare(new_time_window.start_time, end_time) >= 0) {
+ /* Then, we must push back end time : keep the same time width
+ * if possible, else end traceset time */
+ end_time = LTT_TIME_MIN(time_span.end_time,
+ ltt_time_add(new_time_window.start_time,
+ new_time_window.time_width)
+ );
+ }
+
+ /* Fix the time width to fit start time and end time */
+ new_time_window.time_width = ltt_time_sub(end_time,
+ new_time_window.start_time);
+
+ time_change_manager(tab, new_time_window);
+
+}
+
+void
+on_MEntry3_value_changed (GtkSpinButton *spinbutton,
+ gpointer user_data)
+{
+ Tab *tab =(Tab *)user_data;
+ LttvTracesetContext * tsc =
+ LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context);
+ TimeInterval time_span = tsc->time_span;
+ gint value = gtk_spin_button_get_value_as_int(spinbutton);
+
+ TimeWindow new_time_window = tab->time_window;
+
+ LttTime end_time = ltt_time_add(new_time_window.start_time,
+ new_time_window.time_width);
+ end_time.tv_sec = value;
+
+ /* end nanoseconds */
+ if(end_time.tv_sec == time_span.start_time.tv_sec) {
+ if(end_time.tv_nsec < time_span.start_time.tv_nsec)
+ end_time.tv_nsec = time_span.start_time.tv_nsec+1;
+ }
+ else if(end_time.tv_sec == time_span.end_time.tv_sec) {
+ if(end_time.tv_nsec > time_span.end_time.tv_nsec)
+ end_time.tv_nsec = time_span.end_time.tv_nsec;
+ }
+
+ /* check if end time selected is below or equal */
+ if(ltt_time_compare(new_time_window.start_time, end_time) >= 0) {
+ /* Then, we must push front start time : keep the same time width
+ * if possible, else end traceset time */
+ new_time_window.start_time = LTT_TIME_MAX(time_span.start_time,
+ ltt_time_sub(end_time,
+ new_time_window.time_width)
+ );
+ }
+
+ /* Fix the time width to fit start time and end time */
+ new_time_window.time_width = ltt_time_sub(end_time,
+ new_time_window.start_time);
+
+ time_change_manager(tab, new_time_window);
+
+}
+
+void
+on_MEntry4_value_changed (GtkSpinButton *spinbutton,
+ gpointer user_data)
+{
+ Tab *tab =(Tab *)user_data;
+ LttvTracesetContext * tsc =
+ LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context);
+ TimeInterval time_span = tsc->time_span;
+ gint value = gtk_spin_button_get_value_as_int(spinbutton);
+
+ TimeWindow new_time_window = tab->time_window;
+
+ LttTime end_time = ltt_time_add(new_time_window.start_time,
+ new_time_window.time_width);
+ end_time.tv_nsec = value;
+
+ /* check if end time selected is below or equal */
+ if(ltt_time_compare(new_time_window.start_time, end_time) >= 0) {
+ /* Then, we must push front start time : keep the same time width
+ * if possible, else end traceset time */
+ new_time_window.start_time = LTT_TIME_MAX(time_span.start_time,
+ ltt_time_sub(end_time,
+ new_time_window.time_width)
+ );
+ }
+
+ /* Fix the time width to fit start time and end time */
+ new_time_window.time_width = ltt_time_sub(end_time,
+ new_time_window.start_time);
+
+ time_change_manager(tab, new_time_window);
+
+}
+
+
+void current_time_change_manager (Tab *tab,
+ LttTime new_current_time)
+{
+ /* Only one source of time change */
+ if(tab->current_time_manager_lock == TRUE) return;
+
+ tab->current_time_manager_lock = TRUE;
+
+ LttvTracesetContext *tsc = LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context);
+ TimeInterval time_span = tsc->time_span;
+
+ tab->current_time = new_current_time;
+
+ /* current seconds */
+ gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab->MEntry5),
+ (double)time_span.start_time.tv_sec,
+ (double)time_span.end_time.tv_sec);
+
+ /* start nanoseconds */
+ if(new_current_time.tv_sec == time_span.start_time.tv_sec) {
+ gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab->MEntry6),
+ (double)time_span.start_time.tv_nsec,
+ (double)NANOSECONDS_PER_SECOND-1);
+ }
+ else if(new_current_time.tv_sec == time_span.end_time.tv_sec) {
+ /* If we are at the end, max nsec to end.. */
+ gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab->MEntry6),
+ 0.0,
+ (double)time_span.end_time.tv_nsec);
+ }
+ else /* anywhere else */
+ gtk_spin_button_set_range(GTK_SPIN_BUTTON(tab->MEntry6),
+ 0.0,
+ (double)NANOSECONDS_PER_SECOND-1);
+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(tab->MEntry6),
+ (double)new_current_time.tv_nsec);
+
+ lttvwindow_report_current_time(tab, tab->current_time);
+
+ tab->current_time_manager_lock = FALSE;
+}
+
+void
+on_MEntry5_value_changed (GtkSpinButton *spinbutton,
+ gpointer user_data)
+{
+ Tab *tab = (Tab*)user_data;
+ LttvTracesetContext * tsc =
+ LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context);
+ TimeInterval time_span = tsc->time_span;
+ gint value = gtk_spin_button_get_value_as_int(spinbutton);
+ LttTime new_current_time = tab->current_time;
+ new_current_time.tv_sec = value;
+
+ /* current nanoseconds */
+ if(new_current_time.tv_sec == time_span.start_time.tv_sec) {
+ if(new_current_time.tv_nsec < time_span.start_time.tv_nsec)
+ new_current_time.tv_nsec = time_span.start_time.tv_nsec;
+ }
+ else if(new_current_time.tv_sec == time_span.end_time.tv_sec) {
+ if(new_current_time.tv_nsec > time_span.end_time.tv_nsec)
+ new_current_time.tv_nsec = time_span.end_time.tv_nsec;
+ }
+
+ current_time_change_manager(tab, new_current_time);
+}
+
+void
+on_MEntry6_value_changed (GtkSpinButton *spinbutton,
+ gpointer user_data)
+{
+ Tab *tab = (Tab*)user_data;
+ gint value = gtk_spin_button_get_value_as_int(spinbutton);
+ LttTime new_current_time = tab->current_time;
+ new_current_time.tv_nsec = value;
+
+ current_time_change_manager(tab, new_current_time);
+}
+
+
void scroll_value_changed_cb(GtkWidget *scrollbar,
gpointer user_data)
{
Tab *tab = (Tab *)user_data;
- TimeWindow time_window;
+ TimeWindow new_time_window;
LttTime time;
GtkAdjustment *adjust = gtk_range_get_adjustment(GTK_RANGE(scrollbar));
gdouble value = gtk_adjustment_get_value(adjust);
- gdouble upper, lower, ratio, page_size;
+ // gdouble upper, lower, ratio, page_size;
+ gdouble page_size;
LttvTracesetContext * tsc =
LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context);
TimeInterval time_span = tsc->time_span;
+ time = ltt_time_add(ltt_time_from_double(value/NANOSECONDS_PER_SECOND),
+ time_span.start_time);
+
+ new_time_window.start_time = time;
+
+ page_size = adjust->page_size;
+
+ new_time_window.time_width =
+ ltt_time_from_double(page_size/NANOSECONDS_PER_SECOND);
+
+
+ time_change_manager(tab, new_time_window);
+#if 0
//time_window = tab->time_window;
lower = adjust->lower;
/* call viewer hooks for new time window */
set_time_window(tab, &time_window);
-
+#endif //0
}
// Add the object's information to the module's array
g_main_window_list = g_slist_append(g_main_window_list, new_m_window);
-
new_window = create_MWindow();
gtk_widget_show (new_window);
g_printf("Notebook does not exist\n");
return;
}
- gtk_notebook_popup_enable (GTK_NOTEBOOK(notebook));
+ //gtk_notebook_popup_enable (GTK_NOTEBOOK(notebook));
//for now there is no name field in LttvTraceset structure
//Use "Traceset" as the label for the default tab
if(parent) {
lttvwindow_add_trace(new_tab,
g_init_trace);
- LttvTraceset *traceset = new_tab->traceset_info->traceset;
- SetTraceset(new_tab, traceset);
}
+ LttvTraceset *traceset = new_tab->traceset_info->traceset;
+ SetTraceset(new_tab, traceset);
}
g_printf("There are now : %d windows\n",g_slist_length(g_main_window_list));
fflush(stdout);
#endif //DEBUG
+ tab->time_manager_lock = FALSE;
+ tab->current_time_manager_lock = FALSE;
//FIXME copy not implemented in lower level
tab->traceset_info->traceset_context =
(LttvTracesetState*)tab->traceset_info->traceset_context);
//determine the current_time and time_window of the tab
+#if 0
if(copy_tab != NULL){
tab->time_window = copy_tab->time_window;
tab->current_time = copy_tab->current_time;
LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context)->
time_span.start_time.tv_nsec;
}
+#endif //0
tab->attributes = LTTV_IATTRIBUTE(g_object_new(LTTV_ATTRIBUTE_TYPE, NULL));
tab->interrupted_state = g_object_new(LTTV_ATTRIBUTE_TYPE, NULL);
TRUE, /* expand */
TRUE, /* Give the extra space to the child */
0); /* No padding */
-
+
+ /* Create the timebar */
+ {
+ tab->MTimebar = gtk_hbox_new(FALSE, 2);
+ gtk_widget_show(tab->MTimebar);
+
+ tab->MText1 = gtk_label_new("Time Frame start: ");
+ gtk_widget_show(tab->MText1);
+ tab->MText2 = gtk_label_new("s");
+ gtk_widget_show(tab->MText2);
+ tab->MText3a = gtk_label_new("ns");
+ gtk_widget_show(tab->MText3a);
+ tab->MText3b = gtk_label_new("end:");
+ gtk_widget_show(tab->MText3b);
+ tab->MText4 = gtk_label_new("s");
+ gtk_widget_show(tab->MText4);
+ tab->MText5a = gtk_label_new("ns");
+ gtk_widget_show(tab->MText5a);
+ tab->MText5b = gtk_label_new("Current Time:");
+ gtk_widget_show(tab->MText5b);
+ tab->MText6 = gtk_label_new("s");
+ gtk_widget_show(tab->MText6);
+ tab->MText7 = gtk_label_new("ns");
+ gtk_widget_show(tab->MText7);
+
+ tab->MEntry1 = gtk_spin_button_new_with_range(0.0, 1.0, 1.0);
+ gtk_spin_button_set_digits(GTK_SPIN_BUTTON(tab->MEntry1),0);
+ gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(tab->MEntry1),TRUE);
+ gtk_widget_show(tab->MEntry1);
+ tab->MEntry2 = gtk_spin_button_new_with_range(0.0, 1.0, 1.0);
+ gtk_spin_button_set_digits(GTK_SPIN_BUTTON(tab->MEntry2),0);
+ gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(tab->MEntry2),TRUE);
+ gtk_widget_show(tab->MEntry2);
+ tab->MEntry3 = gtk_spin_button_new_with_range(0.0, 1.0, 1.0);
+ gtk_spin_button_set_digits(GTK_SPIN_BUTTON(tab->MEntry3),0);
+ gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(tab->MEntry3),TRUE);
+ gtk_widget_show(tab->MEntry3);
+ tab->MEntry4 = gtk_spin_button_new_with_range(0.0, 1.0, 1.0);
+ gtk_spin_button_set_digits(GTK_SPIN_BUTTON(tab->MEntry4),0);
+ gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(tab->MEntry4),TRUE);
+ gtk_widget_show(tab->MEntry4);
+ tab->MEntry5 = gtk_spin_button_new_with_range(0.0, 1.0, 1.0);
+ gtk_spin_button_set_digits(GTK_SPIN_BUTTON(tab->MEntry5),0);
+ gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(tab->MEntry5),TRUE);
+ gtk_widget_show(tab->MEntry5);
+ tab->MEntry6 = gtk_spin_button_new_with_range(0.0, 1.0, 1.0);
+ gtk_spin_button_set_digits(GTK_SPIN_BUTTON(tab->MEntry6),0);
+ gtk_spin_button_set_snap_to_ticks(GTK_SPIN_BUTTON(tab->MEntry6),TRUE);
+ gtk_widget_show(tab->MEntry6);
+
+
+ GtkWidget *temp_widget;
+
+ gtk_box_pack_start (GTK_BOX (tab->MTimebar), tab->MText1, FALSE, FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (tab->MTimebar), tab->MEntry1, FALSE, FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (tab->MTimebar), tab->MText2, FALSE, FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (tab->MTimebar), tab->MEntry2, FALSE, FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (tab->MTimebar), tab->MText3a, FALSE, FALSE, 0);
+ temp_widget = gtk_vseparator_new();
+ gtk_widget_show(temp_widget);
+ gtk_box_pack_start (GTK_BOX (tab->MTimebar), temp_widget, FALSE, FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (tab->MTimebar), tab->MText3b, FALSE, FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (tab->MTimebar), tab->MEntry3, FALSE, FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (tab->MTimebar), tab->MText4, FALSE, FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (tab->MTimebar), tab->MEntry4, FALSE, FALSE, 0);
+ gtk_box_pack_start (GTK_BOX (tab->MTimebar), tab->MText5a, FALSE, FALSE, 0);
+ temp_widget = gtk_vseparator_new();
+ gtk_widget_show(temp_widget);
+ gtk_box_pack_end (GTK_BOX (tab->MTimebar), tab->MText7, FALSE, FALSE, 0);
+ gtk_box_pack_end (GTK_BOX (tab->MTimebar), tab->MEntry6, FALSE, FALSE, 0);
+ gtk_box_pack_end (GTK_BOX (tab->MTimebar), tab->MText6, FALSE, FALSE, 0);
+ gtk_box_pack_end (GTK_BOX (tab->MTimebar), tab->MEntry5, FALSE, FALSE, 0);
+ gtk_box_pack_end (GTK_BOX (tab->MTimebar), tab->MText5b, FALSE, FALSE, 0);
+ gtk_box_pack_end (GTK_BOX (tab->MTimebar), temp_widget, FALSE, FALSE, 0);
+ }
+
gtk_box_pack_end(GTK_BOX(tab->vbox),
tab->scrollbar,
FALSE, /* Do not expand */
FALSE, /* Fill has no effect here (expand false) */
0); /* No padding */
-
+
+ gtk_box_pack_end(GTK_BOX(tab->vbox),
+ tab->MTimebar,
+ FALSE, /* Do not expand */
+ FALSE, /* Fill has no effect here (expand false) */
+ 0); /* No padding */
+
g_object_set_data(G_OBJECT(tab->viewer_container), "focused_viewer", NULL);
g_signal_connect(G_OBJECT(tab->scrollbar), "value-changed",
G_CALLBACK(scroll_value_changed_cb), tab);
+
+ g_signal_connect ((gpointer) tab->MEntry1, "value-changed",
+ G_CALLBACK (on_MEntry1_value_changed),
+ tab);
+ g_signal_connect ((gpointer) tab->MEntry2, "value-changed",
+ G_CALLBACK (on_MEntry2_value_changed),
+ tab);
+ g_signal_connect ((gpointer) tab->MEntry3, "value-changed",
+ G_CALLBACK (on_MEntry3_value_changed),
+ tab);
+ g_signal_connect ((gpointer) tab->MEntry4, "value-changed",
+ G_CALLBACK (on_MEntry4_value_changed),
+ tab);
+ g_signal_connect ((gpointer) tab->MEntry5, "value-changed",
+ G_CALLBACK (on_MEntry5_value_changed),
+ tab);
+ g_signal_connect ((gpointer) tab->MEntry6, "value-changed",
+ G_CALLBACK (on_MEntry6_value_changed),
+ tab);
+
//g_signal_connect(G_OBJECT(tab->scrollbar), "changed",
// G_CALLBACK(scroll_value_changed_cb), tab);
guint page_num,
gpointer user_data);
+
+void
+on_MEntry1_value_changed (GtkSpinButton *spinbutton,
+ gpointer user_data);
+void
+on_MEntry2_value_changed (GtkSpinButton *spinbutton,
+ gpointer user_data);
+void
+on_MEntry3_value_changed (GtkSpinButton *spinbutton,
+ gpointer user_data);
+void
+on_MEntry4_value_changed (GtkSpinButton *spinbutton,
+ gpointer user_data);
+void
+on_MEntry5_value_changed (GtkSpinButton *spinbutton,
+ gpointer user_data);
+void
+on_MEntry6_value_changed (GtkSpinButton *spinbutton,
+ gpointer user_data);
+
+
+void time_change_manager (Tab *tab,
+ TimeWindow new_time_window);
+
+void current_time_change_manager (Tab *tab,
+ LttTime new_current_time);
+
gboolean execute_time_requests(MainWindow * mw);
GtkWidget *tlbZoomIn;
GtkWidget *tlbZoomOut;
GtkWidget *tlbZoomExtended;
- // GtkWidget *tlbGoToTime;
- // GtkWidget *tlbShowTimeFrame;
+ //GtkWidget *tlbGoToTime;
+ //GtkWidget *tlbShowTimeFrame;
GtkWidget *tlbMoveViewerUp;
GtkWidget *tlbMoveViewerDown;
GtkWidget *tlbRemoveViewer;
gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (MToolbar1)->children)->data))->label), TRUE);
gtk_widget_show (tlbZoomExtended);
gtk_container_set_border_width (GTK_CONTAINER (tlbZoomExtended), 1);
-/*
+
+ /*
tmp_toolbar_icon = create_pixmap (MWindow, "gtk-jump-to.png");
tlbGoToTime = gtk_toolbar_append_element (GTK_TOOLBAR (MToolbar1),
GTK_TOOLBAR_CHILD_BUTTON,
gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (MToolbar1)->children)->data))->label), TRUE);
gtk_widget_show (tlbShowTimeFrame);
gtk_container_set_border_width (GTK_CONTAINER (tlbShowTimeFrame), 1);
-*/
+ */
gtk_toolbar_append_space (GTK_TOOLBAR (MToolbar1));
tmp_toolbar_icon = create_pixmap (MWindow, "1uparrow.png");
gtk_widget_show (MNotebook);
gtk_notebook_set_show_tabs((GtkNotebook*)MNotebook, FALSE);
gtk_box_pack_start (GTK_BOX (MVbox), MNotebook, TRUE, TRUE, 0);
+
/*
empty_notebook_page = gtk_vbox_new (FALSE, 0);
gtk_widget_show (empty_notebook_page);
g_signal_connect ((gpointer) tlbZoomExtended, "clicked",
G_CALLBACK (on_button_zoom_extended_clicked),
NULL);
-/*
+ /*
g_signal_connect ((gpointer) tlbGoToTime, "clicked",
G_CALLBACK (on_button_go_to_time_clicked),
NULL);
g_signal_connect ((gpointer) tlbShowTimeFrame, "clicked",
G_CALLBACK (on_button_show_time_frame_clicked),
NULL);
-*/
+ */
g_signal_connect ((gpointer) tlbMoveViewerUp, "clicked",
G_CALLBACK (on_button_move_up_clicked),
NULL);
*/
void lttvwindow_report_time_window(Tab *tab,
- const TimeWindow *time_window)
+ TimeWindow time_window)
{
//set_time_window(tab, time_window);
//set_time_window_adjustment(tab, time_window);
+ time_change_manager(tab, time_window);
+
+
+#if 0
/* Set scrollbar */
LttvTracesetContext *tsc =
LTTV_TRACESET_CONTEXT(tab->traceset_info->traceset_context);
TimeInterval time_span = tsc->time_span;
GtkAdjustment *adjustment = gtk_range_get_adjustment(GTK_RANGE(tab->scrollbar));
-
g_object_set(G_OBJECT(adjustment),
"lower",
0.0, /* lower */
ltt_time_sub(time_window->start_time,
time_span.start_time))
* NANOSECONDS_PER_SECOND);
+#endif //0
}
*/
void lttvwindow_report_current_time(Tab *tab,
- const LttTime *time)
+ LttTime time)
{
LttvAttributeValue value;
LttvHooks * tmp;
- tab->current_time = *time;
+
+ current_time_change_manager(tab, time);
+
g_assert(lttv_iattribute_find_by_path(tab->attributes,
"hooks/updatecurrenttime", LTTV_POINTER, &value));
tmp = (LttvHooks*)*(value.v_pointer);
* Function to set the time interval of the current tab.a
*
* @param tab the tab the viewer belongs to.
- * @param time_interval pointer to the time interval value.
+ * @param time_interval new time window.
*/
void lttvwindow_report_time_window(Tab *tab,
- const TimeWindow *time_window);
+ TimeWindow time_window);
/**
* Function to set the current time/event of the current tab.
* It will be called by a viewer's signal handle associated with
* the button-release-event signal
* @param tab the tab the viewer belongs to.
- * @param time a pointer where time is stored.
+ * @param new current time.
*/
void lttvwindow_report_current_time(Tab *tab,
- const LttTime *time);
+ LttTime time);
/**
//GtkWidget *multivpaned;
GtkWidget *viewer_container;
GtkWidget *scrollbar;
+
+ /* time bar */
+ GtkWidget *MTimebar;
+ GtkWidget *MText1;
+ GtkWidget *MEntry1;
+ GtkWidget *MText2;
+ GtkWidget *MEntry2;
+ GtkWidget *MText3a;
+ GtkWidget *MText3b;
+ GtkWidget *MEntry3;
+ GtkWidget *MText4;
+ GtkWidget *MEntry4;
+ GtkWidget *MText5a;
+ GtkWidget *MText5b;
+ GtkWidget *MEntry5;
+ GtkWidget *MText6;
+ GtkWidget *MEntry6;
+ GtkWidget *MText7;
// startTime is the left of the visible area. Corresponds to the scrollbar
// value.
// Time_Width is a zoom dependant value (corresponding to page size)
TimeWindow time_window;
+ gboolean time_manager_lock;
// The current time is the time selected in the visible area by the user,
// not the scrollbar value.
LttTime current_time;
+ gboolean current_time_manager_lock;
+
LttvIAttribute * attributes;
//struct _Tab * next;
stock_stop_24.png\
stock_redo_24.png\
stock_refresh_24.png\
- close.png
+ close.png\
+ stock_jump_to_24.png
projects / lttv.git / commitdiff
