projects / lttv.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
processing bhunk size tweak
[lttv.git] / ltt / branches / poly / lttv / modules / gui / controlflow / eventhooks.c
CommitLineData
ce0214a6 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
f0d936c0 20/*****************************************************************************
21 * Hooks to be called by the main window *
22 *****************************************************************************/
23
f0d936c0 24
b9a010a2 25/* Event hooks are the drawing hooks called during traceset read. They draw the
26 * icons, text, lines and background color corresponding to the events read.
27 *
e92eabaf 28 * Two hooks are used for drawing : before_schedchange and after_schedchange hooks. The
29 * before_schedchange is called before the state update that occurs with an event and
30 * the after_schedchange hook is called after this state update.
b9a010a2 31 *
e92eabaf 32 * The before_schedchange hooks fulfill the task of drawing the visible objects that
33 * corresponds to the data accumulated by the after_schedchange hook.
b9a010a2 34 *
e92eabaf 35 * The after_schedchange hook accumulates the data that need to be shown on the screen
36 * (items) into a queue. Then, the next before_schedchange hook will draw what that
b9a010a2 37 * queue contains. That's the Right Way (TM) of drawing items on the screen,
38 * because we need to draw the background first (and then add icons, text, ...
39 * over it), but we only know the length of a background region once the state
e92eabaf 40 * corresponding to it is over, which happens to be at the next before_schedchange
b9a010a2 41 * hook.
42 *
43 * We also have a hook called at the end of a chunk to draw the information left
44 * undrawn in each process queue. We use the current time as end of
45 * line/background.
46 */
47
4e4d11b3 48#ifdef HAVE_CONFIG_H
49#include <config.h>
50#endif
b9a010a2 51
cf6cb7e0 52//#define PANGO_ENABLE_BACKEND
558aa013 53#include <gtk/gtk.h>
54#include <gdk/gdk.h>
5f16133f 55#include <glib.h>
80a52ff8 56#include <assert.h>
50439712 57#include <string.h>
319e9d81 58#include <stdio.h>
5f16133f 59
cf6cb7e0 60//#include <pango/pango.h>
61
80a52ff8 62#include <ltt/event.h>
4ba42155 63#include <ltt/time.h>
50439712 64#include <ltt/type.h>
2c82c4dc 65#include <ltt/trace.h>
80a52ff8 66
2a2fa4f0 67#include <lttv/lttv.h>
558aa013 68#include <lttv/hook.h>
80a52ff8 69#include <lttv/state.h>
2d262115 70#include <lttvwindow/lttvwindow.h>
6395d57c 71#include <lttvwindow/lttvwindowtraces.h>
80a52ff8 72
f0d936c0 73
a117e3f7 74#include "eventhooks.h"
75#include "cfv.h"
76#include "processlist.h"
77#include "drawing.h"
5f16133f 78
80a52ff8 79
1a31868c 80#define MAX_PATH_LEN 256
81
b9a010a2 82#if 0
83typedef struct _ProcessAddClosure {
84 ControlFlowData *cfd;
85 guint trace_num;
86} ProcessAddClosure;
87
88static void process_add(gpointer key,
89 gpointer value,
90 gpointer user_data)
91{
92 LttvProcessState *process = (LttvProcessState*)value;
93 ProcessAddClosure *closure = (ProcessAddClosure*)user_data;
94 ControlFlowData *control_flow_data = closure->cfd;
95 guint trace_num = closure->trace_num;
96
97 /* Add process to process list (if not present) */
98 guint pid;
99 LttTime birth;
100 guint y = 0, height = 0, pl_height = 0;
101
5c230fc4 102 ProcessList *process_list = control_flow_data->process_list;
b9a010a2 103
104 pid = process->pid;
105 birth = process->creation_time;
106 const gchar *name = g_quark_to_string(process->name);
107 HashedProcessData *hashed_process_data = NULL;
108
109 if(processlist_get_process_pixels(process_list,
110 pid,
111 &birth,
112 trace_num,
113 &y,
114 &height,
115 &hashed_process_data) == 1)
116 {
117 /* Process not present */
118 processlist_add(process_list,
119 pid,
120 &birth,
121 trace_num,
122 name,
123 &pl_height,
124 &hashed_process_data);
125 processlist_get_process_pixels(process_list,
126 pid,
127 &birth,
128 trace_num,
129 &y,
130 &height,
131 &hashed_process_data);
132 drawing_insert_square( control_flow_data->drawing, y, height);
133 }
134}
135#endif //0
136
137
6395d57c 138/* Action to do when background computation completed.
139 *
e800cf84 140 * Wait for all the awaited computations to be over.
6395d57c 141 */
142
143gint background_ready(void *hook_data, void *call_data)
144{
145 ControlFlowData *control_flow_data = (ControlFlowData *)hook_data;
146 LttvTrace *trace = (LttvTrace*)call_data;
147
e800cf84 148 control_flow_data->background_info_waiting--;
149
150 if(control_flow_data->background_info_waiting == 0) {
151 g_debug("control flow viewer : background computation data ready.");
6395d57c 152
e800cf84 153 drawing_clear(control_flow_data->drawing);
154 processlist_clear(control_flow_data->process_list);
07390ec1 155 gtk_widget_set_size_request(
156 control_flow_data->drawing->drawing_area,
157 -1, processlist_get_height(control_flow_data->process_list));
e800cf84 158 redraw_notify(control_flow_data, NULL);
b9a010a2 159 }
6395d57c 160
161 return 0;
162}
163
164
165/* Request background computation. Verify if it is in progress or ready first.
e800cf84 166 * Only for each trace in the tab's traceset.
6395d57c 167 */
168void request_background_data(ControlFlowData *control_flow_data)
169{
e800cf84 170 LttvTracesetContext * tsc =
171 lttvwindow_get_traceset_context(control_flow_data->tab);
172 gint num_traces = lttv_traceset_number(tsc->ts);
6395d57c 173 gint i;
174 LttvTrace *trace;
175
176 LttvHooks *background_ready_hook =
177 lttv_hooks_new();
178 lttv_hooks_add(background_ready_hook, background_ready, control_flow_data,
179 LTTV_PRIO_DEFAULT);
e800cf84 180 control_flow_data->background_info_waiting = 0;
6395d57c 181
182 for(i=0;i<num_traces;i++) {
e800cf84 183 trace = lttv_traceset_get(tsc->ts, i);
6395d57c 184
185 if(lttvwindowtraces_get_ready(g_quark_from_string("state"),trace)==FALSE) {
186
187 if(lttvwindowtraces_get_in_progress(g_quark_from_string("state"),
188 trace) == FALSE) {
189 /* We first remove requests that could have been done for the same
190 * information. Happens when two viewers ask for it before servicing
191 * starts.
192 */
193 lttvwindowtraces_background_request_remove(trace, "state");
194 lttvwindowtraces_background_request_queue(trace,
195 "state");
196 lttvwindowtraces_background_notify_queue(control_flow_data,
197 trace,
198 ltt_time_infinite,
199 NULL,
200 background_ready_hook);
e800cf84 201 control_flow_data->background_info_waiting++;
6395d57c 202 } else { /* in progress */
203
204 lttvwindowtraces_background_notify_current(control_flow_data,
205 trace,
206 ltt_time_infinite,
207 NULL,
208 background_ready_hook);
e800cf84 209 control_flow_data->background_info_waiting++;
6395d57c 210 }
4368b993 211 } else {
212 /* Data ready. Be its nature, this viewer doesn't need to have
213 * its data ready hook called htere, because a background
214 * request is always linked with a redraw.
215 */
6395d57c 216 }
4368b993 217
6395d57c 218 }
219
220 lttv_hooks_destroy(background_ready_hook);
221}
222
223
224
225
f0d936c0 226/**
227 * Event Viewer's constructor hook
228 *
229 * This constructor is given as a parameter to the menuitem and toolbar button
230 * registration. It creates the list.
ca0f8a8e 231 * @param tab A pointer to the parent tab.
f0d936c0 232 * @return The widget created.
233 */
234GtkWidget *
d47b33d2 235h_guicontrolflow(Tab *tab)
f0d936c0 236{
d47b33d2 237 g_info("h_guicontrolflow, %p", tab);
68997a22 238 ControlFlowData *control_flow_data = guicontrolflow() ;
a56a1ba4 239
ca0f8a8e 240 control_flow_data->tab = tab;
a56a1ba4 241
a56a1ba4 242 // Unreg done in the GuiControlFlow_Destructor
6395d57c 243 lttvwindow_register_traceset_notify(tab,
244 traceset_notify,
245 control_flow_data);
246
ca0f8a8e 247 lttvwindow_register_time_window_notify(tab,
224446ce 248 update_time_window_hook,
249 control_flow_data);
ca0f8a8e 250 lttvwindow_register_current_time_notify(tab,
224446ce 251 update_current_time_hook,
252 control_flow_data);
ca0f8a8e 253 lttvwindow_register_redraw_notify(tab,
254 redraw_notify,
255 control_flow_data);
256 lttvwindow_register_continue_notify(tab,
257 continue_notify,
258 control_flow_data);
088f6772 259 request_background_data(control_flow_data);
6395d57c 260
ca0f8a8e 261
68997a22 262 return guicontrolflow_get_widget(control_flow_data) ;
a56a1ba4 263
f0d936c0 264}
265
3cff8cc1 266int event_selected_hook(void *hook_data, void *call_data)
f0d936c0 267{
68997a22 268 ControlFlowData *control_flow_data = (ControlFlowData*) hook_data;
14963be0 269 guint *event_number = (guint*) call_data;
f0d936c0 270
2a2fa4f0 271 g_debug("DEBUG : event selected by main window : %u", *event_number);
a56a1ba4 272
2eef04b5 273 return 0;
f0d936c0 274}
275
9a1ec01b 276/* Function that selects the color of status&exemode line */
6550d711 277static inline PropertiesLine prepare_s_e_line(LttvProcessState *process)
9a1ec01b 278{
279 PropertiesLine prop_line;
280 prop_line.line_width = 2;
281 prop_line.style = GDK_LINE_SOLID;
282 prop_line.y = MIDDLE;
283 //GdkColormap *colormap = gdk_colormap_get_system();
284
9a1ec01b 285 if(process->state->s == LTTV_STATE_RUN) {
286 if(process->state->t == LTTV_STATE_USER_MODE)
287 prop_line.color = drawing_colors[COL_RUN_USER_MODE];
288 else if(process->state->t == LTTV_STATE_SYSCALL)
289 prop_line.color = drawing_colors[COL_RUN_SYSCALL];
290 else if(process->state->t == LTTV_STATE_TRAP)
291 prop_line.color = drawing_colors[COL_RUN_TRAP];
292 else if(process->state->t == LTTV_STATE_IRQ)
293 prop_line.color = drawing_colors[COL_RUN_IRQ];
294 else if(process->state->t == LTTV_STATE_MODE_UNKNOWN)
295 prop_line.color = drawing_colors[COL_MODE_UNKNOWN];
296 else
297 g_assert(FALSE); /* RUNNING MODE UNKNOWN */
298 } else if(process->state->s == LTTV_STATE_WAIT) {
299 /* We don't show if we wait while in user mode, trap, irq or syscall */
300 prop_line.color = drawing_colors[COL_WAIT];
301 } else if(process->state->s == LTTV_STATE_WAIT_CPU) {
302 /* We don't show if we wait for CPU while in user mode, trap, irq
303 * or syscall */
304 prop_line.color = drawing_colors[COL_WAIT_CPU];
305 } else if(process->state->s == LTTV_STATE_ZOMBIE) {
306 prop_line.color = drawing_colors[COL_ZOMBIE];
307 } else if(process->state->s == LTTV_STATE_WAIT_FORK) {
308 prop_line.color = drawing_colors[COL_WAIT_FORK];
309 } else if(process->state->s == LTTV_STATE_EXIT) {
310 prop_line.color = drawing_colors[COL_EXIT];
311 } else if(process->state->s == LTTV_STATE_UNNAMED) {
312 prop_line.color = drawing_colors[COL_UNNAMED];
313 } else
314 g_assert(FALSE); /* UNKNOWN STATE */
315
316 return prop_line;
317
318}
319
320#if 0
6550d711 321static inline PropertiesLine prepare_status_line(LttvProcessState *process)
c8bba5fa 322{
323 PropertiesLine prop_line;
324 prop_line.line_width = 2;
325 prop_line.style = GDK_LINE_SOLID;
e800cf84 326 prop_line.y = MIDDLE;
327 //GdkColormap *colormap = gdk_colormap_get_system();
c8bba5fa 328
23093869 329 g_debug("prepare_status_line for state : %s",
330 g_quark_to_string(process->state->s));
c8bba5fa 331
332 /* color of line : status of the process */
333 if(process->state->s == LTTV_STATE_UNNAMED)
e800cf84 334 prop_line.color = drawing_colors[COL_WHITE];
c8bba5fa 335 else if(process->state->s == LTTV_STATE_WAIT_FORK)
e800cf84 336 prop_line.color = drawing_colors[COL_WAIT_FORK];
c8bba5fa 337 else if(process->state->s == LTTV_STATE_WAIT_CPU)
e800cf84 338 prop_line.color = drawing_colors[COL_WAIT_CPU];
dbd243b1 339 else if(process->state->s == LTTV_STATE_EXIT)
340 prop_line.color = drawing_colors[COL_EXIT];
0828099d 341 else if(process->state->s == LTTV_STATE_ZOMBIE)
342 prop_line.color = drawing_colors[COL_ZOMBIE];
c8bba5fa 343 else if(process->state->s == LTTV_STATE_WAIT)
e800cf84 344 prop_line.color = drawing_colors[COL_WAIT];
c8bba5fa 345 else if(process->state->s == LTTV_STATE_RUN)
e800cf84 346 prop_line.color = drawing_colors[COL_RUN];
c8bba5fa 347 else
23093869 348 prop_line.color = drawing_colors[COL_WHITE];
e800cf84 349
350 //gdk_colormap_alloc_color(colormap,
351 // prop_line.color,
352 // FALSE,
353 // TRUE);
c8bba5fa 354
355 return prop_line;
356
357}
9a1ec01b 358#endif //0
c8bba5fa 359
360
e92eabaf 361/* before_schedchange_hook
b9a010a2 362 *
f0d936c0 363 * This function basically draw lines and icons. Two types of lines are drawn :
364 * one small (3 pixels?) representing the state of the process and the second
365 * type is thicker (10 pixels?) representing on which CPU a process is running
366 * (and this only in running state).
367 *
368 * Extremums of the lines :
369 * x_min : time of the last event context for this process kept in memory.
370 * x_max : time of the current event.
371 * y : middle of the process in the process list. The process is found in the
372 * list, therefore is it's position in pixels.
373 *
374 * The choice of lines'color is defined by the context of the last event for this
375 * process.
376 */
b9a010a2 377
378
e92eabaf 379int before_schedchange_hook(void *hook_data, void *call_data)
f0d936c0 380{
2c82c4dc 381 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
382 EventsRequest *events_request = (EventsRequest*)thf->hook_data;
b9a010a2 383 ControlFlowData *control_flow_data = events_request->viewer_data;
384
385 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
386
387 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
b9a010a2 388
389 LttEvent *e;
2c82c4dc 390 e = ltt_tracefile_get_event(tfc->tf);
b9a010a2 391
392 LttTime evtime = ltt_event_time(e);
fd22065b 393
10a1069a 394 /* we are in a schedchange, before the state update. We must draw the
395 * items corresponding to the state before it changes : now is the right
396 * time to do it.
397 */
b9a010a2 398
10a1069a 399 guint pid_out;
400 guint pid_in;
401 {
2c82c4dc 402 pid_out = ltt_event_get_long_unsigned(e, thf->f1);
403 pid_in = ltt_event_get_long_unsigned(e, thf->f2);
10a1069a 404 }
405
406 {
407 /* For the pid_out */
408 /* First, check if the current process is in the state computation
409 * process list. If it is there, that means we must add it right now and
410 * draw items from the beginning of the read for it. If it is not
411 * present, it's a new process and it was not present : it will
412 * be added after the state update. */
413 LttvProcessState *process;
40debf7b 414 /* unknown state, bad current pid */
415 if(tfs->process->pid != pid_out)
416 process = lttv_state_find_process(tfs, pid_out);
417 else
418 process = tfs->process;
b9a010a2 419
10a1069a 420 if(process != NULL) {
421 /* Well, the process_out existed : we must get it in the process hash
422 * or add it, and draw its items.
423 */
424 /* Add process to process list (if not present) */
1c736ed5 425 guint pl_height = 0;
10a1069a 426 HashedProcessData *hashed_process_data = NULL;
5c230fc4 427 ProcessList *process_list = control_flow_data->process_list;
10a1069a 428 LttTime birth = process->creation_time;
b9a010a2 429
ac4e21cf 430 hashed_process_data = processlist_get_process_data(process_list,
10a1069a 431 pid_out,
40debf7b 432 process->last_cpu_index,
10a1069a 433 &birth,
ac4e21cf 434 tfc->t_context->index);
435 if(hashed_process_data == NULL)
10a1069a 436 {
437 g_assert(pid_out == 0 || pid_out != process->ppid);
aac69e70 438 const gchar *name = g_quark_to_string(process->name);
10a1069a 439 /* Process not present */
4e86ae2e 440 ProcessInfo *process_info;
1c736ed5 441 Drawing_t *drawing = control_flow_data->drawing;
10a1069a 442 processlist_add(process_list,
1c736ed5 443 drawing,
10a1069a 444 pid_out,
40debf7b 445 process->last_cpu_index,
10a1069a 446 process->ppid,
447 &birth,
448 tfc->t_context->index,
449 name,
450 &pl_height,
4e86ae2e 451 &process_info,
10a1069a 452 &hashed_process_data);
1c736ed5 453 gtk_widget_set_size_request(drawing->drawing_area,
454 -1,
455 pl_height);
456 gtk_widget_queue_draw(drawing->drawing_area);
457
10a1069a 458 }
ac4e21cf 459
10a1069a 460 /* Now, the process is in the state hash and our own process hash.
461 * We definitely can draw the items related to the ending state.
462 */
e800cf84 463
b2743953 464 if(ltt_time_compare(hashed_process_data->next_good_time,
465 evtime) > 0)
10a1069a 466 {
b2743953 467 if(hashed_process_data->x.middle_marked == FALSE) {
ac4e21cf 468
fd22065b 469 TimeWindow time_window =
470 lttvwindow_get_time_window(control_flow_data->tab);
471#ifdef EXTRA_CHECK
472 if(ltt_time_compare(evtime, time_window.start_time) == -1
473 || ltt_time_compare(evtime, time_window.end_time) == 1)
474 return;
475#endif //EXTRA_CHECK
d6fef890 476 Drawing_t *drawing = control_flow_data->drawing;
96947fcf 477 guint width = drawing->width;
b2743953 478 guint x;
479 convert_time_to_pixels(
480 time_window,
481 evtime,
482 width,
483 &x);
484
485 /* Draw collision indicator */
486 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
1c736ed5 487 gdk_draw_point(hashed_process_data->pixmap,
b2743953 488 drawing->gc,
489 x,
1c736ed5 490 (hashed_process_data->height/2)-3);
b2743953 491 hashed_process_data->x.middle_marked = TRUE;
492 }
493 } else {
ac4e21cf 494 TimeWindow time_window =
495 lttvwindow_get_time_window(control_flow_data->tab);
fd22065b 496#ifdef EXTRA_CHECK
ac4e21cf 497 if(ltt_time_compare(evtime, time_window.start_time) == -1
498 || ltt_time_compare(evtime, time_window.end_time) == 1)
499 return;
fd22065b 500#endif //EXTRA_CHECK
d6fef890 501 Drawing_t *drawing = control_flow_data->drawing;
96947fcf 502 guint width = drawing->width;
10a1069a 503 guint x;
10a1069a 504 convert_time_to_pixels(
a18124ff 505 time_window,
4b7dc462 506 evtime,
507 width,
508 &x);
10a1069a 509
10a1069a 510
4b7dc462 511 /* Jump over draw if we are at the same x position */
e72908ed 512 if(x == hashed_process_data->x.middle &&
513 hashed_process_data->x.middle_used)
e800cf84 514 {
e72908ed 515 if(hashed_process_data->x.middle_marked == FALSE) {
516 /* Draw collision indicator */
517 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
1c736ed5 518 gdk_draw_point(hashed_process_data->pixmap,
e72908ed 519 drawing->gc,
520 x,
1c736ed5 521 (hashed_process_data->height/2)-3);
de4ea1ad 522 hashed_process_data->x.middle_marked = TRUE;
e72908ed 523 }
4b7dc462 524 /* jump */
525 } else {
526 DrawContext draw_context;
10a1069a 527
4b7dc462 528 /* Now create the drawing context that will be used to draw
529 * items related to the last state. */
1c736ed5 530 draw_context.drawable = hashed_process_data->pixmap;
4b7dc462 531 draw_context.gc = drawing->gc;
532 draw_context.pango_layout = drawing->pango_layout;
533 draw_context.drawinfo.start.x = hashed_process_data->x.middle;
534 draw_context.drawinfo.end.x = x;
535
1c736ed5 536 draw_context.drawinfo.y.over = 1;
537 draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
538 draw_context.drawinfo.y.under = hashed_process_data->height;
4b7dc462 539
540 draw_context.drawinfo.start.offset.over = 0;
541 draw_context.drawinfo.start.offset.middle = 0;
542 draw_context.drawinfo.start.offset.under = 0;
543 draw_context.drawinfo.end.offset.over = 0;
544 draw_context.drawinfo.end.offset.middle = 0;
545 draw_context.drawinfo.end.offset.under = 0;
546
547 {
548 /* Draw the line */
9a1ec01b 549 PropertiesLine prop_line = prepare_s_e_line(process);
4b7dc462 550 draw_line((void*)&prop_line, (void*)&draw_context);
551
552 }
553 /* become the last x position */
554 hashed_process_data->x.middle = x;
e72908ed 555 hashed_process_data->x.middle_used = TRUE;
556 hashed_process_data->x.middle_marked = FALSE;
b2743953 557
558 /* Calculate the next good time */
559 convert_pixels_to_time(width, x+1, time_window,
560 &hashed_process_data->next_good_time);
e800cf84 561 }
562 }
563 }
10a1069a 564 }
e800cf84 565
10a1069a 566 {
567 /* For the pid_in */
568 /* First, check if the current process is in the state computation
569 * process list. If it is there, that means we must add it right now and
570 * draw items from the beginning of the read for it. If it is not
571 * present, it's a new process and it was not present : it will
572 * be added after the state update. */
573 LttvProcessState *process;
574 process = lttv_state_find_process(tfs, pid_in);
575
576 if(process != NULL) {
577 /* Well, the process_out existed : we must get it in the process hash
578 * or add it, and draw its items.
579 */
580 /* Add process to process list (if not present) */
1c736ed5 581 guint pl_height = 0;
10a1069a 582 HashedProcessData *hashed_process_data = NULL;
5c230fc4 583 ProcessList *process_list = control_flow_data->process_list;
10a1069a 584 LttTime birth = process->creation_time;
e800cf84 585
ac4e21cf 586 hashed_process_data = processlist_get_process_data(process_list,
10a1069a 587 pid_in,
40debf7b 588 process->last_cpu_index,
10a1069a 589 &birth,
ac4e21cf 590 tfc->t_context->index);
591 if(hashed_process_data == NULL)
10a1069a 592 {
593 g_assert(pid_in == 0 || pid_in != process->ppid);
aac69e70 594 const gchar *name = g_quark_to_string(process->name);
10a1069a 595 /* Process not present */
4e86ae2e 596 ProcessInfo *process_info;
1c736ed5 597 Drawing_t *drawing = control_flow_data->drawing;
10a1069a 598 processlist_add(process_list,
1c736ed5 599 drawing,
10a1069a 600 pid_in,
40debf7b 601 process->last_cpu_index,
10a1069a 602 process->ppid,
603 &birth,
604 tfc->t_context->index,
605 name,
606 &pl_height,
4e86ae2e 607 &process_info,
10a1069a 608 &hashed_process_data);
1c736ed5 609 gtk_widget_set_size_request(drawing->drawing_area,
610 -1,
611 pl_height);
612 gtk_widget_queue_draw(drawing->drawing_area);
613
10a1069a 614 }
40debf7b 615 //We could set the current process and hash here, but will be done
616 //by after schedchange hook
10a1069a 617
618 /* Now, the process is in the state hash and our own process hash.
619 * We definitely can draw the items related to the ending state.
620 */
b9a010a2 621
b2743953 622 if(ltt_time_compare(hashed_process_data->next_good_time,
623 evtime) > 0)
10a1069a 624 {
b2743953 625 if(hashed_process_data->x.middle_marked == FALSE) {
ac4e21cf 626
fd22065b 627 TimeWindow time_window =
628 lttvwindow_get_time_window(control_flow_data->tab);
629#ifdef EXTRA_CHECK
630 if(ltt_time_compare(evtime, time_window.start_time) == -1
631 || ltt_time_compare(evtime, time_window.end_time) == 1)
632 return;
633#endif //EXTRA_CHECK
d6fef890 634 Drawing_t *drawing = control_flow_data->drawing;
96947fcf 635 guint width = drawing->width;
b2743953 636 guint x;
637 convert_time_to_pixels(
638 time_window,
639 evtime,
640 width,
641 &x);
642
643 /* Draw collision indicator */
644 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
1c736ed5 645 gdk_draw_point(hashed_process_data->pixmap,
b2743953 646 drawing->gc,
647 x,
1c736ed5 648 (hashed_process_data->height/2)-3);
b2743953 649 hashed_process_data->x.middle_marked = TRUE;
650 }
651 } else {
fd22065b 652 TimeWindow time_window =
653 lttvwindow_get_time_window(control_flow_data->tab);
654#ifdef EXTRA_CHECK
655 if(ltt_time_compare(evtime, time_window.start_time) == -1
656 || ltt_time_compare(evtime, time_window.end_time) == 1)
657 return;
658#endif //EXTRA_CHECK
d6fef890 659 Drawing_t *drawing = control_flow_data->drawing;
96947fcf 660 guint width = drawing->width;
10a1069a 661 guint x;
10a1069a 662
663 convert_time_to_pixels(
a18124ff 664 time_window,
4b7dc462 665 evtime,
666 width,
667 &x);
10a1069a 668
10a1069a 669
4b7dc462 670 /* Jump over draw if we are at the same x position */
e72908ed 671 if(x == hashed_process_data->x.middle &&
672 hashed_process_data->x.middle_used)
4b7dc462 673 {
e72908ed 674 if(hashed_process_data->x.middle_marked == FALSE) {
675 /* Draw collision indicator */
676 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
1c736ed5 677 gdk_draw_point(hashed_process_data->pixmap,
e72908ed 678 drawing->gc,
679 x,
1c736ed5 680 (hashed_process_data->height/2)-3);
de4ea1ad 681 hashed_process_data->x.middle_marked = TRUE;
e72908ed 682 }
4b7dc462 683 /* jump */
684 } else {
685 DrawContext draw_context;
10a1069a 686
4b7dc462 687 /* Now create the drawing context that will be used to draw
688 * items related to the last state. */
1c736ed5 689 draw_context.drawable = hashed_process_data->pixmap;
4b7dc462 690 draw_context.gc = drawing->gc;
691 draw_context.pango_layout = drawing->pango_layout;
692 draw_context.drawinfo.start.x = hashed_process_data->x.middle;
693 draw_context.drawinfo.end.x = x;
10a1069a 694
1c736ed5 695 draw_context.drawinfo.y.over = 1;
696 draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
697 draw_context.drawinfo.y.under = hashed_process_data->height;
10a1069a 698
4b7dc462 699 draw_context.drawinfo.start.offset.over = 0;
700 draw_context.drawinfo.start.offset.middle = 0;
701 draw_context.drawinfo.start.offset.under = 0;
702 draw_context.drawinfo.end.offset.over = 0;
703 draw_context.drawinfo.end.offset.middle = 0;
704 draw_context.drawinfo.end.offset.under = 0;
705
706 {
707 /* Draw the line */
9a1ec01b 708 PropertiesLine prop_line = prepare_s_e_line(process);
4b7dc462 709 draw_line((void*)&prop_line, (void*)&draw_context);
710 }
711
712
713 /* become the last x position */
714 hashed_process_data->x.middle = x;
e72908ed 715 hashed_process_data->x.middle_used = TRUE;
716 hashed_process_data->x.middle_marked = FALSE;
b2743953 717
718 /* Calculate the next good time */
719 convert_pixels_to_time(width, x+1, time_window,
720 &hashed_process_data->next_good_time);
4b7dc462 721 }
c8bba5fa 722 }
b9a010a2 723 }
724 }
b9a010a2 725 return 0;
726
727
b9a010a2 728#if 0
ca0f8a8e 729 EventsRequest *events_request = (EventsRequest*)hook_data;
730 ControlFlowData *control_flow_data =
731 (ControlFlowData*)events_request->viewer_data;
732 Tab *tab = control_flow_data->tab;
e9a9c513 733
a56a1ba4 734 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
e9a9c513 735
736 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1aff52a2 737 LttvTraceState *ts =(LttvTraceState *)LTTV_TRACEFILE_CONTEXT(tfs)->t_context;
a56a1ba4 738
e9a9c513 739 LttEvent *e;
e9a9c513 740 e = tfc->e;
741
9444deae 742 LttTime evtime = ltt_event_time(e);
ca0f8a8e 743 TimeWindow time_window =
744 lttvwindow_get_time_window(tab);
9444deae 745
a2aab3a3 746 LttTime time_window.end_time = time_window.time_window.end_time;
6f26fc38 747
9444deae 748 //if(time < time_beg || time > time_end) return;
ca0f8a8e 749 if(ltt_time_compare(evtime, time_window.start_time) == -1
a2aab3a3 750 || ltt_time_compare(evtime, time_window.end_time) == 1)
9444deae 751 return;
752
a56a1ba4 753 if(strcmp(ltt_eventtype_name(ltt_event_eventtype(e)),"schedchange") == 0)
754 {
2a2fa4f0 755 g_debug("schedchange!");
a56a1ba4 756
757 /* Add process to process list (if not present) and get drawing "y" from
758 * process position */
759 guint pid_out, pid_in;
760 LttvProcessState *process_out, *process_in;
761 LttTime birth;
762 guint y_in = 0, y_out = 0, height = 0, pl_height = 0;
763
5c230fc4 764 ProcessList *process_list = control_flow_data->process_list;
a56a1ba4 765
766
767 LttField *f = ltt_event_field(e);
768 LttField *element;
769 element = ltt_field_member(f,0);
770 pid_out = ltt_event_get_long_unsigned(e,element);
771 element = ltt_field_member(f,1);
772 pid_in = ltt_event_get_long_unsigned(e,element);
2a2fa4f0 773 g_debug("out : %u in : %u", pid_out, pid_in);
a56a1ba4 774
775
776 /* Find process pid_out in the list... */
87658614 777 process_out = lttv_state_find_process(tfs, pid_out);
1aff52a2 778 if(process_out == NULL) return 0;
2a2fa4f0 779 g_debug("out : %s",g_quark_to_string(process_out->state->s));
1aff52a2 780
a56a1ba4 781 birth = process_out->creation_time;
51705146 782 const gchar *name = g_quark_to_string(process_out->name);
14963be0 783 HashedProcessData *hashed_process_data_out = NULL;
a56a1ba4 784
785 if(processlist_get_process_pixels(process_list,
786 pid_out,
787 &birth,
d0cd7f09 788 tfc->t_context->index,
a56a1ba4 789 &y_out,
790 &height,
14963be0 791 &hashed_process_data_out) == 1)
a56a1ba4 792 {
51705146 793 /* Process not present */
794 processlist_add(process_list,
795 pid_out,
796 &birth,
797 tfc->t_context->index,
798 name,
799 &pl_height,
800 &hashed_process_data_out);
801 g_assert(processlist_get_process_pixels(process_list,
802 pid_out,
803 &birth,
804 tfc->t_context->index,
805 &y_out,
806 &height,
807 &hashed_process_data_out)==0);
808 drawing_insert_square( control_flow_data->drawing, y_out, height);
a56a1ba4 809 }
51705146 810 //g_free(name);
a56a1ba4 811
812 /* Find process pid_in in the list... */
87658614 813 process_in = lttv_state_find_process(tfs, pid_in);
1aff52a2 814 if(process_in == NULL) return 0;
2a2fa4f0 815 g_debug("in : %s",g_quark_to_string(process_in->state->s));
a56a1ba4 816
817 birth = process_in->creation_time;
51705146 818 name = g_quark_to_string(process_in->name);
14963be0 819 HashedProcessData *hashed_process_data_in = NULL;
a56a1ba4 820
821 if(processlist_get_process_pixels(process_list,
822 pid_in,
823 &birth,
d0cd7f09 824 tfc->t_context->index,
a56a1ba4 825 &y_in,
826 &height,
14963be0 827 &hashed_process_data_in) == 1)
a56a1ba4 828 {
51705146 829 /* Process not present */
a56a1ba4 830 processlist_add(process_list,
831 pid_in,
832 &birth,
d0cd7f09 833 tfc->t_context->index,
a56a1ba4 834 name,
835 &pl_height,
14963be0 836 &hashed_process_data_in);
a56a1ba4 837 processlist_get_process_pixels(process_list,
838 pid_in,
839 &birth,
d0cd7f09 840 tfc->t_context->index,
a56a1ba4 841 &y_in,
842 &height,
14963be0 843 &hashed_process_data_in);
a56a1ba4 844
ca0f8a8e 845 drawing_insert_square( control_flow_data->drawing, y_in, height);
a56a1ba4 846 }
51705146 847 //g_free(name);
a56a1ba4 848
849
850 /* Find pixels corresponding to time of the event. If the time does
851 * not fit in the window, show a warning, not supposed to happend. */
852 guint x = 0;
51705146 853 guint width = control_flow_data->drawing->width;
a56a1ba4 854
855 LttTime time = ltt_event_time(e);
856
a2aab3a3 857 LttTime window_end = time_window.time_window.end_time;
a56a1ba4 858
859 convert_time_to_pixels(
a18124ff 860 time_window,
a56a1ba4 861 time,
862 width,
863 &x);
9444deae 864 //assert(x <= width);
51705146 865 //
a56a1ba4 866 /* draw what represents the event for outgoing process. */
867
14963be0 868 DrawContext *draw_context_out = hashed_process_data_out->draw_context;
68997a22 869 draw_context_out->current->modify_over->x = x;
319e9d81 870 draw_context_out->current->modify_under->x = x;
68997a22 871 draw_context_out->current->modify_over->y = y_out;
319e9d81 872 draw_context_out->current->modify_under->y = y_out+(height/2)+2;
501d5405 873 draw_context_out->drawable = control_flow_data->drawing->pixmap;
874 draw_context_out->pango_layout = control_flow_data->drawing->pango_layout;
875 GtkWidget *widget = control_flow_data->drawing->drawing_area;
a56a1ba4 876 //draw_context_out->gc = widget->style->fg_gc[GTK_WIDGET_STATE (widget)];
d0cd7f09 877 //draw_context_out->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
878 //gdk_gc_copy(draw_context_out->gc, widget->style->black_gc);
a56a1ba4 879 //draw_context_out->gc = widget->style->black_gc;
880
881 //draw_arc((void*)&prop_arc, (void*)draw_context_out);
501d5405 882 //test_draw_item(control_flow_data->drawing, control_flow_data->drawing->pixmap);
a56a1ba4 883
d0cd7f09 884 /* Draw the line/background of the out process */
885 if(draw_context_out->previous->middle->x == -1)
886 {
ca0f8a8e 887 draw_context_out->previous->over->x =
888 control_flow_data->drawing->damage_begin;
889 draw_context_out->previous->middle->x =
890 control_flow_data->drawing->damage_begin;
891 draw_context_out->previous->under->x =
892 control_flow_data->drawing->damage_begin;
ca0f8a8e 893 g_debug("out middle x_beg : %u",control_flow_data->drawing->damage_begin);
d0cd7f09 894 }
895
896 draw_context_out->current->middle->x = x;
897 draw_context_out->current->over->x = x;
898 draw_context_out->current->under->x = x;
899 draw_context_out->current->middle->y = y_out + height/2;
900 draw_context_out->current->over->y = y_out;
901 draw_context_out->current->under->y = y_out + height;
902 draw_context_out->previous->middle->y = y_out + height/2;
903 draw_context_out->previous->over->y = y_out;
904 draw_context_out->previous->under->y = y_out + height;
905
906 draw_context_out->drawable = control_flow_data->drawing->pixmap;
907 draw_context_out->pango_layout = control_flow_data->drawing->pango_layout;
908
909 if(process_out->state->s == LTTV_STATE_RUN)
910 {
51705146 911 //draw_context_out->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
912 //gdk_gc_copy(draw_context_out->gc, widget->style->black_gc);
913 draw_context_out->gc = control_flow_data->drawing->gc;
d0cd7f09 914
915 PropertiesBG prop_bg;
916 prop_bg.color = g_new(GdkColor,1);
917
2c82c4dc 918 switch(ltt_tracefile_num(tfc->tf)) {
d0cd7f09 919 case 0:
920 prop_bg.color->red = 0x1515;
921 prop_bg.color->green = 0x1515;
922 prop_bg.color->blue = 0x8c8c;
923 break;
924 case 1:
925 prop_bg.color->red = 0x4e4e;
926 prop_bg.color->green = 0xa9a9;
927 prop_bg.color->blue = 0xa4a4;
928 break;
929 case 2:
930 prop_bg.color->red = 0x7a7a;
931 prop_bg.color->green = 0x4a4a;
932 prop_bg.color->blue = 0x8b8b;
933 break;
934 case 3:
935 prop_bg.color->red = 0x8080;
936 prop_bg.color->green = 0x7777;
937 prop_bg.color->blue = 0x4747;
938 break;
939 default:
940 prop_bg.color->red = 0xe7e7;
941 prop_bg.color->green = 0xe7e7;
942 prop_bg.color->blue = 0xe7e7;
943 }
944
2a2fa4f0 945 g_debug("calling from draw_event");
d0cd7f09 946 draw_bg((void*)&prop_bg, (void*)draw_context_out);
947 g_free(prop_bg.color);
51705146 948 //gdk_gc_unref(draw_context_out->gc);
d0cd7f09 949 }
950
951 draw_context_out->gc = widget->style->black_gc;
952
a56a1ba4 953 GdkColor colorfg_out = { 0, 0xffff, 0x0000, 0x0000 };
2df6f2bd 954 GdkColor colorbg_out = { 0, 0x0000, 0x0000, 0x0000 };
a56a1ba4 955 PropertiesText prop_text_out;
956 prop_text_out.foreground = &colorfg_out;
957 prop_text_out.background = &colorbg_out;
cfe526b1 958 prop_text_out.size = 6;
a56a1ba4 959 prop_text_out.position = OVER;
960
cfe526b1 961 /* color of text : status of the process */
962 if(process_out->state->s == LTTV_STATE_UNNAMED)
963 {
964 prop_text_out.foreground->red = 0xffff;
965 prop_text_out.foreground->green = 0xffff;
966 prop_text_out.foreground->blue = 0xffff;
967 }
968 else if(process_out->state->s == LTTV_STATE_WAIT_FORK)
969 {
970 prop_text_out.foreground->red = 0x0fff;
d52cfc84 971 prop_text_out.foreground->green = 0xffff;
972 prop_text_out.foreground->blue = 0xfff0;
cfe526b1 973 }
974 else if(process_out->state->s == LTTV_STATE_WAIT_CPU)
975 {
2df6f2bd 976 prop_text_out.foreground->red = 0xffff;
977 prop_text_out.foreground->green = 0xffff;
cfe526b1 978 prop_text_out.foreground->blue = 0x0000;
979 }
0828099d 980 else if(process_out->state->s == LTTV_STATE_ZOMBIE)
cfe526b1 981 {
982 prop_text_out.foreground->red = 0xffff;
983 prop_text_out.foreground->green = 0x0000;
984 prop_text_out.foreground->blue = 0xffff;
985 }
986 else if(process_out->state->s == LTTV_STATE_WAIT)
987 {
988 prop_text_out.foreground->red = 0xffff;
989 prop_text_out.foreground->green = 0x0000;
990 prop_text_out.foreground->blue = 0x0000;
991 }
992 else if(process_out->state->s == LTTV_STATE_RUN)
993 {
994 prop_text_out.foreground->red = 0x0000;
995 prop_text_out.foreground->green = 0xffff;
996 prop_text_out.foreground->blue = 0x0000;
997 }
998 else
999 {
1000 prop_text_out.foreground->red = 0xffff;
1001 prop_text_out.foreground->green = 0xffff;
1002 prop_text_out.foreground->blue = 0xffff;
1003 }
1004
d52cfc84 1005
a56a1ba4 1006 /* Print status of the process : U, WF, WC, E, W, R */
1007 if(process_out->state->s == LTTV_STATE_UNNAMED)
cfe526b1 1008 prop_text_out.text = "U->";
a56a1ba4 1009 else if(process_out->state->s == LTTV_STATE_WAIT_FORK)
cfe526b1 1010 prop_text_out.text = "WF->";
a56a1ba4 1011 else if(process_out->state->s == LTTV_STATE_WAIT_CPU)
cfe526b1 1012 prop_text_out.text = "WC->";
0828099d 1013 else if(process_out->state->s == LTTV_STATE_ZOMBIE)
cfe526b1 1014 prop_text_out.text = "E->";
a56a1ba4 1015 else if(process_out->state->s == LTTV_STATE_WAIT)
cfe526b1 1016 prop_text_out.text = "W->";
a56a1ba4 1017 else if(process_out->state->s == LTTV_STATE_RUN)
cfe526b1 1018 prop_text_out.text = "R->";
a56a1ba4 1019 else
68997a22 1020 prop_text_out.text = "U";
a56a1ba4 1021
1022 draw_text((void*)&prop_text_out, (void*)draw_context_out);
d0cd7f09 1023 //gdk_gc_unref(draw_context_out->gc);
a56a1ba4 1024
51705146 1025 //draw_context_out->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
1026 //gdk_gc_copy(draw_context_out->gc, widget->style->black_gc);
1027 draw_context_out->gc = control_flow_data->drawing->gc;
a56a1ba4 1028
1029 PropertiesLine prop_line_out;
1030 prop_line_out.color = g_new(GdkColor,1);
cfe526b1 1031 prop_line_out.line_width = 2;
a56a1ba4 1032 prop_line_out.style = GDK_LINE_SOLID;
1033 prop_line_out.position = MIDDLE;
d52cfc84 1034
2a2fa4f0 1035 g_debug("out state : %s", g_quark_to_string(process_out->state->s));
a56a1ba4 1036
1037 /* color of line : status of the process */
1038 if(process_out->state->s == LTTV_STATE_UNNAMED)
1039 {
cfe526b1 1040 prop_line_out.color->red = 0xffff;
1041 prop_line_out.color->green = 0xffff;
1042 prop_line_out.color->blue = 0xffff;
a56a1ba4 1043 }
1044 else if(process_out->state->s == LTTV_STATE_WAIT_FORK)
1045 {
1046 prop_line_out.color->red = 0x0fff;
d52cfc84 1047 prop_line_out.color->green = 0xffff;
1048 prop_line_out.color->blue = 0xfff0;
a56a1ba4 1049 }
1050 else if(process_out->state->s == LTTV_STATE_WAIT_CPU)
1051 {
2df6f2bd 1052 prop_line_out.color->red = 0xffff;
1053 prop_line_out.color->green = 0xffff;
a56a1ba4 1054 prop_line_out.color->blue = 0x0000;
1055 }
0828099d 1056 else if(process_out->state->s == LTTV_STATE_ZOMBIE)
a56a1ba4 1057 {
1058 prop_line_out.color->red = 0xffff;
1059 prop_line_out.color->green = 0x0000;
1060 prop_line_out.color->blue = 0xffff;
1061 }
1062 else if(process_out->state->s == LTTV_STATE_WAIT)
1063 {
1064 prop_line_out.color->red = 0xffff;
1065 prop_line_out.color->green = 0x0000;
1066 prop_line_out.color->blue = 0x0000;
1067 }
1068 else if(process_out->state->s == LTTV_STATE_RUN)
1069 {
1070 prop_line_out.color->red = 0x0000;
1071 prop_line_out.color->green = 0xffff;
1072 prop_line_out.color->blue = 0x0000;
1073 }
1074 else
1075 {
cfe526b1 1076 prop_line_out.color->red = 0xffff;
1077 prop_line_out.color->green = 0xffff;
1078 prop_line_out.color->blue = 0xffff;
a56a1ba4 1079 }
1080
1081 draw_line((void*)&prop_line_out, (void*)draw_context_out);
1082 g_free(prop_line_out.color);
51705146 1083 //gdk_gc_unref(draw_context_out->gc);
a56a1ba4 1084 /* Note : finishing line will have to be added when trace read over. */
1085
1086 /* Finally, update the drawing context of the pid_in. */
1087
14963be0 1088 DrawContext *draw_context_in = hashed_process_data_in->draw_context;
68997a22 1089 draw_context_in->current->modify_over->x = x;
319e9d81 1090 draw_context_in->current->modify_under->x = x;
68997a22 1091 draw_context_in->current->modify_over->y = y_in;
319e9d81 1092 draw_context_in->current->modify_under->y = y_in+(height/2)+2;
501d5405 1093 draw_context_in->drawable = control_flow_data->drawing->pixmap;
1094 draw_context_in->pango_layout = control_flow_data->drawing->pango_layout;
1095 widget = control_flow_data->drawing->drawing_area;
a56a1ba4 1096 //draw_context_in->gc = widget->style->fg_gc[GTK_WIDGET_STATE (widget)];
1097 //draw_context_in->gc = widget->style->black_gc;
d0cd7f09 1098 //draw_context_in->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
1099 //gdk_gc_copy(draw_context_in->gc, widget->style->black_gc);
a56a1ba4 1100
1101 //draw_arc((void*)&prop_arc, (void*)draw_context_in);
501d5405 1102 //test_draw_item(control_flow_data->drawing, control_flow_data->drawing->pixmap);
d0cd7f09 1103
1104 /* Draw the line/bg of the in process */
1105 if(draw_context_in->previous->middle->x == -1)
1106 {
ca0f8a8e 1107 draw_context_in->previous->over->x =
1108 control_flow_data->drawing->damage_begin;
1109 draw_context_in->previous->middle->x =
1110 control_flow_data->drawing->damage_begin;
1111 draw_context_in->previous->under->x =
1112 control_flow_data->drawing->damage_begin;
1113
1114 g_debug("in middle x_beg : %u",control_flow_data->drawing->damage_begin);
1115
d0cd7f09 1116 }
1117
1118 draw_context_in->current->middle->x = x;
1119 draw_context_in->current->over->x = x;
1120 draw_context_in->current->under->x = x;
1121 draw_context_in->current->middle->y = y_in + height/2;
1122 draw_context_in->current->over->y = y_in;
1123 draw_context_in->current->under->y = y_in + height;
1124 draw_context_in->previous->middle->y = y_in + height/2;
1125 draw_context_in->previous->over->y = y_in;
1126 draw_context_in->previous->under->y = y_in + height;
a56a1ba4 1127
d0cd7f09 1128 draw_context_in->drawable = control_flow_data->drawing->pixmap;
1129 draw_context_in->pango_layout = control_flow_data->drawing->pango_layout;
1130
1131
1132 if(process_in->state->s == LTTV_STATE_RUN)
1133 {
51705146 1134 //draw_context_in->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
1135 //gdk_gc_copy(draw_context_in->gc, widget->style->black_gc);
1136 draw_context_in->gc = control_flow_data->drawing->gc;
d0cd7f09 1137
1138 PropertiesBG prop_bg;
1139 prop_bg.color = g_new(GdkColor,1);
1140
2c82c4dc 1141 switcht(ltt_tracefile_num(tfc->tf)) {
d0cd7f09 1142 case 0:
1143 prop_bg.color->red = 0x1515;
1144 prop_bg.color->green = 0x1515;
1145 prop_bg.color->blue = 0x8c8c;
1146 break;
1147 case 1:
1148 prop_bg.color->red = 0x4e4e;
1149 prop_bg.color->green = 0xa9a9;
1150 prop_bg.color->blue = 0xa4a4;
1151 break;
1152 case 2:
1153 prop_bg.color->red = 0x7a7a;
1154 prop_bg.color->green = 0x4a4a;
1155 prop_bg.color->blue = 0x8b8b;
1156 break;
1157 case 3:
1158 prop_bg.color->red = 0x8080;
1159 prop_bg.color->green = 0x7777;
1160 prop_bg.color->blue = 0x4747;
1161 break;
1162 default:
1163 prop_bg.color->red = 0xe7e7;
1164 prop_bg.color->green = 0xe7e7;
1165 prop_bg.color->blue = 0xe7e7;
1166 }
1167
1168
1169 draw_bg((void*)&prop_bg, (void*)draw_context_in);
1170 g_free(prop_bg.color);
51705146 1171 //gdk_gc_unref(draw_context_in->gc);
d0cd7f09 1172 }
1173
1174 draw_context_in->gc = widget->style->black_gc;
1175
a56a1ba4 1176 GdkColor colorfg_in = { 0, 0x0000, 0xffff, 0x0000 };
2df6f2bd 1177 GdkColor colorbg_in = { 0, 0x0000, 0x0000, 0x0000 };
a56a1ba4 1178 PropertiesText prop_text_in;
1179 prop_text_in.foreground = &colorfg_in;
1180 prop_text_in.background = &colorbg_in;
cfe526b1 1181 prop_text_in.size = 6;
a56a1ba4 1182 prop_text_in.position = OVER;
1183
2a2fa4f0 1184 g_debug("in state : %s", g_quark_to_string(process_in->state->s));
cfe526b1 1185 /* foreground of text : status of the process */
1186 if(process_in->state->s == LTTV_STATE_UNNAMED)
1187 {
1188 prop_text_in.foreground->red = 0xffff;
1189 prop_text_in.foreground->green = 0xffff;
1190 prop_text_in.foreground->blue = 0xffff;
1191 }
1192 else if(process_in->state->s == LTTV_STATE_WAIT_FORK)
1193 {
1194 prop_text_in.foreground->red = 0x0fff;
d52cfc84 1195 prop_text_in.foreground->green = 0xffff;
1196 prop_text_in.foreground->blue = 0xfff0;
cfe526b1 1197 }
1198 else if(process_in->state->s == LTTV_STATE_WAIT_CPU)
1199 {
2df6f2bd 1200 prop_text_in.foreground->red = 0xffff;
1201 prop_text_in.foreground->green = 0xffff;
cfe526b1 1202 prop_text_in.foreground->blue = 0x0000;
1203 }
0828099d 1204 else if(process_in->state->s == LTTV_STATE_ZOMBIE)
cfe526b1 1205 {
1206 prop_text_in.foreground->red = 0xffff;
1207 prop_text_in.foreground->green = 0x0000;
1208 prop_text_in.foreground->blue = 0xffff;
1209 }
1210 else if(process_in->state->s == LTTV_STATE_WAIT)
1211 {
1212 prop_text_in.foreground->red = 0xffff;
1213 prop_text_in.foreground->green = 0x0000;
1214 prop_text_in.foreground->blue = 0x0000;
1215 }
1216 else if(process_in->state->s == LTTV_STATE_RUN)
1217 {
1218 prop_text_in.foreground->red = 0x0000;
1219 prop_text_in.foreground->green = 0xffff;
1220 prop_text_in.foreground->blue = 0x0000;
1221 }
1222 else
1223 {
1224 prop_text_in.foreground->red = 0xffff;
1225 prop_text_in.foreground->green = 0xffff;
1226 prop_text_in.foreground->blue = 0xffff;
1227 }
1228
1229
1230
a56a1ba4 1231 /* Print status of the process : U, WF, WC, E, W, R */
1232 if(process_in->state->s == LTTV_STATE_UNNAMED)
cfe526b1 1233 prop_text_in.text = "U->";
a56a1ba4 1234 else if(process_in->state->s == LTTV_STATE_WAIT_FORK)
cfe526b1 1235 prop_text_in.text = "WF->";
a56a1ba4 1236 else if(process_in->state->s == LTTV_STATE_WAIT_CPU)
cfe526b1 1237 prop_text_in.text = "WC->";
0828099d 1238 else if(process_in->state->s == LTTV_STATE_ZOMBIE)
cfe526b1 1239 prop_text_in.text = "E->";
a56a1ba4 1240 else if(process_in->state->s == LTTV_STATE_WAIT)
cfe526b1 1241 prop_text_in.text = "W->";
a56a1ba4 1242 else if(process_in->state->s == LTTV_STATE_RUN)
cfe526b1 1243 prop_text_in.text = "R->";
a56a1ba4 1244 else
68997a22 1245 prop_text_in.text = "U";
a56a1ba4 1246
1247 draw_text((void*)&prop_text_in, (void*)draw_context_in);
d0cd7f09 1248 //gdk_gc_unref(draw_context_in->gc);
1249
51705146 1250 //draw_context_in->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
1251 //gdk_gc_copy(draw_context_in->gc, widget->style->black_gc);
1252 draw_context_in->gc = control_flow_data->drawing->gc;
d0cd7f09 1253
a56a1ba4 1254 PropertiesLine prop_line_in;
1255 prop_line_in.color = g_new(GdkColor,1);
cfe526b1 1256 prop_line_in.line_width = 2;
a56a1ba4 1257 prop_line_in.style = GDK_LINE_SOLID;
1258 prop_line_in.position = MIDDLE;
1259
1260 /* color of line : status of the process */
1261 if(process_in->state->s == LTTV_STATE_UNNAMED)
1262 {
cfe526b1 1263 prop_line_in.color->red = 0xffff;
1264 prop_line_in.color->green = 0xffff;
1265 prop_line_in.color->blue = 0xffff;
a56a1ba4 1266 }
1267 else if(process_in->state->s == LTTV_STATE_WAIT_FORK)
1268 {
1269 prop_line_in.color->red = 0x0fff;
d52cfc84 1270 prop_line_in.color->green = 0xffff;
1271 prop_line_in.color->blue = 0xfff0;
a56a1ba4 1272 }
1273 else if(process_in->state->s == LTTV_STATE_WAIT_CPU)
1274 {
2df6f2bd 1275 prop_line_in.color->red = 0xffff;
1276 prop_line_in.color->green = 0xffff;
a56a1ba4 1277 prop_line_in.color->blue = 0x0000;
1278 }
0828099d 1279 else if(process_in->state->s == LTTV_STATE_ZOMBIE)
a56a1ba4 1280 {
1281 prop_line_in.color->red = 0xffff;
1282 prop_line_in.color->green = 0x0000;
1283 prop_line_in.color->blue = 0xffff;
1284 }
1285 else if(process_in->state->s == LTTV_STATE_WAIT)
1286 {
1287 prop_line_in.color->red = 0xffff;
1288 prop_line_in.color->green = 0x0000;
1289 prop_line_in.color->blue = 0x0000;
1290 }
1291 else if(process_in->state->s == LTTV_STATE_RUN)
1292 {
1293 prop_line_in.color->red = 0x0000;
1294 prop_line_in.color->green = 0xffff;
1295 prop_line_in.color->blue = 0x0000;
1296 }
1297 else
1298 {
cfe526b1 1299 prop_line_in.color->red = 0xffff;
1300 prop_line_in.color->green = 0xffff;
1301 prop_line_in.color->blue = 0xffff;
a56a1ba4 1302 }
1303
1304 draw_line((void*)&prop_line_in, (void*)draw_context_in);
1305 g_free(prop_line_in.color);
51705146 1306 //gdk_gc_unref(draw_context_in->gc);
a56a1ba4 1307 }
1308
1309 return 0;
b9a010a2 1310#endif //0
1311
1312
a56a1ba4 1313
51705146 1314 /* Text dump */
80a52ff8 1315#ifdef DONTSHOW
a56a1ba4 1316 GString *string = g_string_new("");;
1317 gboolean field_names = TRUE, state = TRUE;
80a52ff8 1318
e9a9c513 1319 lttv_event_to_string(e, tfc->tf, string, TRUE, field_names, tfs);
1320 g_string_append_printf(string,"\n");
1321
1322 if(state) {
1323 g_string_append_printf(string, " %s",
1324 g_quark_to_string(tfs->process->state->s));
1325 }
1326
1327 g_info("%s",string->str);
1328
a56a1ba4 1329 g_string_free(string, TRUE);
1330
1331 /* End of text dump */
80a52ff8 1332#endif //DONTSHOW
50439712 1333
f0d936c0 1334}
1335
e92eabaf 1336/* after_schedchange_hook
b9a010a2 1337 *
1338 * The draw after hook is called by the reading API to have a
1339 * particular event drawn on the screen.
1340 * @param hook_data ControlFlowData structure of the viewer.
1341 * @param call_data Event context.
1342 *
1343 * This function adds items to be drawn in a queue for each process.
1344 *
1345 */
e92eabaf 1346int after_schedchange_hook(void *hook_data, void *call_data)
f0d936c0 1347{
2c82c4dc 1348 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
1349 EventsRequest *events_request = (EventsRequest*)thf->hook_data;
ca0f8a8e 1350 ControlFlowData *control_flow_data = events_request->viewer_data;
50439712 1351
a56a1ba4 1352 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
50439712 1353
1354 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1355
b9a010a2 1356 LttEvent *e;
2c82c4dc 1357 e = ltt_tracefile_get_event(tfc->tf);
b9a010a2 1358
1359 LttTime evtime = ltt_event_time(e);
b9a010a2 1360
10a1069a 1361 /* Add process to process list (if not present) */
2eef04b5 1362 LttvProcessState *process_in;
10a1069a 1363 LttTime birth;
1c736ed5 1364 guint pl_height = 0;
10a1069a 1365 HashedProcessData *hashed_process_data_in = NULL;
b9a010a2 1366
5c230fc4 1367 ProcessList *process_list = control_flow_data->process_list;
10a1069a 1368
1369 guint pid_in;
1370 {
1371 guint pid_out;
2c82c4dc 1372 pid_out = ltt_event_get_long_unsigned(e, thf->f1);
1373 pid_in = ltt_event_get_long_unsigned(e, thf->f2);
10a1069a 1374 }
b9a010a2 1375
1376
10a1069a 1377 /* Find process pid_in in the list... */
40debf7b 1378 //process_in = lttv_state_find_process(tfs, pid_in);
1379 process_in = tfs->process;
10a1069a 1380 /* It should exist, because we are after the state update. */
96947fcf 1381#ifdef EXTRA_CHECK
10a1069a 1382 g_assert(process_in != NULL);
96947fcf 1383#endif //EXTRA_CHECK
10a1069a 1384 birth = process_in->creation_time;
b9a010a2 1385
ac4e21cf 1386 hashed_process_data_in = processlist_get_process_data(process_list,
10a1069a 1387 pid_in,
40debf7b 1388 process_in->last_cpu_index,
10a1069a 1389 &birth,
ac4e21cf 1390 tfc->t_context->index);
1391 if(hashed_process_data_in == NULL)
10a1069a 1392 {
1393 g_assert(pid_in == 0 || pid_in != process_in->ppid);
aac69e70 1394 const gchar *name = g_quark_to_string(process_in->name);
4e86ae2e 1395 ProcessInfo *process_info;
1c736ed5 1396 Drawing_t *drawing = control_flow_data->drawing;
10a1069a 1397 /* Process not present */
1398 processlist_add(process_list,
1c736ed5 1399 drawing,
10a1069a 1400 pid_in,
40debf7b 1401 process_in->last_cpu_index,
10a1069a 1402 process_in->ppid,
1403 &birth,
1404 tfc->t_context->index,
1405 name,
1406 &pl_height,
4e86ae2e 1407 &process_info,
10a1069a 1408 &hashed_process_data_in);
1c736ed5 1409 gtk_widget_set_size_request(drawing->drawing_area,
1410 -1,
1411 pl_height);
1412 gtk_widget_queue_draw(drawing->drawing_area);
b9a010a2 1413 }
40debf7b 1414 /* Set the current process */
1415 process_list->current_hash_data[process_in->last_cpu_index] =
1416 hashed_process_data_in;
10a1069a 1417
b2743953 1418 if(ltt_time_compare(hashed_process_data_in->next_good_time,
1419 evtime) <= 0)
1420 {
fd22065b 1421 TimeWindow time_window =
1422 lttvwindow_get_time_window(control_flow_data->tab);
1423
1424#ifdef EXTRA_CHECK
1425 if(ltt_time_compare(evtime, time_window.start_time) == -1
1426 || ltt_time_compare(evtime, time_window.end_time) == 1)
1427 return;
1428#endif //EXTRA_CHECK
d6fef890 1429 Drawing_t *drawing = control_flow_data->drawing;
1430 guint width = drawing->width;
b2743953 1431 guint new_x;
1432
1433 convert_time_to_pixels(
1434 time_window,
1435 evtime,
1436 width,
1437 &new_x);
e72908ed 1438
b2743953 1439 if(hashed_process_data_in->x.middle != new_x) {
1440 hashed_process_data_in->x.middle = new_x;
1441 hashed_process_data_in->x.middle_used = FALSE;
1442 hashed_process_data_in->x.middle_marked = FALSE;
1443 }
1444 }
b9a010a2 1445 return 0;
1446
1447
1448
e72908ed 1449
1450
b9a010a2 1451#if 0
1452 EventsRequest *events_request = (EventsRequest*)hook_data;
1453 ControlFlowData *control_flow_data = events_request->viewer_data;
1454
1455 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
1456
1457 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
1458 LttvTraceState *ts =(LttvTraceState *)LTTV_TRACEFILE_CONTEXT(tfs)->t_context;
1459
a56a1ba4 1460
50439712 1461 LttEvent *e;
1462 e = tfc->e;
1463
9444deae 1464 LttTime evtime = ltt_event_time(e);
ca0f8a8e 1465 TimeWindow time_window =
1466 lttvwindow_get_time_window(control_flow_data->tab);
9444deae 1467
a2aab3a3 1468 LttTime time_window.end_time = time_window.time_window.end_time;
6f26fc38 1469
9444deae 1470 //if(time < time_beg || time > time_end) return;
ca0f8a8e 1471 if(ltt_time_compare(evtime, time_window.start_time) == -1
a2aab3a3 1472 || ltt_time_compare(evtime, time_window.end_time) == 1)
9444deae 1473 return;
1474
1475
a56a1ba4 1476 if(strcmp(ltt_eventtype_name(ltt_event_eventtype(e)),"schedchange") == 0)
1477 {
2a2fa4f0 1478 g_debug("schedchange!");
a56a1ba4 1479
1480 /* Add process to process list (if not present) and get drawing "y" from
1481 * process position */
1482 guint pid_out, pid_in;
1483 LttvProcessState *process_out, *process_in;
1484 LttTime birth;
1485 guint y_in = 0, y_out = 0, height = 0, pl_height = 0;
1486
5c230fc4 1487 ProcessList *process_list = control_flow_data->process_list;
a56a1ba4 1488
1489
1490 LttField *f = ltt_event_field(e);
1491 LttField *element;
1492 element = ltt_field_member(f,0);
1493 pid_out = ltt_event_get_long_unsigned(e,element);
1494 element = ltt_field_member(f,1);
1495 pid_in = ltt_event_get_long_unsigned(e,element);
2a2fa4f0 1496 //g_debug("out : %u in : %u", pid_out, pid_in);
a56a1ba4 1497
1498
1499 /* Find process pid_out in the list... */
2a2fa4f0 1500 process_out = lttv_state_find_process(tfs, pid_out);
1aff52a2 1501 if(process_out == NULL) return 0;
2a2fa4f0 1502 //g_debug("out : %s",g_quark_to_string(process_out->state->s));
a56a1ba4 1503
1504 birth = process_out->creation_time;
1505 gchar *name = strdup(g_quark_to_string(process_out->name));
14963be0 1506 HashedProcessData *hashed_process_data_out = NULL;
a56a1ba4 1507
1508 if(processlist_get_process_pixels(process_list,
1509 pid_out,
1510 &birth,
d0cd7f09 1511 tfc->t_context->index,
a56a1ba4 1512 &y_out,
1513 &height,
14963be0 1514 &hashed_process_data_out) == 1)
a56a1ba4 1515 {
51705146 1516 /* Process not present */
1517 processlist_add(process_list,
1518 pid_out,
1519 &birth,
1520 tfc->t_context->index,
1521 name,
1522 &pl_height,
1523 &hashed_process_data_out);
1524 processlist_get_process_pixels(process_list,
1525 pid_out,
1526 &birth,
1527 tfc->t_context->index,
1528 &y_out,
1529 &height,
1530 &hashed_process_data_out);
1531 drawing_insert_square( control_flow_data->drawing, y_out, height);
a56a1ba4 1532 }
1533
1534 g_free(name);
1535
1536 /* Find process pid_in in the list... */
2a2fa4f0 1537 process_in = lttv_state_find_process(tfs, pid_in);
1aff52a2 1538 if(process_in == NULL) return 0;
2a2fa4f0 1539 //g_debug("in : %s",g_quark_to_string(process_in->state->s));
a56a1ba4 1540
1541 birth = process_in->creation_time;
1542 name = strdup(g_quark_to_string(process_in->name));
14963be0 1543 HashedProcessData *hashed_process_data_in = NULL;
a56a1ba4 1544
1545 if(processlist_get_process_pixels(process_list,
1546 pid_in,
1547 &birth,
d0cd7f09 1548 tfc->t_context->index,
a56a1ba4 1549 &y_in,
1550 &height,
14963be0 1551 &hashed_process_data_in) == 1)
a56a1ba4 1552 {
1553 /* Process not present */
1554 processlist_add(process_list,
1555 pid_in,
1556 &birth,
d0cd7f09 1557 tfc->t_context->index,
a56a1ba4 1558 name,
1559 &pl_height,
14963be0 1560 &hashed_process_data_in);
a56a1ba4 1561 processlist_get_process_pixels(process_list,
1562 pid_in,
1563 &birth,
d0cd7f09 1564 tfc->t_context->index,
a56a1ba4 1565 &y_in,
1566 &height,
14963be0 1567 &hashed_process_data_in);
a56a1ba4 1568
ca0f8a8e 1569 drawing_insert_square( control_flow_data->drawing, y_in, height);
a56a1ba4 1570 }
1571 g_free(name);
1572
1573
1574 /* Find pixels corresponding to time of the event. If the time does
1575 * not fit in the window, show a warning, not supposed to happend. */
1576 //guint x = 0;
501d5405 1577 //guint width = control_flow_data->drawing->drawing_area->allocation.width;
a56a1ba4 1578
1579 //LttTime time = ltt_event_time(e);
1580
a2aab3a3 1581 //LttTime window_end = time_window->time_window.end_time;
a56a1ba4 1582
1583
1584 //convert_time_to_pixels(
a18124ff 1585 // *time_window,
a56a1ba4 1586 // time,
1587 // width,
1588 // &x);
1589
1590 //assert(x <= width);
1591
1592 /* draw what represents the event for outgoing process. */
1593
14963be0 1594 DrawContext *draw_context_out = hashed_process_data_out->draw_context;
68997a22 1595 //draw_context_out->current->modify_over->x = x;
1596 draw_context_out->current->modify_over->y = y_out;
319e9d81 1597 draw_context_out->current->modify_under->y = y_out+(height/2)+2;
501d5405 1598 draw_context_out->drawable = control_flow_data->drawing->pixmap;
1599 draw_context_out->pango_layout = control_flow_data->drawing->pango_layout;
1600 GtkWidget *widget = control_flow_data->drawing->drawing_area;
a56a1ba4 1601 //draw_context_out->gc = widget->style->fg_gc[GTK_WIDGET_STATE (widget)];
d0cd7f09 1602
a56a1ba4 1603 //draw_arc((void*)&prop_arc, (void*)draw_context_out);
501d5405 1604 //test_draw_item(control_flow_data->drawing, control_flow_data->drawing->pixmap);
d0cd7f09 1605
1606 /*if(process_out->state->s == LTTV_STATE_RUN)
1607 {
1608 draw_context_out->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
1609 gdk_gc_copy(draw_context_out->gc, widget->style->black_gc);
1610 PropertiesBG prop_bg;
1611 prop_bg.color = g_new(GdkColor,1);
1612
1613 prop_bg.color->red = 0xffff;
1614 prop_bg.color->green = 0xffff;
1615 prop_bg.color->blue = 0xffff;
1616
1617 draw_bg((void*)&prop_bg, (void*)draw_context_out);
1618 g_free(prop_bg.color);
1619 gdk_gc_unref(draw_context_out->gc);
1620 }*/
1621
1622 draw_context_out->gc = widget->style->black_gc;
1623
a56a1ba4 1624 GdkColor colorfg_out = { 0, 0xffff, 0x0000, 0x0000 };
2df6f2bd 1625 GdkColor colorbg_out = { 0, 0x0000, 0x0000, 0x0000 };
a56a1ba4 1626 PropertiesText prop_text_out;
1627 prop_text_out.foreground = &colorfg_out;
1628 prop_text_out.background = &colorbg_out;
cfe526b1 1629 prop_text_out.size = 6;
a56a1ba4 1630 prop_text_out.position = OVER;
1631
cfe526b1 1632 /* color of text : status of the process */
1633 if(process_out->state->s == LTTV_STATE_UNNAMED)
1634 {
1635 prop_text_out.foreground->red = 0xffff;
1636 prop_text_out.foreground->green = 0xffff;
1637 prop_text_out.foreground->blue = 0xffff;
1638 }
1639 else if(process_out->state->s == LTTV_STATE_WAIT_FORK)
1640 {
1641 prop_text_out.foreground->red = 0x0fff;
d52cfc84 1642 prop_text_out.foreground->green = 0xffff;
1643 prop_text_out.foreground->blue = 0xfff0;
cfe526b1 1644 }
1645 else if(process_out->state->s == LTTV_STATE_WAIT_CPU)
1646 {
2df6f2bd 1647 prop_text_out.foreground->red = 0xffff;
1648 prop_text_out.foreground->green = 0xffff;
cfe526b1 1649 prop_text_out.foreground->blue = 0x0000;
1650 }
0828099d 1651 else if(process_out->state->s == LTTV_STATE_ZOMBIE)
cfe526b1 1652 {
1653 prop_text_out.foreground->red = 0xffff;
1654 prop_text_out.foreground->green = 0x0000;
1655 prop_text_out.foreground->blue = 0xffff;
1656 }
1657 else if(process_out->state->s == LTTV_STATE_WAIT)
1658 {
1659 prop_text_out.foreground->red = 0xffff;
1660 prop_text_out.foreground->green = 0x0000;
1661 prop_text_out.foreground->blue = 0x0000;
1662 }
1663 else if(process_out->state->s == LTTV_STATE_RUN)
1664 {
1665 prop_text_out.foreground->red = 0x0000;
1666 prop_text_out.foreground->green = 0xffff;
1667 prop_text_out.foreground->blue = 0x0000;
1668 }
1669 else
1670 {
1671 prop_text_out.foreground->red = 0xffff;
1672 prop_text_out.foreground->green = 0xffff;
1673 prop_text_out.foreground->blue = 0xffff;
1674 }
1675
a56a1ba4 1676 /* Print status of the process : U, WF, WC, E, W, R */
1677 if(process_out->state->s == LTTV_STATE_UNNAMED)
68997a22 1678 prop_text_out.text = "U";
a56a1ba4 1679 else if(process_out->state->s == LTTV_STATE_WAIT_FORK)
68997a22 1680 prop_text_out.text = "WF";
a56a1ba4 1681 else if(process_out->state->s == LTTV_STATE_WAIT_CPU)
68997a22 1682 prop_text_out.text = "WC";
0828099d 1683 else if(process_out->state->s == LTTV_STATE_ZOMBIE)
68997a22 1684 prop_text_out.text = "E";
a56a1ba4 1685 else if(process_out->state->s == LTTV_STATE_WAIT)
68997a22 1686 prop_text_out.text = "W";
a56a1ba4 1687 else if(process_out->state->s == LTTV_STATE_RUN)
68997a22 1688 prop_text_out.text = "R";
a56a1ba4 1689 else
68997a22 1690 prop_text_out.text = "U";
a56a1ba4 1691
1692 draw_text((void*)&prop_text_out, (void*)draw_context_out);
d0cd7f09 1693
1694 //gdk_gc_unref(draw_context_out->gc);
319e9d81 1695
68997a22 1696 draw_context_out->current->middle->y = y_out+height/2;
d0cd7f09 1697 draw_context_out->current->over->y = y_out;
1698 draw_context_out->current->under->y = y_out+height;
68997a22 1699 draw_context_out->current->status = process_out->state->s;
a56a1ba4 1700
68997a22 1701 /* for pid_out : remove previous, Prev = current, new current (default) */
1702 g_free(draw_context_out->previous->modify_under);
1703 g_free(draw_context_out->previous->modify_middle);
1704 g_free(draw_context_out->previous->modify_over);
1705 g_free(draw_context_out->previous->under);
1706 g_free(draw_context_out->previous->middle);
1707 g_free(draw_context_out->previous->over);
1708 g_free(draw_context_out->previous);
1709
1710 draw_context_out->previous = draw_context_out->current;
a56a1ba4 1711
68997a22 1712 draw_context_out->current = g_new(DrawInfo,1);
1713 draw_context_out->current->over = g_new(ItemInfo,1);
1714 draw_context_out->current->over->x = -1;
1715 draw_context_out->current->over->y = -1;
1716 draw_context_out->current->middle = g_new(ItemInfo,1);
1717 draw_context_out->current->middle->x = -1;
1718 draw_context_out->current->middle->y = -1;
1719 draw_context_out->current->under = g_new(ItemInfo,1);
1720 draw_context_out->current->under->x = -1;
1721 draw_context_out->current->under->y = -1;
1722 draw_context_out->current->modify_over = g_new(ItemInfo,1);
1723 draw_context_out->current->modify_over->x = -1;
1724 draw_context_out->current->modify_over->y = -1;
1725 draw_context_out->current->modify_middle = g_new(ItemInfo,1);
1726 draw_context_out->current->modify_middle->x = -1;
1727 draw_context_out->current->modify_middle->y = -1;
1728 draw_context_out->current->modify_under = g_new(ItemInfo,1);
1729 draw_context_out->current->modify_under->x = -1;
1730 draw_context_out->current->modify_under->y = -1;
1731 draw_context_out->current->status = LTTV_STATE_UNNAMED;
a56a1ba4 1732
1733 /* Finally, update the drawing context of the pid_in. */
1734
14963be0 1735 DrawContext *draw_context_in = hashed_process_data_in->draw_context;
68997a22 1736 //draw_context_in->current->modify_over->x = x;
1737 draw_context_in->current->modify_over->y = y_in;
319e9d81 1738 draw_context_in->current->modify_under->y = y_in+(height/2)+2;
501d5405 1739 draw_context_in->drawable = control_flow_data->drawing->pixmap;
1740 draw_context_in->pango_layout = control_flow_data->drawing->pango_layout;
1741 widget = control_flow_data->drawing->drawing_area;
a56a1ba4 1742 //draw_context_in->gc = widget->style->fg_gc[GTK_WIDGET_STATE (widget)];
a56a1ba4 1743
1744 //draw_arc((void*)&prop_arc, (void*)draw_context_in);
501d5405 1745 //test_draw_item(control_flow_data->drawing, control_flow_data->drawing->pixmap);
d0cd7f09 1746
1747 /*if(process_in->state->s == LTTV_STATE_RUN)
1748 {
1749 draw_context_in->gc = gdk_gc_new(control_flow_data->drawing->pixmap);
1750 gdk_gc_copy(draw_context_in->gc, widget->style->black_gc);
1751 PropertiesBG prop_bg;
1752 prop_bg.color = g_new(GdkColor,1);
1753
1754 prop_bg.color->red = 0xffff;
1755 prop_bg.color->green = 0xffff;
1756 prop_bg.color->blue = 0xffff;
1757
1758 draw_bg((void*)&prop_bg, (void*)draw_context_in);
1759 g_free(prop_bg.color);
1760 gdk_gc_unref(draw_context_in->gc);
1761 }*/
1762
1763 draw_context_in->gc = widget->style->black_gc;
1764
a56a1ba4 1765 GdkColor colorfg_in = { 0, 0x0000, 0xffff, 0x0000 };
2df6f2bd 1766 GdkColor colorbg_in = { 0, 0x0000, 0x0000, 0x0000 };
a56a1ba4 1767 PropertiesText prop_text_in;
1768 prop_text_in.foreground = &colorfg_in;
1769 prop_text_in.background = &colorbg_in;
cfe526b1 1770 prop_text_in.size = 6;
a56a1ba4 1771 prop_text_in.position = OVER;
1772
cfe526b1 1773 /* foreground of text : status of the process */
1774 if(process_in->state->s == LTTV_STATE_UNNAMED)
1775 {
1776 prop_text_in.foreground->red = 0xffff;
1777 prop_text_in.foreground->green = 0xffff;
1778 prop_text_in.foreground->blue = 0xffff;
1779 }
1780 else if(process_in->state->s == LTTV_STATE_WAIT_FORK)
1781 {
1782 prop_text_in.foreground->red = 0x0fff;
d52cfc84 1783 prop_text_in.foreground->green = 0xffff;
1784 prop_text_in.foreground->blue = 0xfff0;
cfe526b1 1785 }
1786 else if(process_in->state->s == LTTV_STATE_WAIT_CPU)
1787 {
2df6f2bd 1788 prop_text_in.foreground->red = 0xffff;
1789 prop_text_in.foreground->green = 0xffff;
cfe526b1 1790 prop_text_in.foreground->blue = 0x0000;
1791 }
0828099d 1792 else if(process_in->state->s == LTTV_STATE_ZOMBIE)
cfe526b1 1793 {
1794 prop_text_in.foreground->red = 0xffff;
1795 prop_text_in.foreground->green = 0x0000;
1796 prop_text_in.foreground->blue = 0xffff;
1797 }
1798 else if(process_in->state->s == LTTV_STATE_WAIT)
1799 {
1800 prop_text_in.foreground->red = 0xffff;
1801 prop_text_in.foreground->green = 0x0000;
1802 prop_text_in.foreground->blue = 0x0000;
1803 }
1804 else if(process_in->state->s == LTTV_STATE_RUN)
1805 {
1806 prop_text_in.foreground->red = 0x0000;
1807 prop_text_in.foreground->green = 0xffff;
1808 prop_text_in.foreground->blue = 0x0000;
1809 }
1810 else
1811 {
1812 prop_text_in.foreground->red = 0xffff;
1813 prop_text_in.foreground->green = 0xffff;
1814 prop_text_in.foreground->blue = 0xffff;
1815 }
1816
1817
a56a1ba4 1818 /* Print status of the process : U, WF, WC, E, W, R */
1819 if(process_in->state->s == LTTV_STATE_UNNAMED)
68997a22 1820 prop_text_in.text = "U";
a56a1ba4 1821 else if(process_in->state->s == LTTV_STATE_WAIT_FORK)
68997a22 1822 prop_text_in.text = "WF";
a56a1ba4 1823 else if(process_in->state->s == LTTV_STATE_WAIT_CPU)
68997a22 1824 prop_text_in.text = "WC";
0828099d 1825 else if(process_in->state->s == LTTV_STATE_ZOMBIE)
68997a22 1826 prop_text_in.text = "E";
a56a1ba4 1827 else if(process_in->state->s == LTTV_STATE_WAIT)
68997a22 1828 prop_text_in.text = "W";
a56a1ba4 1829 else if(process_in->state->s == LTTV_STATE_RUN)
68997a22 1830 prop_text_in.text = "R";
a56a1ba4 1831 else
68997a22 1832 prop_text_in.text = "U";
a56a1ba4 1833
1834 draw_text((void*)&prop_text_in, (void*)draw_context_in);
1835
d0cd7f09 1836
319e9d81 1837 if(process_in->state->s == LTTV_STATE_RUN)
1838 {
1839 gchar tmp[255];
1840 prop_text_in.foreground = &colorfg_in;
1841 prop_text_in.background = &colorbg_in;
1842 prop_text_in.foreground->red = 0xffff;
1843 prop_text_in.foreground->green = 0xffff;
1844 prop_text_in.foreground->blue = 0xffff;
1845 prop_text_in.size = 6;
1846 prop_text_in.position = UNDER;
1847
1848 prop_text_in.text = g_new(gchar, 260);
1849 strcpy(prop_text_in.text, "CPU ");
2c82c4dc 1850 snprintf(tmp, 255, "%u", ltt_tracefile_num(tfc->tf));
319e9d81 1851 strcat(prop_text_in.text, tmp);
1852
1853 draw_text((void*)&prop_text_in, (void*)draw_context_in);
1854 g_free(prop_text_in.text);
1855 }
1856
1857
68997a22 1858 draw_context_in->current->middle->y = y_in+height/2;
d0cd7f09 1859 draw_context_in->current->over->y = y_in;
1860 draw_context_in->current->under->y = y_in+height;
68997a22 1861 draw_context_in->current->status = process_in->state->s;
1862
1863 /* for pid_in : remove previous, Prev = current, new current (default) */
1864 g_free(draw_context_in->previous->modify_under);
1865 g_free(draw_context_in->previous->modify_middle);
1866 g_free(draw_context_in->previous->modify_over);
1867 g_free(draw_context_in->previous->under);
1868 g_free(draw_context_in->previous->middle);
1869 g_free(draw_context_in->previous->over);
1870 g_free(draw_context_in->previous);
1871
1872 draw_context_in->previous = draw_context_in->current;
a56a1ba4 1873
68997a22 1874 draw_context_in->current = g_new(DrawInfo,1);
1875 draw_context_in->current->over = g_new(ItemInfo,1);
1876 draw_context_in->current->over->x = -1;
1877 draw_context_in->current->over->y = -1;
1878 draw_context_in->current->middle = g_new(ItemInfo,1);
1879 draw_context_in->current->middle->x = -1;
1880 draw_context_in->current->middle->y = -1;
1881 draw_context_in->current->under = g_new(ItemInfo,1);
1882 draw_context_in->current->under->x = -1;
1883 draw_context_in->current->under->y = -1;
1884 draw_context_in->current->modify_over = g_new(ItemInfo,1);
1885 draw_context_in->current->modify_over->x = -1;
1886 draw_context_in->current->modify_over->y = -1;
1887 draw_context_in->current->modify_middle = g_new(ItemInfo,1);
1888 draw_context_in->current->modify_middle->x = -1;
1889 draw_context_in->current->modify_middle->y = -1;
1890 draw_context_in->current->modify_under = g_new(ItemInfo,1);
1891 draw_context_in->current->modify_under->x = -1;
1892 draw_context_in->current->modify_under->y = -1;
1893 draw_context_in->current->status = LTTV_STATE_UNNAMED;
a56a1ba4 1894
1895 }
1896
1897 return 0;
b9a010a2 1898#endif //0
f0d936c0 1899}
f7afe191 1900
9a1ec01b 1901#if 0
6550d711 1902static inline PropertiesLine prepare_execmode_line(LttvProcessState *process)
23093869 1903{
1904 PropertiesLine prop_line;
1905 prop_line.line_width = 1;
1906 prop_line.style = GDK_LINE_SOLID;
1907 prop_line.y = OVER;
1908 //GdkColormap *colormap = gdk_colormap_get_system();
1909
1910 /* color of line : execution mode of the process */
1911 if(process->state->t == LTTV_STATE_USER_MODE)
1912 prop_line.color = drawing_colors[COL_USER_MODE];
1913 else if(process->state->t == LTTV_STATE_SYSCALL)
1914 prop_line.color = drawing_colors[COL_SYSCALL];
1915 else if(process->state->t == LTTV_STATE_TRAP)
1916 prop_line.color = drawing_colors[COL_TRAP];
1917 else if(process->state->t == LTTV_STATE_IRQ)
1918 prop_line.color = drawing_colors[COL_IRQ];
1919 else if(process->state->t == LTTV_STATE_MODE_UNKNOWN)
1920 prop_line.color = drawing_colors[COL_MODE_UNKNOWN];
1921 else
1922 prop_line.color = drawing_colors[COL_WHITE];
1923
1924 //gdk_colormap_alloc_color(colormap,
1925 // prop_line.color,
1926 // FALSE,
1927 // TRUE);
1928
1929 return prop_line;
1930
1931}
9a1ec01b 1932#endif //0
23093869 1933
1934
1935/* before_execmode_hook
1936 *
1937 * This function basically draw lines and icons. Two types of lines are drawn :
1938 * one small (3 pixels?) representing the state of the process and the second
1939 * type is thicker (10 pixels?) representing on which CPU a process is running
1940 * (and this only in running state).
1941 *
1942 * Extremums of the lines :
1943 * x_min : time of the last event context for this process kept in memory.
1944 * x_max : time of the current event.
1945 * y : middle of the process in the process list. The process is found in the
1946 * list, therefore is it's position in pixels.
1947 *
1948 * The choice of lines'color is defined by the context of the last event for this
1949 * process.
1950 */
1951
1952
1953int before_execmode_hook(void *hook_data, void *call_data)
1954{
088f6772 1955 return 0; //DISABLED
2c82c4dc 1956 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
1957 EventsRequest *events_request = (EventsRequest*)thf->hook_data;
23093869 1958 ControlFlowData *control_flow_data = events_request->viewer_data;
23093869 1959
1960 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
1961
1962 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
23093869 1963
1964 LttEvent *e;
2c82c4dc 1965 e = ltt_tracefile_get_event(tfc->tf);
23093869 1966
1967 LttTime evtime = ltt_event_time(e);
23093869 1968
10a1069a 1969 /* we are in a execmode, before the state update. We must draw the
1970 * items corresponding to the state before it changes : now is the right
1971 * time to do it.
1972 */
1973 /* For the pid */
1974 LttvProcessState *process = tfs->process;
1975 g_assert(process != NULL);
23093869 1976
10a1069a 1977 guint pid = process->pid;
23093869 1978
10a1069a 1979 /* Well, the process_out existed : we must get it in the process hash
1980 * or add it, and draw its items.
1981 */
1982 /* Add process to process list (if not present) */
1c736ed5 1983 guint pl_height = 0;
10a1069a 1984 HashedProcessData *hashed_process_data = NULL;
5c230fc4 1985 ProcessList *process_list = control_flow_data->process_list;
10a1069a 1986 LttTime birth = process->creation_time;
40debf7b 1987
2c82c4dc 1988 if(likely(process_list->current_hash_data[ltt_tracefile_num(tfc->tf)] != NULL)) {
1989 hashed_process_data = process_list->current_hash_data[ltt_tracefile_num(tfc->tf)];
40debf7b 1990 } else {
ac4e21cf 1991 hashed_process_data = processlist_get_process_data(process_list,
40debf7b 1992 pid,
1993 process->last_cpu_index,
1994 &birth,
ac4e21cf 1995 tfc->t_context->index);
1d1df11d 1996 if(unlikely(hashed_process_data == NULL))
40debf7b 1997 {
1998 g_assert(pid == 0 || pid != process->ppid);
1999 ProcessInfo *process_info;
2000 /* Process not present */
1c736ed5 2001 Drawing_t *drawing = control_flow_data->drawing;
40debf7b 2002 const gchar *name = g_quark_to_string(process->name);
2003 processlist_add(process_list,
1c736ed5 2004 drawing,
40debf7b 2005 pid,
2006 process->last_cpu_index,
2007 process->ppid,
2008 &birth,
2009 tfc->t_context->index,
2010 name,
2011 &pl_height,
2012 &process_info,
2013 &hashed_process_data);
1c736ed5 2014 gtk_widget_set_size_request(drawing->drawing_area,
2015 -1,
2016 pl_height);
2017 gtk_widget_queue_draw(drawing->drawing_area);
40debf7b 2018 }
2019 /* Set the current process */
2020 process_list->current_hash_data[process->last_cpu_index] =
2021 hashed_process_data;
10a1069a 2022 }
23093869 2023
10a1069a 2024 /* Now, the process is in the state hash and our own process hash.
2025 * We definitely can draw the items related to the ending state.
2026 */
b2743953 2027
1d1df11d 2028 if(likely(ltt_time_compare(hashed_process_data->next_good_time,
2029 evtime) > 0))
10a1069a 2030 {
1d1df11d 2031 if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
fd22065b 2032 TimeWindow time_window =
2033 lttvwindow_get_time_window(control_flow_data->tab);
2034
2035#ifdef EXTRA_CHECK
2036 if(ltt_time_compare(evtime, time_window.start_time) == -1
2037 || ltt_time_compare(evtime, time_window.end_time) == 1)
2038 return;
2039#endif //EXTRA_CHECK
d6fef890 2040 Drawing_t *drawing = control_flow_data->drawing;
96947fcf 2041 guint width = drawing->width;
b2743953 2042 guint x;
2043 convert_time_to_pixels(
2044 time_window,
2045 evtime,
2046 width,
2047 &x);
2048
2049 /* Draw collision indicator */
2050 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
1c736ed5 2051 gdk_draw_point(hashed_process_data->pixmap,
b2743953 2052 drawing->gc,
2053 x,
1c736ed5 2054 (hashed_process_data->height/2)-3);
b2743953 2055 hashed_process_data->x.middle_marked = TRUE;
2056 }
2057 } else {
fd22065b 2058 TimeWindow time_window =
2059 lttvwindow_get_time_window(control_flow_data->tab);
2060
2061#ifdef EXTRA_CHECK
2062 if(ltt_time_compare(evtime, time_window.start_time) == -1
2063 || ltt_time_compare(evtime, time_window.end_time) == 1)
2064 return;
2065#endif //EXTRA_CHECK
d6fef890 2066 Drawing_t *drawing = control_flow_data->drawing;
96947fcf 2067 guint width = drawing->width;
10a1069a 2068 guint x;
dbd243b1 2069
10a1069a 2070 convert_time_to_pixels(
a18124ff 2071 time_window,
10a1069a 2072 evtime,
2073 width,
2074 &x);
dbd243b1 2075
23093869 2076
4b7dc462 2077 /* Jump over draw if we are at the same x position */
1d1df11d 2078 if(unlikely(x == hashed_process_data->x.middle &&
2079 hashed_process_data->x.middle_used))
10a1069a 2080 {
1d1df11d 2081 if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
e72908ed 2082 /* Draw collision indicator */
2083 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
1c736ed5 2084 gdk_draw_point(hashed_process_data->pixmap,
e72908ed 2085 drawing->gc,
2086 x,
1c736ed5 2087 (hashed_process_data->height/2)-3);
de4ea1ad 2088 hashed_process_data->x.middle_marked = TRUE;
e72908ed 2089 }
4b7dc462 2090 /* jump */
2091 } else {
2092
2093 DrawContext draw_context;
2094 /* Now create the drawing context that will be used to draw
2095 * items related to the last state. */
1c736ed5 2096 draw_context.drawable = hashed_process_data->pixmap;
4b7dc462 2097 draw_context.gc = drawing->gc;
2098 draw_context.pango_layout = drawing->pango_layout;
9a1ec01b 2099 draw_context.drawinfo.start.x = hashed_process_data->x.middle;
4b7dc462 2100 draw_context.drawinfo.end.x = x;
2101
1c736ed5 2102 draw_context.drawinfo.y.over = 1;
2103 draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
2104 draw_context.drawinfo.y.under = hashed_process_data->height;
4b7dc462 2105
2106 draw_context.drawinfo.start.offset.over = 0;
2107 draw_context.drawinfo.start.offset.middle = 0;
2108 draw_context.drawinfo.start.offset.under = 0;
2109 draw_context.drawinfo.end.offset.over = 0;
2110 draw_context.drawinfo.end.offset.middle = 0;
2111 draw_context.drawinfo.end.offset.under = 0;
2112
2113 {
2114 /* Draw the line */
9a1ec01b 2115 PropertiesLine prop_line = prepare_s_e_line(process);
4b7dc462 2116 draw_line((void*)&prop_line, (void*)&draw_context);
23093869 2117
4b7dc462 2118 }
2119 /* become the last x position */
9a1ec01b 2120 hashed_process_data->x.middle = x;
e72908ed 2121 hashed_process_data->x.middle_used = TRUE;
2122 hashed_process_data->x.middle_marked = FALSE;
b2743953 2123
2124 /* Calculate the next good time */
2125 convert_pixels_to_time(width, x+1, time_window,
2126 &hashed_process_data->next_good_time);
23093869 2127 }
2128 }
2129
2130 return 0;
2131}
2132
2133/* after_execmode_hook
2134 *
2135 * The draw after hook is called by the reading API to have a
2136 * particular event drawn on the screen.
2137 * @param hook_data ControlFlowData structure of the viewer.
2138 * @param call_data Event context.
2139 *
2140 * This function adds items to be drawn in a queue for each process.
2141 *
2142 */
2143int after_execmode_hook(void *hook_data, void *call_data)
2144{
8869ac08 2145 /**************** DOES NOTHING!! *************/
2146 /* hook desactivated in drawing.c */
2147 return 0;
2148
2149
2c82c4dc 2150 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
2151 EventsRequest *events_request = (EventsRequest*)thf->hook_data;
23093869 2152 ControlFlowData *control_flow_data = events_request->viewer_data;
2153
2154 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
2155
2156 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
23093869 2157
2158 LttEvent *e;
2c82c4dc 2159 e = ltt_tracefile_get_event(tfc->tf);
23093869 2160
2161 LttTime evtime = ltt_event_time(e);
23093869 2162
10a1069a 2163 /* Add process to process list (if not present) */
2164 LttvProcessState *process;
2165 LttTime birth;
1c736ed5 2166 guint pl_height = 0;
10a1069a 2167 HashedProcessData *hashed_process_data = NULL;
23093869 2168
5c230fc4 2169 ProcessList *process_list = control_flow_data->process_list;
23093869 2170
10a1069a 2171 /* Find process pid_in in the list... */
2172 process = tfs->process;
2173 /* It should exist, because we are after the state update. */
2174 g_assert(process != NULL);
23093869 2175
10a1069a 2176 guint pid = process->pid;
23093869 2177
10a1069a 2178 birth = process->creation_time;
23093869 2179
2c82c4dc 2180 if(likely(process_list->current_hash_data[ltt_tracefile_num(tfc->tf)] != NULL)) {
2181 hashed_process_data = process_list->current_hash_data[ltt_tracefile_num(tfc->tf)];
40debf7b 2182 } else {
ac4e21cf 2183 hashed_process_data = processlist_get_process_data(process_list,
40debf7b 2184 pid,
2185 process->last_cpu_index,
2186 &birth,
ac4e21cf 2187 tfc->t_context->index);
1d1df11d 2188 if(unlikely(hashed_process_data == NULL))
40debf7b 2189 {
2190 g_assert(pid == 0 || pid != process->ppid);
2191 /* Process not present */
1c736ed5 2192 Drawing_t *drawing = control_flow_data->drawing;
40debf7b 2193 const gchar *name = g_quark_to_string(process->name);
2194 ProcessInfo *process_info;
2195 processlist_add(process_list,
1c736ed5 2196 drawing,
40debf7b 2197 pid,
2198 process->last_cpu_index,
2199 process->ppid,
2200 &birth,
2201 tfc->t_context->index,
2202 name,
2203 &pl_height,
2204 &process_info,
2205 &hashed_process_data);
1c736ed5 2206 gtk_widget_set_size_request(drawing->drawing_area,
2207 -1,
2208 pl_height);
2209 gtk_widget_queue_draw(drawing->drawing_area);
40debf7b 2210 }
2211 /* Set the current process */
2212 process_list->current_hash_data[process->last_cpu_index] =
2213 hashed_process_data;
23093869 2214 }
40debf7b 2215
1d1df11d 2216 if(unlikely(ltt_time_compare(hashed_process_data->next_good_time,
2217 evtime) <= 0))
b2743953 2218 {
fd22065b 2219 TimeWindow time_window =
2220 lttvwindow_get_time_window(control_flow_data->tab);
2221
2222#ifdef EXTRA_CHECK
2223 if(ltt_time_compare(evtime, time_window.start_time) == -1
2224 || ltt_time_compare(evtime, time_window.end_time) == 1)
2225 return;
2226#endif //EXTRA_CHECK
d6fef890 2227 Drawing_t *drawing = control_flow_data->drawing;
2228 guint width = drawing->width;
b2743953 2229 guint new_x;
2230
2231 convert_time_to_pixels(
2232 time_window,
2233 evtime,
2234 width,
2235 &new_x);
e72908ed 2236
b2743953 2237 if(hashed_process_data->x.middle != new_x) {
2238 hashed_process_data->x.middle = new_x;
2239 hashed_process_data->x.middle_used = FALSE;
2240 hashed_process_data->x.middle_marked = FALSE;
2241 }
2242 }
23093869 2243 return 0;
2244}
2245
2246
dbd243b1 2247
2c82c4dc 2248
2249/* before_process_exit_hook
dbd243b1 2250 *
2251 * Draw lines for process event.
2252 *
2253 * @param hook_data ControlFlowData structure of the viewer.
2254 * @param call_data Event context.
2255 *
2256 * This function adds items to be drawn in a queue for each process.
2257 *
2258 */
2c82c4dc 2259
2260
2261int before_process_exit_hook(void *hook_data, void *call_data)
dbd243b1 2262{
088f6772 2263 return 0; //DISABLED
2c82c4dc 2264 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
2265 EventsRequest *events_request = (EventsRequest*)thf->hook_data;
2266
dbd243b1 2267 ControlFlowData *control_flow_data = events_request->viewer_data;
dbd243b1 2268
2269 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
2270
2271 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
dbd243b1 2272
2273 LttEvent *e;
2c82c4dc 2274 e = ltt_tracefile_get_event(tfc->tf);
dbd243b1 2275
2276 LttTime evtime = ltt_event_time(e);
dbd243b1 2277
2c82c4dc 2278 /* Add process to process list (if not present) */
2279 LttvProcessState *process = tfs->process;
2280 guint pid = process->pid;
2281 LttTime birth;
2282 guint pl_height = 0;
2283 HashedProcessData *hashed_process_data = NULL;
dbd243b1 2284
2c82c4dc 2285 ProcessList *process_list = control_flow_data->process_list;
2286
2287 g_assert(process != NULL);
dbd243b1 2288
2c82c4dc 2289 birth = process->creation_time;
dbd243b1 2290
2c82c4dc 2291 if(likely(process_list->current_hash_data[ltt_tracefile_num(tfc->tf)] != NULL)) {
2292 hashed_process_data = process_list->current_hash_data[ltt_tracefile_num(tfc->tf)];
2293 } else {
2294 hashed_process_data = processlist_get_process_data(process_list,
2295 pid,
2296 process->last_cpu_index,
2297 &birth,
2298 tfc->t_context->index);
2299 if(unlikely(hashed_process_data == NULL))
2300 {
2301 g_assert(pid == 0 || pid != process->ppid);
2302 /* Process not present */
2303 Drawing_t *drawing = control_flow_data->drawing;
2304 const gchar *name = g_quark_to_string(process->name);
2305 ProcessInfo *process_info;
2306 processlist_add(process_list,
2307 drawing,
2308 pid,
2309 process->last_cpu_index,
2310 process->ppid,
2311 &birth,
2312 tfc->t_context->index,
2313 name,
2314 &pl_height,
2315 &process_info,
2316 &hashed_process_data);
2317 gtk_widget_set_size_request(drawing->drawing_area,
2318 -1,
2319 pl_height);
2320 gtk_widget_queue_draw(drawing->drawing_area);
2321 }
2322 }
dbd243b1 2323
2c82c4dc 2324 /* Now, the process is in the state hash and our own process hash.
2325 * We definitely can draw the items related to the ending state.
2326 */
2327
2328 if(likely(ltt_time_compare(hashed_process_data->next_good_time,
2329 evtime) > 0))
2330 {
2331 if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
2332 TimeWindow time_window =
2333 lttvwindow_get_time_window(control_flow_data->tab);
dbd243b1 2334
2c82c4dc 2335#ifdef EXTRA_CHECK
2336 if(ltt_time_compare(evtime, time_window.start_time) == -1
2337 || ltt_time_compare(evtime, time_window.end_time) == 1)
2338 return;
2339#endif //EXTRA_CHECK
2340 Drawing_t *drawing = control_flow_data->drawing;
2341 guint width = drawing->width;
2342 guint x;
2343 convert_time_to_pixels(
2344 time_window,
2345 evtime,
2346 width,
2347 &x);
dbd243b1 2348
2c82c4dc 2349 /* Draw collision indicator */
2350 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
2351 gdk_draw_point(hashed_process_data->pixmap,
2352 drawing->gc,
2353 x,
2354 (hashed_process_data->height/2)-3);
2355 hashed_process_data->x.middle_marked = TRUE;
2356 }
2357 } else {
2358 TimeWindow time_window =
2359 lttvwindow_get_time_window(control_flow_data->tab);
fd22065b 2360
2361#ifdef EXTRA_CHECK
2c82c4dc 2362 if(ltt_time_compare(evtime, time_window.start_time) == -1
2363 || ltt_time_compare(evtime, time_window.end_time) == 1)
2364 return;
fd22065b 2365#endif //EXTRA_CHECK
2c82c4dc 2366 Drawing_t *drawing = control_flow_data->drawing;
2367 guint width = drawing->width;
2368 guint x;
2369
2370 convert_time_to_pixels(
2371 time_window,
2372 evtime,
2373 width,
2374 &x);
2375
b2743953 2376
2c82c4dc 2377 /* Jump over draw if we are at the same x position */
2378 if(unlikely(x == hashed_process_data->x.middle &&
2379 hashed_process_data->x.middle_used))
2380 {
2381 if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
b2743953 2382 /* Draw collision indicator */
2383 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
1c736ed5 2384 gdk_draw_point(hashed_process_data->pixmap,
b2743953 2385 drawing->gc,
2386 x,
1c736ed5 2387 (hashed_process_data->height/2)-3);
b2743953 2388 hashed_process_data->x.middle_marked = TRUE;
2389 }
2c82c4dc 2390 /* jump */
b2743953 2391 } else {
2c82c4dc 2392 DrawContext draw_context;
fd22065b 2393
2c82c4dc 2394 /* Now create the drawing context that will be used to draw
2395 * items related to the last state. */
2396 draw_context.drawable = hashed_process_data->pixmap;
2397 draw_context.gc = drawing->gc;
2398 draw_context.pango_layout = drawing->pango_layout;
2399 draw_context.drawinfo.start.x = hashed_process_data->x.middle;
2400 draw_context.drawinfo.end.x = x;
dbd243b1 2401
2c82c4dc 2402 draw_context.drawinfo.y.over = 1;
2403 draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
2404 draw_context.drawinfo.y.under = hashed_process_data->height;
dbd243b1 2405
2c82c4dc 2406 draw_context.drawinfo.start.offset.over = 0;
2407 draw_context.drawinfo.start.offset.middle = 0;
2408 draw_context.drawinfo.start.offset.under = 0;
2409 draw_context.drawinfo.end.offset.over = 0;
2410 draw_context.drawinfo.end.offset.middle = 0;
2411 draw_context.drawinfo.end.offset.under = 0;
dbd243b1 2412
2c82c4dc 2413 {
2414 /* Draw the line */
2415 PropertiesLine prop_line = prepare_s_e_line(process);
2416 draw_line((void*)&prop_line, (void*)&draw_context);
dbd243b1 2417
2c82c4dc 2418 }
2419 /* become the last x position */
2420 hashed_process_data->x.middle = x;
2421 hashed_process_data->x.middle_used = TRUE;
2422 hashed_process_data->x.middle_marked = FALSE;
dbd243b1 2423
2c82c4dc 2424 /* Calculate the next good time */
2425 convert_pixels_to_time(width, x+1, time_window,
2426 &hashed_process_data->next_good_time);
2427 }
2428 }
2429
2430 return 0;
2431
2432}
2433
2434
2435
2436/* before_process_release_hook
2437 *
2438 * Draw lines for process event.
2439 *
2440 * @param hook_data ControlFlowData structure of the viewer.
2441 * @param call_data Event context.
2442 *
2443 * This function adds items to be drawn in a queue for each process.
2444 *
2445 */
2446
2447
2448int before_process_release_hook(void *hook_data, void *call_data)
2449{
088f6772 2450 return 0; //DISABLED
2c82c4dc 2451 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
2452 EventsRequest *events_request = (EventsRequest*)thf->hook_data;
2453
2454 ControlFlowData *control_flow_data = events_request->viewer_data;
2455
2456 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
2457
2458 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
2459
2460 LttEvent *e;
2461 e = ltt_tracefile_get_event(tfc->tf);
2462
2463 LttTime evtime = ltt_event_time(e);
2464
2465
2466 guint pid;
2467 {
2468 pid = ltt_event_get_long_unsigned(e, thf->f1);
2469 }
2470
2471 /* Add process to process list (if not present) */
2472 /* Don't care about the process if it's not in the state hash already :
2473 * that means a process that has never done anything in the trace and
2474 * unknown suddently gets destroyed : no state meaningful to show. */
2475 LttvProcessState *process = lttv_state_find_process(tfs, pid);
2476
2477 if(process != NULL) {
2478 LttTime birth;
2479 guint pl_height = 0;
2480 HashedProcessData *hashed_process_data = NULL;
2481
2482 ProcessList *process_list = control_flow_data->process_list;
2483
2484 birth = process->creation_time;
2485
2486 /* Cannot use current process : this event happens on another process,
2487 * action done by the parent. */
2488 hashed_process_data = processlist_get_process_data(process_list,
2489 pid,
2490 process->last_cpu_index,
2491 &birth,
2492 tfc->t_context->index);
2493 if(unlikely(hashed_process_data == NULL))
2494 {
2495 g_assert(pid == 0 || pid != process->ppid);
2496 /* Process not present */
2497 Drawing_t *drawing = control_flow_data->drawing;
2498 const gchar *name = g_quark_to_string(process->name);
2499 ProcessInfo *process_info;
2500 processlist_add(process_list,
2501 drawing,
2502 pid,
2503 process->last_cpu_index,
2504 process->ppid,
2505 &birth,
2506 tfc->t_context->index,
2507 name,
2508 &pl_height,
2509 &process_info,
2510 &hashed_process_data);
2511 gtk_widget_set_size_request(drawing->drawing_area,
2512 -1,
2513 pl_height);
2514 gtk_widget_queue_draw(drawing->drawing_area);
2515 }
2516
2517 /* Now, the process is in the state hash and our own process hash.
2518 * We definitely can draw the items related to the ending state.
2519 */
2520
2521 if(likely(ltt_time_compare(hashed_process_data->next_good_time,
2522 evtime) > 0))
2523 {
2524 if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
2525 TimeWindow time_window =
2526 lttvwindow_get_time_window(control_flow_data->tab);
2527
2528#ifdef EXTRA_CHECK
2529 if(ltt_time_compare(evtime, time_window.start_time) == -1
2530 || ltt_time_compare(evtime, time_window.end_time) == 1)
2531 return;
2532#endif //EXTRA_CHECK
2533 Drawing_t *drawing = control_flow_data->drawing;
2534 guint width = drawing->width;
2535 guint x;
2536 convert_time_to_pixels(
2537 time_window,
2538 evtime,
2539 width,
2540 &x);
2541
2542 /* Draw collision indicator */
2543 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
2544 gdk_draw_point(hashed_process_data->pixmap,
2545 drawing->gc,
2546 x,
2547 (hashed_process_data->height/2)-3);
2548 hashed_process_data->x.middle_marked = TRUE;
2549 }
2550 } else {
2551 TimeWindow time_window =
2552 lttvwindow_get_time_window(control_flow_data->tab);
2553
2554#ifdef EXTRA_CHECK
2555 if(ltt_time_compare(evtime, time_window.start_time) == -1
2556 || ltt_time_compare(evtime, time_window.end_time) == 1)
2557 return;
2558#endif //EXTRA_CHECK
2559 Drawing_t *drawing = control_flow_data->drawing;
2560 guint width = drawing->width;
2561 guint x;
2562
2563 convert_time_to_pixels(
2564 time_window,
2565 evtime,
2566 width,
2567 &x);
2568
2569
2570 /* Jump over draw if we are at the same x position */
2571 if(unlikely(x == hashed_process_data->x.middle &&
2572 hashed_process_data->x.middle_used))
2573 {
2574 if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
2575 /* Draw collision indicator */
2576 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
2577 gdk_draw_point(hashed_process_data->pixmap,
2578 drawing->gc,
2579 x,
2580 (hashed_process_data->height/2)-3);
2581 hashed_process_data->x.middle_marked = TRUE;
2582 }
2583 /* jump */
2584 } else {
2585 DrawContext draw_context;
2586
2587 /* Now create the drawing context that will be used to draw
2588 * items related to the last state. */
2589 draw_context.drawable = hashed_process_data->pixmap;
2590 draw_context.gc = drawing->gc;
2591 draw_context.pango_layout = drawing->pango_layout;
2592 draw_context.drawinfo.start.x = hashed_process_data->x.middle;
2593 draw_context.drawinfo.end.x = x;
2594
2595 draw_context.drawinfo.y.over = 1;
2596 draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
2597 draw_context.drawinfo.y.under = hashed_process_data->height;
2598
2599 draw_context.drawinfo.start.offset.over = 0;
2600 draw_context.drawinfo.start.offset.middle = 0;
2601 draw_context.drawinfo.start.offset.under = 0;
2602 draw_context.drawinfo.end.offset.over = 0;
2603 draw_context.drawinfo.end.offset.middle = 0;
2604 draw_context.drawinfo.end.offset.under = 0;
2605
2606 {
2607 /* Draw the line */
2608 PropertiesLine prop_line = prepare_s_e_line(process);
2609 draw_line((void*)&prop_line, (void*)&draw_context);
2610
2611 }
2612 /* become the last x position */
2613 hashed_process_data->x.middle = x;
2614 hashed_process_data->x.middle_used = TRUE;
2615 hashed_process_data->x.middle_marked = FALSE;
2616
2617 /* Calculate the next good time */
2618 convert_pixels_to_time(width, x+1, time_window,
2619 &hashed_process_data->next_good_time);
2620 }
2621 }
2622 }
2623
2624 return 0;
2625}
2626
2627
2628
2629
2630
2631
2632
2633
2634#if 0
2635/* before_process_hook
2636 *
2637 * Draw lines for process event.
2638 *
2639 * @param hook_data ControlFlowData structure of the viewer.
2640 * @param call_data Event context.
2641 *
2642 * This function adds items to be drawn in a queue for each process.
2643 *
2644 */
2645int before_process_hook(void *hook_data, void *call_data)
2646{
2647 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
2648 EventsRequest *events_request = (EventsRequest*)thf->hook_data;
2649 ControlFlowData *control_flow_data = events_request->viewer_data;
2650
2651 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
2652
2653 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
2654
2655 LttEvent *e;
2656 e = ltt_tracefile_get_event(tfc->tf);
2657
2658 LttTime evtime = ltt_event_time(e);
2659
2660 guint sub_id;
2661 {
2662 LttField *f = ltt_event_field(e);
2663 LttField *element;
2664 element = ltt_field_member(f,0);
2665 sub_id = ltt_event_get_long_unsigned(e,element);
2666 }
2667
2668 if(sub_id == 3) { /* exit */
2669
2670 /* Add process to process list (if not present) */
2671 LttvProcessState *process = tfs->process;
2672 guint pid = process->pid;
2673 LttTime birth;
2674 guint pl_height = 0;
2675 HashedProcessData *hashed_process_data = NULL;
2676
2677 ProcessList *process_list = control_flow_data->process_list;
2678
2679 g_assert(process != NULL);
2680
2681 birth = process->creation_time;
2682
2683 if(likely(process_list->current_hash_data[tfc->index] != NULL)) {
2684 hashed_process_data = process_list->current_hash_data[tfc->index];
2685 } else {
2686 hashed_process_data = processlist_get_process_data(process_list,
2687 pid,
2688 process->last_cpu_index,
2689 &birth,
2690 tfc->t_context->index);
2691 if(unlikely(hashed_process_data == NULL))
2692 {
2693 g_assert(pid == 0 || pid != process->ppid);
2694 /* Process not present */
2695 Drawing_t *drawing = control_flow_data->drawing;
2696 const gchar *name = g_quark_to_string(process->name);
2697 ProcessInfo *process_info;
2698 processlist_add(process_list,
2699 drawing,
2700 pid,
2701 process->last_cpu_index,
2702 process->ppid,
2703 &birth,
2704 tfc->t_context->index,
2705 name,
2706 &pl_height,
2707 &process_info,
2708 &hashed_process_data);
2709 gtk_widget_set_size_request(drawing->drawing_area,
2710 -1,
2711 pl_height);
2712 gtk_widget_queue_draw(drawing->drawing_area);
2713 }
2714 }
2715
2716 /* Now, the process is in the state hash and our own process hash.
2717 * We definitely can draw the items related to the ending state.
2718 */
2719
2720 if(likely(ltt_time_compare(hashed_process_data->next_good_time,
2721 evtime) > 0))
2722 {
2723 if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
2724 TimeWindow time_window =
2725 lttvwindow_get_time_window(control_flow_data->tab);
2726
2727#ifdef EXTRA_CHECK
2728 if(ltt_time_compare(evtime, time_window.start_time) == -1
2729 || ltt_time_compare(evtime, time_window.end_time) == 1)
2730 return;
2731#endif //EXTRA_CHECK
2732 Drawing_t *drawing = control_flow_data->drawing;
2733 guint width = drawing->width;
2734 guint x;
2735 convert_time_to_pixels(
2736 time_window,
2737 evtime,
2738 width,
2739 &x);
2740
2741 /* Draw collision indicator */
2742 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
2743 gdk_draw_point(hashed_process_data->pixmap,
2744 drawing->gc,
2745 x,
2746 (hashed_process_data->height/2)-3);
2747 hashed_process_data->x.middle_marked = TRUE;
2748 }
2749 } else {
2750 TimeWindow time_window =
2751 lttvwindow_get_time_window(control_flow_data->tab);
2752
2753#ifdef EXTRA_CHECK
2754 if(ltt_time_compare(evtime, time_window.start_time) == -1
2755 || ltt_time_compare(evtime, time_window.end_time) == 1)
2756 return;
2757#endif //EXTRA_CHECK
2758 Drawing_t *drawing = control_flow_data->drawing;
2759 guint width = drawing->width;
2760 guint x;
2761
2762 convert_time_to_pixels(
2763 time_window,
2764 evtime,
2765 width,
2766 &x);
2767
2768
2769 /* Jump over draw if we are at the same x position */
2770 if(unlikely(x == hashed_process_data->x.middle &&
2771 hashed_process_data->x.middle_used))
2772 {
2773 if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
2774 /* Draw collision indicator */
2775 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
2776 gdk_draw_point(hashed_process_data->pixmap,
2777 drawing->gc,
2778 x,
2779 (hashed_process_data->height/2)-3);
2780 hashed_process_data->x.middle_marked = TRUE;
2781 }
2782 /* jump */
2783 } else {
2784 DrawContext draw_context;
2785
2786 /* Now create the drawing context that will be used to draw
2787 * items related to the last state. */
2788 draw_context.drawable = hashed_process_data->pixmap;
2789 draw_context.gc = drawing->gc;
2790 draw_context.pango_layout = drawing->pango_layout;
2791 draw_context.drawinfo.start.x = hashed_process_data->x.middle;
2792 draw_context.drawinfo.end.x = x;
2793
2794 draw_context.drawinfo.y.over = 1;
1c736ed5 2795 draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
2796 draw_context.drawinfo.y.under = hashed_process_data->height;
4b7dc462 2797
2798 draw_context.drawinfo.start.offset.over = 0;
2799 draw_context.drawinfo.start.offset.middle = 0;
2800 draw_context.drawinfo.start.offset.under = 0;
2801 draw_context.drawinfo.end.offset.over = 0;
2802 draw_context.drawinfo.end.offset.middle = 0;
2803 draw_context.drawinfo.end.offset.under = 0;
dbd243b1 2804
4b7dc462 2805 {
2806 /* Draw the line */
9a1ec01b 2807 PropertiesLine prop_line = prepare_s_e_line(process);
4b7dc462 2808 draw_line((void*)&prop_line, (void*)&draw_context);
2809
2810 }
2811 /* become the last x position */
2812 hashed_process_data->x.middle = x;
e72908ed 2813 hashed_process_data->x.middle_used = TRUE;
2814 hashed_process_data->x.middle_marked = FALSE;
b2743953 2815
2816 /* Calculate the next good time */
2817 convert_pixels_to_time(width, x+1, time_window,
2818 &hashed_process_data->next_good_time);
dbd243b1 2819 }
dbd243b1 2820 }
2821
2da61677 2822 } else if(sub_id == 7) /* release */ {
2823
2824 guint pid;
2825 {
2826 LttField *f = ltt_event_field(e);
2827 LttField *element;
2828 element = ltt_field_member(f,1);
2829 pid = ltt_event_get_long_unsigned(e,element);
2830 }
2831
2832 /* Add process to process list (if not present) */
2833 /* Don't care about the process if it's not in the state hash already :
2834 * that means a process that has never done anything in the trace and
2835 * unknown suddently gets destroyed : no state meaningful to show. */
2836 LttvProcessState *process = lttv_state_find_process(tfs, pid);
2837
2838 if(process != NULL) {
2839 LttTime birth;
2840 guint pl_height = 0;
2841 HashedProcessData *hashed_process_data = NULL;
2842
2843 ProcessList *process_list = control_flow_data->process_list;
2844
2845 birth = process->creation_time;
2846
2847 /* Cannot use current process : this event happens on another process,
2848 * action done by the parent. */
2849 hashed_process_data = processlist_get_process_data(process_list,
2850 pid,
2851 process->last_cpu_index,
2852 &birth,
2853 tfc->t_context->index);
2854 if(unlikely(hashed_process_data == NULL))
2855 {
2856 g_assert(pid == 0 || pid != process->ppid);
2857 /* Process not present */
2858 Drawing_t *drawing = control_flow_data->drawing;
2859 const gchar *name = g_quark_to_string(process->name);
2860 ProcessInfo *process_info;
2861 processlist_add(process_list,
2862 drawing,
2863 pid,
2864 process->last_cpu_index,
2865 process->ppid,
2866 &birth,
2867 tfc->t_context->index,
2868 name,
2869 &pl_height,
2870 &process_info,
2871 &hashed_process_data);
2872 gtk_widget_set_size_request(drawing->drawing_area,
2873 -1,
2874 pl_height);
2875 gtk_widget_queue_draw(drawing->drawing_area);
2876 }
2877
2878 /* Now, the process is in the state hash and our own process hash.
2879 * We definitely can draw the items related to the ending state.
2880 */
2881
2882 if(likely(ltt_time_compare(hashed_process_data->next_good_time,
2883 evtime) > 0))
2884 {
2885 if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
2886 TimeWindow time_window =
2887 lttvwindow_get_time_window(control_flow_data->tab);
2888
2889#ifdef EXTRA_CHECK
2890 if(ltt_time_compare(evtime, time_window.start_time) == -1
2891 || ltt_time_compare(evtime, time_window.end_time) == 1)
2892 return;
2893#endif //EXTRA_CHECK
2894 Drawing_t *drawing = control_flow_data->drawing;
2895 guint width = drawing->width;
2896 guint x;
2897 convert_time_to_pixels(
2898 time_window,
2899 evtime,
2900 width,
2901 &x);
2902
2903 /* Draw collision indicator */
2904 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
2905 gdk_draw_point(hashed_process_data->pixmap,
2906 drawing->gc,
2907 x,
2908 (hashed_process_data->height/2)-3);
2909 hashed_process_data->x.middle_marked = TRUE;
2910 }
2911 } else {
2912 TimeWindow time_window =
2913 lttvwindow_get_time_window(control_flow_data->tab);
2914
2915#ifdef EXTRA_CHECK
2916 if(ltt_time_compare(evtime, time_window.start_time) == -1
2917 || ltt_time_compare(evtime, time_window.end_time) == 1)
2918 return;
2919#endif //EXTRA_CHECK
2920 Drawing_t *drawing = control_flow_data->drawing;
2921 guint width = drawing->width;
2922 guint x;
2923
2924 convert_time_to_pixels(
2925 time_window,
2926 evtime,
2927 width,
2928 &x);
2929
2930
2931 /* Jump over draw if we are at the same x position */
2932 if(unlikely(x == hashed_process_data->x.middle &&
2933 hashed_process_data->x.middle_used))
2934 {
2935 if(unlikely(hashed_process_data->x.middle_marked == FALSE)) {
2936 /* Draw collision indicator */
2937 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
2938 gdk_draw_point(hashed_process_data->pixmap,
2939 drawing->gc,
2940 x,
2941 (hashed_process_data->height/2)-3);
2942 hashed_process_data->x.middle_marked = TRUE;
2943 }
2944 /* jump */
2945 } else {
2946 DrawContext draw_context;
2947
2948 /* Now create the drawing context that will be used to draw
2949 * items related to the last state. */
2950 draw_context.drawable = hashed_process_data->pixmap;
2951 draw_context.gc = drawing->gc;
2952 draw_context.pango_layout = drawing->pango_layout;
2953 draw_context.drawinfo.start.x = hashed_process_data->x.middle;
2954 draw_context.drawinfo.end.x = x;
2955
2956 draw_context.drawinfo.y.over = 1;
2957 draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
2958 draw_context.drawinfo.y.under = hashed_process_data->height;
2959
2960 draw_context.drawinfo.start.offset.over = 0;
2961 draw_context.drawinfo.start.offset.middle = 0;
2962 draw_context.drawinfo.start.offset.under = 0;
2963 draw_context.drawinfo.end.offset.over = 0;
2964 draw_context.drawinfo.end.offset.middle = 0;
2965 draw_context.drawinfo.end.offset.under = 0;
2966
2967 {
2968 /* Draw the line */
2969 PropertiesLine prop_line = prepare_s_e_line(process);
2970 draw_line((void*)&prop_line, (void*)&draw_context);
2971
2972 }
2973 /* become the last x position */
2974 hashed_process_data->x.middle = x;
2975 hashed_process_data->x.middle_used = TRUE;
2976 hashed_process_data->x.middle_marked = FALSE;
2977
2978 /* Calculate the next good time */
2979 convert_pixels_to_time(width, x+1, time_window,
2980 &hashed_process_data->next_good_time);
2981 }
2982 }
2983 }
2984
dbd243b1 2985 }
2986 return 0;
2987
2988}
2989
2c82c4dc 2990#endif //0
2991
2992
2993
2994/* after_process_fork_hook
2995 *
2996 * Create the processlist entry for the child process. Put the last
2997 * position in x at the current time value.
2998 *
2999 * @param hook_data ControlFlowData structure of the viewer.
3000 * @param call_data Event context.
3001 *
3002 * This function adds items to be drawn in a queue for each process.
3003 *
3004 */
3005int after_process_fork_hook(void *hook_data, void *call_data)
3006{
088f6772 3007 return 0; //DISABLED
2c82c4dc 3008 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
3009 EventsRequest *events_request = (EventsRequest*)thf->hook_data;
3010 ControlFlowData *control_flow_data = events_request->viewer_data;
3011
3012 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
3013
3014 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
3015
3016 LttEvent *e;
3017 e = ltt_tracefile_get_event(tfc->tf);
3018
3019 LttTime evtime = ltt_event_time(e);
3020
3021 guint child_pid;
3022 {
3023 child_pid = ltt_event_get_long_unsigned(e, thf->f2);
3024 }
3025
3026 /* Add process to process list (if not present) */
3027 LttvProcessState *process_child;
3028 LttTime birth;
3029 guint pl_height = 0;
3030 HashedProcessData *hashed_process_data_child = NULL;
3031
3032 ProcessList *process_list = control_flow_data->process_list;
3033
3034 /* Find child in the list... */
3035 process_child = lttv_state_find_process(tfs, child_pid);
3036 /* It should exist, because we are after the state update. */
3037 g_assert(process_child != NULL);
3038
3039 birth = process_child->creation_time;
3040
3041 /* Cannot use current process, because this action is done by the parent
3042 * on its child. */
3043 hashed_process_data_child = processlist_get_process_data(process_list,
3044 child_pid,
3045 process_child->last_cpu_index,
3046 &birth,
3047 tfc->t_context->index);
3048 if(likely(hashed_process_data_child == NULL))
3049 {
3050 g_assert(child_pid == 0 || child_pid != process_child->ppid);
3051 /* Process not present */
3052 Drawing_t *drawing = control_flow_data->drawing;
3053 const gchar *name = g_quark_to_string(process_child->name);
3054 ProcessInfo *process_info;
3055 processlist_add(process_list,
3056 drawing,
3057 child_pid,
3058 process_child->last_cpu_index,
3059 process_child->ppid,
3060 &birth,
3061 tfc->t_context->index,
3062 name,
3063 &pl_height,
3064 &process_info,
3065 &hashed_process_data_child);
3066 gtk_widget_set_size_request(drawing->drawing_area,
3067 -1,
3068 pl_height);
3069 gtk_widget_queue_draw(drawing->drawing_area);
3070 }
3071
3072
3073 if(likely(ltt_time_compare(hashed_process_data_child->next_good_time,
3074 evtime) <= 0))
3075 {
3076 TimeWindow time_window =
3077 lttvwindow_get_time_window(control_flow_data->tab);
3078
3079#ifdef EXTRA_CHECK
3080 if(ltt_time_compare(evtime, time_window.start_time) == -1
3081 || ltt_time_compare(evtime, time_window.end_time) == 1)
3082 return;
3083#endif //EXTRA_CHECK
3084 Drawing_t *drawing = control_flow_data->drawing;
3085 guint width = drawing->width;
3086 guint new_x;
3087 convert_time_to_pixels(
3088 time_window,
3089 evtime,
3090 width,
3091 &new_x);
3092
3093 if(likely(hashed_process_data_child->x.over != new_x)) {
3094 hashed_process_data_child->x.over = new_x;
3095 hashed_process_data_child->x.over_used = FALSE;
3096 hashed_process_data_child->x.over_marked = FALSE;
3097 }
3098 if(likely(hashed_process_data_child->x.middle != new_x)) {
3099 hashed_process_data_child->x.middle = new_x;
3100 hashed_process_data_child->x.middle_used = FALSE;
3101 hashed_process_data_child->x.middle_marked = FALSE;
3102 }
3103 if(likely(hashed_process_data_child->x.under != new_x)) {
3104 hashed_process_data_child->x.under = new_x;
3105 hashed_process_data_child->x.under_used = FALSE;
3106 hashed_process_data_child->x.under_marked = FALSE;
3107 }
3108 }
3109 return 0;
3110}
3111
3112
3113
3114/* after_process_exit_hook
3115 *
3116 * Create the processlist entry for the child process. Put the last
3117 * position in x at the current time value.
3118 *
3119 * @param hook_data ControlFlowData structure of the viewer.
3120 * @param call_data Event context.
3121 *
3122 * This function adds items to be drawn in a queue for each process.
3123 *
3124 */
3125int after_process_exit_hook(void *hook_data, void *call_data)
3126{
088f6772 3127 return 0; //DISABLED
2c82c4dc 3128 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
3129 EventsRequest *events_request = (EventsRequest*)thf->hook_data;
3130 ControlFlowData *control_flow_data = events_request->viewer_data;
3131
3132 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
3133
3134 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
3135
3136 LttEvent *e;
3137 e = ltt_tracefile_get_event(tfc->tf);
3138
3139 LttTime evtime = ltt_event_time(e);
3140
3141 /* Add process to process list (if not present) */
3142 LttvProcessState *process = tfs->process;
3143 guint pid = process->pid;
3144 LttTime birth;
3145 guint pl_height = 0;
3146 HashedProcessData *hashed_process_data = NULL;
3147
3148 ProcessList *process_list = control_flow_data->process_list;
3149
3150 /* It should exist, because we are after the state update. */
3151 g_assert(process != NULL);
3152
3153 birth = process->creation_time;
3154
3155 if(likely(process_list->current_hash_data[ltt_tracefile_num(tfc->tf)] != NULL) ){
3156 hashed_process_data = process_list->current_hash_data[ltt_tracefile_num(tfc->tf)];
3157 } else {
3158 hashed_process_data = processlist_get_process_data(process_list,
3159 pid,
3160 process->last_cpu_index,
3161 &birth,
3162 tfc->t_context->index);
3163 if(unlikely(hashed_process_data == NULL))
3164 {
3165 g_assert(pid == 0 || pid != process->ppid);
3166 /* Process not present */
3167 Drawing_t *drawing = control_flow_data->drawing;
3168 const gchar *name = g_quark_to_string(process->name);
3169 ProcessInfo *process_info;
3170 processlist_add(process_list,
3171 drawing,
3172 pid,
3173 process->last_cpu_index,
3174 process->ppid,
3175 &birth,
3176 tfc->t_context->index,
3177 name,
3178 &pl_height,
3179 &process_info,
3180 &hashed_process_data);
3181 gtk_widget_set_size_request(drawing->drawing_area,
3182 -1,
3183 pl_height);
3184 gtk_widget_queue_draw(drawing->drawing_area);
3185 }
3186
3187 /* Set the current process */
3188 process_list->current_hash_data[process->last_cpu_index] =
3189 hashed_process_data;
3190 }
3191
3192 if(unlikely(ltt_time_compare(hashed_process_data->next_good_time,
3193 evtime) <= 0))
3194 {
3195 TimeWindow time_window =
3196 lttvwindow_get_time_window(control_flow_data->tab);
dbd243b1 3197
2c82c4dc 3198#ifdef EXTRA_CHECK
3199 if(ltt_time_compare(evtime, time_window.start_time) == -1
3200 || ltt_time_compare(evtime, time_window.end_time) == 1)
3201 return;
3202#endif //EXTRA_CHECK
3203 Drawing_t *drawing = control_flow_data->drawing;
3204 guint width = drawing->width;
3205 guint new_x;
3206 convert_time_to_pixels(
3207 time_window,
3208 evtime,
3209 width,
3210 &new_x);
3211 if(unlikely(hashed_process_data->x.middle != new_x)) {
3212 hashed_process_data->x.middle = new_x;
3213 hashed_process_data->x.middle_used = FALSE;
3214 hashed_process_data->x.middle_marked = FALSE;
3215 }
3216 }
dbd243b1 3217
2c82c4dc 3218 return 0;
3219}
dbd243b1 3220
3221
2c82c4dc 3222#if 0
dbd243b1 3223
3224/* after_process_hook
e92eabaf 3225 *
3226 * Create the processlist entry for the child process. Put the last
3227 * position in x at the current time value.
3228 *
3229 * @param hook_data ControlFlowData structure of the viewer.
3230 * @param call_data Event context.
3231 *
3232 * This function adds items to be drawn in a queue for each process.
3233 *
3234 */
dbd243b1 3235int after_process_hook(void *hook_data, void *call_data)
e92eabaf 3236{
2c82c4dc 3237 LttvTraceHookByFacility *thf = (LttvTraceHookByFacility*)hook_data;
3238 EventsRequest *events_request = (EventsRequest*)thf->hook_data;
e92eabaf 3239 ControlFlowData *control_flow_data = events_request->viewer_data;
3240
3241 LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
3242
3243 LttvTracefileState *tfs = (LttvTracefileState *)call_data;
e92eabaf 3244
3245 LttEvent *e;
2c82c4dc 3246 e = ltt_tracefile_get_event(tfc->tf);
e92eabaf 3247
3248 LttTime evtime = ltt_event_time(e);
e92eabaf 3249
10a1069a 3250 guint sub_id;
3251 guint param1;
3252 {
3253 LttField *f = ltt_event_field(e);
3254 LttField *element;
3255 element = ltt_field_member(f,0);
3256 sub_id = ltt_event_get_long_unsigned(e,element);
3257 element = ltt_field_member(f,1);
3258 param1 = ltt_event_get_long_unsigned(e,element);
3259 }
e92eabaf 3260
10a1069a 3261 if(sub_id == 2) { /* fork */
3262
3263 guint child_pid = param1;
3264 /* Add process to process list (if not present) */
3265 LttvProcessState *process_child;
3266 LttTime birth;
1c736ed5 3267 guint pl_height = 0;
10a1069a 3268 HashedProcessData *hashed_process_data_child = NULL;
e92eabaf 3269
5c230fc4 3270 ProcessList *process_list = control_flow_data->process_list;
e92eabaf 3271
10a1069a 3272 /* Find child in the list... */
3273 process_child = lttv_state_find_process(tfs, child_pid);
3274 /* It should exist, because we are after the state update. */
3275 g_assert(process_child != NULL);
e92eabaf 3276
10a1069a 3277 birth = process_child->creation_time;
e92eabaf 3278
2da61677 3279 /* Cannot use current process, because this action is done by the parent
3280 * on its child. */
ac4e21cf 3281 hashed_process_data_child = processlist_get_process_data(process_list,
10a1069a 3282 child_pid,
40debf7b 3283 process_child->last_cpu_index,
10a1069a 3284 &birth,
ac4e21cf 3285 tfc->t_context->index);
1d1df11d 3286 if(likely(hashed_process_data_child == NULL))
10a1069a 3287 {
3288 g_assert(child_pid == 0 || child_pid != process_child->ppid);
3289 /* Process not present */
1c736ed5 3290 Drawing_t *drawing = control_flow_data->drawing;
aac69e70 3291 const gchar *name = g_quark_to_string(process_child->name);
4e86ae2e 3292 ProcessInfo *process_info;
10a1069a 3293 processlist_add(process_list,
1c736ed5 3294 drawing,
10a1069a 3295 child_pid,
40debf7b 3296 process_child->last_cpu_index,
10a1069a 3297 process_child->ppid,
3298 &birth,
3299 tfc->t_context->index,
3300 name,
3301 &pl_height,
4e86ae2e 3302 &process_info,
10a1069a 3303 &hashed_process_data_child);
1c736ed5 3304 gtk_widget_set_size_request(drawing->drawing_area,
3305 -1,
3306 pl_height);
3307 gtk_widget_queue_draw(drawing->drawing_area);
10a1069a 3308 }
e92eabaf 3309
40debf7b 3310
1d1df11d 3311 if(likely(ltt_time_compare(hashed_process_data_child->next_good_time,
3312 evtime) <= 0))
b2743953 3313 {
fd22065b 3314 TimeWindow time_window =
3315 lttvwindow_get_time_window(control_flow_data->tab);
3316
3317#ifdef EXTRA_CHECK
3318 if(ltt_time_compare(evtime, time_window.start_time) == -1
3319 || ltt_time_compare(evtime, time_window.end_time) == 1)
3320 return;
3321#endif //EXTRA_CHECK
d6fef890 3322 Drawing_t *drawing = control_flow_data->drawing;
96947fcf 3323 guint width = drawing->width;
b2743953 3324 guint new_x;
3325 convert_time_to_pixels(
3326 time_window,
3327 evtime,
3328 width,
3329 &new_x);
e72908ed 3330
1d1df11d 3331 if(likely(hashed_process_data_child->x.over != new_x)) {
b2743953 3332 hashed_process_data_child->x.over = new_x;
3333 hashed_process_data_child->x.over_used = FALSE;
3334 hashed_process_data_child->x.over_marked = FALSE;
3335 }
1d1df11d 3336 if(likely(hashed_process_data_child->x.middle != new_x)) {
b2743953 3337 hashed_process_data_child->x.middle = new_x;
3338 hashed_process_data_child->x.middle_used = FALSE;
3339 hashed_process_data_child->x.middle_marked = FALSE;
3340 }
1d1df11d 3341 if(likely(hashed_process_data_child->x.under != new_x)) {
b2743953 3342 hashed_process_data_child->x.under = new_x;
3343 hashed_process_data_child->x.under_used = FALSE;
3344 hashed_process_data_child->x.under_marked = FALSE;
3345 }
e72908ed 3346 }
23093869 3347
10a1069a 3348 } else if(sub_id == 3) { /* exit */
dbd243b1 3349
10a1069a 3350 /* Add process to process list (if not present) */
3351 LttvProcessState *process = tfs->process;
3352 guint pid = process->pid;
3353 LttTime birth;
1c736ed5 3354 guint pl_height = 0;
10a1069a 3355 HashedProcessData *hashed_process_data = NULL;
dbd243b1 3356
5c230fc4 3357 ProcessList *process_list = control_flow_data->process_list;
dbd243b1 3358
10a1069a 3359 /* It should exist, because we are after the state update. */
3360 g_assert(process != NULL);
dbd243b1 3361
10a1069a 3362 birth = process->creation_time;
dbd243b1 3363
2c82c4dc 3364 if(likely(process_list->current_hash_data[ltt_tracefile_num(tfc->tf)] != NULL) ){
3365 hashed_process_data = process_list->current_hash_data[ltt_tracefile_num(tfc->tf)];
40debf7b 3366 } else {
ac4e21cf 3367 hashed_process_data = processlist_get_process_data(process_list,
40debf7b 3368 pid,
3369 process->last_cpu_index,
3370 &birth,
ac4e21cf 3371 tfc->t_context->index);
1d1df11d 3372 if(unlikely(hashed_process_data == NULL))
40debf7b 3373 {
3374 g_assert(pid == 0 || pid != process->ppid);
3375 /* Process not present */
1c736ed5 3376 Drawing_t *drawing = control_flow_data->drawing;
40debf7b 3377 const gchar *name = g_quark_to_string(process->name);
3378 ProcessInfo *process_info;
3379 processlist_add(process_list,
1c736ed5 3380 drawing,
40debf7b 3381 pid,
3382 process->last_cpu_index,
3383 process->ppid,
3384 &birth,
3385 tfc->t_context->index,
3386 name,
3387 &pl_height,
3388 &process_info,
3389 &hashed_process_data);
1c736ed5 3390 gtk_widget_set_size_request(drawing->drawing_area,
3391 -1,
3392 pl_height);
3393 gtk_widget_queue_draw(drawing->drawing_area);
40debf7b 3394 }
3395
3396 /* Set the current process */
3397 process_list->current_hash_data[process->last_cpu_index] =
3398 hashed_process_data;
e92eabaf 3399 }
dbd243b1 3400
1d1df11d 3401 if(unlikely(ltt_time_compare(hashed_process_data->next_good_time,
3402 evtime) <= 0))
b2743953 3403 {
fd22065b 3404 TimeWindow time_window =
3405 lttvwindow_get_time_window(control_flow_data->tab);
3406
3407#ifdef EXTRA_CHECK
3408 if(ltt_time_compare(evtime, time_window.start_time) == -1
3409 || ltt_time_compare(evtime, time_window.end_time) == 1)
3410 return;
3411#endif //EXTRA_CHECK
d6fef890 3412 Drawing_t *drawing = control_flow_data->drawing;
96947fcf 3413 guint width = drawing->width;
b2743953 3414 guint new_x;
3415 convert_time_to_pixels(
3416 time_window,
3417 evtime,
3418 width,
3419 &new_x);
1d1df11d 3420 if(unlikely(hashed_process_data->x.middle != new_x)) {
b2743953 3421 hashed_process_data->x.middle = new_x;
3422 hashed_process_data->x.middle_used = FALSE;
3423 hashed_process_data->x.middle_marked = FALSE;
3424 }
e72908ed 3425 }
3426
e92eabaf 3427 }
3428 return 0;
3429
3430}
2c82c4dc 3431#endif //0
f7afe191 3432
1b238973 3433gint update_time_window_hook(void *hook_data, void *call_data)
f7afe191 3434{
a56a1ba4 3435 ControlFlowData *control_flow_data = (ControlFlowData*) hook_data;
a43d67ba 3436 Drawing_t *drawing = control_flow_data->drawing;
1c736ed5 3437 ProcessList *process_list = control_flow_data->process_list;
a43d67ba 3438
224446ce 3439 const TimeWindowNotifyData *time_window_nofify_data =
3440 ((const TimeWindowNotifyData *)call_data);
3441
14963be0 3442 TimeWindow *old_time_window =
224446ce 3443 time_window_nofify_data->old_time_window;
3444 TimeWindow *new_time_window =
3445 time_window_nofify_data->new_time_window;
a56a1ba4 3446
3cb8b205 3447 /* Update the ruler */
3448 drawing_update_ruler(control_flow_data->drawing,
3449 new_time_window);
3450
3451
a56a1ba4 3452 /* Two cases : zoom in/out or scrolling */
3453
3454 /* In order to make sure we can reuse the old drawing, the scale must
3455 * be the same and the new time interval being partly located in the
3456 * currently shown time interval. (reuse is only for scrolling)
3457 */
3458
2eef04b5 3459 g_info("Old time window HOOK : %lu, %lu to %lu, %lu",
14963be0 3460 old_time_window->start_time.tv_sec,
3461 old_time_window->start_time.tv_nsec,
3462 old_time_window->time_width.tv_sec,
3463 old_time_window->time_width.tv_nsec);
a56a1ba4 3464
2eef04b5 3465 g_info("New time window HOOK : %lu, %lu to %lu, %lu",
14963be0 3466 new_time_window->start_time.tv_sec,
3467 new_time_window->start_time.tv_nsec,
3468 new_time_window->time_width.tv_sec,
3469 new_time_window->time_width.tv_nsec);
a56a1ba4 3470
14963be0 3471 if( new_time_window->time_width.tv_sec == old_time_window->time_width.tv_sec
3472 && new_time_window->time_width.tv_nsec == old_time_window->time_width.tv_nsec)
a56a1ba4 3473 {
3474 /* Same scale (scrolling) */
3475 g_info("scrolling");
14963be0 3476 LttTime *ns = &new_time_window->start_time;
20640e70 3477 LttTime *nw = &new_time_window->time_width;
14963be0 3478 LttTime *os = &old_time_window->start_time;
20640e70 3479 LttTime *ow = &old_time_window->time_width;
6f26fc38 3480 LttTime old_end = old_time_window->end_time;
3481 LttTime new_end = new_time_window->end_time;
a56a1ba4 3482 //if(ns<os+w<ns+w)
3483 //if(ns<os+w && os+w<ns+w)
3484 //if(ns<old_end && os<ns)
3485 if(ltt_time_compare(*ns, old_end) == -1
3486 && ltt_time_compare(*os, *ns) == -1)
3487 {
3488 g_info("scrolling near right");
3489 /* Scroll right, keep right part of the screen */
3490 guint x = 0;
51705146 3491 guint width = control_flow_data->drawing->width;
a56a1ba4 3492 convert_time_to_pixels(
a18124ff 3493 *old_time_window,
a56a1ba4 3494 *ns,
3495 width,
3496 &x);
3497
3498 /* Copy old data to new location */
1c736ed5 3499 copy_pixmap_region(process_list,
3500 NULL,
3501 control_flow_data->drawing->drawing_area->style->black_gc,
3502 NULL,
3503 x, 0,
3504 0, 0,
3505 control_flow_data->drawing->width-x+SAFETY, -1);
3506
6395d57c 3507 if(drawing->damage_begin == drawing->damage_end)
3508 drawing->damage_begin = control_flow_data->drawing->width-x;
3509 else
3510 drawing->damage_begin = 0;
3511
3512 drawing->damage_end = control_flow_data->drawing->width;
3513
a56a1ba4 3514 /* Clear the data request background, but not SAFETY */
1c736ed5 3515 rectangle_pixmap(process_list,
cfe526b1 3516 control_flow_data->drawing->drawing_area->style->black_gc,
a56a1ba4 3517 TRUE,
6395d57c 3518 drawing->damage_begin+SAFETY, 0,
3519 drawing->damage_end - drawing->damage_begin, // do not overlap
1c736ed5 3520 -1);
7abb23ad 3521 gtk_widget_queue_draw(drawing->drawing_area);
3522 //gtk_widget_queue_draw_area (drawing->drawing_area,
3523 // 0,0,
3524 // control_flow_data->drawing->width,
3525 // control_flow_data->drawing->height);
a43d67ba 3526
a56a1ba4 3527 /* Get new data for the rest. */
501d5405 3528 drawing_data_request(control_flow_data->drawing,
6395d57c 3529 drawing->damage_begin, 0,
3530 drawing->damage_end - drawing->damage_begin,
501d5405 3531 control_flow_data->drawing->height);
a56a1ba4 3532 } else {
3533 //if(ns<os<ns+w)
3534 //if(ns<os && os<ns+w)
3535 //if(ns<os && os<new_end)
3536 if(ltt_time_compare(*ns,*os) == -1
3537 && ltt_time_compare(*os,new_end) == -1)
3538 {
3539 g_info("scrolling near left");
3540 /* Scroll left, keep left part of the screen */
3541 guint x = 0;
51705146 3542 guint width = control_flow_data->drawing->width;
a56a1ba4 3543 convert_time_to_pixels(
a18124ff 3544 *new_time_window,
a56a1ba4 3545 *os,
3546 width,
3547 &x);
6395d57c 3548
a56a1ba4 3549 /* Copy old data to new location */
1c736ed5 3550 copy_pixmap_region (process_list,
3551 NULL,
cfe526b1 3552 control_flow_data->drawing->drawing_area->style->black_gc,
1c736ed5 3553 NULL,
a56a1ba4 3554 0, 0,
3555 x, 0,
3556 -1, -1);
3557
6395d57c 3558 if(drawing->damage_begin == drawing->damage_end)
3559 drawing->damage_end = x;
3560 else
3561 drawing->damage_end =
51705146 3562 control_flow_data->drawing->width;
6395d57c 3563
3564 drawing->damage_begin = 0;
3565
1c736ed5 3566 rectangle_pixmap (process_list,
cfe526b1 3567 control_flow_data->drawing->drawing_area->style->black_gc,
a56a1ba4 3568 TRUE,
6395d57c 3569 drawing->damage_begin, 0,
3570 drawing->damage_end - drawing->damage_begin, // do not overlap
1c736ed5 3571 -1);
a43d67ba 3572
7abb23ad 3573 gtk_widget_queue_draw(drawing->drawing_area);
3574 //gtk_widget_queue_draw_area (drawing->drawing_area,
3575 // 0,0,
3576 // control_flow_data->drawing->width,
3577 // control_flow_data->drawing->height);
a43d67ba 3578
6395d57c 3579
a56a1ba4 3580 /* Get new data for the rest. */
501d5405 3581 drawing_data_request(control_flow_data->drawing,
6395d57c 3582 drawing->damage_begin, 0,
3583 drawing->damage_end - drawing->damage_begin,
501d5405 3584 control_flow_data->drawing->height);
a56a1ba4 3585
a56a1ba4 3586 } else {
a43d67ba 3587 if(ltt_time_compare(*ns,*os) == 0)
3588 {
3589 g_info("not scrolling");
3590 } else {
3591 g_info("scrolling far");
3592 /* Cannot reuse any part of the screen : far jump */
3593
3594
1c736ed5 3595 rectangle_pixmap (process_list,
a43d67ba 3596 control_flow_data->drawing->drawing_area->style->black_gc,
3597 TRUE,
a56a1ba4 3598 0, 0,
a43d67ba 3599 control_flow_data->drawing->width+SAFETY, // do not overlap
1c736ed5 3600 -1);
a43d67ba 3601
7abb23ad 3602 //gtk_widget_queue_draw_area (drawing->drawing_area,
3603 // 0,0,
3604 // control_flow_data->drawing->width,
3605 // control_flow_data->drawing->height);
3606 gtk_widget_queue_draw(drawing->drawing_area);
a43d67ba 3607
6395d57c 3608 drawing->damage_begin = 0;
3609 drawing->damage_end = control_flow_data->drawing->width;
3610
a43d67ba 3611 drawing_data_request(control_flow_data->drawing,
a43d67ba 3612 0, 0,
3613 control_flow_data->drawing->width,
3614 control_flow_data->drawing->height);
3615
3616 }
a56a1ba4 3617 }
3618 }
3619 } else {
3620 /* Different scale (zoom) */
3621 g_info("zoom");
3622
1c736ed5 3623 rectangle_pixmap (process_list,
cfe526b1 3624 control_flow_data->drawing->drawing_area->style->black_gc,
a56a1ba4 3625 TRUE,
3626 0, 0,
501d5405 3627 control_flow_data->drawing->width+SAFETY, // do not overlap
1c736ed5 3628 -1);
a56a1ba4 3629
7abb23ad 3630 //gtk_widget_queue_draw_area (drawing->drawing_area,
3631 // 0,0,
3632 // control_flow_data->drawing->width,
3633 // control_flow_data->drawing->height);
3634 gtk_widget_queue_draw(drawing->drawing_area);
a56a1ba4 3635
6395d57c 3636 drawing->damage_begin = 0;
3637 drawing->damage_end = control_flow_data->drawing->width;
3638
501d5405 3639 drawing_data_request(control_flow_data->drawing,
a56a1ba4 3640 0, 0,
501d5405 3641 control_flow_data->drawing->width,
3642 control_flow_data->drawing->height);
a56a1ba4 3643 }
3644
3cb8b205 3645
3646
a56a1ba4 3647 return 0;
f7afe191 3648}
3649
6395d57c 3650gint traceset_notify(void *hook_data, void *call_data)
3651{
3652 ControlFlowData *control_flow_data = (ControlFlowData*) hook_data;
3653 Drawing_t *drawing = control_flow_data->drawing;
6395d57c 3654
6395d57c 3655
b9a010a2 3656 drawing_clear(control_flow_data->drawing);
3657 processlist_clear(control_flow_data->process_list);
07390ec1 3658 gtk_widget_set_size_request(
3659 control_flow_data->drawing->drawing_area,
3660 -1, processlist_get_height(control_flow_data->process_list));
d9267eec 3661 redraw_notify(control_flow_data, NULL);
6395d57c 3662
d9267eec 3663 request_background_data(control_flow_data);
6395d57c 3664
3665 return FALSE;
3666}
3667
ca0f8a8e 3668gint redraw_notify(void *hook_data, void *call_data)
3669{
3670 ControlFlowData *control_flow_data = (ControlFlowData*) hook_data;
3671 Drawing_t *drawing = control_flow_data->drawing;
3672 GtkWidget *widget = drawing->drawing_area;
3673
3674 drawing->damage_begin = 0;
51705146 3675 drawing->damage_end = drawing->width;
ca0f8a8e 3676
49217bd4 3677 /* fun feature, to be separated someday... */
3678 drawing_clear(control_flow_data->drawing);
3679 processlist_clear(control_flow_data->process_list);
07390ec1 3680 gtk_widget_set_size_request(
3681 control_flow_data->drawing->drawing_area,
3682 -1, processlist_get_height(control_flow_data->process_list));
1c736ed5 3683 // Clear the images
3684 rectangle_pixmap (control_flow_data->process_list,
ca0f8a8e 3685 widget->style->black_gc,
3686 TRUE,
3687 0, 0,
f3b7430d 3688 drawing->alloc_width,
1c736ed5 3689 -1);
ca0f8a8e 3690
f3b7430d 3691 gtk_widget_queue_draw(drawing->drawing_area);
ca0f8a8e 3692
3693 if(drawing->damage_begin < drawing->damage_end)
3694 {
3695 drawing_data_request(drawing,
ca0f8a8e 3696 drawing->damage_begin,
3697 0,
3698 drawing->damage_end-drawing->damage_begin,
51705146 3699 drawing->height);
ca0f8a8e 3700 }
3701
7abb23ad 3702 //gtk_widget_queue_draw_area(drawing->drawing_area,
3703 // 0,0,
3704 // drawing->width,
3705 // drawing->height);
ca0f8a8e 3706 return FALSE;
3707
3708}
3709
3710
3711gint continue_notify(void *hook_data, void *call_data)
a43d67ba 3712{
3713 ControlFlowData *control_flow_data = (ControlFlowData*) hook_data;
ca0f8a8e 3714 Drawing_t *drawing = control_flow_data->drawing;
a43d67ba 3715
6395d57c 3716 //g_assert(widget->allocation.width == drawing->damage_end);
ca0f8a8e 3717
3718 if(drawing->damage_begin < drawing->damage_end)
3719 {
3720 drawing_data_request(drawing,
ca0f8a8e 3721 drawing->damage_begin,
3722 0,
3723 drawing->damage_end-drawing->damage_begin,
51705146 3724 drawing->height);
ca0f8a8e 3725 }
3726
3727 return FALSE;
3728}
3729
3730
1b238973 3731gint update_current_time_hook(void *hook_data, void *call_data)
f7afe191 3732{
14963be0 3733 ControlFlowData *control_flow_data = (ControlFlowData*)hook_data;
a43d67ba 3734 Drawing_t *drawing = control_flow_data->drawing;
a56a1ba4 3735
224446ce 3736 LttTime current_time = *((LttTime*)call_data);
a56a1ba4 3737
ca0f8a8e 3738 TimeWindow time_window =
3739 lttvwindow_get_time_window(control_flow_data->tab);
a56a1ba4 3740
ca0f8a8e 3741 LttTime time_begin = time_window.start_time;
3742 LttTime width = time_window.time_width;
90ef7e4a 3743 LttTime half_width;
3744 {
3745 guint64 time_ll = ltt_time_to_uint64(width);
3746 time_ll = time_ll >> 1; /* divide by two */
3747 half_width = ltt_time_from_uint64(time_ll);
3748 }
a56a1ba4 3749 LttTime time_end = ltt_time_add(time_begin, width);
3750
3751 LttvTracesetContext * tsc =
ca0f8a8e 3752 lttvwindow_get_traceset_context(control_flow_data->tab);
a56a1ba4 3753
ca0f8a8e 3754 LttTime trace_start = tsc->time_span.start_time;
3755 LttTime trace_end = tsc->time_span.end_time;
a56a1ba4 3756
2eef04b5 3757 g_info("New current time HOOK : %lu, %lu", current_time.tv_sec,
224446ce 3758 current_time.tv_nsec);
a56a1ba4 3759
3760
3761
3762 /* If current time is inside time interval, just move the highlight
3763 * bar */
3764
3765 /* Else, we have to change the time interval. We have to tell it
3766 * to the main window. */
3767 /* The time interval change will take care of placing the current
3768 * time at the center of the visible area, or nearest possible if we are
3769 * at one end of the trace. */
3770
3771
dbc0ef8a 3772 if(ltt_time_compare(current_time, time_begin) < 0)
a56a1ba4 3773 {
224446ce 3774 TimeWindow new_time_window;
3775
3776 if(ltt_time_compare(current_time,
dbc0ef8a 3777 ltt_time_add(trace_start,half_width)) < 0)
a56a1ba4 3778 time_begin = trace_start;
3779 else
224446ce 3780 time_begin = ltt_time_sub(current_time,half_width);
a56a1ba4 3781
224446ce 3782 new_time_window.start_time = time_begin;
3783 new_time_window.time_width = width;
a18124ff 3784 new_time_window.time_width_double = ltt_time_to_double(width);
6f26fc38 3785 new_time_window.end_time = ltt_time_add(time_begin, width);
a56a1ba4 3786
e800cf84 3787 lttvwindow_report_time_window(control_flow_data->tab, new_time_window);
a56a1ba4 3788 }
dbc0ef8a 3789 else if(ltt_time_compare(current_time, time_end) > 0)
a56a1ba4 3790 {
224446ce 3791 TimeWindow new_time_window;
3792
dbc0ef8a 3793 if(ltt_time_compare(current_time, ltt_time_sub(trace_end, half_width)) > 0)
a56a1ba4 3794 time_begin = ltt_time_sub(trace_end,width);
3795 else
224446ce 3796 time_begin = ltt_time_sub(current_time,half_width);
a56a1ba4 3797
224446ce 3798 new_time_window.start_time = time_begin;
3799 new_time_window.time_width = width;
a18124ff 3800 new_time_window.time_width_double = ltt_time_to_double(width);
6f26fc38 3801 new_time_window.end_time = ltt_time_add(time_begin, width);
a56a1ba4 3802
e800cf84 3803 lttvwindow_report_time_window(control_flow_data->tab, new_time_window);
a56a1ba4 3804
3805 }
7abb23ad 3806 gtk_widget_queue_draw(control_flow_data->drawing->drawing_area);
3807
a56a1ba4 3808
3809 return 0;
f7afe191 3810}
3811
8b90e648 3812typedef struct _ClosureData {
ca0f8a8e 3813 EventsRequest *events_request;
d0cd7f09 3814 LttvTracesetState *tss;
b9a010a2 3815 LttTime end_time;
bc8d270b 3816 guint x_end;
8b90e648 3817} ClosureData;
a56a1ba4 3818
8b90e648 3819
e800cf84 3820void draw_closure(gpointer key, gpointer value, gpointer user_data)
3821{
a56a1ba4 3822 ProcessInfo *process_info = (ProcessInfo*)key;
3823 HashedProcessData *hashed_process_data = (HashedProcessData*)value;
3824 ClosureData *closure_data = (ClosureData*)user_data;
3825
e800cf84 3826 EventsRequest *events_request = closure_data->events_request;
3827 ControlFlowData *control_flow_data = events_request->viewer_data;
a56a1ba4 3828
e800cf84 3829 LttvTracesetState *tss = closure_data->tss;
d6fef890 3830 LttvTracesetContext *tsc = (LttvTracesetContext*)tss;
a56a1ba4 3831
e800cf84 3832 LttTime evtime = closure_data->end_time;
d0cd7f09 3833
e800cf84 3834 {
3835 /* For the process */
3836 /* First, check if the current process is in the state computation
3837 * process list. If it is there, that means we must add it right now and
3838 * draw items from the beginning of the read for it. If it is not
3839 * present, it's a new process and it was not present : it will
3840 * be added after the state update. */
31b6868d 3841#ifdef EXTRA_CHECK
e800cf84 3842 g_assert(lttv_traceset_number(tsc->ts) > 0);
31b6868d 3843#endif //EXTRA_CHECK
2c82c4dc 3844 LttvTraceContext *tc = tsc->traces[process_info->trace_num];
3845
3846 //FIXME : optimize data structures.
3847 LttvTracefileState *tfs;
3848 LttvTracefileContext *tfc;
3849 guint i;
3850 for(i=0;i<tc->tracefiles->len;i++) {
3851 tfc = g_array_index(tc->tracefiles, LttvTracefileContext*, i);
3852 if(ltt_tracefile_name(tfc->tf) == LTT_NAME_CPU
3853 && ltt_tracefile_num(tfc->tf) == process_info->cpu)
3854 break;
3855
3856 }
3857 g_assert(i<tc->tracefiles->len);
3858 tfs = LTTV_TRACEFILE_STATE(tfc);
a56a1ba4 3859
2c82c4dc 3860 // LttvTracefileState *tfs =
3861 // (LttvTracefileState*)tsc->traces[process_info->trace_num]->
3862 // tracefiles[process_info->cpu];
2da61677 3863
e800cf84 3864 LttvProcessState *process;
e025a729 3865 process = lttv_state_find_process(tfs,
3866 process_info->pid);
a56a1ba4 3867
1d1df11d 3868 if(unlikely(process != NULL)) {
e800cf84 3869
3870 /* Only draw for processes that are currently in the trace states */
ad2e83ba 3871
5c230fc4 3872 ProcessList *process_list = control_flow_data->process_list;
1d1df11d 3873#ifdef EXTRA_CHECK
e800cf84 3874 /* Should be alike when background info is ready */
3875 if(control_flow_data->background_info_waiting==0)
3876 g_assert(ltt_time_compare(process->creation_time,
3877 process_info->birth) == 0);
1d1df11d 3878#endif //EXTRA_CHECK
e800cf84 3879
3880 /* Now, the process is in the state hash and our own process hash.
3881 * We definitely can draw the items related to the ending state.
3882 */
3883
1d1df11d 3884 if(unlikely(ltt_time_compare(hashed_process_data->next_good_time,
3885 evtime) <= 0))
e800cf84 3886 {
fd22065b 3887 TimeWindow time_window =
3888 lttvwindow_get_time_window(control_flow_data->tab);
3889
3890#ifdef EXTRA_CHECK
3891 if(ltt_time_compare(evtime, time_window.start_time) == -1
3892 || ltt_time_compare(evtime, time_window.end_time) == 1)
3893 return;
3894#endif //EXTRA_CHECK
d6fef890 3895 Drawing_t *drawing = control_flow_data->drawing;
96947fcf 3896 guint width = drawing->width;
a56a1ba4 3897
bc8d270b 3898 guint x = closure_data->x_end;
8b90e648 3899
4b7dc462 3900 DrawContext draw_context;
3901
e800cf84 3902 /* Now create the drawing context that will be used to draw
3903 * items related to the last state. */
1c736ed5 3904 draw_context.drawable = hashed_process_data->pixmap;
e800cf84 3905 draw_context.gc = drawing->gc;
3906 draw_context.pango_layout = drawing->pango_layout;
e800cf84 3907 draw_context.drawinfo.end.x = x;
3908
1c736ed5 3909 draw_context.drawinfo.y.over = 1;
3910 draw_context.drawinfo.y.middle = (hashed_process_data->height/2);
3911 draw_context.drawinfo.y.under = hashed_process_data->height;
e800cf84 3912
3913 draw_context.drawinfo.start.offset.over = 0;
3914 draw_context.drawinfo.start.offset.middle = 0;
3915 draw_context.drawinfo.start.offset.under = 0;
3916 draw_context.drawinfo.end.offset.over = 0;
3917 draw_context.drawinfo.end.offset.middle = 0;
3918 draw_context.drawinfo.end.offset.under = 0;
9a1ec01b 3919#if 0
4b7dc462 3920 /* Jump over draw if we are at the same x position */
3921 if(x == hashed_process_data->x.over)
e800cf84 3922 {
4b7dc462 3923 /* jump */
3924 } else {
23093869 3925 draw_context.drawinfo.start.x = hashed_process_data->x.over;
3926 /* Draw the line */
3927 PropertiesLine prop_line = prepare_execmode_line(process);
3928 draw_line((void*)&prop_line, (void*)&draw_context);
3929
4b7dc462 3930 hashed_process_data->x.over = x;
23093869 3931 }
9a1ec01b 3932#endif //0
4b7dc462 3933
1d1df11d 3934 if(unlikely(x == hashed_process_data->x.middle &&
3935 hashed_process_data->x.middle_used)) {
b2743953 3936#if 0 /* do not mark closure : not missing information */
e72908ed 3937 if(hashed_process_data->x.middle_marked == FALSE) {
3938 /* Draw collision indicator */
3939 gdk_gc_set_foreground(drawing->gc, &drawing_colors[COL_WHITE]);
3940 gdk_draw_point(drawing->pixmap,
3941 drawing->gc,
3942 x,
2c6618bc 3943 y+(height/2)-3);
de4ea1ad 3944 hashed_process_data->x.middle_marked = TRUE;
e72908ed 3945 }
b2743953 3946#endif //0
4b7dc462 3947 /* Jump */
3948 } else {
23093869 3949 draw_context.drawinfo.start.x = hashed_process_data->x.middle;
e800cf84 3950 /* Draw the line */
9a1ec01b 3951 PropertiesLine prop_line = prepare_s_e_line(process);
e800cf84 3952 draw_line((void*)&prop_line, (void*)&draw_context);
3953
4b7dc462 3954 /* become the last x position */
1d1df11d 3955 if(likely(x != hashed_process_data->x.middle)) {
e72908ed 3956 hashed_process_data->x.middle = x;
3957 /* but don't use the pixel */
3958 hashed_process_data->x.middle_used = FALSE;
b2743953 3959
3960 /* Calculate the next good time */
3961 convert_pixels_to_time(width, x+1, time_window,
3962 &hashed_process_data->next_good_time);
e72908ed 3963 }
e800cf84 3964 }
e800cf84 3965 }
3966 }
3967 }
3968 return;
8b90e648 3969}
3970
b9a010a2 3971int before_chunk(void *hook_data, void *call_data)
3972{
3973 EventsRequest *events_request = (EventsRequest*)hook_data;
16b9cadb 3974 LttvTracesetState *tss = (LttvTracesetState*)call_data;
7c0125e0 3975 ControlFlowData *cfd = (ControlFlowData*)events_request->viewer_data;
cd3892fe 3976#if 0
7c0125e0 3977 /* Desactivate sort */
3978 gtk_tree_sortable_set_sort_column_id(
3979 GTK_TREE_SORTABLE(cfd->process_list->list_store),
3980 TRACE_COLUMN,
3981 GTK_SORT_ASCENDING);
cd3892fe 3982#endif //0
b9a010a2 3983 drawing_chunk_begin(events_request, tss);
3984
3985 return 0;
3986}
3987
3988int before_request(void *hook_data, void *call_data)
ca0f8a8e 3989{
3990 EventsRequest *events_request = (EventsRequest*)hook_data;
16b9cadb 3991 LttvTracesetState *tss = (LttvTracesetState*)call_data;
7c0125e0 3992
ca0f8a8e 3993 drawing_data_request_begin(events_request, tss);
3994
3995 return 0;
3996}
3997
3998
8b90e648 3999/*
b9a010a2 4000 * after request is necessary in addition of after chunk in order to draw
4001 * lines until the end of the screen. after chunk just draws lines until
4002 * the last event.
4003 *
8b90e648 4004 * for each process
a56a1ba4 4005 * draw closing line
b9a010a2 4006 * expose
8b90e648 4007 */
b9a010a2 4008int after_request(void *hook_data, void *call_data)
8b90e648 4009{
ca0f8a8e 4010 EventsRequest *events_request = (EventsRequest*)hook_data;
4011 ControlFlowData *control_flow_data = events_request->viewer_data;
16b9cadb 4012 LttvTracesetState *tss = (LttvTracesetState*)call_data;
a56a1ba4 4013
5c230fc4 4014 ProcessList *process_list = control_flow_data->process_list;
b9a010a2 4015 LttTime end_time = events_request->end_time;
4016
4017 ClosureData closure_data;
4018 closure_data.events_request = (EventsRequest*)hook_data;
4019 closure_data.tss = tss;
4020 closure_data.end_time = end_time;
4021
bc8d270b 4022 TimeWindow time_window =
4023 lttvwindow_get_time_window(control_flow_data->tab);
4024 guint width = control_flow_data->drawing->width;
4025 convert_time_to_pixels(
4026 time_window,
4027 end_time,
4028 width,
4029 &closure_data.x_end);
4030
4031
b9a010a2 4032 /* Draw last items */
4033 g_hash_table_foreach(process_list->process_hash, draw_closure,
4034 (void*)&closure_data);
7c0125e0 4035
b9a010a2 4036
4037 /* Request expose */
4038 drawing_request_expose(events_request, tss, end_time);
4039 return 0;
4040}
4041
4042/*
4043 * for each process
4044 * draw closing line
e800cf84 4045 * expose
b9a010a2 4046 */
4047int after_chunk(void *hook_data, void *call_data)
4048{
4049 EventsRequest *events_request = (EventsRequest*)hook_data;
4050 ControlFlowData *control_flow_data = events_request->viewer_data;
16b9cadb 4051 LttvTracesetState *tss = (LttvTracesetState*)call_data;
4052 LttvTracesetContext *tsc = (LttvTracesetContext*)call_data;
b9a010a2 4053 LttvTracefileContext *tfc = lttv_traceset_context_get_current_tfc(tsc);
4054 LttTime end_time;
4055
5c230fc4 4056 ProcessList *process_list = control_flow_data->process_list;
b9a010a2 4057
40debf7b 4058 g_free(process_list->current_hash_data);
4059 process_list->current_hash_data = NULL;
4060
e800cf84 4061 if(tfc != NULL)
4062 end_time = LTT_TIME_MIN(tfc->timestamp, events_request->end_time);
0c5dbe3b 4063 else /* end of traceset, or position now out of request : end */
4064 end_time = events_request->end_time;
4065
a56a1ba4 4066 ClosureData closure_data;
ca0f8a8e 4067 closure_data.events_request = (EventsRequest*)hook_data;
4068 closure_data.tss = tss;
b9a010a2 4069 closure_data.end_time = end_time;
a56a1ba4 4070
bc8d270b 4071 TimeWindow time_window =
4072 lttvwindow_get_time_window(control_flow_data->tab);
4073 guint width = control_flow_data->drawing->width;
4074 convert_time_to_pixels(
4075 time_window,
4076 end_time,
4077 width,
4078 &closure_data.x_end);
4079
b9a010a2 4080 /* Draw last items */
14963be0 4081 g_hash_table_foreach(process_list->process_hash, draw_closure,
a56a1ba4 4082 (void*)&closure_data);
cd3892fe 4083#if 0
7c0125e0 4084 /* Reactivate sort */
4085 gtk_tree_sortable_set_sort_column_id(
4086 GTK_TREE_SORTABLE(control_flow_data->process_list->list_store),
4087 GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
4088 GTK_SORT_ASCENDING);
4089
4090 update_index_to_pixmap(control_flow_data->process_list);
cd3892fe 4091 /* Request a full expose : drawing scrambled */
4092 gtk_widget_queue_draw(control_flow_data->drawing->drawing_area);
4093#endif //0
4094 /* Request expose (updates damages zone also) */
b9a010a2 4095 drawing_request_expose(events_request, tss, end_time);
ca0f8a8e 4096
4097 return 0;
8b90e648 4098}
4099
LTTng 2.x Viewer (LTTV)
This page took 0.254807 seconds and 4 git commands to generate.