browser.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <sys/types.h>
   4 #include <sys/stat.h>
   5 #include <fcntl.h>
   6 #include <string.h>
   7
   8 #include <gtk/gtk.h>
   9 #include <gtk/gtkx.h>
  10 #include <gdk/gdkkeysyms.h>
  11 #include <gio/gio.h>
  12 #include <webkit2/webkit2.h>
  13
  14
  15 static void client_destroy(GtkWidget *, gpointer);
  16 static gboolean client_destroy_request(WebKitWebView *, gpointer);
  17 static WebKitWebView *client_new(const gchar *);
  18 static WebKitWebView *client_new_request(WebKitWebView *, WebKitNavigationAction *,
  19                                          gpointer);
  20 static void cooperation_setup(void);
  21 static void changed_download_progress(GObject *, GParamSpec *, gpointer);
  22 static void changed_load_progress(GObject *, GParamSpec *, gpointer);
  23 static void changed_title(GObject *, GParamSpec *, gpointer);
  24 static void changed_uri(GObject *, GParamSpec *, gpointer);
  25 static gboolean decide_policy(WebKitWebView *, WebKitPolicyDecision *,
  26                               WebKitPolicyDecisionType, gpointer);
  27 static gboolean download_handle(WebKitDownload *, gchar *, gpointer);
  28 static void download_handle_start(WebKitWebView *, WebKitDownload *, gpointer);
  29 static void downloadmanager_cancel(GtkToolButton *, gpointer data);
  30 static void downloadmanager_setup(void);
  31 static gchar *ensure_uri_scheme(const gchar *);
  32 static void grab_environment_configuration(void);
  33 static void hover_web_view(WebKitWebView *, WebKitHitTestResult *, guint, gpointer);
  34 static gboolean key_downloadmanager(GtkWidget *, GdkEvent *, gpointer);
  35 static gboolean key_location(GtkWidget *, GdkEvent *, gpointer);
  36 static gboolean key_web_view(GtkWidget *, GdkEvent *, gpointer);
  37 static void keywords_load(void);
  38 static gboolean keywords_try_search(WebKitWebView *, const gchar *);
  39 static gboolean remote_msg(GIOChannel *, GIOCondition, gpointer);
  40 static void search(gpointer, gint);
  41 static Window tabbed_launch(void);
  42 static void usage(void);
  43
  44
  45 struct Client
  46 {
  47         gchar *hover_uri;
  48         GtkWidget *location;
  49         GtkWidget *progress;
  50         GtkWidget *scroll;
  51         GtkWidget *top_box;
  52         GtkWidget *vbox;
  53         GtkWidget *web_view;
  54         GtkWidget *win;
  55 };
  56
  57 struct DownloadManager
  58 {
  59         GtkWidget *scroll;
  60         GtkWidget *toolbar;
  61         GtkWidget *win;
  62 } dm;
  63
  64
  65 static const gchar *accepted_language[2] = { NULL, NULL };
  66 static gint clients = 0;
  67 static gboolean cooperative_alone = TRUE;
  68 static gboolean cooperative_instances = TRUE;
  69 static int cooperative_pipe_fp = 0;
  70 static gchar *download_dir = "/tmp";
  71 static Window embed = 0;
  72 static gchar *fifo_suffix = "main";
  73 static gdouble global_zoom = 1.0;
  74 static gchar *home_uri = "about:blank";
  75 static gboolean initial_wc_setup_done = FALSE;
  76 static GHashTable *keywords = NULL;
  77 static gchar *search_text = NULL;
  78 static gboolean tabbed_automagic = TRUE;
  79 static gchar *user_agent = NULL;
  80 static gchar *web_extensions_dir = NULL;
  81
  82
  83 void
  84 client_destroy(GtkWidget *obj, gpointer data)
  85 {
  86         struct Client *c = (struct Client *)data;
  87
  88         g_signal_handlers_disconnect_by_func(G_OBJECT(c->web_view),
  89                                              changed_load_progress, c);
  90
  91         free(c);
  92         clients--;
  93
  94         if (clients == 0)
  95                 gtk_main_quit();
  96 }
  97
  98 gboolean
  99 client_destroy_request(WebKitWebView *web_view, gpointer data)
 100 {
 101         struct Client *c = (struct Client *)data;
 102
 103         gtk_widget_destroy(c->win);
 104
 105         return TRUE;
 106 }
 107
 108 WebKitWebView *
 109 client_new(const gchar *uri)
 110 {
 111         struct Client *c;
 112         WebKitWebContext *wc;
 113         gchar *f;
 114
 115         if (uri != NULL && cooperative_instances && !cooperative_alone)
 116         {
 117                 write(cooperative_pipe_fp, uri, strlen(uri));
 118                 write(cooperative_pipe_fp, "\n", 1);
 119                 return NULL;
 120         }
 121
 122         c = malloc(sizeof(struct Client));
 123         if (!c)
 124         {
 125                 fprintf(stderr, __NAME__": fatal: malloc failed\n");
 126                 exit(EXIT_FAILURE);
 127         }
 128
 129         c->hover_uri = NULL;
 130         c->win = NULL;
 131         if (embed != 0)
 132         {
 133                 c->win = gtk_plug_new(embed);
 134                 if (!gtk_plug_get_embedded(GTK_PLUG(c->win)))
 135                 {
 136                         fprintf(stderr, __NAME__": Can't plug-in to XID %ld.\n", embed);
 137                         gtk_widget_destroy(c->win);
 138                         c->win = NULL;
 139                         embed = 0;
 140                 }
 141         }
 142
 143         if (c->win == NULL)
 144         {
 145                 c->win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 146                 gtk_window_set_wmclass(GTK_WINDOW(c->win), __NAME__, __NAME_CAPITALIZED__);
 147         }
 148
 149         g_signal_connect(G_OBJECT(c->win), "destroy", G_CALLBACK(client_destroy), c);
 150         gtk_window_set_title(GTK_WINDOW(c->win), __NAME__);
 151
 152         c->web_view = webkit_web_view_new();
 153         wc = webkit_web_view_get_context(WEBKIT_WEB_VIEW(c->web_view));
 154
 155         webkit_web_view_set_zoom_level(WEBKIT_WEB_VIEW(c->web_view), global_zoom);
 156         g_signal_connect(G_OBJECT(c->web_view), "notify::title",
 157                          G_CALLBACK(changed_title), c);
 158         g_signal_connect(G_OBJECT(c->web_view), "notify::uri",
 159                          G_CALLBACK(changed_uri), c);
 160         g_signal_connect(G_OBJECT(c->web_view), "notify::estimated-load-progress",
 161                          G_CALLBACK(changed_load_progress), c);
 162         g_signal_connect(G_OBJECT(c->web_view), "create",
 163                          G_CALLBACK(client_new_request), NULL);
 164         g_signal_connect(G_OBJECT(c->web_view), "close",
 165                          G_CALLBACK(client_destroy_request), c);
 166         g_signal_connect(G_OBJECT(c->web_view), "decide-policy",
 167                          G_CALLBACK(decide_policy), NULL);
 168         g_signal_connect(G_OBJECT(c->web_view), "key-press-event",
 169                          G_CALLBACK(key_web_view), c);
 170         g_signal_connect(G_OBJECT(c->web_view), "button-press-event",
 171                          G_CALLBACK(key_web_view), c);
 172         g_signal_connect(G_OBJECT(c->web_view), "scroll-event",
 173                          G_CALLBACK(key_web_view), c);
 174         g_signal_connect(G_OBJECT(c->web_view), "mouse-target-changed",
 175                          G_CALLBACK(hover_web_view), c);
 176
 177         if (!initial_wc_setup_done)
 178         {
 179                 if (accepted_language[0] != NULL)
 180                         webkit_web_context_set_preferred_languages(wc, accepted_language);
 181
 182                 g_signal_connect(G_OBJECT(wc), "download-started",
 183                                  G_CALLBACK(download_handle_start), NULL);
 184
 185                 initial_wc_setup_done = TRUE;
 186         }
 187
 188         if (user_agent != NULL)
 189                 g_object_set(G_OBJECT(webkit_web_view_get_settings(WEBKIT_WEB_VIEW(c->web_view))),
 190                              "user-agent", user_agent, NULL);
 191
 192         c->scroll = gtk_scrolled_window_new(NULL, NULL);
 193
 194         gtk_container_add(GTK_CONTAINER(c->scroll), c->web_view);
 195
 196         c->location = gtk_entry_new();
 197         g_signal_connect(G_OBJECT(c->location), "key-press-event",
 198                          G_CALLBACK(key_location), c);
 199
 200         /* XXX Progress bars don't work/look as intended anymore. Level bars
 201          * are a dirty workaround (kind of). */
 202         c->progress = gtk_level_bar_new();
 203         gtk_level_bar_set_value(GTK_LEVEL_BAR(c->progress), 0);
 204         gtk_widget_set_size_request(c->progress, 100, -1);
 205
 206         c->top_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
 207         gtk_box_pack_start(GTK_BOX(c->top_box), c->location, TRUE, TRUE, 2);
 208         gtk_box_pack_start(GTK_BOX(c->top_box), c->progress, FALSE, FALSE, 2);
 209
 210         c->vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
 211         gtk_box_pack_start(GTK_BOX(c->vbox), c->top_box, FALSE, FALSE, 2);
 212         gtk_box_pack_start(GTK_BOX(c->vbox), c->scroll, TRUE, TRUE, 2);
 213
 214         gtk_container_add(GTK_CONTAINER(c->win), c->vbox);
 215
 216         gtk_widget_grab_focus(c->web_view);
 217         gtk_widget_show_all(c->win);
 218
 219         if (uri != NULL)
 220         {
 221                 f = ensure_uri_scheme(uri);
 222                 webkit_web_view_load_uri(WEBKIT_WEB_VIEW(c->web_view), f);
 223                 g_free(f);
 224         }
 225
 226         clients++;
 227
 228         return WEBKIT_WEB_VIEW(c->web_view);
 229 }
 230
 231 WebKitWebView *
 232 client_new_request(WebKitWebView *web_view,
 233                    WebKitNavigationAction *navigation_action, gpointer data)
 234 {
 235         return client_new(NULL);
 236 }
 237
 238 void
 239 cooperation_setup(void)
 240 {
 241         GIOChannel *towatch;
 242         gchar *fifofilename, *fifopath;
 243
 244         fifofilename = g_strdup_printf("%s-%s", __NAME__".fifo", fifo_suffix);
 245         fifopath = g_build_filename(g_get_user_runtime_dir(), fifofilename, NULL);
 246         g_free(fifofilename);
 247
 248         if (!g_file_test(fifopath, G_FILE_TEST_EXISTS))
 249                 mkfifo(fifopath, 0600);
 250
 251         cooperative_pipe_fp = open(fifopath, O_WRONLY | O_NONBLOCK);
 252         if (!cooperative_pipe_fp)
 253         {
 254                 fprintf(stderr, __NAME__": Can't open FIFO at all.\n");
 255         }
 256         else
 257         {
 258                 if (write(cooperative_pipe_fp, "", 0) == -1)
 259                 {
 260                         /* Could not do an empty write to the FIFO which means there's
 261                          * no one listening. */
 262                         close(cooperative_pipe_fp);
 263                         towatch = g_io_channel_new_file(fifopath, "r+", NULL);
 264                         g_io_add_watch(towatch, G_IO_IN, (GIOFunc)remote_msg, NULL);
 265                 }
 266                 else
 267                         cooperative_alone = FALSE;
 268         }
 269
 270         g_free(fifopath);
 271 }
 272
 273 void
 274 changed_download_progress(GObject *obj, GParamSpec *pspec, gpointer data)
 275 {
 276         WebKitDownload *download = WEBKIT_DOWNLOAD(obj);
 277         WebKitURIResponse *resp;
 278         GtkToolItem *tb = GTK_TOOL_ITEM(data);
 279         gdouble p, size_mb;
 280         const gchar *uri;
 281         gchar *t, *filename, *base;
 282
 283         p = webkit_download_get_estimated_progress(download) * 100;
 284         resp = webkit_download_get_response(download);
 285         size_mb = webkit_uri_response_get_content_length(resp) / 1e6;
 286
 287         uri = webkit_download_get_destination(download);
 288         filename = g_filename_from_uri(uri, NULL, NULL);
 289         if (filename == NULL)
 290         {
 291                 /* This really should not happen because WebKit uses that URI to
 292                  * write to a file... */
 293                 fprintf(stderr, __NAME__": Could not construct file name from URI!\n");
 294                 t = g_strdup_printf("%s (%.0f%% of %.1f MB)",
 295                                     webkit_uri_response_get_uri(resp), p, size_mb);
 296         }
 297         else
 298         {
 299                 base = g_path_get_basename(filename);
 300                 t = g_strdup_printf("%s (%.0f%% of %.1f MB)", base, p, size_mb);
 301                 g_free(filename);
 302                 g_free(base);
 303         }
 304         gtk_tool_button_set_label(GTK_TOOL_BUTTON(tb), t);
 305         g_free(t);
 306 }
 307
 308 void
 309 changed_load_progress(GObject *obj, GParamSpec *pspec, gpointer data)
 310 {
 311         struct Client *c = (struct Client *)data;
 312         gdouble p;
 313
 314         p = webkit_web_view_get_estimated_load_progress(WEBKIT_WEB_VIEW(c->web_view));
 315         gtk_level_bar_set_value(GTK_LEVEL_BAR(c->progress), p);
 316 }
 317
 318 void
 319 changed_title(GObject *obj, GParamSpec *pspec, gpointer data)
 320 {
 321         const gchar *t;
 322         struct Client *c = (struct Client *)data;
 323
 324         t = webkit_web_view_get_title(WEBKIT_WEB_VIEW(c->web_view));
 325         gtk_window_set_title(GTK_WINDOW(c->win), (t == NULL ? __NAME__ : t));
 326 }
 327
 328 void
 329 changed_uri(GObject *obj, GParamSpec *pspec, gpointer data)
 330 {
 331         const gchar *t;
 332         struct Client *c = (struct Client *)data;
 333
 334         t = webkit_web_view_get_uri(WEBKIT_WEB_VIEW(c->web_view));
 335         gtk_entry_set_text(GTK_ENTRY(c->location), (t == NULL ? __NAME__ : t));
 336 }
 337
 338 gboolean
 339 decide_policy(WebKitWebView *web_view, WebKitPolicyDecision *decision,
 340               WebKitPolicyDecisionType type, gpointer data)
 341 {
 342         WebKitResponsePolicyDecision *r;
 343
 344         switch (type)
 345         {
 346                 case WEBKIT_POLICY_DECISION_TYPE_RESPONSE:
 347                         r = WEBKIT_RESPONSE_POLICY_DECISION(decision);
 348                         if (!webkit_response_policy_decision_is_mime_type_supported(r))
 349                                 webkit_policy_decision_download(decision);
 350                         else
 351                                 webkit_policy_decision_use(decision);
 352                         break;
 353                 default:
 354                         /* Use whatever default there is. */
 355                         return FALSE;
 356         }
 357         return TRUE;
 358 }
 359
 360 void
 361 download_handle_start(WebKitWebView *web_view, WebKitDownload *download,
 362                       gpointer data)
 363 {
 364         g_signal_connect(G_OBJECT(download), "decide-destination",
 365                          G_CALLBACK(download_handle), data);
 366 }
 367
 368 gboolean
 369 download_handle(WebKitDownload *download, gchar *suggested_filename, gpointer data)
 370 {
 371         gchar *path, *path2 = NULL, *uri;
 372         GtkToolItem *tb;
 373         int suffix = 1;
 374
 375         path = g_build_filename(download_dir, suggested_filename, NULL);
 376         path2 = g_strdup(path);
 377         while (g_file_test(path2, G_FILE_TEST_EXISTS) && suffix < 1000)
 378         {
 379                 g_free(path2);
 380
 381                 path2 = g_strdup_printf("%s.%d", path, suffix);
 382                 suffix++;
 383         }
 384
 385         if (suffix == 1000)
 386         {
 387                 fprintf(stderr, __NAME__": Suffix reached limit for download.\n");
 388                 webkit_download_cancel(download);
 389         }
 390         else
 391         {
 392                 uri = g_filename_to_uri(path2, NULL, NULL);
 393                 webkit_download_set_destination(download, uri);
 394                 g_free(uri);
 395
 396                 tb = gtk_tool_button_new(NULL, NULL);
 397                 gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(tb), "gtk-delete");
 398                 gtk_tool_button_set_label(GTK_TOOL_BUTTON(tb), suggested_filename);
 399                 gtk_toolbar_insert(GTK_TOOLBAR(dm.toolbar), tb, 0);
 400                 gtk_widget_show_all(dm.toolbar);
 401
 402                 g_signal_connect(G_OBJECT(download), "notify::estimated-progress",
 403                                  G_CALLBACK(changed_download_progress), tb);
 404
 405                 g_object_ref(download);
 406                 g_signal_connect(G_OBJECT(tb), "clicked",
 407                                  G_CALLBACK(downloadmanager_cancel), download);
 408         }
 409
 410         g_free(path);
 411         g_free(path2);
 412
 413         /* Propagate -- to whom it may concern. */
 414         return FALSE;
 415 }
 416
 417 void
 418 downloadmanager_cancel(GtkToolButton *tb, gpointer data)
 419 {
 420         WebKitDownload *download = WEBKIT_DOWNLOAD(data);
 421
 422         webkit_download_cancel(download);
 423         g_object_unref(download);
 424
 425         gtk_widget_destroy(GTK_WIDGET(tb));
 426 }
 427
 428 void
 429 downloadmanager_setup(void)
 430 {
 431         dm.win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 432         gtk_window_set_type_hint(GTK_WINDOW(dm.win), GDK_WINDOW_TYPE_HINT_DIALOG);
 433         gtk_window_set_default_size(GTK_WINDOW(dm.win), 500, 250);
 434         gtk_window_set_title(GTK_WINDOW(dm.win), __NAME__" - Download Manager");
 435         g_signal_connect(G_OBJECT(dm.win), "delete-event",
 436                          G_CALLBACK(gtk_widget_hide_on_delete), NULL);
 437         g_signal_connect(G_OBJECT(dm.win), "key-press-event",
 438                          G_CALLBACK(key_downloadmanager), NULL);
 439
 440         dm.toolbar = gtk_toolbar_new();
 441         gtk_orientable_set_orientation(GTK_ORIENTABLE(dm.toolbar),
 442                                        GTK_ORIENTATION_VERTICAL);
 443         gtk_toolbar_set_style(GTK_TOOLBAR(dm.toolbar), GTK_TOOLBAR_BOTH_HORIZ);
 444         gtk_toolbar_set_show_arrow(GTK_TOOLBAR(dm.toolbar), FALSE);
 445
 446         dm.scroll = gtk_scrolled_window_new(NULL, NULL);
 447         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(dm.scroll),
 448                                        GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 449         gtk_container_add(GTK_CONTAINER(dm.scroll), dm.toolbar);
 450
 451         gtk_container_add(GTK_CONTAINER(dm.win), dm.scroll);
 452 }
 453
 454 gchar *
 455 ensure_uri_scheme(const gchar *t)
 456 {
 457         gchar *f;
 458
 459         f = g_ascii_strdown(t, -1);
 460         if (!g_str_has_prefix(f, "http:") &&
 461             !g_str_has_prefix(f, "https:") &&
 462             !g_str_has_prefix(f, "file:") &&
 463             !g_str_has_prefix(f, "about:"))
 464         {
 465                 g_free(f);
 466                 f = g_strdup_printf("http://%s", t);
 467                 return f;
 468         }
 469         else
 470                 return g_strdup(t);
 471 }
 472
 473 void
 474 grab_environment_configuration(void)
 475 {
 476         const gchar *e;
 477
 478         e = g_getenv(__NAME_UPPERCASE__"_ACCEPTED_LANGUAGE");
 479         if (e != NULL)
 480                 accepted_language[0] = g_strdup(e);
 481
 482         e = g_getenv(__NAME_UPPERCASE__"_DOWNLOAD_DIR");
 483         if (e != NULL)
 484                 download_dir = g_strdup(e);
 485
 486         e = g_getenv(__NAME_UPPERCASE__"_FIFO_SUFFIX");
 487         if (e != NULL)
 488                 fifo_suffix = g_strdup(e);
 489
 490         e = g_getenv(__NAME_UPPERCASE__"_HOME_URI");
 491         if (e != NULL)
 492                 home_uri = g_strdup(e);
 493
 494         e = g_getenv(__NAME_UPPERCASE__"_USER_AGENT");
 495         if (e != NULL)
 496                 user_agent = g_strdup(e);
 497
 498         e = g_getenv(__NAME_UPPERCASE__"_WEB_EXTENSIONS_DIR");
 499         if (e != NULL)
 500                 web_extensions_dir = g_strdup(e);
 501         else
 502                 web_extensions_dir = g_build_filename(g_get_user_data_dir(), __NAME__,
 503                                                       "web_extensions", NULL);
 504
 505         e = g_getenv(__NAME_UPPERCASE__"_ZOOM");
 506         if (e != NULL)
 507                 global_zoom = atof(e);
 508 }
 509
 510 void
 511 hover_web_view(WebKitWebView *web_view, WebKitHitTestResult *ht, guint modifiers,
 512                gpointer data)
 513 {
 514         struct Client *c = (struct Client *)data;
 515
 516         if (!gtk_widget_is_focus(c->location))
 517         {
 518                 if (webkit_hit_test_result_context_is_link(ht))
 519                 {
 520                         gtk_entry_set_text(GTK_ENTRY(c->location),
 521                                            webkit_hit_test_result_get_link_uri(ht));
 522
 523                         if (c->hover_uri != NULL)
 524                                 g_free(c->hover_uri);
 525                         c->hover_uri = g_strdup(webkit_hit_test_result_get_link_uri(ht));
 526                 }
 527                 else
 528                 {
 529                         gtk_entry_set_text(GTK_ENTRY(c->location),
 530                                            webkit_web_view_get_uri(WEBKIT_WEB_VIEW(c->web_view)));
 531
 532                         if (c->hover_uri != NULL)
 533                                 g_free(c->hover_uri);
 534                         c->hover_uri = NULL;
 535                 }
 536         }
 537 }
 538
 539 gboolean
 540 key_downloadmanager(GtkWidget *widget, GdkEvent *event, gpointer data)
 541 {
 542         if (event->type == GDK_KEY_PRESS)
 543         {
 544                 if (((GdkEventKey *)event)->state & GDK_MOD1_MASK)
 545                 {
 546                         switch (((GdkEventKey *)event)->keyval)
 547                         {
 548                                 case GDK_KEY_d:  /* close window (left hand) */
 549                                         gtk_widget_hide(dm.win);
 550                                         return TRUE;
 551                         }
 552                 }
 553         }
 554
 555         return FALSE;
 556 }
 557
 558 gboolean
 559 key_location(GtkWidget *widget, GdkEvent *event, gpointer data)
 560 {
 561         struct Client *c = (struct Client *)data;
 562         const gchar *t;
 563         gchar *f;
 564
 565         if (event->type == GDK_KEY_PRESS)
 566         {
 567                 if (((GdkEventKey *)event)->state & GDK_MOD1_MASK)
 568                 {
 569                         switch (((GdkEventKey *)event)->keyval)
 570                         {
 571                                 case GDK_KEY_q:  /* close window (left hand) */
 572                                         gtk_widget_destroy(c->win);
 573                                         return TRUE;
 574                                 case GDK_KEY_d:  /* download manager (left hand) */
 575                                         gtk_widget_show_all(dm.win);
 576                                         return TRUE;
 577                                 case GDK_KEY_r:  /* reload (left hand) */
 578                                         webkit_web_view_reload_bypass_cache(WEBKIT_WEB_VIEW(
 579                                                                             c->web_view));
 580                                         return TRUE;
 581                                 case GDK_KEY_k:  /* initiate search (BOTH hands) */
 582                                         gtk_entry_set_text(GTK_ENTRY(c->location), "/");
 583                                         gtk_editable_set_position(GTK_EDITABLE(c->location), -1);
 584                                         return TRUE;
 585                         }
 586                 }
 587                 else
 588                 {
 589                         switch (((GdkEventKey *)event)->keyval)
 590                         {
 591                                 case GDK_KEY_Return:
 592                                         gtk_widget_grab_focus(c->web_view);
 593                                         t = gtk_entry_get_text(GTK_ENTRY(c->location));
 594                                         if (t != NULL && t[0] == '/')
 595                                         {
 596                                                 if (search_text != NULL)
 597                                                         g_free(search_text);
 598                                                 search_text = g_strdup(t + 1);  /* XXX whacky */
 599                                                 search(c, 0);
 600                                         }
 601                                         else if (!keywords_try_search(WEBKIT_WEB_VIEW(c->web_view), t))
 602                                         {
 603                                                 f = ensure_uri_scheme(t);
 604                                                 webkit_web_view_load_uri(WEBKIT_WEB_VIEW(c->web_view), f);
 605                                                 g_free(f);
 606                                         }
 607                                         return TRUE;
 608                                 case GDK_KEY_Escape:
 609                                         t = webkit_web_view_get_uri(WEBKIT_WEB_VIEW(c->web_view));
 610                                         gtk_entry_set_text(GTK_ENTRY(c->location),
 611                                                            (t == NULL ? __NAME__ : t));
 612                                         return TRUE;
 613                         }
 614                 }
 615         }
 616
 617         return FALSE;
 618 }
 619
 620 gboolean
 621 key_web_view(GtkWidget *widget, GdkEvent *event, gpointer data)
 622 {
 623         struct Client *c = (struct Client *)data;
 624         gdouble dx, dy;
 625         gchar *f;
 626         gfloat z;
 627
 628         if (event->type == GDK_KEY_PRESS)
 629         {
 630                 if (((GdkEventKey *)event)->state & GDK_MOD1_MASK)
 631                 {
 632                         switch (((GdkEventKey *)event)->keyval)
 633                         {
 634                                 case GDK_KEY_q:  /* close window (left hand) */
 635                                         gtk_widget_destroy(c->win);
 636                                         return TRUE;
 637                                 case GDK_KEY_w:  /* home (left hand) */
 638                                         f = ensure_uri_scheme(home_uri);
 639                                         webkit_web_view_load_uri(WEBKIT_WEB_VIEW(c->web_view), f);
 640                                         g_free(f);
 641                                         return TRUE;
 642                                 case GDK_KEY_e:  /* new tab (left hand) */
 643                                         f = ensure_uri_scheme(home_uri);
 644                                         client_new(f);
 645                                         g_free(f);
 646                                         return TRUE;
 647                                 case GDK_KEY_r:  /* reload (left hand) */
 648                                         webkit_web_view_reload_bypass_cache(WEBKIT_WEB_VIEW(
 649                                                                             c->web_view));
 650                                         return TRUE;
 651                                 case GDK_KEY_d:  /* download manager (left hand) */
 652                                         gtk_widget_show_all(dm.win);
 653                                         return TRUE;
 654                                 case GDK_KEY_2:  /* search forward (left hand) */
 655                                 case GDK_KEY_n:  /* search forward (maybe both hands) */
 656                                         search(c, 1);
 657                                         return TRUE;
 658                                 case GDK_KEY_3:  /* search backward (left hand) */
 659                                         search(c, -1);
 660                                         return TRUE;
 661                                 case GDK_KEY_l:  /* location (BOTH hands) */
 662                                         gtk_widget_grab_focus(c->location);
 663                                         return TRUE;
 664                                 case GDK_KEY_k:  /* initiate search (BOTH hands) */
 665                                         gtk_widget_grab_focus(c->location);
 666                                         gtk_entry_set_text(GTK_ENTRY(c->location), "/");
 667                                         gtk_editable_set_position(GTK_EDITABLE(c->location), -1);
 668                                         return TRUE;
 669                         }
 670                 }
 671                 else if (((GdkEventKey *)event)->keyval == GDK_KEY_Escape)
 672                 {
 673                         webkit_web_view_stop_loading(WEBKIT_WEB_VIEW(c->web_view));
 674                         gtk_level_bar_set_value(GTK_LEVEL_BAR(c->progress), 0);
 675                 }
 676         }
 677         else if (event->type == GDK_BUTTON_PRESS)
 678         {
 679                 switch (((GdkEventButton *)event)->button)
 680                 {
 681                         case 2:
 682                                 if (c->hover_uri != NULL)
 683                                 {
 684                                         client_new(c->hover_uri);
 685                                         return TRUE;
 686                                 }
 687                                 break;
 688                         case 8:
 689                                 webkit_web_view_go_back(WEBKIT_WEB_VIEW(c->web_view));
 690                                 return TRUE;
 691                         case 9:
 692                                 webkit_web_view_go_forward(WEBKIT_WEB_VIEW(c->web_view));
 693                                 return TRUE;
 694                 }
 695         }
 696         else if (event->type == GDK_SCROLL)
 697         {
 698                 if (((GdkEventScroll *)event)->state & GDK_MOD1_MASK ||
 699                     ((GdkEventScroll *)event)->state & GDK_CONTROL_MASK)
 700                 {
 701                         gdk_event_get_scroll_deltas(event, &dx, &dy);
 702                         z = webkit_web_view_get_zoom_level(WEBKIT_WEB_VIEW(c->web_view));
 703                         z += -dy * 0.1;
 704                         z = dx != 0 ? global_zoom : z;
 705                         webkit_web_view_set_zoom_level(WEBKIT_WEB_VIEW(c->web_view), z);
 706                         return TRUE;
 707                 }
 708         }
 709
 710         return FALSE;
 711 }
 712
 713 void
 714 keywords_load(void)
 715 {
 716         GError *err = NULL;
 717         GIOChannel *channel = NULL;
 718         gchar *path = NULL, *buf = NULL;
 719         gchar **tokens = NULL;
 720
 721         keywords = g_hash_table_new(g_str_hash, g_str_equal);
 722
 723         path = g_build_filename(g_get_user_config_dir(), __NAME__, "keywordsearch",
 724                                 NULL);
 725         channel = g_io_channel_new_file(path, "r", &err);
 726         if (channel != NULL)
 727         {
 728                 while (g_io_channel_read_line(channel, &buf, NULL, NULL, NULL)
 729                        == G_IO_STATUS_NORMAL)
 730                 {
 731                         g_strstrip(buf);
 732                         if (buf[0] != '#')
 733                         {
 734                                 tokens = g_strsplit(buf, " ", 2);
 735                                 if (tokens[0] != NULL && tokens[1] != NULL)
 736                                         g_hash_table_insert(keywords, g_strdup(tokens[0]),
 737                                                             g_strdup(tokens[1]));
 738                                 g_strfreev(tokens);
 739                         }
 740                         g_free(buf);
 741                 }
 742                 g_io_channel_shutdown(channel, FALSE, NULL);
 743         }
 744         g_free(path);
 745 }
 746
 747 gboolean
 748 keywords_try_search(WebKitWebView *web_view, const gchar *t)
 749 {
 750         gboolean ret = FALSE;
 751         gchar **tokens = NULL;
 752         gchar *val = NULL, *uri = NULL;
 753
 754         tokens = g_strsplit(t, " ", 2);
 755         if (tokens[0] != NULL && tokens[1] != NULL)
 756         {
 757                 val = g_hash_table_lookup(keywords, tokens[0]);
 758                 if (val != NULL)
 759                 {
 760                         uri = g_strdup_printf((gchar *)val, tokens[1]);
 761                         webkit_web_view_load_uri(web_view, uri);
 762                         g_free(uri);
 763                         ret = TRUE;
 764                 }
 765         }
 766         g_strfreev(tokens);
 767
 768         return ret;
 769 }
 770
 771 gboolean
 772 remote_msg(GIOChannel *channel, GIOCondition condition, gpointer data)
 773 {
 774         gchar *uri = NULL;
 775
 776         g_io_channel_read_line(channel, &uri, NULL, NULL, NULL);
 777         if (uri)
 778         {
 779                 g_strstrip(uri);
 780                 client_new(uri);
 781                 g_free(uri);
 782         }
 783         return TRUE;
 784 }
 785
 786 void
 787 search(gpointer data, gint direction)
 788 {
 789         struct Client *c = (struct Client *)data;
 790         WebKitWebView *web_view = WEBKIT_WEB_VIEW(c->web_view);
 791         WebKitFindController *fc = webkit_web_view_get_find_controller(web_view);
 792
 793         if (search_text == NULL)
 794                 return;
 795
 796         switch (direction)
 797         {
 798                 case 0:
 799                         webkit_find_controller_search(fc, search_text,
 800                                                       WEBKIT_FIND_OPTIONS_CASE_INSENSITIVE |
 801                                                       WEBKIT_FIND_OPTIONS_WRAP_AROUND,
 802                                                       G_MAXUINT);
 803                         break;
 804                 case 1:
 805                         webkit_find_controller_search_next(fc);
 806                         break;
 807                 case -1:
 808                         webkit_find_controller_search_previous(fc);
 809                         break;
 810         }
 811 }
 812
 813 Window
 814 tabbed_launch(void)
 815 {
 816         gint tabbed_stdout;
 817         GIOChannel *tabbed_stdout_channel;
 818         GError *err = NULL;
 819         gchar *output = NULL;
 820         char *argv[] = { "tabbed", "-c", "-d", "-p", "s1", "-n", __NAME__, NULL };
 821         Window plug_into;
 822
 823         if (!g_spawn_async_with_pipes(NULL, argv, NULL, G_SPAWN_SEARCH_PATH, NULL,
 824                                       NULL, NULL, NULL, &tabbed_stdout, NULL,
 825                                       &err))
 826         {
 827                 fprintf(stderr, __NAME__": Could not launch tabbed: %s\n", err->message);
 828                 g_error_free(err);
 829                 return 0;
 830         }
 831
 832         tabbed_stdout_channel = g_io_channel_unix_new(tabbed_stdout);
 833         if (tabbed_stdout_channel == NULL)
 834         {
 835                 fprintf(stderr, __NAME__": Could open tabbed's stdout\n");
 836                 return 0;
 837         }
 838         g_io_channel_read_line(tabbed_stdout_channel, &output, NULL, NULL, NULL);
 839         g_io_channel_shutdown(tabbed_stdout_channel, FALSE, NULL);
 840         if (output == NULL)
 841         {
 842                 fprintf(stderr, __NAME__": Could not read XID from tabbed\n");
 843                 return 0;
 844         }
 845         g_strstrip(output);
 846         plug_into = strtol(output, NULL, 16);
 847         g_free(output);
 848         if (plug_into == 0)
 849                 fprintf(stderr, __NAME__": The XID from tabbed is 0\n");
 850         return plug_into;
 851 }
 852
 853 void
 854 usage(void)
 855 {
 856         fprintf(stderr, "Usage: "__NAME__" [OPTION]... [URI]...\n");
 857         exit(EXIT_FAILURE);
 858 }
 859
 860
 861 int
 862 main(int argc, char **argv)
 863 {
 864         int opt, i;
 865
 866         gtk_init(&argc, &argv);
 867
 868         grab_environment_configuration();
 869
 870         while ((opt = getopt(argc, argv, "e:CT")) != -1)
 871         {
 872                 switch (opt)
 873                 {
 874                         case 'e':
 875                                 embed = atol(optarg);
 876                                 tabbed_automagic = FALSE;
 877                                 break;
 878                         case 'C':
 879                                 cooperative_instances = FALSE;
 880                                 break;
 881                         case 'T':
 882                                 tabbed_automagic = FALSE;
 883                                 break;
 884                         default:
 885                                 usage();
 886                 }
 887         }
 888
 889         keywords_load();
 890         cooperation_setup();
 891         downloadmanager_setup();
 892
 893         if (tabbed_automagic && !(cooperative_instances && !cooperative_alone))
 894                 embed = tabbed_launch();
 895
 896         if (!cooperative_instances || cooperative_alone)
 897                 webkit_web_context_set_web_extensions_directory(webkit_web_context_get_default(),
 898                                                                 web_extensions_dir);
 899
 900         if (optind >= argc)
 901                 client_new(home_uri);
 902         else
 903         {
 904                 for (i = optind; i < argc; i++)
 905                         client_new(argv[i]);
 906         }
 907
 908         if (!cooperative_instances || cooperative_alone)
 909                 gtk_main();
 910         exit(EXIT_SUCCESS);
 911 }