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
 387   return;
 388 }
 389
 390 void drawing_data_request_begin(EventsRequest *events_request, LttvTracesetState *tss)
 391 {
 392   g_debug("Begin of data request");
 393   ControlFlowData *cfd = events_request->viewer_data;
 394   LttvTracesetContext *tsc = LTTV_TRACESET_CONTEXT(tss);
 395   TimeWindow time_window =
 396     lttvwindow_get_time_window(cfd->tab);
 397   LttTime end_time = time_window.end_time;
 398
 399   guint width = cfd->drawing->width;
 400   guint x=0;
 401
 402   cfd->drawing->last_start = events_request->start_time;
 403
 404   convert_time_to_pixels(
 405           time_window,
 406           events_request->start_time,
 407           width,
 408           &x);
 409
 410   g_hash_table_foreach(cfd->process_list->process_hash, set_last_start,
 411                             (gpointer)x);
 412 }
 413
 414 void drawing_chunk_begin(EventsRequest *events_request, LttvTracesetState *tss)
 415 {
 416   g_debug("Begin of chunk");
 417   ControlFlowData *cfd = events_request->viewer_data;
 418   LttvTracesetContext *tsc = LTTV_TRACESET_CONTEXT(tss);
 419   LttTime current_time = lttv_traceset_context_get_current_tfc(tsc)->timestamp;
 420
 421   //cfd->drawing->last_start = LTT_TIME_MIN(current_time,
 422   //                                        events_request->end_time);
 423 }
 424
 425
 426 void drawing_request_expose(EventsRequest *events_request,
 427                             LttvTracesetState *tss,
 428                             LttTime end_time)
 429 {
 430   gint x, x_end, width;
 431
 432   ControlFlowData *cfd = events_request->viewer_data;
 433   LttvTracesetContext *tsc = LTTV_TRACESET_CONTEXT(tss);
 434   Drawing_t *drawing = cfd->drawing;
 435
 436   TimeWindow time_window =
 437         lttvwindow_get_time_window(cfd->tab);
 438
 439   g_debug("request expose");
 440
 441   LttTime window_end = time_window.end_time;
 442
 443 #if 0
 444   convert_time_to_pixels(
 445         time_window,
 446         cfd->drawing->last_start,
 447         drawing->width,
 448         &x);
 449
 450 #endif //0
 451   convert_time_to_pixels(
 452         time_window,
 453         end_time,
 454         drawing->width,
 455         &x_end);
 456   x = drawing->damage_begin;
 457  // x_end = drawing->damage_end;
 458   width = x_end - x;
 459
 460   drawing->damage_begin = x+width;
 461   //drawing->damage_end = drawing->width;
 462
 463   /* ask for the buffer to be redrawn */
 464
 465   //gtk_widget_queue_draw_area ( drawing->drawing_area,
 466   //                             0, 0,
 467   //                             drawing->width, drawing->height);
 468
 469   /* FIXME
 470    * will need more precise pixel_to_time and time_to_pixel conversion
 471    * functions to redraw only the needed area. */
 472   gtk_widget_queue_draw_area ( drawing->drawing_area,
 473                                x, 0,
 474                                width, drawing->height);
 475
 476 }
 477
 478
 479 /* Callbacks */
 480
 481
 482 /* Create a new backing pixmap of the appropriate size */
 483 /* As the scaling will always change, it's of no use to copy old
 484  * pixmap.
 485  *
 486  * Only change the size if width changes. The height is specified and changed
 487  * when process ID are added or removed from the process list.
 488  */
 489 static gboolean
 490 configure_event( GtkWidget *widget, GdkEventConfigure *event,
 491     gpointer user_data)
 492 {
 493   Drawing_t *drawing = (Drawing_t*)user_data;
 494
 495
 496   /* First, get the new time interval of the main window */
 497   /* we assume (see documentation) that the main window
 498    * has updated the time interval before this configure gets
 499    * executed.
 500    */
 501   //lttvwindow_get_time_window(drawing->control_flow_data->mw,
 502   //      &drawing->control_flow_data->time_window);
 503
 504   /* New pixmap, size of the configure event */
 505   //GdkPixmap *pixmap = gdk_pixmap_new(widget->window,
 506   //      widget->allocation.width + SAFETY,
 507   //      widget->allocation.height + SAFETY,
 508   //      -1);
 509
 510   if(widget->allocation.width != drawing->width) {
 511     g_debug("drawing configure event");
 512     g_debug("New alloc draw size : %i by %i",widget->allocation.width,
 513                                     widget->allocation.height);
 514
 515
 516     if (drawing->pixmap)
 517       gdk_pixmap_unref(drawing->pixmap);
 518
 519     drawing->width = widget->allocation.width;
 520     //drawing->height = widget->allocation.height;
 521
 522     drawing->pixmap = gdk_pixmap_new(widget->window,
 523                                      drawing->width + SAFETY,
 524                                      drawing->height,
 525                                      -1);
 526     //ProcessList_get_height
 527     // (GuiControlFlow_get_process_list(drawing->control_flow_data)),
 528
 529
 530     // Clear the image
 531     gdk_draw_rectangle (drawing->pixmap,
 532           widget->style->black_gc,
 533           TRUE,
 534           0, 0,
 535           drawing->width+SAFETY,
 536           drawing->height);
 537
 538     //g_info("init data request");
 539
 540
 541     /* Initial data request */
 542     /* no, do initial data request in the expose event */
 543     // Do not need to ask for data of 1 pixel : not synchronized with
 544     // main window time at this moment.
 545     //drawing_data_request(drawing, &drawing->pixmap, 0, 0,
 546     //    widget->allocation.width,
 547     //    widget->allocation.height);
 548
 549     //drawing->width = widget->allocation.width;
 550     //drawing->height = widget->allocation.height;
 551
 552     drawing->damage_begin = 0;
 553     drawing->damage_end = widget->allocation.width;
 554
 555     if(drawing->damage_begin < drawing->damage_end)
 556     {
 557       drawing_data_request(drawing,
 558                            &drawing->pixmap,
 559                            drawing->damage_begin,
 560                            0,
 561                            drawing->damage_end - drawing->damage_begin,
 562                            drawing->height);
 563     }
 564   }
 565   return TRUE;
 566 }
 567
 568
 569 /* Redraw the screen from the backing pixmap */
 570 static gboolean
 571 expose_event( GtkWidget *widget, GdkEventExpose *event, gpointer user_data )
 572 {
 573   Drawing_t *drawing = (Drawing_t*)user_data;
 574
 575   ControlFlowData *control_flow_data =
 576       (ControlFlowData*)g_object_get_data(
 577                 G_OBJECT(widget),
 578                 "control_flow_data");
 579   if(drawing->gc == NULL) {
 580     drawing->gc = gdk_gc_new(drawing->drawing_area->window);
 581     gdk_gc_copy(drawing->gc, drawing->drawing_area->style->black_gc);
 582   }
 583
 584   TimeWindow time_window =
 585       lttvwindow_get_time_window(control_flow_data->tab);
 586   LttTime current_time =
 587       lttvwindow_get_current_time(control_flow_data->tab);
 588
 589   guint cursor_x=0;
 590
 591   LttTime window_end = time_window.end_time;
 592
 593   /* update the screen from the pixmap buffer */
 594   gdk_draw_pixmap(widget->window,
 595       widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
 596       drawing->pixmap,
 597       event->area.x, event->area.y,
 598       event->area.x, event->area.y,
 599       event->area.width, event->area.height);
 600
 601
 602   if(ltt_time_compare(time_window.start_time, current_time) <= 0 &&
 603            ltt_time_compare(window_end, current_time) >= 0)
 604   {
 605     /* Draw the dotted lines */
 606     convert_time_to_pixels(
 607           time_window,
 608           current_time,
 609           drawing->width,
 610           &cursor_x);
 611
 612
 613     if(drawing->dotted_gc == NULL) {
 614
 615       drawing->dotted_gc = gdk_gc_new(drawing->drawing_area->window);
 616       gdk_gc_copy(drawing->dotted_gc, widget->style->white_gc);
 617
 618       gint8 dash_list[] = { 1, 2 };
 619       gdk_gc_set_line_attributes(drawing->dotted_gc,
 620                                  1,
 621                                  GDK_LINE_ON_OFF_DASH,
 622                                  GDK_CAP_BUTT,
 623                                  GDK_JOIN_MITER);
 624       gdk_gc_set_dashes(drawing->dotted_gc,
 625                         0,
 626                         dash_list,
 627                         2);
 628     }
 629
 630     drawing_draw_line(NULL, widget->window,
 631                   cursor_x, 0,
 632                   cursor_x, drawing->height,
 633                   drawing->dotted_gc);
 634   }
 635   return FALSE;
 636 }
 637
 638 static gboolean
 639 after_expose_event( GtkWidget *widget, GdkEventExpose *event, gpointer user_data )
 640 {
 641   //g_assert(0);
 642   g_debug("AFTER EXPOSE");
 643
 644   return FALSE;
 645
 646
 647 }
 648
 649 #if 0
 650 void
 651 tree_row_activated(GtkTreeModel *treemodel,
 652                    GtkTreePath *arg1,
 653                    GtkTreeViewColumn *arg2,
 654                    gpointer user_data)
 655 {
 656   ControlFlowData *cfd = (ControlFlowData*)user_data;
 657   Drawing_t *drawing = cfd->drawing;
 658   GtkTreeView *treeview = cfd->process_list->process_list_widget;
 659   gint *path_indices;
 660   gint height;
 661
 662   path_indices =  gtk_tree_path_get_indices (arg1);
 663
 664   height = get_cell_height(cfd->process_list,
 665         GTK_TREE_VIEW(treeview));
 666   drawing->horizontal_sel = height * path_indices[0];
 667   g_critical("new hor sel : %i", drawing->horizontal_sel);
 668 }
 669 #endif //0
 670
 671 /* mouse click */
 672 static gboolean
 673 button_press_event( GtkWidget *widget, GdkEventButton *event, gpointer user_data )
 674 {
 675   ControlFlowData *control_flow_data =
 676       (ControlFlowData*)g_object_get_data(
 677                 G_OBJECT(widget),
 678                 "control_flow_data");
 679   Drawing_t *drawing = control_flow_data->drawing;
 680   TimeWindow time_window =
 681                lttvwindow_get_time_window(control_flow_data->tab);
 682
 683   g_debug("click");
 684   if(event->button == 1)
 685   {
 686     LttTime time;
 687
 688     LttTime window_end = time_window.end_time;
 689
 690
 691     /* left mouse button click */
 692     g_debug("x click is : %f", event->x);
 693
 694     convert_pixels_to_time(drawing->width, (guint)event->x,
 695         time_window,
 696         &time);
 697
 698     lttvwindow_report_current_time(control_flow_data->tab, time);
 699
 700   }
 701
 702   return FALSE;
 703 }
 704
 705 static gboolean
 706 scrollbar_size_allocate(GtkWidget *widget,
 707                         GtkAllocation *allocation,
 708                         gpointer user_data)
 709 {
 710   Drawing_t *drawing = (Drawing_t*)user_data;
 711
 712   gtk_widget_set_size_request(drawing->padding, allocation->width, -1);
 713   //gtk_widget_queue_resize(drawing->padding);
 714   //gtk_widget_queue_resize(drawing->ruler);
 715   gtk_container_check_resize(GTK_CONTAINER(drawing->ruler_hbox));
 716   return 0;
 717 }
 718
 719
 720
 721 Drawing_t *drawing_construct(ControlFlowData *control_flow_data)
 722 {
 723   Drawing_t *drawing = g_new(Drawing_t, 1);
 724
 725   drawing->control_flow_data = control_flow_data;
 726
 727   drawing->vbox = gtk_vbox_new(FALSE, 1);
 728
 729
 730   drawing->ruler_hbox = gtk_hbox_new(FALSE, 1);
 731   drawing->ruler = gtk_drawing_area_new ();
 732   //gtk_widget_set_size_request(drawing->ruler, -1, 27);
 733
 734   drawing->padding = gtk_drawing_area_new ();
 735   //gtk_widget_set_size_request(drawing->padding, -1, 27);
 736   gtk_box_pack_start(GTK_BOX(drawing->ruler_hbox), drawing->ruler,
 737                      TRUE, TRUE, 0);
 738   gtk_box_pack_end(GTK_BOX(drawing->ruler_hbox), drawing->padding,
 739                      FALSE, FALSE, 0);
 740
 741
 742
 743   drawing->drawing_area = gtk_drawing_area_new ();
 744
 745   drawing->gc = NULL;
 746
 747   drawing->hbox = gtk_hbox_new(FALSE, 1);
 748   drawing->viewport = gtk_viewport_new(NULL, control_flow_data->v_adjust);
 749   drawing->scrollbar = gtk_vscrollbar_new(control_flow_data->v_adjust);
 750   gtk_box_pack_start(GTK_BOX(drawing->hbox), drawing->viewport,
 751                      TRUE, TRUE, 0);
 752   gtk_box_pack_end(GTK_BOX(drawing->hbox), drawing->scrollbar,
 753                      FALSE, FALSE, 0);
 754
 755   //drawing->scrolled_window =
 756   //    gtk_scrolled_window_new (NULL,
 757   //    control_flow_data->v_adjust);
 758
 759   //gtk_scrolled_window_set_policy(
 760   //  GTK_SCROLLED_WINDOW(drawing->scrolled_window),
 761   //  GTK_POLICY_NEVER,
 762   //  GTK_POLICY_AUTOMATIC);
 763
 764   gtk_container_add(GTK_CONTAINER(drawing->viewport),
 765                     drawing->drawing_area);
 766   //gtk_scrolled_window_add_with_viewport(
 767   //  GTK_SCROLLED_WINDOW(drawing->scrolled_window),
 768   //  drawing->drawing_area);
 769
 770   gtk_box_pack_start(GTK_BOX(drawing->vbox), drawing->ruler_hbox,
 771                      FALSE, FALSE, 0);
 772   gtk_box_pack_end(GTK_BOX(drawing->vbox), drawing->hbox,
 773                    TRUE, TRUE, 0);
 774
 775   drawing->pango_layout =
 776     gtk_widget_create_pango_layout(drawing->drawing_area, NULL);
 777
 778   drawing->dotted_gc = NULL;
 779
 780   drawing->height = 1;
 781   drawing->width = 1;
 782   drawing->depth = 0;
 783
 784   drawing->damage_begin = 0;
 785   drawing->damage_end = 0;
 786   drawing->horizontal_sel = -1;
 787
 788   //gtk_widget_set_size_request(drawing->drawing_area->window, 50, 50);
 789   g_object_set_data_full(
 790       G_OBJECT(drawing->drawing_area),
 791       "Link_drawing_Data",
 792       drawing,
 793       (GDestroyNotify)drawing_destroy);
 794
 795   g_object_set_data(
 796       G_OBJECT(drawing->ruler),
 797       "drawing",
 798       drawing);
 799
 800
 801   //gtk_widget_modify_bg( drawing->drawing_area,
 802   //      GTK_STATE_NORMAL,
 803   //      &CF_Colors[BLACK]);
 804
 805   //gdk_window_get_geometry(drawing->drawing_area->window,
 806   //    NULL, NULL,
 807   //    &(drawing->width),
 808   //    &(drawing->height),
 809   //    -1);
 810
 811   //drawing->pixmap = gdk_pixmap_new(
 812   //    drawing->drawing_area->window,
 813   //    drawing->width,
 814   //    drawing->height,
 815   //    drawing->depth);
 816
 817   drawing->pixmap = NULL;
 818
 819 //  drawing->pixmap = gdk_pixmap_new(drawing->drawing_area->window,
 820 //        drawing->drawing_area->allocation.width,
 821 //        drawing->drawing_area->allocation.height,
 822 //        -1);
 823
 824   g_signal_connect (G_OBJECT(drawing->drawing_area),
 825         "configure_event",
 826         G_CALLBACK (configure_event),
 827         (gpointer)drawing);
 828
 829   g_signal_connect (G_OBJECT(drawing->ruler),
 830         "expose_event",
 831         G_CALLBACK(expose_ruler),
 832         (gpointer)drawing);
 833
 834   gtk_widget_add_events(drawing->ruler, GDK_POINTER_MOTION_MASK);
 835
 836   g_signal_connect (G_OBJECT(drawing->ruler),
 837         "motion-notify-event",
 838         G_CALLBACK(motion_notify_ruler),
 839         (gpointer)drawing);
 840
 841
 842   g_signal_connect (G_OBJECT(drawing->scrollbar),
 843         "size-allocate",
 844         G_CALLBACK(scrollbar_size_allocate),
 845         (gpointer)drawing);
 846
 847
 848
 849   g_signal_connect (G_OBJECT(drawing->drawing_area),
 850         "expose_event",
 851         G_CALLBACK (expose_event),
 852         (gpointer)drawing);
 853
 854   g_signal_connect_after (G_OBJECT(drawing->drawing_area),
 855         "expose_event",
 856         G_CALLBACK (after_expose_event),
 857         (gpointer)drawing);
 858
 859   g_signal_connect (G_OBJECT(drawing->drawing_area),
 860         "button-press-event",
 861         G_CALLBACK (button_press_event),
 862         (gpointer)drawing);
 863
 864   gtk_widget_show(drawing->ruler);
 865   gtk_widget_show(drawing->padding);
 866   gtk_widget_show(drawing->ruler_hbox);
 867
 868   gtk_widget_show(drawing->drawing_area);
 869   //gtk_widget_show(drawing->scrolled_window);
 870   gtk_widget_show(drawing->viewport);
 871   gtk_widget_show(drawing->scrollbar);
 872   gtk_widget_show(drawing->hbox);
 873
 874   /* Allocate the colors */
 875   GdkColormap* colormap = gdk_colormap_get_system();
 876   gboolean success[NUM_COLORS];
 877   gdk_colormap_alloc_colors(colormap, drawing_colors, NUM_COLORS, FALSE,
 878                             TRUE, success);
 879
 880   return drawing;
 881 }
 882
 883 void drawing_destroy(Drawing_t *drawing)
 884 {
 885   g_info("drawing_destroy %p", drawing);
 886
 887   /* Free the colors */
 888   GdkColormap* colormap = gdk_colormap_get_system();
 889
 890   gdk_colormap_free_colors(colormap, drawing_colors, NUM_COLORS);
 891
 892
 893
 894   // Do not unref here, Drawing_t destroyed by it's widget.
 895   //g_object_unref( G_OBJECT(drawing->drawing_area));
 896   if(drawing->gc != NULL)
 897     gdk_gc_unref(drawing->gc);
 898
 899   g_free(drawing->pango_layout);
 900   if(!drawing->dotted_gc) gdk_gc_unref(drawing->dotted_gc);
 901   g_free(drawing);
 902   g_info("drawing_destroy end");
 903 }
 904
 905 GtkWidget *drawing_get_drawing_area(Drawing_t *drawing)
 906 {
 907   return drawing->drawing_area;
 908 }
 909
 910 GtkWidget *drawing_get_widget(Drawing_t *drawing)
 911 {
 912   return drawing->vbox;
 913 }
 914
 915 /* convert_pixels_to_time
 916  *
 917  * Convert from window pixel and time interval to an absolute time.
 918  */
 919 __inline void convert_pixels_to_time(
 920     gint width,
 921     guint x,
 922     TimeWindow time_window,
 923     LttTime *time)
 924 {
 925   double time_d;
 926
 927   time_d = time_window.time_width_double;
 928   time_d = time_d / (double)width * (double)x;
 929   *time = ltt_time_from_double(time_d);
 930   *time = ltt_time_add(time_window.start_time, *time);
 931 }
 932
 933
 934 __inline void convert_time_to_pixels(
 935     TimeWindow time_window,
 936     LttTime time,
 937     int width,
 938     guint *x)
 939 {
 940   double time_d;
 941 #ifdef EXTRA_CHECK
 942   g_assert(ltt_time_compare(window_time_begin, time) <= 0 &&
 943            ltt_time_compare(window_time_end, time) >= 0);
 944 #endif //EXTRA_CHECK
 945
 946   time = ltt_time_sub(time, time_window.start_time);
 947
 948   time_d = ltt_time_to_double(time);
 949
 950   if(time_window.time_width_double == 0.0) {
 951     g_assert(time_d == 0.0);
 952     *x = 0;
 953   } else {
 954     *x = (guint)(time_d / time_window.time_width_double * (double)width);
 955   }
 956
 957 }
 958
 959 void drawing_draw_line( Drawing_t *drawing,
 960       GdkPixmap *pixmap,
 961       guint x1, guint y1,
 962       guint x2, guint y2,
 963       GdkGC *GC)
 964 {
 965   gdk_draw_line (pixmap,
 966       GC,
 967       x1, y1, x2, y2);
 968 }
 969
 970 void drawing_clear(Drawing_t *drawing)
 971 {
 972   if (drawing->pixmap)
 973     gdk_pixmap_unref(drawing->pixmap);
 974
 975   drawing->height = 1;
 976   /* Allocate a new pixmap with new height */
 977   drawing->pixmap = gdk_pixmap_new(drawing->drawing_area->window,
 978                                    drawing->width + SAFETY,
 979                                    drawing->height,
 980                                      -1);
 981
 982   gtk_widget_set_size_request(drawing->drawing_area,
 983                              -1,
 984                              drawing->height);
 985   gtk_widget_queue_resize_no_redraw(drawing->drawing_area);
 986
 987   /* ask for the buffer to be redrawn */
 988   gtk_widget_queue_draw_area ( drawing->drawing_area,
 989                                0, 0,
 990                                drawing->width, drawing->height);
 991 }
 992
 993
 994 /* Insert a square corresponding to a new process in the list */
 995 /* Applies to whole drawing->width */
 996 void drawing_insert_square(Drawing_t *drawing,
 997         guint y,
 998         guint height)
 999 {
1000   //GdkRectangle update_rect;
1001
1002   /* Allocate a new pixmap with new height */
1003   GdkPixmap *pixmap = gdk_pixmap_new(drawing->drawing_area->window,
1004         drawing->width + SAFETY,
1005         drawing->height + height,
1006         -1);
1007
1008   /* Copy the high region */
1009   gdk_draw_drawable (pixmap,
1010     drawing->drawing_area->style->black_gc,
1011     drawing->pixmap,
1012     0, 0,
1013     0, 0,
1014     drawing->width + SAFETY, y);
1015
1016
1017
1018
1019   /* add an empty square */
1020   gdk_draw_rectangle (pixmap,
1021     drawing->drawing_area->style->black_gc,
1022     TRUE,
1023     0, y,
1024     drawing->width + SAFETY,  // do not overlap
1025     height);
1026
1027
1028
1029   /* copy the bottom of the region */
1030   gdk_draw_drawable (pixmap,
1031     drawing->drawing_area->style->black_gc,
1032     drawing->pixmap,
1033     0, y,
1034     0, y + height,
1035     drawing->width+SAFETY, drawing->height - y);
1036
1037
1038   if (drawing->pixmap)
1039     gdk_pixmap_unref(drawing->pixmap);
1040
1041   drawing->pixmap = pixmap;
1042
1043   if(drawing->height==1) drawing->height = height;
1044   else drawing->height += height;
1045
1046   gtk_widget_set_size_request(drawing->drawing_area,
1047                              -1,
1048                              drawing->height);
1049   gtk_widget_queue_resize_no_redraw(drawing->drawing_area);
1050
1051   /* ask for the buffer to be redrawn */
1052   gtk_widget_queue_draw_area ( drawing->drawing_area,
1053                                0, y,
1054                                drawing->width, drawing->height-y);
1055 }
1056
1057
1058 /* Remove a square corresponding to a removed process in the list */
1059 void drawing_remove_square(Drawing_t *drawing,
1060         guint y,
1061         guint height)
1062 {
1063   GdkPixmap *pixmap;
1064
1065   if(drawing->height == height) {
1066     pixmap = gdk_pixmap_new(
1067         drawing->drawing_area->window,
1068         drawing->width + SAFETY,
1069         1,
1070         -1);
1071     drawing->height=1;
1072   } else {
1073     /* Allocate a new pixmap with new height */
1074      pixmap = gdk_pixmap_new(
1075         drawing->drawing_area->window,
1076         drawing->width + SAFETY,
1077         drawing->height - height,
1078         -1);
1079
1080     /* Copy the high region */
1081     gdk_draw_drawable (pixmap,
1082       drawing->drawing_area->style->black_gc,
1083       drawing->pixmap,
1084       0, 0,
1085       0, 0,
1086       drawing->width + SAFETY, y);
1087
1088     /* Copy up the bottom of the region */
1089     gdk_draw_drawable (pixmap,
1090       drawing->drawing_area->style->black_gc,
1091       drawing->pixmap,
1092       0, y + height,
1093       0, y,
1094       drawing->width, drawing->height - y - height);
1095
1096     drawing->height-=height;
1097   }
1098
1099   if (drawing->pixmap)
1100     gdk_pixmap_unref(drawing->pixmap);
1101
1102   drawing->pixmap = pixmap;
1103
1104   gtk_widget_set_size_request(drawing->drawing_area,
1105                              -1,
1106                              drawing->height);
1107   gtk_widget_queue_resize_no_redraw(drawing->drawing_area);
1108   /* ask for the buffer to be redrawn */
1109   gtk_widget_queue_draw_area ( drawing->drawing_area,
1110                                0, y,
1111                                drawing->width, MAX(drawing->height-y, 1));
1112 }
1113
1114 void drawing_update_ruler(Drawing_t *drawing, TimeWindow *time_window)
1115 {
1116   GtkRequisition req;
1117   GdkRectangle rect;
1118
1119   req.width = drawing->ruler->allocation.width;
1120   req.height = drawing->ruler->allocation.height;
1121
1122
1123   rect.x = 0;
1124   rect.y = 0;
1125   rect.width = req.width;
1126   rect.height = req.height;
1127
1128   gtk_widget_queue_draw(drawing->ruler);
1129   //gtk_widget_draw( drawing->ruler, &rect);
1130 }
1131
1132 /* Redraw the ruler */
1133 static gboolean
1134 expose_ruler( GtkWidget *widget, GdkEventExpose *event, gpointer user_data )
1135 {
1136   Drawing_t *drawing = (Drawing_t*)user_data;
1137   TimeWindow time_window = lttvwindow_get_time_window(drawing->control_flow_data->tab);
1138   gchar text[255];
1139
1140   PangoContext *context;
1141   PangoLayout *layout;
1142   PangoAttribute *attribute;
1143   PangoFontDescription *FontDesc;
1144   gint Font_Size;
1145   PangoRectangle ink_rect;
1146   guint global_width=0;
1147   GdkColor foreground = { 0, 0, 0, 0 };
1148   GdkColor background = { 0, 0xffff, 0xffff, 0xffff };
1149
1150   LttTime window_end = time_window.end_time;
1151   LttTime half_width =
1152     ltt_time_div(time_window.time_width,2.0);
1153   LttTime window_middle =
1154     ltt_time_add(half_width,
1155                  time_window.start_time);
1156   g_debug("ruler expose event");
1157
1158   gdk_draw_rectangle (drawing->ruler->window,
1159           drawing->ruler->style->white_gc,
1160           TRUE,
1161           event->area.x, event->area.y,
1162           event->area.width,
1163           event->area.height);
1164
1165    GdkGC *gc = gdk_gc_new(drawing->ruler->window);
1166    gdk_gc_copy(gc, drawing->ruler->style->black_gc);
1167    gdk_gc_set_line_attributes(gc,
1168                                2,
1169                                GDK_LINE_SOLID,
1170                                GDK_CAP_BUTT,
1171                                GDK_JOIN_MITER);
1172   gdk_draw_line (drawing->ruler->window,
1173                   gc,
1174                   event->area.x, 1,
1175                   event->area.x + event->area.width, 1);
1176
1177
1178   snprintf(text, 255, "%lus\n%luns",
1179     time_window.start_time.tv_sec,
1180     time_window.start_time.tv_nsec);
1181
1182   layout = gtk_widget_create_pango_layout(drawing->drawing_area, NULL);
1183
1184   context = pango_layout_get_context(layout);
1185   FontDesc = pango_context_get_font_description(context);
1186
1187   pango_font_description_set_size(FontDesc, 6*PANGO_SCALE);
1188   pango_layout_context_changed(layout);
1189
1190   pango_layout_set_text(layout, text, -1);
1191   pango_layout_get_pixel_extents(layout, &ink_rect, NULL);
1192   global_width += ink_rect.width;
1193
1194   gdk_draw_layout_with_colors(drawing->ruler->window,
1195       gc,
1196       0,
1197       6,
1198       layout, &foreground, &background);
1199
1200   gdk_gc_set_line_attributes(gc,
1201                              2,
1202                              GDK_LINE_SOLID,
1203                              GDK_CAP_ROUND,
1204                              GDK_JOIN_ROUND);
1205
1206   gdk_draw_line (drawing->ruler->window,
1207                    gc,
1208                    1, 1,
1209                    1, 7);
1210
1211
1212   snprintf(text, 255, "%lus\n%luns", window_end.tv_sec,
1213                                      window_end.tv_nsec);
1214
1215   pango_layout_set_text(layout, text, -1);
1216   pango_layout_get_pixel_extents(layout, &ink_rect, NULL);
1217   global_width += ink_rect.width;
1218
1219   if(global_width <= drawing->ruler->allocation.width)
1220   {
1221     gdk_draw_layout_with_colors(drawing->ruler->window,
1222       gc,
1223       drawing->ruler->allocation.width - ink_rect.width,
1224       6,
1225       layout, &foreground, &background);
1226
1227     gdk_gc_set_line_attributes(gc,
1228                                2,
1229                                GDK_LINE_SOLID,
1230                                GDK_CAP_ROUND,
1231                                GDK_JOIN_ROUND);
1232
1233     gdk_draw_line (drawing->ruler->window,
1234                    gc,
1235                    drawing->ruler->allocation.width-1, 1,
1236                    drawing->ruler->allocation.width-1, 7);
1237   }
1238
1239
1240   snprintf(text, 255, "%lus\n%luns", window_middle.tv_sec,
1241                                      window_middle.tv_nsec);
1242
1243   pango_layout_set_text(layout, text, -1);
1244   pango_layout_get_pixel_extents(layout, &ink_rect, NULL);
1245   global_width += ink_rect.width;
1246
1247   if(global_width <= drawing->ruler->allocation.width)
1248   {
1249     gdk_draw_layout_with_colors(drawing->ruler->window,
1250       gc,
1251       (drawing->ruler->allocation.width - ink_rect.width)/2,
1252       6,
1253       layout, &foreground, &background);
1254
1255     gdk_gc_set_line_attributes(gc,
1256                                2,
1257                                GDK_LINE_SOLID,
1258                                GDK_CAP_ROUND,
1259                                GDK_JOIN_ROUND);
1260
1261     gdk_draw_line (drawing->ruler->window,
1262                    gc,
1263                    drawing->ruler->allocation.width/2, 1,
1264                    drawing->ruler->allocation.width/2, 7);
1265
1266
1267
1268
1269   }
1270
1271   gdk_gc_unref(gc);
1272   g_object_unref(layout);
1273
1274   return FALSE;
1275 }
1276
1277
1278 /* notify mouse on ruler */
1279 static gboolean
1280 motion_notify_ruler(GtkWidget *widget, GdkEventMotion *event, gpointer user_data)
1281 {
1282   //g_debug("motion");
1283   //eventually follow mouse and show time here
1284 }