ltt/branches/poly/lttv/modules/gui/controlflow/eventhooks.c

   1 /* This file is part of the Linux Trace Toolkit viewer
   2  * Copyright (C) 2003-2004 Mathieu Desnoyers
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License Version 2 as
   6  * published by the Free Software Foundation;
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write to the Free Software
  15  * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  16  * MA 02111-1307, USA.
  17  */
  18
  19
  20 /*****************************************************************************
  21  *                       Hooks to be called by the main window               *
  22  *****************************************************************************/
  23
  24
  25 #define g_info(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, format)
  26 #define g_debug(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, format)
  27
  28 //#define PANGO_ENABLE_BACKEND
  29 #include <gtk/gtk.h>
  30 #include <gdk/gdk.h>
  31 #include <glib.h>
  32 #include <assert.h>
  33 #include <string.h>
  34 #include <stdio.h>
  35
  36 //#include <pango/pango.h>
  37
  38 #include <ltt/event.h>
  39 #include <ltt/time.h>
  40 #include <ltt/type.h>
  41
  42 #include <lttv/hook.h>
  43 #include <lttv/common.h>
  44 #include <lttv/state.h>
  45 #include <lttv/gtktraceset.h>
  46
  47
  48 #include "eventhooks.h"
  49 #include "cfv.h"
  50 #include "processlist.h"
  51 #include "drawing.h"
  52 #include "cfv-private.h"
  53
  54
  55 #define MAX_PATH_LEN 256
  56
  57
  58 /**
  59  * Event Viewer's constructor hook
  60  *
  61  * This constructor is given as a parameter to the menuitem and toolbar button
  62  * registration. It creates the list.
  63  * @param mw A pointer to the parent window.
  64  * @return The widget created.
  65  */
  66 GtkWidget *
  67 h_guicontrolflow(MainWindow *mw, LttvTracesetSelector * s, char * key)
  68 {
  69   g_info("h_guicontrolflow, %p, %p, %s", mw, s, key);
  70   ControlFlowData *control_flow_data = guicontrolflow() ;
  71
  72   control_flow_data->mw = mw;
  73   TimeWindow *time_window = guicontrolflow_get_time_window(control_flow_data);
  74   time_window->start_time.tv_sec = 0;
  75   time_window->start_time.tv_nsec = 0;
  76   time_window->time_width.tv_sec = 0;
  77   time_window->time_width.tv_nsec = 0;
  78
  79   LttTime *current_time = guicontrolflow_get_current_time(control_flow_data);
  80   current_time->tv_sec = 0;
  81   current_time->tv_nsec = 0;
  82
  83   //g_critical("time width1 : %u",time_window->time_width);
  84
  85   get_time_window(mw,
  86       time_window);
  87   get_current_time(mw,
  88       current_time);
  89
  90   //g_critical("time width2 : %u",time_window->time_width);
  91   // Unreg done in the GuiControlFlow_Destructor
  92   reg_update_time_window(update_time_window_hook, control_flow_data,
  93         mw);
  94   reg_update_current_time(update_current_time_hook, control_flow_data,
  95         mw);
  96   return guicontrolflow_get_widget(control_flow_data) ;
  97
  98 }
  99
 100 int event_selected_hook(void *hook_data, void *call_data)
 101 {
 102   ControlFlowData *control_flow_data = (ControlFlowData*) hook_data;
 103   guint *event_number = (guint*) call_data;
 104
 105   g_critical("DEBUG : event selected by main window : %u", *event_number);
 106
 107 //  control_flow_data->currently_Selected_Event = *event_number;
 108 //  control_flow_data->Selected_Event = TRUE ;
 109
 110 //  tree_v_set_cursor(control_flow_data);
 111
 112 }
 113
 114 /* Hook called before drawing. Gets the initial context at the beginning of the
 115  * drawing interval and copy it to the context in event_request.
 116  */
 117 int draw_before_hook(void *hook_data, void *call_data)
 118 {
 119   EventRequest *event_request = (EventRequest*)hook_data;
 120   //EventsContext Events_Context = (EventsContext*)call_data;
 121
 122   //event_request->Events_Context = Events_Context;
 123
 124   return 0;
 125 }
 126
 127 /*
 128  * The draw event hook is called by the reading API to have a
 129  * particular event drawn on the screen.
 130  * @param hook_data ControlFlowData structure of the viewer.
 131  * @param call_data Event context.
 132  *
 133  * This function basically draw lines and icons. Two types of lines are drawn :
 134  * one small (3 pixels?) representing the state of the process and the second
 135  * type is thicker (10 pixels?) representing on which CPU a process is running
 136  * (and this only in running state).
 137  *
 138  * Extremums of the lines :
 139  * x_min : time of the last event context for this process kept in memory.
 140  * x_max : time of the current event.
 141  * y : middle of the process in the process list. The process is found in the
 142  * list, therefore is it's position in pixels.
 143  *
 144  * The choice of lines'color is defined by the context of the last event for this
 145  * process.
 146  */
 147 int draw_event_hook(void *hook_data, void *call_data)
 148 {
 149   EventRequest *event_request = (EventRequest*)hook_data;
 150   ControlFlowData *control_flow_data = event_request->control_flow_data;
 151
 152   LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
 153
 154   LttvTracefileState *tfs = (LttvTracefileState *)call_data;
 155
 156
 157   LttEvent *e;
 158   e = tfc->e;
 159
 160   LttTime evtime = ltt_event_time(e);
 161   TimeWindow *time_window =
 162     guicontrolflow_get_time_window(control_flow_data);
 163
 164   LttTime end_time = ltt_time_add(time_window->start_time,
 165                                     time_window->time_width);
 166   //if(time < time_beg || time > time_end) return;
 167   if(ltt_time_compare(evtime, time_window->start_time) == -1
 168         || ltt_time_compare(evtime, end_time) == 1)
 169             return;
 170
 171   if(strcmp(ltt_eventtype_name(ltt_event_eventtype(e)),"schedchange") == 0)
 172   {
 173     g_critical("schedchange!");
 174
 175     /* Add process to process list (if not present) and get drawing "y" from
 176      * process position */
 177     guint pid_out, pid_in;
 178     LttvProcessState *process_out, *process_in;
 179     LttTime birth;
 180     guint y_in = 0, y_out = 0, height = 0, pl_height = 0;
 181
 182     ProcessList *process_list =
 183       guicontrolflow_get_process_list(event_request->control_flow_data);
 184
 185
 186     LttField *f = ltt_event_field(e);
 187     LttField *element;
 188     element = ltt_field_member(f,0);
 189     pid_out = ltt_event_get_long_unsigned(e,element);
 190     element = ltt_field_member(f,1);
 191     pid_in = ltt_event_get_long_unsigned(e,element);
 192     g_critical("out : %u  in : %u", pid_out, pid_in);
 193
 194
 195     /* Find process pid_out in the list... */
 196     process_out = lttv_state_find_process(tfs, pid_out);
 197     g_critical("out : %s",g_quark_to_string(process_out->state->s));
 198
 199     birth = process_out->creation_time;
 200     gchar *name = strdup(g_quark_to_string(process_out->name));
 201     HashedProcessData *hashed_process_data_out = NULL;
 202
 203     if(processlist_get_process_pixels(process_list,
 204             pid_out,
 205             &birth,
 206             tfc->t_context->index,
 207             &y_out,
 208             &height,
 209             &hashed_process_data_out) == 1)
 210     {
 211     /* Process not present */
 212     processlist_add(process_list,
 213         pid_out,
 214         &birth,
 215         tfc->t_context->index,
 216         name,
 217         &pl_height,
 218         &hashed_process_data_out);
 219     processlist_get_process_pixels(process_list,
 220             pid_out,
 221             &birth,
 222             tfc->t_context->index,
 223             &y_out,
 224             &height,
 225             &hashed_process_data_out);
 226     drawing_insert_square( event_request->control_flow_data->drawing, y_out, height);
 227     }
 228
 229     g_free(name);
 230
 231     /* Find process pid_in in the list... */
 232     process_in = lttv_state_find_process(tfs, pid_in);
 233     g_critical("in : %s",g_quark_to_string(process_in->state->s));
 234
 235     birth = process_in->creation_time;
 236     name = strdup(g_quark_to_string(process_in->name));
 237     HashedProcessData *hashed_process_data_in = NULL;
 238
 239     if(processlist_get_process_pixels(process_list,
 240             pid_in,
 241             &birth,
 242             tfc->t_context->index,
 243             &y_in,
 244             &height,
 245             &hashed_process_data_in) == 1)
 246     {
 247     /* Process not present */
 248       processlist_add(process_list,
 249         pid_in,
 250         &birth,
 251         tfc->t_context->index,
 252         name,
 253         &pl_height,
 254         &hashed_process_data_in);
 255       processlist_get_process_pixels(process_list,
 256             pid_in,
 257             &birth,
 258             tfc->t_context->index,
 259             &y_in,
 260             &height,
 261             &hashed_process_data_in);
 262
 263       drawing_insert_square( event_request->control_flow_data->drawing, y_in, height);
 264     }
 265     g_free(name);
 266
 267
 268     /* Find pixels corresponding to time of the event. If the time does
 269      * not fit in the window, show a warning, not supposed to happend. */
 270     guint x = 0;
 271     guint width = control_flow_data->drawing->drawing_area->allocation.width;
 272
 273     LttTime time = ltt_event_time(e);
 274
 275     LttTime window_end = ltt_time_add(control_flow_data->time_window.time_width,
 276                           control_flow_data->time_window.start_time);
 277
 278
 279     convert_time_to_pixels(
 280         control_flow_data->time_window.start_time,
 281         window_end,
 282         time,
 283         width,
 284         &x);
 285     //assert(x <= width);
 286
 287     /* draw what represents the event for outgoing process. */
 288
 289     DrawContext *draw_context_out = hashed_process_data_out->draw_context;
 290     draw_context_out->current->modify_over->x = x;
 291     draw_context_out->current->modify_under->x = x;
 292     draw_context_out->current->modify_over->y = y_out;
 293     draw_context_out->current->modify_under->y = y_out+(height/2)+2;
 294     draw_context_out->drawable = control_flow_data->drawing->pixmap;
 295     draw_context_out->pango_layout = control_flow_data->drawing->pango_layout;
 296     GtkWidget *widget = control_flow_data->drawing->drawing_area;
 297     //draw_context_out->gc = widget->style->fg_gc[GTK_WIDGET_STATE (widget)];
 298     //draw_context_out->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
 299     //gdk_gc_copy(draw_context_out->gc, widget->style->black_gc);
 300     //draw_context_out->gc = widget->style->black_gc;
 301
 302     //draw_arc((void*)&prop_arc, (void*)draw_context_out);
 303     //test_draw_item(control_flow_data->drawing, control_flow_data->drawing->pixmap);
 304
 305     /* Draw the line/background of the out process */
 306     if(draw_context_out->previous->middle->x == -1)
 307     {
 308       draw_context_out->previous->over->x = event_request->x_begin;
 309       draw_context_out->previous->middle->x = event_request->x_begin;
 310       draw_context_out->previous->under->x = event_request->x_begin;
 311
 312       g_critical("out middle x_beg : %u",event_request->x_begin);
 313     }
 314
 315     draw_context_out->current->middle->x = x;
 316     draw_context_out->current->over->x = x;
 317     draw_context_out->current->under->x = x;
 318     draw_context_out->current->middle->y = y_out + height/2;
 319     draw_context_out->current->over->y = y_out;
 320     draw_context_out->current->under->y = y_out + height;
 321     draw_context_out->previous->middle->y = y_out + height/2;
 322     draw_context_out->previous->over->y = y_out;
 323     draw_context_out->previous->under->y = y_out + height;
 324
 325     draw_context_out->drawable = control_flow_data->drawing->pixmap;
 326     draw_context_out->pango_layout = control_flow_data->drawing->pango_layout;
 327
 328     if(process_out->state->s == LTTV_STATE_RUN)
 329     {
 330       draw_context_out->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
 331       gdk_gc_copy(draw_context_out->gc, widget->style->black_gc);
 332
 333       PropertiesBG prop_bg;
 334       prop_bg.color = g_new(GdkColor,1);
 335
 336       switch(tfc->index) {
 337         case 0:
 338           prop_bg.color->red = 0x1515;
 339           prop_bg.color->green = 0x1515;
 340           prop_bg.color->blue = 0x8c8c;
 341           break;
 342         case 1:
 343           prop_bg.color->red = 0x4e4e;
 344           prop_bg.color->green = 0xa9a9;
 345           prop_bg.color->blue = 0xa4a4;
 346           break;
 347         case 2:
 348           prop_bg.color->red = 0x7a7a;
 349           prop_bg.color->green = 0x4a4a;
 350           prop_bg.color->blue = 0x8b8b;
 351           break;
 352         case 3:
 353           prop_bg.color->red = 0x8080;
 354           prop_bg.color->green = 0x7777;
 355           prop_bg.color->blue = 0x4747;
 356           break;
 357         default:
 358           prop_bg.color->red = 0xe7e7;
 359           prop_bg.color->green = 0xe7e7;
 360           prop_bg.color->blue = 0xe7e7;
 361       }
 362
 363       g_critical("calling from draw_event");
 364       draw_bg((void*)&prop_bg, (void*)draw_context_out);
 365       g_free(prop_bg.color);
 366       gdk_gc_unref(draw_context_out->gc);
 367     }
 368
 369     draw_context_out->gc = widget->style->black_gc;
 370
 371     GdkColor colorfg_out = { 0, 0xffff, 0x0000, 0x0000 };
 372     GdkColor colorbg_out = { 0, 0x0000, 0x0000, 0x0000 };
 373     PropertiesText prop_text_out;
 374     prop_text_out.foreground = &colorfg_out;
 375     prop_text_out.background = &colorbg_out;
 376     prop_text_out.size = 6;
 377     prop_text_out.position = OVER;
 378
 379     /* color of text : status of the process */
 380     if(process_out->state->s == LTTV_STATE_UNNAMED)
 381     {
 382       prop_text_out.foreground->red = 0xffff;
 383       prop_text_out.foreground->green = 0xffff;
 384       prop_text_out.foreground->blue = 0xffff;
 385     }
 386     else if(process_out->state->s == LTTV_STATE_WAIT_FORK)
 387     {
 388       prop_text_out.foreground->red = 0x0fff;
 389       prop_text_out.foreground->green = 0xffff;
 390       prop_text_out.foreground->blue = 0xfff0;
 391     }
 392     else if(process_out->state->s == LTTV_STATE_WAIT_CPU)
 393     {
 394       prop_text_out.foreground->red = 0xffff;
 395       prop_text_out.foreground->green = 0xffff;
 396       prop_text_out.foreground->blue = 0x0000;
 397     }
 398     else if(process_out->state->s == LTTV_STATE_EXIT)
 399     {
 400       prop_text_out.foreground->red = 0xffff;
 401       prop_text_out.foreground->green = 0x0000;
 402       prop_text_out.foreground->blue = 0xffff;
 403     }
 404     else if(process_out->state->s == LTTV_STATE_WAIT)
 405     {
 406       prop_text_out.foreground->red = 0xffff;
 407       prop_text_out.foreground->green = 0x0000;
 408       prop_text_out.foreground->blue = 0x0000;
 409     }
 410     else if(process_out->state->s == LTTV_STATE_RUN)
 411     {
 412       prop_text_out.foreground->red = 0x0000;
 413       prop_text_out.foreground->green = 0xffff;
 414       prop_text_out.foreground->blue = 0x0000;
 415     }
 416     else
 417     {
 418       prop_text_out.foreground->red = 0xffff;
 419       prop_text_out.foreground->green = 0xffff;
 420       prop_text_out.foreground->blue = 0xffff;
 421     }
 422
 423
 424     /* Print status of the process : U, WF, WC, E, W, R */
 425     if(process_out->state->s == LTTV_STATE_UNNAMED)
 426       prop_text_out.text = "U->";
 427     else if(process_out->state->s == LTTV_STATE_WAIT_FORK)
 428       prop_text_out.text = "WF->";
 429     else if(process_out->state->s == LTTV_STATE_WAIT_CPU)
 430       prop_text_out.text = "WC->";
 431     else if(process_out->state->s == LTTV_STATE_EXIT)
 432       prop_text_out.text = "E->";
 433     else if(process_out->state->s == LTTV_STATE_WAIT)
 434       prop_text_out.text = "W->";
 435     else if(process_out->state->s == LTTV_STATE_RUN)
 436       prop_text_out.text = "R->";
 437     else
 438       prop_text_out.text = "U";
 439
 440     draw_text((void*)&prop_text_out, (void*)draw_context_out);
 441     //gdk_gc_unref(draw_context_out->gc);
 442
 443     draw_context_out->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
 444     gdk_gc_copy(draw_context_out->gc, widget->style->black_gc);
 445
 446     PropertiesLine prop_line_out;
 447     prop_line_out.color = g_new(GdkColor,1);
 448     prop_line_out.line_width = 2;
 449     prop_line_out.style = GDK_LINE_SOLID;
 450     prop_line_out.position = MIDDLE;
 451
 452     g_critical("out state : %s", g_quark_to_string(process_out->state->s));
 453
 454     /* color of line : status of the process */
 455     if(process_out->state->s == LTTV_STATE_UNNAMED)
 456     {
 457       prop_line_out.color->red = 0xffff;
 458       prop_line_out.color->green = 0xffff;
 459       prop_line_out.color->blue = 0xffff;
 460     }
 461     else if(process_out->state->s == LTTV_STATE_WAIT_FORK)
 462     {
 463       prop_line_out.color->red = 0x0fff;
 464       prop_line_out.color->green = 0xffff;
 465       prop_line_out.color->blue = 0xfff0;
 466     }
 467     else if(process_out->state->s == LTTV_STATE_WAIT_CPU)
 468     {
 469       prop_line_out.color->red = 0xffff;
 470       prop_line_out.color->green = 0xffff;
 471       prop_line_out.color->blue = 0x0000;
 472     }
 473     else if(process_out->state->s == LTTV_STATE_EXIT)
 474     {
 475       prop_line_out.color->red = 0xffff;
 476       prop_line_out.color->green = 0x0000;
 477       prop_line_out.color->blue = 0xffff;
 478     }
 479     else if(process_out->state->s == LTTV_STATE_WAIT)
 480     {
 481       prop_line_out.color->red = 0xffff;
 482       prop_line_out.color->green = 0x0000;
 483       prop_line_out.color->blue = 0x0000;
 484     }
 485     else if(process_out->state->s == LTTV_STATE_RUN)
 486     {
 487       prop_line_out.color->red = 0x0000;
 488       prop_line_out.color->green = 0xffff;
 489       prop_line_out.color->blue = 0x0000;
 490     }
 491     else
 492     {
 493       prop_line_out.color->red = 0xffff;
 494       prop_line_out.color->green = 0xffff;
 495       prop_line_out.color->blue = 0xffff;
 496     }
 497
 498     draw_line((void*)&prop_line_out, (void*)draw_context_out);
 499     g_free(prop_line_out.color);
 500     gdk_gc_unref(draw_context_out->gc);
 501     /* Note : finishing line will have to be added when trace read over. */
 502
 503     /* Finally, update the drawing context of the pid_in. */
 504
 505     DrawContext *draw_context_in = hashed_process_data_in->draw_context;
 506     draw_context_in->current->modify_over->x = x;
 507     draw_context_in->current->modify_under->x = x;
 508     draw_context_in->current->modify_over->y = y_in;
 509     draw_context_in->current->modify_under->y = y_in+(height/2)+2;
 510     draw_context_in->drawable = control_flow_data->drawing->pixmap;
 511     draw_context_in->pango_layout = control_flow_data->drawing->pango_layout;
 512     widget = control_flow_data->drawing->drawing_area;
 513     //draw_context_in->gc = widget->style->fg_gc[GTK_WIDGET_STATE (widget)];
 514     //draw_context_in->gc = widget->style->black_gc;
 515     //draw_context_in->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
 516     //gdk_gc_copy(draw_context_in->gc, widget->style->black_gc);
 517
 518     //draw_arc((void*)&prop_arc, (void*)draw_context_in);
 519     //test_draw_item(control_flow_data->drawing, control_flow_data->drawing->pixmap);
 520
 521     /* Draw the line/bg of the in process */
 522     if(draw_context_in->previous->middle->x == -1)
 523     {
 524       draw_context_in->previous->middle->x = event_request->x_begin;
 525       draw_context_in->previous->over->x = event_request->x_begin;
 526       draw_context_in->previous->under->x = event_request->x_begin;
 527       g_critical("in middle x_beg : %u",event_request->x_begin);
 528     }
 529
 530     draw_context_in->current->middle->x = x;
 531     draw_context_in->current->over->x = x;
 532     draw_context_in->current->under->x = x;
 533     draw_context_in->current->middle->y = y_in + height/2;
 534     draw_context_in->current->over->y = y_in;
 535     draw_context_in->current->under->y = y_in + height;
 536     draw_context_in->previous->middle->y = y_in + height/2;
 537     draw_context_in->previous->over->y = y_in;
 538     draw_context_in->previous->under->y = y_in + height;
 539
 540     draw_context_in->drawable = control_flow_data->drawing->pixmap;
 541     draw_context_in->pango_layout = control_flow_data->drawing->pango_layout;
 542
 543
 544     if(process_in->state->s == LTTV_STATE_RUN)
 545     {
 546       draw_context_in->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
 547       gdk_gc_copy(draw_context_in->gc, widget->style->black_gc);
 548
 549       PropertiesBG prop_bg;
 550       prop_bg.color = g_new(GdkColor,1);
 551
 552       switch(tfc->index) {
 553         case 0:
 554           prop_bg.color->red = 0x1515;
 555           prop_bg.color->green = 0x1515;
 556           prop_bg.color->blue = 0x8c8c;
 557           break;
 558         case 1:
 559           prop_bg.color->red = 0x4e4e;
 560           prop_bg.color->green = 0xa9a9;
 561           prop_bg.color->blue = 0xa4a4;
 562           break;
 563         case 2:
 564           prop_bg.color->red = 0x7a7a;
 565           prop_bg.color->green = 0x4a4a;
 566           prop_bg.color->blue = 0x8b8b;
 567           break;
 568         case 3:
 569           prop_bg.color->red = 0x8080;
 570           prop_bg.color->green = 0x7777;
 571           prop_bg.color->blue = 0x4747;
 572           break;
 573         default:
 574           prop_bg.color->red = 0xe7e7;
 575           prop_bg.color->green = 0xe7e7;
 576           prop_bg.color->blue = 0xe7e7;
 577       }
 578
 579
 580       draw_bg((void*)&prop_bg, (void*)draw_context_in);
 581       g_free(prop_bg.color);
 582       gdk_gc_unref(draw_context_in->gc);
 583     }
 584
 585     draw_context_in->gc = widget->style->black_gc;
 586
 587     GdkColor colorfg_in = { 0, 0x0000, 0xffff, 0x0000 };
 588     GdkColor colorbg_in = { 0, 0x0000, 0x0000, 0x0000 };
 589     PropertiesText prop_text_in;
 590     prop_text_in.foreground = &colorfg_in;
 591     prop_text_in.background = &colorbg_in;
 592     prop_text_in.size = 6;
 593     prop_text_in.position = OVER;
 594
 595     g_critical("in state : %s", g_quark_to_string(process_in->state->s));
 596     /* foreground of text : status of the process */
 597     if(process_in->state->s == LTTV_STATE_UNNAMED)
 598     {
 599       prop_text_in.foreground->red = 0xffff;
 600       prop_text_in.foreground->green = 0xffff;
 601       prop_text_in.foreground->blue = 0xffff;
 602     }
 603     else if(process_in->state->s == LTTV_STATE_WAIT_FORK)
 604     {
 605       prop_text_in.foreground->red = 0x0fff;
 606       prop_text_in.foreground->green = 0xffff;
 607       prop_text_in.foreground->blue = 0xfff0;
 608     }
 609     else if(process_in->state->s == LTTV_STATE_WAIT_CPU)
 610     {
 611       prop_text_in.foreground->red = 0xffff;
 612       prop_text_in.foreground->green = 0xffff;
 613       prop_text_in.foreground->blue = 0x0000;
 614     }
 615     else if(process_in->state->s == LTTV_STATE_EXIT)
 616     {
 617       prop_text_in.foreground->red = 0xffff;
 618       prop_text_in.foreground->green = 0x0000;
 619       prop_text_in.foreground->blue = 0xffff;
 620     }
 621     else if(process_in->state->s == LTTV_STATE_WAIT)
 622     {
 623       prop_text_in.foreground->red = 0xffff;
 624       prop_text_in.foreground->green = 0x0000;
 625       prop_text_in.foreground->blue = 0x0000;
 626     }
 627     else if(process_in->state->s == LTTV_STATE_RUN)
 628     {
 629       prop_text_in.foreground->red = 0x0000;
 630       prop_text_in.foreground->green = 0xffff;
 631       prop_text_in.foreground->blue = 0x0000;
 632     }
 633     else
 634     {
 635       prop_text_in.foreground->red = 0xffff;
 636       prop_text_in.foreground->green = 0xffff;
 637       prop_text_in.foreground->blue = 0xffff;
 638     }
 639
 640
 641
 642     /* Print status of the process : U, WF, WC, E, W, R */
 643     if(process_in->state->s == LTTV_STATE_UNNAMED)
 644       prop_text_in.text = "U->";
 645     else if(process_in->state->s == LTTV_STATE_WAIT_FORK)
 646       prop_text_in.text = "WF->";
 647     else if(process_in->state->s == LTTV_STATE_WAIT_CPU)
 648       prop_text_in.text = "WC->";
 649     else if(process_in->state->s == LTTV_STATE_EXIT)
 650       prop_text_in.text = "E->";
 651     else if(process_in->state->s == LTTV_STATE_WAIT)
 652       prop_text_in.text = "W->";
 653     else if(process_in->state->s == LTTV_STATE_RUN)
 654       prop_text_in.text = "R->";
 655     else
 656       prop_text_in.text = "U";
 657
 658     draw_text((void*)&prop_text_in, (void*)draw_context_in);
 659     //gdk_gc_unref(draw_context_in->gc);
 660
 661     draw_context_in->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
 662     gdk_gc_copy(draw_context_in->gc, widget->style->black_gc);
 663
 664     PropertiesLine prop_line_in;
 665     prop_line_in.color = g_new(GdkColor,1);
 666     prop_line_in.line_width = 2;
 667     prop_line_in.style = GDK_LINE_SOLID;
 668     prop_line_in.position = MIDDLE;
 669
 670     /* color of line : status of the process */
 671     if(process_in->state->s == LTTV_STATE_UNNAMED)
 672     {
 673       prop_line_in.color->red = 0xffff;
 674       prop_line_in.color->green = 0xffff;
 675       prop_line_in.color->blue = 0xffff;
 676     }
 677     else if(process_in->state->s == LTTV_STATE_WAIT_FORK)
 678     {
 679       prop_line_in.color->red = 0x0fff;
 680       prop_line_in.color->green = 0xffff;
 681       prop_line_in.color->blue = 0xfff0;
 682     }
 683     else if(process_in->state->s == LTTV_STATE_WAIT_CPU)
 684     {
 685       prop_line_in.color->red = 0xffff;
 686       prop_line_in.color->green = 0xffff;
 687       prop_line_in.color->blue = 0x0000;
 688     }
 689     else if(process_in->state->s == LTTV_STATE_EXIT)
 690     {
 691       prop_line_in.color->red = 0xffff;
 692       prop_line_in.color->green = 0x0000;
 693       prop_line_in.color->blue = 0xffff;
 694     }
 695     else if(process_in->state->s == LTTV_STATE_WAIT)
 696     {
 697       prop_line_in.color->red = 0xffff;
 698       prop_line_in.color->green = 0x0000;
 699       prop_line_in.color->blue = 0x0000;
 700     }
 701     else if(process_in->state->s == LTTV_STATE_RUN)
 702     {
 703       prop_line_in.color->red = 0x0000;
 704       prop_line_in.color->green = 0xffff;
 705       prop_line_in.color->blue = 0x0000;
 706     }
 707     else
 708     {
 709       prop_line_in.color->red = 0xffff;
 710       prop_line_in.color->green = 0xffff;
 711       prop_line_in.color->blue = 0xffff;
 712     }
 713
 714     draw_line((void*)&prop_line_in, (void*)draw_context_in);
 715     g_free(prop_line_in.color);
 716     gdk_gc_unref(draw_context_in->gc);
 717   }
 718
 719   return 0;
 720
 721   /* Temp dump */
 722 #ifdef DONTSHOW
 723   GString *string = g_string_new("");;
 724   gboolean field_names = TRUE, state = TRUE;
 725
 726   lttv_event_to_string(e, tfc->tf, string, TRUE, field_names, tfs);
 727   g_string_append_printf(string,"\n");
 728
 729   if(state) {
 730     g_string_append_printf(string, " %s",
 731         g_quark_to_string(tfs->process->state->s));
 732   }
 733
 734   g_info("%s",string->str);
 735
 736   g_string_free(string, TRUE);
 737
 738   /* End of text dump */
 739 #endif //DONTSHOW
 740
 741 }
 742
 743
 744 int draw_after_hook(void *hook_data, void *call_data)
 745 {
 746   EventRequest *event_request = (EventRequest*)hook_data;
 747   ControlFlowData *control_flow_data = event_request->control_flow_data;
 748
 749   LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
 750
 751   LttvTracefileState *tfs = (LttvTracefileState *)call_data;
 752
 753
 754   LttEvent *e;
 755   e = tfc->e;
 756
 757   LttTime evtime = ltt_event_time(e);
 758   TimeWindow *time_window =
 759     guicontrolflow_get_time_window(control_flow_data);
 760
 761   LttTime end_time = ltt_time_add(time_window->start_time,
 762                                     time_window->time_width);
 763   //if(time < time_beg || time > time_end) return;
 764   if(ltt_time_compare(evtime, time_window->start_time) == -1
 765         || ltt_time_compare(evtime, end_time) == 1)
 766             return;
 767
 768
 769   if(strcmp(ltt_eventtype_name(ltt_event_eventtype(e)),"schedchange") == 0)
 770   {
 771     g_critical("schedchange!");
 772
 773     /* Add process to process list (if not present) and get drawing "y" from
 774      * process position */
 775     guint pid_out, pid_in;
 776     LttvProcessState *process_out, *process_in;
 777     LttTime birth;
 778     guint y_in = 0, y_out = 0, height = 0, pl_height = 0;
 779
 780     ProcessList *process_list =
 781       guicontrolflow_get_process_list(event_request->control_flow_data);
 782
 783
 784     LttField *f = ltt_event_field(e);
 785     LttField *element;
 786     element = ltt_field_member(f,0);
 787     pid_out = ltt_event_get_long_unsigned(e,element);
 788     element = ltt_field_member(f,1);
 789     pid_in = ltt_event_get_long_unsigned(e,element);
 790     //g_critical("out : %u  in : %u", pid_out, pid_in);
 791
 792
 793     /* Find process pid_out in the list... */
 794     process_out = lttv_state_find_process(tfs, pid_out);
 795     //g_critical("out : %s",g_quark_to_string(process_out->state->s));
 796
 797     birth = process_out->creation_time;
 798     gchar *name = strdup(g_quark_to_string(process_out->name));
 799     HashedProcessData *hashed_process_data_out = NULL;
 800
 801     if(processlist_get_process_pixels(process_list,
 802             pid_out,
 803             &birth,
 804             tfc->t_context->index,
 805             &y_out,
 806             &height,
 807             &hashed_process_data_out) == 1)
 808     {
 809     /* Process not present */
 810     processlist_add(process_list,
 811         pid_out,
 812         &birth,
 813         tfc->t_context->index,
 814         name,
 815         &pl_height,
 816         &hashed_process_data_out);
 817     processlist_get_process_pixels(process_list,
 818             pid_out,
 819             &birth,
 820             tfc->t_context->index,
 821             &y_out,
 822             &height,
 823             &hashed_process_data_out);
 824     drawing_insert_square( event_request->control_flow_data->drawing, y_out, height);
 825     }
 826
 827     g_free(name);
 828
 829     /* Find process pid_in in the list... */
 830     process_in = lttv_state_find_process(tfs, pid_in);
 831     //g_critical("in : %s",g_quark_to_string(process_in->state->s));
 832
 833     birth = process_in->creation_time;
 834     name = strdup(g_quark_to_string(process_in->name));
 835     HashedProcessData *hashed_process_data_in = NULL;
 836
 837     if(processlist_get_process_pixels(process_list,
 838             pid_in,
 839             &birth,
 840             tfc->t_context->index,
 841             &y_in,
 842             &height,
 843             &hashed_process_data_in) == 1)
 844     {
 845     /* Process not present */
 846       processlist_add(process_list,
 847         pid_in,
 848         &birth,
 849         tfc->t_context->index,
 850         name,
 851         &pl_height,
 852         &hashed_process_data_in);
 853       processlist_get_process_pixels(process_list,
 854             pid_in,
 855             &birth,
 856             tfc->t_context->index,
 857             &y_in,
 858             &height,
 859             &hashed_process_data_in);
 860
 861       drawing_insert_square( event_request->control_flow_data->drawing, y_in, height);
 862     }
 863     g_free(name);
 864
 865
 866     /* Find pixels corresponding to time of the event. If the time does
 867      * not fit in the window, show a warning, not supposed to happend. */
 868     //guint x = 0;
 869     //guint width = control_flow_data->drawing->drawing_area->allocation.width;
 870
 871     //LttTime time = ltt_event_time(e);
 872
 873     //LttTime window_end = ltt_time_add(control_flow_data->time_window.time_width,
 874     //                      control_flow_data->time_window.start_time);
 875
 876
 877     //convert_time_to_pixels(
 878     //    control_flow_data->time_window.start_time,
 879     //    window_end,
 880     //    time,
 881     //    width,
 882     //    &x);
 883
 884     //assert(x <= width);
 885
 886     /* draw what represents the event for outgoing process. */
 887
 888     DrawContext *draw_context_out = hashed_process_data_out->draw_context;
 889     //draw_context_out->current->modify_over->x = x;
 890     draw_context_out->current->modify_over->y = y_out;
 891     draw_context_out->current->modify_under->y = y_out+(height/2)+2;
 892     draw_context_out->drawable = control_flow_data->drawing->pixmap;
 893     draw_context_out->pango_layout = control_flow_data->drawing->pango_layout;
 894     GtkWidget *widget = control_flow_data->drawing->drawing_area;
 895     //draw_context_out->gc = widget->style->fg_gc[GTK_WIDGET_STATE (widget)];
 896
 897     //draw_arc((void*)&prop_arc, (void*)draw_context_out);
 898     //test_draw_item(control_flow_data->drawing, control_flow_data->drawing->pixmap);
 899
 900     /*if(process_out->state->s == LTTV_STATE_RUN)
 901     {
 902       draw_context_out->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
 903       gdk_gc_copy(draw_context_out->gc, widget->style->black_gc);
 904       PropertiesBG prop_bg;
 905       prop_bg.color = g_new(GdkColor,1);
 906
 907       prop_bg.color->red = 0xffff;
 908       prop_bg.color->green = 0xffff;
 909       prop_bg.color->blue = 0xffff;
 910
 911       draw_bg((void*)&prop_bg, (void*)draw_context_out);
 912       g_free(prop_bg.color);
 913       gdk_gc_unref(draw_context_out->gc);
 914     }*/
 915
 916     draw_context_out->gc = widget->style->black_gc;
 917
 918     GdkColor colorfg_out = { 0, 0xffff, 0x0000, 0x0000 };
 919     GdkColor colorbg_out = { 0, 0x0000, 0x0000, 0x0000 };
 920     PropertiesText prop_text_out;
 921     prop_text_out.foreground = &colorfg_out;
 922     prop_text_out.background = &colorbg_out;
 923     prop_text_out.size = 6;
 924     prop_text_out.position = OVER;
 925
 926     /* color of text : status of the process */
 927     if(process_out->state->s == LTTV_STATE_UNNAMED)
 928     {
 929       prop_text_out.foreground->red = 0xffff;
 930       prop_text_out.foreground->green = 0xffff;
 931       prop_text_out.foreground->blue = 0xffff;
 932     }
 933     else if(process_out->state->s == LTTV_STATE_WAIT_FORK)
 934     {
 935       prop_text_out.foreground->red = 0x0fff;
 936       prop_text_out.foreground->green = 0xffff;
 937       prop_text_out.foreground->blue = 0xfff0;
 938     }
 939     else if(process_out->state->s == LTTV_STATE_WAIT_CPU)
 940     {
 941       prop_text_out.foreground->red = 0xffff;
 942       prop_text_out.foreground->green = 0xffff;
 943       prop_text_out.foreground->blue = 0x0000;
 944     }
 945     else if(process_out->state->s == LTTV_STATE_EXIT)
 946     {
 947       prop_text_out.foreground->red = 0xffff;
 948       prop_text_out.foreground->green = 0x0000;
 949       prop_text_out.foreground->blue = 0xffff;
 950     }
 951     else if(process_out->state->s == LTTV_STATE_WAIT)
 952     {
 953       prop_text_out.foreground->red = 0xffff;
 954       prop_text_out.foreground->green = 0x0000;
 955       prop_text_out.foreground->blue = 0x0000;
 956     }
 957     else if(process_out->state->s == LTTV_STATE_RUN)
 958     {
 959       prop_text_out.foreground->red = 0x0000;
 960       prop_text_out.foreground->green = 0xffff;
 961       prop_text_out.foreground->blue = 0x0000;
 962     }
 963     else
 964     {
 965       prop_text_out.foreground->red = 0xffff;
 966       prop_text_out.foreground->green = 0xffff;
 967       prop_text_out.foreground->blue = 0xffff;
 968     }
 969
 970     /* Print status of the process : U, WF, WC, E, W, R */
 971     if(process_out->state->s == LTTV_STATE_UNNAMED)
 972       prop_text_out.text = "U";
 973     else if(process_out->state->s == LTTV_STATE_WAIT_FORK)
 974       prop_text_out.text = "WF";
 975     else if(process_out->state->s == LTTV_STATE_WAIT_CPU)
 976       prop_text_out.text = "WC";
 977     else if(process_out->state->s == LTTV_STATE_EXIT)
 978       prop_text_out.text = "E";
 979     else if(process_out->state->s == LTTV_STATE_WAIT)
 980       prop_text_out.text = "W";
 981     else if(process_out->state->s == LTTV_STATE_RUN)
 982       prop_text_out.text = "R";
 983     else
 984       prop_text_out.text = "U";
 985
 986     draw_text((void*)&prop_text_out, (void*)draw_context_out);
 987
 988     //gdk_gc_unref(draw_context_out->gc);
 989
 990     draw_context_out->current->middle->y = y_out+height/2;
 991     draw_context_out->current->over->y = y_out;
 992     draw_context_out->current->under->y = y_out+height;
 993     draw_context_out->current->status = process_out->state->s;
 994
 995     /* for pid_out : remove previous, Prev = current, new current (default) */
 996     g_free(draw_context_out->previous->modify_under);
 997     g_free(draw_context_out->previous->modify_middle);
 998     g_free(draw_context_out->previous->modify_over);
 999     g_free(draw_context_out->previous->under);
1000     g_free(draw_context_out->previous->middle);
1001     g_free(draw_context_out->previous->over);
1002     g_free(draw_context_out->previous);
1003
1004     draw_context_out->previous = draw_context_out->current;
1005
1006     draw_context_out->current = g_new(DrawInfo,1);
1007     draw_context_out->current->over = g_new(ItemInfo,1);
1008     draw_context_out->current->over->x = -1;
1009     draw_context_out->current->over->y = -1;
1010     draw_context_out->current->middle = g_new(ItemInfo,1);
1011     draw_context_out->current->middle->x = -1;
1012     draw_context_out->current->middle->y = -1;
1013     draw_context_out->current->under = g_new(ItemInfo,1);
1014     draw_context_out->current->under->x = -1;
1015     draw_context_out->current->under->y = -1;
1016     draw_context_out->current->modify_over = g_new(ItemInfo,1);
1017     draw_context_out->current->modify_over->x = -1;
1018     draw_context_out->current->modify_over->y = -1;
1019     draw_context_out->current->modify_middle = g_new(ItemInfo,1);
1020     draw_context_out->current->modify_middle->x = -1;
1021     draw_context_out->current->modify_middle->y = -1;
1022     draw_context_out->current->modify_under = g_new(ItemInfo,1);
1023     draw_context_out->current->modify_under->x = -1;
1024     draw_context_out->current->modify_under->y = -1;
1025     draw_context_out->current->status = LTTV_STATE_UNNAMED;
1026
1027     /* Finally, update the drawing context of the pid_in. */
1028
1029     DrawContext *draw_context_in = hashed_process_data_in->draw_context;
1030     //draw_context_in->current->modify_over->x = x;
1031     draw_context_in->current->modify_over->y = y_in;
1032     draw_context_in->current->modify_under->y = y_in+(height/2)+2;
1033     draw_context_in->drawable = control_flow_data->drawing->pixmap;
1034     draw_context_in->pango_layout = control_flow_data->drawing->pango_layout;
1035     widget = control_flow_data->drawing->drawing_area;
1036     //draw_context_in->gc = widget->style->fg_gc[GTK_WIDGET_STATE (widget)];
1037
1038     //draw_arc((void*)&prop_arc, (void*)draw_context_in);
1039     //test_draw_item(control_flow_data->drawing, control_flow_data->drawing->pixmap);
1040
1041     /*if(process_in->state->s == LTTV_STATE_RUN)
1042     {
1043       draw_context_in->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
1044       gdk_gc_copy(draw_context_in->gc, widget->style->black_gc);
1045       PropertiesBG prop_bg;
1046       prop_bg.color = g_new(GdkColor,1);
1047
1048       prop_bg.color->red = 0xffff;
1049       prop_bg.color->green = 0xffff;
1050       prop_bg.color->blue = 0xffff;
1051
1052       draw_bg((void*)&prop_bg, (void*)draw_context_in);
1053       g_free(prop_bg.color);
1054       gdk_gc_unref(draw_context_in->gc);
1055     }*/
1056
1057     draw_context_in->gc = widget->style->black_gc;
1058
1059     GdkColor colorfg_in = { 0, 0x0000, 0xffff, 0x0000 };
1060     GdkColor colorbg_in = { 0, 0x0000, 0x0000, 0x0000 };
1061     PropertiesText prop_text_in;
1062     prop_text_in.foreground = &colorfg_in;
1063     prop_text_in.background = &colorbg_in;
1064     prop_text_in.size = 6;
1065     prop_text_in.position = OVER;
1066
1067     /* foreground of text : status of the process */
1068     if(process_in->state->s == LTTV_STATE_UNNAMED)
1069     {
1070       prop_text_in.foreground->red = 0xffff;
1071       prop_text_in.foreground->green = 0xffff;
1072       prop_text_in.foreground->blue = 0xffff;
1073     }
1074     else if(process_in->state->s == LTTV_STATE_WAIT_FORK)
1075     {
1076       prop_text_in.foreground->red = 0x0fff;
1077       prop_text_in.foreground->green = 0xffff;
1078       prop_text_in.foreground->blue = 0xfff0;
1079     }
1080     else if(process_in->state->s == LTTV_STATE_WAIT_CPU)
1081     {
1082       prop_text_in.foreground->red = 0xffff;
1083       prop_text_in.foreground->green = 0xffff;
1084       prop_text_in.foreground->blue = 0x0000;
1085     }
1086     else if(process_in->state->s == LTTV_STATE_EXIT)
1087     {
1088       prop_text_in.foreground->red = 0xffff;
1089       prop_text_in.foreground->green = 0x0000;
1090       prop_text_in.foreground->blue = 0xffff;
1091     }
1092     else if(process_in->state->s == LTTV_STATE_WAIT)
1093     {
1094       prop_text_in.foreground->red = 0xffff;
1095       prop_text_in.foreground->green = 0x0000;
1096       prop_text_in.foreground->blue = 0x0000;
1097     }
1098     else if(process_in->state->s == LTTV_STATE_RUN)
1099     {
1100       prop_text_in.foreground->red = 0x0000;
1101       prop_text_in.foreground->green = 0xffff;
1102       prop_text_in.foreground->blue = 0x0000;
1103     }
1104     else
1105     {
1106       prop_text_in.foreground->red = 0xffff;
1107       prop_text_in.foreground->green = 0xffff;
1108       prop_text_in.foreground->blue = 0xffff;
1109     }
1110
1111
1112     /* Print status of the process : U, WF, WC, E, W, R */
1113     if(process_in->state->s == LTTV_STATE_UNNAMED)
1114       prop_text_in.text = "U";
1115     else if(process_in->state->s == LTTV_STATE_WAIT_FORK)
1116       prop_text_in.text = "WF";
1117     else if(process_in->state->s == LTTV_STATE_WAIT_CPU)
1118       prop_text_in.text = "WC";
1119     else if(process_in->state->s == LTTV_STATE_EXIT)
1120       prop_text_in.text = "E";
1121     else if(process_in->state->s == LTTV_STATE_WAIT)
1122       prop_text_in.text = "W";
1123     else if(process_in->state->s == LTTV_STATE_RUN)
1124       prop_text_in.text = "R";
1125     else
1126       prop_text_in.text = "U";
1127
1128     draw_text((void*)&prop_text_in, (void*)draw_context_in);
1129
1130
1131     if(process_in->state->s == LTTV_STATE_RUN)
1132     {
1133       gchar tmp[255];
1134       prop_text_in.foreground = &colorfg_in;
1135       prop_text_in.background = &colorbg_in;
1136       prop_text_in.foreground->red = 0xffff;
1137       prop_text_in.foreground->green = 0xffff;
1138       prop_text_in.foreground->blue = 0xffff;
1139       prop_text_in.size = 6;
1140       prop_text_in.position = UNDER;
1141
1142       prop_text_in.text = g_new(gchar, 260);
1143       strcpy(prop_text_in.text, "CPU ");
1144       snprintf(tmp, 255, "%u", tfc->index);
1145       strcat(prop_text_in.text, tmp);
1146
1147       draw_text((void*)&prop_text_in, (void*)draw_context_in);
1148       g_free(prop_text_in.text);
1149     }
1150
1151
1152     draw_context_in->current->middle->y = y_in+height/2;
1153     draw_context_in->current->over->y = y_in;
1154     draw_context_in->current->under->y = y_in+height;
1155     draw_context_in->current->status = process_in->state->s;
1156
1157     /* for pid_in : remove previous, Prev = current, new current (default) */
1158     g_free(draw_context_in->previous->modify_under);
1159     g_free(draw_context_in->previous->modify_middle);
1160     g_free(draw_context_in->previous->modify_over);
1161     g_free(draw_context_in->previous->under);
1162     g_free(draw_context_in->previous->middle);
1163     g_free(draw_context_in->previous->over);
1164     g_free(draw_context_in->previous);
1165
1166     draw_context_in->previous = draw_context_in->current;
1167
1168     draw_context_in->current = g_new(DrawInfo,1);
1169     draw_context_in->current->over = g_new(ItemInfo,1);
1170     draw_context_in->current->over->x = -1;
1171     draw_context_in->current->over->y = -1;
1172     draw_context_in->current->middle = g_new(ItemInfo,1);
1173     draw_context_in->current->middle->x = -1;
1174     draw_context_in->current->middle->y = -1;
1175     draw_context_in->current->under = g_new(ItemInfo,1);
1176     draw_context_in->current->under->x = -1;
1177     draw_context_in->current->under->y = -1;
1178     draw_context_in->current->modify_over = g_new(ItemInfo,1);
1179     draw_context_in->current->modify_over->x = -1;
1180     draw_context_in->current->modify_over->y = -1;
1181     draw_context_in->current->modify_middle = g_new(ItemInfo,1);
1182     draw_context_in->current->modify_middle->x = -1;
1183     draw_context_in->current->modify_middle->y = -1;
1184     draw_context_in->current->modify_under = g_new(ItemInfo,1);
1185     draw_context_in->current->modify_under->x = -1;
1186     draw_context_in->current->modify_under->y = -1;
1187     draw_context_in->current->status = LTTV_STATE_UNNAMED;
1188
1189   }
1190
1191   return 0;
1192 }
1193
1194
1195
1196
1197 gint update_time_window_hook(void *hook_data, void *call_data)
1198 {
1199   ControlFlowData *control_flow_data = (ControlFlowData*) hook_data;
1200   TimeWindow *old_time_window =
1201     guicontrolflow_get_time_window(control_flow_data);
1202   TimeWindow *new_time_window = ((TimeWindow*)call_data);
1203
1204   /* Update the ruler */
1205   drawing_update_ruler(control_flow_data->drawing,
1206                        new_time_window);
1207
1208
1209   /* Two cases : zoom in/out or scrolling */
1210
1211   /* In order to make sure we can reuse the old drawing, the scale must
1212    * be the same and the new time interval being partly located in the
1213    * currently shown time interval. (reuse is only for scrolling)
1214    */
1215
1216   g_info("Old time window HOOK : %u, %u to %u, %u",
1217       old_time_window->start_time.tv_sec,
1218       old_time_window->start_time.tv_nsec,
1219       old_time_window->time_width.tv_sec,
1220       old_time_window->time_width.tv_nsec);
1221
1222   g_info("New time window HOOK : %u, %u to %u, %u",
1223       new_time_window->start_time.tv_sec,
1224       new_time_window->start_time.tv_nsec,
1225       new_time_window->time_width.tv_sec,
1226       new_time_window->time_width.tv_nsec);
1227
1228   if( new_time_window->time_width.tv_sec == old_time_window->time_width.tv_sec
1229   && new_time_window->time_width.tv_nsec == old_time_window->time_width.tv_nsec)
1230   {
1231     /* Same scale (scrolling) */
1232     g_info("scrolling");
1233     LttTime *ns = &new_time_window->start_time;
1234     LttTime *os = &old_time_window->start_time;
1235     LttTime old_end = ltt_time_add(old_time_window->start_time,
1236                                     old_time_window->time_width);
1237     LttTime new_end = ltt_time_add(new_time_window->start_time,
1238                                     new_time_window->time_width);
1239     //if(ns<os+w<ns+w)
1240     //if(ns<os+w && os+w<ns+w)
1241     //if(ns<old_end && os<ns)
1242     if(ltt_time_compare(*ns, old_end) == -1
1243         && ltt_time_compare(*os, *ns) == -1)
1244     {
1245       g_info("scrolling near right");
1246       /* Scroll right, keep right part of the screen */
1247       guint x = 0;
1248       guint width = control_flow_data->drawing->drawing_area->allocation.width;
1249       convert_time_to_pixels(
1250           *os,
1251           old_end,
1252           *ns,
1253           width,
1254           &x);
1255
1256       /* Copy old data to new location */
1257       gdk_draw_drawable (control_flow_data->drawing->pixmap,
1258           control_flow_data->drawing->drawing_area->style->black_gc,
1259           control_flow_data->drawing->pixmap,
1260           x, 0,
1261           0, 0,
1262           -1, -1);
1263
1264       convert_time_to_pixels(
1265           *ns,
1266           new_end,
1267           old_end,
1268           width,
1269           &x);
1270
1271       *old_time_window = *new_time_window;
1272       /* Clear the data request background, but not SAFETY */
1273       gdk_draw_rectangle (control_flow_data->drawing->pixmap,
1274           control_flow_data->drawing->drawing_area->style->black_gc,
1275           TRUE,
1276           x+SAFETY, 0,
1277           control_flow_data->drawing->width - x,  // do not overlap
1278           control_flow_data->drawing->height+SAFETY);
1279       /* Get new data for the rest. */
1280       drawing_data_request(control_flow_data->drawing,
1281           &control_flow_data->drawing->pixmap,
1282           x, 0,
1283           control_flow_data->drawing->width - x,
1284           control_flow_data->drawing->height);
1285
1286       drawing_refresh(control_flow_data->drawing,
1287           0, 0,
1288           control_flow_data->drawing->width,
1289           control_flow_data->drawing->height);
1290
1291
1292     } else {
1293       //if(ns<os<ns+w)
1294       //if(ns<os && os<ns+w)
1295       //if(ns<os && os<new_end)
1296       if(ltt_time_compare(*ns,*os) == -1
1297           && ltt_time_compare(*os,new_end) == -1)
1298       {
1299         g_info("scrolling near left");
1300         /* Scroll left, keep left part of the screen */
1301         guint x = 0;
1302         guint width = control_flow_data->drawing->drawing_area->allocation.width;
1303         convert_time_to_pixels(
1304             *ns,
1305             new_end,
1306             *os,
1307             width,
1308             &x);
1309
1310         /* Copy old data to new location */
1311         gdk_draw_drawable (control_flow_data->drawing->pixmap,
1312             control_flow_data->drawing->drawing_area->style->black_gc,
1313             control_flow_data->drawing->pixmap,
1314             0, 0,
1315             x, 0,
1316             -1, -1);
1317
1318         *old_time_window = *new_time_window;
1319
1320         /* Clean the data request background */
1321         gdk_draw_rectangle (control_flow_data->drawing->pixmap,
1322           control_flow_data->drawing->drawing_area->style->black_gc,
1323           TRUE,
1324           0, 0,
1325           x,  // do not overlap
1326           control_flow_data->drawing->height+SAFETY);
1327         /* Get new data for the rest. */
1328         drawing_data_request(control_flow_data->drawing,
1329             &control_flow_data->drawing->pixmap,
1330             0, 0,
1331             x,
1332             control_flow_data->drawing->height);
1333
1334         drawing_refresh(control_flow_data->drawing,
1335             0, 0,
1336             control_flow_data->drawing->width,
1337             control_flow_data->drawing->height);
1338
1339       } else {
1340         g_info("scrolling far");
1341         /* Cannot reuse any part of the screen : far jump */
1342         *old_time_window = *new_time_window;
1343
1344
1345         gdk_draw_rectangle (control_flow_data->drawing->pixmap,
1346           control_flow_data->drawing->drawing_area->style->black_gc,
1347           TRUE,
1348           0, 0,
1349           control_flow_data->drawing->width+SAFETY, // do not overlap
1350           control_flow_data->drawing->height+SAFETY);
1351
1352         drawing_data_request(control_flow_data->drawing,
1353             &control_flow_data->drawing->pixmap,
1354             0, 0,
1355             control_flow_data->drawing->width,
1356             control_flow_data->drawing->height);
1357
1358         drawing_refresh(control_flow_data->drawing,
1359             0, 0,
1360             control_flow_data->drawing->width,
1361             control_flow_data->drawing->height);
1362       }
1363     }
1364   } else {
1365     /* Different scale (zoom) */
1366     g_info("zoom");
1367
1368     *old_time_window = *new_time_window;
1369
1370     gdk_draw_rectangle (control_flow_data->drawing->pixmap,
1371           control_flow_data->drawing->drawing_area->style->black_gc,
1372           TRUE,
1373           0, 0,
1374           control_flow_data->drawing->width+SAFETY, // do not overlap
1375           control_flow_data->drawing->height+SAFETY);
1376
1377
1378     drawing_data_request(control_flow_data->drawing,
1379         &control_flow_data->drawing->pixmap,
1380         0, 0,
1381         control_flow_data->drawing->width,
1382         control_flow_data->drawing->height);
1383
1384     drawing_refresh(control_flow_data->drawing,
1385         0, 0,
1386         control_flow_data->drawing->width,
1387         control_flow_data->drawing->height);
1388   }
1389
1390
1391
1392   return 0;
1393 }
1394
1395 gint update_current_time_hook(void *hook_data, void *call_data)
1396 {
1397   ControlFlowData *control_flow_data = (ControlFlowData*)hook_data;
1398
1399   LttTime* current_time =
1400     guicontrolflow_get_current_time(control_flow_data);
1401   *current_time = *((LttTime*)call_data);
1402
1403   TimeWindow time_window;
1404
1405   LttTime time_begin = control_flow_data->time_window.start_time;
1406   LttTime width = control_flow_data->time_window.time_width;
1407   LttTime half_width = ltt_time_div(width,2.0);
1408   LttTime time_end = ltt_time_add(time_begin, width);
1409
1410   LttvTracesetContext * tsc =
1411         get_traceset_context(control_flow_data->mw);
1412
1413   LttTime trace_start = tsc->Time_Span->startTime;
1414   LttTime trace_end = tsc->Time_Span->endTime;
1415
1416   g_info("New current time HOOK : %u, %u", current_time->tv_sec,
1417               current_time->tv_nsec);
1418
1419
1420
1421   /* If current time is inside time interval, just move the highlight
1422    * bar */
1423
1424   /* Else, we have to change the time interval. We have to tell it
1425    * to the main window. */
1426   /* The time interval change will take care of placing the current
1427    * time at the center of the visible area, or nearest possible if we are
1428    * at one end of the trace. */
1429
1430
1431   if(ltt_time_compare(*current_time, time_begin) == -1)
1432   {
1433     if(ltt_time_compare(*current_time,
1434           ltt_time_add(trace_start,half_width)) == -1)
1435       time_begin = trace_start;
1436     else
1437       time_begin = ltt_time_sub(*current_time,half_width);
1438
1439     time_window.start_time = time_begin;
1440     time_window.time_width = width;
1441
1442     set_time_window(control_flow_data->mw, &time_window);
1443   }
1444   else if(ltt_time_compare(*current_time, time_end) == 1)
1445   {
1446     if(ltt_time_compare(*current_time, ltt_time_sub(trace_end, half_width)) == 1)
1447       time_begin = ltt_time_sub(trace_end,width);
1448     else
1449       time_begin = ltt_time_sub(*current_time,half_width);
1450
1451     time_window.start_time = time_begin;
1452     time_window.time_width = width;
1453
1454     set_time_window(control_flow_data->mw, &time_window);
1455
1456   }
1457   gtk_widget_queue_draw(control_flow_data->drawing->drawing_area);
1458
1459   return 0;
1460 }
1461
1462 typedef struct _ClosureData {
1463   EventRequest *event_request;
1464   LttvTracesetState *tss;
1465 } ClosureData;
1466
1467
1468 void draw_closure(gpointer key, gpointer value, gpointer user_data)
1469 {
1470   ProcessInfo *process_info = (ProcessInfo*)key;
1471   HashedProcessData *hashed_process_data = (HashedProcessData*)value;
1472   ClosureData *closure_data = (ClosureData*)user_data;
1473
1474   ControlFlowData *control_flow_data =
1475     closure_data->event_request->control_flow_data;
1476
1477   GtkWidget *widget = control_flow_data->drawing->drawing_area;
1478
1479   /* Get y position of process */
1480   gint y=0, height=0;
1481
1482   processlist_get_pixels_from_data( control_flow_data->process_list,
1483           process_info,
1484           hashed_process_data,
1485           &y,
1486           &height);
1487   /* Get last state of process */
1488   LttvTraceContext *tc =
1489     ((LttvTracesetContext*)closure_data->tss)->traces[process_info->trace_num];
1490   //LttvTracefileContext *tfc = (LttvTracefileContext *)closure_data->ts;
1491
1492   LttvTraceState *ts = (LttvTraceState*)tc;
1493   LttvProcessState *process;
1494
1495   process = lttv_state_find_process_from_trace(ts, process_info->pid);
1496
1497   /* Draw the closing line */
1498   DrawContext *draw_context = hashed_process_data->draw_context;
1499   if(draw_context->previous->middle->x == -1)
1500   {
1501     draw_context->previous->middle->x = closure_data->event_request->x_begin;
1502     draw_context->previous->over->x = closure_data->event_request->x_begin;
1503     draw_context->previous->under->x = closure_data->event_request->x_begin;
1504     g_critical("out middle x_beg : %u",closure_data->event_request->x_begin);
1505   }
1506
1507   draw_context->current->middle->x = closure_data->event_request->x_end;
1508   draw_context->current->over->x = closure_data->event_request->x_end;
1509   draw_context->current->under->x = closure_data->event_request->x_end;
1510   draw_context->current->middle->y = y + height/2;
1511   draw_context->current->over->y = y ;
1512   draw_context->current->under->y = y + height;
1513   draw_context->previous->middle->y = y + height/2;
1514   draw_context->previous->over->y = y ;
1515   draw_context->previous->under->y = y + height;
1516   draw_context->drawable = control_flow_data->drawing->pixmap;
1517   draw_context->pango_layout = control_flow_data->drawing->pango_layout;
1518   //draw_context->gc = widget->style->black_gc;
1519   draw_context->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
1520   gdk_gc_copy(draw_context->gc, widget->style->black_gc);
1521
1522   if(process->state->s == LTTV_STATE_RUN)
1523   {
1524     PropertiesBG prop_bg;
1525     prop_bg.color = g_new(GdkColor,1);
1526
1527     /*switch(tfc->index) {
1528       case 0:
1529         prop_bg.color->red = 0x1515;
1530         prop_bg.color->green = 0x1515;
1531         prop_bg.color->blue = 0x8c8c;
1532         break;
1533       case 1:
1534         prop_bg.color->red = 0x4e4e;
1535         prop_bg.color->green = 0xa9a9;
1536         prop_bg.color->blue = 0xa4a4;
1537       break;
1538       case 2:
1539         prop_bg.color->red = 0x7a7a;
1540         prop_bg.color->green = 0x4a4a;
1541         prop_bg.color->blue = 0x8b8b;
1542         break;
1543       case 3:
1544         prop_bg.color->red = 0x8080;
1545         prop_bg.color->green = 0x7777;
1546         prop_bg.color->blue = 0x4747;
1547         break;
1548       default:
1549         prop_bg.color->red = 0xe7e7;
1550         prop_bg.color->green = 0xe7e7;
1551         prop_bg.color->blue = 0xe7e7;
1552     }
1553     */
1554
1555     g_critical("calling from closure");
1556     //FIXME : I need the cpu number in process's state to draw this.
1557     //draw_bg((void*)&prop_bg, (void*)draw_context);
1558     g_free(prop_bg.color);
1559   }
1560
1561
1562   PropertiesLine prop_line;
1563   prop_line.color = g_new(GdkColor,1);
1564   prop_line.line_width = 2;
1565   prop_line.style = GDK_LINE_SOLID;
1566   prop_line.position = MIDDLE;
1567
1568   /* color of line : status of the process */
1569   if(process->state->s == LTTV_STATE_UNNAMED)
1570   {
1571     prop_line.color->red = 0xffff;
1572     prop_line.color->green = 0xffff;
1573     prop_line.color->blue = 0xffff;
1574   }
1575   else if(process->state->s == LTTV_STATE_WAIT_FORK)
1576   {
1577     prop_line.color->red = 0x0fff;
1578     prop_line.color->green = 0xffff;
1579     prop_line.color->blue = 0xfff0;
1580   }
1581   else if(process->state->s == LTTV_STATE_WAIT_CPU)
1582   {
1583     prop_line.color->red = 0xffff;
1584     prop_line.color->green = 0xffff;
1585     prop_line.color->blue = 0x0000;
1586   }
1587   else if(process->state->s == LTTV_STATE_EXIT)
1588   {
1589     prop_line.color->red = 0xffff;
1590     prop_line.color->green = 0x0000;
1591     prop_line.color->blue = 0xffff;
1592   }
1593   else if(process->state->s == LTTV_STATE_WAIT)
1594   {
1595     prop_line.color->red = 0xffff;
1596     prop_line.color->green = 0x0000;
1597     prop_line.color->blue = 0x0000;
1598   }
1599   else if(process->state->s == LTTV_STATE_RUN)
1600   {
1601     prop_line.color->red = 0x0000;
1602     prop_line.color->green = 0xffff;
1603     prop_line.color->blue = 0x0000;
1604   }
1605   else
1606   {
1607     prop_line.color->red = 0xffff;
1608     prop_line.color->green = 0xffff;
1609     prop_line.color->blue = 0xffff;
1610   }
1611
1612   draw_line((void*)&prop_line, (void*)draw_context);
1613   g_free(prop_line.color);
1614   gdk_gc_unref(draw_context->gc);
1615
1616   /* Reset draw_context of the process for next request */
1617
1618   hashed_process_data->draw_context->drawable = NULL;
1619   hashed_process_data->draw_context->gc = NULL;
1620   hashed_process_data->draw_context->pango_layout = NULL;
1621   hashed_process_data->draw_context->current->over->x = -1;
1622   hashed_process_data->draw_context->current->over->y = -1;
1623   hashed_process_data->draw_context->current->middle->x = -1;
1624   hashed_process_data->draw_context->current->middle->y = -1;
1625   hashed_process_data->draw_context->current->under->x = -1;
1626   hashed_process_data->draw_context->current->under->y = -1;
1627   hashed_process_data->draw_context->current->modify_over->x = -1;
1628   hashed_process_data->draw_context->current->modify_over->y = -1;
1629   hashed_process_data->draw_context->current->modify_middle->x = -1;
1630   hashed_process_data->draw_context->current->modify_middle->y = -1;
1631   hashed_process_data->draw_context->current->modify_under->x = -1;
1632   hashed_process_data->draw_context->current->modify_under->y = -1;
1633   hashed_process_data->draw_context->current->status = LTTV_STATE_UNNAMED;
1634   hashed_process_data->draw_context->previous->over->x = -1;
1635   hashed_process_data->draw_context->previous->over->y = -1;
1636   hashed_process_data->draw_context->previous->middle->x = -1;
1637   hashed_process_data->draw_context->previous->middle->y = -1;
1638   hashed_process_data->draw_context->previous->under->x = -1;
1639   hashed_process_data->draw_context->previous->under->y = -1;
1640   hashed_process_data->draw_context->previous->modify_over->x = -1;
1641   hashed_process_data->draw_context->previous->modify_over->y = -1;
1642   hashed_process_data->draw_context->previous->modify_middle->x = -1;
1643   hashed_process_data->draw_context->previous->modify_middle->y = -1;
1644   hashed_process_data->draw_context->previous->modify_under->x = -1;
1645   hashed_process_data->draw_context->previous->modify_under->y = -1;
1646   hashed_process_data->draw_context->previous->status = LTTV_STATE_UNNAMED;
1647
1648
1649 }
1650
1651 /*
1652  * for each process
1653  *    draw closing line
1654  *    new default prev and current
1655  */
1656 int  after_data_request(void *hook_data, void *call_data)
1657 {
1658   EventRequest *event_request = (EventRequest*)hook_data;
1659   ControlFlowData *control_flow_data = event_request->control_flow_data;
1660
1661   ProcessList *process_list =
1662     guicontrolflow_get_process_list(event_request->control_flow_data);
1663
1664   ClosureData closure_data;
1665   closure_data.event_request = (EventRequest*)hook_data;
1666   closure_data.tss = (LttvTracesetState*)call_data;
1667
1668   g_hash_table_foreach(process_list->process_hash, draw_closure,
1669                         (void*)&closure_data);
1670
1671 }
1672