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