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