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