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