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