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