now, main window resize will change the scale, not time interval
[lttv.git] / ltt / branches / poly / lttv / modules / guiControlFlow / Event_Hooks.c
index 6340bfcba7d1c2e8670476276511c61bdc76c916..de41f0c64cc01948438bab4a23eb0724aa98f445 100644 (file)
 #include <gtk/gtk.h>
 #include <gdk/gdk.h>
 #include <glib.h>
+#include <assert.h>
 
 //#include <pango/pango.h>
 
+#include <ltt/event.h>
+#include <ltt/time.h>
+
 #include <lttv/hook.h>
 #include <lttv/common.h>
+#include <lttv/state.h>
+
 
 #include "Event_Hooks.h"
 #include "CFV.h"
@@ -22,6 +28,7 @@
 #include "Drawing.h"
 #include "CFV-private.h"
 
+
 #define MAX_PATH_LEN 256
 
 //FIXME : remove this include when tests finished.
@@ -36,16 +43,14 @@ void test_draw_item(Drawing_t *Drawing,
        DrawInfo current, previous;
        ItemInfo over, middle, under, modify_over, modify_middle, modify_under;
 
-       int i,j;
+       int i=0,j=0;
        
-       for(i=0; i<1024;i=i+15)
+       //for(i=0; i<1024;i=i+15)
        {
-               for(j=0;j<768;j=j+15)
+       //      for(j=0;j<768;j=j+15)
                {
                        over.x = i;
                        over.y = j;
-                       over.ts =  NULL;
-                       over.tfs = NULL;
 
                        current.modify_over = &over;
        
@@ -69,6 +74,7 @@ void test_draw_item(Drawing_t *Drawing,
 
 }
 
+#ifdef NOTUSE
 /* NOTE : no drawing data should be sent there, since the drawing widget
  * has not been initialized */
 void send_test_drawing(ProcessList *Process_List,
@@ -396,7 +402,7 @@ void send_test_process(ProcessList *Process_List, Drawing_t *Drawing)
        Process_List->Test_Process_Sent = TRUE;
 
 }
-
+#endif//NOTUSE
 
 
 /**
@@ -491,23 +497,23 @@ int draw_before_hook(void *hook_data, void *call_data)
 int draw_event_hook(void *hook_data, void *call_data)
 {
        EventRequest *Event_Request = (EventRequest*)hook_data;
-       
+       ControlFlowData *control_flow_data = Event_Request->Control_Flow_Data;
        //static int i=0;
 
        //i++;
        //g_critical("%i", i);
-       
-       /* Text dumping if the information */
-       GString *string = g_string_new("");;
-       gboolean field_names = TRUE, state = TRUE;
-  LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
+       LttvTracefileContext *tfc = (LttvTracefileContext *)call_data;
 
   LttvTracefileState *tfs = (LttvTracefileState *)call_data;
 
   LttEvent *e;
-
   e = tfc->e;
 
+       /* Temp dump */
+#ifdef DONTSHOW
+       GString *string = g_string_new("");;
+       gboolean field_names = TRUE, state = TRUE;
+
   lttv_event_to_string(e, tfc->tf, string, TRUE, field_names, tfs);
   g_string_append_printf(string,"\n");  
 
@@ -521,12 +527,15 @@ int draw_event_hook(void *hook_data, void *call_data)
        g_string_free(string, TRUE);
        
        /* End of text dump */
-
+#endif //DONTSHOW
        /* Add process to process list (if not present) and get drawing "y" from
         * process position */
        guint pid = tfs->process->pid;
        LttTime birth = tfs->process->creation_time;
-       guint y = 0, height = 0;
+       gchar *name = strdup("name");
+       guint y = 0, height = 0, pl_height = 0;
+       HashedProcessData *Hashed_Process_Data = NULL;
+
        ProcessList *process_list =
                guicontrolflow_get_process_list(Event_Request->Control_Flow_Data);
        
@@ -534,23 +543,58 @@ int draw_event_hook(void *hook_data, void *call_data)
                                        pid,
                                        &birth,
                                        &y,
-                                       &height) == 1)
+                                       &height,
+                                       &Hashed_Process_Data) == 1)
        {
                /* Process not present */
                processlist_add(process_list,
                                pid,
                                &birth,
-                               &y);
+                               name,
+                               &pl_height,
+                               &Hashed_Process_Data);
+               g_free(name);
                drawing_insert_square( Event_Request->Control_Flow_Data->Drawing, y, height);
        }
-
+       
        /* Find pixels corresponding to time of the event. If the time does
         * not fit in the window, show a warning, not supposed to happend. */
-       
+       guint x = 0;
+       guint width = control_flow_data->Drawing->Drawing_Area_V->allocation.width;
 
-       /* Finally, draw what represents the event. */
+       LttTime time = ltt_event_time(e);
+
+       LttTime window_end = ltt_time_add(control_flow_data->Time_Window.time_width,
+                                                                                               control_flow_data->Time_Window.start_time);
+
+       
+       convert_time_to_pixels(
+                       control_flow_data->Time_Window.start_time,
+                       window_end,
+                       time,
+                       width,
+                       &x);
        
+       assert(x <= width);
        
+       /* Finally, draw what represents the event. */
+
+       GdkColor color = { 0, 0xffff, 0x0000, 0x0000 };
+       PropertiesArc prop_arc;
+       prop_arc.color = &color;
+       prop_arc.size = 10;
+       prop_arc.filled = TRUE;
+       prop_arc.position = OVER;
+       DrawContext *draw_context = Hashed_Process_Data->draw_context;
+       draw_context->Current->modify_over->x = x;
+       draw_context->Current->modify_over->y = y;
+       draw_context->drawable = control_flow_data->Drawing->Pixmap;
+       GtkWidget *widget = control_flow_data->Drawing->Drawing_Area_V;
+       //draw_context->gc = widget->style->fg_gc[GTK_WIDGET_STATE (widget)];
+       draw_context->gc = widget->style->black_gc;
+       
+       draw_arc((void*)&prop_arc, (void*)draw_context);
+       //test_draw_item(control_flow_data->Drawing, control_flow_data->Drawing->Pixmap);
        return 0;
 }
 
@@ -568,34 +612,193 @@ int draw_after_hook(void *hook_data, void *call_data)
 
 void update_time_window_hook(void *hook_data, void *call_data)
 {
-       ControlFlowData *Control_Flow_Data = (ControlFlowData*) hook_data;
-       TimeWindowTime_Window = 
-               guicontrolflow_get_time_window(Control_Flow_Data);
+       ControlFlowData *control_flow_data = (ControlFlowData*) hook_data;
+       TimeWindow *Old_Time_Window = 
+               guicontrolflow_get_time_window(control_flow_data);
        TimeWindow *New_Time_Window = ((TimeWindow*)call_data);
-
-       // As the time interval change will mostly be used for
-       // zoom in and out, it's not useful to keep old drawing
-       // sections, as scale will be changed.
        
+       /* Two cases : zoom in/out or scrolling */
+       
+       /* In order to make sure we can reuse the old drawing, the scale must
+        * be the same and the new time interval being partly located in the
+        * currently shown time interval. (reuse is only for scrolling)
+        */
+
+       g_info("Old time window HOOK : %u, %u to %u, %u",
+                       Old_Time_Window->start_time.tv_sec,
+                       Old_Time_Window->start_time.tv_nsec,
+                       Old_Time_Window->time_width.tv_sec,
+                       Old_Time_Window->time_width.tv_nsec);
 
-       *Time_Window = *New_Time_Window;
        g_info("New time window HOOK : %u, %u to %u, %u",
-                       Time_Window->start_time.tv_sec,
-                       Time_Window->start_time.tv_nsec,
-                       Time_Window->time_width.tv_sec,
-                       Time_Window->time_width.tv_nsec);
-
-  drawing_data_request(Control_Flow_Data->Drawing,
-                       &Control_Flow_Data->Drawing->Pixmap,
-                       0, 0,
-                       Control_Flow_Data->Drawing->width,
-                       Control_Flow_Data->Drawing->height);
-
-       drawing_refresh(Control_Flow_Data->Drawing,
-                       0, 0,
-                       Control_Flow_Data->Drawing->width,
-                       Control_Flow_Data->Drawing->height);
+                       New_Time_Window->start_time.tv_sec,
+                       New_Time_Window->start_time.tv_nsec,
+                       New_Time_Window->time_width.tv_sec,
+                       New_Time_Window->time_width.tv_nsec);
 
+       if( New_Time_Window->time_width.tv_sec == Old_Time_Window->time_width.tv_sec
+       && New_Time_Window->time_width.tv_nsec == Old_Time_Window->time_width.tv_nsec)
+       {
+               /* Same scale (scrolling) */
+               g_info("scrolling");
+               LttTime *ns = &New_Time_Window->start_time;
+               LttTime *os = &Old_Time_Window->start_time;
+               LttTime old_end = ltt_time_add(Old_Time_Window->start_time,
+                                                                                                                                               Old_Time_Window->time_width);
+               LttTime new_end = ltt_time_add(New_Time_Window->start_time,
+                                                                                                                                               New_Time_Window->time_width);
+               //if(ns<os+w<ns+w)
+               //if(ns<os+w && os+w<ns+w)
+               //if(ns<old_end && os<ns)
+               if(ltt_time_compare(*ns, old_end) == -1
+                               && ltt_time_compare(*os, *ns) == -1)
+               {
+                       g_info("scrolling near right");
+                       /* Scroll right, keep right part of the screen */
+                       guint x = 0;
+                       guint width = control_flow_data->Drawing->Drawing_Area_V->allocation.width;
+                       convert_time_to_pixels(
+                                       *os,
+                                       old_end,
+                                       *ns,
+                                       width,
+                                       &x);
+
+                 /* Copy old data to new location */
+                 gdk_draw_drawable (control_flow_data->Drawing->Pixmap,
+                                 control_flow_data->Drawing->Drawing_Area_V->style->white_gc,
+                                 control_flow_data->Drawing->Pixmap,
+                                 x, 0,
+                                 0, 0,
+                                 -1, -1);
+                       
+                       convert_time_to_pixels(
+                                       *ns,
+                                       new_end,
+                                       old_end,
+                                       width,
+                                       &x);
+
+                       *Old_Time_Window = *New_Time_Window;
+                       /* Clear the data request background, but not SAFETY */
+                       gdk_draw_rectangle (control_flow_data->Drawing->Pixmap,
+                                       control_flow_data->Drawing->Drawing_Area_V->style->white_gc,
+                     TRUE,
+                     x+SAFETY, 0,
+                     control_flow_data->Drawing->width - x,    // do not overlap
+                     control_flow_data->Drawing->height+SAFETY);
+                       /* Get new data for the rest. */
+                 drawing_data_request(control_flow_data->Drawing,
+                                       &control_flow_data->Drawing->Pixmap,
+                                       x, 0,
+                                       control_flow_data->Drawing->width - x,
+                                       control_flow_data->Drawing->height);
+       
+                       drawing_refresh(control_flow_data->Drawing,
+                                       0, 0,
+                                       control_flow_data->Drawing->width,
+                                       control_flow_data->Drawing->height);
+
+
+               } else { 
+                       //if(ns<os<ns+w)
+                       //if(ns<os && os<ns+w)
+                       //if(ns<os && os<new_end)
+                       if(ltt_time_compare(*ns,*os) == -1
+                                       && ltt_time_compare(*os,new_end) == -1)
+                       {
+                               g_info("scrolling near left");
+                               /* Scroll left, keep left part of the screen */
+                               guint x = 0;
+                               guint width = control_flow_data->Drawing->Drawing_Area_V->allocation.width;
+                               convert_time_to_pixels(
+                                               *ns,
+                                               new_end,
+                                               *os,
+                                               width,
+                                               &x);
+       
+                         /* Copy old data to new location */
+                         gdk_draw_drawable (control_flow_data->Drawing->Pixmap,
+                                       control_flow_data->Drawing->Drawing_Area_V->style->white_gc,
+                                         control_flow_data->Drawing->Pixmap,
+                                         0, 0,
+                                         x, 0,
+                                         -1, -1);
+       
+                               *Old_Time_Window = *New_Time_Window;
+
+                               /* Clean the data request background */
+                               gdk_draw_rectangle (control_flow_data->Drawing->Pixmap,
+                                       control_flow_data->Drawing->Drawing_Area_V->style->white_gc,
+                     TRUE,
+                     0, 0,
+                     x,        // do not overlap
+                     control_flow_data->Drawing->height+SAFETY);
+                               /* Get new data for the rest. */
+                         drawing_data_request(control_flow_data->Drawing,
+                                               &control_flow_data->Drawing->Pixmap,
+                                               0, 0,
+                                               x,
+                                               control_flow_data->Drawing->height);
+               
+                               drawing_refresh(control_flow_data->Drawing,
+                                               0, 0,
+                                               control_flow_data->Drawing->width,
+                                               control_flow_data->Drawing->height);
+                               
+                       } else {
+                               g_info("scrolling far");
+                               /* Cannot reuse any part of the screen : far jump */
+                               *Old_Time_Window = *New_Time_Window;
+                               
+                               
+                               gdk_draw_rectangle (control_flow_data->Drawing->Pixmap,
+                                       control_flow_data->Drawing->Drawing_Area_V->style->white_gc,
+                     TRUE,
+                     0, 0,
+                     control_flow_data->Drawing->width+SAFETY, // do not overlap
+                     control_flow_data->Drawing->height+SAFETY);
+
+                               drawing_data_request(control_flow_data->Drawing,
+                                               &control_flow_data->Drawing->Pixmap,
+                                               0, 0,
+                                               control_flow_data->Drawing->width,
+                                               control_flow_data->Drawing->height);
+               
+                               drawing_refresh(control_flow_data->Drawing,
+                                               0, 0,
+                                               control_flow_data->Drawing->width,
+                                               control_flow_data->Drawing->height);
+                       }
+               }
+       } else {
+               /* Different scale (zoom) */
+               g_info("zoom");
+
+               *Old_Time_Window = *New_Time_Window;
+       
+               gdk_draw_rectangle (control_flow_data->Drawing->Pixmap,
+                                       control_flow_data->Drawing->Drawing_Area_V->style->white_gc,
+                     TRUE,
+                     0, 0,
+                     control_flow_data->Drawing->width+SAFETY, // do not overlap
+                     control_flow_data->Drawing->height+SAFETY);
+
+       
+         drawing_data_request(control_flow_data->Drawing,
+                               &control_flow_data->Drawing->Pixmap,
+                               0, 0,
+                               control_flow_data->Drawing->width,
+                               control_flow_data->Drawing->height);
+       
+               drawing_refresh(control_flow_data->Drawing,
+                               0, 0,
+                               control_flow_data->Drawing->width,
+                               control_flow_data->Drawing->height);
+       }
+
+       
 }
 
 void update_current_time_hook(void *hook_data, void *call_data)
This page took 0.027681 seconds and 4 git commands to generate.