plugins/symbol-db/symbol-db-view-search.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3  * anjuta
   4  * Copyright (C) 2001-2003 CodeFactory AB
   5  * Copyright (C) 2001-2003 Mikael Hallendal <micke@imendio.com>
   6  * Copyright (C) 2005-2007 Massimo Corà <maxcvs@email.it>
   7  *
   8  * anjuta is free software.
   9  *
  10  * You may redistribute it and/or modify it under the terms of the
  11  * GNU General Public License, as published by the Free Software
  12  * Foundation; either version 2 of the License, or (at your option)
  13  * any later version.
  14  *
  15  * anjuta is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  18  * See the GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with anjuta.  If not, write to:
  22  *      The Free Software Foundation, Inc.,
  23  *      51 Franklin Street, Fifth Floor
  24  *      Boston, MA  02110-1301, USA.
  25  */
  26
  27 #include <config.h>
  28 #include <string.h>
  29 #include <glib.h>
  30 #include <glib-object.h>
  31 #include <gdk/gdkkeysyms.h>
  32 #include <gtk/gtk.h>
  33 #include <gtk/gtkaccessible.h>
  34 #include <gtk/gtkcellrenderertext.h>
  35 #include <gtk/gtkentry.h>
  36 #include <gtk/gtkframe.h>
  37 #include <gtk/gtkhbox.h>
  38 #include <gtk/gtkvbox.h>
  39 #include <gtk/gtklabel.h>
  40 #include <gtk/gtkscrolledwindow.h>
  41 #include <gtk/gtktreeview.h>
  42 #include <gtk/gtktreeselection.h>
  43 #include <libgnome/gnome-i18n.h>
  44 #include <libanjuta/anjuta-debug.h>
  45
  46 #include "symbol-db-view-search.h"
  47 #include "symbol-db-engine.h"
  48 #include "symbol-db-engine-iterator.h"
  49 #include "symbol-db-engine-iterator-node.h"
  50 #include "symbol-db-view.h"
  51
  52 /* private class */
  53 struct _SymbolDBViewSearchPriv
  54 {
  55         SymbolDBEngine *sdbe;
  56         GtkTreeModel *model;
  57
  58         GtkWidget *entry;       /* entrybox */
  59         GtkWidget *hitlist;     /* treeview */
  60
  61         GCompletion *completion;
  62
  63         guint idle_complete;
  64         guint idle_filter;
  65 };
  66
  67 enum
  68 {
  69         SYM_SELECTED,
  70         LAST_SIGNAL
  71 };
  72
  73 enum {
  74         COLUMN_PIXBUF,
  75         COLUMN_NAME,
  76         COLUMN_LINE,
  77         COLUMN_FILE,
  78         COLUMN_SYMBOL_ID,
  79         COLUMN_MAX
  80 };
  81
  82 /* max hits to display on the search tab */
  83 #define MAX_HITS        100
  84
  85 static GtkVBox *parent_class;
  86 static gint signals[LAST_SIGNAL] = { 0 };
  87
  88 static void
  89 sdb_view_search_model_filter (SymbolDBViewSearch * search,
  90                                                            const gchar * string)
  91 {
  92         SymbolDBViewSearchPriv *priv;
  93         gint i;
  94         GtkTreeStore *store;
  95         SymbolDBEngineIterator *iterator;
  96         gint hits = 0;
  97
  98         g_return_if_fail (SYMBOL_IS_DB_VIEW_SEARCH (search));
  99         g_return_if_fail (string != NULL);
 100
 101         priv = search->priv;
 102
 103         /* get the tree store model */
 104         store = GTK_TREE_STORE (gtk_tree_view_get_model
 105                                 (GTK_TREE_VIEW (priv->hitlist)));
 106
 107         /* let's clean up rows from store model */
 108         g_list_foreach (priv->completion->items, (GFunc)g_free, NULL);
 109         g_completion_clear_items (priv->completion);
 110
 111         gtk_tree_store_clear (GTK_TREE_STORE (store));
 112
 113         if (strlen (string))
 114         {
 115                 iterator = symbol_db_engine_find_symbol_by_name_pattern (priv->sdbe,
 116                                                                                 string, SYMINFO_SIMPLE| SYMINFO_FILE_PATH |
 117                                                                                                 SYMINFO_ACCESS | SYMINFO_KIND);
 118                 if (iterator)
 119                 {
 120                         GList *completion_list;
 121                         gint max_hits;
 122                         SymbolDBEngineIteratorNode *iter_node;
 123
 124                         /* max number of hits to take care of */
 125                         hits = symbol_db_engine_iterator_get_n_items (iterator);
 126                         max_hits = (hits < MAX_HITS)? hits : MAX_HITS;
 127
 128                         completion_list = NULL;
 129
 130                         for (i = 0; i < max_hits; ++i)
 131                         {
 132                                 GtkTreeIter iter;
 133
 134                                 iter_node = SYMBOL_DB_ENGINE_ITERATOR_NODE (iterator);
 135
 136                                 const gchar *sym_name =
 137                                         symbol_db_engine_iterator_node_get_symbol_name (iter_node);
 138
 139                                 if (sym_name)
 140                                 {
 141                                         /* get the full file path instead of a database-oriented one. */
 142                                         gchar *file_path =
 143                                                 symbol_db_engine_get_full_local_path (priv->sdbe,
 144                                                         symbol_db_engine_iterator_node_get_symbol_extra_string (
 145                                                                         iter_node, SYMINFO_FILE_PATH));
 146
 147                                         /* add a new iter */
 148                                         gtk_tree_store_append (GTK_TREE_STORE (store), &iter, NULL);
 149
 150                                         gtk_tree_store_set (GTK_TREE_STORE (store), &iter,
 151                                                         COLUMN_PIXBUF, symbol_db_view_get_pixbuf (
 152                                                                 symbol_db_engine_iterator_node_get_symbol_extra_string (
 153                                                                         iter_node, SYMINFO_KIND),
 154                                                                         symbol_db_engine_iterator_node_get_symbol_extra_string (
 155                                                                         iter_node, SYMINFO_ACCESS)
 156                                                                 ),
 157                                                         COLUMN_NAME, sym_name,
 158                                                         COLUMN_LINE,
 159                                                                 symbol_db_engine_iterator_node_get_symbol_file_pos (
 160                                                                                                         iter_node),
 161                                                         COLUMN_FILE, file_path,
 162                                                         COLUMN_SYMBOL_ID,
 163                                                                 symbol_db_engine_iterator_node_get_symbol_id (iter_node),
 164                                                         -1);
 165
 166                                         completion_list = g_list_prepend (completion_list,
 167                                                         g_strdup (sym_name));
 168                                         g_free (file_path);
 169                                 }
 170
 171                                 symbol_db_engine_iterator_move_next (iterator);
 172                         }
 173                         if (completion_list)
 174                         {
 175                                 completion_list = g_list_reverse (completion_list);
 176                                 g_completion_add_items (priv->completion, completion_list);
 177                                 g_list_free (completion_list);
 178                         }
 179                 }
 180
 181                 if (iterator)
 182                         g_object_unref (iterator);
 183         }
 184 }
 185
 186 static gboolean
 187 sdb_view_search_filter_idle (SymbolDBViewSearch * search)
 188 {
 189         SymbolDBViewSearchPriv *priv;
 190         gchar *str;
 191
 192         g_return_val_if_fail (SYMBOL_IS_DB_VIEW_SEARCH (search), FALSE);
 193
 194         priv = search->priv;
 195
 196         str = (gchar *) gtk_entry_get_text (GTK_ENTRY (priv->entry));
 197         sdb_view_search_model_filter (search, str);
 198
 199         priv->idle_filter = 0;
 200         return FALSE;
 201 }
 202
 203
 204 static void
 205 sdb_view_search_on_entry_changed (GtkEntry * entry,
 206                                    SymbolDBViewSearch * search)
 207 {
 208         SymbolDBViewSearchPriv *priv;
 209
 210         g_return_if_fail (GTK_IS_ENTRY (entry));
 211         g_return_if_fail (SYMBOL_IS_DB_VIEW_SEARCH (search));
 212
 213         priv = search->priv;
 214
 215         DEBUG_PRINT("Entry changed");
 216
 217         if (!priv->idle_filter)
 218         {
 219                 priv->idle_filter =
 220                         g_idle_add ((GSourceFunc)
 221                                     sdb_view_search_filter_idle, search);
 222         }
 223 }
 224
 225 static void
 226 sdb_view_search_on_entry_activated (GtkEntry * entry,
 227                                      SymbolDBViewSearch * search)
 228 {
 229         SymbolDBViewSearchPriv *priv;
 230         gchar *str;
 231
 232         g_return_if_fail (GTK_IS_ENTRY (entry));
 233         g_return_if_fail (SYMBOL_IS_DB_VIEW_SEARCH (search));
 234
 235         priv = search->priv;
 236
 237         str = (gchar *) gtk_entry_get_text (GTK_ENTRY (priv->entry));
 238
 239         /* parse the string typed in the entry   */
 240         sdb_view_search_model_filter (search, str);
 241 }
 242
 243
 244
 245 static gboolean
 246 sdb_view_search_on_tree_row_activate (GtkTreeView * view,
 247                                        GtkTreePath * arg1,
 248                                        GtkTreeViewColumn * arg2,
 249                                        SymbolDBViewSearch * search)
 250 {
 251
 252         GtkTreeIter iter;
 253         SymbolDBViewSearchPriv *priv;
 254         gint line;
 255         gchar *file;
 256         GtkTreeSelection *selection;
 257
 258         priv = search->priv;
 259
 260         selection = gtk_tree_view_get_selection (view);
 261
 262         if (!gtk_tree_selection_get_selected (selection, NULL, &iter))
 263         {
 264                 DEBUG_PRINT
 265                         ("sdb_view_search_on_tree_row_activate: error getting selected row");
 266                 return FALSE;
 267         }
 268
 269         gtk_tree_model_get (GTK_TREE_MODEL (priv->model),
 270                                                 &iter,
 271                                                 COLUMN_LINE, &line,
 272                                                 COLUMN_FILE, &file,
 273                                                 -1);
 274
 275         DEBUG_PRINT ("sdb_view_search_on_tree_row_activate: file %s", file);
 276
 277         g_signal_emit (search, signals[SYM_SELECTED], 0, line, file);
 278
 279         g_free (file);
 280
 281         /* Always return FALSE so the tree view gets the event and can update
 282          * the selection etc.
 283          */
 284         return FALSE;
 285 }
 286
 287
 288
 289 static gboolean
 290 sdb_view_search_on_entry_key_press_event (GtkEntry * entry,
 291                                            GdkEventKey * event,
 292                                            SymbolDBViewSearch * search)
 293 {
 294         SymbolDBViewSearchPriv *priv;
 295
 296         priv = search->priv;
 297
 298         DEBUG_PRINT ("key_press event");
 299         if (event->keyval == GDK_Tab)
 300         {
 301                 DEBUG_PRINT ("tab key pressed");
 302                 if (event->state & GDK_CONTROL_MASK)
 303                 {
 304                         gtk_widget_grab_focus (priv->hitlist);
 305                 }
 306                 else
 307                 {
 308                         gtk_editable_set_position (GTK_EDITABLE (entry), -1);
 309                         gtk_editable_select_region (GTK_EDITABLE (entry), -1,
 310                                                     -1);
 311                 }
 312                 return TRUE;
 313         }
 314
 315         if (event->keyval == GDK_Return || event->keyval == GDK_KP_Enter)
 316         {
 317                 GtkTreeIter iter;
 318                 gchar *name;
 319                 gint line;
 320                 gchar *file;
 321
 322                 DEBUG_PRINT("enter key pressed: getting the first entry found");
 323
 324                 /* Get the first entry found. */
 325                 if (gtk_tree_model_get_iter_first
 326                     (GTK_TREE_MODEL (priv->model), &iter))
 327                 {
 328
 329                         gtk_tree_model_get (GTK_TREE_MODEL (priv->model),
 330                                                                 &iter,
 331                                                                 COLUMN_NAME, &name,
 332                                                                 COLUMN_LINE, &line,
 333                                                                 COLUMN_FILE, &file,
 334                                                                 -1);
 335
 336                         g_return_val_if_fail (&iter != NULL, FALSE);
 337
 338                         gtk_entry_set_text (GTK_ENTRY (entry), name);
 339
 340                         gtk_editable_set_position (GTK_EDITABLE (entry), -1);
 341                         gtk_editable_select_region (GTK_EDITABLE (entry), -1, -1);
 342
 343                         g_signal_emit (search, signals[SYM_SELECTED], 0, line, file);
 344
 345                         g_free (name);
 346                         g_free (file);
 347
 348                         return TRUE;
 349                 }
 350         }
 351         return FALSE;
 352 }
 353
 354 static gboolean
 355 sdb_view_search_complete_idle (SymbolDBViewSearch * search)
 356 {
 357         SymbolDBViewSearchPriv *priv;
 358         const gchar *text;
 359         gchar *completed = NULL;
 360         GList *list;
 361         gint text_length;
 362
 363         g_return_val_if_fail (SYMBOL_IS_DB_VIEW_SEARCH (search), FALSE);
 364
 365         priv = search->priv;
 366
 367         text = gtk_entry_get_text (GTK_ENTRY (priv->entry));
 368
 369         list = g_completion_complete (priv->completion, (gchar *) text,
 370                                                                   &completed);
 371
 372         if (completed)
 373         {
 374                 text_length = strlen (text);
 375                 gtk_entry_set_text (GTK_ENTRY (priv->entry), completed);
 376
 377                 gtk_editable_set_position (GTK_EDITABLE (priv->entry),
 378                                            text_length);
 379
 380                 gtk_editable_select_region (GTK_EDITABLE (priv->entry),
 381                                             text_length, -1);
 382                 g_free (completed);
 383         }
 384         priv->idle_complete = 0;
 385         return FALSE;
 386 }
 387
 388 static void
 389 sdb_view_search_on_entry_text_inserted (GtkEntry * entry,
 390                                          const gchar * text,
 391                                          gint length,
 392                                          gint * position,
 393                                          SymbolDBViewSearch * search)
 394 {
 395         SymbolDBViewSearchPriv *priv;
 396         g_return_if_fail (SYMBOL_IS_DB_VIEW_SEARCH (search));
 397
 398         priv = search->priv;
 399
 400         if (!priv->idle_complete)
 401         {
 402                 priv->idle_complete =
 403                         g_idle_add ((GSourceFunc)
 404                                     sdb_view_search_complete_idle, search);
 405         }
 406 }
 407
 408 static void
 409 sdb_view_search_init (SymbolDBViewSearch * search)
 410 {
 411
 412         SymbolDBViewSearchPriv *priv;
 413         GtkTreeViewColumn *column;
 414         GtkCellRenderer *renderer;
 415         GtkWidget *frame, *list_sw;
 416
 417
 418         /* allocate space for a SymbolDBViewSearchPriv class. */
 419         priv = g_new0 (SymbolDBViewSearchPriv, 1);
 420         search->priv = priv;
 421
 422         priv->idle_complete = 0;
 423         priv->idle_filter = 0;
 424
 425         priv->completion = g_completion_new (NULL);
 426
 427         priv->hitlist = gtk_tree_view_new ();
 428
 429
 430         priv->model = GTK_TREE_MODEL (gtk_tree_store_new (COLUMN_MAX, GDK_TYPE_PIXBUF,
 431                                     G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING, G_TYPE_INT));
 432
 433         gtk_tree_view_set_model (GTK_TREE_VIEW (priv->hitlist), GTK_TREE_MODEL (priv->model));
 434         gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->hitlist), FALSE);
 435
 436         gtk_tree_view_set_model (GTK_TREE_VIEW (priv->hitlist),
 437                                  GTK_TREE_MODEL (priv->model));
 438         gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (priv->hitlist), TRUE);
 439
 440         /* column initialization */
 441         column = gtk_tree_view_column_new ();
 442         gtk_tree_view_column_set_sizing (column,
 443                                          GTK_TREE_VIEW_COLUMN_AUTOSIZE);
 444
 445         renderer = gtk_cell_renderer_pixbuf_new ();
 446         gtk_tree_view_column_pack_start (column, renderer, FALSE);
 447         gtk_tree_view_column_add_attribute (column, renderer, "pixbuf",
 448                                             COLUMN_PIXBUF);
 449
 450         renderer = gtk_cell_renderer_text_new ();
 451         gtk_tree_view_column_pack_start (column, renderer, TRUE);
 452         gtk_tree_view_column_add_attribute (column, renderer, "text",
 453                                             COLUMN_NAME);
 454
 455         gtk_tree_view_append_column (GTK_TREE_VIEW (priv->hitlist), column);
 456         gtk_tree_view_set_expander_column (GTK_TREE_VIEW (priv->hitlist),
 457                                            column);
 458
 459         gtk_box_set_spacing (GTK_BOX (search), 2);
 460
 461         gtk_container_set_border_width (GTK_CONTAINER (search), 2);
 462
 463         /* creating entry box, where we'll type the keyword to look for */
 464         priv->entry = gtk_entry_new ();
 465
 466         /* set up some signals */
 467         g_signal_connect (priv->entry, "key_press_event",
 468                           G_CALLBACK (sdb_view_search_on_entry_key_press_event),
 469                           search);
 470
 471         g_signal_connect (priv->hitlist, "row_activated",
 472                           G_CALLBACK (sdb_view_search_on_tree_row_activate),
 473                           search);
 474
 475         g_signal_connect (priv->entry, "changed",
 476                           G_CALLBACK (sdb_view_search_on_entry_changed),
 477                           search);
 478
 479         g_signal_connect (priv->entry, "activate",
 480                           G_CALLBACK (sdb_view_search_on_entry_activated),
 481                           search);
 482
 483         g_signal_connect (priv->entry, "insert_text",
 484                           G_CALLBACK (sdb_view_search_on_entry_text_inserted), search);
 485
 486         gtk_box_pack_start (GTK_BOX (search), priv->entry, FALSE, FALSE, 0);
 487
 488         frame = gtk_frame_new (NULL);
 489         gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
 490
 491         list_sw = gtk_scrolled_window_new (NULL, NULL);
 492         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (list_sw),
 493                                         GTK_POLICY_AUTOMATIC,
 494                                         GTK_POLICY_AUTOMATIC);
 495
 496         gtk_container_add (GTK_CONTAINER (frame), list_sw);
 497         gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->hitlist), FALSE);
 498
 499         gtk_container_add (GTK_CONTAINER (list_sw), priv->hitlist);
 500         gtk_box_pack_end_defaults (GTK_BOX (search), frame);
 501
 502         gtk_widget_show_all (GTK_WIDGET (search));
 503 }
 504
 505 static void
 506 sdb_view_search_dispose (GObject * obj)
 507 {
 508         SymbolDBViewSearch *search = SYMBOL_DB_VIEW_SEARCH (obj);
 509         SymbolDBViewSearchPriv *priv = search->priv;
 510
 511         DEBUG_PRINT("Destroying symbolsearch");
 512
 513         /* anjuta_symbol_view's dispose should manage it's freeing */
 514         if (priv->model)
 515         {
 516                 symbol_db_view_search_clear(search);
 517                 g_object_unref (priv->model);
 518                 priv->model = NULL;
 519         }
 520
 521         if (priv->entry)
 522                 priv->entry = NULL;
 523
 524         if (priv->hitlist)
 525                 priv->hitlist = NULL;
 526
 527         G_OBJECT_CLASS (parent_class)->dispose (obj);
 528 }
 529
 530
 531 static void
 532 sdb_view_search_finalize (GObject * obj)
 533 {
 534         SymbolDBViewSearch *search = SYMBOL_DB_VIEW_SEARCH (obj);
 535         SymbolDBViewSearchPriv *priv = search->priv;
 536
 537         DEBUG_PRINT ("Finalizing symbolsearch widget");
 538
 539         g_list_foreach (priv->completion->items, (GFunc)g_free, NULL);
 540         g_completion_free (priv->completion);
 541         g_free (priv);
 542
 543         G_OBJECT_CLASS (parent_class)->finalize (obj);
 544 }
 545
 546
 547 static void
 548 sdb_view_search_class_init (SymbolDBViewSearchClass * klass)
 549 {
 550         GObjectClass *object_class;
 551
 552         object_class = G_OBJECT_CLASS (klass);
 553         parent_class = g_type_class_peek_parent (klass);
 554
 555         object_class->finalize = sdb_view_search_finalize;
 556         object_class->dispose = sdb_view_search_dispose;
 557
 558         signals[SYM_SELECTED] =
 559                 g_signal_new ("symbol-selected",
 560                               G_TYPE_FROM_CLASS (klass),
 561                               G_SIGNAL_RUN_LAST,
 562                               G_STRUCT_OFFSET (SymbolDBViewSearchClass,
 563                                                symbol_selected), NULL, NULL,
 564                                g_cclosure_marshal_VOID__UINT_POINTER, G_TYPE_NONE,
 565                               2, G_TYPE_INT, G_TYPE_STRING);
 566 }
 567
 568 /**
 569  * Cleaning issues. This function must be called when a project is removed.
 570  */
 571 void
 572 symbol_db_view_search_clear (SymbolDBViewSearch *search)
 573 {
 574         SymbolDBViewSearchPriv *priv;
 575         priv = search->priv;
 576
 577         /* set entry text to a NULL string */
 578         gtk_entry_set_text (GTK_ENTRY (priv->entry), "");
 579
 580         /* thrown away the g_completion words */
 581         g_list_foreach (priv->completion->items, (GFunc)g_free, NULL);
 582         g_completion_clear_items (priv->completion);
 583
 584         /* clean the gtk_tree_store */
 585         gtk_tree_store_clear (GTK_TREE_STORE(gtk_tree_view_get_model
 586                                 (GTK_TREE_VIEW (priv->hitlist))));
 587 }
 588
 589 GType
 590 sdb_view_search_get_type (void)
 591 {
 592         static GType type = 0;
 593
 594         if (!type)
 595         {
 596                 static const GTypeInfo info = {
 597                         sizeof (SymbolDBViewSearchClass),
 598                         NULL,
 599                         NULL,
 600                         (GClassInitFunc) sdb_view_search_class_init,
 601                         NULL,
 602                         NULL,
 603                         sizeof (SymbolDBViewSearch),
 604                         0,
 605                         (GInstanceInitFunc) sdb_view_search_init,
 606                 };
 607
 608                 type = g_type_register_static (GTK_TYPE_VBOX,
 609                                                "SymbolDBViewSearch", &info, 0);
 610         }
 611         return type;
 612 }
 613
 614 GtkWidget *
 615 symbol_db_view_search_new (SymbolDBEngine *dbe)
 616 {
 617         SymbolDBViewSearch *search;
 618         SymbolDBViewSearchPriv *priv;
 619
 620         /* create a new object   */
 621         search = g_object_new (SYMBOL_TYPE_DB_VIEW_SEARCH, NULL);
 622
 623         /* store the engine pointer */
 624         priv = search->priv;
 625         priv->sdbe = dbe;
 626
 627         return GTK_WIDGET (search);
 628 }
 629