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