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