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
  37 GdkColor drawing_colors[NUM_COLORS] =
  38 { /* Pixel, R, G, B */
  39   { 0, 0, 0, 0 }, /* COL_BLACK */
  40   { 0, 0xFFFF, 0xFFFF, 0xFFFF }, /* COL_WHITE */
  41   { 0, 0x0fff, 0xffff, 0xfffF }, /* COL_WAIT_FORK : pale blue */
  42   { 0, 0xffff, 0xffff, 0x0000 }, /* COL_WAIT_CPU : yeallow */
  43   { 0, 0xffff, 0x0000, 0xffff }, /* COL_ZOMBIE : purple */
  44   { 0, 0xffff, 0x0000, 0x0000 }, /* COL_WAIT : red */
  45   { 0, 0x0000, 0xffff, 0x0000 }  /* COL_RUN : green */
  46 };
  47
  48
  49
  50 /*****************************************************************************
  51  *                              drawing functions                            *
  52  *****************************************************************************/
  53
  54 static gboolean
  55 expose_ruler( GtkWidget *widget, GdkEventExpose *event, gpointer user_data );
  56
  57 static gboolean
  58 motion_notify_ruler(GtkWidget *widget, GdkEventMotion *event, gpointer user_data);
  59
  60
  61 /* Function responsible for updating the exposed area.
  62  * It must do an events request to the lttvwindow API to ask for this update.
  63  * Note : this function cannot clear the background, because it may
  64  * erase drawing already present (SAFETY).
  65  */
  66 void drawing_data_request(Drawing_t *drawing,
  67       GdkPixmap **pixmap,
  68       gint x, gint y,
  69       gint width,
  70       gint height)
  71 {
  72   if(width < 0) return ;
  73   if(height < 0) return ;
  74
  75   if(drawing->gc == NULL) {
  76     drawing->gc = gdk_gc_new(drawing->drawing_area->window);
  77     gdk_gc_copy(drawing->gc, drawing->drawing_area->style->black_gc);
  78   }
  79
  80
  81
  82   TimeWindow time_window =
  83               lttvwindow_get_time_window(drawing->control_flow_data->tab);
  84
  85   ControlFlowData *control_flow_data = drawing->control_flow_data;
  86   Tab *tab = control_flow_data->tab;
  87   //    (ControlFlowData*)g_object_get_data(
  88   //               G_OBJECT(drawing->drawing_area), "control_flow_data");
  89
  90   LttTime start, time_end;
  91   LttTime window_end = ltt_time_add(time_window.time_width,
  92                                     time_window.start_time);
  93
  94   g_debug("req : window start_time : %u, %u", time_window.start_time.tv_sec,
  95                                        time_window.start_time.tv_nsec);
  96
  97   g_debug("req : window time width : %u, %u", time_window.time_width.tv_sec,
  98                                        time_window.time_width.tv_nsec);
  99
 100   g_debug("req : window_end : %u, %u", window_end.tv_sec,
 101                                        window_end.tv_nsec);
 102
 103   g_debug("x is : %i, x+width is : %i", x, x+width);
 104
 105   convert_pixels_to_time(drawing->width, x,
 106         time_window.start_time,
 107         window_end,
 108         &start);
 109
 110   convert_pixels_to_time(drawing->width, x+width,
 111         time_window.start_time,
 112         window_end,
 113         &time_end);
 114
 115   EventsRequest *events_request = g_new(EventsRequest, 1);
 116   // Create the hooks
 117   LttvHooks *event = lttv_hooks_new();
 118   LttvHooks *before_chunk_traceset = lttv_hooks_new();
 119   LttvHooks *after_chunk_traceset = lttv_hooks_new();
 120   LttvHooks *before_request_hook = lttv_hooks_new();
 121   LttvHooks *after_request_hook = lttv_hooks_new();
 122
 123   lttv_hooks_add(before_chunk_traceset,
 124                  before_chunk,
 125                  events_request,
 126                  LTTV_PRIO_DEFAULT);
 127
 128   lttv_hooks_add(after_chunk_traceset,
 129                  after_chunk,
 130                  events_request,
 131                  LTTV_PRIO_DEFAULT);
 132
 133   lttv_hooks_add(before_request_hook,
 134                  before_request,
 135                  events_request,
 136                  LTTV_PRIO_DEFAULT);
 137
 138   lttv_hooks_add(after_request_hook,
 139                  after_request,
 140                  events_request,
 141                  LTTV_PRIO_DEFAULT);
 142
 143   /* FIXME : hooks are registered global instead of by ID.
 144    * This is due to the lack of granularity of main window's events requests.
 145    * Should be fixed for gain of performance.
 146    */
 147   lttv_hooks_add(event,
 148                  before_schedchange_hook,
 149                  events_request,
 150                  LTTV_PRIO_STATE-5);
 151   lttv_hooks_add(event,
 152                  after_schedchange_hook,
 153                  events_request,
 154                  LTTV_PRIO_STATE+5);
 155   lttv_hooks_add(event,
 156                  after_fork_hook,
 157                  events_request,
 158                  LTTV_PRIO_STATE+5);
 159
 160   // Fill the events request
 161   events_request->owner = control_flow_data;
 162   events_request->viewer_data = control_flow_data;
 163   events_request->servicing = FALSE;
 164   events_request->start_time = start;
 165   events_request->start_position = NULL;
 166   events_request->stop_flag = FALSE;
 167   events_request->end_time = time_end;
 168   events_request->num_events = G_MAXUINT;
 169   events_request->end_position = NULL;
 170   events_request->before_chunk_traceset = before_chunk_traceset;
 171   events_request->before_chunk_trace = NULL;
 172   events_request->before_chunk_tracefile = NULL;
 173   events_request->event = event;
 174   events_request->event_by_id = NULL;
 175   events_request->after_chunk_tracefile = NULL;
 176   events_request->after_chunk_trace = NULL;
 177   events_request->after_chunk_traceset = after_chunk_traceset;
 178   events_request->before_request = before_request_hook;
 179   events_request->after_request = after_request_hook;
 180
 181   g_debug("req : start : %u, %u", start.tv_sec,
 182                                       start.tv_nsec);
 183
 184   g_debug("req : end : %u, %u", time_end.tv_sec,
 185                                      time_end.tv_nsec);
 186
 187   lttvwindow_events_request_remove_all(tab,
 188                                        control_flow_data);
 189   lttvwindow_events_request(tab, events_request);
 190 }
 191
 192
 193 static void set_last_start(gpointer key, gpointer value, gpointer user_data)
 194 {
 195   ProcessInfo *process_info = (ProcessInfo*)key;
 196   HashedProcessData *hashed_process_data = (HashedProcessData*)value;
 197   guint x = (guint)user_data;
 198
 199   hashed_process_data->x = x;
 200
 201   return;
 202 }
 203
 204 void drawing_data_request_begin(EventsRequest *events_request, LttvTracesetState *tss)
 205 {
 206   g_debug("Begin of data request");
 207   ControlFlowData *cfd = events_request->viewer_data;
 208   LttvTracesetContext *tsc = LTTV_TRACESET_CONTEXT(tss);
 209   TimeWindow time_window =
 210     lttvwindow_get_time_window(cfd->tab);
 211   LttTime end_time = ltt_time_add(time_window.start_time,
 212                                     time_window.time_width);
 213   guint width = cfd->drawing->width;
 214   guint x=0;
 215
 216   cfd->drawing->last_start = events_request->start_time;
 217
 218   convert_time_to_pixels(
 219           time_window.start_time,
 220           end_time,
 221           events_request->start_time,
 222           width,
 223           &x);
 224
 225   g_hash_table_foreach(cfd->process_list->process_hash, set_last_start,
 226                             (gpointer)x);
 227 }
 228
 229 void drawing_chunk_begin(EventsRequest *events_request, LttvTracesetState *tss)
 230 {
 231   g_debug("Begin of chunk");
 232   ControlFlowData *cfd = events_request->viewer_data;
 233   LttvTracesetContext *tsc = LTTV_TRACESET_CONTEXT(tss);
 234   LttTime current_time = lttv_traceset_context_get_current_tfc(tsc)->timestamp;
 235
 236   cfd->drawing->last_start = LTT_TIME_MIN(current_time,
 237                                           events_request->end_time);
 238 }
 239
 240
 241 void drawing_request_expose(EventsRequest *events_request,
 242                             LttvTracesetState *tss,
 243                             LttTime end_time)
 244 {
 245   gint x, x_end, width;
 246
 247   ControlFlowData *cfd = events_request->viewer_data;
 248   LttvTracesetContext *tsc = LTTV_TRACESET_CONTEXT(tss);
 249   Drawing_t *drawing = cfd->drawing;
 250
 251   TimeWindow time_window =
 252         lttvwindow_get_time_window(cfd->tab);
 253
 254   g_debug("request expose");
 255
 256   LttTime window_end = ltt_time_add(time_window.time_width,
 257                                     time_window.start_time);
 258
 259   convert_time_to_pixels(
 260         time_window.start_time,
 261         window_end,
 262         cfd->drawing->last_start,
 263         drawing->width,
 264         &x);
 265
 266   convert_time_to_pixels(
 267         time_window.start_time,
 268         window_end,
 269         end_time,
 270         drawing->width,
 271         &x_end);
 272
 273   width = x_end - x;
 274
 275   drawing->damage_begin = x+width;
 276   //drawing->damage_end = drawing->width;
 277
 278   /* ask for the buffer to be redrawn */
 279
 280   //gtk_widget_queue_draw_area ( drawing->drawing_area,
 281   //                             0, 0,
 282   //                             drawing->width, drawing->height);
 283
 284   /* FIXME
 285    * will need more precise pixel_to_time and time_to_pixel conversion
 286    * functions to redraw only the needed area. */
 287   gtk_widget_queue_draw_area ( drawing->drawing_area,
 288                                x, 0,
 289                                width, drawing->height);
 290
 291 }
 292
 293
 294 /* Callbacks */
 295
 296
 297 /* Create a new backing pixmap of the appropriate size */
 298 /* As the scaling will always change, it's of no use to copy old
 299  * pixmap.
 300  *
 301  * Only change the size if width changes. The height is specified and changed
 302  * when process ID are added or removed from the process list.
 303  */
 304 static gboolean
 305 configure_event( GtkWidget *widget, GdkEventConfigure *event,
 306     gpointer user_data)
 307 {
 308   Drawing_t *drawing = (Drawing_t*)user_data;
 309
 310
 311   /* First, get the new time interval of the main window */
 312   /* we assume (see documentation) that the main window
 313    * has updated the time interval before this configure gets
 314    * executed.
 315    */
 316   //lttvwindow_get_time_window(drawing->control_flow_data->mw,
 317   //      &drawing->control_flow_data->time_window);
 318
 319   /* New pixmap, size of the configure event */
 320   //GdkPixmap *pixmap = gdk_pixmap_new(widget->window,
 321   //      widget->allocation.width + SAFETY,
 322   //      widget->allocation.height + SAFETY,
 323   //      -1);
 324
 325   if(widget->allocation.width != drawing->width) {
 326     g_debug("drawing configure event");
 327     g_debug("New alloc draw size : %i by %i",widget->allocation.width,
 328                                     widget->allocation.height);
 329
 330
 331     if (drawing->pixmap)
 332       gdk_pixmap_unref(drawing->pixmap);
 333
 334     drawing->width = widget->allocation.width;
 335     //drawing->height = widget->allocation.height;
 336
 337     drawing->pixmap = gdk_pixmap_new(widget->window,
 338                                      drawing->width + SAFETY,
 339                                      drawing->height,
 340                                      -1);
 341     //ProcessList_get_height
 342     // (GuiControlFlow_get_process_list(drawing->control_flow_data)),
 343
 344
 345     // Clear the image
 346     gdk_draw_rectangle (drawing->pixmap,
 347           widget->style->black_gc,
 348           TRUE,
 349           0, 0,
 350           drawing->width+SAFETY,
 351           drawing->height);
 352
 353     //g_info("init data request");
 354
 355
 356     /* Initial data request */
 357     /* no, do initial data request in the expose event */
 358     // Do not need to ask for data of 1 pixel : not synchronized with
 359     // main window time at this moment.
 360     //drawing_data_request(drawing, &drawing->pixmap, 0, 0,
 361     //    widget->allocation.width,
 362     //    widget->allocation.height);
 363
 364     //drawing->width = widget->allocation.width;
 365     //drawing->height = widget->allocation.height;
 366
 367     drawing->damage_begin = 0;
 368     drawing->damage_end = widget->allocation.width;
 369
 370     if(drawing->damage_begin < drawing->damage_end)
 371     {
 372       drawing_data_request(drawing,
 373                            &drawing->pixmap,
 374                            drawing->damage_begin,
 375                            0,
 376                            drawing->damage_end - drawing->damage_begin,
 377                            drawing->height);
 378     }
 379   }
 380   return TRUE;
 381 }
 382
 383
 384 /* Redraw the screen from the backing pixmap */
 385 static gboolean
 386 expose_event( GtkWidget *widget, GdkEventExpose *event, gpointer user_data )
 387 {
 388   Drawing_t *drawing = (Drawing_t*)user_data;
 389
 390   ControlFlowData *control_flow_data =
 391       (ControlFlowData*)g_object_get_data(
 392                 G_OBJECT(widget),
 393                 "control_flow_data");
 394
 395   TimeWindow time_window =
 396       lttvwindow_get_time_window(control_flow_data->tab);
 397   LttTime current_time =
 398       lttvwindow_get_current_time(control_flow_data->tab);
 399
 400   guint cursor_x=0;
 401
 402   LttTime window_end = ltt_time_add(time_window.time_width,
 403                                     time_window.start_time);
 404
 405
 406   /* update the screen from the pixmap buffer */
 407   gdk_draw_pixmap(widget->window,
 408       widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
 409       drawing->pixmap,
 410       event->area.x, event->area.y,
 411       event->area.x, event->area.y,
 412       event->area.width, event->area.height);
 413
 414
 415   if(ltt_time_compare(time_window.start_time, current_time) <= 0 &&
 416            ltt_time_compare(window_end, current_time) >= 0)
 417   {
 418     /* Draw the dotted lines */
 419     convert_time_to_pixels(
 420           time_window.start_time,
 421           window_end,
 422           current_time,
 423           drawing->width,
 424           &cursor_x);
 425
 426
 427     if(drawing->dotted_gc == NULL) {
 428
 429       drawing->dotted_gc = gdk_gc_new(drawing->drawing_area->window);
 430       gdk_gc_copy(drawing->dotted_gc, widget->style->white_gc);
 431
 432       gint8 dash_list[] = { 1, 2 };
 433       gdk_gc_set_line_attributes(drawing->dotted_gc,
 434                                  1,
 435                                  GDK_LINE_ON_OFF_DASH,
 436                                  GDK_CAP_BUTT,
 437                                  GDK_JOIN_MITER);
 438       gdk_gc_set_dashes(drawing->dotted_gc,
 439                         0,
 440                         dash_list,
 441                         2);
 442     }
 443
 444     drawing_draw_line(NULL, widget->window,
 445                   cursor_x, 0,
 446                   cursor_x, drawing->height,
 447                   drawing->dotted_gc);
 448   }
 449   return FALSE;
 450 }
 451
 452 static gboolean
 453 after_expose_event( GtkWidget *widget, GdkEventExpose *event, gpointer user_data )
 454 {
 455   //g_assert(0);
 456   g_debug("AFTER EXPOSE");
 457
 458   return FALSE;
 459
 460
 461 }
 462
 463
 464 /* mouse click */
 465 static gboolean
 466 button_press_event( GtkWidget *widget, GdkEventButton *event, gpointer user_data )
 467 {
 468   ControlFlowData *control_flow_data =
 469       (ControlFlowData*)g_object_get_data(
 470                 G_OBJECT(widget),
 471                 "control_flow_data");
 472   Drawing_t *drawing = control_flow_data->drawing;
 473   TimeWindow time_window =
 474                lttvwindow_get_time_window(control_flow_data->tab);
 475
 476   g_debug("click");
 477   if(event->button == 1)
 478   {
 479     LttTime time;
 480
 481     LttTime window_end = ltt_time_add(time_window.time_width,
 482                                       time_window.start_time);
 483
 484
 485     /* left mouse button click */
 486     g_debug("x click is : %f", event->x);
 487
 488     convert_pixels_to_time(drawing->width, (guint)event->x,
 489         time_window.start_time,
 490         window_end,
 491         &time);
 492
 493     lttvwindow_report_current_time(control_flow_data->tab, time);
 494
 495   }
 496
 497   return FALSE;
 498 }
 499
 500 static gboolean
 501 scrollbar_size_allocate(GtkWidget *widget,
 502                         GtkAllocation *allocation,
 503                         gpointer user_data)
 504 {
 505   Drawing_t *drawing = (Drawing_t*)user_data;
 506
 507   gtk_widget_set_size_request(drawing->padding, allocation->width, -1);
 508   //gtk_widget_queue_resize(drawing->padding);
 509   //gtk_widget_queue_resize(drawing->ruler);
 510   gtk_container_check_resize(GTK_CONTAINER(drawing->ruler_hbox));
 511   return 0;
 512 }
 513
 514
 515
 516 Drawing_t *drawing_construct(ControlFlowData *control_flow_data)
 517 {
 518   Drawing_t *drawing = g_new(Drawing_t, 1);
 519
 520   drawing->control_flow_data = control_flow_data;
 521
 522   drawing->vbox = gtk_vbox_new(FALSE, 1);
 523
 524
 525   drawing->ruler_hbox = gtk_hbox_new(FALSE, 1);
 526   drawing->ruler = gtk_drawing_area_new ();
 527   //gtk_widget_set_size_request(drawing->ruler, -1, 27);
 528
 529   drawing->padding = gtk_drawing_area_new ();
 530   //gtk_widget_set_size_request(drawing->padding, -1, 27);
 531   gtk_box_pack_start(GTK_BOX(drawing->ruler_hbox), drawing->ruler,
 532                      TRUE, TRUE, 0);
 533   gtk_box_pack_end(GTK_BOX(drawing->ruler_hbox), drawing->padding,
 534                      FALSE, FALSE, 0);
 535
 536
 537
 538   drawing->drawing_area = gtk_drawing_area_new ();
 539
 540   drawing->gc = NULL;
 541
 542   drawing->hbox = gtk_hbox_new(FALSE, 1);
 543   drawing->viewport = gtk_viewport_new(NULL, control_flow_data->v_adjust);
 544   drawing->scrollbar = gtk_vscrollbar_new(control_flow_data->v_adjust);
 545   gtk_box_pack_start(GTK_BOX(drawing->hbox), drawing->viewport,
 546                      TRUE, TRUE, 0);
 547   gtk_box_pack_end(GTK_BOX(drawing->hbox), drawing->scrollbar,
 548                      FALSE, FALSE, 0);
 549
 550   //drawing->scrolled_window =
 551   //    gtk_scrolled_window_new (NULL,
 552   //    control_flow_data->v_adjust);
 553
 554   //gtk_scrolled_window_set_policy(
 555   //  GTK_SCROLLED_WINDOW(drawing->scrolled_window),
 556   //  GTK_POLICY_NEVER,
 557   //  GTK_POLICY_AUTOMATIC);
 558
 559   gtk_container_add(GTK_CONTAINER(drawing->viewport),
 560                     drawing->drawing_area);
 561   //gtk_scrolled_window_add_with_viewport(
 562   //  GTK_SCROLLED_WINDOW(drawing->scrolled_window),
 563   //  drawing->drawing_area);
 564
 565   gtk_box_pack_start(GTK_BOX(drawing->vbox), drawing->ruler_hbox,
 566                      FALSE, FALSE, 0);
 567   gtk_box_pack_end(GTK_BOX(drawing->vbox), drawing->hbox,
 568                    TRUE, TRUE, 0);
 569
 570   drawing->pango_layout =
 571     gtk_widget_create_pango_layout(drawing->drawing_area, NULL);
 572
 573   drawing->dotted_gc = NULL;
 574
 575   drawing->height = 1;
 576   drawing->width = 1;
 577   drawing->depth = 0;
 578
 579   drawing->damage_begin = 0;
 580   drawing->damage_end = 0;
 581
 582   //gtk_widget_set_size_request(drawing->drawing_area->window, 50, 50);
 583   g_object_set_data_full(
 584       G_OBJECT(drawing->drawing_area),
 585       "Link_drawing_Data",
 586       drawing,
 587       (GDestroyNotify)drawing_destroy);
 588
 589   g_object_set_data(
 590       G_OBJECT(drawing->ruler),
 591       "drawing",
 592       drawing);
 593
 594
 595   //gtk_widget_modify_bg( drawing->drawing_area,
 596   //      GTK_STATE_NORMAL,
 597   //      &CF_Colors[BLACK]);
 598
 599   //gdk_window_get_geometry(drawing->drawing_area->window,
 600   //    NULL, NULL,
 601   //    &(drawing->width),
 602   //    &(drawing->height),
 603   //    -1);
 604
 605   //drawing->pixmap = gdk_pixmap_new(
 606   //    drawing->drawing_area->window,
 607   //    drawing->width,
 608   //    drawing->height,
 609   //    drawing->depth);
 610
 611   drawing->pixmap = NULL;
 612
 613 //  drawing->pixmap = gdk_pixmap_new(drawing->drawing_area->window,
 614 //        drawing->drawing_area->allocation.width,
 615 //        drawing->drawing_area->allocation.height,
 616 //        -1);
 617
 618   g_signal_connect (G_OBJECT(drawing->drawing_area),
 619         "configure_event",
 620         G_CALLBACK (configure_event),
 621         (gpointer)drawing);
 622
 623   g_signal_connect (G_OBJECT(drawing->ruler),
 624         "expose_event",
 625         G_CALLBACK(expose_ruler),
 626         (gpointer)drawing);
 627
 628   gtk_widget_add_events(drawing->ruler, GDK_POINTER_MOTION_MASK);
 629
 630   g_signal_connect (G_OBJECT(drawing->ruler),
 631         "motion-notify-event",
 632         G_CALLBACK(motion_notify_ruler),
 633         (gpointer)drawing);
 634
 635
 636   g_signal_connect (G_OBJECT(drawing->scrollbar),
 637         "size-allocate",
 638         G_CALLBACK(scrollbar_size_allocate),
 639         (gpointer)drawing);
 640
 641
 642
 643   g_signal_connect (G_OBJECT(drawing->drawing_area),
 644         "expose_event",
 645         G_CALLBACK (expose_event),
 646         (gpointer)drawing);
 647
 648   g_signal_connect_after (G_OBJECT(drawing->drawing_area),
 649         "expose_event",
 650         G_CALLBACK (after_expose_event),
 651         (gpointer)drawing);
 652
 653   g_signal_connect (G_OBJECT(drawing->drawing_area),
 654         "button-press-event",
 655         G_CALLBACK (button_press_event),
 656         (gpointer)drawing);
 657
 658   gtk_widget_show(drawing->ruler);
 659   gtk_widget_show(drawing->padding);
 660   gtk_widget_show(drawing->ruler_hbox);
 661
 662   gtk_widget_show(drawing->drawing_area);
 663   //gtk_widget_show(drawing->scrolled_window);
 664   gtk_widget_show(drawing->viewport);
 665   gtk_widget_show(drawing->scrollbar);
 666   gtk_widget_show(drawing->hbox);
 667
 668
 669   return drawing;
 670 }
 671
 672 void drawing_destroy(Drawing_t *drawing)
 673 {
 674   g_info("drawing_destroy %p", drawing);
 675   // Do not unref here, Drawing_t destroyed by it's widget.
 676   //g_object_unref( G_OBJECT(drawing->drawing_area));
 677   if(drawing->gc != NULL)
 678     gdk_gc_unref(drawing->gc);
 679
 680   g_free(drawing->pango_layout);
 681   if(!drawing->dotted_gc) gdk_gc_unref(drawing->dotted_gc);
 682   g_free(drawing);
 683   g_info("drawing_destroy end");
 684 }
 685
 686 GtkWidget *drawing_get_drawing_area(Drawing_t *drawing)
 687 {
 688   return drawing->drawing_area;
 689 }
 690
 691 GtkWidget *drawing_get_widget(Drawing_t *drawing)
 692 {
 693   return drawing->vbox;
 694 }
 695
 696 /* convert_pixels_to_time
 697  *
 698  * Convert from window pixel and time interval to an absolute time.
 699  */
 700 //FIXME : could need ceil and floor versions of this function
 701 void convert_pixels_to_time(
 702     gint width,
 703     guint x,
 704     LttTime window_time_begin,
 705     LttTime window_time_end,
 706     LttTime *time)
 707 {
 708   LttTime window_time_interval;
 709
 710   window_time_interval = ltt_time_sub(window_time_end,
 711             window_time_begin);
 712   *time = ltt_time_mul(window_time_interval, (x/(float)width));
 713   *time = ltt_time_add(window_time_begin, *time);
 714 }
 715
 716 //FIXME : could need ceil and floor versions of this function
 717
 718 void convert_time_to_pixels(
 719     LttTime window_time_begin,
 720     LttTime window_time_end,
 721     LttTime time,
 722     int width,
 723     guint *x)
 724 {
 725   LttTime window_time_interval;
 726   double interval_double, time_double;
 727
 728   g_assert(ltt_time_compare(window_time_begin, time) <= 0 &&
 729            ltt_time_compare(window_time_end, time) >= 0);
 730
 731   window_time_interval = ltt_time_sub(window_time_end,window_time_begin);
 732
 733   time = ltt_time_sub(time, window_time_begin);
 734
 735   /* LttTime to double conversions here should really be under 4000 hours.. */
 736   interval_double = ltt_time_to_double(window_time_interval);
 737   time_double = ltt_time_to_double(time);
 738
 739   *x = (guint)(time_double/interval_double * width);
 740
 741 }
 742
 743 void drawing_draw_line( Drawing_t *drawing,
 744       GdkPixmap *pixmap,
 745       guint x1, guint y1,
 746       guint x2, guint y2,
 747       GdkGC *GC)
 748 {
 749   gdk_draw_line (pixmap,
 750       GC,
 751       x1, y1, x2, y2);
 752 }
 753
 754 void drawing_clear(Drawing_t *drawing)
 755 {
 756   if (drawing->pixmap)
 757     gdk_pixmap_unref(drawing->pixmap);
 758
 759   drawing->height = 1;
 760   /* Allocate a new pixmap with new height */
 761   drawing->pixmap = gdk_pixmap_new(drawing->drawing_area->window,
 762                                    drawing->width + SAFETY,
 763                                    drawing->height,
 764                                      -1);
 765
 766   gtk_widget_set_size_request(drawing->drawing_area,
 767                              -1,
 768                              drawing->height);
 769   gtk_widget_queue_resize_no_redraw(drawing->drawing_area);
 770
 771   /* ask for the buffer to be redrawn */
 772   gtk_widget_queue_draw_area ( drawing->drawing_area,
 773                                0, 0,
 774                                drawing->width, drawing->height);
 775 }
 776
 777
 778 /* Insert a square corresponding to a new process in the list */
 779 /* Applies to whole drawing->width */
 780 void drawing_insert_square(Drawing_t *drawing,
 781         guint y,
 782         guint height)
 783 {
 784   //GdkRectangle update_rect;
 785
 786   /* Allocate a new pixmap with new height */
 787   GdkPixmap *pixmap = gdk_pixmap_new(drawing->drawing_area->window,
 788         drawing->width + SAFETY,
 789         drawing->height + height,
 790         -1);
 791
 792   /* Copy the high region */
 793   gdk_draw_drawable (pixmap,
 794     drawing->drawing_area->style->black_gc,
 795     drawing->pixmap,
 796     0, 0,
 797     0, 0,
 798     drawing->width + SAFETY, y);
 799
 800
 801
 802
 803   /* add an empty square */
 804   gdk_draw_rectangle (pixmap,
 805     drawing->drawing_area->style->black_gc,
 806     TRUE,
 807     0, y,
 808     drawing->width + SAFETY,  // do not overlap
 809     height);
 810
 811
 812
 813   /* copy the bottom of the region */
 814   gdk_draw_drawable (pixmap,
 815     drawing->drawing_area->style->black_gc,
 816     drawing->pixmap,
 817     0, y,
 818     0, y + height,
 819     drawing->width+SAFETY, drawing->height - y);
 820
 821
 822   if (drawing->pixmap)
 823     gdk_pixmap_unref(drawing->pixmap);
 824
 825   drawing->pixmap = pixmap;
 826
 827   if(drawing->height==1) drawing->height = height;
 828   else drawing->height += height;
 829
 830   gtk_widget_set_size_request(drawing->drawing_area,
 831                              -1,
 832                              drawing->height);
 833   gtk_widget_queue_resize_no_redraw(drawing->drawing_area);
 834
 835   /* ask for the buffer to be redrawn */
 836   gtk_widget_queue_draw_area ( drawing->drawing_area,
 837                                0, y,
 838                                drawing->width, drawing->height-y);
 839 }
 840
 841
 842 /* Remove a square corresponding to a removed process in the list */
 843 void drawing_remove_square(Drawing_t *drawing,
 844         guint y,
 845         guint height)
 846 {
 847   GdkPixmap *pixmap;
 848
 849   if(drawing->height == height) {
 850     pixmap = gdk_pixmap_new(
 851         drawing->drawing_area->window,
 852         drawing->width + SAFETY,
 853         1,
 854         -1);
 855     drawing->height=1;
 856   } else {
 857     /* Allocate a new pixmap with new height */
 858      pixmap = gdk_pixmap_new(
 859         drawing->drawing_area->window,
 860         drawing->width + SAFETY,
 861         drawing->height - height,
 862         -1);
 863
 864     /* Copy the high region */
 865     gdk_draw_drawable (pixmap,
 866       drawing->drawing_area->style->black_gc,
 867       drawing->pixmap,
 868       0, 0,
 869       0, 0,
 870       drawing->width + SAFETY, y);
 871
 872     /* Copy up the bottom of the region */
 873     gdk_draw_drawable (pixmap,
 874       drawing->drawing_area->style->black_gc,
 875       drawing->pixmap,
 876       0, y + height,
 877       0, y,
 878       drawing->width, drawing->height - y - height);
 879
 880     drawing->height-=height;
 881   }
 882
 883   if (drawing->pixmap)
 884     gdk_pixmap_unref(drawing->pixmap);
 885
 886   drawing->pixmap = pixmap;
 887
 888   gtk_widget_set_size_request(drawing->drawing_area,
 889                              -1,
 890                              drawing->height);
 891   gtk_widget_queue_resize_no_redraw(drawing->drawing_area);
 892   /* ask for the buffer to be redrawn */
 893   gtk_widget_queue_draw_area ( drawing->drawing_area,
 894                                0, y,
 895                                drawing->width, MAX(drawing->height-y, 1));
 896 }
 897
 898 void drawing_update_ruler(Drawing_t *drawing, TimeWindow *time_window)
 899 {
 900   GtkRequisition req;
 901   GdkRectangle rect;
 902
 903   req.width = drawing->ruler->allocation.width;
 904   req.height = drawing->ruler->allocation.height;
 905
 906
 907   rect.x = 0;
 908   rect.y = 0;
 909   rect.width = req.width;
 910   rect.height = req.height;
 911
 912   gtk_widget_queue_draw(drawing->ruler);
 913   //gtk_widget_draw( drawing->ruler, &rect);
 914 }
 915
 916 /* Redraw the ruler */
 917 static gboolean
 918 expose_ruler( GtkWidget *widget, GdkEventExpose *event, gpointer user_data )
 919 {
 920   Drawing_t *drawing = (Drawing_t*)user_data;
 921   TimeWindow time_window = lttvwindow_get_time_window(drawing->control_flow_data->tab);
 922   gchar text[255];
 923
 924   PangoContext *context;
 925   PangoLayout *layout;
 926   PangoAttribute *attribute;
 927   PangoFontDescription *FontDesc;
 928   gint Font_Size;
 929   PangoRectangle ink_rect;
 930   guint global_width=0;
 931   GdkColor foreground = { 0, 0, 0, 0 };
 932   GdkColor background = { 0, 0xffff, 0xffff, 0xffff };
 933
 934   LttTime window_end =
 935     ltt_time_add(time_window.time_width,
 936                  time_window.start_time);
 937   LttTime half_width =
 938     ltt_time_div(time_window.time_width,2.0);
 939   LttTime window_middle =
 940     ltt_time_add(half_width,
 941                  time_window.start_time);
 942   g_debug("ruler expose event");
 943
 944   gdk_draw_rectangle (drawing->ruler->window,
 945           drawing->ruler->style->white_gc,
 946           TRUE,
 947           event->area.x, event->area.y,
 948           event->area.width,
 949           event->area.height);
 950
 951    GdkGC *gc = gdk_gc_new(drawing->ruler->window);
 952    gdk_gc_copy(gc, drawing->ruler->style->black_gc);
 953    gdk_gc_set_line_attributes(gc,
 954                                2,
 955                                GDK_LINE_SOLID,
 956                                GDK_CAP_BUTT,
 957                                GDK_JOIN_MITER);
 958   gdk_draw_line (drawing->ruler->window,
 959                   gc,
 960                   event->area.x, 1,
 961                   event->area.x + event->area.width, 1);
 962
 963
 964   snprintf(text, 255, "%lus\n%luns",
 965     time_window.start_time.tv_sec,
 966     time_window.start_time.tv_nsec);
 967
 968   layout = gtk_widget_create_pango_layout(drawing->drawing_area, NULL);
 969
 970   context = pango_layout_get_context(layout);
 971   FontDesc = pango_context_get_font_description(context);
 972
 973   pango_font_description_set_size(FontDesc, 6*PANGO_SCALE);
 974   pango_layout_context_changed(layout);
 975
 976   pango_layout_set_text(layout, text, -1);
 977   pango_layout_get_pixel_extents(layout, &ink_rect, NULL);
 978   global_width += ink_rect.width;
 979
 980   gdk_draw_layout_with_colors(drawing->ruler->window,
 981       gc,
 982       0,
 983       6,
 984       layout, &foreground, &background);
 985
 986   gdk_gc_set_line_attributes(gc,
 987                              2,
 988                              GDK_LINE_SOLID,
 989                              GDK_CAP_ROUND,
 990                              GDK_JOIN_ROUND);
 991
 992   gdk_draw_line (drawing->ruler->window,
 993                    gc,
 994                    1, 1,
 995                    1, 7);
 996
 997
 998   snprintf(text, 255, "%lus\n%luns", window_end.tv_sec,
 999                                      window_end.tv_nsec);
1000
1001   pango_layout_set_text(layout, text, -1);
1002   pango_layout_get_pixel_extents(layout, &ink_rect, NULL);
1003   global_width += ink_rect.width;
1004
1005   if(global_width <= drawing->ruler->allocation.width)
1006   {
1007     gdk_draw_layout_with_colors(drawing->ruler->window,
1008       gc,
1009       drawing->ruler->allocation.width - ink_rect.width,
1010       6,
1011       layout, &foreground, &background);
1012
1013     gdk_gc_set_line_attributes(gc,
1014                                2,
1015                                GDK_LINE_SOLID,
1016                                GDK_CAP_ROUND,
1017                                GDK_JOIN_ROUND);
1018
1019     gdk_draw_line (drawing->ruler->window,
1020                    gc,
1021                    drawing->ruler->allocation.width-1, 1,
1022                    drawing->ruler->allocation.width-1, 7);
1023   }
1024
1025
1026   snprintf(text, 255, "%lus\n%luns", window_middle.tv_sec,
1027                                      window_middle.tv_nsec);
1028
1029   pango_layout_set_text(layout, text, -1);
1030   pango_layout_get_pixel_extents(layout, &ink_rect, NULL);
1031   global_width += ink_rect.width;
1032
1033   if(global_width <= drawing->ruler->allocation.width)
1034   {
1035     gdk_draw_layout_with_colors(drawing->ruler->window,
1036       gc,
1037       (drawing->ruler->allocation.width - ink_rect.width)/2,
1038       6,
1039       layout, &foreground, &background);
1040
1041     gdk_gc_set_line_attributes(gc,
1042                                2,
1043                                GDK_LINE_SOLID,
1044                                GDK_CAP_ROUND,
1045                                GDK_JOIN_ROUND);
1046
1047     gdk_draw_line (drawing->ruler->window,
1048                    gc,
1049                    drawing->ruler->allocation.width/2, 1,
1050                    drawing->ruler->allocation.width/2, 7);
1051
1052
1053
1054
1055   }
1056
1057   gdk_gc_unref(gc);
1058   g_object_unref(layout);
1059
1060   return FALSE;
1061 }
1062
1063
1064 /* notify mouse on ruler */
1065 static gboolean
1066 motion_notify_ruler(GtkWidget *widget, GdkEventMotion *event, gpointer user_data)
1067 {
1068   //g_debug("motion");
1069   //eventually follow mouse and show time here
1070 }