Pileus Git - ~andy/gtk/blob - gtk/gtkmodelsimple.c

   1 /* gtkmodelsimple.c
   2  * Copyright (C) 2000  Red Hat, Inc.,  Jonathan Blandford <jrb@redhat.com>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include "gtkmodelsimple.h"
  21 #include "gtksignal.h"
  22 enum {
  23   CHANGED,
  24   INSERTED,
  25   CHILD_TOGGLED,
  26   DELETED,
  27
  28   GET_N_COLUMNS,
  29   GET_COLUMN_TYPE,
  30   GET_ITER,
  31   GET_PATH,
  32   GET_VALUE,
  33   ITER_NEXT,
  34   ITER_CHILDREN,
  35   ITER_HAS_CHILD,
  36   ITER_N_CHILDREN,
  37   ITER_NTH_CHILD,
  38   ITER_PARENT,
  39   LAST_SIGNAL
  40 };
  41
  42 static void         gtk_model_simple_init                 (GtkModelSimple      *model_simple);
  43 static void         gtk_model_simple_class_init           (GtkModelSimpleClass *class);
  44 static void         gtk_model_simple_tree_model_init      (GtkTreeModelIface   *iface);
  45 static gint         gtk_real_model_simple_get_n_columns   (GtkTreeModel        *tree_model);
  46 static GType        gtk_real_model_simple_get_column_type (GtkTreeModel        *tree_model,
  47                                                            gint                 index);
  48 static gboolean     gtk_real_model_simple_get_iter        (GtkTreeModel        *tree_model,
  49                                                            GtkTreeIter         *iter,
  50                                                            GtkTreePath         *path);
  51 static GtkTreePath *gtk_real_model_simple_get_path        (GtkTreeModel        *tree_model,
  52                                                            GtkTreeIter         *iter);
  53 static void         gtk_real_model_simple_get_value       (GtkTreeModel        *tree_model,
  54                                                            GtkTreeIter         *iter,
  55                                                            gint                 column,
  56                                                            GValue              *value);
  57 static gboolean     gtk_real_model_simple_iter_next       (GtkTreeModel        *tree_model,
  58                                                            GtkTreeIter         *iter);
  59 static gboolean     gtk_real_model_simple_iter_children   (GtkTreeModel        *tree_model,
  60                                                            GtkTreeIter         *iter,
  61                                                            GtkTreeIter         *parent);
  62 static gboolean     gtk_real_model_simple_iter_has_child  (GtkTreeModel        *tree_model,
  63                                                            GtkTreeIter         *iter);
  64 static gint         gtk_real_model_simple_iter_n_children (GtkTreeModel        *tree_model,
  65                                                            GtkTreeIter         *iter);
  66 static gboolean     gtk_real_model_simple_iter_nth_child  (GtkTreeModel        *tree_model,
  67                                                            GtkTreeIter         *iter,
  68                                                            GtkTreeIter         *parent,
  69                                                            gint                 n);
  70 static gboolean     gtk_real_model_simple_iter_parent     (GtkTreeModel        *tree_model,
  71                                                            GtkTreeIter         *iter,
  72                                                            GtkTreeIter         *child);
  73
  74
  75
  76
  77 static guint model_simple_signals[LAST_SIGNAL] = { 0 };
  78
  79
  80 GtkType
  81 gtk_model_simple_get_type (void)
  82 {
  83   static GtkType model_simple_type = 0;
  84
  85   if (!model_simple_type)
  86     {
  87       static const GTypeInfo model_simple_info =
  88       {
  89         sizeof (GtkModelSimpleClass),
  90         NULL,           /* base_init */
  91         NULL,           /* base_finalize */
  92         (GClassInitFunc) gtk_model_simple_class_init,
  93         NULL,           /* class_finalize */
  94         NULL,           /* class_data */
  95         sizeof (GtkModelSimple),
  96         0,
  97         (GInstanceInitFunc) gtk_model_simple_init
  98       };
  99
 100       static const GInterfaceInfo tree_model_info =
 101       {
 102         (GInterfaceInitFunc) gtk_model_simple_tree_model_init,
 103         NULL,
 104         NULL
 105       };
 106
 107       model_simple_type = g_type_register_static (GTK_TYPE_TREE_MODEL, "GtkModelSimple", &model_simple_info, 0);
 108       g_type_add_interface_static (model_simple_type,
 109                                    GTK_TYPE_TREE_MODEL,
 110                                    &tree_model_info);
 111     }
 112
 113   return model_simple_type;
 114 }
 115
 116 GtkModelSimple *
 117 gtk_model_simple_new (void)
 118 {
 119   GtkModelSimple *retval;
 120
 121   retval = GTK_MODEL_SIMPLE (gtk_type_new (GTK_TYPE_MODEL_SIMPLE));
 122
 123   return retval;
 124 }
 125
 126 static void
 127 gtk_model_simple_class_init (GtkModelSimpleClass *class)
 128 {
 129   GtkObjectClass *object_class;
 130
 131   object_class = (GtkObjectClass*) class;
 132
 133   model_simple_signals[CHANGED] =
 134     gtk_signal_new ("changed",
 135                     GTK_RUN_FIRST,
 136                     GTK_CLASS_TYPE (object_class),
 137                     GTK_SIGNAL_OFFSET (GtkModelSimpleClass, changed),
 138                     gtk_marshal_VOID__POINTER_POINTER,
 139                     GTK_TYPE_NONE, 2,
 140                     GTK_TYPE_POINTER,
 141                     GTK_TYPE_POINTER);
 142   model_simple_signals[INSERTED] =
 143     gtk_signal_new ("inserted",
 144                     GTK_RUN_FIRST,
 145                     GTK_CLASS_TYPE (object_class),
 146                     GTK_SIGNAL_OFFSET (GtkModelSimpleClass, inserted),
 147                     gtk_marshal_VOID__POINTER_POINTER,
 148                     GTK_TYPE_NONE, 2,
 149                     GTK_TYPE_POINTER,
 150                     GTK_TYPE_POINTER);
 151   model_simple_signals[CHILD_TOGGLED] =
 152     gtk_signal_new ("child_toggled",
 153                     GTK_RUN_FIRST,
 154                     GTK_CLASS_TYPE (object_class),
 155                     GTK_SIGNAL_OFFSET (GtkModelSimpleClass, child_toggled),
 156                     gtk_marshal_VOID__POINTER_POINTER,
 157                     GTK_TYPE_NONE, 2,
 158                     GTK_TYPE_POINTER,
 159                     GTK_TYPE_POINTER);
 160   model_simple_signals[DELETED] =
 161     gtk_signal_new ("deleted",
 162                     GTK_RUN_FIRST,
 163                     GTK_CLASS_TYPE (object_class),
 164                     GTK_SIGNAL_OFFSET (GtkModelSimpleClass, deleted),
 165                     gtk_marshal_VOID__POINTER,
 166                     GTK_TYPE_NONE, 1,
 167                     GTK_TYPE_POINTER);
 168
 169   model_simple_signals[GET_N_COLUMNS] =
 170     gtk_signal_new ("get_n_columns",
 171                     GTK_RUN_LAST,
 172                     GTK_CLASS_TYPE (object_class),
 173                     0,
 174                     gtk_marshal_INT__VOID,
 175                     GTK_TYPE_INT, 0);
 176   model_simple_signals[GET_COLUMN_TYPE] =
 177     gtk_signal_new ("get_column_type",
 178                     GTK_RUN_LAST,
 179                     GTK_CLASS_TYPE (object_class),
 180                     0,
 181                     gtk_marshal_INT__INT,
 182                     GTK_TYPE_INT, 1,
 183                     GTK_TYPE_INT);
 184   model_simple_signals[GET_ITER] =
 185     gtk_signal_new ("get_iter",
 186                     GTK_RUN_LAST,
 187                     GTK_CLASS_TYPE (object_class),
 188                     0,
 189                     gtk_marshal_BOOLEAN__POINTER_POINTER,
 190                     GTK_TYPE_BOOL, 2,
 191                     GTK_TYPE_POINTER,
 192                     GTK_TYPE_POINTER);
 193   model_simple_signals[GET_PATH] =
 194     gtk_signal_new ("get_path",
 195                     GTK_RUN_LAST,
 196                     GTK_CLASS_TYPE (object_class),
 197                     0,
 198                     gtk_marshal_POINTER__POINTER,
 199                     GTK_TYPE_POINTER, 1,
 200                     GTK_TYPE_POINTER);
 201   model_simple_signals[GET_VALUE] =
 202     gtk_signal_new ("get_value",
 203                     GTK_RUN_LAST,
 204                     GTK_CLASS_TYPE (object_class),
 205                     0,
 206                     gtk_marshal_VOID__POINTER_INT_POINTER,
 207                     GTK_TYPE_NONE, 3,
 208                     GTK_TYPE_POINTER,
 209                     GTK_TYPE_INT,
 210                     GTK_TYPE_POINTER);
 211   model_simple_signals[ITER_NEXT] =
 212     gtk_signal_new ("iter_next",
 213                     GTK_RUN_LAST,
 214                     GTK_CLASS_TYPE (object_class),
 215                     0,
 216                     gtk_marshal_BOOLEAN__POINTER,
 217                     GTK_TYPE_BOOL, 1,
 218                     GTK_TYPE_POINTER);
 219   model_simple_signals[ITER_CHILDREN] =
 220     gtk_signal_new ("iter_children",
 221                     GTK_RUN_LAST,
 222                     GTK_CLASS_TYPE (object_class),
 223                     0,
 224                     gtk_marshal_BOOLEAN__POINTER_POINTER,
 225                     GTK_TYPE_POINTER, 2,
 226                     GTK_TYPE_POINTER,
 227                     GTK_TYPE_POINTER);
 228   model_simple_signals[ITER_HAS_CHILD] =
 229     gtk_signal_new ("iter_has_child",
 230                     GTK_RUN_LAST,
 231                     GTK_CLASS_TYPE (object_class),
 232                     0,
 233                     gtk_marshal_BOOLEAN__POINTER,
 234                     GTK_TYPE_BOOL, 1,
 235                     GTK_TYPE_POINTER);
 236   model_simple_signals[ITER_N_CHILDREN] =
 237     gtk_signal_new ("iter_n_children",
 238                     GTK_RUN_LAST,
 239                     GTK_CLASS_TYPE (object_class),
 240                     0,
 241                     gtk_marshal_INT__POINTER,
 242                     GTK_TYPE_INT, 1,
 243                     GTK_TYPE_POINTER);
 244   model_simple_signals[ITER_NTH_CHILD] =
 245     gtk_signal_new ("node_nth_child",
 246                     GTK_RUN_LAST,
 247                     GTK_CLASS_TYPE (object_class),
 248                     0,
 249                     gtk_marshal_BOOLEAN__POINTER_POINTER_INT,
 250                     GTK_TYPE_BOOL, 2,
 251                     GTK_TYPE_POINTER,
 252                     GTK_TYPE_POINTER);
 253   model_simple_signals[ITER_PARENT] =
 254     gtk_signal_new ("node_parent",
 255                     GTK_RUN_LAST,
 256                     GTK_CLASS_TYPE (object_class),
 257                     0,
 258                     gtk_marshal_BOOLEAN__POINTER_POINTER,
 259                     GTK_TYPE_BOOL, 2,
 260                     GTK_TYPE_POINTER,
 261                     GTK_TYPE_POINTER);
 262
 263   gtk_object_class_add_signals (object_class, model_simple_signals, LAST_SIGNAL);
 264 }
 265
 266 static void
 267 gtk_model_simple_tree_model_init (GtkTreeModelIface *iface)
 268 {
 269   iface->get_n_columns = gtk_real_model_simple_get_n_columns;
 270   iface->get_column_type = gtk_real_model_simple_get_column_type;
 271   iface->get_iter = gtk_real_model_simple_get_iter;
 272   iface->get_path = gtk_real_model_simple_get_path;
 273   iface->get_value = gtk_real_model_simple_get_value;
 274   iface->iter_next = gtk_real_model_simple_iter_next;
 275   iface->iter_children = gtk_real_model_simple_iter_children;
 276   iface->iter_has_child = gtk_real_model_simple_iter_has_child;
 277   iface->iter_n_children = gtk_real_model_simple_iter_n_children;
 278   iface->iter_nth_child = gtk_real_model_simple_iter_nth_child;
 279   iface->iter_parent = gtk_real_model_simple_iter_parent;
 280 }
 281
 282
 283 static void
 284 gtk_model_simple_init (GtkModelSimple *model_simple)
 285 {
 286   model_simple->stamp = 1;
 287 }
 288
 289 static gint
 290 gtk_real_model_simple_get_n_columns (GtkTreeModel *tree_model)
 291 {
 292   gint retval = 0;
 293
 294   gtk_signal_emit (GTK_OBJECT (tree_model), model_simple_signals[GET_N_COLUMNS], &retval);
 295
 296   return retval;
 297 }
 298
 299 static GType
 300 gtk_real_model_simple_get_column_type (GtkTreeModel *tree_model,
 301                                        gint          index)
 302 {
 303   GType retval = G_TYPE_INVALID;
 304
 305   gtk_signal_emit (GTK_OBJECT (tree_model), model_simple_signals[GET_COLUMN_TYPE], index, &retval);
 306
 307   return retval;
 308 }
 309
 310 static gboolean
 311 gtk_real_model_simple_get_iter (GtkTreeModel *tree_model,
 312                                 GtkTreeIter  *iter,
 313                                 GtkTreePath  *path)
 314 {
 315   gboolean retval;
 316
 317   gtk_signal_emit (GTK_OBJECT (tree_model), model_simple_signals[GET_ITER], iter, path, &retval);
 318
 319   return retval;
 320 }
 321
 322 static GtkTreePath *
 323 gtk_real_model_simple_get_path (GtkTreeModel *tree_model,
 324                                 GtkTreeIter  *iter)
 325 {
 326   GtkTreePath *retval;
 327
 328   gtk_signal_emit (GTK_OBJECT (tree_model), model_simple_signals[GET_PATH], iter, &retval);
 329
 330   return retval;
 331 }
 332
 333 static void
 334 gtk_real_model_simple_get_value (GtkTreeModel *tree_model,
 335                                  GtkTreeIter  *iter,
 336                                  gint          column,
 337                                  GValue       *value)
 338 {
 339   gtk_signal_emit (GTK_OBJECT (tree_model), model_simple_signals[GET_VALUE], iter, column, value);
 340 }
 341
 342 static gboolean
 343 gtk_real_model_simple_iter_next (GtkTreeModel  *tree_model,
 344                                  GtkTreeIter   *iter)
 345 {
 346   gboolean retval = FALSE;
 347
 348   gtk_signal_emit (GTK_OBJECT (tree_model), model_simple_signals[ITER_NEXT], iter, &retval);
 349
 350   return retval;
 351 }
 352
 353 static gboolean
 354 gtk_real_model_simple_iter_children (GtkTreeModel *tree_model,
 355                                      GtkTreeIter  *iter,
 356                                      GtkTreeIter  *parent)
 357 {
 358   gboolean retval = FALSE;
 359
 360   gtk_signal_emit (GTK_OBJECT (tree_model), model_simple_signals[ITER_CHILDREN], iter, parent, &retval);
 361
 362   return retval;
 363 }
 364
 365 static gboolean
 366 gtk_real_model_simple_iter_has_child (GtkTreeModel *tree_model,
 367                                       GtkTreeIter  *iter)
 368 {
 369   gboolean retval = FALSE;
 370
 371   gtk_signal_emit (GTK_OBJECT (tree_model), model_simple_signals[ITER_HAS_CHILD], iter, &retval);
 372
 373   return retval;
 374 }
 375
 376 static gint
 377 gtk_real_model_simple_iter_n_children (GtkTreeModel *tree_model,
 378                                        GtkTreeIter  *iter)
 379 {
 380   gint retval = 0;
 381
 382   gtk_signal_emit (GTK_OBJECT (tree_model), model_simple_signals[ITER_N_CHILDREN], iter, &retval);
 383
 384   return retval;
 385 }
 386
 387 static gboolean
 388 gtk_real_model_simple_iter_nth_child (GtkTreeModel *tree_model,
 389                                       GtkTreeIter  *iter,
 390                                       GtkTreeIter  *parent,
 391                                       gint          n)
 392 {
 393   gboolean retval = FALSE;
 394
 395   gtk_signal_emit (GTK_OBJECT (tree_model), model_simple_signals[ITER_NTH_CHILD], iter, parent, n, &retval);
 396
 397   return retval;
 398 }
 399
 400 static gboolean
 401 gtk_real_model_simple_iter_parent (GtkTreeModel *tree_model,
 402                                    GtkTreeIter  *iter,
 403                                    GtkTreeIter  *child)
 404 {
 405   gboolean retval = FALSE;
 406
 407   gtk_signal_emit (GTK_OBJECT (tree_model), model_simple_signals[ITER_PARENT], iter, child, &retval);
 408
 409   return retval;
 410 }
 411
 412 /* Public functions */
 413 void
 414 gtk_model_simple_changed (GtkModelSimple *simple,
 415                           GtkTreePath    *path,
 416                           GtkTreeIter    *iter)
 417 {
 418   g_return_if_fail (simple != NULL);
 419   g_return_if_fail (GTK_IS_MODEL_SIMPLE (simple));
 420   g_return_if_fail (path != NULL);
 421
 422   gtk_signal_emit_by_name (GTK_OBJECT (simple), "changed", path, iter);
 423 }
 424
 425 void
 426 gtk_model_simple_inserted (GtkModelSimple *simple,
 427                            GtkTreePath    *path,
 428                            GtkTreeIter    *iter)
 429 {
 430   g_return_if_fail (simple != NULL);
 431   g_return_if_fail (GTK_IS_MODEL_SIMPLE (simple));
 432   g_return_if_fail (path != NULL);
 433
 434   gtk_signal_emit_by_name (GTK_OBJECT (simple), "inserted", path, iter);
 435 }
 436
 437 void
 438 gtk_model_simple_child_toggled (GtkModelSimple *simple,
 439                                 GtkTreePath    *path,
 440                                 GtkTreeIter    *iter)
 441 {
 442   g_return_if_fail (simple != NULL);
 443   g_return_if_fail (GTK_IS_MODEL_SIMPLE (simple));
 444   g_return_if_fail (path != NULL);
 445
 446   gtk_signal_emit_by_name (GTK_OBJECT (simple), "child_toggled", path, iter);
 447 }
 448
 449 void
 450 gtk_model_simple_iter_deleted (GtkModelSimple *simple,
 451                                GtkTreePath    *path,
 452                                GtkTreeIter    *iter)
 453 {
 454   g_return_if_fail (simple != NULL);
 455   g_return_if_fail (GTK_IS_MODEL_SIMPLE (simple));
 456   g_return_if_fail (path != NULL);
 457
 458   gtk_signal_emit_by_name (GTK_OBJECT (simple), "iter_deleted", path, iter);
 459 }