ui/gtk/proto_hier_tree_model.c

   1 /* proto_hier_tree_model.c
   2  *
   3  * $Id$
   4  *
   5  * Wireshark - Network traffic analyzer
   6  * By Gerald Combs <gerald@wireshark.org>
   7  * Copyright 1998 Gerald Combs
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License
  11  * as published by the Free Software Foundation; either version 2
  12  * of the License, or (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
  22  * USA.
  23  */
  24
  25 /* This code was originally based on the GTK+ Tree View tutorial at
  26  * http://scentric.net/tutorial */
  27
  28 #include "config.h"
  29
  30 #include <string.h>
  31
  32 #include <gtk/gtk.h>
  33 #include <glib.h>
  34
  35 #include "proto_hier_tree_model.h"
  36
  37 #include <epan/proto.h>
  38
  39 static GObjectClass *parent_class = NULL;
  40
  41 static GtkTreeModelFlags
  42 proto_hier_tree_get_flags(GtkTreeModel *tree_model)
  43 {
  44         g_return_val_if_fail(PROTOHIER_IS_TREE(tree_model), (GtkTreeModelFlags)0);
  45
  46         return GTK_TREE_MODEL_ITERS_PERSIST;
  47 }
  48
  49 static gint
  50 proto_hier_tree_get_n_columns(GtkTreeModel *tree_model)
  51 {
  52         g_return_val_if_fail(PROTOHIER_IS_TREE(tree_model), 0);
  53
  54         return 2;
  55 }
  56
  57 static GType
  58 proto_hier_tree_get_column_type(GtkTreeModel *tree_model, gint idx)
  59 {
  60         g_return_val_if_fail(PROTOHIER_IS_TREE(tree_model), G_TYPE_INVALID);
  61         g_return_val_if_fail(idx == 0 || idx == 1, G_TYPE_INVALID);
  62
  63         switch (idx) {
  64                 case 0:
  65                         return G_TYPE_POINTER;
  66                 case 1:
  67                         return G_TYPE_STRING;
  68         }
  69         /* never here */
  70         return G_TYPE_INVALID;
  71 }
  72
  73 static gboolean
  74 proto_hier_tree_iter_nth_child(GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *parent, gint n)
  75 {
  76         ProtoHierTreeModel *model;
  77
  78         gint proto_id;
  79         void *cookie;
  80
  81         g_return_val_if_fail(PROTOHIER_IS_TREE(tree_model), FALSE);
  82         model = (ProtoHierTreeModel *) tree_model;
  83
  84         if (parent) {
  85                 header_field_info *hfinfo;
  86
  87                 g_return_val_if_fail(parent->stamp == model->stamp, FALSE);
  88
  89                 /* no child of field */
  90                 if (parent->user_data2 != NULL)
  91                         return FALSE;
  92
  93                 proto_id = proto_get_data_protocol(parent->user_data);
  94
  95                 /* get n-th field of protocol */
  96                 hfinfo = proto_get_first_protocol_field(proto_id, &cookie);
  97                 while (hfinfo) {
  98                         if (hfinfo->same_name_prev_id == -1) {
  99                                 if (!n)
 100                                         break;
 101                                 n--;
 102                         }
 103                         hfinfo = proto_get_next_protocol_field(&cookie);
 104                 }
 105
 106                 /* not found? */
 107                 if (!hfinfo)
 108                         return FALSE;
 109
 110                 iter->stamp = model->stamp;
 111                 iter->user_data = parent->user_data;
 112                 iter->user_data2 = cookie;
 113                 iter->user_data3 = hfinfo;
 114                 return TRUE;
 115         }
 116
 117         /* get n-th enabled protocol */
 118         proto_id = proto_get_first_protocol(&cookie);
 119         while (proto_id != -1) {
 120                 protocol_t *p = find_protocol_by_id(proto_id);
 121
 122                 if (proto_is_protocol_enabled(p)) {
 123                         if (!n)
 124                                 break;
 125                         n--;
 126                 }
 127                 proto_id = proto_get_next_protocol(&cookie);
 128         }
 129
 130         /* not found? */
 131         if (proto_id == -1)
 132                 return FALSE;
 133
 134         iter->stamp = model->stamp;
 135         iter->user_data = cookie;
 136         iter->user_data2 = NULL;
 137         iter->user_data3 = proto_registrar_get_nth(proto_id);
 138         return TRUE;
 139 }
 140
 141 static gboolean
 142 proto_hier_tree_get_iter(GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreePath *path)
 143 {
 144         gint *indices, depth;
 145
 146         g_assert(PROTOHIER_IS_TREE(tree_model));
 147         g_assert(path != NULL);
 148
 149         indices = gtk_tree_path_get_indices(path);
 150         depth = gtk_tree_path_get_depth(path);
 151
 152         g_assert(depth == 1 || depth == 2);
 153
 154         if (!proto_hier_tree_iter_nth_child(tree_model, iter, NULL, indices[0]))
 155                 return FALSE;
 156
 157         if (depth == 2) {
 158                 if (!proto_hier_tree_iter_nth_child(tree_model, iter, iter, indices[1]))
 159                         return FALSE;
 160         }
 161         return TRUE;
 162 }
 163
 164 static char *
 165 hfinfo_to_name(const header_field_info *hfinfo)
 166 {
 167         if (hfinfo->parent == -1) {
 168                 protocol_t *protocol = find_protocol_by_id(hfinfo->id);
 169
 170                 return g_strdup_printf("%s - %s", proto_get_protocol_short_name(protocol), proto_get_protocol_long_name(protocol));
 171         }
 172         if (hfinfo->blurb != NULL && hfinfo->blurb[0] != '\0')
 173                 return g_strdup_printf("%s - %s (%s)", hfinfo->abbrev, hfinfo->name, hfinfo->blurb);
 174         else
 175                 return g_strdup_printf("%s - %s", hfinfo->abbrev, hfinfo->name);
 176 }
 177
 178 static void
 179 proto_hier_tree_get_value(GtkTreeModel *tree_model, GtkTreeIter *iter, gint column, GValue *value)
 180 {
 181         ProtoHierTreeModel *model;
 182         header_field_info *hfinfo;
 183
 184         g_return_if_fail(PROTOHIER_IS_TREE(tree_model));
 185         model = (ProtoHierTreeModel *) tree_model;
 186
 187         g_return_if_fail(iter != NULL);
 188         g_return_if_fail(iter->stamp == model->stamp);
 189         g_return_if_fail(column == 0 || column == 1);
 190
 191         hfinfo = (header_field_info *)iter->user_data3;
 192
 193         switch (column) {
 194                 case 0: /* hfinfo */
 195                         g_value_init(value, G_TYPE_POINTER);
 196                         g_value_set_pointer(value, hfinfo);
 197                         break;
 198
 199                 case 1: /* field name */
 200                         g_value_init(value, G_TYPE_STRING);
 201                         g_value_take_string(value, hfinfo_to_name(hfinfo));
 202                         break;
 203         }
 204 }
 205
 206 static gboolean
 207 proto_hier_tree_iter_next(GtkTreeModel *tree_model, GtkTreeIter *iter)
 208 {
 209         ProtoHierTreeModel *model;
 210
 211         g_return_val_if_fail(PROTOHIER_IS_TREE(tree_model), FALSE);
 212         model = (ProtoHierTreeModel *) tree_model;
 213
 214         g_return_val_if_fail(iter->stamp == model->stamp, FALSE);
 215
 216         /* protocol */
 217         if (iter->user_data2 == NULL) {
 218                 void *cookie = iter->user_data;
 219                 int proto_id;
 220
 221                 proto_id = proto_get_next_protocol(&cookie);
 222                 /* get next enabled protocol */
 223                 while (proto_id != -1) {
 224                         protocol_t *p = find_protocol_by_id(proto_id);
 225
 226                         if (proto_is_protocol_enabled(p))
 227                                 break;
 228                         proto_id = proto_get_next_protocol(&cookie);
 229                 }
 230
 231                 if (proto_id == -1)
 232                         return FALSE;
 233
 234                 iter->user_data = cookie;
 235                 iter->user_data3 = proto_registrar_get_nth(proto_id);
 236                 return TRUE;
 237         }
 238
 239         /* field */
 240         {
 241                 void *cookie2 = iter->user_data2;
 242                 header_field_info *hfinfo;
 243
 244                 hfinfo = proto_get_next_protocol_field(&cookie2);
 245                 /* get next field */
 246                 while (hfinfo) {
 247                         if (hfinfo->same_name_prev_id == -1)
 248                                 break;
 249                         hfinfo = proto_get_next_protocol_field(&cookie2);
 250                 }
 251
 252                 /* not found? */
 253                 if (!hfinfo)
 254                         return FALSE;
 255
 256                 iter->user_data2 = cookie2;
 257                 iter->user_data3 = hfinfo;
 258                 return TRUE;
 259         }
 260 }
 261
 262 static gboolean
 263 proto_hier_tree_iter_children(GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *parent)
 264 {
 265         return proto_hier_tree_iter_nth_child(tree_model, iter, parent, 0);
 266 }
 267
 268 static gint
 269 proto_hier_tree_iter_n_children(GtkTreeModel *tree_model, GtkTreeIter *iter)
 270 {
 271         ProtoHierTreeModel *model;
 272         gint count = 0;
 273
 274         int p_id;
 275         void *cookie;
 276
 277         g_return_val_if_fail(PROTOHIER_IS_TREE(tree_model), 0);
 278         model = (ProtoHierTreeModel *) tree_model;
 279
 280         g_return_val_if_fail(iter == NULL || iter->user_data != NULL, 0);
 281
 282         if (iter) {
 283                 header_field_info *hfinfo;
 284
 285                 g_return_val_if_fail(iter->stamp == model->stamp, 0);
 286
 287                 /* field has no child */
 288                 if (iter->user_data2 != NULL)
 289                         return 0;
 290
 291                 p_id = proto_get_data_protocol(iter->user_data);
 292
 293                 /* count not-duplicated fields */
 294                 for (hfinfo = proto_get_first_protocol_field(p_id, &cookie); hfinfo; hfinfo = proto_get_next_protocol_field(&cookie)) {
 295                         if (hfinfo->same_name_prev_id != -1)
 296                                 continue;
 297                         count++;
 298                 }
 299
 300         } else {
 301                 /* count enabled protocols */
 302                 for (p_id = proto_get_first_protocol(&cookie); p_id != -1; p_id = proto_get_next_protocol(&cookie)) {
 303                         protocol_t *p = find_protocol_by_id(p_id);
 304
 305                         if (!proto_is_protocol_enabled(p))
 306                                 continue;
 307                         count++;
 308                 }
 309         }
 310
 311         return count;
 312 }
 313
 314 static GtkTreePath *
 315 proto_hier_tree_get_path(GtkTreeModel *tree_model, GtkTreeIter *iter)
 316 {
 317         ProtoHierTreeModel *model;
 318         GtkTreePath *path;
 319         int pos;
 320
 321         int p_id;
 322         void *cookie;
 323
 324         g_return_val_if_fail(PROTOHIER_IS_TREE(tree_model), NULL);
 325         model = (ProtoHierTreeModel *) tree_model;
 326
 327         g_return_val_if_fail(iter != NULL, NULL);
 328         g_return_val_if_fail(iter->stamp == model->stamp, FALSE);
 329
 330         p_id = proto_get_data_protocol(iter->user_data);
 331
 332         path = gtk_tree_path_new();
 333
 334         /* protocol */
 335         {
 336                 int id;
 337
 338                 /* XXX, assuming that protocols can't be disabled! */
 339                 pos = 0;
 340                 for (id = proto_get_first_protocol(&cookie); id != p_id && id != -1; id = proto_get_next_protocol(&cookie)) {
 341                         protocol_t *p = find_protocol_by_id(id);
 342
 343                         if (!proto_is_protocol_enabled(p))
 344                                 continue;
 345                         pos++;
 346                 }
 347                 gtk_tree_path_append_index(path, pos);
 348         }
 349
 350         /* field */
 351         if (iter->user_data2 != NULL) {
 352                 header_field_info *hfinfo;
 353
 354                 pos = 0;
 355                 for (hfinfo = proto_get_first_protocol_field(p_id, &cookie); hfinfo && hfinfo != iter->user_data3; hfinfo = proto_get_next_protocol_field(&cookie)) {
 356                         if (hfinfo->same_name_prev_id != -1)
 357                                 continue;
 358                         pos++;
 359                 }
 360                 gtk_tree_path_append_index(path, pos);
 361         }
 362
 363         return path;
 364 }
 365
 366 static gboolean
 367 proto_hier_tree_iter_has_child(GtkTreeModel *tree_model, GtkTreeIter *iter)
 368 {
 369         /* no need to optimize? */
 370         return proto_hier_tree_iter_n_children(tree_model, iter) != 0;
 371 }
 372
 373 static gboolean
 374 proto_hier_tree_iter_parent(GtkTreeModel *tree_model, GtkTreeIter *iter, GtkTreeIter *child)
 375 {
 376         ProtoHierTreeModel *model;
 377
 378         g_return_val_if_fail(PROTOHIER_IS_TREE(tree_model), FALSE);
 379         model = (ProtoHierTreeModel *) tree_model;
 380
 381         g_return_val_if_fail(iter != NULL, FALSE);
 382         g_return_val_if_fail(child->stamp == model->stamp, FALSE);
 383
 384         /* from field to protocol */
 385         if (child->user_data2 != NULL) {
 386                 int p_id = proto_get_data_protocol(child->user_data);
 387
 388                 iter->stamp = model->stamp;
 389                 iter->user_data = child->user_data;
 390                 iter->user_data2 = NULL;
 391                 iter->user_data3 = proto_registrar_get_nth(p_id);
 392
 393                 return TRUE;
 394         }
 395         /* protocol has no parent */
 396         return FALSE;
 397 }
 398
 399 static void
 400 proto_hier_tree_model_tree_init(GtkTreeModelIface *iface)
 401 {
 402         iface->get_flags = proto_hier_tree_get_flags;
 403         iface->get_n_columns = proto_hier_tree_get_n_columns;
 404         iface->get_column_type = proto_hier_tree_get_column_type;
 405         iface->get_iter = proto_hier_tree_get_iter;
 406         iface->get_path = proto_hier_tree_get_path;
 407         iface->get_value = proto_hier_tree_get_value;
 408         iface->iter_next = proto_hier_tree_iter_next;
 409         iface->iter_children = proto_hier_tree_iter_children;
 410         iface->iter_has_child = proto_hier_tree_iter_has_child;
 411         iface->iter_n_children = proto_hier_tree_iter_n_children;
 412         iface->iter_nth_child = proto_hier_tree_iter_nth_child;
 413         iface->iter_parent = proto_hier_tree_iter_parent;
 414 }
 415
 416 static void
 417 proto_hier_tree_model_init(ProtoHierTreeModel *model)
 418 {
 419         /* To check whether an iter belongs to our model. */
 420         model->stamp = g_random_int();
 421 }
 422
 423 static void
 424 _class_finalize(GObject *object)
 425 {
 426         /* must chain up - finalize parent */
 427         (*parent_class->finalize)(object);
 428 }
 429
 430 static void
 431 proto_hier_tree_class_init(ProtoHierTreeModelClass *klass)
 432 {
 433         GObjectClass *object_class;
 434
 435         parent_class = (GObjectClass*) g_type_class_peek_parent(klass);
 436         object_class = (GObjectClass*) klass;
 437
 438         object_class->finalize = _class_finalize;
 439 }
 440
 441 GType
 442 proto_hier_tree_get_type(void)
 443 {
 444         static GType proto_hier_tree_type = 0;
 445
 446         if (proto_hier_tree_type == 0) {
 447                 static const GTypeInfo proto_hier_tree_info = {
 448                         sizeof(ProtoHierTreeModelClass),
 449                         NULL, /* base_init */
 450                         NULL, /* base_finalize */
 451                         (GClassInitFunc) proto_hier_tree_class_init,
 452                         NULL, /* class finalize */
 453                         NULL, /* class_data */
 454                         sizeof(ProtoHierTreeModel),
 455                         0, /* n_preallocs */
 456                         (GInstanceInitFunc) proto_hier_tree_model_init,
 457                         NULL /* value_table */
 458                 };
 459
 460                 static const GInterfaceInfo tree_model_info = {
 461                         (GInterfaceInitFunc) proto_hier_tree_model_tree_init,
 462                         NULL,
 463                         NULL
 464                 };
 465
 466                 /* Register the new derived type with the GObject type system */
 467                 proto_hier_tree_type = g_type_register_static(G_TYPE_OBJECT,
 468                                                           "ProtoHierTreeModel",
 469                                                           &proto_hier_tree_info,
 470                                                           (GTypeFlags)0);
 471
 472                 g_type_add_interface_static(proto_hier_tree_type,
 473                                                 GTK_TYPE_TREE_MODEL,
 474                                                 &tree_model_info);
 475         }
 476         return proto_hier_tree_type;
 477 }
 478
 479 ProtoHierTreeModel *
 480 proto_hier_tree_model_new(void)
 481 {
 482         ProtoHierTreeModel *model;
 483
 484         model = (ProtoHierTreeModel *) g_object_new(PROTOHIER_TYPE_TREE, NULL);
 485
 486         g_assert(model != NULL);
 487
 488         return model;
 489 }
 490