projects / lttv.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
desactivate ruler, preallocate pixmap
[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->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 if(ltt_time_compare(time_window.start_time, current_time) <= 0 &&
603 ltt_time_compare(window_end, current_time) >= 0)
604 {
605 /* Draw the dotted lines */
606 convert_time_to_pixels(
607 time_window,
608 current_time,
609 drawing->width,
610 &cursor_x);
611
612
613 if(drawing->dotted_gc == NULL) {
614
615 drawing->dotted_gc = gdk_gc_new(drawing->drawing_area->window);
616 gdk_gc_copy(drawing->dotted_gc, widget->style->white_gc);
617
618 gint8 dash_list[] = { 1, 2 };
619 gdk_gc_set_line_attributes(drawing->dotted_gc,
620 1,
621 GDK_LINE_ON_OFF_DASH,
622 GDK_CAP_BUTT,
623 GDK_JOIN_MITER);
624 gdk_gc_set_dashes(drawing->dotted_gc,
625 0,
626 dash_list,
627 2);
628 }
629
630 drawing_draw_line(NULL, widget->window,
631 cursor_x, 0,
632 cursor_x, drawing->drawing_area->allocation.height,
633 drawing->dotted_gc);
634 }
635 return FALSE;
636 }
637
638 static gboolean
639 after_expose_event( GtkWidget *widget, GdkEventExpose *event, gpointer user_data )
640 {
641 //g_assert(0);
642 g_debug("AFTER EXPOSE");
643
644 return FALSE;
645
646
647 }
648
649 #if 0
650 void
651 tree_row_activated(GtkTreeModel *treemodel,
652 GtkTreePath *arg1,
653 GtkTreeViewColumn *arg2,
654 gpointer user_data)
655 {
656 ControlFlowData *cfd = (ControlFlowData*)user_data;
657 Drawing_t *drawing = cfd->drawing;
658 GtkTreeView *treeview = cfd->process_list->process_list_widget;
659 gint *path_indices;
660 gint height;
661
662 path_indices = gtk_tree_path_get_indices (arg1);
663
664 height = get_cell_height(cfd->process_list,
665 GTK_TREE_VIEW(treeview));
666 drawing->horizontal_sel = height * path_indices[0];
667 g_critical("new hor sel : %i", drawing->horizontal_sel);
668 }
669 #endif //0
670
671 /* mouse click */
672 static gboolean
673 button_press_event( GtkWidget *widget, GdkEventButton *event, gpointer user_data )
674 {
675 ControlFlowData *control_flow_data =
676 (ControlFlowData*)g_object_get_data(
677 G_OBJECT(widget),
678 "control_flow_data");
679 Drawing_t *drawing = control_flow_data->drawing;
680 TimeWindow time_window =
681 lttvwindow_get_time_window(control_flow_data->tab);
682
683 g_debug("click");
684 if(event->button == 1)
685 {
686 LttTime time;
687
688 /* left mouse button click */
689 g_debug("x click is : %f", event->x);
690
691 convert_pixels_to_time(drawing->width, (guint)event->x,
692 time_window,
693 &time);
694
695 lttvwindow_report_current_time(control_flow_data->tab, time);
696
697 }
698
699 return FALSE;
700 }
701
702 static gboolean
703 scrollbar_size_allocate(GtkWidget *widget,
704 GtkAllocation *allocation,
705 gpointer user_data)
706 {
707 Drawing_t *drawing = (Drawing_t*)user_data;
708
709 gtk_widget_set_size_request(drawing->padding, allocation->width, -1);
710 //gtk_widget_queue_resize(drawing->padding);
711 //gtk_widget_queue_resize(drawing->ruler);
712 gtk_container_check_resize(GTK_CONTAINER(drawing->ruler_hbox));
713 return 0;
714 }
715
716
717
718 Drawing_t *drawing_construct(ControlFlowData *control_flow_data)
719 {
720 Drawing_t *drawing = g_new(Drawing_t, 1);
721
722 drawing->control_flow_data = control_flow_data;
723
724 drawing->vbox = gtk_vbox_new(FALSE, 1);
725
726
727 drawing->ruler_hbox = gtk_hbox_new(FALSE, 1);
728 drawing->ruler = gtk_drawing_area_new ();
729 //gtk_widget_set_size_request(drawing->ruler, -1, 27);
730
731 drawing->padding = gtk_drawing_area_new ();
732 //gtk_widget_set_size_request(drawing->padding, -1, 27);
733 gtk_box_pack_start(GTK_BOX(drawing->ruler_hbox), drawing->ruler,
734 TRUE, TRUE, 0);
735 gtk_box_pack_end(GTK_BOX(drawing->ruler_hbox), drawing->padding,
736 FALSE, FALSE, 0);
737
738
739
740 drawing->drawing_area = gtk_drawing_area_new ();
741
742 drawing->gc = NULL;
743
744 drawing->hbox = gtk_hbox_new(FALSE, 1);
745 drawing->viewport = gtk_viewport_new(NULL, control_flow_data->v_adjust);
746 drawing->scrollbar = gtk_vscrollbar_new(control_flow_data->v_adjust);
747 gtk_box_pack_start(GTK_BOX(drawing->hbox), drawing->viewport,
748 TRUE, TRUE, 0);
749 gtk_box_pack_end(GTK_BOX(drawing->hbox), drawing->scrollbar,
750 FALSE, FALSE, 0);
751
752 //drawing->scrolled_window =
753 // gtk_scrolled_window_new (NULL,
754 // control_flow_data->v_adjust);
755
756 //gtk_scrolled_window_set_policy(
757 // GTK_SCROLLED_WINDOW(drawing->scrolled_window),
758 // GTK_POLICY_NEVER,
759 // GTK_POLICY_AUTOMATIC);
760
761 gtk_container_add(GTK_CONTAINER(drawing->viewport),
762 drawing->drawing_area);
763 //gtk_scrolled_window_add_with_viewport(
764 // GTK_SCROLLED_WINDOW(drawing->scrolled_window),
765 // drawing->drawing_area);
766
767 gtk_box_pack_start(GTK_BOX(drawing->vbox), drawing->ruler_hbox,
768 FALSE, FALSE, 0);
769 gtk_box_pack_end(GTK_BOX(drawing->vbox), drawing->hbox,
770 TRUE, TRUE, 0);
771
772 drawing->pango_layout =
773 gtk_widget_create_pango_layout(drawing->drawing_area, NULL);
774
775 drawing->dotted_gc = NULL;
776
777 drawing->height = 1;
778 drawing->width = 1;
779 drawing->depth = 0;
780 drawing->alloc_height = 1;
781 drawing->alloc_width = 1;
782
783 drawing->damage_begin = 0;
784 drawing->damage_end = 0;
785 drawing->horizontal_sel = -1;
786
787 //gtk_widget_set_size_request(drawing->drawing_area->window, 50, 50);
788 g_object_set_data_full(
789 G_OBJECT(drawing->drawing_area),
790 "Link_drawing_Data",
791 drawing,
792 (GDestroyNotify)drawing_destroy);
793
794 g_object_set_data(
795 G_OBJECT(drawing->ruler),
796 "drawing",
797 drawing);
798
799
800 //gtk_widget_modify_bg( drawing->drawing_area,
801 // GTK_STATE_NORMAL,
802 // &CF_Colors[BLACK]);
803
804 //gdk_window_get_geometry(drawing->drawing_area->window,
805 // NULL, NULL,
806 // &(drawing->width),
807 // &(drawing->height),
808 // -1);
809
810 //drawing->pixmap = gdk_pixmap_new(
811 // drawing->drawing_area->window,
812 // drawing->width,
813 // drawing->height,
814 // drawing->depth);
815
816 drawing->pixmap = NULL;
817
818 // drawing->pixmap = gdk_pixmap_new(drawing->drawing_area->window,
819 // drawing->drawing_area->allocation.width,
820 // drawing->drawing_area->allocation.height,
821 // -1);
822
823 g_signal_connect (G_OBJECT(drawing->drawing_area),
824 "configure_event",
825 G_CALLBACK (configure_event),
826 (gpointer)drawing);
827
828 g_signal_connect (G_OBJECT(drawing->ruler),
829 "expose_event",
830 G_CALLBACK(expose_ruler),
831 (gpointer)drawing);
832
833 gtk_widget_add_events(drawing->ruler, GDK_POINTER_MOTION_MASK);
834
835 g_signal_connect (G_OBJECT(drawing->ruler),
836 "motion-notify-event",
837 G_CALLBACK(motion_notify_ruler),
838 (gpointer)drawing);
839
840
841 g_signal_connect (G_OBJECT(drawing->scrollbar),
842 "size-allocate",
843 G_CALLBACK(scrollbar_size_allocate),
844 (gpointer)drawing);
845
846
847
848 g_signal_connect (G_OBJECT(drawing->drawing_area),
849 "expose_event",
850 G_CALLBACK (expose_event),
851 (gpointer)drawing);
852
853 g_signal_connect_after (G_OBJECT(drawing->drawing_area),
854 "expose_event",
855 G_CALLBACK (after_expose_event),
856 (gpointer)drawing);
857
858 g_signal_connect (G_OBJECT(drawing->drawing_area),
859 "button-press-event",
860 G_CALLBACK (button_press_event),
861 (gpointer)drawing);
862
863 gtk_widget_show(drawing->ruler);
864 gtk_widget_show(drawing->padding);
865 gtk_widget_show(drawing->ruler_hbox);
866
867 gtk_widget_show(drawing->drawing_area);
868 //gtk_widget_show(drawing->scrolled_window);
869 gtk_widget_show(drawing->viewport);
870 gtk_widget_show(drawing->scrollbar);
871 gtk_widget_show(drawing->hbox);
872
873 /* Allocate the colors */
874 GdkColormap* colormap = gdk_colormap_get_system();
875 gboolean success[NUM_COLORS];
876 gdk_colormap_alloc_colors(colormap, drawing_colors, NUM_COLORS, FALSE,
877 TRUE, success);
878
879 return drawing;
880 }
881
882 void drawing_destroy(Drawing_t *drawing)
883 {
884 g_info("drawing_destroy %p", drawing);
885
886 /* Free the colors */
887 GdkColormap* colormap = gdk_colormap_get_system();
888
889 gdk_colormap_free_colors(colormap, drawing_colors, NUM_COLORS);
890
891
892
893 // Do not unref here, Drawing_t destroyed by it's widget.
894 //g_object_unref( G_OBJECT(drawing->drawing_area));
895 if(drawing->gc != NULL)
896 gdk_gc_unref(drawing->gc);
897
898 g_free(drawing->pango_layout);
899 if(!drawing->dotted_gc) gdk_gc_unref(drawing->dotted_gc);
900 g_free(drawing);
901 g_info("drawing_destroy end");
902 }
903
904 GtkWidget *drawing_get_drawing_area(Drawing_t *drawing)
905 {
906 return drawing->drawing_area;
907 }
908
909 GtkWidget *drawing_get_widget(Drawing_t *drawing)
910 {
911 return drawing->vbox;
912 }
913
914 void drawing_draw_line( Drawing_t *drawing,
915 GdkPixmap *pixmap,
916 guint x1, guint y1,
917 guint x2, guint y2,
918 GdkGC *GC)
919 {
920 gdk_draw_line (pixmap,
921 GC,
922 x1, y1, x2, y2);
923 }
924
925 void drawing_clear(Drawing_t *drawing)
926 {
927 if (drawing->pixmap)
928 gdk_pixmap_unref(drawing->pixmap);
929
930 drawing->height = 1;
931 /* Allocate a new pixmap with new height */
932 drawing->pixmap = gdk_pixmap_new(drawing->drawing_area->window,
933 drawing->width + SAFETY + EXTRA_ALLOC,
934 drawing->height + EXTRA_ALLOC,
935 -1);
936 drawing->alloc_width = drawing->width + SAFETY + EXTRA_ALLOC;
937 drawing->alloc_height = drawing->height + EXTRA_ALLOC;
938
939 gtk_widget_set_size_request(drawing->drawing_area,
940 -1,
941 drawing->height);
942 gtk_widget_queue_resize_no_redraw(drawing->drawing_area);
943
944 /* ask for the buffer to be redrawn */
945 gtk_widget_queue_draw_area ( drawing->drawing_area,
946 0, 0,
947 drawing->width, drawing->height);
948 }
949
950
951 /* Insert a square corresponding to a new process in the list */
952 /* Applies to whole drawing->width */
953 void drawing_insert_square(Drawing_t *drawing,
954 guint y,
955 guint height)
956 {
957 //GdkRectangle update_rect;
958 gboolean reallocate = FALSE;
959 GdkPixmap *new_pixmap;
960
961 /* Allocate a new pixmap with new height */
962 if(drawing->alloc_height < drawing->height + height) {
963
964 new_pixmap = gdk_pixmap_new(drawing->drawing_area->window,
965 drawing->width + SAFETY + EXTRA_ALLOC,
966 drawing->height + height + EXTRA_ALLOC,
967 -1);
968 drawing->alloc_width = drawing->width + SAFETY + EXTRA_ALLOC;
969 drawing->alloc_height = drawing->height + height + EXTRA_ALLOC;
970 reallocate = TRUE;
971
972 /* Copy the high region */
973 gdk_draw_drawable (new_pixmap,
974 drawing->drawing_area->style->black_gc,
975 drawing->pixmap,
976 0, 0,
977 0, 0,
978 drawing->width + SAFETY, y);
979
980 } else {
981 new_pixmap = drawing->pixmap;
982 }
983
984 //GdkPixmap *pixmap = gdk_pixmap_new(drawing->drawing_area->window,
985 // drawing->width + SAFETY,
986 // drawing->height + height,
987 // -1);
988
989 /* add an empty square */
990 gdk_draw_rectangle (new_pixmap,
991 drawing->drawing_area->style->black_gc,
992 TRUE,
993 0, y,
994 drawing->width + SAFETY, // do not overlap
995 height);
996
997 /* copy the bottom of the region */
998 gdk_draw_drawable (new_pixmap,
999 drawing->drawing_area->style->black_gc,
1000 drawing->pixmap,
1001 0, y,
1002 0, y + height,
1003 drawing->width+SAFETY, drawing->height - y);
1004
1005
1006 if(reallocate && likely(drawing->pixmap)) {
1007 gdk_pixmap_unref(drawing->pixmap);
1008 drawing->pixmap = new_pixmap;
1009 }
1010
1011 if(unlikely(drawing->height==1)) drawing->height = height;
1012 else drawing->height += height;
1013
1014 gtk_widget_set_size_request(drawing->drawing_area,
1015 -1,
1016 drawing->height);
1017 gtk_widget_queue_resize_no_redraw(drawing->drawing_area);
1018
1019 /* ask for the buffer to be redrawn */
1020 gtk_widget_queue_draw_area ( drawing->drawing_area,
1021 0, y,
1022 drawing->width, drawing->height-y);
1023 }
1024
1025
1026 /* Remove a square corresponding to a removed process in the list */
1027 void drawing_remove_square(Drawing_t *drawing,
1028 guint y,
1029 guint height)
1030 {
1031 GdkPixmap *pixmap;
1032
1033 if(unlikely((guint)drawing->height == height)) {
1034 //pixmap = gdk_pixmap_new(
1035 // drawing->drawing_area->window,
1036 // drawing->width + SAFETY,
1037 // 1,
1038 // -1);
1039 pixmap = drawing->pixmap;
1040 drawing->height=1;
1041 } else {
1042 /* Allocate a new pixmap with new height */
1043 //pixmap = gdk_pixmap_new(
1044 // drawing->drawing_area->window,
1045 // drawing->width + SAFETY,
1046 // drawing->height - height,
1047 // -1);
1048 /* Keep the same preallocated pixmap */
1049 pixmap = drawing->pixmap;
1050
1051 /* Copy the high region */
1052 gdk_draw_drawable (pixmap,
1053 drawing->drawing_area->style->black_gc,
1054 drawing->pixmap,
1055 0, 0,
1056 0, 0,
1057 drawing->width + SAFETY, y);
1058
1059 /* Copy up the bottom of the region */
1060 gdk_draw_drawable (pixmap,
1061 drawing->drawing_area->style->black_gc,
1062 drawing->pixmap,
1063 0, y + height,
1064 0, y,
1065 drawing->width, drawing->height - y - height);
1066
1067 drawing->height-=height;
1068 }
1069
1070 //if(likely(drawing->pixmap))
1071 // gdk_pixmap_unref(drawing->pixmap);
1072
1073 //drawing->pixmap = pixmap;
1074
1075 gtk_widget_set_size_request(drawing->drawing_area,
1076 -1,
1077 drawing->height);
1078 gtk_widget_queue_resize_no_redraw(drawing->drawing_area);
1079 /* ask for the buffer to be redrawn */
1080 gtk_widget_queue_draw_area ( drawing->drawing_area,
1081 0, y,
1082 drawing->width, MAX(drawing->height-y, 1));
1083 }
1084
1085 void drawing_update_ruler(Drawing_t *drawing, TimeWindow *time_window)
1086 {
1087 GtkRequisition req;
1088 GdkRectangle rect;
1089
1090 req.width = drawing->ruler->allocation.width;
1091 req.height = drawing->ruler->allocation.height;
1092
1093
1094 rect.x = 0;
1095 rect.y = 0;
1096 rect.width = req.width;
1097 rect.height = req.height;
1098
1099 gtk_widget_queue_draw(drawing->ruler);
1100 //gtk_widget_draw( drawing->ruler, &rect);
1101 }
1102
1103 /* Redraw the ruler */
1104 static gboolean
1105 expose_ruler( GtkWidget *widget, GdkEventExpose *event, gpointer user_data )
1106 {
1107 /* ruler desactivated */
1108 return 0;
1109 Drawing_t *drawing = (Drawing_t*)user_data;
1110 TimeWindow time_window = lttvwindow_get_time_window(drawing->control_flow_data->tab);
1111 gchar text[255];
1112
1113 PangoContext *context;
1114 PangoLayout *layout;
1115 PangoFontDescription *FontDesc;
1116 PangoRectangle ink_rect;
1117 gint global_width=0;
1118 GdkColor foreground = { 0, 0, 0, 0 };
1119 GdkColor background = { 0, 0xffff, 0xffff, 0xffff };
1120
1121 LttTime window_end = time_window.end_time;
1122 LttTime half_width =
1123 ltt_time_div(time_window.time_width,2.0);
1124 LttTime window_middle =
1125 ltt_time_add(half_width,
1126 time_window.start_time);
1127 g_debug("ruler expose event");
1128
1129 gdk_draw_rectangle (drawing->ruler->window,
1130 drawing->ruler->style->white_gc,
1131 TRUE,
1132 event->area.x, event->area.y,
1133 event->area.width,
1134 event->area.height);
1135
1136 GdkGC *gc = gdk_gc_new(drawing->ruler->window);
1137 gdk_gc_copy(gc, drawing->ruler->style->black_gc);
1138 gdk_gc_set_line_attributes(gc,
1139 2,
1140 GDK_LINE_SOLID,
1141 GDK_CAP_BUTT,
1142 GDK_JOIN_MITER);
1143 gdk_draw_line (drawing->ruler->window,
1144 gc,
1145 event->area.x, 1,
1146 event->area.x + event->area.width, 1);
1147
1148
1149 snprintf(text, 255, "%lus\n%luns",
1150 time_window.start_time.tv_sec,
1151 time_window.start_time.tv_nsec);
1152
1153 layout = gtk_widget_create_pango_layout(drawing->drawing_area, NULL);
1154
1155 context = pango_layout_get_context(layout);
1156 FontDesc = pango_context_get_font_description(context);
1157
1158 pango_font_description_set_size(FontDesc, 6*PANGO_SCALE);
1159 pango_layout_context_changed(layout);
1160
1161 pango_layout_set_text(layout, text, -1);
1162 pango_layout_get_pixel_extents(layout, &ink_rect, NULL);
1163 global_width += ink_rect.width;
1164
1165 gdk_draw_layout_with_colors(drawing->ruler->window,
1166 gc,
1167 0,
1168 6,
1169 layout, &foreground, &background);
1170
1171 gdk_gc_set_line_attributes(gc,
1172 2,
1173 GDK_LINE_SOLID,
1174 GDK_CAP_ROUND,
1175 GDK_JOIN_ROUND);
1176
1177 gdk_draw_line (drawing->ruler->window,
1178 gc,
1179 1, 1,
1180 1, 7);
1181
1182
1183 snprintf(text, 255, "%lus\n%luns", window_end.tv_sec,
1184 window_end.tv_nsec);
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 if(global_width <= drawing->ruler->allocation.width)
1191 {
1192 gdk_draw_layout_with_colors(drawing->ruler->window,
1193 gc,
1194 drawing->ruler->allocation.width - ink_rect.width,
1195 6,
1196 layout, &foreground, &background);
1197
1198 gdk_gc_set_line_attributes(gc,
1199 2,
1200 GDK_LINE_SOLID,
1201 GDK_CAP_ROUND,
1202 GDK_JOIN_ROUND);
1203
1204 gdk_draw_line (drawing->ruler->window,
1205 gc,
1206 drawing->ruler->allocation.width-1, 1,
1207 drawing->ruler->allocation.width-1, 7);
1208 }
1209
1210
1211 snprintf(text, 255, "%lus\n%luns", window_middle.tv_sec,
1212 window_middle.tv_nsec);
1213
1214 pango_layout_set_text(layout, text, -1);
1215 pango_layout_get_pixel_extents(layout, &ink_rect, NULL);
1216 global_width += ink_rect.width;
1217
1218 if(global_width <= drawing->ruler->allocation.width)
1219 {
1220 gdk_draw_layout_with_colors(drawing->ruler->window,
1221 gc,
1222 (drawing->ruler->allocation.width - ink_rect.width)/2,
1223 6,
1224 layout, &foreground, &background);
1225
1226 gdk_gc_set_line_attributes(gc,
1227 2,
1228 GDK_LINE_SOLID,
1229 GDK_CAP_ROUND,
1230 GDK_JOIN_ROUND);
1231
1232 gdk_draw_line (drawing->ruler->window,
1233 gc,
1234 drawing->ruler->allocation.width/2, 1,
1235 drawing->ruler->allocation.width/2, 7);
1236
1237
1238
1239
1240 }
1241
1242 gdk_gc_unref(gc);
1243 g_object_unref(layout);
1244
1245 return FALSE;
1246 }
1247
1248
1249 /* notify mouse on ruler */
1250 static gboolean
1251 motion_notify_ruler(GtkWidget *widget, GdkEventMotion *event, gpointer user_data)
1252 {
1253 //g_debug("motion");
1254 //eventually follow mouse and show time here
1255 }
LTTng 2.x Viewer (LTTV)
This page took 0.0567800000000001 seconds and 4 git commands to generate.