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