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 /* Event hooks are the drawing hooks called during traceset read. They draw the
  26  * icons, text, lines and background color corresponding to the events read.
  27  *
  28  * Two hooks are used for drawing : before_schedchange and after_schedchange hooks. The
  29  * before_schedchange is called before the state update that occurs with an event and
  30  * the after_schedchange hook is called after this state update.
  31  *
  32  * The before_schedchange hooks fulfill the task of drawing the visible objects that
  33  * corresponds to the data accumulated by the after_schedchange hook.
  34  *
  35  * The after_schedchange hook accumulates the data that need to be shown on the screen
  36  * (items) into a queue. Then, the next before_schedchange hook will draw what that
  37  * queue contains. That's the Right Way (TM) of drawing items on the screen,
  38  * because we need to draw the background first (and then add icons, text, ...
  39  * over it), but we only know the length of a background region once the state
  40  * corresponding to it is over, which happens to be at the next before_schedchange
  41  * hook.
  42  *
  43  * We also have a hook called at the end of a chunk to draw the information left
  44  * undrawn in each process queue. We use the current time as end of
  45  * line/background.
  46  */
  47
  48 #ifdef HAVE_CONFIG_H
  49 #include <config.h>
  50 #endif
  51
  52 //#define PANGO_ENABLE_BACKEND
  53 #include <gtk/gtk.h>
  54 #include <gdk/gdk.h>
  55 #include <glib.h>
  56 #include <assert.h>
  57 #include <string.h>
  58 #include <stdio.h>
  59
  60 //#include <pango/pango.h>
  61
  62 #include <ltt/event.h>
  63 #include <ltt/time.h>
  64 #include <ltt/trace.h>
  65
  66 #include <lttv/lttv.h>
  67 #include <lttv/hook.h>
  68 #include <lttv/state.h>
  69 #include <lttvwindow/lttvwindow.h>
  70 #include <lttvwindow/lttvwindowtraces.h>
  71 #include <lttvwindow/support.h>
  72
  73
  74 #include "eventhooks.h"
  75 #include "cfv.h"
  76 #include "processlist.h"
  77 #include "drawing.h"
  78
  79
  80 #define MAX_PATH_LEN 256
  81 #define STATE_LINE_WIDTH 4
  82 #define COLLISION_POSITION(height) (((height - STATE_LINE_WIDTH)/2) -3)
  83
  84 extern GSList *g_legend_list;
  85
  86
  87 /* Action to do when background computation completed.
  88  *
  89  * Wait for all the awaited computations to be over.
  90  */
  91
  92 static gint background_ready(void *hook_data, void *call_data)
  93 {
  94   ControlFlowData *control_flow_data = (ControlFlowData *)hook_data;
  95   LttvTrace *trace = (LttvTrace*)call_data;
  96
  97   control_flow_data->background_info_waiting--;
  98
  99   if(control_flow_data->background_info_waiting == 0) {
 100     g_message("control flow viewer : background computation data ready.");
 101
 102     drawing_clear(control_flow_data->drawing);
 103     processlist_clear(control_flow_data->process_list);
 104     gtk_widget_set_size_request(
 105       control_flow_data->drawing->drawing_area,
 106                 -1, processlist_get_height(control_flow_data->process_list));
 107     redraw_notify(control_flow_data, NULL);
 108   }
 109
 110   return 0;
 111 }
 112
 113
 114 /* Request background computation. Verify if it is in progress or ready first.
 115  * Only for each trace in the tab's traceset.
 116  */
 117 static void request_background_data(ControlFlowData *control_flow_data)
 118 {
 119   LttvTracesetContext * tsc =
 120         lttvwindow_get_traceset_context(control_flow_data->tab);
 121   gint num_traces = lttv_traceset_number(tsc->ts);
 122   gint i;
 123   LttvTrace *trace;
 124   LttvTraceState *tstate;
 125
 126   LttvHooks *background_ready_hook =
 127     lttv_hooks_new();
 128   lttv_hooks_add(background_ready_hook, background_ready, control_flow_data,
 129       LTTV_PRIO_DEFAULT);
 130   control_flow_data->background_info_waiting = 0;
 131
 132   for(i=0;i<num_traces;i++) {
 133     trace = lttv_traceset_get(tsc->ts, i);
 134     tstate = LTTV_TRACE_STATE(tsc->traces[i]);
 135
 136     if(lttvwindowtraces_get_ready(g_quark_from_string("state"),trace)==FALSE
 137         && !tstate->has_precomputed_states) {
 138
 139       if(lttvwindowtraces_get_in_progress(g_quark_from_string("state"),
 140                                           trace) == FALSE) {
 141         /* We first remove requests that could have been done for the same
 142          * information. Happens when two viewers ask for it before servicing
 143          * starts.
 144          */
 145         if(!lttvwindowtraces_background_request_find(trace, "state"))
 146           lttvwindowtraces_background_request_queue(
 147               main_window_get_widget(control_flow_data->tab), trace, "state");
 148         lttvwindowtraces_background_notify_queue(control_flow_data,
 149                                                  trace,
 150                                                  ltt_time_infinite,
 151                                                  NULL,
 152                                                  background_ready_hook);
 153         control_flow_data->background_info_waiting++;
 154       } else { /* in progress */
 155
 156         lttvwindowtraces_background_notify_current(control_flow_data,
 157                                                    trace,
 158                                                    ltt_time_infinite,
 159                                                    NULL,
 160                                                    background_ready_hook);
 161         control_flow_data->background_info_waiting++;
 162       }
 163     } else {
 164       /* Data ready. By its nature, this viewer doesn't need to have
 165        * its data ready hook called there, because a background
 166        * request is always linked with a redraw.
 167        */
 168     }
 169
 170   }
 171
 172   lttv_hooks_destroy(background_ready_hook);
 173 }
 174
 175
 176
 177
 178 /**
 179  * Event Viewer's constructor hook
 180  *
 181  * This constructor is given as a parameter to the menuitem and toolbar button
 182  * registration. It creates the list.
 183  * @param tab A pointer to the parent tab.
 184  * @return The widget created.
 185  */
 186 GtkWidget *
 187 h_guicontrolflow(LttvPlugin *plugin)
 188 {
 189   LttvPluginTab *ptab = LTTV_PLUGIN_TAB(plugin);
 190   Tab *tab = ptab->tab;
 191   g_info("h_guicontrolflow, %p", tab);
 192   ControlFlowData *control_flow_data = guicontrolflow(ptab);
 193
 194   control_flow_data->tab = tab;
 195
 196   // Unreg done in the GuiControlFlow_Destructor
 197   lttvwindow_register_traceset_notify(tab,
 198         traceset_notify,
 199         control_flow_data);
 200
 201   lttvwindow_register_time_window_notify(tab,
 202                                          update_time_window_hook,
 203                                          control_flow_data);
 204   lttvwindow_register_current_time_notify(tab,
 205                                           update_current_time_hook,
 206                                           control_flow_data);
 207   lttvwindow_register_redraw_notify(tab,
 208                                     redraw_notify,
 209                                     control_flow_data);
 210   lttvwindow_register_continue_notify(tab,
 211                                       continue_notify,
 212                                       control_flow_data);
 213   request_background_data(control_flow_data);
 214
 215
 216   return guicontrolflow_get_widget(control_flow_data) ;
 217
 218 }
 219
 220 int event_selected_hook(void *hook_data, void *call_data)
 221 {
 222   ControlFlowData *control_flow_data = (ControlFlowData*) hook_data;
 223   guint *event_number = (guint*) call_data;
 224
 225   g_debug("DEBUG : event selected by main window : %u", *event_number);
 226
 227   return 0;
 228 }
 229
 230 /* Function that selects the color of status&exemode line */
 231 static inline PropertiesLine prepare_s_e_line(LttvProcessState *process)
 232 {
 233   PropertiesLine prop_line;
 234   prop_line.line_width = STATE_LINE_WIDTH;
 235   prop_line.style = GDK_LINE_SOLID;
 236   prop_line.y = MIDDLE;
 237   //GdkColormap *colormap = gdk_colormap_get_system();
 238
 239   if(process->state->s == LTTV_STATE_RUN) {
 240     if(process->state->t == LTTV_STATE_USER_MODE)
 241       prop_line.color = drawing_colors[COL_RUN_USER_MODE];
 242     else if(process->state->t == LTTV_STATE_SYSCALL)
 243       prop_line.color = drawing_colors[COL_RUN_SYSCALL];
 244     else if(process->state->t == LTTV_STATE_TRAP)
 245       prop_line.color = drawing_colors[COL_RUN_TRAP];
 246     else if(process->state->t == LTTV_STATE_IRQ)
 247       prop_line.color = drawing_colors[COL_RUN_IRQ];
 248     else if(process->state->t == LTTV_STATE_SOFT_IRQ)
 249       prop_line.color = drawing_colors[COL_RUN_SOFT_IRQ];
 250     else if(process->state->t == LTTV_STATE_MODE_UNKNOWN)
 251       prop_line.color = drawing_colors[COL_MODE_UNKNOWN];
 252     else
 253       g_assert(FALSE);   /* RUNNING MODE UNKNOWN */
 254   } else if(process->state->s == LTTV_STATE_WAIT) {
 255     /* We don't show if we wait while in user mode, trap, irq or syscall */
 256     prop_line.color = drawing_colors[COL_WAIT];
 257   } else if(process->state->s == LTTV_STATE_WAIT_CPU) {
 258     /* We don't show if we wait for CPU while in user mode, trap, irq
 259      * or syscall */
 260     prop_line.color = drawing_colors[COL_WAIT_CPU];
 261   } else if(process->state->s == LTTV_STATE_ZOMBIE) {
 262     prop_line.color = drawing_colors[COL_ZOMBIE];
 263   } else if(process->state->s == LTTV_STATE_WAIT_FORK) {
 264     prop_line.color = drawing_colors[COL_WAIT_FORK];
 265   } else if(process->state->s == LTTV_STATE_EXIT) {
 266     prop_line.color = drawing_colors[COL_EXIT];
 267   } else if(process->state->s == LTTV_STATE_UNNAMED) {
 268     prop_line.color = drawing_colors[COL_UNNAMED];
 269   } else {
 270                 g_critical("unknown state : %s", g_quark_to_string(process->state->s));
 271     g_assert(FALSE);   /* UNKNOWN STATE */
 272         }
 273
 274   return prop_line;
 275
 276 }
 277
 278
 279 /* before_schedchange_hook
 280  *
 281  * This function basically draw lines and icons. Two types of lines are drawn :
 282  * one small (3 pixels?) representing the state of the process and the second
 283  * type is thicker (10 pixels?) representing on which CPU a process is running
 284  * (and this only in running state).
 285  *
 286  * Extremums of the lines :
 287  * x_min : time of the last event context for this process kept in memory.
 288  * x_max : time of the current event.
 289  * y : middle of the process in the process list. The process is found in the
 290  * list, therefore is it's position in pixels.
 291  *
 292  * The choice of lines'color is defined by the context of the last event for this
 293  * process.
 294  */
 295
 296
 297 int before_schedchange_hook(void *hook_data, void *call_data)
 298 {
 299   LttvTraceHook *th = (LttvTraceHook*)hook_data;
 300   EventsRequest *events_request = (EventsRequest*)th->hook_data;
 301   ControlFlowData *control_flow_data = events_request->viewer_data;
 302
 303   LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
 304
 305   LttvTracefileState *tfs = (LttvTracefileState *)call_data;
 306   LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
 307
 308   LttEvent *e;
 309   e = ltt_tracefile_get_event(tfc->tf);
 310   gint target_pid_saved = tfc->target_pid;
 311
 312   LttTime evtime = ltt_event_time(e);
 313   LttvFilter *filter = control_flow_data->filter;
 314
 315   /* we are in a schedchange, before the state update. We must draw the
 316    * items corresponding to the state before it changes : now is the right
 317    * time to do it.
 318    */
 319
 320   guint pid_out;
 321   guint pid_in;
 322   {
 323     pid_out = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 0));
 324     pid_in = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 1));
 325   }
 326
 327   tfc->target_pid = pid_out;
 328   if(!filter || !filter->head ||
 329     lttv_filter_tree_parse(filter->head,e,tfc->tf,
 330           tfc->t_context->t,tfc,NULL,NULL)) {
 331     /* For the pid_out */
 332     /* First, check if the current process is in the state computation
 333      * process list. If it is there, that means we must add it right now and
 334      * draw items from the beginning of the read for it. If it is not
 335      * present, it's a new process and it was not present : it will
 336      * be added after the state update.  */
 337     guint cpu = tfs->cpu;
 338     guint trace_num = ts->parent.index;
 339     LttvProcessState *process = ts->running_process[cpu];
 340     /* unknown state, bad current pid */
 341     if(process->pid != pid_out)
 342       process = lttv_state_find_process(ts,
 343           tfs->cpu, pid_out);
 344
 345     if(process != NULL) {
 346       /* Well, the process_out existed : we must get it in the process hash
 347        * or add it, and draw its items.
 348        */
 349        /* Add process to process list (if not present) */
 350       guint pl_height = 0;
 351       HashedProcessData *hashed_process_data = NULL;
 352       ProcessList *process_list = control_flow_data->process_list;
 353       LttTime birth = process->creation_time;
 354
 355       hashed_process_data = processlist_get_process_data(process_list,
 356               pid_out,
 357               process->cpu,
 358               &birth,
 359               trace_num);
 360       if(hashed_process_data == NULL)
 361       {
 362         g_assert(pid_out == 0 || pid_out != process->ppid);
 363         /* Process not present */
 364         ProcessInfo *process_info;
 365         Drawing_t *drawing = control_flow_data->drawing;
 366         processlist_add(process_list,
 367             drawing,
 368             pid_out,
 369             process->tgid,
 370             process->cpu,
 371             process->ppid,
 372             &birth,
 373             trace_num,
 374             process->name,
 375             process->brand,
 376             &pl_height,
 377             &process_info,
 378             &hashed_process_data);
 379         gtk_widget_set_size_request(drawing->drawing_area,
 380                                     -1,
 381                                     pl_height);
 382         gtk_widget_queue_draw(drawing->drawing_area);
 383
 384       }
 385
 386       /* Now, the process is in the state hash and our own process hash.
 387        * We definitely can draw the items related to the ending state.
 388        */
 389
 390       if(ltt_time_compare(hashed_process_data->next_good_time,
 391                           evtime) > 0)
 392       {
 393         if(hashed_process_data->x.middle_marked == FALSE) {
 394
 395           TimeWindow time_window =
 396             lttvwindow_get_time_window(control_flow_data->tab);
 397 #ifdef EXTRA_CHECK
 398           if(ltt_time_compare(evtime, time_window.start_time) == -1
 399                 || ltt_time_compare(evtime, time_window.end_time) == 1)
 400                     return;
 401 #endif //EXTRA_CHECK
 402           Drawing_t *drawing = control_flow_data->drawing;
 403           guint width = drawing->width;
 404           guint x;
 405           convert_time_to_pixels(
 406                     time_window,
 407                     evtime,
 408                     width,
 409                     &x);
 410
 411           /* Draw collision indicator */
 412           gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
 413           gdk_draw_point(hashed_process_data->pixmap,
 414                          drawing->gc,
 415                          x,
 416                          COLLISION_POSITION(hashed_process_data->height));
 417           hashed_process_data->x.middle_marked = TRUE;
 418         }
 419       } else {
 420         TimeWindow time_window =
 421           lttvwindow_get_time_window(control_flow_data->tab);
 422 #ifdef EXTRA_CHECK
 423         if(ltt_time_compare(evtime, time_window.start_time) == -1
 424               || ltt_time_compare(evtime, time_window.end_time) == 1)
 425                   return;
 426 #endif //EXTRA_CHECK
 427         Drawing_t *drawing = control_flow_data->drawing;
 428         guint width = drawing->width;
 429         guint x;
 430         convert_time_to_pixels(
 431                   time_window,
 432                   evtime,
 433                   width,
 434                   &x);
 435
 436
 437         /* Jump over draw if we are at the same x position */
 438         if(x == hashed_process_data->x.middle &&
 439              hashed_process_data->x.middle_used)
 440         {
 441           if(hashed_process_data->x.middle_marked == FALSE) {
 442             /* Draw collision indicator */
 443             gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
 444             gdk_draw_point(hashed_process_data->pixmap,
 445                            drawing->gc,
 446                            x,
 447                            COLLISION_POSITION(hashed_process_data->height));
 448             hashed_process_data->x.middle_marked = TRUE;
 449           }
 450           /* jump */
 451         } else {
 452           DrawContext draw_context;
 453
 454           /* Now create the drawing context that will be used to draw
 455            * items related to the last state. */
 456           draw_context.drawable = hashed_process_data->pixmap;
 457           draw_context.gc = drawing->gc;
 458           draw_context.pango_layout = drawing->pango_layout;
 459           draw_context.drawinfo.start.x = hashed_process_data->x.middle;
 460           draw_context.drawinfo.end.x = x;
 461
 462           draw_context.drawinfo.y.over = 1;
 463           draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
 464           draw_context.drawinfo.y.under = hashed_process_data->height;
 465
 466           draw_context.drawinfo.start.offset.over = 0;
 467           draw_context.drawinfo.start.offset.middle = 0;
 468           draw_context.drawinfo.start.offset.under = 0;
 469           draw_context.drawinfo.end.offset.over = 0;
 470           draw_context.drawinfo.end.offset.middle = 0;
 471           draw_context.drawinfo.end.offset.under = 0;
 472
 473           {
 474             /* Draw the line */
 475             PropertiesLine prop_line = prepare_s_e_line(process);
 476             draw_line((void*)&prop_line, (void*)&draw_context);
 477
 478           }
 479           /* become the last x position */
 480           hashed_process_data->x.middle = x;
 481           hashed_process_data->x.middle_used = TRUE;
 482           hashed_process_data->x.middle_marked = FALSE;
 483
 484           /* Calculate the next good time */
 485           convert_pixels_to_time(width, x+1, time_window,
 486                                  &hashed_process_data->next_good_time);
 487         }
 488       }
 489     }
 490   }
 491
 492   tfc->target_pid = pid_in;
 493   if(!filter || !filter->head ||
 494     lttv_filter_tree_parse(filter->head,e,tfc->tf,
 495           tfc->t_context->t,tfc,NULL,NULL)) {
 496     /* For the pid_in */
 497     /* First, check if the current process is in the state computation
 498      * process list. If it is there, that means we must add it right now and
 499      * draw items from the beginning of the read for it. If it is not
 500      * present, it's a new process and it was not present : it will
 501      * be added after the state update.  */
 502     LttvProcessState *process;
 503     process = lttv_state_find_process(ts,
 504         tfs->cpu, pid_in);
 505     guint trace_num = ts->parent.index;
 506
 507     if(process != NULL) {
 508       /* Well, the process existed : we must get it in the process hash
 509        * or add it, and draw its items.
 510        */
 511        /* Add process to process list (if not present) */
 512       guint pl_height = 0;
 513       HashedProcessData *hashed_process_data = NULL;
 514       ProcessList *process_list = control_flow_data->process_list;
 515       LttTime birth = process->creation_time;
 516
 517       hashed_process_data = processlist_get_process_data(process_list,
 518               pid_in,
 519               tfs->cpu,
 520               &birth,
 521               trace_num);
 522       if(hashed_process_data == NULL)
 523       {
 524         g_assert(pid_in == 0 || pid_in != process->ppid);
 525         /* Process not present */
 526         ProcessInfo *process_info;
 527         Drawing_t *drawing = control_flow_data->drawing;
 528         processlist_add(process_list,
 529             drawing,
 530             pid_in,
 531             process->tgid,
 532             tfs->cpu,
 533             process->ppid,
 534             &birth,
 535             trace_num,
 536             process->name,
 537             process->brand,
 538             &pl_height,
 539             &process_info,
 540             &hashed_process_data);
 541         gtk_widget_set_size_request(drawing->drawing_area,
 542                                     -1,
 543                                     pl_height);
 544         gtk_widget_queue_draw(drawing->drawing_area);
 545
 546       }
 547       //We could set the current process and hash here, but will be done
 548       //by after schedchange hook
 549
 550       /* Now, the process is in the state hash and our own process hash.
 551        * We definitely can draw the items related to the ending state.
 552        */
 553
 554       if(ltt_time_compare(hashed_process_data->next_good_time,
 555                           evtime) > 0)
 556       {
 557         if(hashed_process_data->x.middle_marked == FALSE) {
 558
 559           TimeWindow time_window =
 560             lttvwindow_get_time_window(control_flow_data->tab);
 561 #ifdef EXTRA_CHECK
 562           if(ltt_time_compare(evtime, time_window.start_time) == -1
 563                 || ltt_time_compare(evtime, time_window.end_time) == 1)
 564                     return;
 565 #endif //EXTRA_CHECK
 566           Drawing_t *drawing = control_flow_data->drawing;
 567           guint width = drawing->width;
 568           guint x;
 569           convert_time_to_pixels(
 570                     time_window,
 571                     evtime,
 572                     width,
 573                     &x);
 574
 575           /* Draw collision indicator */
 576           gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
 577           gdk_draw_point(hashed_process_data->pixmap,
 578                          drawing->gc,
 579                          x,
 580                          COLLISION_POSITION(hashed_process_data->height));
 581           hashed_process_data->x.middle_marked = TRUE;
 582         }
 583       } else {
 584         TimeWindow time_window =
 585           lttvwindow_get_time_window(control_flow_data->tab);
 586 #ifdef EXTRA_CHECK
 587         if(ltt_time_compare(evtime, time_window.start_time) == -1
 588               || ltt_time_compare(evtime, time_window.end_time) == 1)
 589                   return;
 590 #endif //EXTRA_CHECK
 591         Drawing_t *drawing = control_flow_data->drawing;
 592         guint width = drawing->width;
 593         guint x;
 594
 595         convert_time_to_pixels(
 596                   time_window,
 597                   evtime,
 598                   width,
 599                   &x);
 600
 601
 602         /* Jump over draw if we are at the same x position */
 603         if(x == hashed_process_data->x.middle &&
 604             hashed_process_data->x.middle_used)
 605         {
 606           if(hashed_process_data->x.middle_marked == FALSE) {
 607             /* Draw collision indicator */
 608             gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
 609             gdk_draw_point(hashed_process_data->pixmap,
 610                            drawing->gc,
 611                            x,
 612                            COLLISION_POSITION(hashed_process_data->height));
 613             hashed_process_data->x.middle_marked = TRUE;
 614           }
 615           /* jump */
 616         } else {
 617           DrawContext draw_context;
 618
 619           /* Now create the drawing context that will be used to draw
 620            * items related to the last state. */
 621           draw_context.drawable = hashed_process_data->pixmap;
 622           draw_context.gc = drawing->gc;
 623           draw_context.pango_layout = drawing->pango_layout;
 624           draw_context.drawinfo.start.x = hashed_process_data->x.middle;
 625           draw_context.drawinfo.end.x = x;
 626
 627           draw_context.drawinfo.y.over = 1;
 628           draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
 629           draw_context.drawinfo.y.under = hashed_process_data->height;
 630
 631           draw_context.drawinfo.start.offset.over = 0;
 632           draw_context.drawinfo.start.offset.middle = 0;
 633           draw_context.drawinfo.start.offset.under = 0;
 634           draw_context.drawinfo.end.offset.over = 0;
 635           draw_context.drawinfo.end.offset.middle = 0;
 636           draw_context.drawinfo.end.offset.under = 0;
 637
 638           {
 639             /* Draw the line */
 640             PropertiesLine prop_line = prepare_s_e_line(process);
 641             draw_line((void*)&prop_line, (void*)&draw_context);
 642           }
 643
 644
 645           /* become the last x position */
 646           hashed_process_data->x.middle = x;
 647           hashed_process_data->x.middle_used = TRUE;
 648           hashed_process_data->x.middle_marked = FALSE;
 649
 650           /* Calculate the next good time */
 651           convert_pixels_to_time(width, x+1, time_window,
 652                                  &hashed_process_data->next_good_time);
 653         }
 654       }
 655     } else
 656       g_warning("Cannot find pin_in in schedchange %u", pid_in);
 657   }
 658   tfc->target_pid = target_pid_saved;
 659   return 0;
 660
 661
 662
 663
 664   /* Text dump */
 665 #ifdef DONTSHOW
 666   GString *string = g_string_new("");;
 667   gboolean field_names = TRUE, state = TRUE;
 668
 669   lttv_event_to_string(e, tfc->tf, string, TRUE, field_names, tfs);
 670   g_string_append_printf(string,"\n");
 671
 672   if(state) {
 673     g_string_append_printf(string, " %s",
 674         g_quark_to_string(tfs->process->state->s));
 675   }
 676
 677   g_info("%s",string->str);
 678
 679   g_string_free(string, TRUE);
 680
 681   /* End of text dump */
 682 #endif //DONTSHOW
 683
 684 }
 685
 686 /* after_schedchange_hook
 687  *
 688  * The draw after hook is called by the reading API to have a
 689  * particular event drawn on the screen.
 690  * @param hook_data ControlFlowData structure of the viewer.
 691  * @param call_data Event context.
 692  *
 693  * This function adds items to be drawn in a queue for each process.
 694  *
 695  */
 696 int after_schedchange_hook(void *hook_data, void *call_data)
 697 {
 698   LttvTraceHook *th = (LttvTraceHook*)hook_data;
 699   EventsRequest *events_request = (EventsRequest*)th->hook_data;
 700   ControlFlowData *control_flow_data = events_request->viewer_data;
 701
 702   LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
 703
 704   LttvTracefileState *tfs = (LttvTracefileState *)call_data;
 705
 706   LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
 707
 708   LttEvent *e;
 709   e = ltt_tracefile_get_event(tfc->tf);
 710
 711   LttvFilter *filter = control_flow_data->filter;
 712   if(filter != NULL && filter->head != NULL)
 713     if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
 714           tfc->t_context->t,tfc,NULL,NULL))
 715       return FALSE;
 716
 717   LttTime evtime = ltt_event_time(e);
 718
 719   /* Add process to process list (if not present) */
 720   LttvProcessState *process_in;
 721   LttTime birth;
 722   guint pl_height = 0;
 723   HashedProcessData *hashed_process_data_in = NULL;
 724
 725   ProcessList *process_list = control_flow_data->process_list;
 726
 727   guint pid_in;
 728   {
 729     guint pid_out;
 730     pid_out = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 0));
 731     pid_in = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 1));
 732   }
 733
 734
 735   /* Find process pid_in in the list... */
 736   //process_in = lttv_state_find_process(ts, ANY_CPU, pid_in);
 737   //process_in = tfs->process;
 738   guint cpu = tfs->cpu;
 739   guint trace_num = ts->parent.index;
 740   process_in = ts->running_process[cpu];
 741   /* It should exist, because we are after the state update. */
 742 #ifdef EXTRA_CHECK
 743   g_assert(process_in != NULL);
 744 #endif //EXTRA_CHECK
 745   birth = process_in->creation_time;
 746
 747   hashed_process_data_in = processlist_get_process_data(process_list,
 748           pid_in,
 749           process_in->cpu,
 750           &birth,
 751           trace_num);
 752   if(hashed_process_data_in == NULL)
 753   {
 754     g_assert(pid_in == 0 || pid_in != process_in->ppid);
 755     ProcessInfo *process_info;
 756     Drawing_t *drawing = control_flow_data->drawing;
 757     /* Process not present */
 758     processlist_add(process_list,
 759         drawing,
 760         pid_in,
 761         process_in->tgid,
 762         process_in->cpu,
 763         process_in->ppid,
 764         &birth,
 765         trace_num,
 766         process_in->name,
 767         process_in->brand,
 768         &pl_height,
 769         &process_info,
 770         &hashed_process_data_in);
 771         gtk_widget_set_size_request(drawing->drawing_area,
 772                                     -1,
 773                                     pl_height);
 774         gtk_widget_queue_draw(drawing->drawing_area);
 775   }
 776   /* Set the current process */
 777   process_list->current_hash_data[trace_num][process_in->cpu] =
 778                                              hashed_process_data_in;
 779
 780   if(ltt_time_compare(hashed_process_data_in->next_good_time,
 781                           evtime) <= 0)
 782   {
 783     TimeWindow time_window =
 784     lttvwindow_get_time_window(control_flow_data->tab);
 785
 786 #ifdef EXTRA_CHECK
 787     if(ltt_time_compare(evtime, time_window.start_time) == -1
 788         || ltt_time_compare(evtime, time_window.end_time) == 1)
 789             return;
 790 #endif //EXTRA_CHECK
 791     Drawing_t *drawing = control_flow_data->drawing;
 792     guint width = drawing->width;
 793     guint new_x;
 794
 795     convert_time_to_pixels(
 796         time_window,
 797         evtime,
 798         width,
 799         &new_x);
 800
 801     if(hashed_process_data_in->x.middle != new_x) {
 802       hashed_process_data_in->x.middle = new_x;
 803       hashed_process_data_in->x.middle_used = FALSE;
 804       hashed_process_data_in->x.middle_marked = FALSE;
 805     }
 806   }
 807   return 0;
 808 }
 809
 810
 811
 812
 813 /* before_execmode_hook
 814  *
 815  * This function basically draw lines and icons. Two types of lines are drawn :
 816  * one small (3 pixels?) representing the state of the process and the second
 817  * type is thicker (10 pixels?) representing on which CPU a process is running
 818  * (and this only in running state).
 819  *
 820  * Extremums of the lines :
 821  * x_min : time of the last event context for this process kept in memory.
 822  * x_max : time of the current event.
 823  * y : middle of the process in the process list. The process is found in the
 824  * list, therefore is it's position in pixels.
 825  *
 826  * The choice of lines'color is defined by the context of the last event for this
 827  * process.
 828  */
 829
 830
 831 int before_execmode_hook(void *hook_data, void *call_data)
 832 {
 833   LttvTraceHook *th = (LttvTraceHook*)hook_data;
 834   EventsRequest *events_request = (EventsRequest*)th->hook_data;
 835   ControlFlowData *control_flow_data = events_request->viewer_data;
 836
 837   LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
 838
 839   LttvTracefileState *tfs = (LttvTracefileState *)call_data;
 840
 841   LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
 842
 843   LttEvent *e;
 844   e = ltt_tracefile_get_event(tfc->tf);
 845
 846   LttvFilter *filter = control_flow_data->filter;
 847   if(filter != NULL && filter->head != NULL)
 848     if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
 849           tfc->t_context->t,tfc,NULL,NULL))
 850       return FALSE;
 851
 852   LttTime evtime = ltt_event_time(e);
 853
 854   /* we are in a execmode, before the state update. We must draw the
 855    * items corresponding to the state before it changes : now is the right
 856    * time to do it.
 857    */
 858   /* For the pid */
 859   //LttvProcessState *process = tfs->process;
 860   guint cpu = tfs->cpu;
 861   guint trace_num = ts->parent.index;
 862   LttvProcessState *process = ts->running_process[cpu];
 863   g_assert(process != NULL);
 864
 865   guint pid = process->pid;
 866
 867   /* Well, the process_out existed : we must get it in the process hash
 868    * or add it, and draw its items.
 869    */
 870    /* Add process to process list (if not present) */
 871   guint pl_height = 0;
 872   HashedProcessData *hashed_process_data = NULL;
 873   ProcessList *process_list = control_flow_data->process_list;
 874   LttTime birth = process->creation_time;
 875
 876   if(likely(process_list->current_hash_data[trace_num][cpu] != NULL)) {
 877     hashed_process_data = process_list->current_hash_data[trace_num][cpu];
 878   } else {
 879     hashed_process_data = processlist_get_process_data(process_list,
 880             pid,
 881             process->cpu,
 882             &birth,
 883             trace_num);
 884     if(unlikely(hashed_process_data == NULL))
 885     {
 886       g_assert(pid == 0 || pid != process->ppid);
 887       ProcessInfo *process_info;
 888       /* Process not present */
 889       Drawing_t *drawing = control_flow_data->drawing;
 890       processlist_add(process_list,
 891           drawing,
 892           pid,
 893           process->tgid,
 894           process->cpu,
 895           process->ppid,
 896           &birth,
 897           trace_num,
 898           process->name,
 899           process->brand,
 900           &pl_height,
 901           &process_info,
 902           &hashed_process_data);
 903         gtk_widget_set_size_request(drawing->drawing_area,
 904                                     -1,
 905                                     pl_height);
 906         gtk_widget_queue_draw(drawing->drawing_area);
 907     }
 908     /* Set the current process */
 909     process_list->current_hash_data[trace_num][process->cpu] =
 910                                                hashed_process_data;
 911   }
 912
 913   /* Now, the process is in the state hash and our own process hash.
 914    * We definitely can draw the items related to the ending state.
 915    */
 916
 917   if(likely(ltt_time_compare(hashed_process_data->next_good_time,
 918                       evtime) > 0))
 919   {
 920     if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
 921       TimeWindow time_window =
 922         lttvwindow_get_time_window(control_flow_data->tab);
 923
 924 #ifdef EXTRA_CHECK
 925       if(ltt_time_compare(evtime, time_window.start_time) == -1
 926             || ltt_time_compare(evtime, time_window.end_time) == 1)
 927                 return;
 928 #endif //EXTRA_CHECK
 929       Drawing_t *drawing = control_flow_data->drawing;
 930       guint width = drawing->width;
 931       guint x;
 932       convert_time_to_pixels(
 933                 time_window,
 934                 evtime,
 935                 width,
 936                 &x);
 937
 938       /* Draw collision indicator */
 939       gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
 940       gdk_draw_point(hashed_process_data->pixmap,
 941                      drawing->gc,
 942                      x,
 943                      COLLISION_POSITION(hashed_process_data->height));
 944       hashed_process_data->x.middle_marked = TRUE;
 945     }
 946   } else {
 947     TimeWindow time_window =
 948       lttvwindow_get_time_window(control_flow_data->tab);
 949
 950 #ifdef EXTRA_CHECK
 951     if(ltt_time_compare(evtime, time_window.start_time) == -1
 952           || ltt_time_compare(evtime, time_window.end_time) == 1)
 953               return;
 954 #endif //EXTRA_CHECK
 955     Drawing_t *drawing = control_flow_data->drawing;
 956     guint width = drawing->width;
 957     guint x;
 958
 959     convert_time_to_pixels(
 960         time_window,
 961         evtime,
 962         width,
 963         &x);
 964
 965
 966     /* Jump over draw if we are at the same x position */
 967     if(unlikely(x == hashed_process_data->x.middle &&
 968              hashed_process_data->x.middle_used))
 969     {
 970       if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
 971         /* Draw collision indicator */
 972         gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
 973         gdk_draw_point(hashed_process_data->pixmap,
 974                        drawing->gc,
 975                        x,
 976                        COLLISION_POSITION(hashed_process_data->height));
 977         hashed_process_data->x.middle_marked = TRUE;
 978       }
 979       /* jump */
 980     } else {
 981
 982       DrawContext draw_context;
 983       /* Now create the drawing context that will be used to draw
 984        * items related to the last state. */
 985       draw_context.drawable = hashed_process_data->pixmap;
 986       draw_context.gc = drawing->gc;
 987       draw_context.pango_layout = drawing->pango_layout;
 988       draw_context.drawinfo.start.x = hashed_process_data->x.middle;
 989       draw_context.drawinfo.end.x = x;
 990
 991       draw_context.drawinfo.y.over = 1;
 992       draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
 993       draw_context.drawinfo.y.under = hashed_process_data->height;
 994
 995       draw_context.drawinfo.start.offset.over = 0;
 996       draw_context.drawinfo.start.offset.middle = 0;
 997       draw_context.drawinfo.start.offset.under = 0;
 998       draw_context.drawinfo.end.offset.over = 0;
 999       draw_context.drawinfo.end.offset.middle = 0;
1000       draw_context.drawinfo.end.offset.under = 0;
1001
1002       {
1003         /* Draw the line */
1004         PropertiesLine prop_line = prepare_s_e_line(process);
1005         draw_line((void*)&prop_line, (void*)&draw_context);
1006
1007       }
1008       /* become the last x position */
1009       hashed_process_data->x.middle = x;
1010       hashed_process_data->x.middle_used = TRUE;
1011       hashed_process_data->x.middle_marked = FALSE;
1012
1013       /* Calculate the next good time */
1014       convert_pixels_to_time(width, x+1, time_window,
1015                              &hashed_process_data->next_good_time);
1016     }
1017   }
1018
1019   return 0;
1020 }
1021
1022 /* before_process_exit_hook
1023  *
1024  * Draw lines for process event.
1025  *
1026  * @param hook_data ControlFlowData structure of the viewer.
1027  * @param call_data Event context.
1028  *
1029  * This function adds items to be drawn in a queue for each process.
1030  *
1031  */
1032
1033
1034 int before_process_exit_hook(void *hook_data, void *call_data)
1035 {
1036   LttvTraceHook *th = (LttvTraceHook*)hook_data;
1037   EventsRequest *events_request = (EventsRequest*)th->hook_data;
1038
1039   ControlFlowData *control_flow_data = events_request->viewer_data;
1040
1041   LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
1042
1043   LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1044
1045   LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
1046
1047   LttEvent *e;
1048   e = ltt_tracefile_get_event(tfc->tf);
1049
1050   LttvFilter *filter = control_flow_data->filter;
1051   if(filter != NULL && filter->head != NULL)
1052     if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1053           tfc->t_context->t,tfc,NULL,NULL))
1054       return FALSE;
1055
1056   LttTime evtime = ltt_event_time(e);
1057
1058   /* Add process to process list (if not present) */
1059   //LttvProcessState *process = tfs->process;
1060   guint cpu = tfs->cpu;
1061   guint trace_num = ts->parent.index;
1062   LttvProcessState *process = ts->running_process[cpu];
1063   guint pid = process->pid;
1064   LttTime birth;
1065   guint pl_height = 0;
1066   HashedProcessData *hashed_process_data = NULL;
1067
1068   ProcessList *process_list = control_flow_data->process_list;
1069
1070   g_assert(process != NULL);
1071
1072   birth = process->creation_time;
1073
1074   if(likely(process_list->current_hash_data[trace_num][cpu] != NULL)) {
1075     hashed_process_data = process_list->current_hash_data[trace_num][cpu];
1076   } else {
1077     hashed_process_data = processlist_get_process_data(process_list,
1078           pid,
1079           process->cpu,
1080           &birth,
1081           trace_num);
1082     if(unlikely(hashed_process_data == NULL))
1083     {
1084       g_assert(pid == 0 || pid != process->ppid);
1085       /* Process not present */
1086       Drawing_t *drawing = control_flow_data->drawing;
1087       ProcessInfo *process_info;
1088       processlist_add(process_list,
1089           drawing,
1090           pid,
1091           process->tgid,
1092           process->cpu,
1093           process->ppid,
1094           &birth,
1095           trace_num,
1096           process->name,
1097           process->brand,
1098           &pl_height,
1099           &process_info,
1100           &hashed_process_data);
1101       gtk_widget_set_size_request(drawing->drawing_area,
1102                                   -1,
1103                                   pl_height);
1104       gtk_widget_queue_draw(drawing->drawing_area);
1105     }
1106   }
1107
1108   /* Now, the process is in the state hash and our own process hash.
1109    * We definitely can draw the items related to the ending state.
1110    */
1111
1112   if(likely(ltt_time_compare(hashed_process_data->next_good_time,
1113                       evtime) > 0))
1114   {
1115     if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
1116       TimeWindow time_window =
1117         lttvwindow_get_time_window(control_flow_data->tab);
1118
1119 #ifdef EXTRA_CHECK
1120       if(ltt_time_compare(evtime, time_window.start_time) == -1
1121             || ltt_time_compare(evtime, time_window.end_time) == 1)
1122                 return;
1123 #endif //EXTRA_CHECK
1124       Drawing_t *drawing = control_flow_data->drawing;
1125       guint width = drawing->width;
1126       guint x;
1127       convert_time_to_pixels(
1128                 time_window,
1129                 evtime,
1130                 width,
1131                 &x);
1132
1133       /* Draw collision indicator */
1134       gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
1135       gdk_draw_point(hashed_process_data->pixmap,
1136                      drawing->gc,
1137                      x,
1138                      COLLISION_POSITION(hashed_process_data->height));
1139       hashed_process_data->x.middle_marked = TRUE;
1140     }
1141   } else {
1142     TimeWindow time_window =
1143       lttvwindow_get_time_window(control_flow_data->tab);
1144
1145 #ifdef EXTRA_CHECK
1146     if(ltt_time_compare(evtime, time_window.start_time) == -1
1147           || ltt_time_compare(evtime, time_window.end_time) == 1)
1148               return;
1149 #endif //EXTRA_CHECK
1150     Drawing_t *drawing = control_flow_data->drawing;
1151     guint width = drawing->width;
1152     guint x;
1153
1154     convert_time_to_pixels(
1155         time_window,
1156         evtime,
1157         width,
1158         &x);
1159
1160
1161     /* Jump over draw if we are at the same x position */
1162     if(unlikely(x == hashed_process_data->x.middle &&
1163            hashed_process_data->x.middle_used))
1164     {
1165       if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
1166         /* Draw collision indicator */
1167         gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
1168         gdk_draw_point(hashed_process_data->pixmap,
1169                        drawing->gc,
1170                        x,
1171                        COLLISION_POSITION(hashed_process_data->height));
1172         hashed_process_data->x.middle_marked = TRUE;
1173       }
1174       /* jump */
1175     } else {
1176       DrawContext draw_context;
1177
1178       /* Now create the drawing context that will be used to draw
1179        * items related to the last state. */
1180       draw_context.drawable = hashed_process_data->pixmap;
1181       draw_context.gc = drawing->gc;
1182       draw_context.pango_layout = drawing->pango_layout;
1183       draw_context.drawinfo.start.x = hashed_process_data->x.middle;
1184       draw_context.drawinfo.end.x = x;
1185
1186       draw_context.drawinfo.y.over = 1;
1187       draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
1188       draw_context.drawinfo.y.under = hashed_process_data->height;
1189
1190       draw_context.drawinfo.start.offset.over = 0;
1191       draw_context.drawinfo.start.offset.middle = 0;
1192       draw_context.drawinfo.start.offset.under = 0;
1193       draw_context.drawinfo.end.offset.over = 0;
1194       draw_context.drawinfo.end.offset.middle = 0;
1195       draw_context.drawinfo.end.offset.under = 0;
1196
1197       {
1198         /* Draw the line */
1199         PropertiesLine prop_line = prepare_s_e_line(process);
1200         draw_line((void*)&prop_line, (void*)&draw_context);
1201
1202       }
1203       /* become the last x position */
1204       hashed_process_data->x.middle = x;
1205       hashed_process_data->x.middle_used = TRUE;
1206       hashed_process_data->x.middle_marked = FALSE;
1207
1208       /* Calculate the next good time */
1209       convert_pixels_to_time(width, x+1, time_window,
1210                              &hashed_process_data->next_good_time);
1211     }
1212   }
1213
1214   return 0;
1215
1216 }
1217
1218
1219
1220 /* before_process_release_hook
1221  *
1222  * Draw lines for process event.
1223  *
1224  * @param hook_data ControlFlowData structure of the viewer.
1225  * @param call_data Event context.
1226  *
1227  * This function adds items to be drawn in a queue for each process.
1228  *
1229  */
1230
1231
1232 int before_process_release_hook(void *hook_data, void *call_data)
1233 {
1234   LttvTraceHook *th = (LttvTraceHook*)hook_data;
1235   EventsRequest *events_request = (EventsRequest*)th->hook_data;
1236
1237   ControlFlowData *control_flow_data = events_request->viewer_data;
1238
1239   LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
1240
1241   LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1242
1243   LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
1244
1245   LttEvent *e;
1246   e = ltt_tracefile_get_event(tfc->tf);
1247
1248   LttvFilter *filter = control_flow_data->filter;
1249   if(filter != NULL && filter->head != NULL)
1250     if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1251           tfc->t_context->t,tfc,NULL,NULL))
1252       return FALSE;
1253
1254   LttTime evtime = ltt_event_time(e);
1255
1256   guint trace_num = ts->parent.index;
1257
1258   guint pid;
1259   {
1260     pid = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 0));
1261   }
1262
1263   /* Add process to process list (if not present) */
1264   /* Don't care about the process if it's not in the state hash already :
1265    * that means a process that has never done anything in the trace and
1266    * unknown suddently gets destroyed : no state meaningful to show. */
1267   LttvProcessState *process = lttv_state_find_process(ts, ANY_CPU, pid);
1268
1269   if(process != NULL) {
1270     LttTime birth;
1271     guint pl_height = 0;
1272     HashedProcessData *hashed_process_data = NULL;
1273
1274     ProcessList *process_list = control_flow_data->process_list;
1275
1276     birth = process->creation_time;
1277
1278     /* Cannot use current process : this event happens on another process,
1279      * action done by the parent. */
1280     hashed_process_data = processlist_get_process_data(process_list,
1281           pid,
1282           process->cpu,
1283           &birth,
1284           trace_num);
1285     if(unlikely(hashed_process_data == NULL))
1286     {
1287       g_assert(pid == 0 || pid != process->ppid);
1288       /* Process not present */
1289       Drawing_t *drawing = control_flow_data->drawing;
1290       ProcessInfo *process_info;
1291       processlist_add(process_list,
1292           drawing,
1293           pid,
1294           process->tgid,
1295           process->cpu,
1296           process->ppid,
1297           &birth,
1298           trace_num,
1299           process->name,
1300           process->brand,
1301           &pl_height,
1302           &process_info,
1303           &hashed_process_data);
1304       gtk_widget_set_size_request(drawing->drawing_area,
1305                                   -1,
1306                                   pl_height);
1307       gtk_widget_queue_draw(drawing->drawing_area);
1308     }
1309
1310     /* Now, the process is in the state hash and our own process hash.
1311      * We definitely can draw the items related to the ending state.
1312      */
1313
1314     if(likely(ltt_time_compare(hashed_process_data->next_good_time,
1315                         evtime) > 0))
1316     {
1317       if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
1318         TimeWindow time_window =
1319           lttvwindow_get_time_window(control_flow_data->tab);
1320
1321 #ifdef EXTRA_CHECK
1322         if(ltt_time_compare(evtime, time_window.start_time) == -1
1323               || ltt_time_compare(evtime, time_window.end_time) == 1)
1324                   return;
1325 #endif //EXTRA_CHECK
1326         Drawing_t *drawing = control_flow_data->drawing;
1327         guint width = drawing->width;
1328         guint x;
1329         convert_time_to_pixels(
1330                   time_window,
1331                   evtime,
1332                   width,
1333                   &x);
1334
1335         /* Draw collision indicator */
1336         gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
1337         gdk_draw_point(hashed_process_data->pixmap,
1338                        drawing->gc,
1339                        x,
1340                        COLLISION_POSITION(hashed_process_data->height));
1341         hashed_process_data->x.middle_marked = TRUE;
1342       }
1343     } else {
1344       TimeWindow time_window =
1345         lttvwindow_get_time_window(control_flow_data->tab);
1346
1347 #ifdef EXTRA_CHECK
1348       if(ltt_time_compare(evtime, time_window.start_time) == -1
1349             || ltt_time_compare(evtime, time_window.end_time) == 1)
1350                 return;
1351 #endif //EXTRA_CHECK
1352       Drawing_t *drawing = control_flow_data->drawing;
1353       guint width = drawing->width;
1354       guint x;
1355
1356       convert_time_to_pixels(
1357           time_window,
1358           evtime,
1359           width,
1360           &x);
1361
1362
1363       /* Jump over draw if we are at the same x position */
1364       if(unlikely(x == hashed_process_data->x.middle &&
1365              hashed_process_data->x.middle_used))
1366       {
1367         if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
1368           /* Draw collision indicator */
1369           gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
1370           gdk_draw_point(hashed_process_data->pixmap,
1371                          drawing->gc,
1372                          x,
1373                          COLLISION_POSITION(hashed_process_data->height));
1374           hashed_process_data->x.middle_marked = TRUE;
1375         }
1376         /* jump */
1377       } else {
1378         DrawContext draw_context;
1379
1380         /* Now create the drawing context that will be used to draw
1381          * items related to the last state. */
1382         draw_context.drawable = hashed_process_data->pixmap;
1383         draw_context.gc = drawing->gc;
1384         draw_context.pango_layout = drawing->pango_layout;
1385         draw_context.drawinfo.start.x = hashed_process_data->x.middle;
1386         draw_context.drawinfo.end.x = x;
1387
1388         draw_context.drawinfo.y.over = 1;
1389         draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
1390         draw_context.drawinfo.y.under = hashed_process_data->height;
1391
1392         draw_context.drawinfo.start.offset.over = 0;
1393         draw_context.drawinfo.start.offset.middle = 0;
1394         draw_context.drawinfo.start.offset.under = 0;
1395         draw_context.drawinfo.end.offset.over = 0;
1396         draw_context.drawinfo.end.offset.middle = 0;
1397         draw_context.drawinfo.end.offset.under = 0;
1398
1399         {
1400           /* Draw the line */
1401           PropertiesLine prop_line = prepare_s_e_line(process);
1402           draw_line((void*)&prop_line, (void*)&draw_context);
1403
1404         }
1405         /* become the last x position */
1406         hashed_process_data->x.middle = x;
1407         hashed_process_data->x.middle_used = TRUE;
1408         hashed_process_data->x.middle_marked = FALSE;
1409
1410         /* Calculate the next good time */
1411         convert_pixels_to_time(width, x+1, time_window,
1412                                &hashed_process_data->next_good_time);
1413       }
1414     }
1415   }
1416
1417   return 0;
1418 }
1419
1420
1421
1422
1423
1424 /* after_process_fork_hook
1425  *
1426  * Create the processlist entry for the child process. Put the last
1427  * position in x at the current time value.
1428  *
1429  * @param hook_data ControlFlowData structure of the viewer.
1430  * @param call_data Event context.
1431  *
1432  * This function adds items to be drawn in a queue for each process.
1433  *
1434  */
1435 int after_process_fork_hook(void *hook_data, void *call_data)
1436 {
1437   LttvTraceHook *th = (LttvTraceHook*)hook_data;
1438   EventsRequest *events_request = (EventsRequest*)th->hook_data;
1439   ControlFlowData *control_flow_data = events_request->viewer_data;
1440
1441   LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
1442
1443   LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1444
1445   LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
1446
1447   LttEvent *e;
1448   e = ltt_tracefile_get_event(tfc->tf);
1449
1450   LttvFilter *filter = control_flow_data->filter;
1451   if(filter != NULL && filter->head != NULL)
1452     if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1453           tfc->t_context->t,tfc,NULL,NULL))
1454       return FALSE;
1455
1456   LttTime evtime = ltt_event_time(e);
1457
1458   guint child_pid;
1459   {
1460     child_pid = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 1));
1461   }
1462
1463   /* Add process to process list (if not present) */
1464   LttvProcessState *process_child;
1465   LttTime birth;
1466   guint pl_height = 0;
1467   HashedProcessData *hashed_process_data_child = NULL;
1468
1469   ProcessList *process_list = control_flow_data->process_list;
1470
1471   /* Find child in the list... */
1472   process_child = lttv_state_find_process(ts, ANY_CPU, child_pid);
1473   /* It should exist, because we are after the state update. */
1474   g_assert(process_child != NULL);
1475
1476   birth = process_child->creation_time;
1477   guint trace_num = ts->parent.index;
1478
1479   /* Cannot use current process, because this action is done by the parent
1480    * on its child. */
1481   hashed_process_data_child = processlist_get_process_data(process_list,
1482           child_pid,
1483           process_child->cpu,
1484           &birth,
1485           trace_num);
1486   if(likely(hashed_process_data_child == NULL))
1487   {
1488     g_assert(child_pid == 0 || child_pid != process_child->ppid);
1489     /* Process not present */
1490     Drawing_t *drawing = control_flow_data->drawing;
1491     ProcessInfo *process_info;
1492     processlist_add(process_list,
1493         drawing,
1494         child_pid,
1495         process_child->tgid,
1496         process_child->cpu,
1497         process_child->ppid,
1498         &birth,
1499         trace_num,
1500         process_child->name,
1501         process_child->brand,
1502         &pl_height,
1503         &process_info,
1504         &hashed_process_data_child);
1505       gtk_widget_set_size_request(drawing->drawing_area,
1506                                   -1,
1507                                   pl_height);
1508       gtk_widget_queue_draw(drawing->drawing_area);
1509   } else {
1510           processlist_set_ppid(process_list, process_child->ppid,
1511                                hashed_process_data_child);
1512           processlist_set_tgid(process_list, process_child->tgid,
1513                                hashed_process_data_child);
1514   }
1515
1516
1517   if(likely(ltt_time_compare(hashed_process_data_child->next_good_time,
1518                         evtime) <= 0))
1519   {
1520     TimeWindow time_window =
1521       lttvwindow_get_time_window(control_flow_data->tab);
1522
1523 #ifdef EXTRA_CHECK
1524     if(ltt_time_compare(evtime, time_window.start_time) == -1
1525           || ltt_time_compare(evtime, time_window.end_time) == 1)
1526               return;
1527 #endif //EXTRA_CHECK
1528     Drawing_t *drawing = control_flow_data->drawing;
1529     guint width = drawing->width;
1530     guint new_x;
1531     convert_time_to_pixels(
1532         time_window,
1533         evtime,
1534         width,
1535         &new_x);
1536
1537     if(likely(hashed_process_data_child->x.over != new_x)) {
1538       hashed_process_data_child->x.over = new_x;
1539       hashed_process_data_child->x.over_used = FALSE;
1540       hashed_process_data_child->x.over_marked = FALSE;
1541     }
1542     if(likely(hashed_process_data_child->x.middle != new_x)) {
1543       hashed_process_data_child->x.middle = new_x;
1544       hashed_process_data_child->x.middle_used = FALSE;
1545       hashed_process_data_child->x.middle_marked = FALSE;
1546     }
1547     if(likely(hashed_process_data_child->x.under != new_x)) {
1548       hashed_process_data_child->x.under = new_x;
1549       hashed_process_data_child->x.under_used = FALSE;
1550       hashed_process_data_child->x.under_marked = FALSE;
1551     }
1552   }
1553   return 0;
1554 }
1555
1556
1557
1558 /* after_process_exit_hook
1559  *
1560  * Create the processlist entry for the child process. Put the last
1561  * position in x at the current time value.
1562  *
1563  * @param hook_data ControlFlowData structure of the viewer.
1564  * @param call_data Event context.
1565  *
1566  * This function adds items to be drawn in a queue for each process.
1567  *
1568  */
1569 int after_process_exit_hook(void *hook_data, void *call_data)
1570 {
1571   LttvTraceHook *th = (LttvTraceHook*)hook_data;
1572   EventsRequest *events_request = (EventsRequest*)th->hook_data;
1573   ControlFlowData *control_flow_data = events_request->viewer_data;
1574
1575   LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
1576
1577   LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1578
1579   LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
1580
1581   LttEvent *e;
1582   e = ltt_tracefile_get_event(tfc->tf);
1583
1584   LttvFilter *filter = control_flow_data->filter;
1585   if(filter != NULL && filter->head != NULL)
1586     if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1587           tfc->t_context->t,tfc,NULL,NULL))
1588       return FALSE;
1589
1590   LttTime evtime = ltt_event_time(e);
1591
1592   /* Add process to process list (if not present) */
1593   //LttvProcessState *process = tfs->process;
1594   guint cpu = tfs->cpu;
1595   guint trace_num = ts->parent.index;
1596   LttvProcessState *process = ts->running_process[cpu];
1597
1598   /* It should exist, because we are after the state update. */
1599   g_assert(process != NULL);
1600
1601   guint pid = process->pid;
1602   LttTime birth;
1603   guint pl_height = 0;
1604   HashedProcessData *hashed_process_data = NULL;
1605
1606   ProcessList *process_list = control_flow_data->process_list;
1607
1608   birth = process->creation_time;
1609
1610   if(likely(process_list->current_hash_data[trace_num][cpu] != NULL) ){
1611     hashed_process_data = process_list->current_hash_data[trace_num][cpu];
1612   } else {
1613     hashed_process_data = processlist_get_process_data(process_list,
1614             pid,
1615             process->cpu,
1616             &birth,
1617             trace_num);
1618     if(unlikely(hashed_process_data == NULL))
1619     {
1620       g_assert(pid == 0 || pid != process->ppid);
1621       /* Process not present */
1622       Drawing_t *drawing = control_flow_data->drawing;
1623       ProcessInfo *process_info;
1624       processlist_add(process_list,
1625           drawing,
1626           pid,
1627           process->tgid,
1628           process->cpu,
1629           process->ppid,
1630           &birth,
1631           trace_num,
1632           process->name,
1633           process->brand,
1634           &pl_height,
1635           &process_info,
1636           &hashed_process_data);
1637       gtk_widget_set_size_request(drawing->drawing_area,
1638                                   -1,
1639                                   pl_height);
1640       gtk_widget_queue_draw(drawing->drawing_area);
1641     }
1642
1643     /* Set the current process */
1644     process_list->current_hash_data[trace_num][process->cpu] =
1645                                              hashed_process_data;
1646   }
1647
1648   if(unlikely(ltt_time_compare(hashed_process_data->next_good_time,
1649                         evtime) <= 0))
1650   {
1651     TimeWindow time_window =
1652       lttvwindow_get_time_window(control_flow_data->tab);
1653
1654 #ifdef EXTRA_CHECK
1655     if(ltt_time_compare(evtime, time_window.start_time) == -1
1656           || ltt_time_compare(evtime, time_window.end_time) == 1)
1657               return;
1658 #endif //EXTRA_CHECK
1659     Drawing_t *drawing = control_flow_data->drawing;
1660     guint width = drawing->width;
1661     guint new_x;
1662     convert_time_to_pixels(
1663         time_window,
1664         evtime,
1665         width,
1666         &new_x);
1667     if(unlikely(hashed_process_data->x.middle != new_x)) {
1668       hashed_process_data->x.middle = new_x;
1669       hashed_process_data->x.middle_used = FALSE;
1670       hashed_process_data->x.middle_marked = FALSE;
1671     }
1672   }
1673
1674   return 0;
1675 }
1676
1677
1678 /* Get the filename of the process to print */
1679 int after_fs_exec_hook(void *hook_data, void *call_data)
1680 {
1681   LttvTraceHook *th = (LttvTraceHook*)hook_data;
1682   EventsRequest *events_request = (EventsRequest*)th->hook_data;
1683   ControlFlowData *control_flow_data = events_request->viewer_data;
1684
1685   LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
1686
1687   LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1688
1689   LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
1690
1691   LttEvent *e;
1692   e = ltt_tracefile_get_event(tfc->tf);
1693
1694   LttvFilter *filter = control_flow_data->filter;
1695   if(filter != NULL && filter->head != NULL)
1696     if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1697           tfc->t_context->t,tfc,NULL,NULL))
1698       return FALSE;
1699
1700   guint cpu = tfs->cpu;
1701   guint trace_num = ts->parent.index;
1702   LttvProcessState *process = ts->running_process[cpu];
1703   g_assert(process != NULL);
1704
1705   guint pid = process->pid;
1706
1707   /* Well, the process_out existed : we must get it in the process hash
1708    * or add it, and draw its items.
1709    */
1710    /* Add process to process list (if not present) */
1711   guint pl_height = 0;
1712   HashedProcessData *hashed_process_data = NULL;
1713   ProcessList *process_list = control_flow_data->process_list;
1714   LttTime birth = process->creation_time;
1715
1716   if(likely(process_list->current_hash_data[trace_num][cpu] != NULL)) {
1717     hashed_process_data = process_list->current_hash_data[trace_num][cpu];
1718   } else {
1719     hashed_process_data = processlist_get_process_data(process_list,
1720             pid,
1721             process->cpu,
1722             &birth,
1723             trace_num);
1724     if(unlikely(hashed_process_data == NULL))
1725     {
1726       g_assert(pid == 0 || pid != process->ppid);
1727       ProcessInfo *process_info;
1728       /* Process not present */
1729       Drawing_t *drawing = control_flow_data->drawing;
1730       processlist_add(process_list,
1731           drawing,
1732           pid,
1733           process->tgid,
1734           process->cpu,
1735           process->ppid,
1736           &birth,
1737           trace_num,
1738           process->name,
1739           process->brand,
1740           &pl_height,
1741           &process_info,
1742           &hashed_process_data);
1743         gtk_widget_set_size_request(drawing->drawing_area,
1744                                     -1,
1745                                     pl_height);
1746         gtk_widget_queue_draw(drawing->drawing_area);
1747     }
1748     /* Set the current process */
1749     process_list->current_hash_data[trace_num][process->cpu] =
1750                                                hashed_process_data;
1751   }
1752
1753   processlist_set_name(process_list, process->name, hashed_process_data);
1754
1755   return 0;
1756
1757 }
1758
1759 /* Get the filename of the process to print */
1760 int after_user_generic_thread_brand_hook(void *hook_data, void *call_data)
1761 {
1762   LttvTraceHook *th = (LttvTraceHook*)hook_data;
1763   EventsRequest *events_request = (EventsRequest*)th->hook_data;
1764   ControlFlowData *control_flow_data = events_request->viewer_data;
1765
1766   LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
1767
1768   LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1769
1770   LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
1771
1772   LttEvent *e;
1773   e = ltt_tracefile_get_event(tfc->tf);
1774
1775   LttvFilter *filter = control_flow_data->filter;
1776   if(filter != NULL && filter->head != NULL)
1777     if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1778           tfc->t_context->t,tfc,NULL,NULL))
1779       return FALSE;
1780
1781   guint cpu = tfs->cpu;
1782   guint trace_num = ts->parent.index;
1783   LttvProcessState *process = ts->running_process[cpu];
1784   g_assert(process != NULL);
1785
1786   guint pid = process->pid;
1787
1788   /* Well, the process_out existed : we must get it in the process hash
1789    * or add it, and draw its items.
1790    */
1791    /* Add process to process list (if not present) */
1792   guint pl_height = 0;
1793   HashedProcessData *hashed_process_data = NULL;
1794   ProcessList *process_list = control_flow_data->process_list;
1795   LttTime birth = process->creation_time;
1796
1797   if(likely(process_list->current_hash_data[trace_num][cpu] != NULL)) {
1798     hashed_process_data = process_list->current_hash_data[trace_num][cpu];
1799   } else {
1800     hashed_process_data = processlist_get_process_data(process_list,
1801             pid,
1802             process->cpu,
1803             &birth,
1804             trace_num);
1805     if(unlikely(hashed_process_data == NULL))
1806     {
1807       g_assert(pid == 0 || pid != process->ppid);
1808       ProcessInfo *process_info;
1809       /* Process not present */
1810       Drawing_t *drawing = control_flow_data->drawing;
1811       processlist_add(process_list,
1812           drawing,
1813           pid,
1814           process->tgid,
1815           process->cpu,
1816           process->ppid,
1817           &birth,
1818           trace_num,
1819           process->name,
1820           process->brand,
1821           &pl_height,
1822           &process_info,
1823           &hashed_process_data);
1824         gtk_widget_set_size_request(drawing->drawing_area,
1825                                     -1,
1826                                     pl_height);
1827         gtk_widget_queue_draw(drawing->drawing_area);
1828     }
1829     /* Set the current process */
1830     process_list->current_hash_data[trace_num][process->cpu] =
1831                                                hashed_process_data;
1832   }
1833
1834   processlist_set_brand(process_list, process->brand, hashed_process_data);
1835
1836   return 0;
1837
1838 }
1839
1840
1841 /* after_event_enum_process_hook
1842  *
1843  * Create the processlist entry for the child process. Put the last
1844  * position in x at the current time value.
1845  *
1846  * @param hook_data ControlFlowData structure of the viewer.
1847  * @param call_data Event context.
1848  *
1849  * This function adds items to be drawn in a queue for each process.
1850  *
1851  */
1852 int after_event_enum_process_hook(void *hook_data, void *call_data)
1853 {
1854   LttvTraceHook *th = (LttvTraceHook*)hook_data;
1855   EventsRequest *events_request = (EventsRequest*)th->hook_data;
1856   ControlFlowData *control_flow_data = events_request->viewer_data;
1857
1858   LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
1859
1860   LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1861
1862   LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
1863
1864   guint first_cpu, nb_cpus, cpu;
1865
1866   LttEvent *e;
1867   e = ltt_tracefile_get_event(tfc->tf);
1868
1869   LttvFilter *filter = control_flow_data->filter;
1870   if(filter != NULL && filter->head != NULL)
1871     if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
1872           tfc->t_context->t,tfc,NULL,NULL))
1873       return FALSE;
1874
1875   LttTime evtime = ltt_event_time(e);
1876
1877   /* Add process to process list (if not present) */
1878   LttvProcessState *process_in;
1879   LttTime birth;
1880   guint pl_height = 0;
1881   HashedProcessData *hashed_process_data_in = NULL;
1882
1883   ProcessList *process_list = control_flow_data->process_list;
1884   guint trace_num = ts->parent.index;
1885
1886   guint pid_in;
1887   {
1888     pid_in = ltt_event_get_long_unsigned(e, lttv_trace_get_hook_field(th, 0));
1889   }
1890
1891   if(pid_in == 0) {
1892     first_cpu = 0;
1893     nb_cpus = ltt_trace_get_num_cpu(ts->parent.t);
1894   } else {
1895     first_cpu = ANY_CPU;
1896     nb_cpus = ANY_CPU+1;
1897   }
1898
1899   for(cpu = first_cpu; cpu < nb_cpus; cpu++) {
1900     /* Find process pid_in in the list... */
1901     process_in = lttv_state_find_process(ts, cpu, pid_in);
1902     //process_in = tfs->process;
1903     //guint cpu = tfs->cpu;
1904     //guint trace_num = ts->parent.index;
1905     //process_in = ts->running_process[cpu];
1906     /* It should exist, because we are after the state update. */
1907   #ifdef EXTRA_CHECK
1908     //g_assert(process_in != NULL);
1909   #endif //EXTRA_CHECK
1910     birth = process_in->creation_time;
1911
1912     hashed_process_data_in = processlist_get_process_data(process_list,
1913             pid_in,
1914             process_in->cpu,
1915             &birth,
1916             trace_num);
1917     if(hashed_process_data_in == NULL)
1918     {
1919       if(pid_in != 0 && pid_in == process_in->ppid)
1920         g_critical("TEST %u , %u", pid_in, process_in->ppid);
1921       g_assert(pid_in == 0 || pid_in != process_in->ppid);
1922       ProcessInfo *process_info;
1923       Drawing_t *drawing = control_flow_data->drawing;
1924       /* Process not present */
1925       processlist_add(process_list,
1926           drawing,
1927           pid_in,
1928           process_in->tgid,
1929           process_in->cpu,
1930           process_in->ppid,
1931           &birth,
1932           trace_num,
1933           process_in->name,
1934           process_in->brand,
1935           &pl_height,
1936           &process_info,
1937           &hashed_process_data_in);
1938           gtk_widget_set_size_request(drawing->drawing_area,
1939                                       -1,
1940                                       pl_height);
1941           gtk_widget_queue_draw(drawing->drawing_area);
1942     } else {
1943       processlist_set_name(process_list, process_in->name,
1944                            hashed_process_data_in);
1945       processlist_set_ppid(process_list, process_in->ppid,
1946                            hashed_process_data_in);
1947       processlist_set_tgid(process_list, process_in->tgid,
1948                            hashed_process_data_in);
1949     }
1950   }
1951   return 0;
1952 }
1953
1954
1955 gint update_time_window_hook(void *hook_data, void *call_data)
1956 {
1957   ControlFlowData *control_flow_data = (ControlFlowData*) hook_data;
1958   Drawing_t *drawing = control_flow_data->drawing;
1959   ProcessList *process_list = control_flow_data->process_list;
1960
1961   const TimeWindowNotifyData *time_window_nofify_data =
1962                           ((const TimeWindowNotifyData *)call_data);
1963
1964   TimeWindow *old_time_window =
1965     time_window_nofify_data->old_time_window;
1966   TimeWindow *new_time_window =
1967     time_window_nofify_data->new_time_window;
1968
1969   /* Update the ruler */
1970   drawing_update_ruler(control_flow_data->drawing,
1971                        new_time_window);
1972
1973
1974   /* Two cases : zoom in/out or scrolling */
1975
1976   /* In order to make sure we can reuse the old drawing, the scale must
1977    * be the same and the new time interval being partly located in the
1978    * currently shown time interval. (reuse is only for scrolling)
1979    */
1980
1981   g_info("Old time window HOOK : %lu, %lu to %lu, %lu",
1982       old_time_window->start_time.tv_sec,
1983       old_time_window->start_time.tv_nsec,
1984       old_time_window->time_width.tv_sec,
1985       old_time_window->time_width.tv_nsec);
1986
1987   g_info("New time window HOOK : %lu, %lu to %lu, %lu",
1988       new_time_window->start_time.tv_sec,
1989       new_time_window->start_time.tv_nsec,
1990       new_time_window->time_width.tv_sec,
1991       new_time_window->time_width.tv_nsec);
1992
1993   if( new_time_window->time_width.tv_sec == old_time_window->time_width.tv_sec
1994   && new_time_window->time_width.tv_nsec == old_time_window->time_width.tv_nsec)
1995   {
1996     /* Same scale (scrolling) */
1997     g_info("scrolling");
1998     LttTime *ns = &new_time_window->start_time;
1999     LttTime *nw = &new_time_window->time_width;
2000     LttTime *os = &old_time_window->start_time;
2001     LttTime *ow = &old_time_window->time_width;
2002     LttTime old_end = old_time_window->end_time;
2003     LttTime new_end = new_time_window->end_time;
2004     //if(ns<os+w<ns+w)
2005     //if(ns<os+w && os+w<ns+w)
2006     //if(ns<old_end && os<ns)
2007     if(ltt_time_compare(*ns, old_end) == -1
2008         && ltt_time_compare(*os, *ns) == -1)
2009     {
2010       g_info("scrolling near right");
2011       /* Scroll right, keep right part of the screen */
2012       guint x = 0;
2013       guint width = control_flow_data->drawing->width;
2014       convert_time_to_pixels(
2015           *old_time_window,
2016           *ns,
2017           width,
2018           &x);
2019
2020       /* Copy old data to new location */
2021       copy_pixmap_region(process_list,
2022                   NULL,
2023                   control_flow_data->drawing->drawing_area->style->black_gc,
2024                   NULL,
2025                   x, 0,
2026                   0, 0,
2027                   control_flow_data->drawing->width-x+SAFETY, -1);
2028
2029       if(drawing->damage_begin == drawing->damage_end)
2030         drawing->damage_begin = control_flow_data->drawing->width-x;
2031       else
2032         drawing->damage_begin = 0;
2033
2034       drawing->damage_end = control_flow_data->drawing->width;
2035
2036       /* Clear the data request background, but not SAFETY */
2037       rectangle_pixmap(process_list,
2038           control_flow_data->drawing->drawing_area->style->black_gc,
2039           TRUE,
2040           drawing->damage_begin+SAFETY, 0,
2041           drawing->damage_end - drawing->damage_begin,  // do not overlap
2042           -1);
2043       gtk_widget_queue_draw(drawing->drawing_area);
2044       //gtk_widget_queue_draw_area (drawing->drawing_area,
2045       //                          0,0,
2046       //                          control_flow_data->drawing->width,
2047       //                          control_flow_data->drawing->height);
2048
2049       /* Get new data for the rest. */
2050       drawing_data_request(control_flow_data->drawing,
2051           drawing->damage_begin, 0,
2052           drawing->damage_end - drawing->damage_begin,
2053           control_flow_data->drawing->height);
2054     } else {
2055       //if(ns<os<ns+w)
2056       //if(ns<os && os<ns+w)
2057       //if(ns<os && os<new_end)
2058       if(ltt_time_compare(*ns,*os) == -1
2059           && ltt_time_compare(*os,new_end) == -1)
2060       {
2061         g_info("scrolling near left");
2062         /* Scroll left, keep left part of the screen */
2063         guint x = 0;
2064         guint width = control_flow_data->drawing->width;
2065         convert_time_to_pixels(
2066             *new_time_window,
2067             *os,
2068             width,
2069             &x);
2070
2071         /* Copy old data to new location */
2072         copy_pixmap_region  (process_list,
2073             NULL,
2074             control_flow_data->drawing->drawing_area->style->black_gc,
2075             NULL,
2076             0, 0,
2077             x, 0,
2078             -1, -1);
2079
2080         if(drawing->damage_begin == drawing->damage_end)
2081           drawing->damage_end = x;
2082         else
2083           drawing->damage_end =
2084             control_flow_data->drawing->width;
2085
2086         drawing->damage_begin = 0;
2087
2088         rectangle_pixmap (process_list,
2089           control_flow_data->drawing->drawing_area->style->black_gc,
2090           TRUE,
2091           drawing->damage_begin, 0,
2092           drawing->damage_end - drawing->damage_begin,  // do not overlap
2093           -1);
2094
2095         gtk_widget_queue_draw(drawing->drawing_area);
2096         //gtk_widget_queue_draw_area (drawing->drawing_area,
2097         //                        0,0,
2098         //                        control_flow_data->drawing->width,
2099         //                        control_flow_data->drawing->height);
2100
2101
2102         /* Get new data for the rest. */
2103         drawing_data_request(control_flow_data->drawing,
2104             drawing->damage_begin, 0,
2105             drawing->damage_end - drawing->damage_begin,
2106             control_flow_data->drawing->height);
2107
2108       } else {
2109         if(ltt_time_compare(*ns,*os) == 0)
2110         {
2111           g_info("not scrolling");
2112         } else {
2113           g_info("scrolling far");
2114           /* Cannot reuse any part of the screen : far jump */
2115
2116
2117           rectangle_pixmap (process_list,
2118             control_flow_data->drawing->drawing_area->style->black_gc,
2119             TRUE,
2120             0, 0,
2121             control_flow_data->drawing->width+SAFETY, // do not overlap
2122             -1);
2123
2124           //gtk_widget_queue_draw_area (drawing->drawing_area,
2125           //                      0,0,
2126           //                      control_flow_data->drawing->width,
2127           //                      control_flow_data->drawing->height);
2128           gtk_widget_queue_draw(drawing->drawing_area);
2129
2130           drawing->damage_begin = 0;
2131           drawing->damage_end = control_flow_data->drawing->width;
2132
2133           drawing_data_request(control_flow_data->drawing,
2134               0, 0,
2135               control_flow_data->drawing->width,
2136               control_flow_data->drawing->height);
2137
2138         }
2139       }
2140     }
2141   } else {
2142     /* Different scale (zoom) */
2143     g_info("zoom");
2144
2145     rectangle_pixmap (process_list,
2146           control_flow_data->drawing->drawing_area->style->black_gc,
2147           TRUE,
2148           0, 0,
2149           control_flow_data->drawing->width+SAFETY, // do not overlap
2150           -1);
2151
2152     //gtk_widget_queue_draw_area (drawing->drawing_area,
2153     //                            0,0,
2154     //                            control_flow_data->drawing->width,
2155     //                            control_flow_data->drawing->height);
2156     gtk_widget_queue_draw(drawing->drawing_area);
2157
2158     drawing->damage_begin = 0;
2159     drawing->damage_end = control_flow_data->drawing->width;
2160
2161     drawing_data_request(control_flow_data->drawing,
2162         0, 0,
2163         control_flow_data->drawing->width,
2164         control_flow_data->drawing->height);
2165   }
2166
2167   /* Update directly when scrolling */
2168   gdk_window_process_updates(control_flow_data->drawing->drawing_area->window,
2169       TRUE);
2170
2171   return 0;
2172 }
2173
2174 gint traceset_notify(void *hook_data, void *call_data)
2175 {
2176   ControlFlowData *control_flow_data = (ControlFlowData*) hook_data;
2177   Drawing_t *drawing = control_flow_data->drawing;
2178
2179   if(unlikely(drawing->gc == NULL)) {
2180     return FALSE;
2181   }
2182   if(drawing->dotted_gc == NULL) {
2183     return FALSE;
2184   }
2185
2186   drawing_clear(control_flow_data->drawing);
2187   processlist_clear(control_flow_data->process_list);
2188   gtk_widget_set_size_request(
2189       control_flow_data->drawing->drawing_area,
2190                 -1, processlist_get_height(control_flow_data->process_list));
2191   redraw_notify(control_flow_data, NULL);
2192
2193   request_background_data(control_flow_data);
2194
2195   return FALSE;
2196 }
2197
2198 gint redraw_notify(void *hook_data, void *call_data)
2199 {
2200   ControlFlowData *control_flow_data = (ControlFlowData*) hook_data;
2201   Drawing_t *drawing = control_flow_data->drawing;
2202   GtkWidget *widget = drawing->drawing_area;
2203
2204   drawing->damage_begin = 0;
2205   drawing->damage_end = drawing->width;
2206
2207   /* fun feature, to be separated someday... */
2208   drawing_clear(control_flow_data->drawing);
2209   processlist_clear(control_flow_data->process_list);
2210   gtk_widget_set_size_request(
2211       control_flow_data->drawing->drawing_area,
2212                 -1, processlist_get_height(control_flow_data->process_list));
2213   // Clear the images
2214   rectangle_pixmap (control_flow_data->process_list,
2215         widget->style->black_gc,
2216         TRUE,
2217         0, 0,
2218         drawing->alloc_width,
2219         -1);
2220
2221   gtk_widget_queue_draw(drawing->drawing_area);
2222
2223   if(drawing->damage_begin < drawing->damage_end)
2224   {
2225     drawing_data_request(drawing,
2226                          drawing->damage_begin,
2227                          0,
2228                          drawing->damage_end-drawing->damage_begin,
2229                          drawing->height);
2230   }
2231
2232   //gtk_widget_queue_draw_area(drawing->drawing_area,
2233   //                           0,0,
2234   //                           drawing->width,
2235   //                           drawing->height);
2236   return FALSE;
2237
2238 }
2239
2240
2241 gint continue_notify(void *hook_data, void *call_data)
2242 {
2243   ControlFlowData *control_flow_data = (ControlFlowData*) hook_data;
2244   Drawing_t *drawing = control_flow_data->drawing;
2245
2246   //g_assert(widget->allocation.width == drawing->damage_end);
2247
2248   if(drawing->damage_begin < drawing->damage_end)
2249   {
2250     drawing_data_request(drawing,
2251                          drawing->damage_begin,
2252                          0,
2253                          drawing->damage_end-drawing->damage_begin,
2254                          drawing->height);
2255   }
2256
2257   return FALSE;
2258 }
2259
2260
2261 gint update_current_time_hook(void *hook_data, void *call_data)
2262 {
2263   ControlFlowData *control_flow_data = (ControlFlowData*)hook_data;
2264   Drawing_t *drawing = control_flow_data->drawing;
2265
2266   LttTime current_time = *((LttTime*)call_data);
2267
2268   TimeWindow time_window =
2269             lttvwindow_get_time_window(control_flow_data->tab);
2270
2271   LttTime time_begin = time_window.start_time;
2272   LttTime width = time_window.time_width;
2273   LttTime half_width;
2274   {
2275     guint64 time_ll = ltt_time_to_uint64(width);
2276     time_ll = time_ll >> 1; /* divide by two */
2277     half_width = ltt_time_from_uint64(time_ll);
2278   }
2279   LttTime time_end = ltt_time_add(time_begin, width);
2280
2281   LttvTracesetContext * tsc =
2282         lttvwindow_get_traceset_context(control_flow_data->tab);
2283
2284   LttTime trace_start = tsc->time_span.start_time;
2285   LttTime trace_end = tsc->time_span.end_time;
2286
2287   g_info("New current time HOOK : %lu, %lu", current_time.tv_sec,
2288               current_time.tv_nsec);
2289
2290
2291
2292   /* If current time is inside time interval, just move the highlight
2293    * bar */
2294
2295   /* Else, we have to change the time interval. We have to tell it
2296    * to the main window. */
2297   /* The time interval change will take care of placing the current
2298    * time at the center of the visible area, or nearest possible if we are
2299    * at one end of the trace. */
2300
2301
2302   if(ltt_time_compare(current_time, time_begin) < 0)
2303   {
2304     TimeWindow new_time_window;
2305
2306     if(ltt_time_compare(current_time,
2307           ltt_time_add(trace_start,half_width)) < 0)
2308       time_begin = trace_start;
2309     else
2310       time_begin = ltt_time_sub(current_time,half_width);
2311
2312     new_time_window.start_time = time_begin;
2313     new_time_window.time_width = width;
2314     new_time_window.time_width_double = ltt_time_to_double(width);
2315     new_time_window.end_time = ltt_time_add(time_begin, width);
2316
2317     lttvwindow_report_time_window(control_flow_data->tab, new_time_window);
2318   }
2319   else if(ltt_time_compare(current_time, time_end) > 0)
2320   {
2321     TimeWindow new_time_window;
2322
2323     if(ltt_time_compare(current_time, ltt_time_sub(trace_end, half_width)) > 0)
2324       time_begin = ltt_time_sub(trace_end,width);
2325     else
2326       time_begin = ltt_time_sub(current_time,half_width);
2327
2328     new_time_window.start_time = time_begin;
2329     new_time_window.time_width = width;
2330     new_time_window.time_width_double = ltt_time_to_double(width);
2331     new_time_window.end_time = ltt_time_add(time_begin, width);
2332
2333     lttvwindow_report_time_window(control_flow_data->tab, new_time_window);
2334
2335   }
2336   gtk_widget_queue_draw(control_flow_data->drawing->drawing_area);
2337
2338   /* Update directly when scrolling */
2339   gdk_window_process_updates(control_flow_data->drawing->drawing_area->window,
2340       TRUE);
2341
2342   return 0;
2343 }
2344
2345 typedef struct _ClosureData {
2346   EventsRequest *events_request;
2347   LttvTracesetState *tss;
2348   LttTime end_time;
2349   guint x_end;
2350 } ClosureData;
2351
2352
2353 void draw_closure(gpointer key, gpointer value, gpointer user_data)
2354 {
2355   ProcessInfo *process_info = (ProcessInfo*)key;
2356   HashedProcessData *hashed_process_data = (HashedProcessData*)value;
2357   ClosureData *closure_data = (ClosureData*)user_data;
2358
2359   EventsRequest *events_request = closure_data->events_request;
2360   ControlFlowData *control_flow_data = events_request->viewer_data;
2361
2362   LttvTracesetState *tss = closure_data->tss;
2363   LttvTracesetContext *tsc = (LttvTracesetContext*)tss;
2364
2365   LttTime evtime = closure_data->end_time;
2366
2367   gboolean dodraw = TRUE;
2368
2369   {
2370     /* For the process */
2371     /* First, check if the current process is in the state computation
2372      * process list. If it is there, that means we must add it right now and
2373      * draw items from the beginning of the read for it. If it is not
2374      * present, it's a new process and it was not present : it will
2375      * be added after the state update.  */
2376 #ifdef EXTRA_CHECK
2377     g_assert(lttv_traceset_number(tsc->ts) > 0);
2378 #endif //EXTRA_CHECK
2379     LttvTraceContext *tc = tsc->traces[process_info->trace_num];
2380     LttvTraceState *ts = (LttvTraceState*)tc;
2381
2382 #if 0
2383     //FIXME : optimize data structures.
2384     LttvTracefileState *tfs;
2385     LttvTracefileContext *tfc;
2386     guint i;
2387     for(i=0;i<tc->tracefiles->len;i++) {
2388       tfc = g_array_index(tc->tracefiles, LttvTracefileContext*, i);
2389       if(ltt_tracefile_name(tfc->tf) == LTT_NAME_CPU
2390           && tfs->cpu == process_info->cpu)
2391         break;
2392
2393     }
2394     g_assert(i<tc->tracefiles->len);
2395     tfs = LTTV_TRACEFILE_STATE(tfc);
2396 #endif //0
2397  //   LttvTracefileState *tfs =
2398  //    (LttvTracefileState*)tsc->traces[process_info->trace_num]->
2399  //                        tracefiles[process_info->cpu];
2400
2401     LttvProcessState *process;
2402     process = lttv_state_find_process(ts, process_info->cpu,
2403                                       process_info->pid);
2404
2405     if(unlikely(process != NULL)) {
2406
2407        LttvFilter *filter = control_flow_data->filter;
2408        if(filter != NULL && filter->head != NULL)
2409          if(!lttv_filter_tree_parse(filter->head,NULL,NULL,
2410              tc->t,NULL,process,tc))
2411            dodraw = FALSE;
2412
2413       /* Only draw for processes that are currently in the trace states */
2414
2415       ProcessList *process_list = control_flow_data->process_list;
2416 #ifdef EXTRA_CHECK
2417       /* Should be alike when background info is ready */
2418       if(control_flow_data->background_info_waiting==0)
2419         g_assert(ltt_time_compare(process->creation_time,
2420                                   process_info->birth) == 0);
2421 #endif //EXTRA_CHECK
2422
2423       /* Now, the process is in the state hash and our own process hash.
2424        * We definitely can draw the items related to the ending state.
2425        */
2426
2427       if(unlikely(ltt_time_compare(hashed_process_data->next_good_time,
2428                             evtime) <= 0))
2429       {
2430         TimeWindow time_window =
2431           lttvwindow_get_time_window(control_flow_data->tab);
2432
2433 #ifdef EXTRA_CHECK
2434         if(ltt_time_compare(evtime, time_window.start_time) == -1
2435               || ltt_time_compare(evtime, time_window.end_time) == 1)
2436                   return;
2437 #endif //EXTRA_CHECK
2438         Drawing_t *drawing = control_flow_data->drawing;
2439         guint width = drawing->width;
2440
2441         guint x = closure_data->x_end;
2442
2443         DrawContext draw_context;
2444
2445         /* Now create the drawing context that will be used to draw
2446          * items related to the last state. */
2447         draw_context.drawable = hashed_process_data->pixmap;
2448         draw_context.gc = drawing->gc;
2449         draw_context.pango_layout = drawing->pango_layout;
2450         draw_context.drawinfo.end.x = x;
2451
2452         draw_context.drawinfo.y.over = 1;
2453         draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
2454         draw_context.drawinfo.y.under = hashed_process_data->height;
2455
2456         draw_context.drawinfo.start.offset.over = 0;
2457         draw_context.drawinfo.start.offset.middle = 0;
2458         draw_context.drawinfo.start.offset.under = 0;
2459         draw_context.drawinfo.end.offset.over = 0;
2460         draw_context.drawinfo.end.offset.middle = 0;
2461         draw_context.drawinfo.end.offset.under = 0;
2462 #if 0
2463         /* Jump over draw if we are at the same x position */
2464         if(x == hashed_process_data->x.over)
2465         {
2466           /* jump */
2467         } else {
2468           draw_context.drawinfo.start.x = hashed_process_data->x.over;
2469           /* Draw the line */
2470           PropertiesLine prop_line = prepare_execmode_line(process);
2471           draw_line((void*)&prop_line, (void*)&draw_context);
2472
2473           hashed_process_data->x.over = x;
2474         }
2475 #endif //0
2476
2477         if(unlikely(x == hashed_process_data->x.middle &&
2478             hashed_process_data->x.middle_used)) {
2479 #if 0 /* do not mark closure : not missing information */
2480           if(hashed_process_data->x.middle_marked == FALSE) {
2481             /* Draw collision indicator */
2482             gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
2483             gdk_draw_point(drawing->pixmap,
2484                            drawing->gc,
2485                            x,
2486                            y+(height/2)-3);
2487             hashed_process_data->x.middle_marked = TRUE;
2488           }
2489 #endif //0
2490           /* Jump */
2491         } else {
2492           draw_context.drawinfo.start.x = hashed_process_data->x.middle;
2493           /* Draw the line */
2494           if(dodraw) {
2495                   PropertiesLine prop_line = prepare_s_e_line(process);
2496                   draw_line((void*)&prop_line, (void*)&draw_context);
2497           }
2498
2499            /* become the last x position */
2500           if(likely(x != hashed_process_data->x.middle)) {
2501             hashed_process_data->x.middle = x;
2502             /* but don't use the pixel */
2503             hashed_process_data->x.middle_used = FALSE;
2504
2505             /* Calculate the next good time */
2506             convert_pixels_to_time(width, x+1, time_window,
2507                                   &hashed_process_data->next_good_time);
2508           }
2509         }
2510       }
2511     }
2512   }
2513   return;
2514 }
2515
2516 int before_chunk(void *hook_data, void *call_data)
2517 {
2518   EventsRequest *events_request = (EventsRequest*)hook_data;
2519   LttvTracesetState *tss = (LttvTracesetState*)call_data;
2520   ControlFlowData *cfd = (ControlFlowData*)events_request->viewer_data;
2521 #if 0
2522   /* Desactivate sort */
2523   gtk_tree_sortable_set_sort_column_id(
2524       GTK_TREE_SORTABLE(cfd->process_list->list_store),
2525       TRACE_COLUMN,
2526       GTK_SORT_ASCENDING);
2527 #endif //0
2528   drawing_chunk_begin(events_request, tss);
2529
2530   return 0;
2531 }
2532
2533 int before_request(void *hook_data, void *call_data)
2534 {
2535   EventsRequest *events_request = (EventsRequest*)hook_data;
2536   LttvTracesetState *tss = (LttvTracesetState*)call_data;
2537
2538   drawing_data_request_begin(events_request, tss);
2539
2540   return 0;
2541 }
2542
2543
2544 /*
2545  * after request is necessary in addition of after chunk in order to draw
2546  * lines until the end of the screen. after chunk just draws lines until
2547  * the last event.
2548  *
2549  * for each process
2550  *    draw closing line
2551  *    expose
2552  */
2553 int after_request(void *hook_data, void *call_data)
2554 {
2555   EventsRequest *events_request = (EventsRequest*)hook_data;
2556   ControlFlowData *control_flow_data = events_request->viewer_data;
2557   LttvTracesetState *tss = (LttvTracesetState*)call_data;
2558
2559   ProcessList *process_list = control_flow_data->process_list;
2560   LttTime end_time = events_request->end_time;
2561
2562   ClosureData closure_data;
2563   closure_data.events_request = (EventsRequest*)hook_data;
2564   closure_data.tss = tss;
2565   closure_data.end_time = end_time;
2566
2567   TimeWindow time_window =
2568           lttvwindow_get_time_window(control_flow_data->tab);
2569   guint width = control_flow_data->drawing->width;
2570   convert_time_to_pixels(
2571             time_window,
2572             end_time,
2573             width,
2574             &closure_data.x_end);
2575
2576
2577   /* Draw last items */
2578   g_hash_table_foreach(process_list->process_hash, draw_closure,
2579                         (void*)&closure_data);
2580
2581
2582   /* Request expose */
2583   drawing_request_expose(events_request, tss, end_time);
2584   return 0;
2585 }
2586
2587 /*
2588  * for each process
2589  *    draw closing line
2590  * expose
2591  */
2592 int after_chunk(void *hook_data, void *call_data)
2593 {
2594   EventsRequest *events_request = (EventsRequest*)hook_data;
2595   ControlFlowData *control_flow_data = events_request->viewer_data;
2596   LttvTracesetState *tss = (LttvTracesetState*)call_data;
2597   LttvTracesetContext *tsc = (LttvTracesetContext*)call_data;
2598   LttvTracefileContext *tfc = lttv_traceset_context_get_current_tfc(tsc);
2599   LttTime end_time;
2600
2601   ProcessList *process_list = control_flow_data->process_list;
2602   guint i;
2603   LttvTraceset *traceset = tsc->ts;
2604   guint nb_trace = lttv_traceset_number(traceset);
2605
2606   /* Only execute when called for the first trace's events request */
2607   if(!process_list->current_hash_data) return;
2608
2609   for(i = 0 ; i < nb_trace ; i++) {
2610     g_free(process_list->current_hash_data[i]);
2611   }
2612   g_free(process_list->current_hash_data);
2613   process_list->current_hash_data = NULL;
2614
2615   if(tfc != NULL)
2616     end_time = LTT_TIME_MIN(tfc->timestamp, events_request->end_time);
2617   else /* end of traceset, or position now out of request : end */
2618     end_time = events_request->end_time;
2619
2620   ClosureData closure_data;
2621   closure_data.events_request = (EventsRequest*)hook_data;
2622   closure_data.tss = tss;
2623   closure_data.end_time = end_time;
2624
2625   TimeWindow time_window =
2626           lttvwindow_get_time_window(control_flow_data->tab);
2627   guint width = control_flow_data->drawing->width;
2628   convert_time_to_pixels(
2629             time_window,
2630             end_time,
2631             width,
2632             &closure_data.x_end);
2633
2634   /* Draw last items */
2635   g_hash_table_foreach(process_list->process_hash, draw_closure,
2636                         (void*)&closure_data);
2637 #if 0
2638   /* Reactivate sort */
2639   gtk_tree_sortable_set_sort_column_id(
2640       GTK_TREE_SORTABLE(control_flow_data->process_list->list_store),
2641       GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
2642       GTK_SORT_ASCENDING);
2643
2644   update_index_to_pixmap(control_flow_data->process_list);
2645   /* Request a full expose : drawing scrambled */
2646   gtk_widget_queue_draw(control_flow_data->drawing->drawing_area);
2647 #endif //0
2648   /* Request expose (updates damages zone also) */
2649   drawing_request_expose(events_request, tss, end_time);
2650
2651   return 0;
2652 }
2653
2654 /* after_statedump_end
2655  *
2656  * @param hook_data ControlFlowData structure of the viewer.
2657  * @param call_data Event context.
2658  *
2659  * This function adds items to be drawn in a queue for each process.
2660  *
2661  */
2662 int before_statedump_end(void *hook_data, void *call_data)
2663 {
2664   LttvTraceHook *th = (LttvTraceHook*)hook_data;
2665   EventsRequest *events_request = (EventsRequest*)th->hook_data;
2666   ControlFlowData *control_flow_data = events_request->viewer_data;
2667
2668   LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
2669
2670   LttvTracefileState *tfs = (LttvTracefileState *)call_data;
2671
2672   LttvTraceState *ts = (LttvTraceState *)tfc->t_context;
2673
2674   LttvTracesetState *tss = (LttvTracesetState*)tfc->t_context->ts_context;
2675   ProcessList *process_list = control_flow_data->process_list;
2676
2677   LttEvent *e;
2678   e = ltt_tracefile_get_event(tfc->tf);
2679
2680   LttvFilter *filter = control_flow_data->filter;
2681   if(filter != NULL && filter->head != NULL)
2682     if(!lttv_filter_tree_parse(filter->head,e,tfc->tf,
2683           tfc->t_context->t,tfc,NULL,NULL))
2684       return FALSE;
2685
2686   LttTime evtime = ltt_event_time(e);
2687
2688   ClosureData closure_data;
2689   closure_data.events_request = events_request;
2690   closure_data.tss = tss;
2691   closure_data.end_time = evtime;
2692
2693   TimeWindow time_window =
2694           lttvwindow_get_time_window(control_flow_data->tab);
2695   guint width = control_flow_data->drawing->width;
2696   convert_time_to_pixels(
2697             time_window,
2698             evtime,
2699             width,
2700             &closure_data.x_end);
2701
2702   /* Draw last items */
2703   g_hash_table_foreach(process_list->process_hash, draw_closure,
2704                         (void*)&closure_data);
2705 #if 0
2706   /* Reactivate sort */
2707   gtk_tree_sortable_set_sort_column_id(
2708       GTK_TREE_SORTABLE(control_flow_data->process_list->list_store),
2709       GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
2710       GTK_SORT_ASCENDING);
2711
2712   update_index_to_pixmap(control_flow_data->process_list);
2713   /* Request a full expose : drawing scrambled */
2714   gtk_widget_queue_draw(control_flow_data->drawing->drawing_area);
2715 #endif //0
2716   /* Request expose (updates damages zone also) */
2717   drawing_request_expose(events_request, tss, evtime);
2718
2719   return 0;
2720 }