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