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