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