filter for selecting eventtype

[lttv.git] / ltt / branches / poly / lttv / modules / gui / mainWin / src / lttvfilter.c

diff --git a/ltt/branches/poly/lttv/modules/gui/mainWin/src/lttvfilter.c b/ltt/branches/poly/lttv/modules/gui/mainWin/src/lttvfilter.c
index ed5f98243c927d0616fe77efe7dbc0ff9684c013..2c7398d96ac23090c70003b20773beb66ccbd151 100644 (file)
--- a/ltt/branches/poly/lttv/modules/gui/mainWin/src/lttvfilter.c
+++ b/ltt/branches/poly/lttv/modules/gui/mainWin/src/lttvfilter.c
@@ -2,21 +2,29 @@
 #include <lttv/lttvfilter.h>
 #include <stdio.h>
 #include <ltt/trace.h>
+#include <ltt/type.h>
 
 struct _LttvTracesetSelector {
   char      * traceset_name;
-  GPtrArray *traces;
+  GPtrArray * traces;
 };
 
 
 struct _LttvTraceSelector {
   char      * trace_name;
   GPtrArray * tracefiles;
+  GPtrArray * eventtypes;
   gboolean    selected;
 };
 
 struct _LttvTracefileSelector {
   char      * tracefile_name;
+  GPtrArray * eventtypes;
+  gboolean    selected;
+};
+
+struct _LttvEventtypeSelector {
+  char      * eventtype_name;
   gboolean    selected;
 };
 
@@ -41,6 +49,7 @@ LttvTraceSelector *lttv_trace_selector_new(LttTrace *t)
   trace = g_new(LttvTraceSelector, 1);
   trace->trace_name = g_strdup(ltt_trace_name(t));
   trace->tracefiles = g_ptr_array_new();
+  trace->eventtypes = g_ptr_array_new();
   trace->selected = TRUE;
   return trace;
 }
@@ -51,10 +60,19 @@ LttvTracefileSelector *lttv_tracefile_selector_new(LttTracefile *t)
 
   tracefile = g_new(LttvTracefileSelector, 1);
   tracefile->tracefile_name = g_strdup(ltt_tracefile_name(t));
+  tracefile->eventtypes = g_ptr_array_new();
   tracefile->selected = TRUE;
   return tracefile;
 }
 
+LttvEventtypeSelector *lttv_eventtype_selector_new(LttEventType * et)
+{
+  LttvEventtypeSelector * ev;
+  ev = g_new(LttvEventtypeSelector, 1);
+  ev->eventtype_name = g_strdup(ltt_eventtype_name(et));
+  ev->selected = TRUE;
+  return ev;
+}
 
 void lttv_traceset_selector_destroy(LttvTracesetSelector *s) 
 {
@@ -74,66 +92,135 @@ void lttv_trace_selector_destroy(LttvTraceSelector *s)
 {
   int i;
   LttvTracefileSelector * t;
+  LttvEventtypeSelector * e;
 
   for(i=0;i<s->tracefiles->len;i++){
     t = (LttvTracefileSelector*)s->tracefiles->pdata[i];
     lttv_tracefile_selector_destroy(t);
   }
+  for(i=0;i<s->eventtypes->len;i++){
+    e = (LttvEventtypeSelector*)s->eventtypes->pdata[i];
+    lttv_eventtype_selector_destroy(e);
+  }
   if(s->trace_name) g_free(s->trace_name);
   g_free(s);
 }
 
 void lttv_tracefile_selector_destroy(LttvTracefileSelector *t) 
 {
+  int i;
+  LttvEventtypeSelector * e;
+
+  for(i=0;i<t->eventtypes->len;i++){
+    e = (LttvEventtypeSelector*)t->eventtypes->pdata[i];
+    lttv_eventtype_selector_destroy(e);
+  }
+
   if(t->tracefile_name) g_free(t->tracefile_name);
   g_free(t);
 }
 
-void lttv_traceset_selector_add(LttvTracesetSelector *s, LttvTraceSelector *t) 
+void lttv_eventtype_selector_destroy(LttvEventtypeSelector *e)
+{
+  if(e->eventtype_name) g_free(e->eventtype_name);
+  free(e);
+}
+
+void lttv_traceset_selector_trace_add(LttvTracesetSelector *s, 
+                                     LttvTraceSelector *t) 
 {
   g_ptr_array_add(s->traces, t);
 }
 
-void lttv_trace_selector_add(LttvTraceSelector *s, LttvTracefileSelector *t) 
+void lttv_trace_selector_tracefile_add(LttvTraceSelector *s, 
+                                      LttvTracefileSelector *t) 
 {
   g_ptr_array_add(s->tracefiles, t);
 }
 
+void lttv_trace_selector_eventtype_add(LttvTraceSelector *s, 
+                                      LttvEventtypeSelector *et)
+{  
+  g_ptr_array_add(s->eventtypes, et);
+}
+
+void lttv_tracefile_selector_eventtype_add(LttvTracefileSelector *s, 
+                                          LttvEventtypeSelector *et)
+{
+  g_ptr_array_add(s->eventtypes, et);
+}
 
-unsigned lttv_traceset_selector_number(LttvTracesetSelector *s) 
+unsigned lttv_traceset_selector_trace_number(LttvTracesetSelector *s) 
 {
   return s->traces->len;
 }
 
-unsigned lttv_trace_selector_number(LttvTraceSelector *s) 
+unsigned lttv_trace_selector_tracefile_number(LttvTraceSelector *s) 
 {
   return s->tracefiles->len;
 }
 
-LttvTraceSelector *lttv_traceset_selector_get(LttvTracesetSelector *s, unsigned i) 
+unsigned lttv_trace_selector_eventtype_number(LttvTraceSelector *s)
+{
+  return s->eventtypes->len;
+}
+
+unsigned lttv_tracefile_selector_eventtype_number(LttvTracefileSelector *s)
+{
+  return s->eventtypes->len;
+}
+
+LttvTraceSelector *lttv_traceset_selector_trace_get(LttvTracesetSelector *s,
+                                                   unsigned i) 
 {
   g_assert(s->traces->len > i);
   return ((LttvTraceSelector *)s->traces->pdata[i]);
 }
 
-LttvTracefileSelector *lttv_trace_selector_get(LttvTraceSelector *s, unsigned i) 
+LttvTracefileSelector *lttv_trace_selector_tracefile_get(LttvTraceSelector *s,
+                                                        unsigned i) 
 {
   g_assert(s->tracefiles->len > i);
   return ((LttvTracefileSelector *)s->tracefiles->pdata[i]);
 }
 
-void lttv_traceset_selector_remove(LttvTracesetSelector *s, unsigned i) 
+LttvEventtypeSelector *lttv_trace_selector_eventtype_get(LttvTraceSelector *s,
+                                                        unsigned i)
+{
+  g_assert(s->eventtypes->len > i);
+  return ((LttvEventtypeSelector *)s->eventtypes->pdata[i]);
+}
+
+LttvEventtypeSelector *lttv_tracefile_selector_eventtype_get(LttvTracefileSelector *s,
+                                                            unsigned i)
+{
+  g_assert(s->eventtypes->len > i);
+  return ((LttvEventtypeSelector *)s->eventtypes->pdata[i]);
+}
+
+void lttv_traceset_selector_trace_remove(LttvTracesetSelector *s, unsigned i) 
 {
   g_assert(s->traces->len > i);
   g_ptr_array_remove_index(s->traces, i);
 }
 
-void lttv_trace_selector_remove(LttvTraceSelector *s, unsigned i) 
+void lttv_trace_selector_tracefile_remove(LttvTraceSelector *s, unsigned i) 
 {
   g_assert(s->tracefiles->len > i);
   g_ptr_array_remove_index(s->tracefiles, i);
 }
 
+void lttv_trace_selector_eventtype_remove(LttvTraceSelector *s, unsigned i)
+{
+  g_assert(s->eventtypes->len > i);
+  g_ptr_array_remove_index(s->eventtypes, i);
+}
+
+void lttv_tracefile_selector_eventtype_remove(LttvTracefileSelector *s, unsigned i)
+{
+  g_assert(s->eventtypes->len > i);
+  g_ptr_array_remove_index(s->eventtypes, i);
+}
 
 void lttv_trace_selector_set_selected(LttvTraceSelector *s, gboolean g)
 {
@@ -145,6 +232,11 @@ void lttv_tracefile_selector_set_selected(LttvTracefileSelector *s, gboolean g)
   s->selected = g;
 }
 
+void lttv_eventtype_selector_set_selected(LttvEventtypeSelector *s, gboolean g)
+{
+  s->selected = g;
+}
+
 gboolean lttv_trace_selector_get_selected(LttvTraceSelector *s)
 {
   return s->selected;
@@ -155,6 +247,16 @@ gboolean lttv_tracefile_selector_get_selected(LttvTracefileSelector *s)
   return s->selected;
 }
 
+gboolean lttv_eventtype_selector_get_selected(LttvEventtypeSelector *s)
+{
+  return s->selected;
+}
+
+char * lttv_traceset_selector_get_name(LttvTracesetSelector *s)
+{
+  return s->traceset_name;
+}
+
 char * lttv_trace_selector_get_name(LttvTraceSelector *s)
 {
   return s->trace_name;
@@ -164,3 +266,29 @@ char * lttv_tracefile_selector_get_name(LttvTracefileSelector *s)
 {
   return s->tracefile_name;
 }
+
+char * lttv_eventtype_selector_get_name(LttvEventtypeSelector *s)
+{
+  return s->eventtype_name;
+}
+
+LttvEventtypeSelector * lttv_eventtype_selector_clone(LttvEventtypeSelector * s)
+{
+  LttvEventtypeSelector * ev = g_new(LttvEventtypeSelector, 1);
+  ev->eventtype_name = g_strdup(s->eventtype_name);
+  ev->selected = s->selected;
+  return ev;
+}
+
+void lttv_eventtype_selector_copy(LttvTraceSelector * s, LttvTracefileSelector * d)
+{
+  int i, len;
+  LttvEventtypeSelector * ev, *ev1;
+
+  len = s->eventtypes->len;
+  for(i=0;i<len;i++){
+    ev = lttv_trace_selector_eventtype_get(s,i);
+    ev1 = lttv_eventtype_selector_clone(ev);
+    lttv_tracefile_selector_eventtype_add(d,ev1);
+  }
+}