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