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

   1
   2 #include <lttv/lttvfilter.h>
   3 #include <stdio.h>
   4 #include <ltt/trace.h>
   5 #include <ltt/type.h>
   6
   7 struct _LttvTracesetSelector {
   8   char      * traceset_name;
   9   GPtrArray * traces;
  10 };
  11
  12
  13 struct _LttvTraceSelector {
  14   char      * trace_name;
  15   GPtrArray * tracefiles;
  16   GPtrArray * eventtypes;
  17   gboolean    selected;
  18 };
  19
  20 struct _LttvTracefileSelector {
  21   char      * tracefile_name;
  22   GPtrArray * eventtypes;
  23   gboolean    selected;
  24 };
  25
  26 struct _LttvEventtypeSelector {
  27   char      * eventtype_name;
  28   gboolean    selected;
  29 };
  30
  31
  32 LttvTracesetSelector *lttv_traceset_selector_new(char * name)
  33 {
  34   LttvTracesetSelector *s;
  35
  36   s = g_new(LttvTracesetSelector, 1);
  37   if(name)
  38     s->traceset_name = g_strdup(name);
  39   else
  40     s->traceset_name = NULL;
  41   s->traces = g_ptr_array_new();
  42   return s;
  43 }
  44
  45 LttvTraceSelector *lttv_trace_selector_new(LttTrace *t)
  46 {
  47   LttvTraceSelector * trace;
  48
  49   trace = g_new(LttvTraceSelector, 1);
  50   trace->trace_name = g_strdup(ltt_trace_name(t));
  51   trace->tracefiles = g_ptr_array_new();
  52   trace->eventtypes = g_ptr_array_new();
  53   trace->selected = TRUE;
  54   return trace;
  55 }
  56
  57 LttvTracefileSelector *lttv_tracefile_selector_new(LttTracefile *t)
  58 {
  59   LttvTracefileSelector * tracefile;
  60
  61   tracefile = g_new(LttvTracefileSelector, 1);
  62   tracefile->tracefile_name = g_strdup(ltt_tracefile_name(t));
  63   tracefile->eventtypes = g_ptr_array_new();
  64   tracefile->selected = TRUE;
  65   return tracefile;
  66 }
  67
  68 LttvEventtypeSelector *lttv_eventtype_selector_new(LttEventType * et)
  69 {
  70   LttvEventtypeSelector * ev;
  71   ev = g_new(LttvEventtypeSelector, 1);
  72   ev->eventtype_name = g_strdup(ltt_eventtype_name(et));
  73   ev->selected = TRUE;
  74   return ev;
  75 }
  76
  77 void lttv_traceset_selector_destroy(LttvTracesetSelector *s)
  78 {
  79   int i;
  80   LttvTraceSelector * t;
  81
  82   for(i=0;i<s->traces->len;i++){
  83     t = (LttvTraceSelector*)s->traces->pdata[i];
  84     lttv_trace_selector_destroy(t);
  85   }
  86   g_ptr_array_free(s->traces, TRUE);
  87   if(s->traceset_name) g_free(s->traceset_name);
  88   g_free(s);
  89 }
  90
  91 void lttv_trace_selector_destroy(LttvTraceSelector *s)
  92 {
  93   int i;
  94   LttvTracefileSelector * t;
  95   LttvEventtypeSelector * e;
  96
  97   for(i=0;i<s->tracefiles->len;i++){
  98     t = (LttvTracefileSelector*)s->tracefiles->pdata[i];
  99     lttv_tracefile_selector_destroy(t);
 100   }
 101   for(i=0;i<s->eventtypes->len;i++){
 102     e = (LttvEventtypeSelector*)s->eventtypes->pdata[i];
 103     lttv_eventtype_selector_destroy(e);
 104   }
 105   if(s->trace_name) g_free(s->trace_name);
 106   g_free(s);
 107 }
 108
 109 void lttv_tracefile_selector_destroy(LttvTracefileSelector *t)
 110 {
 111   int i;
 112   LttvEventtypeSelector * e;
 113
 114   for(i=0;i<t->eventtypes->len;i++){
 115     e = (LttvEventtypeSelector*)t->eventtypes->pdata[i];
 116     lttv_eventtype_selector_destroy(e);
 117   }
 118
 119   if(t->tracefile_name) g_free(t->tracefile_name);
 120   g_free(t);
 121 }
 122
 123 void lttv_eventtype_selector_destroy(LttvEventtypeSelector *e)
 124 {
 125   if(e->eventtype_name) g_free(e->eventtype_name);
 126   free(e);
 127 }
 128
 129 void lttv_traceset_selector_trace_add(LttvTracesetSelector *s,
 130                                       LttvTraceSelector *t)
 131 {
 132   g_ptr_array_add(s->traces, t);
 133 }
 134
 135 void lttv_trace_selector_tracefile_add(LttvTraceSelector *s,
 136                                        LttvTracefileSelector *t)
 137 {
 138   g_ptr_array_add(s->tracefiles, t);
 139 }
 140
 141 void lttv_trace_selector_eventtype_add(LttvTraceSelector *s,
 142                                        LttvEventtypeSelector *et)
 143 {
 144   g_ptr_array_add(s->eventtypes, et);
 145 }
 146
 147 void lttv_tracefile_selector_eventtype_add(LttvTracefileSelector *s,
 148                                            LttvEventtypeSelector *et)
 149 {
 150   g_ptr_array_add(s->eventtypes, et);
 151 }
 152
 153 unsigned lttv_traceset_selector_trace_number(LttvTracesetSelector *s)
 154 {
 155   return s->traces->len;
 156 }
 157
 158 unsigned lttv_trace_selector_tracefile_number(LttvTraceSelector *s)
 159 {
 160   return s->tracefiles->len;
 161 }
 162
 163 unsigned lttv_trace_selector_eventtype_number(LttvTraceSelector *s)
 164 {
 165   return s->eventtypes->len;
 166 }
 167
 168 unsigned lttv_tracefile_selector_eventtype_number(LttvTracefileSelector *s)
 169 {
 170   return s->eventtypes->len;
 171 }
 172
 173 LttvTraceSelector *lttv_traceset_selector_trace_get(LttvTracesetSelector *s,
 174                                                     unsigned i)
 175 {
 176   g_assert(s->traces->len > i);
 177   return ((LttvTraceSelector *)s->traces->pdata[i]);
 178 }
 179
 180 LttvTracefileSelector *lttv_trace_selector_tracefile_get(LttvTraceSelector *s,
 181                                                          unsigned i)
 182 {
 183   g_assert(s->tracefiles->len > i);
 184   return ((LttvTracefileSelector *)s->tracefiles->pdata[i]);
 185 }
 186
 187 LttvEventtypeSelector *lttv_trace_selector_eventtype_get(LttvTraceSelector *s,
 188                                                          unsigned i)
 189 {
 190   g_assert(s->eventtypes->len > i);
 191   return ((LttvEventtypeSelector *)s->eventtypes->pdata[i]);
 192 }
 193
 194 LttvEventtypeSelector *lttv_tracefile_selector_eventtype_get(LttvTracefileSelector *s,
 195                                                              unsigned i)
 196 {
 197   g_assert(s->eventtypes->len > i);
 198   return ((LttvEventtypeSelector *)s->eventtypes->pdata[i]);
 199 }
 200
 201 void lttv_traceset_selector_trace_remove(LttvTracesetSelector *s, unsigned i)
 202 {
 203   g_assert(s->traces->len > i);
 204   g_ptr_array_remove_index(s->traces, i);
 205 }
 206
 207 void lttv_trace_selector_tracefile_remove(LttvTraceSelector *s, unsigned i)
 208 {
 209   g_assert(s->tracefiles->len > i);
 210   g_ptr_array_remove_index(s->tracefiles, i);
 211 }
 212
 213 void lttv_trace_selector_eventtype_remove(LttvTraceSelector *s, unsigned i)
 214 {
 215   g_assert(s->eventtypes->len > i);
 216   g_ptr_array_remove_index(s->eventtypes, i);
 217 }
 218
 219 void lttv_tracefile_selector_eventtype_remove(LttvTracefileSelector *s, unsigned i)
 220 {
 221   g_assert(s->eventtypes->len > i);
 222   g_ptr_array_remove_index(s->eventtypes, i);
 223 }
 224
 225 void lttv_trace_selector_set_selected(LttvTraceSelector *s, gboolean g)
 226 {
 227   s->selected = g;
 228 }
 229
 230 void lttv_tracefile_selector_set_selected(LttvTracefileSelector *s, gboolean g)
 231 {
 232   s->selected = g;
 233 }
 234
 235 void lttv_eventtype_selector_set_selected(LttvEventtypeSelector *s, gboolean g)
 236 {
 237   s->selected = g;
 238 }
 239
 240 gboolean lttv_trace_selector_get_selected(LttvTraceSelector *s)
 241 {
 242   return s->selected;
 243 }
 244
 245 gboolean lttv_tracefile_selector_get_selected(LttvTracefileSelector *s)
 246 {
 247   return s->selected;
 248 }
 249
 250 gboolean lttv_eventtype_selector_get_selected(LttvEventtypeSelector *s)
 251 {
 252   return s->selected;
 253 }
 254
 255 char * lttv_traceset_selector_get_name(LttvTracesetSelector *s)
 256 {
 257   return s->traceset_name;
 258 }
 259
 260 char * lttv_trace_selector_get_name(LttvTraceSelector *s)
 261 {
 262   return s->trace_name;
 263 }
 264
 265 char * lttv_tracefile_selector_get_name(LttvTracefileSelector *s)
 266 {
 267   return s->tracefile_name;
 268 }
 269
 270 char * lttv_eventtype_selector_get_name(LttvEventtypeSelector *s)
 271 {
 272   return s->eventtype_name;
 273 }
 274
 275 LttvEventtypeSelector * lttv_eventtype_selector_clone(LttvEventtypeSelector * s)
 276 {
 277   LttvEventtypeSelector * ev = g_new(LttvEventtypeSelector, 1);
 278   ev->eventtype_name = g_strdup(s->eventtype_name);
 279   ev->selected = s->selected;
 280   return ev;
 281 }
 282
 283 void lttv_eventtype_selector_copy(LttvTraceSelector * s, LttvTracefileSelector * d)
 284 {
 285   int i, len;
 286   LttvEventtypeSelector * ev, *ev1;
 287
 288   len = s->eventtypes->len;
 289   for(i=0;i<len;i++){
 290     ev = lttv_trace_selector_eventtype_get(s,i);
 291     ev1 = lttv_eventtype_selector_clone(ev);
 292     lttv_tracefile_selector_eventtype_add(d,ev1);
 293   }
 294 }