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