ltt/branches/poly/lttv/modules/gui/controlflow/drawing.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 #include <gtk/gtk.h>
  20 #include <gdk/gdk.h>
  21
  22 #include <lttv/lttv.h>
  23 #include <lttv/tracecontext.h>
  24 #include <lttvwindow/lttvwindow.h>
  25 #include <lttv/state.h>
  26 #include <lttv/hook.h>
  27
  28 #include "drawing.h"
  29 #include "eventhooks.h"
  30 #include "cfv.h"
  31 #include "cfv-private.h"
  32
  33 #define g_info(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, format)
  34 #define g_debug(format...) g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, format)
  35
  36 //FIXME
  37 #define TRACE_NUMBER 0
  38
  39 #if 0 /* colors for two lines representation */
  40 GdkColor drawing_colors[NUM_COLORS] =
  41 { /* Pixel, R, G, B */
  42   { 0, 0, 0, 0 }, /* COL_BLACK */
  43   { 0, 0xFFFF, 0xFFFF, 0xFFFF }, /* COL_WHITE */
  44   { 0, 0x0FFF, 0xFFFF, 0xFFFF }, /* COL_WAIT_FORK : pale blue */
  45   { 0, 0xFFFF, 0xFFFF, 0x0000 }, /* COL_WAIT_CPU : yellow */
  46   { 0, 0xFFFF, 0xA000, 0xFCFF }, /* COL_EXIT : pale magenta */
  47   { 0, 0xFFFF, 0x0000, 0xFFFF }, /* COL_ZOMBIE : purple */
  48   { 0, 0xFFFF, 0x0000, 0x0000 }, /* COL_WAIT : red */
  49   { 0, 0x0000, 0xFFFF, 0x0000 }, /* COL_RUN : green */
  50   { 0, 0x8800, 0xFFFF, 0x8A00 }, /* COL_USER_MODE : pale green */
  51   { 0, 0x09FF, 0x01FF, 0xFFFF }, /* COL_SYSCALL : blue */
  52   { 0, 0xF900, 0x4200, 0xFF00 }, /* COL_TRAP : pale purple */
  53   { 0, 0xFFFF, 0x5AFF, 0x01FF }, /* COL_IRQ : orange */
  54   { 0, 0xFFFF, 0xFFFF, 0xFFFF }  /* COL_MODE_UNKNOWN : white */
  55
  56 };
  57 #endif //0
  58
  59
  60 GdkColor drawing_colors[NUM_COLORS] =
  61 { /* Pixel, R, G, B */
  62   { 0, 0, 0, 0 }, /* COL_BLACK */
  63   { 0, 0xFFFF, 0xFFFF, 0xFFFF }, /* COL_WHITE */
  64   { 0, 0x0000, 0xFF00, 0x0000 }, /* COL_RUN_USER_MODE : green */
  65   { 0, 0x0100, 0x9E00, 0xFFFF }, /* COL_RUN_SYSCALL : pale blue */
  66   { 0, 0xFF00, 0xFF00, 0x0100 }, /* COL_RUN_TRAP : yellow */
  67   { 0, 0xFFFF, 0x0000, 0x0000 }, /* COL_RUN_IRQ : red */
  68   { 0, 0xA3FF, 0x0000, 0x0000 }, /* COL_WAIT : dark red */
  69   { 0, 0x7700, 0x7700, 0x0000 }, /* COL_WAIT_CPU : dark yellow */
  70   { 0, 0x6400, 0x0000, 0x5D00 }, /* COL_ZOMBIE : dark purple */
  71   { 0, 0x0700, 0x6400, 0x0000 }, /* COL_WAIT_FORK : dark green */
  72   { 0, 0x8900, 0x0000, 0x8400 }, /* COL_EXIT : "less dark" magenta */
  73   { 0, 0xFFFF, 0xFFFF, 0xFFFF }, /* COL_MODE_UNKNOWN : white */
  74   { 0, 0xFFFF, 0xFFFF, 0xFFFF }  /* COL_UNNAMED : white */
  75
  76 };
  77
  78 /*
  79 RUN+USER MODE green
  80 RUN+SYSCALL
  81 RUN+TRAP
  82 RUN+IRQ
  83 WAIT+foncé
  84 WAIT CPU + WAIT FORK vert foncé ou jaune
  85 IRQ rouge
  86 TRAP: orange
  87 SYSCALL: bleu pâle
  88
  89 ZOMBIE + WAIT EXIT
  90 */
  91
  92
  93 /*****************************************************************************
  94  *                              drawing functions                            *
  95  *****************************************************************************/
  96
  97 static gboolean
  98 expose_ruler( GtkWidget *widget, GdkEventExpose *event, gpointer user_data );
  99
 100 static gboolean
 101 motion_notify_ruler(GtkWidget *widget, GdkEventMotion *event, gpointer user_data);
 102
 103
 104 /* Function responsible for updating the exposed area.
 105  * It must do an events request to the lttvwindow API to ask for this update.
 106  * Note : this function cannot clear the background, because it may
 107  * erase drawing already present (SAFETY).
 108  */
 109 void drawing_data_request(Drawing_t *drawing,
 110       GdkPixmap **pixmap,
 111       gint x, gint y,
 112       gint width,
 113       gint height)
 114 {
 115   if(width < 0) return ;
 116   if(height < 0) return ;
 117
 118   Tab *tab = drawing->control_flow_data->tab;
 119   TimeWindow time_window =
 120               lttvwindow_get_time_window(tab);
 121
 122   ControlFlowData *control_flow_data = drawing->control_flow_data;
 123   //    (ControlFlowData*)g_object_get_data(
 124   //               G_OBJECT(drawing->drawing_area), "control_flow_data");
 125
 126   LttTime start, time_end;
 127   LttTime window_end = time_window.end_time;
 128
 129   g_debug("req : window start_time : %u, %u", time_window.start_time.tv_sec,
 130                                        time_window.start_time.tv_nsec);
 131
 132   g_debug("req : window time width : %u, %u", time_window.time_width.tv_sec,
 133                                        time_window.time_width.tv_nsec);
 134
 135   g_debug("req : window_end : %u, %u", window_end.tv_sec,
 136                                        window_end.tv_nsec);
 137
 138   g_debug("x is : %i, x+width is : %i", x, x+width);
 139
 140   convert_pixels_to_time(drawing->width, x,
 141         time_window,
 142         &start);
 143
 144   convert_pixels_to_time(drawing->width, x+width,
 145         time_window,
 146         &time_end);
 147   time_end = ltt_time_add(time_end, ltt_time_one); // because main window
 148                                                    // doesn't deliver end time.
 149
 150   lttvwindow_events_request_remove_all(tab,
 151                                        control_flow_data);
 152
 153   {
 154     /* find the tracehooks */
 155     LttvTracesetContext *tsc = lttvwindow_get_traceset_context(tab);
 156
 157     LttvTraceset *traceset = tsc->ts;
 158
 159     guint i, k, nb_trace;
 160
 161     LttvTraceState *ts;
 162
 163     LttvTracefileState *tfs;
 164
 165     GArray *hooks;
 166
 167     LttvTraceHook hook;
 168
 169     LttvAttributeValue val;
 170
 171     nb_trace = lttv_traceset_number(traceset);
 172     // FIXME : eventually request for more traces
 173     // for(i = 0 ; i < nb_trace ; i++) {
 174     for(i = 0; i<MIN(TRACE_NUMBER+1, nb_trace);i++)
 175     {
 176       EventsRequest *events_request = g_new(EventsRequest, 1);
 177       // Create the hooks
 178       //LttvHooks *event = lttv_hooks_new();
 179       LttvHooksById *event_by_id = lttv_hooks_by_id_new();
 180       LttvHooks *before_chunk_traceset = lttv_hooks_new();
 181       LttvHooks *after_chunk_traceset = lttv_hooks_new();
 182       LttvHooks *before_request_hook = lttv_hooks_new();
 183       LttvHooks *after_request_hook = lttv_hooks_new();
 184
 185       lttv_hooks_add(before_chunk_traceset,
 186                      before_chunk,
 187                      events_request,
 188                      LTTV_PRIO_DEFAULT);
 189
 190       lttv_hooks_add(after_chunk_traceset,
 191                      after_chunk,
 192                      events_request,
 193                      LTTV_PRIO_DEFAULT);
 194
 195       lttv_hooks_add(before_request_hook,
 196                      before_request,
 197                      events_request,
 198                      LTTV_PRIO_DEFAULT);
 199
 200       lttv_hooks_add(after_request_hook,
 201                      after_request,
 202                      events_request,
 203                      LTTV_PRIO_DEFAULT);
 204
 205
 206       ts = (LttvTraceState *)tsc->traces[i];
 207
 208       /* Find the eventtype id for the following events and register the
 209          associated by id hooks. */
 210
 211       hooks = g_array_new(FALSE, FALSE, sizeof(LttvTraceHook));
 212       g_array_set_size(hooks, 16);
 213
 214       /* before hooks */
 215
 216       lttv_trace_find_hook(ts->parent.t, "core","syscall_entry","syscall_id",
 217     NULL, NULL, before_execmode_hook, &g_array_index(hooks, LttvTraceHook, 0));
 218
 219       lttv_trace_find_hook(ts->parent.t, "core", "syscall_exit", NULL, NULL,
 220           NULL, before_execmode_hook, &g_array_index(hooks, LttvTraceHook, 1));
 221
 222       lttv_trace_find_hook(ts->parent.t, "core", "trap_entry", "trap_id",
 223     NULL, NULL, before_execmode_hook, &g_array_index(hooks, LttvTraceHook, 2));
 224
 225       lttv_trace_find_hook(ts->parent.t, "core", "trap_exit", NULL, NULL, NULL,
 226           before_execmode_hook, &g_array_index(hooks, LttvTraceHook, 3));
 227
 228       lttv_trace_find_hook(ts->parent.t, "core", "irq_entry", "irq_id", NULL,
 229           NULL, before_execmode_hook, &g_array_index(hooks, LttvTraceHook, 4));
 230
 231       lttv_trace_find_hook(ts->parent.t, "core", "irq_exit", NULL, NULL, NULL,
 232           before_execmode_hook, &g_array_index(hooks, LttvTraceHook, 5));
 233
 234       lttv_trace_find_hook(ts->parent.t, "core", "schedchange", "in", "out",
 235         "out_state", before_schedchange_hook,
 236         &g_array_index(hooks, LttvTraceHook, 6));
 237
 238       lttv_trace_find_hook(ts->parent.t, "core", "process", "event_sub_id",
 239           "event_data1", "event_data2", before_process_hook,
 240           &g_array_index(hooks, LttvTraceHook, 7));
 241
 242 #if 0
 243       lttv_trace_find_hook(ts->parent.t, "core", "process_fork", "child_pid",
 244           NULL, NULL, process_fork, &g_array_index(hooks, LttvTraceHook, 7));
 245
 246       lttv_trace_find_hook(ts->parent.t, "core", "process_exit", NULL, NULL,
 247           NULL, process_exit, &g_array_index(hooks, LttvTraceHook, 8));
 248 #endif //0
 249
 250       /* after hooks */
 251
 252       lttv_trace_find_hook(ts->parent.t, "core","syscall_entry","syscall_id",
 253     NULL, NULL, after_execmode_hook, &g_array_index(hooks, LttvTraceHook, 8));
 254
 255       lttv_trace_find_hook(ts->parent.t, "core", "syscall_exit", NULL, NULL,
 256           NULL, after_execmode_hook, &g_array_index(hooks, LttvTraceHook, 9));
 257
 258       lttv_trace_find_hook(ts->parent.t, "core", "trap_entry", "trap_id",
 259     NULL, NULL, after_execmode_hook, &g_array_index(hooks, LttvTraceHook, 10));
 260
 261       lttv_trace_find_hook(ts->parent.t, "core", "trap_exit", NULL, NULL, NULL,
 262           after_execmode_hook, &g_array_index(hooks, LttvTraceHook, 11));
 263
 264       lttv_trace_find_hook(ts->parent.t, "core", "irq_entry", "irq_id", NULL,
 265           NULL, after_execmode_hook, &g_array_index(hooks, LttvTraceHook, 12));
 266
 267       lttv_trace_find_hook(ts->parent.t, "core", "irq_exit", NULL, NULL, NULL,
 268           after_execmode_hook, &g_array_index(hooks, LttvTraceHook, 13));
 269
 270       lttv_trace_find_hook(ts->parent.t, "core", "schedchange", "in", "out",
 271         "out_state", after_schedchange_hook,
 272         &g_array_index(hooks, LttvTraceHook, 14));
 273
 274       lttv_trace_find_hook(ts->parent.t, "core", "process", "event_sub_id",
 275           "event_data1", "event_data2", after_process_hook,
 276           &g_array_index(hooks, LttvTraceHook, 15));
 277
 278 #if 0
 279       lttv_trace_find_hook(ts->parent.t, "core", "process_fork", "child_pid",
 280           NULL, NULL, process_fork, &g_array_index(hooks, LttvTraceHook, 7));
 281
 282       lttv_trace_find_hook(ts->parent.t, "core", "process_exit", NULL, NULL,
 283           NULL, process_exit, &g_array_index(hooks, LttvTraceHook, 8));
 284 #endif //0
 285
 286
 287
 288       /* Add these hooks to each event_by_id hooks list */
 289       /* add before */
 290       for(k = 0 ; k < hooks->len/2 ; k++) {
 291         hook = g_array_index(hooks, LttvTraceHook, k);
 292         lttv_hooks_add(lttv_hooks_by_id_find(event_by_id,
 293                         hook.id), hook.h,
 294                         events_request,
 295                         LTTV_PRIO_STATE-5);
 296       }
 297
 298       /* add after */
 299       for(k = hooks->len/2 ; k < hooks->len ; k++) {
 300         hook = g_array_index(hooks, LttvTraceHook, k);
 301         lttv_hooks_add(lttv_hooks_by_id_find(event_by_id,
 302                        hook.id), hook.h,
 303                        events_request,
 304                        LTTV_PRIO_STATE+5);
 305       }
 306
 307       events_request->hooks = hooks;
 308
 309       // Fill the events request
 310       events_request->owner = control_flow_data;
 311       events_request->viewer_data = control_flow_data;
 312       events_request->servicing = FALSE;
 313       events_request->start_time = start;
 314       events_request->start_position = NULL;
 315       events_request->stop_flag = FALSE;
 316       events_request->end_time = time_end;
 317       events_request->num_events = G_MAXUINT;
 318       events_request->end_position = NULL;
 319       events_request->trace = i;    /* FIXME */
 320       events_request->before_chunk_traceset = before_chunk_traceset;
 321       events_request->before_chunk_trace = NULL;
 322       events_request->before_chunk_tracefile = NULL;
 323       events_request->event = NULL;
 324       events_request->event_by_id = event_by_id;
 325       events_request->after_chunk_tracefile = NULL;
 326       events_request->after_chunk_trace = NULL;
 327       events_request->after_chunk_traceset = after_chunk_traceset;
 328       events_request->before_request = before_request_hook;
 329       events_request->after_request = after_request_hook;
 330
 331       g_debug("req : start : %u, %u", start.tv_sec,
 332                                           start.tv_nsec);
 333
 334       g_debug("req : end : %u, %u", time_end.tv_sec,
 335                                          time_end.tv_nsec);
 336
 337       lttvwindow_events_request(tab, events_request);
 338
 339     }
 340
 341   }
 342
 343 #if 0
 344   lttv_hooks_add(event,
 345                  before_schedchange_hook,
 346                  events_request,
 347                  LTTV_PRIO_STATE-5);
 348   lttv_hooks_add(event,
 349                  after_schedchange_hook,
 350                  events_request,
 351                  LTTV_PRIO_STATE+5);
 352   lttv_hooks_add(event,
 353                  before_execmode_hook,
 354                  events_request,
 355                  LTTV_PRIO_STATE-5);
 356   lttv_hooks_add(event,
 357                  after_execmode_hook,
 358                  events_request,
 359                  LTTV_PRIO_STATE+5);
 360   lttv_hooks_add(event,
 361                  before_process_hook,
 362                  events_request,
 363                  LTTV_PRIO_STATE-5);
 364   lttv_hooks_add(event,
 365                  after_process_hook,
 366                  events_request,
 367                  LTTV_PRIO_STATE+5);
 368 #endif //0
 369
 370 }
 371
 372
 373 static void set_last_start(gpointer key, gpointer value, gpointer user_data)
 374 {
 375   ProcessInfo *process_info = (ProcessInfo*)key;
 376   HashedProcessData *hashed_process_data = (HashedProcessData*)value;
 377   guint x = (guint)user_data;
 378
 379   hashed_process_data->x.over = x;
 380   hashed_process_data->x.over_used = FALSE;
 381   hashed_process_data->x.over_marked = FALSE;
 382   hashed_process_data->x.middle = x;
 383   hashed_process_data->x.middle_used = FALSE;
 384   hashed_process_data->x.middle_marked = FALSE;
 385   hashed_process_data->x.under = x;
 386   hashed_process_data->x.under_used = FALSE;
 387   hashed_process_data->x.under_marked = FALSE;
 388   hashed_process_data->next_good_time = ltt_time_zero;
 389
 390   return;
 391 }
 392
 393 void drawing_data_request_begin(EventsRequest *events_request, LttvTracesetState *tss)
 394 {
 395   g_debug("Begin of data request");
 396   ControlFlowData *cfd = events_request->viewer_data;
 397   LttvTracesetContext *tsc = LTTV_TRACESET_CONTEXT(tss);
 398   TimeWindow time_window =
 399     lttvwindow_get_time_window(cfd->tab);
 400   LttTime end_time = time_window.end_time;
 401
 402   guint width = cfd->drawing->width;
 403   guint x=0;
 404
 405   cfd->drawing->last_start = events_request->start_time;
 406
 407   convert_time_to_pixels(
 408           time_window,
 409           events_request->start_time,
 410           width,
 411           &x);
 412
 413   g_hash_table_foreach(cfd->process_list->process_hash, set_last_start,
 414                             (gpointer)x);
 415
 416   cfd->process_list->current_process_info = NULL;
 417   cfd->process_list->current_hash_data = NULL;
 418
 419 }
 420
 421 void drawing_chunk_begin(EventsRequest *events_request, LttvTracesetState *tss)
 422 {
 423   g_debug("Begin of chunk");
 424   ControlFlowData *cfd = events_request->viewer_data;
 425   LttvTracesetContext *tsc = LTTV_TRACESET_CONTEXT(tss);
 426   LttTime current_time = lttv_traceset_context_get_current_tfc(tsc)->timestamp;
 427
 428   //cfd->drawing->last_start = LTT_TIME_MIN(current_time,
 429   //                                        events_request->end_time);
 430 }
 431
 432
 433 void drawing_request_expose(EventsRequest *events_request,
 434                             LttvTracesetState *tss,
 435                             LttTime end_time)
 436 {
 437   gint x, x_end, width;
 438
 439   ControlFlowData *cfd = events_request->viewer_data;
 440   LttvTracesetContext *tsc = LTTV_TRACESET_CONTEXT(tss);
 441   Drawing_t *drawing = cfd->drawing;
 442
 443   TimeWindow time_window =
 444         lttvwindow_get_time_window(cfd->tab);
 445
 446   g_debug("request expose");
 447
 448   LttTime window_end = time_window.end_time;
 449
 450 #if 0
 451   convert_time_to_pixels(
 452         time_window,
 453         cfd->drawing->last_start,
 454         drawing->width,
 455         &x);
 456
 457 #endif //0
 458   convert_time_to_pixels(
 459         time_window,
 460         end_time,
 461         drawing->width,
 462         &x_end);
 463   x = drawing->damage_begin;
 464  // x_end = drawing->damage_end;
 465   width = x_end - x;
 466
 467   drawing->damage_begin = x+width;
 468   //drawing->damage_end = drawing->width;
 469
 470   /* ask for the buffer to be redrawn */
 471
 472   //gtk_widget_queue_draw_area ( drawing->drawing_area,
 473   //                             0, 0,
 474   //                             drawing->width, drawing->height);
 475
 476   /* FIXME
 477    * will need more precise pixel_to_time and time_to_pixel conversion
 478    * functions to redraw only the needed area. */
 479   gtk_widget_queue_draw_area ( drawing->drawing_area,
 480                                x, 0,
 481                                width, drawing->height);
 482
 483 }
 484
 485
 486 /* Callbacks */
 487
 488
 489 /* Create a new backing pixmap of the appropriate size */
 490 /* As the scaling will always change, it's of no use to copy old
 491  * pixmap.
 492  *
 493  * Only change the size if width changes. The height is specified and changed
 494  * when process ID are added or removed from the process list.
 495  */
 496 static gboolean
 497 configure_event( GtkWidget *widget, GdkEventConfigure *event,
 498     gpointer user_data)
 499 {
 500   Drawing_t *drawing = (Drawing_t*)user_data;
 501
 502
 503   /* First, get the new time interval of the main window */
 504   /* we assume (see documentation) that the main window
 505    * has updated the time interval before this configure gets
 506    * executed.
 507    */
 508   //lttvwindow_get_time_window(drawing->control_flow_data->mw,
 509   //      &drawing->control_flow_data->time_window);
 510
 511   /* New pixmap, size of the configure event */
 512   //GdkPixmap *pixmap = gdk_pixmap_new(widget->window,
 513   //      widget->allocation.width + SAFETY,
 514   //      widget->allocation.height + SAFETY,
 515   //      -1);
 516
 517   if(widget->allocation.width != drawing->width) {
 518     g_debug("drawing configure event");
 519     g_debug("New alloc draw size : %i by %i",widget->allocation.width,
 520                                     widget->allocation.height);
 521
 522
 523     if (drawing->pixmap)
 524       gdk_pixmap_unref(drawing->pixmap);
 525
 526     drawing->width = widget->allocation.width;
 527     //drawing->height = widget->allocation.height;
 528
 529     drawing->pixmap = gdk_pixmap_new(widget->window,
 530                                      drawing->width + SAFETY,
 531                                      drawing->height,
 532                                      -1);
 533     //ProcessList_get_height
 534     // (GuiControlFlow_get_process_list(drawing->control_flow_data)),
 535
 536
 537     // Clear the image
 538     gdk_draw_rectangle (drawing->pixmap,
 539           widget->style->black_gc,
 540           TRUE,
 541           0, 0,
 542           drawing->width+SAFETY,
 543           drawing->height);
 544
 545     //g_info("init data request");
 546
 547
 548     /* Initial data request */
 549     /* no, do initial data request in the expose event */
 550     // Do not need to ask for data of 1 pixel : not synchronized with
 551     // main window time at this moment.
 552     //drawing_data_request(drawing, &drawing->pixmap, 0, 0,
 553     //    widget->allocation.width,
 554     //    widget->allocation.height);
 555
 556     //drawing->width = widget->allocation.width;
 557     //drawing->height = widget->allocation.height;
 558
 559     drawing->damage_begin = 0;
 560     drawing->damage_end = widget->allocation.width;
 561
 562     if(drawing->damage_begin < drawing->damage_end)
 563     {
 564       drawing_data_request(drawing,
 565                            &drawing->pixmap,
 566                            drawing->damage_begin,
 567                            0,
 568                            drawing->damage_end - drawing->damage_begin,
 569                            drawing->height);
 570     }
 571   }
 572   return TRUE;
 573 }
 574
 575
 576 /* Redraw the screen from the backing pixmap */
 577 static gboolean
 578 expose_event( GtkWidget *widget, GdkEventExpose *event, gpointer user_data )
 579 {
 580   Drawing_t *drawing = (Drawing_t*)user_data;
 581
 582   ControlFlowData *control_flow_data =
 583       (ControlFlowData*)g_object_get_data(
 584                 G_OBJECT(widget),
 585                 "control_flow_data");
 586   if(drawing->gc == NULL) {
 587     drawing->gc = gdk_gc_new(drawing->drawing_area->window);
 588     gdk_gc_copy(drawing->gc, drawing->drawing_area->style->black_gc);
 589   }
 590
 591   TimeWindow time_window =
 592       lttvwindow_get_time_window(control_flow_data->tab);
 593   LttTime current_time =
 594       lttvwindow_get_current_time(control_flow_data->tab);
 595
 596   guint cursor_x=0;
 597
 598   LttTime window_end = time_window.end_time;
 599
 600   /* update the screen from the pixmap buffer */
 601   gdk_draw_pixmap(widget->window,
 602       widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
 603       drawing->pixmap,
 604       event->area.x, event->area.y,
 605       event->area.x, event->area.y,
 606       event->area.width, event->area.height);
 607
 608
 609   if(ltt_time_compare(time_window.start_time, current_time) <= 0 &&
 610            ltt_time_compare(window_end, current_time) >= 0)
 611   {
 612     /* Draw the dotted lines */
 613     convert_time_to_pixels(
 614           time_window,
 615           current_time,
 616           drawing->width,
 617           &cursor_x);
 618
 619
 620     if(drawing->dotted_gc == NULL) {
 621
 622       drawing->dotted_gc = gdk_gc_new(drawing->drawing_area->window);
 623       gdk_gc_copy(drawing->dotted_gc, widget->style->white_gc);
 624
 625       gint8 dash_list[] = { 1, 2 };
 626       gdk_gc_set_line_attributes(drawing->dotted_gc,
 627                                  1,
 628                                  GDK_LINE_ON_OFF_DASH,
 629                                  GDK_CAP_BUTT,
 630                                  GDK_JOIN_MITER);
 631       gdk_gc_set_dashes(drawing->dotted_gc,
 632                         0,
 633                         dash_list,
 634                         2);
 635     }
 636
 637     drawing_draw_line(NULL, widget->window,
 638                   cursor_x, 0,
 639                   cursor_x, drawing->height,
 640                   drawing->dotted_gc);
 641   }
 642   return FALSE;
 643 }
 644
 645 static gboolean
 646 after_expose_event( GtkWidget *widget, GdkEventExpose *event, gpointer user_data )
 647 {
 648   //g_assert(0);
 649   g_debug("AFTER EXPOSE");
 650
 651   return FALSE;
 652
 653
 654 }
 655
 656 #if 0
 657 void
 658 tree_row_activated(GtkTreeModel *treemodel,
 659                    GtkTreePath *arg1,
 660                    GtkTreeViewColumn *arg2,
 661                    gpointer user_data)
 662 {
 663   ControlFlowData *cfd = (ControlFlowData*)user_data;
 664   Drawing_t *drawing = cfd->drawing;
 665   GtkTreeView *treeview = cfd->process_list->process_list_widget;
 666   gint *path_indices;
 667   gint height;
 668
 669   path_indices =  gtk_tree_path_get_indices (arg1);
 670
 671   height = get_cell_height(cfd->process_list,
 672         GTK_TREE_VIEW(treeview));
 673   drawing->horizontal_sel = height * path_indices[0];
 674   g_critical("new hor sel : %i", drawing->horizontal_sel);
 675 }
 676 #endif //0
 677
 678 /* mouse click */
 679 static gboolean
 680 button_press_event( GtkWidget *widget, GdkEventButton *event, gpointer user_data )
 681 {
 682   ControlFlowData *control_flow_data =
 683       (ControlFlowData*)g_object_get_data(
 684                 G_OBJECT(widget),
 685                 "control_flow_data");
 686   Drawing_t *drawing = control_flow_data->drawing;
 687   TimeWindow time_window =
 688                lttvwindow_get_time_window(control_flow_data->tab);
 689
 690   g_debug("click");
 691   if(event->button == 1)
 692   {
 693     LttTime time;
 694
 695     LttTime window_end = time_window.end_time;
 696
 697
 698     /* left mouse button click */
 699     g_debug("x click is : %f", event->x);
 700
 701     convert_pixels_to_time(drawing->width, (guint)event->x,
 702         time_window,
 703         &time);
 704
 705     lttvwindow_report_current_time(control_flow_data->tab, time);
 706
 707   }
 708
 709   return FALSE;
 710 }
 711
 712 static gboolean
 713 scrollbar_size_allocate(GtkWidget *widget,
 714                         GtkAllocation *allocation,
 715                         gpointer user_data)
 716 {
 717   Drawing_t *drawing = (Drawing_t*)user_data;
 718
 719   gtk_widget_set_size_request(drawing->padding, allocation->width, -1);
 720   //gtk_widget_queue_resize(drawing->padding);
 721   //gtk_widget_queue_resize(drawing->ruler);
 722   gtk_container_check_resize(GTK_CONTAINER(drawing->ruler_hbox));
 723   return 0;
 724 }
 725
 726
 727
 728 Drawing_t *drawing_construct(ControlFlowData *control_flow_data)
 729 {
 730   Drawing_t *drawing = g_new(Drawing_t, 1);
 731
 732   drawing->control_flow_data = control_flow_data;
 733
 734   drawing->vbox = gtk_vbox_new(FALSE, 1);
 735
 736
 737   drawing->ruler_hbox = gtk_hbox_new(FALSE, 1);
 738   drawing->ruler = gtk_drawing_area_new ();
 739   //gtk_widget_set_size_request(drawing->ruler, -1, 27);
 740
 741   drawing->padding = gtk_drawing_area_new ();
 742   //gtk_widget_set_size_request(drawing->padding, -1, 27);
 743   gtk_box_pack_start(GTK_BOX(drawing->ruler_hbox), drawing->ruler,
 744                      TRUE, TRUE, 0);
 745   gtk_box_pack_end(GTK_BOX(drawing->ruler_hbox), drawing->padding,
 746                      FALSE, FALSE, 0);
 747
 748
 749
 750   drawing->drawing_area = gtk_drawing_area_new ();
 751
 752   drawing->gc = NULL;
 753
 754   drawing->hbox = gtk_hbox_new(FALSE, 1);
 755   drawing->viewport = gtk_viewport_new(NULL, control_flow_data->v_adjust);
 756   drawing->scrollbar = gtk_vscrollbar_new(control_flow_data->v_adjust);
 757   gtk_box_pack_start(GTK_BOX(drawing->hbox), drawing->viewport,
 758                      TRUE, TRUE, 0);
 759   gtk_box_pack_end(GTK_BOX(drawing->hbox), drawing->scrollbar,
 760                      FALSE, FALSE, 0);
 761
 762   //drawing->scrolled_window =
 763   //    gtk_scrolled_window_new (NULL,
 764   //    control_flow_data->v_adjust);
 765
 766   //gtk_scrolled_window_set_policy(
 767   //  GTK_SCROLLED_WINDOW(drawing->scrolled_window),
 768   //  GTK_POLICY_NEVER,
 769   //  GTK_POLICY_AUTOMATIC);
 770
 771   gtk_container_add(GTK_CONTAINER(drawing->viewport),
 772                     drawing->drawing_area);
 773   //gtk_scrolled_window_add_with_viewport(
 774   //  GTK_SCROLLED_WINDOW(drawing->scrolled_window),
 775   //  drawing->drawing_area);
 776
 777   gtk_box_pack_start(GTK_BOX(drawing->vbox), drawing->ruler_hbox,
 778                      FALSE, FALSE, 0);
 779   gtk_box_pack_end(GTK_BOX(drawing->vbox), drawing->hbox,
 780                    TRUE, TRUE, 0);
 781
 782   drawing->pango_layout =
 783     gtk_widget_create_pango_layout(drawing->drawing_area, NULL);
 784
 785   drawing->dotted_gc = NULL;
 786
 787   drawing->height = 1;
 788   drawing->width = 1;
 789   drawing->depth = 0;
 790
 791   drawing->damage_begin = 0;
 792   drawing->damage_end = 0;
 793   drawing->horizontal_sel = -1;
 794
 795   //gtk_widget_set_size_request(drawing->drawing_area->window, 50, 50);
 796   g_object_set_data_full(
 797       G_OBJECT(drawing->drawing_area),
 798       "Link_drawing_Data",
 799       drawing,
 800       (GDestroyNotify)drawing_destroy);
 801
 802   g_object_set_data(
 803       G_OBJECT(drawing->ruler),
 804       "drawing",
 805       drawing);
 806
 807
 808   //gtk_widget_modify_bg( drawing->drawing_area,
 809   //      GTK_STATE_NORMAL,
 810   //      &CF_Colors[BLACK]);
 811
 812   //gdk_window_get_geometry(drawing->drawing_area->window,
 813   //    NULL, NULL,
 814   //    &(drawing->width),
 815   //    &(drawing->height),
 816   //    -1);
 817
 818   //drawing->pixmap = gdk_pixmap_new(
 819   //    drawing->drawing_area->window,
 820   //    drawing->width,
 821   //    drawing->height,
 822   //    drawing->depth);
 823
 824   drawing->pixmap = NULL;
 825
 826 //  drawing->pixmap = gdk_pixmap_new(drawing->drawing_area->window,
 827 //        drawing->drawing_area->allocation.width,
 828 //        drawing->drawing_area->allocation.height,
 829 //        -1);
 830
 831   g_signal_connect (G_OBJECT(drawing->drawing_area),
 832         "configure_event",
 833         G_CALLBACK (configure_event),
 834         (gpointer)drawing);
 835
 836   g_signal_connect (G_OBJECT(drawing->ruler),
 837         "expose_event",
 838         G_CALLBACK(expose_ruler),
 839         (gpointer)drawing);
 840
 841   gtk_widget_add_events(drawing->ruler, GDK_POINTER_MOTION_MASK);
 842
 843   g_signal_connect (G_OBJECT(drawing->ruler),
 844         "motion-notify-event",
 845         G_CALLBACK(motion_notify_ruler),
 846         (gpointer)drawing);
 847
 848
 849   g_signal_connect (G_OBJECT(drawing->scrollbar),
 850         "size-allocate",
 851         G_CALLBACK(scrollbar_size_allocate),
 852         (gpointer)drawing);
 853
 854
 855
 856   g_signal_connect (G_OBJECT(drawing->drawing_area),
 857         "expose_event",
 858         G_CALLBACK (expose_event),
 859         (gpointer)drawing);
 860
 861   g_signal_connect_after (G_OBJECT(drawing->drawing_area),
 862         "expose_event",
 863         G_CALLBACK (after_expose_event),
 864         (gpointer)drawing);
 865
 866   g_signal_connect (G_OBJECT(drawing->drawing_area),
 867         "button-press-event",
 868         G_CALLBACK (button_press_event),
 869         (gpointer)drawing);
 870
 871   gtk_widget_show(drawing->ruler);
 872   gtk_widget_show(drawing->padding);
 873   gtk_widget_show(drawing->ruler_hbox);
 874
 875   gtk_widget_show(drawing->drawing_area);
 876   //gtk_widget_show(drawing->scrolled_window);
 877   gtk_widget_show(drawing->viewport);
 878   gtk_widget_show(drawing->scrollbar);
 879   gtk_widget_show(drawing->hbox);
 880
 881   /* Allocate the colors */
 882   GdkColormap* colormap = gdk_colormap_get_system();
 883   gboolean success[NUM_COLORS];
 884   gdk_colormap_alloc_colors(colormap, drawing_colors, NUM_COLORS, FALSE,
 885                             TRUE, success);
 886
 887   return drawing;
 888 }
 889
 890 void drawing_destroy(Drawing_t *drawing)
 891 {
 892   g_info("drawing_destroy %p", drawing);
 893
 894   /* Free the colors */
 895   GdkColormap* colormap = gdk_colormap_get_system();
 896
 897   gdk_colormap_free_colors(colormap, drawing_colors, NUM_COLORS);
 898
 899
 900
 901   // Do not unref here, Drawing_t destroyed by it's widget.
 902   //g_object_unref( G_OBJECT(drawing->drawing_area));
 903   if(drawing->gc != NULL)
 904     gdk_gc_unref(drawing->gc);
 905
 906   g_free(drawing->pango_layout);
 907   if(!drawing->dotted_gc) gdk_gc_unref(drawing->dotted_gc);
 908   g_free(drawing);
 909   g_info("drawing_destroy end");
 910 }
 911
 912 GtkWidget *drawing_get_drawing_area(Drawing_t *drawing)
 913 {
 914   return drawing->drawing_area;
 915 }
 916
 917 GtkWidget *drawing_get_widget(Drawing_t *drawing)
 918 {
 919   return drawing->vbox;
 920 }
 921
 922 /* convert_pixels_to_time
 923  *
 924  * Convert from window pixel and time interval to an absolute time.
 925  */
 926 __inline__ void convert_pixels_to_time(
 927     gint width,
 928     guint x,
 929     TimeWindow time_window,
 930     LttTime *time)
 931 {
 932   double time_d;
 933
 934   time_d = time_window.time_width_double;
 935   time_d = time_d / (double)width * (double)x;
 936   *time = ltt_time_from_double(time_d);
 937   *time = ltt_time_add(time_window.start_time, *time);
 938 }
 939
 940
 941 __inline__ void convert_time_to_pixels(
 942     TimeWindow time_window,
 943     LttTime time,
 944     int width,
 945     guint *x)
 946 {
 947   double time_d;
 948 #ifdef EXTRA_CHECK
 949   g_assert(ltt_time_compare(window_time_begin, time) <= 0 &&
 950            ltt_time_compare(window_time_end, time) >= 0);
 951 #endif //EXTRA_CHECK
 952
 953   time = ltt_time_sub(time, time_window.start_time);
 954
 955   time_d = ltt_time_to_double(time);
 956
 957   if(time_window.time_width_double == 0.0) {
 958     g_assert(time_d == 0.0);
 959     *x = 0;
 960   } else {
 961     *x = (guint)(time_d / time_window.time_width_double * (double)width);
 962   }
 963
 964 }
 965
 966 void drawing_draw_line( Drawing_t *drawing,
 967       GdkPixmap *pixmap,
 968       guint x1, guint y1,
 969       guint x2, guint y2,
 970       GdkGC *GC)
 971 {
 972   gdk_draw_line (pixmap,
 973       GC,
 974       x1, y1, x2, y2);
 975 }
 976
 977 void drawing_clear(Drawing_t *drawing)
 978 {
 979   if (drawing->pixmap)
 980     gdk_pixmap_unref(drawing->pixmap);
 981
 982   drawing->height = 1;
 983   /* Allocate a new pixmap with new height */
 984   drawing->pixmap = gdk_pixmap_new(drawing->drawing_area->window,
 985                                    drawing->width + SAFETY,
 986                                    drawing->height,
 987                                      -1);
 988
 989   gtk_widget_set_size_request(drawing->drawing_area,
 990                              -1,
 991                              drawing->height);
 992   gtk_widget_queue_resize_no_redraw(drawing->drawing_area);
 993
 994   /* ask for the buffer to be redrawn */
 995   gtk_widget_queue_draw_area ( drawing->drawing_area,
 996                                0, 0,
 997                                drawing->width, drawing->height);
 998 }
 999
1000
1001 /* Insert a square corresponding to a new process in the list */
1002 /* Applies to whole drawing->width */
1003 void drawing_insert_square(Drawing_t *drawing,
1004         guint y,
1005         guint height)
1006 {
1007   //GdkRectangle update_rect;
1008
1009   /* Allocate a new pixmap with new height */
1010   GdkPixmap *pixmap = gdk_pixmap_new(drawing->drawing_area->window,
1011         drawing->width + SAFETY,
1012         drawing->height + height,
1013         -1);
1014
1015   /* Copy the high region */
1016   gdk_draw_drawable (pixmap,
1017     drawing->drawing_area->style->black_gc,
1018     drawing->pixmap,
1019     0, 0,
1020     0, 0,
1021     drawing->width + SAFETY, y);
1022
1023
1024
1025
1026   /* add an empty square */
1027   gdk_draw_rectangle (pixmap,
1028     drawing->drawing_area->style->black_gc,
1029     TRUE,
1030     0, y,
1031     drawing->width + SAFETY,  // do not overlap
1032     height);
1033
1034
1035
1036   /* copy the bottom of the region */
1037   gdk_draw_drawable (pixmap,
1038     drawing->drawing_area->style->black_gc,
1039     drawing->pixmap,
1040     0, y,
1041     0, y + height,
1042     drawing->width+SAFETY, drawing->height - y);
1043
1044
1045   if (drawing->pixmap)
1046     gdk_pixmap_unref(drawing->pixmap);
1047
1048   drawing->pixmap = pixmap;
1049
1050   if(drawing->height==1) drawing->height = height;
1051   else drawing->height += height;
1052
1053   gtk_widget_set_size_request(drawing->drawing_area,
1054                              -1,
1055                              drawing->height);
1056   gtk_widget_queue_resize_no_redraw(drawing->drawing_area);
1057
1058   /* ask for the buffer to be redrawn */
1059   gtk_widget_queue_draw_area ( drawing->drawing_area,
1060                                0, y,
1061                                drawing->width, drawing->height-y);
1062 }
1063
1064
1065 /* Remove a square corresponding to a removed process in the list */
1066 void drawing_remove_square(Drawing_t *drawing,
1067         guint y,
1068         guint height)
1069 {
1070   GdkPixmap *pixmap;
1071
1072   if(drawing->height == height) {
1073     pixmap = gdk_pixmap_new(
1074         drawing->drawing_area->window,
1075         drawing->width + SAFETY,
1076         1,
1077         -1);
1078     drawing->height=1;
1079   } else {
1080     /* Allocate a new pixmap with new height */
1081      pixmap = gdk_pixmap_new(
1082         drawing->drawing_area->window,
1083         drawing->width + SAFETY,
1084         drawing->height - height,
1085         -1);
1086
1087     /* Copy the high region */
1088     gdk_draw_drawable (pixmap,
1089       drawing->drawing_area->style->black_gc,
1090       drawing->pixmap,
1091       0, 0,
1092       0, 0,
1093       drawing->width + SAFETY, y);
1094
1095     /* Copy up the bottom of the region */
1096     gdk_draw_drawable (pixmap,
1097       drawing->drawing_area->style->black_gc,
1098       drawing->pixmap,
1099       0, y + height,
1100       0, y,
1101       drawing->width, drawing->height - y - height);
1102
1103     drawing->height-=height;
1104   }
1105
1106   if (drawing->pixmap)
1107     gdk_pixmap_unref(drawing->pixmap);
1108
1109   drawing->pixmap = pixmap;
1110
1111   gtk_widget_set_size_request(drawing->drawing_area,
1112                              -1,
1113                              drawing->height);
1114   gtk_widget_queue_resize_no_redraw(drawing->drawing_area);
1115   /* ask for the buffer to be redrawn */
1116   gtk_widget_queue_draw_area ( drawing->drawing_area,
1117                                0, y,
1118                                drawing->width, MAX(drawing->height-y, 1));
1119 }
1120
1121 void drawing_update_ruler(Drawing_t *drawing, TimeWindow *time_window)
1122 {
1123   GtkRequisition req;
1124   GdkRectangle rect;
1125
1126   req.width = drawing->ruler->allocation.width;
1127   req.height = drawing->ruler->allocation.height;
1128
1129
1130   rect.x = 0;
1131   rect.y = 0;
1132   rect.width = req.width;
1133   rect.height = req.height;
1134
1135   gtk_widget_queue_draw(drawing->ruler);
1136   //gtk_widget_draw( drawing->ruler, &rect);
1137 }
1138
1139 /* Redraw the ruler */
1140 static gboolean
1141 expose_ruler( GtkWidget *widget, GdkEventExpose *event, gpointer user_data )
1142 {
1143   Drawing_t *drawing = (Drawing_t*)user_data;
1144   TimeWindow time_window = lttvwindow_get_time_window(drawing->control_flow_data->tab);
1145   gchar text[255];
1146
1147   PangoContext *context;
1148   PangoLayout *layout;
1149   PangoAttribute *attribute;
1150   PangoFontDescription *FontDesc;
1151   gint Font_Size;
1152   PangoRectangle ink_rect;
1153   guint global_width=0;
1154   GdkColor foreground = { 0, 0, 0, 0 };
1155   GdkColor background = { 0, 0xffff, 0xffff, 0xffff };
1156
1157   LttTime window_end = time_window.end_time;
1158   LttTime half_width =
1159     ltt_time_div(time_window.time_width,2.0);
1160   LttTime window_middle =
1161     ltt_time_add(half_width,
1162                  time_window.start_time);
1163   g_debug("ruler expose event");
1164
1165   gdk_draw_rectangle (drawing->ruler->window,
1166           drawing->ruler->style->white_gc,
1167           TRUE,
1168           event->area.x, event->area.y,
1169           event->area.width,
1170           event->area.height);
1171
1172    GdkGC *gc = gdk_gc_new(drawing->ruler->window);
1173    gdk_gc_copy(gc, drawing->ruler->style->black_gc);
1174    gdk_gc_set_line_attributes(gc,
1175                                2,
1176                                GDK_LINE_SOLID,
1177                                GDK_CAP_BUTT,
1178                                GDK_JOIN_MITER);
1179   gdk_draw_line (drawing->ruler->window,
1180                   gc,
1181                   event->area.x, 1,
1182                   event->area.x + event->area.width, 1);
1183
1184
1185   snprintf(text, 255, "%lus\n%luns",
1186     time_window.start_time.tv_sec,
1187     time_window.start_time.tv_nsec);
1188
1189   layout = gtk_widget_create_pango_layout(drawing->drawing_area, NULL);
1190
1191   context = pango_layout_get_context(layout);
1192   FontDesc = pango_context_get_font_description(context);
1193
1194   pango_font_description_set_size(FontDesc, 6*PANGO_SCALE);
1195   pango_layout_context_changed(layout);
1196
1197   pango_layout_set_text(layout, text, -1);
1198   pango_layout_get_pixel_extents(layout, &ink_rect, NULL);
1199   global_width += ink_rect.width;
1200
1201   gdk_draw_layout_with_colors(drawing->ruler->window,
1202       gc,
1203       0,
1204       6,
1205       layout, &foreground, &background);
1206
1207   gdk_gc_set_line_attributes(gc,
1208                              2,
1209                              GDK_LINE_SOLID,
1210                              GDK_CAP_ROUND,
1211                              GDK_JOIN_ROUND);
1212
1213   gdk_draw_line (drawing->ruler->window,
1214                    gc,
1215                    1, 1,
1216                    1, 7);
1217
1218
1219   snprintf(text, 255, "%lus\n%luns", window_end.tv_sec,
1220                                      window_end.tv_nsec);
1221
1222   pango_layout_set_text(layout, text, -1);
1223   pango_layout_get_pixel_extents(layout, &ink_rect, NULL);
1224   global_width += ink_rect.width;
1225
1226   if(global_width <= drawing->ruler->allocation.width)
1227   {
1228     gdk_draw_layout_with_colors(drawing->ruler->window,
1229       gc,
1230       drawing->ruler->allocation.width - ink_rect.width,
1231       6,
1232       layout, &foreground, &background);
1233
1234     gdk_gc_set_line_attributes(gc,
1235                                2,
1236                                GDK_LINE_SOLID,
1237                                GDK_CAP_ROUND,
1238                                GDK_JOIN_ROUND);
1239
1240     gdk_draw_line (drawing->ruler->window,
1241                    gc,
1242                    drawing->ruler->allocation.width-1, 1,
1243                    drawing->ruler->allocation.width-1, 7);
1244   }
1245
1246
1247   snprintf(text, 255, "%lus\n%luns", window_middle.tv_sec,
1248                                      window_middle.tv_nsec);
1249
1250   pango_layout_set_text(layout, text, -1);
1251   pango_layout_get_pixel_extents(layout, &ink_rect, NULL);
1252   global_width += ink_rect.width;
1253
1254   if(global_width <= drawing->ruler->allocation.width)
1255   {
1256     gdk_draw_layout_with_colors(drawing->ruler->window,
1257       gc,
1258       (drawing->ruler->allocation.width - ink_rect.width)/2,
1259       6,
1260       layout, &foreground, &background);
1261
1262     gdk_gc_set_line_attributes(gc,
1263                                2,
1264                                GDK_LINE_SOLID,
1265                                GDK_CAP_ROUND,
1266                                GDK_JOIN_ROUND);
1267
1268     gdk_draw_line (drawing->ruler->window,
1269                    gc,
1270                    drawing->ruler->allocation.width/2, 1,
1271                    drawing->ruler->allocation.width/2, 7);
1272
1273
1274
1275
1276   }
1277
1278   gdk_gc_unref(gc);
1279   g_object_unref(layout);
1280
1281   return FALSE;
1282 }
1283
1284
1285 /* notify mouse on ruler */
1286 static gboolean
1287 motion_notify_ruler(GtkWidget *widget, GdkEventMotion *event, gpointer user_data)
1288 {
1289   //g_debug("motion");
1290   //eventually follow mouse and show time here
1291 }