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