view.c

   1 /*
   2  * (c) 2010 Cyrill Gorcunov, gorcunov@gmail.com
   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 as published by
   6  * the Free Software Foundation; either version 2 of the License, or (at
   7  * your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  17  *
  18  */
  19
  20 #include <unistd.h>
  21 #include <stdio.h>
  22 #include <stddef.h>
  23 #include <stdlib.h>
  24 #include <stdarg.h>
  25 #include <string.h>
  26 #include <errno.h>
  27 #include <limits.h>
  28 #include <sys/param.h>
  29 #include <sys/types.h>
  30 #include <gtk/gtk.h>
  31 #include <gio/gio.h>
  32
  33 #include "view.h"
  34
  35 #include "backend-proto.h"
  36 #include "id-utils.h"
  37 #include "cscope.h"
  38 #include "tags.h"
  39
  40 #include "notebook.h"
  41 #include "sourceview.h"
  42 #include "queries.h"
  43
  44 #include "util.h"
  45 #include "list.h"
  46
  47 static void cb_notebook_page_switched(struct notebook_page *page)
  48 {
  49         struct source_view *source_view;
  50
  51         if (!(page->status & NB_STATUS_SOURCE))
  52                 return;
  53
  54         source_view = page->private;
  55
  56         gscope_info.title_buf[0] = 0;
  57         strlcat(gscope_info.title_buf, source_view->file_path, sizeof(gscope_info.title_buf));
  58
  59         gtk_window_set_title(GTK_WINDOW(gscope_info.main_window), gscope_info.title_buf);
  60 }
  61
  62 void read_file_into_notebook(struct gscope_info *info, char *filename)
  63 {
  64         struct notebook_page *page;
  65         struct source_view *source_view;
  66
  67         source_view = source_view_create(filename);
  68         DIE_IF(!source_view);
  69
  70         page = notebook_create_page(info->notebook_source, g_path_get_basename(filename),
  71                         strlen(g_path_get_basename(filename)), NB_STATUS_SOURCE);
  72         notebook_page_child_attach(page, source_view->me, source_view, cb_notebook_page_switched, source_view->delete_hook);
  73         notebook_activate_page(info->notebook_source, page);
  74         gtk_widget_show_all(info->main_window);
  75 }
  76
  77 void do_cscope_query(struct gscope_info *info, char *query_name, int type, int nocase)
  78 {
  79         struct notebook_page *page;
  80         struct list_head *head;
  81         struct query_result query_result;
  82         struct query_view *query_view;
  83
  84         struct backend_proto_query_params params = {
  85                 .u.cscope.name          = query_name,
  86                 .u.cscope.type          = type,
  87                 .u.cscope.nocase        = nocase,
  88         };
  89
  90         query_result.proto = backend_proto_find(BACKEND_PROTO_CSCOPE);
  91         DIE_IF(!query_result.proto);
  92
  93         head = query_result.proto->backend_proto_query(&params);
  94         if (!head || list_empty(head))
  95                 return;
  96         query_result.head = head;
  97
  98         /*
  99          * A special case -- single entry
 100          */
 101         if (list_is_singular(head)) {
 102                 struct backend_proto_item item;
 103                 struct list_head *t;
 104                 list_for_each(t, head)
 105                         query_result.proto->backend_proto_get(t, &item);
 106                 query_switch_or_read_source_into_notebook(info, &item);
 107         } else {
 108                 query_view = query_view_create(&query_result);
 109                 DIE_IF(!query_view);
 110
 111                 page = notebook_create_page(info->notebook_query, query_name, strlen(query_name), NB_STATUS_QUERY);
 112                 notebook_page_child_attach(page, query_view->me, query_view, NULL, query_view_destroy);
 113
 114                 gtk_widget_show_all(info->main_window);
 115         }
 116 }
 117
 118 void do_id_utils_query(struct gscope_info *info, char *query_name)
 119 {
 120         struct notebook_page *page;
 121         struct list_head *head;
 122         struct query_result query_result;
 123         struct query_view *query_view;
 124
 125         struct backend_proto_query_params params = {
 126                 .u.idutils.name         = query_name,
 127         };
 128
 129         query_result.proto = backend_proto_find(BACKEND_PROTO_ID_UTILS);
 130         DIE_IF(!query_result.proto);
 131
 132         head = query_result.proto->backend_proto_query(&params);
 133         if (!head || list_empty(head))
 134                 return;
 135         query_result.head = head;
 136
 137         query_view = query_view_create(&query_result);
 138         DIE_IF(!query_view);
 139
 140         page = notebook_create_page(info->notebook_query, query_name, 8, NB_STATUS_QUERY);
 141         notebook_page_child_attach(page, query_view->me, query_view, NULL, query_view_destroy);
 142
 143         gtk_widget_show_all(info->main_window);
 144 }
 145
 146 struct cscope_cb_params {
 147         GtkWidget *entry;
 148         unsigned int opcode;
 149 };
 150
 151 static void cb_response(GtkWidget *w, gint resp_code, gpointer param)
 152 {
 153         if (resp_code == GTK_RESPONSE_OK) {
 154                 GtkWidget *entry = ((struct cscope_cb_params *)param)->entry;
 155                 unsigned int opcode = ((struct cscope_cb_params *)param)->opcode;
 156                 do_cscope_query(&gscope_info, (char *)gtk_entry_get_text(GTK_ENTRY(entry)),
 157                                 opcode, 0);
 158         }
 159         gtk_widget_destroy(w);
 160 }
 161
 162 static struct cscope_cb_params params;
 163
 164 void do_cscope_query_dialog(gpointer opcode)
 165 {
 166         GtkWidget *window;
 167         GtkWidget *vbox;
 168         GtkWidget *label;
 169         GtkWidget *entry;
 170         GtkEntryBuffer *buffer;
 171         const char *desc = cscope_param_desc((unsigned int)(unsigned long)opcode);
 172
 173         if (!desc)
 174                 return;
 175
 176         window = gtk_dialog_new_with_buttons(desc, GTK_WINDOW(gscope_info.main_window), 0,
 177                                         GTK_STOCK_OK, GTK_RESPONSE_OK,
 178                                         GTK_STOCK_CANCEL, GTK_RESPONSE_NONE,
 179                                         NULL);
 180
 181         gtk_window_set_destroy_with_parent(GTK_WINDOW(window), TRUE);
 182         gtk_dialog_set_default_response(GTK_DIALOG(window), GTK_RESPONSE_OK);
 183         gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
 184
 185         vbox = gtk_vbox_new(FALSE, 5);
 186         gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->vbox), vbox, TRUE, TRUE, 0);
 187         gtk_container_set_border_width(GTK_CONTAINER(vbox), 5);
 188
 189         label = gtk_label_new(NULL);
 190         gtk_label_set_markup(GTK_LABEL(label), "Enter the symbol");
 191         gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
 192
 193         /* Create a buffer */
 194         buffer = gtk_entry_buffer_new(NULL, 0);
 195
 196         /* Create our first entry */
 197         entry = gtk_entry_new_with_buffer(buffer);
 198         gtk_box_pack_start(GTK_BOX(vbox), entry, FALSE, FALSE, 0);
 199         gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE);
 200
 201         params.opcode   = (unsigned int)(unsigned long)opcode;
 202         params.entry    = entry;
 203
 204         g_signal_connect(window, "response", G_CALLBACK(cb_response), &params);
 205         g_signal_connect(window, "destroy", G_CALLBACK(gtk_widget_destroyed), &window);
 206
 207         g_object_unref(buffer);
 208
 209         gtk_widget_show_all(window);
 210 }
 211
 212 void do_cscope_rebuild(gpointer pointer)
 213 {
 214         struct backend_proto *proto = backend_proto_find(BACKEND_PROTO_CSCOPE);
 215         DIE_IF(!proto);
 216
 217         proto->backend_proto_refresh();
 218 }