* erase drawing already present (SAFETY).
*/
void drawing_data_request(Drawing_t *drawing,
- GdkPixmap **pixmap,
gint x, gint y,
gint width,
gint height)
drawing->damage_begin = x+width;
+ // FIXME ?
gtk_widget_queue_draw_area ( drawing->drawing_area,
x, 0,
width, drawing->drawing_area->allocation.height);
drawing->width = widget->allocation.width;
if(drawing->alloc_width < widget->allocation.width) {
- if(drawing->pixmap)
- gdk_pixmap_unref(drawing->pixmap);
+ //if(drawing->pixmap)
+ // gdk_pixmap_unref(drawing->pixmap);
- drawing->pixmap = gdk_pixmap_new(widget->window,
- drawing->width + SAFETY + EXTRA_ALLOC,
- drawing->height + EXTRA_ALLOC,
- -1);
+ //drawing->pixmap = gdk_pixmap_new(widget->window,
+ // drawing->width + SAFETY + EXTRA_ALLOC,
+ // drawing->height + EXTRA_ALLOC,
+ // -1);
drawing->alloc_width = drawing->width + SAFETY + EXTRA_ALLOC;
drawing->alloc_height = drawing->height + EXTRA_ALLOC;
+ update_pixmap_size(drawing->control_flow_data->process_list,
+ drawing->alloc_width);
}
//drawing->height = widget->allocation.height;
// Clear the image
- gdk_draw_rectangle (drawing->pixmap,
- widget->style->black_gc,
- TRUE,
- 0, 0,
- drawing->width+SAFETY,
- drawing->height);
+ //gdk_draw_rectangle (drawing->pixmap,
+ // widget->style->black_gc,
+ // TRUE,
+ // 0, 0,
+ // drawing->width+SAFETY,
+ // drawing->height);
//g_info("init data request");
drawing->damage_begin = 0;
drawing->damage_end = widget->allocation.width;
- if(drawing->damage_begin < drawing->damage_end)
+ if((widget->allocation.width != 1 &&
+ widget->allocation.height != 1)
+ && drawing->damage_begin < drawing->damage_end)
{
drawing_data_request(drawing,
- &drawing->pixmap,
drawing->damage_begin,
0,
drawing->damage_end - drawing->damage_begin,
LttTime window_end = time_window.end_time;
/* update the screen from the pixmap buffer */
+#if 0
gdk_draw_pixmap(widget->window,
widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
drawing->pixmap,
event->area.x, event->area.y,
event->area.x, event->area.y,
event->area.width, event->area.height);
-
+#endif //0
+ copy_pixmap_to_screen(control_flow_data->process_list,
+ widget->window,
+ widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
+ event->area.x, event->area.y,
+ event->area.width, event->area.height);
+
+
/* Erase the dotted lines left.. */
+#if 0
if(widget->allocation.height > drawing->height)
{
gdk_draw_rectangle (widget->window,
event->area.x, drawing->height,
event->area.width, // do not overlap
widget->allocation.height - drawing->height);
-g_critical("blah : %u, %u", widget->allocation.height, drawing->height);
}
-
+#endif //0
if(ltt_time_compare(time_window.start_time, current_time) <= 0 &&
ltt_time_compare(window_end, current_time) >= 0)
{
// drawing->height,
// drawing->depth);
- drawing->pixmap = NULL;
+ //drawing->pixmap = NULL;
// drawing->pixmap = gdk_pixmap_new(drawing->drawing_area->window,
// drawing->drawing_area->allocation.width,
void drawing_clear(Drawing_t *drawing)
{
- if (drawing->pixmap)
- gdk_pixmap_unref(drawing->pixmap);
+ //if (drawing->pixmap)
+ // gdk_pixmap_unref(drawing->pixmap);
+ ControlFlowData *cfd = drawing->control_flow_data;
- drawing->height = 1;
+
+ rectangle_pixmap(cfd->process_list,
+ drawing->drawing_area->style->black_gc,
+ TRUE,
+ 0, 0,
+ drawing->alloc_width, // do not overlap
+ -1);
+
+ //drawing->height = 1;
/* Allocate a new pixmap with new height */
- drawing->pixmap = gdk_pixmap_new(drawing->drawing_area->window,
- drawing->width + SAFETY + EXTRA_ALLOC,
- drawing->height + EXTRA_ALLOC,
- -1);
- drawing->alloc_width = drawing->width + SAFETY + EXTRA_ALLOC;
- drawing->alloc_height = drawing->height + EXTRA_ALLOC;
-
- gtk_widget_set_size_request(drawing->drawing_area,
- -1,
- drawing->height);
- gtk_widget_queue_resize_no_redraw(drawing->drawing_area);
+ //drawing->pixmap = gdk_pixmap_new(drawing->drawing_area->window,
+ // drawing->width + SAFETY + EXTRA_ALLOC,
+ // drawing->height + EXTRA_ALLOC,
+ // -1);
+ //drawing->alloc_width = drawing->width + SAFETY + EXTRA_ALLOC;
+ //drawing->alloc_height = drawing->height + EXTRA_ALLOC;
+
+ //gtk_widget_set_size_request(drawing->drawing_area,
+ // -1,
+ // drawing->height);
+ //gtk_widget_queue_resize_no_redraw(drawing->drawing_area);
/* ask for the buffer to be redrawn */
gtk_widget_queue_draw ( drawing->drawing_area);
}
-
+#if 0
/* Insert a square corresponding to a new process in the list */
/* Applies to whole drawing->width */
void drawing_insert_square(Drawing_t *drawing,
reallocate = TRUE;
/* Copy the high region */
- gdk_draw_drawable (new_pixmap,
+ gdk_draw_pixmap (new_pixmap,
drawing->drawing_area->style->black_gc,
drawing->pixmap,
0, 0,
height);
/* copy the bottom of the region */
- gdk_draw_drawable (new_pixmap,
+ gdk_draw_pixmap (new_pixmap,
drawing->drawing_area->style->black_gc,
drawing->pixmap,
0, y,
pixmap = drawing->pixmap;
/* Copy the high region */
- gdk_draw_drawable (pixmap,
+ gdk_draw_pixmap (pixmap,
drawing->drawing_area->style->black_gc,
drawing->pixmap,
0, 0,
drawing->width + SAFETY, y);
/* Copy up the bottom of the region */
- gdk_draw_drawable (pixmap,
+ gdk_draw_pixmap (pixmap,
drawing->drawing_area->style->black_gc,
drawing->pixmap,
0, y + height,
0, y,
drawing->width, MAX(drawing->height-y, 1));
}
+#endif //0
void drawing_update_ruler(Drawing_t *drawing, TimeWindow *time_window)
{
* or add it, and draw its items.
*/
/* Add process to process list (if not present) */
- guint y = 0, height = 0, pl_height = 0;
+ guint pl_height = 0;
HashedProcessData *hashed_process_data = NULL;
ProcessList *process_list = control_flow_data->process_list;
LttTime birth = process->creation_time;
const gchar *name = g_quark_to_string(process->name);
/* Process not present */
ProcessInfo *process_info;
+ Drawing_t *drawing = control_flow_data->drawing;
processlist_add(process_list,
+ drawing,
pid_out,
process->last_cpu_index,
process->ppid,
&pl_height,
&process_info,
&hashed_process_data);
- processlist_get_pixels_from_data(process_list,
- hashed_process_data,
- &y,
- &height);
- drawing_insert_square( control_flow_data->drawing, y, height);
+ gtk_widget_set_size_request(drawing->drawing_area,
+ -1,
+ pl_height);
+ gtk_widget_queue_draw(drawing->drawing_area);
+
}
/* Now, the process is in the state hash and our own process hash.
evtime) > 0)
{
if(hashed_process_data->x.middle_marked == FALSE) {
- processlist_get_pixels_from_data(process_list,
- hashed_process_data,
- &y,
- &height);
TimeWindow time_window =
lttvwindow_get_time_window(control_flow_data->tab);
/* Draw collision indicator */
gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
- gdk_draw_point(drawing->pixmap,
+ gdk_draw_point(hashed_process_data->pixmap,
drawing->gc,
x,
- y+(height/2)-3);
+ (hashed_process_data->height/2)-3);
hashed_process_data->x.middle_marked = TRUE;
}
} else {
- processlist_get_pixels_from_data(process_list,
- hashed_process_data,
- &y,
- &height);
-
-
TimeWindow time_window =
lttvwindow_get_time_window(control_flow_data->tab);
#ifdef EXTRA_CHECK
if(hashed_process_data->x.middle_marked == FALSE) {
/* Draw collision indicator */
gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
- gdk_draw_point(drawing->pixmap,
+ gdk_draw_point(hashed_process_data->pixmap,
drawing->gc,
x,
- y+(height/2)-3);
+ (hashed_process_data->height/2)-3);
hashed_process_data->x.middle_marked = TRUE;
}
/* jump */
/* Now create the drawing context that will be used to draw
* items related to the last state. */
- draw_context.drawable = drawing->pixmap;
+ draw_context.drawable = hashed_process_data->pixmap;
draw_context.gc = drawing->gc;
draw_context.pango_layout = drawing->pango_layout;
draw_context.drawinfo.start.x = hashed_process_data->x.middle;
draw_context.drawinfo.end.x = x;
- draw_context.drawinfo.y.over = y+1;
- draw_context.drawinfo.y.middle = y+(height/2);
- draw_context.drawinfo.y.under = y+height;
+ draw_context.drawinfo.y.over = 1;
+ draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
+ draw_context.drawinfo.y.under = hashed_process_data->height;
draw_context.drawinfo.start.offset.over = 0;
draw_context.drawinfo.start.offset.middle = 0;
* or add it, and draw its items.
*/
/* Add process to process list (if not present) */
- guint y = 0, height = 0, pl_height = 0;
+ guint pl_height = 0;
HashedProcessData *hashed_process_data = NULL;
ProcessList *process_list = control_flow_data->process_list;
LttTime birth = process->creation_time;
const gchar *name = g_quark_to_string(process->name);
/* Process not present */
ProcessInfo *process_info;
+ Drawing_t *drawing = control_flow_data->drawing;
processlist_add(process_list,
+ drawing,
pid_in,
process->last_cpu_index,
process->ppid,
&pl_height,
&process_info,
&hashed_process_data);
- processlist_get_pixels_from_data(process_list,
- hashed_process_data,
- &y,
- &height);
- drawing_insert_square( control_flow_data->drawing, y, height);
+ gtk_widget_set_size_request(drawing->drawing_area,
+ -1,
+ pl_height);
+ gtk_widget_queue_draw(drawing->drawing_area);
+
}
//We could set the current process and hash here, but will be done
//by after schedchange hook
{
if(hashed_process_data->x.middle_marked == FALSE) {
- processlist_get_pixels_from_data(process_list,
- hashed_process_data,
- &y,
- &height);
TimeWindow time_window =
lttvwindow_get_time_window(control_flow_data->tab);
#ifdef EXTRA_CHECK
/* Draw collision indicator */
gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
- gdk_draw_point(drawing->pixmap,
+ gdk_draw_point(hashed_process_data->pixmap,
drawing->gc,
x,
- y+(height/2)-3);
+ (hashed_process_data->height/2)-3);
hashed_process_data->x.middle_marked = TRUE;
}
} else {
- processlist_get_pixels_from_data(process_list,
- hashed_process_data,
- &y,
- &height);
TimeWindow time_window =
lttvwindow_get_time_window(control_flow_data->tab);
#ifdef EXTRA_CHECK
if(hashed_process_data->x.middle_marked == FALSE) {
/* Draw collision indicator */
gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
- gdk_draw_point(drawing->pixmap,
+ gdk_draw_point(hashed_process_data->pixmap,
drawing->gc,
x,
- y+(height/2)-3);
+ (hashed_process_data->height/2)-3);
hashed_process_data->x.middle_marked = TRUE;
}
/* jump */
/* Now create the drawing context that will be used to draw
* items related to the last state. */
- draw_context.drawable = drawing->pixmap;
+ draw_context.drawable = hashed_process_data->pixmap;
draw_context.gc = drawing->gc;
draw_context.pango_layout = drawing->pango_layout;
draw_context.drawinfo.start.x = hashed_process_data->x.middle;
draw_context.drawinfo.end.x = x;
- draw_context.drawinfo.y.over = y+1;
- draw_context.drawinfo.y.middle = y+(height/2);
- draw_context.drawinfo.y.under = y+height;
+ draw_context.drawinfo.y.over = 1;
+ draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
+ draw_context.drawinfo.y.under = hashed_process_data->height;
draw_context.drawinfo.start.offset.over = 0;
draw_context.drawinfo.start.offset.middle = 0;
/* Add process to process list (if not present) */
LttvProcessState *process_in;
LttTime birth;
- guint y_in = 0, height = 0, pl_height = 0;
+ guint pl_height = 0;
HashedProcessData *hashed_process_data_in = NULL;
ProcessList *process_list = control_flow_data->process_list;
g_assert(pid_in == 0 || pid_in != process_in->ppid);
const gchar *name = g_quark_to_string(process_in->name);
ProcessInfo *process_info;
+ Drawing_t *drawing = control_flow_data->drawing;
/* Process not present */
processlist_add(process_list,
+ drawing,
pid_in,
process_in->last_cpu_index,
process_in->ppid,
&pl_height,
&process_info,
&hashed_process_data_in);
- processlist_get_pixels_from_data(process_list,
- hashed_process_data_in,
- &y_in,
- &height);
- drawing_insert_square( control_flow_data->drawing, y_in, height);
+ gtk_widget_set_size_request(drawing->drawing_area,
+ -1,
+ pl_height);
+ gtk_widget_queue_draw(drawing->drawing_area);
}
/* Set the current process */
process_list->current_hash_data[process_in->last_cpu_index] =
if(ltt_time_compare(hashed_process_data_in->next_good_time,
evtime) <= 0)
{
- processlist_get_pixels_from_data(process_list,
- hashed_process_data_in,
- &y_in,
- &height);
TimeWindow time_window =
lttvwindow_get_time_window(control_flow_data->tab);
* or add it, and draw its items.
*/
/* Add process to process list (if not present) */
- guint y = 0, height = 0, pl_height = 0;
+ guint pl_height = 0;
HashedProcessData *hashed_process_data = NULL;
ProcessList *process_list = control_flow_data->process_list;
LttTime birth = process->creation_time;
g_assert(pid == 0 || pid != process->ppid);
ProcessInfo *process_info;
/* Process not present */
+ Drawing_t *drawing = control_flow_data->drawing;
const gchar *name = g_quark_to_string(process->name);
processlist_add(process_list,
+ drawing,
pid,
process->last_cpu_index,
process->ppid,
&pl_height,
&process_info,
&hashed_process_data);
- processlist_get_pixels_from_data(process_list,
- hashed_process_data,
- &y,
- &height);
- drawing_insert_square( control_flow_data->drawing, y, height);
+ gtk_widget_set_size_request(drawing->drawing_area,
+ -1,
+ pl_height);
+ gtk_widget_queue_draw(drawing->drawing_area);
}
/* Set the current process */
process_list->current_hash_data[process->last_cpu_index] =
evtime) > 0))
{
if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
- processlist_get_pixels_from_data(process_list,
- hashed_process_data,
- &y,
- &height);
TimeWindow time_window =
lttvwindow_get_time_window(control_flow_data->tab);
/* Draw collision indicator */
gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
- gdk_draw_point(drawing->pixmap,
+ gdk_draw_point(hashed_process_data->pixmap,
drawing->gc,
x,
- y+(height/2)-3);
+ (hashed_process_data->height/2)-3);
hashed_process_data->x.middle_marked = TRUE;
}
} else {
- processlist_get_pixels_from_data(process_list,
- hashed_process_data,
- &y,
- &height);
TimeWindow time_window =
lttvwindow_get_time_window(control_flow_data->tab);
if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
/* Draw collision indicator */
gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
- gdk_draw_point(drawing->pixmap,
+ gdk_draw_point(hashed_process_data->pixmap,
drawing->gc,
x,
- y+(height/2)-3);
+ (hashed_process_data->height/2)-3);
hashed_process_data->x.middle_marked = TRUE;
}
/* jump */
DrawContext draw_context;
/* Now create the drawing context that will be used to draw
* items related to the last state. */
- draw_context.drawable = drawing->pixmap;
+ draw_context.drawable = hashed_process_data->pixmap;
draw_context.gc = drawing->gc;
draw_context.pango_layout = drawing->pango_layout;
draw_context.drawinfo.start.x = hashed_process_data->x.middle;
draw_context.drawinfo.end.x = x;
- draw_context.drawinfo.y.over = y+1;
- draw_context.drawinfo.y.middle = y+(height/2);
- draw_context.drawinfo.y.under = y+height;
+ draw_context.drawinfo.y.over = 1;
+ draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
+ draw_context.drawinfo.y.under = hashed_process_data->height;
draw_context.drawinfo.start.offset.over = 0;
draw_context.drawinfo.start.offset.middle = 0;
/* Add process to process list (if not present) */
LttvProcessState *process;
LttTime birth;
- guint y = 0, height = 0, pl_height = 0;
+ guint pl_height = 0;
HashedProcessData *hashed_process_data = NULL;
ProcessList *process_list = control_flow_data->process_list;
{
g_assert(pid == 0 || pid != process->ppid);
/* Process not present */
+ Drawing_t *drawing = control_flow_data->drawing;
const gchar *name = g_quark_to_string(process->name);
ProcessInfo *process_info;
processlist_add(process_list,
+ drawing,
pid,
process->last_cpu_index,
process->ppid,
&pl_height,
&process_info,
&hashed_process_data);
- processlist_get_pixels_from_data(process_list,
- hashed_process_data,
- &y,
- &height);
- drawing_insert_square( control_flow_data->drawing, y, height);
+ gtk_widget_set_size_request(drawing->drawing_area,
+ -1,
+ pl_height);
+ gtk_widget_queue_draw(drawing->drawing_area);
}
/* Set the current process */
process_list->current_hash_data[process->last_cpu_index] =
if(unlikely(ltt_time_compare(hashed_process_data->next_good_time,
evtime) <= 0))
{
-#if 0
- processlist_get_pixels_from_data(process_list,
- hashed_process_data,
- &y,
- &height);
-#endif //0
TimeWindow time_window =
lttvwindow_get_time_window(control_flow_data->tab);
LttvProcessState *process = tfs->process;
guint pid = process->pid;
LttTime birth;
- guint y = 0, height = 0, pl_height = 0;
+ guint pl_height = 0;
HashedProcessData *hashed_process_data = NULL;
ProcessList *process_list = control_flow_data->process_list;
{
g_assert(pid == 0 || pid != process->ppid);
/* Process not present */
+ Drawing_t *drawing = control_flow_data->drawing;
const gchar *name = g_quark_to_string(process->name);
ProcessInfo *process_info;
processlist_add(process_list,
+ drawing,
pid,
process->last_cpu_index,
process->ppid,
&pl_height,
&process_info,
&hashed_process_data);
- processlist_get_pixels_from_data(process_list,
- hashed_process_data,
- &y,
- &height);
- drawing_insert_square( control_flow_data->drawing, y, height);
+ gtk_widget_set_size_request(drawing->drawing_area,
+ -1,
+ pl_height);
+ gtk_widget_queue_draw(drawing->drawing_area);
}
}
evtime) > 0))
{
if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
- processlist_get_pixels_from_data(process_list,
- hashed_process_data,
- &y,
- &height);
TimeWindow time_window =
lttvwindow_get_time_window(control_flow_data->tab);
/* Draw collision indicator */
gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
- gdk_draw_point(drawing->pixmap,
+ gdk_draw_point(hashed_process_data->pixmap,
drawing->gc,
x,
- y+(height/2)-3);
+ (hashed_process_data->height/2)-3);
hashed_process_data->x.middle_marked = TRUE;
}
} else {
- processlist_get_pixels_from_data(process_list,
- hashed_process_data,
- &y,
- &height);
TimeWindow time_window =
lttvwindow_get_time_window(control_flow_data->tab);
if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
/* Draw collision indicator */
gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
- gdk_draw_point(drawing->pixmap,
+ gdk_draw_point(hashed_process_data->pixmap,
drawing->gc,
x,
- y+(height/2)-3);
+ (hashed_process_data->height/2)-3);
hashed_process_data->x.middle_marked = TRUE;
}
/* jump */
/* Now create the drawing context that will be used to draw
* items related to the last state. */
- draw_context.drawable = drawing->pixmap;
+ draw_context.drawable = hashed_process_data->pixmap;
draw_context.gc = drawing->gc;
draw_context.pango_layout = drawing->pango_layout;
draw_context.drawinfo.start.x = hashed_process_data->x.middle;
draw_context.drawinfo.end.x = x;
- draw_context.drawinfo.y.over = y+1;
- draw_context.drawinfo.y.middle = y+(height/2);
- draw_context.drawinfo.y.under = y+height;
+ draw_context.drawinfo.y.over = 1;
+ draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
+ draw_context.drawinfo.y.under = hashed_process_data->height;
draw_context.drawinfo.start.offset.over = 0;
draw_context.drawinfo.start.offset.middle = 0;
/* Add process to process list (if not present) */
LttvProcessState *process_child;
LttTime birth;
- guint y_child = 0, height = 0, pl_height = 0;
+ guint pl_height = 0;
HashedProcessData *hashed_process_data_child = NULL;
ProcessList *process_list = control_flow_data->process_list;
{
g_assert(child_pid == 0 || child_pid != process_child->ppid);
/* Process not present */
+ Drawing_t *drawing = control_flow_data->drawing;
const gchar *name = g_quark_to_string(process_child->name);
ProcessInfo *process_info;
processlist_add(process_list,
+ drawing,
child_pid,
process_child->last_cpu_index,
process_child->ppid,
&pl_height,
&process_info,
&hashed_process_data_child);
- processlist_get_pixels_from_data(process_list,
- hashed_process_data_child,
- &y_child,
- &height);
- drawing_insert_square( control_flow_data->drawing, y_child, height);
+ gtk_widget_set_size_request(drawing->drawing_area,
+ -1,
+ pl_height);
+ gtk_widget_queue_draw(drawing->drawing_area);
}
if(likely(ltt_time_compare(hashed_process_data_child->next_good_time,
evtime) <= 0))
{
-#if 0
- processlist_get_pixels_from_data(process_list,
- hashed_process_data_child,
- &y_child,
- &height);
-#endif //0
TimeWindow time_window =
lttvwindow_get_time_window(control_flow_data->tab);
LttvProcessState *process = tfs->process;
guint pid = process->pid;
LttTime birth;
- guint y = 0, height = 0, pl_height = 0;
+ guint pl_height = 0;
HashedProcessData *hashed_process_data = NULL;
ProcessList *process_list = control_flow_data->process_list;
{
g_assert(pid == 0 || pid != process->ppid);
/* Process not present */
+ Drawing_t *drawing = control_flow_data->drawing;
const gchar *name = g_quark_to_string(process->name);
ProcessInfo *process_info;
processlist_add(process_list,
+ drawing,
pid,
process->last_cpu_index,
process->ppid,
&pl_height,
&process_info,
&hashed_process_data);
- processlist_get_pixels_from_data(process_list,
- hashed_process_data,
- &y,
- &height);
- drawing_insert_square( control_flow_data->drawing, y, height);
+ gtk_widget_set_size_request(drawing->drawing_area,
+ -1,
+ pl_height);
+ gtk_widget_queue_draw(drawing->drawing_area);
}
/* Set the current process */
if(unlikely(ltt_time_compare(hashed_process_data->next_good_time,
evtime) <= 0))
{
-#if 0
- processlist_get_pixels_from_data(process_list,
- hashed_process_data,
- &y,
- &height);
-#endif //0
TimeWindow time_window =
lttvwindow_get_time_window(control_flow_data->tab);
{
ControlFlowData *control_flow_data = (ControlFlowData*) hook_data;
Drawing_t *drawing = control_flow_data->drawing;
+ ProcessList *process_list = control_flow_data->process_list;
const TimeWindowNotifyData *time_window_nofify_data =
((const TimeWindowNotifyData *)call_data);
&x);
/* Copy old data to new location */
- gdk_draw_drawable (control_flow_data->drawing->pixmap,
- control_flow_data->drawing->drawing_area->style->black_gc,
- control_flow_data->drawing->pixmap,
- x, 0,
- 0, 0,
- control_flow_data->drawing->width-x+SAFETY, -1);
-
+ copy_pixmap_region(process_list,
+ NULL,
+ control_flow_data->drawing->drawing_area->style->black_gc,
+ NULL,
+ x, 0,
+ 0, 0,
+ control_flow_data->drawing->width-x+SAFETY, -1);
+
if(drawing->damage_begin == drawing->damage_end)
drawing->damage_begin = control_flow_data->drawing->width-x;
else
drawing->damage_end = control_flow_data->drawing->width;
/* Clear the data request background, but not SAFETY */
- gdk_draw_rectangle (control_flow_data->drawing->pixmap,
- //control_flow_data->drawing->drawing_area->style->black_gc,
+ rectangle_pixmap(process_list,
control_flow_data->drawing->drawing_area->style->black_gc,
TRUE,
drawing->damage_begin+SAFETY, 0,
drawing->damage_end - drawing->damage_begin, // do not overlap
- control_flow_data->drawing->height);
+ -1);
gtk_widget_queue_draw(drawing->drawing_area);
//gtk_widget_queue_draw_area (drawing->drawing_area,
// 0,0,
/* Get new data for the rest. */
drawing_data_request(control_flow_data->drawing,
- &control_flow_data->drawing->pixmap,
drawing->damage_begin, 0,
drawing->damage_end - drawing->damage_begin,
control_flow_data->drawing->height);
width,
&x);
-
/* Copy old data to new location */
- gdk_draw_drawable (control_flow_data->drawing->pixmap,
+ copy_pixmap_region (process_list,
+ NULL,
control_flow_data->drawing->drawing_area->style->black_gc,
- control_flow_data->drawing->pixmap,
+ NULL,
0, 0,
x, 0,
-1, -1);
drawing->damage_begin = 0;
- gdk_draw_rectangle (control_flow_data->drawing->pixmap,
+ rectangle_pixmap (process_list,
control_flow_data->drawing->drawing_area->style->black_gc,
TRUE,
drawing->damage_begin, 0,
drawing->damage_end - drawing->damage_begin, // do not overlap
- control_flow_data->drawing->height);
+ -1);
gtk_widget_queue_draw(drawing->drawing_area);
//gtk_widget_queue_draw_area (drawing->drawing_area,
/* Get new data for the rest. */
drawing_data_request(control_flow_data->drawing,
- &control_flow_data->drawing->pixmap,
drawing->damage_begin, 0,
drawing->damage_end - drawing->damage_begin,
control_flow_data->drawing->height);
/* Cannot reuse any part of the screen : far jump */
- gdk_draw_rectangle (control_flow_data->drawing->pixmap,
+ rectangle_pixmap (process_list,
control_flow_data->drawing->drawing_area->style->black_gc,
TRUE,
0, 0,
control_flow_data->drawing->width+SAFETY, // do not overlap
- control_flow_data->drawing->height);
+ -1);
//gtk_widget_queue_draw_area (drawing->drawing_area,
// 0,0,
drawing->damage_end = control_flow_data->drawing->width;
drawing_data_request(control_flow_data->drawing,
- &control_flow_data->drawing->pixmap,
0, 0,
control_flow_data->drawing->width,
control_flow_data->drawing->height);
/* Different scale (zoom) */
g_info("zoom");
- gdk_draw_rectangle (control_flow_data->drawing->pixmap,
+ rectangle_pixmap (process_list,
control_flow_data->drawing->drawing_area->style->black_gc,
TRUE,
0, 0,
control_flow_data->drawing->width+SAFETY, // do not overlap
- control_flow_data->drawing->height);
+ -1);
//gtk_widget_queue_draw_area (drawing->drawing_area,
// 0,0,
drawing->damage_end = control_flow_data->drawing->width;
drawing_data_request(control_flow_data->drawing,
- &control_flow_data->drawing->pixmap,
0, 0,
control_flow_data->drawing->width,
control_flow_data->drawing->height);
drawing_clear(control_flow_data->drawing);
processlist_clear(control_flow_data->process_list);
- // Clear the image
- gdk_draw_rectangle (drawing->pixmap,
+ // Clear the images
+ rectangle_pixmap (control_flow_data->process_list,
widget->style->black_gc,
TRUE,
0, 0,
drawing->width+SAFETY,
- drawing->height);
+ -1);
if(drawing->damage_begin < drawing->damage_end)
{
drawing_data_request(drawing,
- &drawing->pixmap,
drawing->damage_begin,
0,
drawing->damage_end-drawing->damage_begin,
if(drawing->damage_begin < drawing->damage_end)
{
drawing_data_request(drawing,
- &drawing->pixmap,
drawing->damage_begin,
0,
drawing->damage_end-drawing->damage_begin,
/* Only draw for processes that are currently in the trace states */
- guint y = 0, height = 0;
ProcessList *process_list = control_flow_data->process_list;
#ifdef EXTRA_CHECK
/* Should be alike when background info is ready */
g_assert(ltt_time_compare(process->creation_time,
process_info->birth) == 0);
#endif //EXTRA_CHECK
- /* process HAS to be present */
- processlist_get_pixels_from_data(process_list,
- hashed_process_data,
- &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.
/* Now create the drawing context that will be used to draw
* items related to the last state. */
- draw_context.drawable = drawing->pixmap;
+ draw_context.drawable = hashed_process_data->pixmap;
draw_context.gc = drawing->gc;
draw_context.pango_layout = drawing->pango_layout;
draw_context.drawinfo.end.x = x;
- draw_context.drawinfo.y.over = y+1;
- draw_context.drawinfo.y.middle = y+(height/2);
- draw_context.drawinfo.y.under = y+height;
+ draw_context.drawinfo.y.over = 1;
+ draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
+ draw_context.drawinfo.y.under = hashed_process_data->height;
draw_context.drawinfo.start.offset.over = 0;
draw_context.drawinfo.start.offset.middle = 0;
#include <glib.h>
#include <string.h>
#include <stdlib.h>
+#include <math.h>
#include "processlist.h"
+#include "drawing.h"
#include "drawitem.h"
#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)
+/* Preallocated Size of the index_to_pixmap array */
+#define ALLOCATE_PROCESSES 1000
/*****************************************************************************
* Methods to synchronize process list *
void destroy_hash_data(gpointer data);
+static void update_index_to_pixmap_each(ProcessInfo *key,
+ HashedProcessData *value,
+ ProcessList *process_list)
+{
+ guint array_index = processlist_get_index_from_data(process_list, value);
+
+ g_assert(array_index < process_list->index_to_pixmap->len);
+
+ GdkPixmap **pixmap =
+ (GdkPixmap**)&g_ptr_array_index(process_list->index_to_pixmap, array_index);
+
+ *pixmap = value->pixmap;
+}
+
+
+static void update_index_to_pixmap(ProcessList *process_list)
+{
+ g_ptr_array_set_size(process_list->index_to_pixmap,
+ g_hash_table_size(process_list->process_hash));
+ g_hash_table_foreach(process_list->process_hash,
+ (GHFunc)update_index_to_pixmap_each,
+ process_list);
+}
+
+
+static void update_pixmap_size_each(ProcessInfo *key,
+ HashedProcessData *value,
+ guint width)
+{
+ GdkPixmap *old_pixmap = value->pixmap;
+
+ value->pixmap =
+ gdk_pixmap_new(old_pixmap,
+ width,
+ value->height,
+ -1);
+
+ gdk_pixmap_unref(old_pixmap);
+}
+
+
+void update_pixmap_size(ProcessList *process_list, guint width)
+{
+ g_hash_table_foreach(process_list->process_hash,
+ (GHFunc)update_pixmap_size_each,
+ (gpointer)width);
+}
+
+
+typedef struct _CopyPixmap {
+ GdkDrawable *dest;
+ GdkGC *gc;
+ GdkDrawable *src;
+ gint xsrc, ysrc, xdest, ydest, width, height;
+} CopyPixmap;
+
+static void copy_pixmap_region_each(ProcessInfo *key,
+ HashedProcessData *value,
+ CopyPixmap *cp)
+{
+ GdkPixmap *src = cp->src;
+ GdkPixmap *dest = cp->dest;
+
+ if(dest == NULL)
+ dest = value->pixmap;
+ if(src == NULL)
+ src = value->pixmap;
+
+ gdk_draw_drawable (dest,
+ cp->gc,
+ src,
+ cp->xsrc, cp->ysrc,
+ cp->xdest, cp->ydest,
+ cp->width, cp->height);
+}
+
+
+
+
+void copy_pixmap_region(ProcessList *process_list, GdkDrawable *dest,
+ GdkGC *gc, GdkDrawable *src,
+ gint xsrc, gint ysrc,
+ gint xdest, gint ydest, gint width, gint height)
+{
+ CopyPixmap cp = { dest, gc, src, xsrc, ysrc, xdest, ydest, width, height };
+
+ g_hash_table_foreach(process_list->process_hash,
+ (GHFunc)copy_pixmap_region_each,
+ &cp);
+}
+
+
+
+typedef struct _RectanglePixmap {
+ gboolean filled;
+ gint x, y, width, height;
+ GdkGC *gc;
+} RectanglePixmap;
+
+static void rectangle_pixmap_each(ProcessInfo *key,
+ HashedProcessData *value,
+ RectanglePixmap *rp)
+{
+ if(rp->height == -1)
+ rp->height = value->height;
+
+ gdk_draw_rectangle (value->pixmap,
+ rp->gc,
+ rp->filled,
+ rp->x, rp->y,
+ rp->width, rp->height);
+}
+
+
+
+
+void rectangle_pixmap(ProcessList *process_list, GdkGC *gc,
+ gboolean filled, gint x, gint y, gint width, gint height)
+{
+ RectanglePixmap rp = { filled, x, y, width, height, gc };
+
+ g_hash_table_foreach(process_list->process_hash,
+ (GHFunc)rectangle_pixmap_each,
+ &rp);
+}
+
+
+/* Renders each pixmaps into on big drawable */
+void copy_pixmap_to_screen(ProcessList *process_list,
+ GdkDrawable *dest,
+ GdkGC *gc,
+ gint x, gint y,
+ gint width, gint height)
+{
+ gint cell_height =
+ get_cell_height(process_list,
+ (GtkTreeView*)process_list->process_list_widget);
+ cell_height = 24; //FIXME
+ /* Get indexes */
+ gint begin = floor(y/(double)cell_height);
+ gint end = MIN(ceil((y+height)/(double)cell_height),
+ process_list->index_to_pixmap->len);
+ gint i;
+ g_warning("begin : %i, end : %i", begin,end);
+ for(i=begin; i<end; i++) {
+ g_assert(i<process_list->index_to_pixmap->len);
+ /* Render the pixmap to the screen */
+ GdkPixmap *pixmap =
+ (GdkPixmap*)g_ptr_array_index(process_list->index_to_pixmap, i);
+
+ gdk_draw_drawable (dest,
+ gc,
+ pixmap,
+ x, 0,
+ x, i*cell_height,
+ width, cell_height);
+
+ }
+
+
+}
+
+
+
+
+
+
+
ProcessList *processlist_construct(void)
ProcessList* process_list = g_new(ProcessList,1);
process_list->number_of_process = 0;
- process_list->cell_height_cache = -1;
process_list->current_hash_data = NULL;
process_list,
(GDestroyNotify)processlist_destroy);
+ process_list->index_to_pixmap = g_ptr_array_sized_new(ALLOCATE_PROCESSES);
+
return process_list;
}
g_debug("processlist_destroy %p", process_list);
g_hash_table_destroy(process_list->process_hash);
process_list->process_hash = NULL;
+ g_ptr_array_free(process_list->index_to_pixmap, TRUE);
g_free(process_list);
g_debug("processlist_destroy end");
iter = hashed_process_data->y_iter;
gtk_list_store_remove (process_list->list_store, &iter);
+ gdk_pixmap_unref(hashed_process_data->pixmap);
if(likely(process_list->current_hash_data != NULL)) {
if(likely(hashed_process_data ==
(GHRFunc)remove_hash_item,
(gpointer)process_list);
process_list->number_of_process = 0;
+ update_index_to_pixmap(process_list);
}
}
int processlist_add( ProcessList *process_list,
+ Drawing_t *drawing,
guint pid,
guint cpu,
guint ppid,
hashed_process_data->x.under_used = FALSE;
hashed_process_data->x.under_marked = FALSE;
hashed_process_data->next_good_time = ltt_time_zero;
-
+
/* Add a new row to the model */
gtk_list_store_append ( process_list->list_store,
&hashed_process_data->y_iter);
BIRTH_NS_COLUMN, birth->tv_nsec,
TRACE_COLUMN, trace_num,
-1);
-#if 0
- hashed_process_data->row_ref = gtk_tree_row_reference_new (
- GTK_TREE_MODEL(process_list->list_store),
- gtk_tree_model_get_path(
- GTK_TREE_MODEL(process_list->list_store),
- &iter));
-#endif //0
+
g_hash_table_insert(process_list->process_hash,
(gpointer)Process_Info,
(gpointer)hashed_process_data);
- //g_critical ( "iter after : %s", gtk_tree_path_to_string (
- // gtk_tree_model_get_path (
- // GTK_TREE_MODEL(process_list->list_store),
- // &iter)));
process_list->number_of_process++;
- *height = get_cell_height(process_list,
- GTK_TREE_VIEW(process_list->process_list_widget))
- * process_list->number_of_process ;
+ hashed_process_data->height = get_cell_height(process_list,
+ (GtkTreeView*)process_list->process_list_widget);
+ hashed_process_data->height = 24; // FIXME
+ g_assert(hashed_process_data->height != 0);
+
+ *height = hashed_process_data->height * process_list->number_of_process;
+
+ hashed_process_data->pixmap =
+ gdk_pixmap_new(drawing->drawing_area->window,
+ drawing->alloc_width,
+ hashed_process_data->height,
+ -1);
+ // Clear the image
+ gdk_draw_rectangle (hashed_process_data->pixmap,
+ drawing->drawing_area->style->black_gc,
+ TRUE,
+ 0, 0,
+ drawing->alloc_width,
+ hashed_process_data->height);
+
+ update_index_to_pixmap(process_list);
+
+
return 0;
}
process_list->current_hash_data[cpu] = NULL;
}
}
+
+ gdk_pixmap_unref(hashed_process_data->pixmap);
+
+ update_index_to_pixmap(process_list);
+
process_list->number_of_process--;
return 0;
projects / lttv.git / commitdiff
