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