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

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