gschem/src/gschem_find_text_dockable.c

   1 /* gEDA - GPL Electronic Design Automation
   2  * gschem - gEDA Schematic Capture
   3  * Copyright (C) 1998-2010 Ales Hvezda
   4  * Copyright (C) 1998-2020 gEDA Contributors (see ChangeLog for details)
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20 /*!
  21  * \file gschem_find_text_dockable.c
  22  *
  23  * \brief Stores state of a find text operation
  24  */
  25
  26 #include <config.h>
  27
  28 #include <stdio.h>
  29 #ifdef HAVE_STDLIB_H
  30 #include <stdlib.h>
  31 #endif
  32 #ifdef HAVE_STRING_H
  33 #include <string.h>
  34 #endif
  35
  36 #include "gschem.h"
  37
  38 #include "../include/gschem_find_text_dockable.h"
  39
  40
  41 enum
  42 {
  43   COLUMN_FILENAME,
  44   COLUMN_STRING,
  45   COLUMN_OBJECT,
  46   COLUMN_COUNT
  47 };
  48
  49
  50 typedef void (*NotifyFunc)(void*, void*);
  51
  52
  53 static void
  54 assign_store (GschemFindTextDockable *state, GSList *objects);
  55
  56 static void
  57 class_init (GschemFindTextDockableClass *klass);
  58
  59 static void
  60 clear_store (GschemFindTextDockable *state);
  61
  62 static void
  63 dispose (GObject *object);
  64
  65 static void
  66 finalize (GObject *object);
  67
  68 static GSList*
  69 find_objects_using_pattern (GSList *pages, const char *text);
  70
  71 static GSList*
  72 find_objects_using_regex (GSList *pages, const char *text, GError **error);
  73
  74 static GSList*
  75 find_objects_using_substring (GSList *pages, const char *text);
  76
  77 static GSList*
  78 get_pages (GList *pages, gboolean descend);
  79
  80 static void
  81 get_property (GObject *object, guint param_id, GValue *value, GParamSpec *pspec);
  82
  83 static GList*
  84 get_subpages (PAGE *page);
  85
  86 static void
  87 instance_init (GschemFindTextDockable *state);
  88
  89 static GtkWidget *
  90 create_widget (GschemDockable *parent);
  91
  92 static void
  93 object_weakref_cb (OBJECT *object, GschemFindTextDockable *state);
  94
  95 static void
  96 remove_object (GschemFindTextDockable *state, OBJECT *object);
  97
  98 static void
  99 select_cb (GtkTreeSelection *selection, GschemFindTextDockable *state);
 100
 101 static void
 102 set_property (GObject *object, guint param_id, const GValue *value, GParamSpec *pspec);
 103
 104
 105 static GObjectClass *gschem_find_text_dockable_parent_class = NULL;
 106
 107
 108 /*! \brief find instances of a given string
 109  *
 110  *  Finds instances of a given string and displays the result inside this
 111  *  widget.
 112  *
 113  *  \param [in] state
 114  *  \param [in] pages a list of pages to search
 115  *  \param [in] type the type of find to perform
 116  *  \param [in] text the text to find
 117  *  \param [in] descend decend the page heirarchy
 118  *  \return the number of objects found
 119  */
 120 int
 121 gschem_find_text_dockable_find (GschemFindTextDockable *state, GList *pages, int type, const char *text, gboolean descend)
 122 {
 123   int count;
 124   GSList *objects = NULL;
 125   GSList *all_pages;
 126
 127   all_pages = get_pages (pages, descend);
 128
 129   switch (type) {
 130     case FIND_TYPE_SUBSTRING:
 131       objects = find_objects_using_substring (all_pages, text);
 132       break;
 133
 134     case FIND_TYPE_PATTERN:
 135       objects = find_objects_using_pattern (all_pages, text);
 136       break;
 137
 138     case FIND_TYPE_REGEX:
 139       objects = find_objects_using_regex (all_pages, text, NULL);
 140       break;
 141
 142     default:
 143       break;
 144   }
 145
 146   g_slist_free (all_pages);
 147
 148   assign_store (state, objects);
 149
 150   count = g_slist_length (objects);
 151   g_slist_free (objects);
 152
 153   return count;
 154 }
 155
 156
 157 /*! \brief Get/register GschemFindTextDockable type.
 158  */
 159 GType
 160 gschem_find_text_dockable_get_type ()
 161 {
 162   static GType type = 0;
 163
 164   if (type == 0) {
 165     static const GTypeInfo info = {
 166       sizeof(GschemFindTextDockableClass),
 167       NULL,                                /* base_init */
 168       NULL,                                /* base_finalize */
 169       (GClassInitFunc) class_init,
 170       NULL,                                /* class_finalize */
 171       NULL,                                /* class_data */
 172       sizeof(GschemFindTextDockable),
 173       0,                                   /* n_preallocs */
 174       (GInstanceInitFunc) instance_init,
 175     };
 176
 177     type = g_type_register_static (GSCHEM_TYPE_DOCKABLE,
 178                                    "GschemFindTextDockable",
 179                                    &info,
 180                                    0);
 181   }
 182
 183   return type;
 184 }
 185
 186
 187
 188
 189
 190
 191
 192
 193 /*! \brief places object in the store so the user can see them
 194  *
 195  *  \param [in] state
 196  *  \param [in] objects the list of objects to put in the store
 197  */
 198 static void
 199 assign_store (GschemFindTextDockable *state, GSList *objects)
 200 {
 201   GSList *object_iter;
 202
 203   g_return_if_fail (state != NULL);
 204   g_return_if_fail (state->store != NULL);
 205
 206   clear_store (state);
 207
 208   object_iter = objects;
 209
 210   while (object_iter != NULL) {
 211     char *basename;
 212     OBJECT *object = (OBJECT*) object_iter->data;
 213     const char *str;
 214     GtkTreeIter tree_iter;
 215
 216     object_iter = g_slist_next (object_iter);
 217
 218     if (object == NULL) {
 219       g_warning ("NULL object encountered");
 220       continue;
 221     }
 222
 223     if (object->page == NULL) {
 224       g_warning ("NULL page encountered");
 225       continue;
 226     }
 227
 228     if (object->type != OBJ_TEXT) {
 229       g_warning ("expecting a text object");
 230       continue;
 231     }
 232
 233     str = o_text_get_string (object->page->toplevel, object);
 234
 235     if (str == NULL) {
 236       g_warning ("NULL string encountered");
 237       continue;
 238     }
 239
 240     s_object_weak_ref (object, (NotifyFunc) object_weakref_cb, state);
 241
 242     gtk_list_store_append (state->store, &tree_iter);
 243
 244     if (object->page->is_untitled)
 245       basename = g_strdup (_("Untitled page"));
 246     else
 247       basename = g_path_get_basename (object->page->page_filename);
 248
 249     gtk_list_store_set (state->store,
 250                         &tree_iter,
 251                         COLUMN_FILENAME, basename,
 252                         COLUMN_STRING, str,
 253                         COLUMN_OBJECT, object,
 254                         -1);
 255
 256     g_free (basename);
 257   }
 258 }
 259
 260
 261 /*! \brief initialize class
 262  *
 263  *  \param [in] klass The class for initialization
 264  */
 265 static void
 266 class_init (GschemFindTextDockableClass *klass)
 267 {
 268   gschem_find_text_dockable_parent_class = G_OBJECT_CLASS (g_type_class_peek_parent (klass));
 269
 270   GSCHEM_DOCKABLE_CLASS (klass)->create_widget = create_widget;
 271
 272   G_OBJECT_CLASS (klass)->dispose  = dispose;
 273   G_OBJECT_CLASS (klass)->finalize = finalize;
 274
 275   G_OBJECT_CLASS (klass)->get_property = get_property;
 276   G_OBJECT_CLASS (klass)->set_property = set_property;
 277
 278   g_signal_new ("select-object",                     /* signal_name  */
 279                 G_OBJECT_CLASS_TYPE (klass),         /* itype        */
 280                 0,                                   /* signal_flags */
 281                 0,                                   /* class_offset */
 282                 NULL,                                /* accumulator  */
 283                 NULL,                                /* accu_data    */
 284                 g_cclosure_marshal_VOID__POINTER,    /* c_marshaller */
 285                 G_TYPE_NONE,                         /* return_type  */
 286                 1,                                   /* n_params     */
 287                 G_TYPE_POINTER
 288                 );
 289 }
 290
 291
 292 /*! \brief delete all items from the list store
 293  *
 294  *  This function deletes all items in the list store and removes all the weak
 295  *  references to the objects.
 296  *
 297  *  \param [in] state
 298  */
 299 static void
 300 clear_store (GschemFindTextDockable *state)
 301 {
 302   GtkTreeIter iter;
 303   gboolean valid;
 304
 305   g_return_if_fail (state != NULL);
 306   g_return_if_fail (state->store != NULL);
 307
 308   valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (state->store), &iter);
 309
 310   while (valid) {
 311     GValue value = G_VALUE_INIT;
 312
 313     gtk_tree_model_get_value (GTK_TREE_MODEL (state->store),
 314                               &iter,
 315                               COLUMN_OBJECT,
 316                               &value);
 317
 318     if (G_VALUE_HOLDS_POINTER (&value)) {
 319       OBJECT *object = g_value_get_pointer (&value);
 320
 321       s_object_weak_unref (object, (NotifyFunc) object_weakref_cb, state);
 322     }
 323
 324     g_value_unset (&value);
 325
 326     valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (state->store), &iter);
 327   }
 328
 329   gtk_list_store_clear (state->store);
 330 }
 331
 332
 333 /*! \brief Dispose of the object
 334  */
 335 static void
 336 dispose (GObject *object)
 337 {
 338   GschemFindTextDockable *state = GSCHEM_FIND_TEXT_DOCKABLE (object);
 339
 340   if (state->store) {
 341     clear_store (state);
 342     g_object_unref (state->store);
 343     state->store = NULL;
 344   }
 345
 346   /* lastly, chain up to the parent dispose */
 347
 348   g_return_if_fail (gschem_find_text_dockable_parent_class != NULL);
 349   gschem_find_text_dockable_parent_class->dispose (object);
 350 }
 351
 352
 353 /*! \brief Finalize object
 354  */
 355 static void
 356 finalize (GObject *object)
 357 {
 358   /* lastly, chain up to the parent finalize */
 359
 360   g_return_if_fail (gschem_find_text_dockable_parent_class != NULL);
 361   gschem_find_text_dockable_parent_class->finalize (object);
 362 }
 363
 364
 365 /*! \brief Find all text objects that match a pattern
 366  *
 367  *  \param pages the list of pages to search
 368  *  \param text the pattern to match
 369  *  \return a list of objects that match the given pattern
 370  */
 371 static GSList*
 372 find_objects_using_pattern (GSList *pages, const char *text)
 373 {
 374   GSList *object_list = NULL;
 375   GSList *page_iter = pages;
 376   GPatternSpec *pattern;
 377
 378   g_return_val_if_fail (text != NULL, NULL);
 379
 380   pattern = g_pattern_spec_new (text);
 381
 382   while (page_iter != NULL) {
 383     const GList *object_iter;
 384     PAGE *page = (PAGE*) page_iter->data;
 385
 386     page_iter = g_slist_next (page_iter);
 387
 388     if (page == NULL) {
 389       g_warning ("NULL page encountered");
 390       continue;
 391     }
 392
 393     object_iter = s_page_objects (page);
 394
 395     while (object_iter != NULL) {
 396       OBJECT *object = (OBJECT*) object_iter->data;
 397       const char *str;
 398
 399       object_iter = g_list_next (object_iter);
 400
 401       if (object == NULL) {
 402         g_warning ("NULL object encountered");
 403         continue;
 404       }
 405
 406       if (object->type != OBJ_TEXT) {
 407         continue;
 408       }
 409
 410       if (!(o_is_visible (object) || page->toplevel->show_hidden_text)) {
 411         continue;
 412       }
 413
 414       str = o_text_get_string (object->page->toplevel, object);
 415
 416       if (str == NULL) {
 417         g_warning ("NULL string encountered");
 418         continue;
 419       }
 420
 421       if (g_pattern_match_string (pattern, str)) {
 422         object_list = g_slist_prepend (object_list, object);
 423       }
 424     }
 425   }
 426
 427   g_pattern_spec_free (pattern);
 428
 429   return g_slist_reverse (object_list);
 430 }
 431
 432
 433 /*! \brief Find all text objects that match a regex
 434  *
 435  *  \param pages the list of pages to search
 436  *  \param text the regex to match
 437  *  \return a list of objects that match the given regex
 438  */
 439 static GSList*
 440 find_objects_using_regex (GSList *pages, const char *text, GError **error)
 441 {
 442   GError *ierror = NULL;
 443   GSList *object_list = NULL;
 444   GSList *page_iter = pages;
 445   GRegex *regex;
 446
 447   g_return_val_if_fail (text != NULL, NULL);
 448
 449   regex = g_regex_new (text,
 450                        0,
 451                        0,
 452                        &ierror);
 453
 454   if (ierror != NULL) {
 455     g_propagate_error (error, ierror);
 456     return NULL;
 457   }
 458
 459   while (page_iter != NULL) {
 460     const GList *object_iter;
 461     PAGE *page = (PAGE*) page_iter->data;
 462
 463     page_iter = g_slist_next (page_iter);
 464
 465     if (page == NULL) {
 466       g_warning ("NULL page encountered");
 467       continue;
 468     }
 469
 470     object_iter = s_page_objects (page);
 471
 472     while (object_iter != NULL) {
 473       OBJECT *object = (OBJECT*) object_iter->data;
 474       const char *str;
 475
 476       object_iter = g_list_next (object_iter);
 477
 478       if (object == NULL) {
 479         g_warning ("NULL object encountered");
 480         continue;
 481       }
 482
 483       if (object->type != OBJ_TEXT) {
 484         continue;
 485       }
 486
 487       if (!(o_is_visible (object) || page->toplevel->show_hidden_text)) {
 488         continue;
 489       }
 490
 491       str = o_text_get_string (object->page->toplevel, object);
 492
 493       if (str == NULL) {
 494         g_warning ("NULL string encountered");
 495         continue;
 496       }
 497
 498       if (g_regex_match (regex, str, 0, NULL)) {
 499         object_list = g_slist_prepend (object_list, object);
 500       }
 501     }
 502   }
 503
 504   g_regex_unref (regex);
 505
 506   return g_slist_reverse (object_list);
 507 }
 508
 509
 510 /*! \brief Find all text objects that contain a substring
 511  *
 512  *  \param pages the list of pages to search
 513  *  \param text the substring to find
 514  *  \return a list of objects that contain the given substring
 515  */
 516 static GSList*
 517 find_objects_using_substring (GSList *pages, const char *text)
 518 {
 519   GSList *object_list = NULL;
 520   GSList *page_iter = pages;
 521
 522   g_return_val_if_fail (text != NULL, NULL);
 523
 524   while (page_iter != NULL) {
 525     const GList *object_iter;
 526     PAGE *page = (PAGE*) page_iter->data;
 527
 528     page_iter = g_slist_next (page_iter);
 529
 530     if (page == NULL) {
 531       g_warning ("NULL page encountered");
 532       continue;
 533     }
 534
 535     object_iter = s_page_objects (page);
 536
 537     while (object_iter != NULL) {
 538       OBJECT *object = (OBJECT*) object_iter->data;
 539       const char *str;
 540
 541       object_iter = g_list_next (object_iter);
 542
 543       if (object == NULL) {
 544         g_warning ("NULL object encountered");
 545         continue;
 546       }
 547
 548       if (object->type != OBJ_TEXT) {
 549         continue;
 550       }
 551
 552       if (!(o_is_visible (object) || page->toplevel->show_hidden_text)) {
 553         continue;
 554       }
 555
 556       str = o_text_get_string (object->page->toplevel, object);
 557
 558       if (str == NULL) {
 559         g_warning ("NULL string encountered");
 560         continue;
 561       }
 562
 563       if (strstr (str, text) != NULL) {
 564         object_list = g_slist_prepend (object_list, object);
 565       }
 566     }
 567   }
 568
 569   return g_slist_reverse (object_list);
 570 }
 571
 572
 573
 574 /*! \brief obtain a list of pages for an operation
 575  *
 576  *  Descends the heirarchy of pages, if selected, and removes duplicate pages.
 577  *
 578  *  \param [in] pages the list of pages to begin search
 579  *  \param [in] descend alose locates subpages
 580  *  \return a list of all the pages
 581  */
 582 static GSList*
 583 get_pages (GList *pages, gboolean descend)
 584 {
 585   GList *input_list = g_list_copy (pages);
 586   GSList *output_list = NULL;
 587   GHashTable *visit_list = g_hash_table_new (NULL, NULL);
 588
 589   while (input_list != NULL) {
 590     PAGE *page = (PAGE*) input_list->data;
 591
 592     input_list = g_list_delete_link (input_list, input_list);
 593
 594     if (page == NULL) {
 595       g_warning ("NULL page encountered");
 596       continue;
 597     }
 598
 599     /** \todo the following function becomes available in glib 2.32 */
 600     /* if (g_hash_table_contains (visit_list, page)) { */
 601
 602     if (g_hash_table_lookup_extended (visit_list, page, NULL, NULL)) {
 603       continue;
 604     }
 605
 606     output_list = g_slist_prepend (output_list, page);
 607     g_hash_table_insert (visit_list, page, NULL);
 608
 609     if (descend) {
 610       input_list = g_list_concat (input_list, get_subpages (page));
 611     }
 612   }
 613
 614   g_hash_table_destroy (visit_list);
 615
 616   return g_slist_reverse (output_list);
 617 }
 618
 619
 620 /*! \brief Get a property
 621  *
 622  *  \param [in]     object
 623  *  \param [in]     param_id
 624  *  \param [in,out] value
 625  *  \param [in]     pspec
 626  */
 627 static void
 628 get_property (GObject *object, guint param_id, GValue *value, GParamSpec *pspec)
 629 {
 630   /* GschemFindTextDockable *state = GSCHEM_FIND_TEXT_DOCKABLE (object); */
 631
 632   switch (param_id) {
 633     default:
 634       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 635   }
 636 }
 637
 638
 639 /*! \brief get the subpages of a schematic page
 640  *
 641  *  if any subpages are not loaded, this function will load them.
 642  *
 643  *  \param [in] page the parent page
 644  *  \return a list of all the subpages
 645  */
 646 static GList*
 647 get_subpages (PAGE *page)
 648 {
 649   const GList *object_iter;
 650   GList *page_list = NULL;
 651
 652   g_return_val_if_fail (page != NULL, NULL);
 653
 654   object_iter = s_page_objects (page);
 655
 656   while (object_iter != NULL) {
 657     char *attrib;
 658     char **filenames;
 659     char **iter;
 660     OBJECT *object = (OBJECT*) object_iter->data;
 661
 662     object_iter = g_list_next (object_iter);
 663
 664     if (object == NULL) {
 665       g_warning ("NULL object encountered");
 666       continue;
 667     }
 668
 669     if (object->type != OBJ_COMPLEX) {
 670       continue;
 671     }
 672
 673     attrib = o_attrib_search_attached_attribs_by_name (object,
 674                                                        "source",
 675                                                        0);
 676
 677     if (attrib == NULL) {
 678       attrib = o_attrib_search_inherited_attribs_by_name (object,
 679                                                           "source",
 680                                                           0);
 681     }
 682
 683     if (attrib == NULL) {
 684       continue;
 685     }
 686
 687     filenames = g_strsplit (attrib, ",", 0);
 688
 689     if (filenames == NULL) {
 690       continue;
 691     }
 692
 693     for (iter = filenames; *iter != NULL; iter++) {
 694       PAGE *subpage = s_hierarchy_load_subpage (page, *iter, NULL);
 695
 696       if (subpage != NULL) {
 697         page_list = g_list_prepend (page_list, subpage);
 698       }
 699     }
 700
 701     g_strfreev (filenames);
 702   }
 703
 704   return g_list_reverse (page_list);
 705 }
 706
 707
 708 /*! \brief initialize a new instance
 709  *
 710  *  \param [in] state the new instance
 711  */
 712 static void
 713 instance_init (GschemFindTextDockable *state)
 714 {
 715   state->store = gtk_list_store_new(COLUMN_COUNT,
 716                                     G_TYPE_STRING,
 717                                     G_TYPE_STRING,
 718                                     G_TYPE_POINTER);
 719 }
 720
 721 static GtkWidget *
 722 create_widget (GschemDockable *parent)
 723 {
 724   GschemFindTextDockable *state = GSCHEM_FIND_TEXT_DOCKABLE (parent);
 725
 726   GtkTreeViewColumn *column;
 727   GtkCellRenderer *renderer;
 728   GtkWidget *scrolled;
 729   GtkTreeSelection *selection;
 730   GtkWidget *tree_widget;
 731
 732   scrolled = gtk_scrolled_window_new (NULL, NULL);
 733
 734   tree_widget = gtk_tree_view_new_with_model (GTK_TREE_MODEL (state->store));
 735   gtk_container_add (GTK_CONTAINER (scrolled), tree_widget);
 736
 737   /* filename column */
 738
 739   column = gtk_tree_view_column_new();
 740   gtk_tree_view_column_set_resizable (column, TRUE);
 741   gtk_tree_view_column_set_title (column, _("Filename"));
 742
 743   gtk_tree_view_append_column (GTK_TREE_VIEW (tree_widget), column);
 744
 745   renderer = gtk_cell_renderer_text_new();
 746   gtk_tree_view_column_pack_start(column, renderer, TRUE);
 747   gtk_tree_view_column_add_attribute(column, renderer, "text", 0);
 748
 749   /* text column */
 750
 751   column = gtk_tree_view_column_new();
 752   gtk_tree_view_column_set_resizable (column, TRUE);
 753   gtk_tree_view_column_set_title (column, _("Text"));
 754
 755   gtk_tree_view_append_column (GTK_TREE_VIEW (tree_widget), column);
 756
 757   renderer = gtk_cell_renderer_text_new();
 758   gtk_tree_view_column_pack_start(column, renderer, TRUE);
 759   gtk_tree_view_column_add_attribute(column, renderer, "text", 1);
 760
 761   /* attach signal to detect user selection */
 762
 763   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_widget));
 764   g_signal_connect (selection, "changed", G_CALLBACK (select_cb), state);
 765
 766   gtk_widget_show_all (scrolled);
 767   return scrolled;
 768 }
 769
 770
 771 /*! \brief callback for an object that has been destroyed
 772  *
 773  *  \param [in] object the object that has been destroyed
 774  *  \param [in] state
 775  */
 776 static void
 777 object_weakref_cb (OBJECT *object, GschemFindTextDockable *state)
 778 {
 779   g_return_if_fail (state != NULL);
 780
 781   remove_object (state, object);
 782 }
 783
 784
 785 /*! \brief remove an object from the store
 786  *
 787  *  This function gets called in response to the object deletion. And, doesn't
 788  *  dereference the object.
 789  *
 790  *  This function doesn't remove the weak reference, under the assumption that
 791  *  the object is being destroyed.
 792  *
 793  *  \param [in] state
 794  *  \param [in] object the object to remove from the store
 795  */
 796 static void
 797 remove_object (GschemFindTextDockable *state, OBJECT *object)
 798 {
 799   GtkTreeIter iter;
 800   gboolean valid;
 801
 802   g_return_if_fail (object != NULL);
 803   g_return_if_fail (state != NULL);
 804   g_return_if_fail (state->store != NULL);
 805
 806   valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (state->store), &iter);
 807
 808   while (valid) {
 809     GValue value = G_VALUE_INIT;
 810
 811     gtk_tree_model_get_value (GTK_TREE_MODEL (state->store),
 812                               &iter,
 813                               COLUMN_OBJECT,
 814                               &value);
 815
 816     if (G_VALUE_HOLDS_POINTER (&value)) {
 817       OBJECT *other = g_value_get_pointer (&value);
 818
 819       if (object == other) {
 820         g_value_unset (&value);
 821         valid = gtk_list_store_remove (state->store, &iter);
 822         continue;
 823       }
 824     }
 825
 826     g_value_unset (&value);
 827     valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (state->store), &iter);
 828   }
 829 }
 830
 831
 832 /*! \brief callback for user selecting an item
 833  *
 834  *  \param [in] selection
 835  *  \param [in] state
 836  */
 837 static void
 838 select_cb (GtkTreeSelection *selection, GschemFindTextDockable *state)
 839 {
 840   GtkTreeIter iter;
 841   gboolean success;
 842
 843   g_return_if_fail (selection != NULL);
 844   g_return_if_fail (state != NULL);
 845
 846   success = gtk_tree_selection_get_selected (selection, NULL, &iter);
 847
 848   if (success) {
 849     GValue value = G_VALUE_INIT;
 850
 851     gtk_tree_model_get_value (GTK_TREE_MODEL (state->store),
 852                               &iter,
 853                               COLUMN_OBJECT,
 854                               &value);
 855
 856     if (G_VALUE_HOLDS_POINTER (&value)) {
 857       OBJECT *object = g_value_get_pointer (&value);
 858
 859       if (object != NULL) {
 860         g_signal_emit_by_name (state, "select-object", object);
 861       } else {
 862         g_warning ("NULL object encountered");
 863       }
 864     }
 865
 866     g_value_unset (&value);
 867   }
 868 }
 869
 870
 871 /*! \brief Set a gobject property
 872  *
 873  *  \param [in]     object
 874  *  \param [in]     param_id
 875  *  \param [in,out] value
 876  *  \param [in]     pspec
 877  */
 878 static void
 879 set_property (GObject *object, guint param_id, const GValue *value, GParamSpec *pspec)
 880 {
 881   /* GschemFindTextDockable *state = GSCHEM_FIND_TEXT_DOCKABLE (object); */
 882
 883   switch (param_id) {
 884     default:
 885       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
 886   }
 887 }