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