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