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