?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Enabled hinting for framepages too.
[vimprobable2.git] / main.c
blobe3b7dbb6d50e97151aa34d5757ad8ad041431c74
1
2 /*
3 (c) 2009 by Leon Winter
4 (c) 2009-2011 by Hannes Schueller
5 (c) 2009-2010 by Matto Fransen
6 (c) 2010-2011 by Hans-Peter Deifel
7 (c) 2010-2011 by Thomas Adam
8 (c) 2011 by Albert Kim
9 see LICENSE file
10 */
11
12 #include <X11/Xlib.h>
13 #include "includes.h"
14 #include "vimprobable.h"
15 #include "utilities.h"
16 #include "callbacks.h"
17 #include "javascript.h"
18
19 /* the CLEAN_MOD_*_MASK defines have all the bits set that will be stripped from the modifier bit field */
20 #define CLEAN_MOD_NUMLOCK_MASK (GDK_MOD2_MASK)
21 #define CLEAN_MOD_BUTTON_MASK (GDK_BUTTON1_MASK|GDK_BUTTON2_MASK|GDK_BUTTON3_MASK|GDK_BUTTON4_MASK|GDK_BUTTON5_MASK)
22
23 /* remove unused bits, numlock symbol and buttons from keymask */
24 #define CLEAN(mask) (mask & (GDK_MODIFIER_MASK) & ~(CLEAN_MOD_NUMLOCK_MASK) & ~(CLEAN_MOD_BUTTON_MASK))
25
26 #define IS_ESCAPE(event) (IS_ESCAPE_KEY(CLEAN(event->state), event->keyval))
27 #define IS_ESCAPE_KEY(s, k) ((s == 0 && k == GDK_Escape) || \
28 (s == GDK_CONTROL_MASK && k == GDK_bracketleft))
29
30 /* callbacks here */
31 static void inputbox_activate_cb(GtkEntry *entry, gpointer user_data);
32 static gboolean inputbox_keypress_cb(GtkEntry *entry, GdkEventKey *event);
33 static gboolean inputbox_keyrelease_cb(GtkEntry *entry, GdkEventKey *event);
34 static gboolean inputbox_changed_cb(GtkEditable *entry, gpointer user_data);
35 static WebKitWebView* inspector_inspect_web_view_cb(gpointer inspector, WebKitWebView* web_view);
36 static gboolean notify_event_cb(GtkWidget *widget, GdkEvent *event, gpointer user_data);
37 static gboolean webview_console_cb(WebKitWebView *webview, char *message, int line, char *source, gpointer user_data);
38 static gboolean webview_download_cb(WebKitWebView *webview, WebKitDownload *download, gpointer user_data);
39 static void webview_hoverlink_cb(WebKitWebView *webview, char *title, char *link, gpointer data);
40 static gboolean webview_keypress_cb(WebKitWebView *webview, GdkEventKey *event);
41 static void webview_load_committed_cb(WebKitWebView *webview, WebKitWebFrame *frame, gpointer user_data);
42 static void webview_load_finished_cb(WebKitWebView *webview, WebKitWebFrame *frame, gpointer user_data);
43 static gboolean webview_mimetype_cb(WebKitWebView *webview, WebKitWebFrame *frame, WebKitNetworkRequest *request,
44 char *mime_type, WebKitWebPolicyDecision *decision, gpointer user_data);
45 static gboolean webview_new_window_cb(WebKitWebView *webview, WebKitWebFrame *frame, WebKitNetworkRequest *request,
46 WebKitWebNavigationAction *action, WebKitWebPolicyDecision *decision, gpointer user_data);
47 static gboolean webview_open_in_new_window_cb(WebKitWebView *webview, WebKitWebFrame *frame, gpointer user_data);
48 static void webview_progress_changed_cb(WebKitWebView *webview, int progress, gpointer user_data);
49 static void webview_title_changed_cb(WebKitWebView *webview, WebKitWebFrame *frame, char *title, gpointer user_data);
50 static void window_destroyed_cb(GtkWidget *window, gpointer func_data);
51
52 /* functions */
53 static gboolean bookmark(const Arg *arg);
54 static gboolean browser_settings(const Arg *arg);
55 static gboolean commandhistoryfetch(const Arg *arg);
56 static gboolean complete(const Arg *arg);
57 static gboolean descend(const Arg *arg);
58 gboolean echo(const Arg *arg);
59 static gboolean focus_input(const Arg *arg);
60 static gboolean input(const Arg *arg);
61 static gboolean navigate(const Arg *arg);
62 static gboolean number(const Arg *arg);
63 static gboolean open_arg(const Arg *arg);
64 static gboolean open_remembered(const Arg *arg);
65 static gboolean paste(const Arg *arg);
66 static gboolean quickmark(const Arg *arg);
67 static gboolean quit(const Arg *arg);
68 static gboolean revive(const Arg *arg);
69 static gboolean print_frame(const Arg *arg);
70 static gboolean search(const Arg *arg);
71 static gboolean set(const Arg *arg);
72 static gboolean script(const Arg *arg);
73 static gboolean scroll(const Arg *arg);
74 static gboolean search_tag(const Arg *arg);
75 static gboolean yank(const Arg *arg);
76 static gboolean view_source(const Arg * arg);
77 static gboolean zoom(const Arg *arg);
78 static gboolean fake_key_event(const Arg *arg);
79
80 static void update_url(const char *uri);
81 static void setup_modkeys(void);
82 static void setup_gui(void);
83 static void setup_settings(void);
84 static void setup_signals(void);
85 static void ascii_bar(int total, int state, char *string);
86 static gchar *jsapi_ref_to_string(JSContextRef context, JSValueRef ref);
87 static void jsapi_evaluate_script(const gchar *script, gchar **value, gchar **message);
88 static void download_progress(WebKitDownload *d, GParamSpec *pspec);
89 static void set_widget_font_and_color(GtkWidget *widget, const char *font_str,
90 const char *bg_color_str, const char *fg_color_str);
91
92 static gboolean history(void);
93 static gboolean process_set_line(char *line);
94 void save_command_history(char *line);
95 void toggle_proxy(gboolean onoff);
96 void toggle_scrollbars(gboolean onoff);
97
98 gboolean process_keypress(GdkEventKey *event);
99 void fill_suggline(char * suggline, const char * command, const char *fill_with);
100 GtkWidget * fill_eventbox(const char * completion_line);
101 static void mop_up(void);
102
103 #include "main.h"
104
105 /* variables */
106 static GtkWindow *window;
107 static GtkWidget *viewport;
108 static GtkBox *box;
109 static GtkScrollbar *scroll_h;
110 static GtkScrollbar *scroll_v;
111 static GtkAdjustment *adjust_h;
112 static GtkAdjustment *adjust_v;
113 static GtkWidget *inputbox;
114 static GtkWidget *eventbox;
115 static GtkBox *statusbar;
116 static GtkWidget *status_url;
117 static GtkWidget *status_state;
118 static WebKitWebView *webview;
119 static SoupSession *session;
120 static GtkClipboard *clipboards[2];
121
122 static char **args;
123 static unsigned int mode = ModeNormal;
124 static unsigned int count = 0;
125 static float zoomstep;
126 static char *modkeys;
127 static char current_modkey;
128 static char *search_handle;
129 static gboolean search_direction;
130 static gboolean echo_active = TRUE;
131 WebKitWebInspector *inspector;
132
133 static GdkNativeWindow embed = 0;
134 static char *configfile = NULL;
135 static char *winid = NULL;
136
137 static char rememberedURI[1024] = "";
138 static char followTarget[8] = "";
139 char *error_msg = NULL;
140
141 GList *activeDownloads;
142
143 #include "config.h"
144 #include "keymap.h"
145
146 char commandhistory[COMMANDHISTSIZE][255];
147 int lastcommand = 0;
148 int maxcommands = 0;
149 int commandpointer = 0;
150 KeyList *keylistroot = NULL;
151
152 /* Cookie support. */
153 #ifdef ENABLE_COOKIE_SUPPORT
154 static SoupCookieJar *session_cookie_jar = NULL;
155 static SoupCookieJar *file_cookie_jar = NULL;
156 static time_t cookie_timeout = 4800;
157 static char *cookie_store;
158 static void setup_cookies(void);
159 static const char *get_cookies(SoupURI *soup_uri);
160 static void load_all_cookies(void);
161 static void new_generic_request(SoupSession *soup_ses, SoupMessage *soup_msg, gpointer unused);
162 static void update_cookie_jar(SoupCookieJar *jar, SoupCookie *old, SoupCookie *new);
163 static void handle_cookie_request(SoupMessage *soup_msg, gpointer unused);
164 #endif
165 /* callbacks */
166 void
167 window_destroyed_cb(GtkWidget *window, gpointer func_data) {
168 quit(NULL);
169 }
170
171 void
172 webview_title_changed_cb(WebKitWebView *webview, WebKitWebFrame *frame, char *title, gpointer user_data) {
173 gtk_window_set_title(window, title);
174 }
175
176 void
177 webview_progress_changed_cb(WebKitWebView *webview, int progress, gpointer user_data) {
178 #ifdef ENABLE_GTK_PROGRESS_BAR
179 gtk_entry_set_progress_fraction(GTK_ENTRY(inputbox), progress == 100 ? 0 : (double)progress/100);
180 #endif
181 update_state();
182 }
183
184 #ifdef ENABLE_WGET_PROGRESS_BAR
185 void
186 ascii_bar(int total, int state, char *string) {
187 int i;
188
189 for (i = 0; i < state; i++)
190 string[i] = progressbartickchar;
191 string[i++] = progressbarcurrent;
192 for (; i < total; i++)
193 string[i] = progressbarspacer;
194 string[i] = '\0';
195 }
196 #endif
197
198 void
199 webview_load_committed_cb(WebKitWebView *webview, WebKitWebFrame *frame, gpointer user_data) {
200 Arg a = { .i = Silent, .s = g_strdup(JS_SETUP_HINTS) };
201 const char *uri = webkit_web_view_get_uri(webview);
202
203 update_url(uri);
204 script(&a);
205 }
206
207 void
208 webview_load_finished_cb(WebKitWebView *webview, WebKitWebFrame *frame, gpointer user_data) {
209 Arg a = { .i = Silent, .s = g_strdup(JS_SETUP_INPUT_FOCUS) };
210
211 if (HISTORY_MAX_ENTRIES > 0)
212 history();
213 update_state();
214 script(&a);
215 }
216
217 static gboolean
218 webview_open_in_new_window_cb(WebKitWebView *webview, WebKitWebFrame *frame, gpointer user_data) {
219 Arg a = { .i = TargetNew, .s = (char*)webkit_web_view_get_uri(webview) };
220 if (strlen(rememberedURI) > 0) {
221 a.s = rememberedURI;
222 }
223 open_arg(&a);
224 return FALSE;
225 }
226
227 gboolean
228 webview_new_window_cb(WebKitWebView *webview, WebKitWebFrame *frame, WebKitNetworkRequest *request,
229 WebKitWebNavigationAction *action, WebKitWebPolicyDecision *decision, gpointer user_data) {
230 Arg a = { .i = TargetNew, .s = (char*)webkit_network_request_get_uri(request) };
231 open_arg(&a);
232 webkit_web_policy_decision_ignore(decision);
233 return TRUE;
234 }
235
236 gboolean
237 webview_mimetype_cb(WebKitWebView *webview, WebKitWebFrame *frame, WebKitNetworkRequest *request,
238 char *mime_type, WebKitWebPolicyDecision *decision, gpointer user_data) {
239 if (webkit_web_view_can_show_mime_type(webview, mime_type) == FALSE) {
240 webkit_web_policy_decision_download(decision);
241 return TRUE;
242 } else {
243 return FALSE;
244 }
245 }
246
247 static WebKitWebView*
248 inspector_inspect_web_view_cb(gpointer inspector, WebKitWebView* web_view) {
249 gchar* inspector_title;
250 GtkWidget* inspector_window;
251 GtkWidget* inspector_view;
252
253 /* just enough code to show the inspector - no signal handling etc. */
254 inspector_title = g_strdup_printf("Inspect page - %s - Vimprobable2", webkit_web_view_get_uri(web_view));
255 if (embed) {
256 inspector_window = gtk_plug_new(embed);
257 } else {
258 inspector_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
259 gtk_window_set_wmclass(window, "vimprobable2", "Vimprobable2");
260 }
261 gtk_window_set_title(GTK_WINDOW(inspector_window), inspector_title);
262 g_free(inspector_title);
263 inspector_view = webkit_web_view_new();
264 gtk_container_add(GTK_CONTAINER(inspector_window), inspector_view);
265 gtk_widget_show_all(inspector_window);
266 return WEBKIT_WEB_VIEW(inspector_view);
267 }
268
269 gboolean
270 webview_download_cb(WebKitWebView *webview, WebKitDownload *download, gpointer user_data) {
271 const gchar *filename;
272 gchar *uri, *path;
273 uint32_t size;
274 Arg a;
275
276 filename = webkit_download_get_suggested_filename(download);
277 if (filename == NULL || strlen(filename) == 0) {
278 filename = "vimprobable_download";
279 }
280 path = g_build_filename(g_strdup_printf(DOWNLOADS_PATH), filename, NULL);
281 uri = g_strconcat("file://", path, NULL);
282 webkit_download_set_destination_uri(download, uri);
283 g_free(uri);
284 size = (uint32_t)webkit_download_get_total_size(download);
285 a.i = Info;
286 if (size > 0)
287 a.s = g_strdup_printf("Download %s started (expected size: %u bytes)...", filename, size);
288 else
289 a.s = g_strdup_printf("Download %s started (unknown size)...", filename);
290 echo(&a);
291 g_free(a.s);
292 activeDownloads = g_list_prepend(activeDownloads, download);
293 g_signal_connect(download, "notify::progress", G_CALLBACK(download_progress), NULL);
294 g_signal_connect(download, "notify::status", G_CALLBACK(download_progress), NULL);
295 update_state();
296 return TRUE;
297 }
298
299 void
300 download_progress(WebKitDownload *d, GParamSpec *pspec) {
301 Arg a;
302 WebKitDownloadStatus status = webkit_download_get_status(d);
303
304 if (status != WEBKIT_DOWNLOAD_STATUS_STARTED && status != WEBKIT_DOWNLOAD_STATUS_CREATED) {
305 if (status != WEBKIT_DOWNLOAD_STATUS_FINISHED) {
306 a.i = Error;
307 a.s = g_strdup_printf("Error while downloading %s", webkit_download_get_suggested_filename(d));
308 echo(&a);
309 } else {
310 a.i = Info;
311 a.s = g_strdup_printf("Download %s finished", webkit_download_get_suggested_filename(d));
312 echo(&a);
313 }
314 g_free(a.s);
315 activeDownloads = g_list_remove(activeDownloads, d);
316 }
317 update_state();
318 }
319
320
321 gboolean
322 process_keypress(GdkEventKey *event) {
323 KeyList *current;
324
325 current = keylistroot;
326 while (current != NULL) {
327 if (current->Element.mask == CLEAN(event->state)
328 && (current->Element.modkey == current_modkey
329 || (!current->Element.modkey && !current_modkey)
330 || current->Element.modkey == GDK_VoidSymbol ) /* wildcard */
331 && current->Element.key == event->keyval
332 && current->Element.func)
333 if (current->Element.func(&current->Element.arg)) {
334 current_modkey = count = 0;
335 update_state();
336 return TRUE;
337 }
338 current = current->next;
339 }
340 return FALSE;
341 }
342
343 gboolean
344 webview_keypress_cb(WebKitWebView *webview, GdkEventKey *event) {
345 Arg a = { .i = ModeNormal, .s = NULL };
346
347 switch (mode) {
348 case ModeNormal:
349 if (CLEAN(event->state) == 0) {
350 if (IS_ESCAPE(event)) {
351 a.i = Info;
352 a.s = g_strdup("");
353 echo(&a);
354 g_free(a.s);
355 } else if (current_modkey == 0 && ((event->keyval >= GDK_1 && event->keyval <= GDK_9)
356 || (event->keyval == GDK_0 && count))) {
357 count = (count ? count * 10 : 0) + (event->keyval - GDK_0);
358 update_state();
359 return TRUE;
360 } else if (strchr(modkeys, event->keyval) && current_modkey != event->keyval) {
361 current_modkey = event->keyval;
362 update_state();
363 return TRUE;
364 }
365 }
366 /* keybindings */
367 if (process_keypress(event) == TRUE) return TRUE;
368
369 break;
370 case ModeInsert:
371 if (IS_ESCAPE(event)) {
372 a.i = Silent;
373 a.s = g_strdup("hints.clearFocus();");
374 script(&a);
375 a.i = ModeNormal;
376 return set(&a);
377 }
378 case ModePassThrough:
379 if (IS_ESCAPE(event)) {
380 echo(&a);
381 set(&a);
382 return TRUE;
383 }
384 break;
385 case ModeSendKey:
386 echo(&a);
387 set(&a);
388 break;
389 }
390 return FALSE;
391 }
392
393 void
394 set_widget_font_and_color(GtkWidget *widget, const char *font_str, const char *bg_color_str,
395 const char *fg_color_str) {
396 GdkColor fg_color;
397 GdkColor bg_color;
398 PangoFontDescription *font;
399
400 font = pango_font_description_from_string(font_str);
401 gtk_widget_modify_font(widget, font);
402 pango_font_description_free(font);
403
404 if (fg_color_str)
405 gdk_color_parse(fg_color_str, &fg_color);
406 if (bg_color_str)
407 gdk_color_parse(bg_color_str, &bg_color);
408
409 gtk_widget_modify_text(widget, GTK_STATE_NORMAL, fg_color_str ? &fg_color : NULL);
410 gtk_widget_modify_base(widget, GTK_STATE_NORMAL, bg_color_str ? &bg_color : NULL);
411
412 return;
413 }
414
415 void
416 webview_hoverlink_cb(WebKitWebView *webview, char *title, char *link, gpointer data) {
417 const char *uri = webkit_web_view_get_uri(webview);
418
419 memset(rememberedURI, 0, 1024);
420 if (link) {
421 gtk_label_set_markup(GTK_LABEL(status_url), g_markup_printf_escaped("<span font=\"%s\">Link: %s</span>", statusfont, link));
422 strncpy(rememberedURI, link, 1024);
423 } else
424 update_url(uri);
425 }
426
427 gboolean
428 webview_console_cb(WebKitWebView *webview, char *message, int line, char *source, gpointer user_data) {
429 Arg a;
430
431 /* Don't change internal mode if the browser doesn't have focus to prevent inconsistent states */
432 if (gtk_window_has_toplevel_focus(window)) {
433 if (!strcmp(message, "hintmode_off") || !strcmp(message, "insertmode_off")) {
434 a.i = ModeNormal;
435 return set(&a);
436 } else if (!strcmp(message, "insertmode_on")) {
437 a.i = ModeInsert;
438 return set(&a);
439 }
440 }
441 return FALSE;
442 }
443
444 void
445 inputbox_activate_cb(GtkEntry *entry, gpointer user_data) {
446 char *text;
447 guint16 length = gtk_entry_get_text_length(entry);
448 Arg a;
449 gboolean success = FALSE, forward = FALSE;
450
451 a.i = HideCompletion;
452 complete(&a);
453 if (length == 0)
454 return;
455 text = (char*)gtk_entry_get_text(entry);
456 if (length > 1 && text[0] == ':') {
457 success = process_line((text + 1));
458 } else if (length > 1 && ((forward = text[0] == '/') || text[0] == '?')) {
459 webkit_web_view_unmark_text_matches(webview);
460 #ifdef ENABLE_MATCH_HIGHLITING
461 webkit_web_view_mark_text_matches(webview, &text[1], FALSE, 0);
462 webkit_web_view_set_highlight_text_matches(webview, TRUE);
463 #endif
464 count = 0;
465 #ifndef ENABLE_INCREMENTAL_SEARCH
466 a.s =& text[1];
467 a.i = searchoptions | (forward ? DirectionForward : DirectionBackwards);
468 search(&a);
469 #else
470 search_direction = forward;
471 search_handle = g_strdup(&text[1]);
472 #endif
473 } else if (text[0] == '.' || text[0] == ',') {
474 a.i = Silent;
475 a.s = g_strdup_printf("hints.fire();");
476 script(&a);
477 update_state();
478 } else
479 return;
480 if (!echo_active)
481 gtk_entry_set_text(entry, "");
482 gtk_widget_grab_focus(GTK_WIDGET(webview));
483 }
484
485 gboolean
486 inputbox_keypress_cb(GtkEntry *entry, GdkEventKey *event) {
487 Arg a;
488 int numval;
489
490 if (mode == ModeHints) {
491 if (event->keyval == GDK_Tab) {
492 a.i = Silent;
493 a.s = g_strdup_printf("hints.focusNextHint();");
494 script(&a);
495 update_state();
496 return TRUE;
497 }
498 if (event->keyval == GDK_ISO_Left_Tab) {
499 a.i = Silent;
500 a.s = g_strdup_printf("hints.focusPreviousHint();");
501 script(&a);
502 update_state();
503 return TRUE;
504 }
505 if (event->keyval == GDK_Return) {
506 a.i = Silent;
507 a.s = g_strdup_printf("hints.fire();");
508 script(&a);
509 update_state();
510 return TRUE;
511 }
512 }
513 switch (event->keyval) {
514 case GDK_bracketleft:
515 case GDK_Escape:
516 if (!IS_ESCAPE(event)) break;
517 a.i = HideCompletion;
518 complete(&a);
519 a.i = ModeNormal;
520 return set(&a);
521 break;
522 case GDK_Tab:
523 a.i = DirectionNext;
524 return complete(&a);
525 break;
526 case GDK_Up:
527 a.i = DirectionPrev;
528 return commandhistoryfetch(&a);
529 break;
530 case GDK_Down:
531 a.i = DirectionNext;
532 return commandhistoryfetch(&a);
533 break;
534 case GDK_ISO_Left_Tab:
535 a.i = DirectionPrev;
536 return complete(&a);
537 break;
538 }
539
540 if (mode == ModeHints) {
541 if ((CLEAN(event->state) & GDK_SHIFT_MASK) &&
542 (CLEAN(event->state) & GDK_CONTROL_MASK) &&
543 (event->keyval == GDK_BackSpace)) {
544 count /= 10;
545 a.i = Silent;
546 a.s = g_strdup_printf("hints.updateHints(%d);", count);
547 script(&a);
548 update_state();
549 return TRUE;
550 }
551
552 numval = g_unichar_digit_value((gunichar) gdk_keyval_to_unicode(event->keyval));
553 if ((numval >= 1 && numval <= 9) || (numval == 0 && count)) {
554 /* allow a zero as non-first number */
555 count = (count ? count * 10 : 0) + numval;
556 a.i = Silent;
557 a.s = g_strdup_printf("hints.updateHints(%d);", count);
558 script(&a);
559 update_state();
560 return TRUE;
561 }
562 }
563
564 return FALSE;
565 }
566
567 gboolean
568 notify_event_cb(GtkWidget *widget, GdkEvent *event, gpointer user_data) {
569 int i;
570 if (mode == ModeNormal && event->type == GDK_BUTTON_RELEASE) {
571 /* handle mouse click events */
572 for (i = 0; i < LENGTH(mouse); i++) {
573 if (mouse[i].mask == CLEAN(event->button.state)
574 && (mouse[i].modkey == current_modkey
575 || (!mouse[i].modkey && !current_modkey)
576 || mouse[i].modkey == GDK_VoidSymbol) /* wildcard */
577 && mouse[i].button == event->button.button
578 && mouse[i].func) {
579 if (mouse[i].func(&mouse[i].arg)) {
580 current_modkey = count = 0;
581 update_state();
582 return TRUE;
583 }
584 }
585 }
586 }
587 return FALSE;
588 }
589
590 static gboolean inputbox_keyrelease_cb(GtkEntry *entry, GdkEventKey *event) {
591 Arg a;
592 guint16 length = gtk_entry_get_text_length(entry);
593
594 if (!length) {
595 a.i = HideCompletion;
596 complete(&a);
597 a.i = ModeNormal;
598 return set(&a);
599 }
600 return FALSE;
601 }
602
603 static gboolean inputbox_changed_cb(GtkEditable *entry, gpointer user_data) {
604 Arg a;
605 char *text = (char*)gtk_entry_get_text(GTK_ENTRY(entry));
606 guint16 length = gtk_entry_get_text_length(GTK_ENTRY(entry));
607 gboolean forward = FALSE;
608
609 /* Update incremental search if the user changes the search text.
610 *
611 * Note: gtk_widget_is_focus() is a poor way to check if the change comes
612 * from the user. But if the entry is focused and the text is set
613 * through gtk_entry_set_text() in some asyncrounous operation,
614 * I would consider that a bug.
615 */
616
617 if (gtk_widget_is_focus(GTK_WIDGET(entry)) && length > 1 && ((forward = text[0] == '/') || text[0] == '?')) {
618 webkit_web_view_unmark_text_matches(webview);
619 webkit_web_view_search_text(webview, &text[1], searchoptions & CaseSensitive, forward, searchoptions & Wrapping);
620 return TRUE;
621 } else if (gtk_widget_is_focus(GTK_WIDGET(entry)) && length >= 1 &&
622 (text[0] == '.' || text[0] == ',')) {
623 a.i = Silent;
624 a.s = g_strdup("hints.clearHints();");
625 script(&a);
626
627 a.i = Silent;
628 a.s = g_strconcat("hints.createHints('", text + 1, "');", NULL);
629 script(&a);
630
631 return TRUE;
632 } else if (length == 0 && followTarget[0]) {
633 mode = ModeNormal;
634 a.i = Silent;
635 a.s = g_strdup("hints.clearHints();");
636 script(&a);
637 count = 0;
638 update_state();
639 }
640
641 return FALSE;
642 }
643
644 /* funcs here */
645
646 void fill_suggline(char * suggline, const char * command, const char *fill_with) {
647 memset(suggline, 0, 512);
648 strncpy(suggline, command, 512);
649 strncat(suggline, " ", 1);
650 strncat(suggline, fill_with, 512 - strlen(suggline) - 1);
651 }
652
653 GtkWidget * fill_eventbox(const char * completion_line) {
654 GtkBox * row;
655 GtkWidget *row_eventbox, *el;
656 GdkColor color;
657 char * markup;
658
659 row = GTK_BOX(gtk_hbox_new(FALSE, 0));
660 row_eventbox = gtk_event_box_new();
661 gdk_color_parse(completionbgcolor[0], &color);
662 gtk_widget_modify_bg(row_eventbox, GTK_STATE_NORMAL, &color);
663 el = gtk_label_new(NULL);
664 markup = g_strconcat("<span font=\"", completionfont[0], "\" color=\"", completioncolor[0], "\">",
665 g_markup_escape_text(completion_line, strlen(completion_line)), "</span>", NULL);
666 gtk_label_set_markup(GTK_LABEL(el), markup);
667 g_free(markup);
668 gtk_misc_set_alignment(GTK_MISC(el), 0, 0);
669 gtk_box_pack_start(row, el, TRUE, TRUE, 2);
670 gtk_container_add(GTK_CONTAINER(row_eventbox), GTK_WIDGET(row));
671 return row_eventbox;
672 }
673
674 gboolean
675 complete(const Arg *arg) {
676 char *str, *p, *s, *markup, *entry, *searchfor, command[32] = "", suggline[512] = "", **suggurls;
677 size_t listlen, len, cmdlen;
678 int i, spacepos;
679 Listelement *elementlist = NULL, *elementpointer;
680 gboolean highlight = FALSE;
681 GtkBox *row;
682 GtkWidget *row_eventbox, *el;
683 GtkBox *_table;
684 GdkColor color;
685 static GtkWidget *table, *top_border;
686 static char *prefix;
687 static char **suggestions;
688 static GtkWidget **widgets;
689 static int n = 0, m, current = -1;
690
691 str = (char*)gtk_entry_get_text(GTK_ENTRY(inputbox));
692 len = strlen(str);
693
694 /* Get the length of the list of commands for completion. We need this to
695 * malloc/realloc correctly.
696 */
697 listlen = LENGTH(commands);
698
699 if ((len == 0 || str[0] != ':') && arg->i != HideCompletion)
700 return TRUE;
701 if (prefix) {
702 if (arg->i != HideCompletion && widgets && current != -1 && !strcmp(&str[1], suggestions[current])) {
703 gdk_color_parse(completionbgcolor[0], &color);
704 gtk_widget_modify_bg(widgets[current], GTK_STATE_NORMAL, &color);
705 current = (n + current + (arg->i == DirectionPrev ? -1 : 1)) % n;
706 if ((arg->i == DirectionNext && current == 0)
707 || (arg->i == DirectionPrev && current == n - 1))
708 current = -1;
709 } else {
710 free(widgets);
711 free(suggestions);
712 free(prefix);
713 gtk_widget_destroy(GTK_WIDGET(table));
714 gtk_widget_destroy(GTK_WIDGET(top_border));
715 table = NULL;
716 widgets = NULL;
717 suggestions = NULL;
718 prefix = NULL;
719 n = 0;
720 current = -1;
721 if (arg->i == HideCompletion)
722 return TRUE;
723 }
724 } else if (arg->i == HideCompletion)
725 return TRUE;
726 if (!widgets) {
727 prefix = g_strdup_printf(str);
728 widgets = malloc(sizeof(GtkWidget*) * listlen);
729 suggestions = malloc(sizeof(char*) * listlen);
730 top_border = gtk_event_box_new();
731 gtk_widget_set_size_request(GTK_WIDGET(top_border), 0, 1);
732 gdk_color_parse(completioncolor[2], &color);
733 gtk_widget_modify_bg(top_border, GTK_STATE_NORMAL, &color);
734 table = gtk_event_box_new();
735 gdk_color_parse(completionbgcolor[0], &color);
736 _table = GTK_BOX(gtk_vbox_new(FALSE, 0));
737 highlight = len > 1;
738 if (strchr(str, ' ') == NULL) {
739 /* command completion */
740 listlen = LENGTH(commands);
741 for (i = 0; i < listlen; i++) {
742 if (commands[i].cmd == NULL)
743 break;
744 cmdlen = strlen(commands[i].cmd);
745 if (!highlight || (n < MAX_LIST_SIZE && len - 1 <= cmdlen && !strncmp(&str[1], commands[i].cmd, len - 1))) {
746 p = s = malloc(sizeof(char*) * (highlight ? sizeof(COMPLETION_TAG_OPEN) + sizeof(COMPLETION_TAG_CLOSE) - 1 : 1) + cmdlen);
747 if (highlight) {
748 memcpy(p, COMPLETION_TAG_OPEN, sizeof(COMPLETION_TAG_OPEN) - 1);
749 memcpy((p += sizeof(COMPLETION_TAG_OPEN) - 1), &str[1], len - 1);
750 memcpy((p += len - 1), COMPLETION_TAG_CLOSE, sizeof(COMPLETION_TAG_CLOSE) - 1);
751 p += sizeof(COMPLETION_TAG_CLOSE) - 1;
752 }
753 memcpy(p, &commands[i].cmd[len - 1], cmdlen - len + 2);
754 row = GTK_BOX(gtk_hbox_new(FALSE, 0));
755 row_eventbox = gtk_event_box_new();
756 gtk_widget_modify_bg(row_eventbox, GTK_STATE_NORMAL, &color);
757 el = gtk_label_new(NULL);
758 markup = g_strconcat("<span font=\"", completionfont[0], "\" color=\"", completioncolor[0], "\">", s, "</span>", NULL);
759 free(s);
760 gtk_label_set_markup(GTK_LABEL(el), markup);
761 g_free(markup);
762 gtk_misc_set_alignment(GTK_MISC(el), 0, 0);
763 gtk_box_pack_start(row, el, TRUE, TRUE, 2);
764 gtk_container_add(GTK_CONTAINER(row_eventbox), GTK_WIDGET(row));
765 gtk_box_pack_start(_table, GTK_WIDGET(row_eventbox), FALSE, FALSE, 0);
766 suggestions[n] = commands[i].cmd;
767 widgets[n++] = row_eventbox;
768 }
769 }
770 } else {
771 entry = (char *)malloc(512 * sizeof(char));
772 if (entry == NULL) {
773 return FALSE;
774 }
775 memset(entry, 0, 512);
776 suggurls = malloc(sizeof(char*) * listlen);
777 if (suggurls == NULL) {
778 return FALSE;
779 }
780 spacepos = strcspn(str, " ");
781 searchfor = (str + spacepos + 1);
782 strncpy(command, (str + 1), spacepos - 1);
783 if (strlen(command) == 3 && strncmp(command, "set", 3) == 0) {
784 /* browser settings */
785 listlen = LENGTH(browsersettings);
786 for (i = 0; i < listlen; i++) {
787 if (n < MAX_LIST_SIZE && strstr(browsersettings[i].name, searchfor) != NULL) {
788 /* match */
789 fill_suggline(suggline, command, browsersettings[i].name);
790 suggurls[n] = (char *)malloc(sizeof(char) * 512 + 1);
791 strncpy(suggurls[n], suggline, 512);
792 suggestions[n] = suggurls[n];
793 row_eventbox = fill_eventbox(suggline);
794 gtk_box_pack_start(_table, GTK_WIDGET(row_eventbox), FALSE, FALSE, 0);
795 widgets[n++] = row_eventbox;
796 }
797
798 }
799 } else if (strlen(command) == 2 && strncmp(command, "qt", 2) == 0) {
800 /* completion on tags */
801 spacepos = strcspn(str, " ");
802 searchfor = (str + spacepos + 1);
803 elementlist = complete_list(searchfor, 1, elementlist);
804 } else {
805 /* URL completion: bookmarks */
806 elementlist = complete_list(searchfor, 0, elementlist);
807 m = count_list(elementlist);
808 if (m < MAX_LIST_SIZE) {
809 /* URL completion: history */
810 elementlist = complete_list(searchfor, 2, elementlist);
811 }
812 }
813 elementpointer = elementlist;
814 while (elementpointer != NULL) {
815 fill_suggline(suggline, command, elementpointer->element);
816 suggurls[n] = (char *)malloc(sizeof(char) * 512 + 1);
817 strncpy(suggurls[n], suggline, 512);
818 suggestions[n] = suggurls[n];
819 row_eventbox = fill_eventbox(suggline);
820 gtk_box_pack_start(_table, GTK_WIDGET(row_eventbox), FALSE, FALSE, 0);
821 widgets[n++] = row_eventbox;
822 elementpointer = elementpointer->next;
823 if (n >= MAX_LIST_SIZE)
824 break;
825 }
826 free_list(elementlist);
827 if (suggurls != NULL) {
828 free(suggurls);
829 suggurls = NULL;
830 }
831 if (entry != NULL) {
832 free(entry);
833 entry = NULL;
834 }
835 }
836 /* TA: FIXME - this needs rethinking entirely. */
837 {
838 GtkWidget **widgets_temp = realloc(widgets, sizeof(*widgets) * n);
839 if (widgets_temp == NULL && widgets == NULL) {
840 fprintf(stderr, "Couldn't realloc() widgets\n");
841 exit(1);
842 }
843 widgets = widgets_temp;
844 char **suggestions_temp = realloc(suggestions, sizeof(*suggestions) * n);
845 if (suggestions_temp == NULL && suggestions == NULL) {
846 fprintf(stderr, "Couldn't realloc() suggestions\n");
847 exit(1);
848 }
849 suggestions = suggestions_temp;
850 }
851 if (!n) {
852 gdk_color_parse(completionbgcolor[1], &color);
853 gtk_widget_modify_bg(table, GTK_STATE_NORMAL, &color);
854 el = gtk_label_new(NULL);
855 gtk_misc_set_alignment(GTK_MISC(el), 0, 0);
856 markup = g_strconcat("<span font=\"", completionfont[1], "\" color=\"", completioncolor[1], "\">No Completions</span>", NULL);
857 gtk_label_set_markup(GTK_LABEL(el), markup);
858 g_free(markup);
859 gtk_box_pack_start(_table, GTK_WIDGET(el), FALSE, FALSE, 0);
860 }
861 gtk_box_pack_start(box, GTK_WIDGET(top_border), FALSE, FALSE, 0);
862 gtk_container_add(GTK_CONTAINER(table), GTK_WIDGET(_table));
863 gtk_box_pack_start(box, GTK_WIDGET(table), FALSE, FALSE, 0);
864 gtk_widget_show_all(GTK_WIDGET(window));
865 if (!n)
866 return TRUE;
867 current = arg->i == DirectionPrev ? n - 1 : 0;
868 }
869 if (current != -1) {
870 gdk_color_parse(completionbgcolor[2], &color);
871 gtk_widget_modify_bg(GTK_WIDGET(widgets[current]), GTK_STATE_NORMAL, &color);
872 s = g_strconcat(":", suggestions[current], NULL);
873 gtk_entry_set_text(GTK_ENTRY(inputbox), s);
874 g_free(s);
875 } else
876 gtk_entry_set_text(GTK_ENTRY(inputbox), prefix);
877 gtk_editable_set_position(GTK_EDITABLE(inputbox), -1);
878 return TRUE;
879 }
880
881 gboolean
882 descend(const Arg *arg) {
883 char *source = (char*)webkit_web_view_get_uri(webview), *p = &source[0], *new;
884 int i, len;
885 count = count ? count : 1;
886
887 if (!source)
888 return TRUE;
889 if (arg->i == Rootdir) {
890 for (i = 0; i < 3; i++) /* get to the third slash */
891 if (!(p = strchr(++p, '/')))
892 return TRUE; /* if we cannot find it quit */
893 } else {
894 len = strlen(source);
895 if (!len) /* if string is empty quit */
896 return TRUE;
897 p = source + len; /* start at the end */
898 if (*(p - 1) == '/') /* /\/$/ is not an additional level */
899 ++count;
900 for (i = 0; i < count; i++)
901 while(*(p--) != '/' || *p == '/') /* count /\/+/ as one slash */
902 if (p == source) /* if we reach the first char pointer quit */
903 return TRUE;
904 ++p; /* since we do p-- in the while, we are pointing at
905 the char before the slash, so +1 */
906 }
907 len = p - source + 1; /* new length = end - start + 1 */
908 new = malloc(len + 1);
909 memcpy(new, source, len);
910 new[len] = '\0';
911 webkit_web_view_load_uri(webview, new);
912 free(new);
913 return TRUE;
914 }
915
916 gboolean
917 echo(const Arg *arg) {
918 int index = !arg->s ? 0 : arg->i & (~NoAutoHide);
919
920 if (index < Info || index > Error)
921 return TRUE;
922
923 set_widget_font_and_color(inputbox, urlboxfont[index], urlboxbgcolor[index], urlboxcolor[index]);
924 gtk_entry_set_text(GTK_ENTRY(inputbox), !arg->s ? "" : arg->s);
925
926 return TRUE;
927 }
928
929 gboolean
930 input(const Arg *arg) {
931 int pos = 0;
932 count = 0;
933 const char *url;
934 int index = Info;
935 Arg a;
936
937 /* if inputbox hidden, show it again */
938 if (!gtk_widget_get_visible(inputbox))
939 gtk_widget_set_visible(inputbox, TRUE);
940
941 update_state();
942
943 /* Set the colour and font back to the default, so that we don't still
944 * maintain a red colour from a warning from an end of search indicator,
945 * etc.
946 */
947 set_widget_font_and_color(inputbox, urlboxfont[index], urlboxbgcolor[index], urlboxcolor[index]);
948
949 if (arg->s[0] == '.' || arg->s[0] == ',') {
950 mode = ModeHints;
951 memset(followTarget, 0, 8);
952 strncpy(followTarget, arg->s[0] == '.' ? "current" : "new", 8);
953 a.i = Silent;
954 a.s = g_strdup("hints.createHints();");
955 script(&a);
956 }
957
958 /* to avoid things like :open URL :open URL2 or :open :open URL */
959 gtk_entry_set_text(GTK_ENTRY(inputbox), "");
960 gtk_editable_insert_text(GTK_EDITABLE(inputbox), arg->s, -1, &pos);
961 if (arg->i & InsertCurrentURL && (url = webkit_web_view_get_uri(webview)))
962 gtk_editable_insert_text(GTK_EDITABLE(inputbox), url, -1, &pos);
963 gtk_widget_grab_focus(inputbox);
964 gtk_editable_set_position(GTK_EDITABLE(inputbox), -1);
965
966 return TRUE;
967 }
968
969 gboolean
970 navigate(const Arg *arg) {
971 if (arg->i & NavigationForwardBack)
972 webkit_web_view_go_back_or_forward(webview, (arg->i == NavigationBack ? -1 : 1) * (count ? count : 1));
973 else if (arg->i & NavigationReloadActions)
974 (arg->i == NavigationReload ? webkit_web_view_reload : webkit_web_view_reload_bypass_cache)(webview);
975 else
976 webkit_web_view_stop_loading(webview);
977 return TRUE;
978 }
979
980 gboolean
981 number(const Arg *arg) {
982 const char *source = webkit_web_view_get_uri(webview);
983 char *uri, *p, *new;
984 int number, diff = (count ? count : 1) * (arg->i == Increment ? 1 : -1);
985
986 if (!source)
987 return TRUE;
988 uri = g_strdup_printf(source); /* copy string */
989 p =& uri[0];
990 while(*p != '\0') /* goto the end of the string */
991 ++p;
992 --p;
993 while(*p >= '0' && *p <= '9') /* go back until non number char is reached */
994 --p;
995 if (*(++p) == '\0') { /* if no numbers were found abort */
996 free(uri);
997 return TRUE;
998 }
999 number = atoi(p) + diff; /* apply diff on number */
1000 *p = '\0';
1001 new = g_strdup_printf("%s%d", uri, number); /* create new uri */
1002 webkit_web_view_load_uri(webview, new);
1003 g_free(new);
1004 free(uri);
1005 return TRUE;
1006 }
1007
1008 gboolean
1009 open_arg(const Arg *arg) {
1010 char *argv[6];
1011 char *s = arg->s, *p = NULL, *new;
1012 Arg a = { .i = NavigationReload };
1013 int len;
1014 char *search_uri, *search_term;
1015
1016 if (embed) {
1017 argv[0] = *args;
1018 argv[1] = "-e";
1019 argv[2] = winid;
1020 argv[3] = arg->s;
1021 argv[4] = NULL;
1022 } else {
1023 argv[0] = *args;
1024 argv[1] = arg->s;
1025 argv[2] = NULL;
1026 }
1027
1028 if (!arg->s)
1029 navigate(&a);
1030 else if (arg->i == TargetCurrent) {
1031 while(*s == ' ') /* strip leading whitespace */
1032 ++s;
1033 p = (s + strlen(s) - 1);
1034 while(*p == ' ') /* strip trailing whitespace */
1035 --p;
1036 *(p + 1) = '\0';
1037 len = strlen(s);
1038 new = NULL, p = strchr(s, ' ');
1039 if (p) { /* check for search engines */
1040 *p = '\0';
1041 search_uri = find_uri_for_searchengine(s);
1042 if (search_uri != NULL) {
1043 search_term = soup_uri_encode(p+1, "&");
1044 new = g_strdup_printf(search_uri, search_term);
1045 g_free(search_term);
1046 }
1047 *p = ' ';
1048 }
1049 if (!new) {
1050 if (len > 3 && strstr(s, "://")) { /* valid url? */
1051 p = new = g_malloc(len + 1);
1052 while(*s != '\0') { /* strip whitespaces */
1053 if (*s != ' ')
1054 *(p++) = *s;
1055 ++s;
1056 }
1057 *p = '\0';
1058 } else if (strcspn(s, "/") == 0 || strcspn(s, "./") == 0) { /* prepend "file://" */
1059 new = g_malloc(sizeof("file://") + len);
1060 strcpy(new, "file://");
1061 memcpy(&new[sizeof("file://") - 1], s, len + 1);
1062 } else if (p || !strchr(s, '.')) { /* whitespaces or no dot? */
1063 search_uri = find_uri_for_searchengine(defaultsearch);
1064 if (search_uri != NULL) {
1065 search_term = soup_uri_encode(s, "&");
1066 new = g_strdup_printf(search_uri, search_term);
1067 g_free(search_term);
1068 }
1069 } else { /* prepend "http://" */
1070 new = g_malloc(sizeof("http://") + len);
1071 strcpy(new, "http://");
1072 memcpy(&new[sizeof("http://") - 1], s, len + 1);
1073 }
1074 }
1075 webkit_web_view_load_uri(webview, new);
1076 g_free(new);
1077 } else
1078 g_spawn_async(NULL, argv, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, NULL, NULL);
1079 return TRUE;
1080 }
1081
1082 gboolean
1083 open_remembered(const Arg *arg)
1084 {
1085 Arg a = {arg->i, rememberedURI};
1086
1087 if (strcmp(rememberedURI, "")) {
1088 open_arg(&a);
1089 }
1090 return TRUE;
1091 }
1092
1093 gboolean
1094 yank(const Arg *arg) {
1095 const char *url, *feedback;
1096
1097 if (arg->i & SourceURL) {
1098 url = webkit_web_view_get_uri(webview);
1099 if (!url)
1100 return TRUE;
1101 feedback = g_strconcat("Yanked ", url, NULL);
1102 give_feedback(feedback);
1103 if (arg->i & ClipboardPrimary)
1104 gtk_clipboard_set_text(clipboards[0], url, -1);
1105 if (arg->i & ClipboardGTK)
1106 gtk_clipboard_set_text(clipboards[1], url, -1);
1107 } else
1108 webkit_web_view_copy_clipboard(webview);
1109 return TRUE;
1110 }
1111
1112 gboolean
1113 paste(const Arg *arg) {
1114 Arg a = { .i = arg->i & TargetNew, .s = NULL };
1115
1116 /* If we're over a link, open it in a new target. */
1117 if (strlen(rememberedURI) > 0) {
1118 Arg new_target = { .i = TargetNew, .s = arg->s };
1119 open_arg(&new_target);
1120 return TRUE;
1121 }
1122
1123 if (arg->i & ClipboardPrimary)
1124 a.s = gtk_clipboard_wait_for_text(clipboards[0]);
1125 if (!a.s && arg->i & ClipboardGTK)
1126 a.s = gtk_clipboard_wait_for_text(clipboards[1]);
1127 if (a.s)
1128 open_arg(&a);
1129 return TRUE;
1130 }
1131
1132 gboolean
1133 quit(const Arg *arg) {
1134 FILE *f;
1135 const char *filename;
1136 const char *uri = webkit_web_view_get_uri(webview);
1137 if (uri != NULL) {
1138 /* write last URL into status file for recreation with "u" */
1139 filename = g_strdup_printf(CLOSED_URL_FILENAME);
1140 f = fopen(filename, "w");
1141 if (f != NULL) {
1142 fprintf(f, "%s", uri);
1143 fclose(f);
1144 }
1145 }
1146 gtk_main_quit();
1147 return TRUE;
1148 }
1149
1150 gboolean
1151 revive(const Arg *arg) {
1152 FILE *f;
1153 const char *filename;
1154 char buffer[512] = "";
1155 Arg a = { .i = TargetNew, .s = NULL };
1156 /* get the URL of the window which has been closed last */
1157 filename = g_strdup_printf(CLOSED_URL_FILENAME);
1158 f = fopen(filename, "r");
1159 if (f != NULL) {
1160 fgets(buffer, 512, f);
1161 fclose(f);
1162 }
1163 if (strlen(buffer) > 0) {
1164 a.s = buffer;
1165 open_arg(&a);
1166 return TRUE;
1167 }
1168 return FALSE;
1169 }
1170
1171 static
1172 gboolean print_frame(const Arg *arg)
1173 {
1174 WebKitWebFrame *frame = webkit_web_view_get_main_frame(webview);
1175 webkit_web_frame_print (frame);
1176 return TRUE;
1177 }
1178
1179 gboolean
1180 search(const Arg *arg) {
1181 count = count ? count : 1;
1182 gboolean success, direction = arg->i & DirectionPrev;
1183 Arg a;
1184
1185 if (arg->s) {
1186 free(search_handle);
1187 search_handle = g_strdup_printf(arg->s);
1188 }
1189 if (!search_handle)
1190 return TRUE;
1191 if (arg->i & DirectionAbsolute)
1192 search_direction = direction;
1193 else
1194 direction ^= search_direction;
1195 do {
1196 success = webkit_web_view_search_text(webview, search_handle, arg->i & CaseSensitive, direction, FALSE);
1197 if (!success) {
1198 if (arg->i & Wrapping) {
1199 success = webkit_web_view_search_text(webview, search_handle, arg->i & CaseSensitive, direction, TRUE);
1200 if (success) {
1201 a.i = Warning;
1202 a.s = g_strdup_printf("search hit %s, continuing at %s",
1203 direction ? "BOTTOM" : "TOP",
1204 direction ? "TOP" : "BOTTOM");
1205 echo(&a);
1206 g_free(a.s);
1207 } else
1208 break;
1209 } else
1210 break;
1211 }
1212 } while(--count);
1213 if (!success) {
1214 a.i = Error;
1215 a.s = g_strdup_printf("Pattern not found: %s", search_handle);
1216 echo(&a);
1217 g_free(a.s);
1218 }
1219 return TRUE;
1220 }
1221
1222 gboolean
1223 set(const Arg *arg) {
1224 Arg a = { .i = Info | NoAutoHide };
1225
1226 switch (arg->i) {
1227 case ModeNormal:
1228 if (search_handle) {
1229 search_handle = NULL;
1230 webkit_web_view_unmark_text_matches(webview);
1231 }
1232 gtk_entry_set_text(GTK_ENTRY(inputbox), "");
1233 gtk_widget_grab_focus(GTK_WIDGET(webview));
1234 break;
1235 case ModePassThrough:
1236 a.s = g_strdup("-- PASS THROUGH --");
1237 echo(&a);
1238 g_free(a.s);
1239 break;
1240 case ModeSendKey:
1241 a.s = g_strdup("-- PASS TROUGH (next) --");
1242 echo(&a);
1243 g_free(a.s);
1244 break;
1245 case ModeInsert: /* should not be called manually but automatically */
1246 a.s = g_strdup("-- INSERT --");
1247 echo(&a);
1248 g_free(a.s);
1249 break;
1250 default:
1251 return TRUE;
1252 }
1253 mode = arg->i;
1254 return TRUE;
1255 }
1256
1257 gchar*
1258 jsapi_ref_to_string(JSContextRef context, JSValueRef ref) {
1259 JSStringRef string_ref;
1260 gchar *string;
1261 size_t length;
1262
1263 string_ref = JSValueToStringCopy(context, ref, NULL);
1264 length = JSStringGetMaximumUTF8CStringSize(string_ref);
1265 string = g_new(gchar, length);
1266 JSStringGetUTF8CString(string_ref, string, length);
1267 JSStringRelease(string_ref);
1268 return string;
1269 }
1270
1271 void
1272 jsapi_evaluate_script(const gchar *script, gchar **value, gchar **message) {
1273 WebKitWebFrame *frame = webkit_web_view_get_main_frame(webview);
1274 JSGlobalContextRef context = webkit_web_frame_get_global_context(frame);
1275 JSStringRef str;
1276 JSValueRef val, exception;
1277
1278 str = JSStringCreateWithUTF8CString(script);
1279 val = JSEvaluateScript(context, str, JSContextGetGlobalObject(context), NULL, 0, &exception);
1280 JSStringRelease(str);
1281 if (!val)
1282 *message = jsapi_ref_to_string(context, exception);
1283 else
1284 *value = jsapi_ref_to_string(context, val);
1285 }
1286
1287 gboolean
1288 quickmark(const Arg *a) {
1289 int i, b;
1290 b = atoi(a->s);
1291 char *fn = g_strdup_printf(QUICKMARK_FILE);
1292 FILE *fp;
1293 fp = fopen(fn, "r");
1294 char buf[100];
1295
1296 if (fp != NULL && b < 10) {
1297 for( i=0; i < b; ++i ) {
1298 if (feof(fp)) {
1299 break;
1300 }
1301 fgets(buf, 100, fp);
1302 }
1303 char *ptr = strrchr(buf, '\n');
1304 *ptr = '\0';
1305 Arg x = { .s = buf };
1306 if (strlen(buf))
1307 return open_arg(&x);
1308 else {
1309 x.i = Error;
1310 x.s = g_strdup_printf("Quickmark %d not defined", b);
1311 echo(&x);
1312 g_free(x.s);
1313 return false;
1314 }
1315 } else { return false; }
1316 }
1317
1318 gboolean
1319 script(const Arg *arg) {
1320 gchar *value = NULL, *message = NULL;
1321 Arg a;
1322
1323 if (!arg->s) {
1324 set_error("Missing argument.");
1325 return FALSE;
1326 }
1327 jsapi_evaluate_script(arg->s, &value, &message);
1328 if (message) {
1329 set_error(message);
1330 if (arg->s)
1331 g_free(arg->s);
1332 return FALSE;
1333 }
1334 if (arg->i != Silent && value) {
1335 a.i = arg->i;
1336 a.s = g_strdup(value);
1337 echo(&a);
1338 g_free(a.s);
1339 }
1340 if (value) {
1341 if (strncmp(value, "fire;", 5) == 0) {
1342 count = 0;
1343 a.s = g_strconcat("hints.fire(", (value + 5), ");", NULL);
1344 a.i = Silent;
1345 script(&a);
1346 } else if (strncmp(value, "open;", 5) == 0) {
1347 count = 0;
1348 a.i = ModeNormal;
1349 set(&a);
1350 if (strncmp(followTarget, "new", 3) == 0)
1351 a.i = TargetNew;
1352 else
1353 a.i = TargetCurrent;
1354 a.s = (value + 5);
1355 open_arg(&a);
1356 }
1357 }
1358 if (arg->s)
1359 g_free(arg->s);
1360 g_free(value);
1361 return TRUE;
1362 }
1363
1364 gboolean
1365 scroll(const Arg *arg) {
1366 GtkAdjustment *adjust = (arg->i & OrientationHoriz) ? adjust_h : adjust_v;
1367 int max = gtk_adjustment_get_upper(adjust) - gtk_adjustment_get_page_size(adjust);
1368 float val = gtk_adjustment_get_value(adjust) / max * 100;
1369 int direction = (arg->i & (1 << 2)) ? 1 : -1;
1370
1371 if ((direction == 1 && val < 100) || (direction == -1 && val > 0)) {
1372 if (arg->i & ScrollMove)
1373 gtk_adjustment_set_value(adjust, gtk_adjustment_get_value(adjust) +
1374 direction * /* direction */
1375 ((arg->i & UnitLine || (arg->i & UnitBuffer && count)) ? (scrollstep * (count ? count : 1)) : (
1376 arg->i & UnitBuffer ? gtk_adjustment_get_page_size(adjust) / 2 :
1377 (count ? count : 1) * (gtk_adjustment_get_page_size(adjust) -
1378 (gtk_adjustment_get_page_size(adjust) > pagingkeep ? pagingkeep : 0)))));
1379 else
1380 gtk_adjustment_set_value(adjust,
1381 ((direction == 1) ? gtk_adjustment_get_upper : gtk_adjustment_get_lower)(adjust));
1382 update_state();
1383 }
1384 return TRUE;
1385 }
1386
1387 gboolean
1388 zoom(const Arg *arg) {
1389 webkit_web_view_set_full_content_zoom(webview, (arg->i & ZoomFullContent) > 0);
1390 webkit_web_view_set_zoom_level(webview, (arg->i & ZoomOut) ?
1391 webkit_web_view_get_zoom_level(webview) +
1392 (((float)(count ? count : 1)) * (arg->i & (1 << 1) ? 1.0 : -1.0) * zoomstep) :
1393 (count ? (float)count / 100.0 : 1.0));
1394 return TRUE;
1395 }
1396
1397 gboolean
1398 fake_key_event(const Arg *a) {
1399 if(!embed) {
1400 return FALSE;
1401 }
1402 Arg err;
1403 err.i = Error;
1404 Display *xdpy;
1405 if ( (xdpy = XOpenDisplay(NULL)) == NULL ) {
1406 err.s = g_strdup("Couldn't find the XDisplay.");
1407 echo(&err);
1408 g_free(err.s);
1409 return FALSE;
1410 }
1411
1412 XKeyEvent xk;
1413 xk.display = xdpy;
1414 xk.subwindow = None;
1415 xk.time = CurrentTime;
1416 xk.same_screen = True;
1417 xk.x = xk.y = xk.x_root = xk.y_root = 1;
1418 xk.window = embed;
1419 xk.state = a->i;
1420
1421 if( ! a->s ) {
1422 err.s = g_strdup("Zero pointer as argument! Check your config.h");
1423 echo(&err);
1424 g_free(err.s);
1425 return FALSE;
1426 }
1427
1428 KeySym keysym;
1429 if( (keysym = XStringToKeysym(a->s)) == NoSymbol ) {
1430 err.s = g_strdup_printf("Couldn't translate %s to keysym", a->s );
1431 echo(&err);
1432 g_free(err.s);
1433 return FALSE;
1434 }
1435
1436 if( (xk.keycode = XKeysymToKeycode(xdpy, keysym)) == NoSymbol ) {
1437 err.s = g_strdup("Couldn't translate keysym to keycode");
1438 echo(&err);
1439 g_free(err.s);
1440 return FALSE;
1441 }
1442
1443 xk.type = KeyPress;
1444 if( !XSendEvent(xdpy, embed, True, KeyPressMask, (XEvent *)&xk) ) {
1445 err.s = g_strdup("XSendEvent failed");
1446 echo(&err);
1447 g_free(err.s);
1448 return FALSE;
1449 }
1450 XFlush(xdpy);
1451
1452 return TRUE;
1453 }
1454
1455
1456 gboolean
1457 commandhistoryfetch(const Arg *arg) {
1458 if (arg->i == DirectionPrev) {
1459 commandpointer--;
1460 if (commandpointer < 0)
1461 commandpointer = maxcommands - 1;
1462 } else {
1463 commandpointer++;
1464 if (commandpointer == COMMANDHISTSIZE || commandpointer == maxcommands)
1465 commandpointer = 0;
1466 }
1467
1468 if (commandpointer < 0)
1469 return FALSE;
1470
1471 gtk_entry_set_text(GTK_ENTRY(inputbox), commandhistory[commandpointer ]);
1472 gtk_editable_set_position(GTK_EDITABLE(inputbox), -1);
1473 return TRUE;
1474 }
1475
1476
1477 gboolean
1478 bookmark(const Arg *arg) {
1479 FILE *f;
1480 const char *filename;
1481 const char *uri = webkit_web_view_get_uri(webview);
1482 const char *title = webkit_web_view_get_title(webview);
1483 filename = g_strdup_printf(BOOKMARKS_STORAGE_FILENAME);
1484 f = fopen(filename, "a");
1485 if (uri == NULL || strlen(uri) == 0) {
1486 set_error("No URI found to bookmark.");
1487 return FALSE;
1488 }
1489 if (f != NULL) {
1490 fprintf(f, "%s", uri);
1491 if (title != NULL) {
1492 fprintf(f, "%s", " ");
1493 fprintf(f, "%s", title);
1494 }
1495 if (arg->s && strlen(arg->s)) {
1496 build_taglist(arg, f);
1497 }
1498 fprintf(f, "%s", "\n");
1499 fclose(f);
1500 give_feedback( "Bookmark saved" );
1501 return TRUE;
1502 } else {
1503 set_error("Bookmarks file not found.");
1504 return FALSE;
1505 }
1506 }
1507
1508 gboolean
1509 history() {
1510 FILE *f;
1511 const char *filename;
1512 const char *uri = webkit_web_view_get_uri(webview);
1513 const char *title = webkit_web_view_get_title(webview);
1514 char *entry, buffer[512], *new;
1515 int n, i = 0;
1516 gboolean finished = FALSE;
1517 if (uri != NULL) {
1518 if (title != NULL) {
1519 entry = malloc((strlen(uri) + strlen(title) + 2) * sizeof(char));
1520 memset(entry, 0, strlen(uri) + strlen(title) + 2);
1521 } else {
1522 entry = malloc((strlen(uri) + 1) * sizeof(char));
1523 memset(entry, 0, strlen(uri) + 1);
1524 }
1525 if (entry != NULL) {
1526 strncpy(entry, uri, strlen(uri));
1527 if (title != NULL) {
1528 strncat(entry, " ", 1);
1529 strncat(entry, title, strlen(title));
1530 }
1531 n = strlen(entry);
1532 filename = g_strdup_printf(HISTORY_STORAGE_FILENAME);
1533 f = fopen(filename, "r");
1534 if (f != NULL) {
1535 new = (char *)malloc(HISTORY_MAX_ENTRIES * 512 * sizeof(char) + 1);
1536 if (new != NULL) {
1537 memset(new, 0, HISTORY_MAX_ENTRIES * 512 * sizeof(char) + 1);
1538 /* newest entries go on top */
1539 strncpy(new, entry, strlen(entry));
1540 strncat(new, "\n", 1);
1541 /* retain at most HISTORY_MAX_ENTIRES - 1 old entries */
1542 while (finished != TRUE) {
1543 if ((char *)NULL == fgets(buffer, 512, f)) {
1544 /* check if end of file was reached / error occured */
1545 if (!feof(f)) {
1546 break;
1547 }
1548 /* end of file reached */
1549 finished = TRUE;
1550 continue;
1551 }
1552 /* compare line (-1 because of newline character) */
1553 if (n != strlen(buffer) - 1 || strncmp(entry, buffer, n) != 0) {
1554 /* if the URI is already in history; we put it on top and skip it here */
1555 strncat(new, buffer, 512);
1556 i++;
1557 }
1558 if ((i + 1) >= HISTORY_MAX_ENTRIES) {
1559 break;
1560 }
1561 }
1562 fclose(f);
1563 }
1564 f = fopen(filename, "w");
1565 if (f != NULL) {
1566 fprintf(f, "%s", new);
1567 fclose(f);
1568 }
1569 if (new != NULL) {
1570 free(new);
1571 new = NULL;
1572 }
1573 }
1574 }
1575 if (entry != NULL) {
1576 free(entry);
1577 entry = NULL;
1578 }
1579 }
1580 return TRUE;
1581 }
1582
1583 static gboolean
1584 view_source(const Arg * arg) {
1585 gboolean current_mode = webkit_web_view_get_view_source_mode(webview);
1586 webkit_web_view_set_view_source_mode(webview, !current_mode);
1587 webkit_web_view_reload(webview);
1588 return TRUE;
1589 }
1590
1591 static gboolean
1592 focus_input(const Arg *arg) {
1593 static Arg a;
1594
1595 a.s = g_strconcat("hints.focusInput();", NULL);
1596 a.i = Silent;
1597 script(&a);
1598 update_state();
1599 return TRUE;
1600 }
1601
1602 static gboolean
1603 browser_settings(const Arg *arg) {
1604 char line[255];
1605 if (!arg->s) {
1606 set_error("Missing argument.");
1607 return FALSE;
1608 }
1609 strncpy(line, arg->s, 254);
1610 if (process_set_line(line))
1611 return TRUE;
1612 else {
1613 set_error("Invalid setting.");
1614 return FALSE;
1615 }
1616 }
1617
1618 char *
1619 search_word(int whichword) {
1620 int k = 0;
1621 static char word[240];
1622 char *c = my_pair.line;
1623
1624 while (isspace(*c) && *c)
1625 c++;
1626
1627 switch (whichword) {
1628 case 0:
1629 while (*c && !isspace (*c) && *c != '=' && k < 240) {
1630 word[k++] = *c;
1631 c++;
1632 }
1633 word[k] = '\0';
1634 strncpy(my_pair.what, word, 20);
1635 break;
1636 case 1:
1637 while (*c && k < 240) {
1638 word[k++] = *c;
1639 c++;
1640 }
1641 word[k] = '\0';
1642 strncpy(my_pair.value, word, 240);
1643 break;
1644 }
1645
1646 return c;
1647 }
1648
1649 static gboolean
1650 process_set_line(char *line) {
1651 char *c;
1652 int listlen, i;
1653 gboolean boolval;
1654 WebKitWebSettings *settings;
1655
1656 settings = webkit_web_view_get_settings(webview);
1657 my_pair.line = line;
1658 c = search_word(0);
1659 if (!strlen(my_pair.what))
1660 return FALSE;
1661
1662 while (isspace(*c) && *c)
1663 c++;
1664
1665 if (*c == ':' || *c == '=')
1666 c++;
1667
1668 my_pair.line = c;
1669 c = search_word(1);
1670
1671 listlen = LENGTH(browsersettings);
1672 for (i = 0; i < listlen; i++) {
1673 if (strlen(browsersettings[i].name) == strlen(my_pair.what) && strncmp(browsersettings[i].name, my_pair.what, strlen(my_pair.what)) == 0) {
1674 /* mandatory argument not provided */
1675 if (strlen(my_pair.value) == 0)
1676 return FALSE;
1677 /* process qmark? */
1678 if (strlen(my_pair.what) == 5 && strncmp("qmark", my_pair.what, 5) == 0) {
1679 return (process_save_qmark(my_pair.value, webview));
1680 }
1681 /* interpret boolean values */
1682 if (browsersettings[i].boolval) {
1683 if (strncmp(my_pair.value, "on", 2) == 0 || strncmp(my_pair.value, "true", 4) == 0 || strncmp(my_pair.value, "ON", 2) == 0 || strncmp(my_pair.value, "TRUE", 4) == 0) {
1684 boolval = TRUE;
1685 } else if (strncmp(my_pair.value, "off", 3) == 0 || strncmp(my_pair.value, "false", 5) == 0 || strncmp(my_pair.value, "OFF", 3) == 0 || strncmp(my_pair.value, "FALSE", 5) == 0) {
1686 boolval = FALSE;
1687 } else {
1688 return FALSE;
1689 }
1690 } else if (browsersettings[i].colourval) {
1691 /* interpret as hexadecimal colour */
1692 if (!parse_colour(my_pair.value)) {
1693 return FALSE;
1694 }
1695 }
1696 if (browsersettings[i].var != NULL) {
1697 /* write value into internal variable */
1698 /*if (browsersettings[i].intval) {
1699 browsersettings[i].var = atoi(my_pair.value);
1700 } else {*/
1701 strncpy(browsersettings[i].var, my_pair.value, MAX_SETTING_SIZE);
1702 if (strlen(my_pair.value) > MAX_SETTING_SIZE - 1) {
1703 /* in this case, \0 will not have been copied */
1704 browsersettings[i].var[MAX_SETTING_SIZE - 1] = '\0';
1705 /* in case this string is also used for a webkit setting, make sure it's consistent */
1706 my_pair.value[MAX_SETTING_SIZE - 1] = '\0';
1707 give_feedback("String too long; automatically truncated!");
1708 }
1709 /*}*/
1710 }
1711 if (strlen(browsersettings[i].webkit) > 0) {
1712 /* activate appropriate webkit setting */
1713 if (browsersettings[i].boolval) {
1714 g_object_set((GObject*)settings, browsersettings[i].webkit, boolval, NULL);
1715 } else if (browsersettings[i].intval) {
1716 g_object_set((GObject*)settings, browsersettings[i].webkit, atoi(my_pair.value), NULL);
1717 } else {
1718 g_object_set((GObject*)settings, browsersettings[i].webkit, my_pair.value, NULL);
1719 }
1720 webkit_web_view_set_settings(webview, settings);
1721 }
1722
1723 /* process acceptlanguage*/
1724 if (strlen(my_pair.what) == 14 && strncmp("acceptlanguage", my_pair.what, 14) == 0) {
1725 g_object_set(G_OBJECT(session), "accept-language", acceptlanguage, NULL);
1726 }
1727
1728 /* toggle proxy usage? */
1729 if (strlen(my_pair.what) == 5 && strncmp("proxy", my_pair.what, 5) == 0) {
1730 toggle_proxy(boolval);
1731 }
1732
1733 /* Toggle scrollbars. */
1734 if (strlen(my_pair.what) == 10 && strncmp("scrollbars", my_pair.what, 10) == 0)
1735 toggle_scrollbars(boolval);
1736
1737 /* Toggle widgets */
1738 if (strlen(my_pair.what) == 9 && strncmp("statusbar", my_pair.what, 9) == 0)
1739 gtk_widget_set_visible(GTK_WIDGET(statusbar), boolval);
1740 if (strlen(my_pair.what) == 8 && strncmp("inputbox", my_pair.what, 8) == 0)
1741 gtk_widget_set_visible(inputbox, boolval);
1742
1743 /* case sensitivity of completion */
1744 if (strlen(my_pair.what) == 14 && strncmp("completioncase", my_pair.what, 14) == 0)
1745 complete_case_sensitive = boolval;
1746
1747 /* reload page? */
1748 if (browsersettings[i].reload)
1749 webkit_web_view_reload(webview);
1750 return TRUE;
1751 }
1752 }
1753 return FALSE;
1754 }
1755
1756 gboolean
1757 process_line(char *line) {
1758 char *c = line;
1759 int i;
1760 size_t len, length = strlen(line);
1761 gboolean found = FALSE, success = FALSE;
1762 Arg a;
1763
1764 while (isspace(*c))
1765 c++;
1766 /* Ignore blank lines. */
1767 if (c[0] == '\0')
1768 return TRUE;
1769 for (i = 0; i < LENGTH(commands); i++) {
1770 if (commands[i].cmd == NULL)
1771 break;
1772 len = strlen(commands[i].cmd);
1773 if (length >= len && !strncmp(c, commands[i].cmd, len) && (c[len] == ' ' || !c[len])) {
1774 found = TRUE;
1775 a.i = commands[i].arg.i;
1776 a.s = length > len + 1 ? &c[len + 1] : commands[i].arg.s;
1777 success = commands[i].func(&a);
1778 break;
1779 }
1780 }
1781 save_command_history(c);
1782 if (!found) {
1783 a.i = Error;
1784 a.s = g_strdup_printf("Not a browser command: %s", c);
1785 echo(&a);
1786 } else if (!success) {
1787 a.i = Error;
1788 if (error_msg != NULL) {
1789 a.s = g_strdup_printf("%s", error_msg);
1790 g_free(error_msg);
1791 error_msg = NULL;
1792 } else {
1793 a.s = g_strdup_printf("Unknown error. Please file a bug report!");
1794 }
1795 echo(&a);
1796 g_free(a.s);
1797 }
1798 return success;
1799 }
1800
1801 static gboolean
1802 search_tag(const Arg * a) {
1803 FILE *f;
1804 const char *filename;
1805 const char *tag = a->s;
1806 char s[BUFFERSIZE], foundtag[40], url[BUFFERSIZE];
1807 int t, i, intag, k;
1808
1809 if (!tag) {
1810 /* The user must give us something to load up. */
1811 set_error("Bookmark tag required with this option.");
1812 return FALSE;
1813 }
1814
1815 if (strlen(tag) > MAXTAGSIZE) {
1816 set_error("Tag too long.");
1817 return FALSE;
1818 }
1819
1820 filename = g_strdup_printf(BOOKMARKS_STORAGE_FILENAME);
1821 f = fopen(filename, "r");
1822 if (f == NULL) {
1823 set_error("Couldn't open bookmarks file.");
1824 return FALSE;
1825 }
1826 while (fgets(s, BUFFERSIZE-1, f)) {
1827 intag = 0;
1828 t = strlen(s) - 1;
1829 while (isspace(s[t]))
1830 t--;
1831 if (s[t] != ']') continue;
1832 while (t > 0) {
1833 if (s[t] == ']') {
1834 if (!intag)
1835 intag = t;
1836 else
1837 intag = 0;
1838 } else {
1839 if (s[t] == '[') {
1840 if (intag) {
1841 i = 0;
1842 k = t + 1;
1843 while (k < intag)
1844 foundtag[i++] = s[k++];
1845 foundtag[i] = '\0';
1846 /* foundtag now contains the tag */
1847 if (strlen(foundtag) < MAXTAGSIZE && strcmp(tag, foundtag) == 0) {
1848 i = 0;
1849 while (isspace(s[i])) i++;
1850 k = 0;
1851 while (s[i] && !isspace(s[i])) url[k++] = s[i++];
1852 url[k] = '\0';
1853 Arg x = { .i = TargetNew, .s = url };
1854 open_arg(&x);
1855 }
1856 }
1857 intag = 0;
1858 }
1859 }
1860 t--;
1861 }
1862 }
1863 return TRUE;
1864 }
1865
1866 void
1867 toggle_proxy(gboolean onoff) {
1868 SoupURI *proxy_uri;
1869 char *filename, *new;
1870 int len;
1871
1872 if (onoff == FALSE) {
1873 g_object_set(session, "proxy-uri", NULL, NULL);
1874 give_feedback("Proxy deactivated");
1875 } else {
1876 filename = (char *)g_getenv("http_proxy");
1877
1878 /* Fallthrough to checking HTTP_PROXY as well, since this can also be
1879 * defined.
1880 */
1881 if (filename == NULL)
1882 filename = (char *)g_getenv("HTTP_PROXY");
1883
1884 if (filename != NULL && 0 < (len = strlen(filename))) {
1885 if (strstr(filename, "://") == NULL) {
1886 /* prepend http:// */
1887 new = g_malloc(sizeof("http://") + len);
1888 strcpy(new, "http://");
1889 memcpy(&new[sizeof("http://") - 1], filename, len + 1);
1890 proxy_uri = soup_uri_new(new);
1891 } else {
1892 proxy_uri = soup_uri_new(filename);
1893 }
1894 g_object_set(session, "proxy-uri", proxy_uri, NULL);
1895 give_feedback("Proxy activated");
1896 }
1897 }
1898 }
1899
1900 void
1901 toggle_scrollbars(gboolean onoff) {
1902 if (onoff == TRUE) {
1903 adjust_h = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(viewport));
1904 adjust_v = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(viewport));
1905 }
1906 else {
1907 adjust_v = gtk_range_get_adjustment(GTK_RANGE(scroll_v));
1908 adjust_h = gtk_range_get_adjustment(GTK_RANGE(scroll_h));
1909 }
1910 gtk_widget_set_scroll_adjustments (GTK_WIDGET(webview), adjust_h, adjust_v);
1911
1912 return;
1913 }
1914
1915 void
1916 update_url(const char *uri) {
1917 gboolean ssl = g_str_has_prefix(uri, "https://");
1918 GdkColor color;
1919 #ifdef ENABLE_HISTORY_INDICATOR
1920 char before[] = " [";
1921 char after[] = "]";
1922 gboolean back = webkit_web_view_can_go_back(webview);
1923 gboolean fwd = webkit_web_view_can_go_forward(webview);
1924
1925 if (!back && !fwd)
1926 before[0] = after[0] = '\0';
1927 #endif
1928 gtk_label_set_markup(GTK_LABEL(status_url), g_markup_printf_escaped(
1929 #ifdef ENABLE_HISTORY_INDICATOR
1930 "<span font=\"%s\">%s%s%s%s%s</span>", statusfont, uri,
1931 before, back ? "+" : "", fwd ? "-" : "", after
1932 #else
1933 "<span font=\"%s\">%s</span>", statusfont, uri
1934 #endif
1935 ));
1936 gdk_color_parse(ssl ? sslbgcolor : statusbgcolor, &color);
1937 gtk_widget_modify_bg(eventbox, GTK_STATE_NORMAL, &color);
1938 gdk_color_parse(ssl ? sslcolor : statuscolor, &color);
1939 gtk_widget_modify_fg(GTK_WIDGET(status_url), GTK_STATE_NORMAL, &color);
1940 gtk_widget_modify_fg(GTK_WIDGET(status_state), GTK_STATE_NORMAL, &color);
1941 }
1942
1943 void
1944 update_state() {
1945 char *markup;
1946 int download_count = g_list_length(activeDownloads);
1947 GString *status = g_string_new("");
1948
1949 /* construct the status line */
1950
1951 /* count, modkey and input buffer */
1952 g_string_append_printf(status, "%.0d", count);
1953 if (current_modkey) g_string_append_c(status, current_modkey);
1954
1955 /* the number of active downloads */
1956 if (activeDownloads) {
1957 g_string_append_printf(status, " %d active %s", download_count,
1958 (download_count == 1) ? "download" : "downloads");
1959 }
1960
1961 #ifdef ENABLE_WGET_PROGRESS_BAR
1962 /* the progressbar */
1963 {
1964 int progress = -1;
1965 char progressbar[progressbartick + 1];
1966
1967 if (activeDownloads) {
1968 progress = 0;
1969 GList *ptr;
1970
1971 for (ptr = activeDownloads; ptr; ptr = g_list_next(ptr)) {
1972 progress += 100 * webkit_download_get_progress(ptr->data);
1973 }
1974
1975 progress /= download_count;
1976
1977 } else if (webkit_web_view_get_load_status(webview) != WEBKIT_LOAD_FINISHED
1978 && webkit_web_view_get_load_status(webview) != WEBKIT_LOAD_FAILED) {
1979
1980 progress = webkit_web_view_get_progress(webview) * 100;
1981 }
1982
1983 if (progress >= 0) {
1984 ascii_bar(progressbartick, progress * progressbartick / 100, progressbar);
1985 g_string_append_printf(status, " %c%s%c",
1986 progressborderleft, progressbar, progressborderright);
1987 }
1988 }
1989 #endif
1990
1991 /* and the current scroll position */
1992 {
1993 int max = gtk_adjustment_get_upper(adjust_v) - gtk_adjustment_get_page_size(adjust_v);
1994 int val = (int)(gtk_adjustment_get_value(adjust_v) / max * 100);
1995
1996 if (max == 0)
1997 g_string_append(status, " All");
1998 else if (val == 0)
1999 g_string_append(status, " Top");
2000 else if (val == 100)
2001 g_string_append(status, " Bot");
2002 else
2003 g_string_append_printf(status, " %d%%", val);
2004 }
2005
2006
2007 markup = g_markup_printf_escaped("<span font=\"%s\">%s</span>", statusfont, status->str);
2008 gtk_label_set_markup(GTK_LABEL(status_state), markup);
2009
2010 g_string_free(status, TRUE);
2011 }
2012
2013 void
2014 setup_modkeys() {
2015 unsigned int i;
2016 modkeys = calloc(LENGTH(keys) + 1, sizeof(char));
2017 char *ptr = modkeys;
2018
2019 for (i = 0; i < LENGTH(keys); i++)
2020 if (keys[i].modkey && !strchr(modkeys, keys[i].modkey))
2021 *(ptr++) = keys[i].modkey;
2022 modkeys = realloc(modkeys, &ptr[0] - &modkeys[0] + 1);
2023 }
2024
2025 void
2026 setup_gui() {
2027 scroll_h = GTK_SCROLLBAR(gtk_hscrollbar_new(NULL));
2028 scroll_v = GTK_SCROLLBAR(gtk_vscrollbar_new(NULL));
2029 adjust_h = gtk_range_get_adjustment(GTK_RANGE(scroll_h));
2030 adjust_v = gtk_range_get_adjustment(GTK_RANGE(scroll_v));
2031 if (embed) {
2032 window = GTK_WINDOW(gtk_plug_new(embed));
2033 } else {
2034 window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
2035 gtk_window_set_wmclass(GTK_WINDOW(window), "vimprobable2", "Vimprobable2");
2036 }
2037 gtk_window_set_default_size(GTK_WINDOW(window), 640, 480);
2038 box = GTK_BOX(gtk_vbox_new(FALSE, 0));
2039 inputbox = gtk_entry_new();
2040 webview = (WebKitWebView*)webkit_web_view_new();
2041 statusbar = GTK_BOX(gtk_hbox_new(FALSE, 0));
2042 eventbox = gtk_event_box_new();
2043 status_url = gtk_label_new(NULL);
2044 status_state = gtk_label_new(NULL);
2045 GdkColor bg;
2046 PangoFontDescription *font;
2047 GdkGeometry hints = { 1, 1 };
2048 inspector = webkit_web_view_get_inspector(WEBKIT_WEB_VIEW(webview));
2049
2050 clipboards[0] = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
2051 clipboards[1] = gtk_clipboard_get(GDK_NONE);
2052 setup_settings();
2053 gdk_color_parse(statusbgcolor, &bg);
2054 gtk_widget_modify_bg(eventbox, GTK_STATE_NORMAL, &bg);
2055 gtk_widget_set_name(GTK_WIDGET(window), "Vimprobable2");
2056 gtk_window_set_geometry_hints(window, NULL, &hints, GDK_HINT_MIN_SIZE);
2057
2058 #ifdef DISABLE_SCROLLBAR
2059 viewport = gtk_scrolled_window_new(NULL, NULL);
2060 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(viewport), GTK_POLICY_NEVER, GTK_POLICY_NEVER);
2061 #else
2062 /* Ensure we still see scrollbars. */
2063 GtkWidget *viewport = gtk_scrolled_window_new(adjust_h, adjust_v);
2064 #endif
2065
2066 setup_signals();
2067 gtk_container_add(GTK_CONTAINER(viewport), GTK_WIDGET(webview));
2068
2069 /* Ensure we set the scroll adjustments now, so that if we're not drawing
2070 * titlebars, we can still scroll.
2071 */
2072 gtk_widget_set_scroll_adjustments(GTK_WIDGET(webview), adjust_h, adjust_v);
2073
2074 font = pango_font_description_from_string(urlboxfont[0]);
2075 gtk_widget_modify_font(GTK_WIDGET(inputbox), font);
2076 pango_font_description_free(font);
2077 gtk_entry_set_inner_border(GTK_ENTRY(inputbox), NULL);
2078 gtk_misc_set_alignment(GTK_MISC(status_url), 0.0, 0.0);
2079 gtk_misc_set_alignment(GTK_MISC(status_state), 1.0, 0.0);
2080 gtk_box_pack_start(statusbar, status_url, TRUE, TRUE, 2);
2081 gtk_box_pack_start(statusbar, status_state, FALSE, FALSE, 2);
2082 gtk_container_add(GTK_CONTAINER(eventbox), GTK_WIDGET(statusbar));
2083 gtk_box_pack_start(box, viewport, TRUE, TRUE, 0);
2084 gtk_box_pack_start(box, eventbox, FALSE, FALSE, 0);
2085 gtk_entry_set_has_frame(GTK_ENTRY(inputbox), FALSE);
2086 gtk_box_pack_end(box, inputbox, FALSE, FALSE, 0);
2087 gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(box));
2088 gtk_widget_grab_focus(GTK_WIDGET(webview));
2089 gtk_widget_show_all(GTK_WIDGET(window));
2090 }
2091
2092 void
2093 setup_settings() {
2094 WebKitWebSettings *settings = (WebKitWebSettings*)webkit_web_settings_new();
2095 SoupURI *proxy_uri;
2096 char *filename, *new;
2097 int len;
2098
2099 session = webkit_get_default_session();
2100 g_object_set(G_OBJECT(settings), "default-font-size", DEFAULT_FONT_SIZE, NULL);
2101 g_object_set(G_OBJECT(settings), "enable-scripts", enablePlugins, NULL);
2102 g_object_set(G_OBJECT(settings), "enable-plugins", enablePlugins, NULL);
2103 g_object_set(G_OBJECT(settings), "enable-java-applet", enableJava, NULL);
2104 g_object_set(G_OBJECT(settings), "enable-page-cache", enablePagecache, NULL);
2105 filename = g_strdup_printf(USER_STYLESHEET);
2106 filename = g_strdup_printf("file://%s", filename);
2107 g_object_set(G_OBJECT(settings), "user-stylesheet-uri", filename, NULL);
2108 g_object_set(G_OBJECT(settings), "user-agent", useragent, NULL);
2109 g_object_get(G_OBJECT(settings), "zoom-step", &zoomstep, NULL);
2110 webkit_web_view_set_settings(webview, settings);
2111
2112 /* proxy */
2113 if (use_proxy == TRUE) {
2114 filename = (char *)g_getenv("http_proxy");
2115 if (filename != NULL && 0 < (len = strlen(filename))) {
2116 if (strstr(filename, "://") == NULL) {
2117 /* prepend http:// */
2118 new = g_malloc(sizeof("http://") + len);
2119 strcpy(new, "http://");
2120 memcpy(&new[sizeof("http://") - 1], filename, len + 1);
2121 proxy_uri = soup_uri_new(new);
2122 } else {
2123 proxy_uri = soup_uri_new(filename);
2124 }
2125 g_object_set(session, "proxy-uri", proxy_uri, NULL);
2126 }
2127 }
2128 }
2129
2130 void
2131 setup_signals() {
2132 #ifdef ENABLE_COOKIE_SUPPORT
2133 /* Headers. */
2134 g_signal_connect_after(G_OBJECT(session), "request-started", G_CALLBACK(new_generic_request), NULL);
2135 #endif
2136 /* Accept-language header */
2137 g_object_set(G_OBJECT(session), "accept-language", acceptlanguage, NULL);
2138 /* window */
2139 g_object_connect(G_OBJECT(window),
2140 "signal::destroy", G_CALLBACK(window_destroyed_cb), NULL,
2141 NULL);
2142 /* webview */
2143 g_object_connect(G_OBJECT(webview),
2144 "signal::title-changed", G_CALLBACK(webview_title_changed_cb), NULL,
2145 "signal::load-progress-changed", G_CALLBACK(webview_progress_changed_cb), NULL,
2146 "signal::load-committed", G_CALLBACK(webview_load_committed_cb), NULL,
2147 "signal::load-finished", G_CALLBACK(webview_load_finished_cb), NULL,
2148 "signal::navigation-policy-decision-requested", G_CALLBACK(webview_navigation_cb), NULL,
2149 "signal::new-window-policy-decision-requested", G_CALLBACK(webview_new_window_cb), NULL,
2150 "signal::mime-type-policy-decision-requested", G_CALLBACK(webview_mimetype_cb), NULL,
2151 "signal::download-requested", G_CALLBACK(webview_download_cb), NULL,
2152 "signal::key-press-event", G_CALLBACK(webview_keypress_cb), NULL,
2153 "signal::hovering-over-link", G_CALLBACK(webview_hoverlink_cb), NULL,
2154 "signal::console-message", G_CALLBACK(webview_console_cb), NULL,
2155 "signal::create-web-view", G_CALLBACK(webview_open_in_new_window_cb), NULL,
2156 "signal::event", G_CALLBACK(notify_event_cb), NULL,
2157 NULL);
2158 /* webview adjustment */
2159 g_object_connect(G_OBJECT(adjust_v),
2160 "signal::value-changed", G_CALLBACK(webview_scroll_cb), NULL,
2161 NULL);
2162 /* inputbox */
2163 g_object_connect(G_OBJECT(inputbox),
2164 "signal::activate", G_CALLBACK(inputbox_activate_cb), NULL,
2165 "signal::key-press-event", G_CALLBACK(inputbox_keypress_cb), NULL,
2166 "signal::key-release-event", G_CALLBACK(inputbox_keyrelease_cb), NULL,
2167 #ifdef ENABLE_INCREMENTAL_SEARCH
2168 "signal::changed", G_CALLBACK(inputbox_changed_cb), NULL,
2169 #endif
2170 NULL);
2171 /* inspector */
2172 g_signal_connect(G_OBJECT(inspector),
2173 "inspect-web-view", G_CALLBACK(inspector_inspect_web_view_cb), NULL);
2174 }
2175
2176 #ifdef ENABLE_COOKIE_SUPPORT
2177 void
2178 setup_cookies()
2179 {
2180 if (file_cookie_jar)
2181 g_object_unref(file_cookie_jar);
2182
2183 if (session_cookie_jar)
2184 g_object_unref(session_cookie_jar);
2185
2186 session_cookie_jar = soup_cookie_jar_new();
2187
2188 cookie_store = g_strdup_printf(COOKIES_STORAGE_FILENAME);
2189
2190 load_all_cookies();
2191
2192 g_signal_connect(G_OBJECT(file_cookie_jar), "changed",
2193 G_CALLBACK(update_cookie_jar), NULL);
2194
2195 return;
2196 }
2197
2198 /* TA: XXX - we should be using this callback for any header-requests we
2199 * receive (hence the name "new_generic_request" -- but for now, its use
2200 * is limited to handling cookies.
2201 */
2202 void
2203 new_generic_request(SoupSession *session, SoupMessage *soup_msg, gpointer unused) {
2204 SoupMessageHeaders *soup_msg_h;
2205 SoupURI *uri;
2206 const char *cookie_str;
2207
2208 soup_msg_h = soup_msg->request_headers;
2209 soup_message_headers_remove(soup_msg_h, "Cookie");
2210 uri = soup_message_get_uri(soup_msg);
2211 if( (cookie_str = get_cookies(uri)) )
2212 soup_message_headers_append(soup_msg_h, "Cookie", cookie_str);
2213
2214 g_signal_connect_after(G_OBJECT(soup_msg), "got-headers", G_CALLBACK(handle_cookie_request), NULL);
2215
2216 return;
2217 }
2218
2219 const char *
2220 get_cookies(SoupURI *soup_uri) {
2221 const char *cookie_str;
2222
2223 cookie_str = soup_cookie_jar_get_cookies(file_cookie_jar, soup_uri, TRUE);
2224
2225 return cookie_str;
2226 }
2227
2228 void
2229 handle_cookie_request(SoupMessage *soup_msg, gpointer unused)
2230 {
2231 GSList *resp_cookie = NULL;
2232 SoupCookie *cookie;
2233
2234 for(resp_cookie = soup_cookies_from_response(soup_msg);
2235 resp_cookie;
2236 resp_cookie = g_slist_next(resp_cookie))
2237 {
2238 SoupDate *soup_date;
2239 cookie = soup_cookie_copy((SoupCookie *)resp_cookie->data);
2240
2241 if (cookie_timeout && cookie->expires == NULL) {
2242 soup_date = soup_date_new_from_time_t(time(NULL) + cookie_timeout * 10);
2243 soup_cookie_set_expires(cookie, soup_date);
2244 }
2245 soup_cookie_jar_add_cookie(file_cookie_jar, cookie);
2246 }
2247
2248 return;
2249 }
2250
2251 void
2252 update_cookie_jar(SoupCookieJar *jar, SoupCookie *old, SoupCookie *new)
2253 {
2254 if (!new) {
2255 /* Nothing to do. */
2256 return;
2257 }
2258
2259 SoupCookie *copy;
2260 copy = soup_cookie_copy(new);
2261
2262 soup_cookie_jar_add_cookie(session_cookie_jar, copy);
2263
2264 return;
2265 }
2266
2267 void
2268 load_all_cookies(void)
2269 {
2270 file_cookie_jar = soup_cookie_jar_text_new(cookie_store, COOKIES_STORAGE_READONLY);
2271
2272 /* Put them back in the session store. */
2273 GSList *cookies_from_file = soup_cookie_jar_all_cookies(file_cookie_jar);
2274
2275 for (; cookies_from_file;
2276 cookies_from_file = cookies_from_file->next)
2277 {
2278 soup_cookie_jar_add_cookie(session_cookie_jar, cookies_from_file->data);
2279 }
2280
2281 soup_cookies_free(cookies_from_file);
2282
2283 return;
2284 }
2285
2286 #endif
2287
2288 void
2289 mop_up(void) {
2290 /* Free up any nasty globals before exiting. */
2291 #ifdef ENABLE_COOKIE_SUPPORT
2292 if (cookie_store)
2293 g_free(cookie_store);
2294 #endif
2295 return;
2296 }
2297
2298 int
2299 main(int argc, char *argv[]) {
2300 static Arg a;
2301 static char url[256] = "";
2302 static gboolean ver = false;
2303 static gboolean configfile_exists = FALSE;
2304 static const char *cfile = NULL;
2305 char *searchengines_file;
2306 static GOptionEntry opts[] = {
2307 { "version", 'v', 0, G_OPTION_ARG_NONE, &ver, "print version", NULL },
2308 { "embed", 'e', 0, G_OPTION_ARG_STRING, &winid, "embedded", NULL },
2309 { "configfile", 'c', 0, G_OPTION_ARG_STRING, &cfile, "config file", NULL },
2310 { NULL }
2311 };
2312 static GError *err;
2313 args = argv;
2314
2315 /* command line argument: version */
2316 if (!gtk_init_with_args(&argc, &argv, "[<uri>]", opts, NULL, &err)) {
2317 g_printerr("can't init gtk: %s\n", err->message);
2318 g_error_free(err);
2319 return EXIT_FAILURE;
2320 }
2321
2322 if (ver) {
2323 printf("%s\n", INTERNAL_VERSION);
2324 return EXIT_SUCCESS;
2325 }
2326
2327 if (cfile)
2328 configfile = g_strdup_printf(cfile);
2329 else
2330 configfile = g_strdup_printf(RCFILE);
2331
2332 if (!g_thread_supported())
2333 g_thread_init(NULL);
2334
2335 if (winid)
2336 embed = atoi(winid);
2337
2338 setup_modkeys();
2339 make_keyslist();
2340 setup_gui();
2341 #ifdef ENABLE_COOKIE_SUPPORT
2342 setup_cookies();
2343 #endif
2344
2345 /* Check if the specified file exists. */
2346 /* And only warn the user, if they explicitly asked for a config on the
2347 * command line.
2348 */
2349 if (!(access(configfile, F_OK) == 0) && cfile) {
2350 char *feedback_str;
2351
2352 feedback_str = g_strdup_printf("Config file '%s' doesn't exist", cfile);
2353 give_feedback(feedback_str);
2354 } else if ((access(configfile, F_OK) == 0))
2355 configfile_exists = true;
2356
2357 /* read config file */
2358 /* But only report errors if we failed, and the file existed. */
2359 if (!read_rcfile(configfile) && configfile_exists) {
2360 a.i = Error;
2361 a.s = g_strdup_printf("Error in config file '%s'", configfile);
2362 echo(&a);
2363 g_free(a.s);
2364 g_free(configfile);
2365 }
2366
2367 make_searchengines_list(searchengines, LENGTH(searchengines));
2368
2369 /* read searchengines. */
2370 searchengines_file = g_strdup_printf(SEARCHENGINES_STORAGE_FILENAME);
2371 switch (read_searchengines(searchengines_file)) {
2372 case SYNTAX_ERROR:
2373 a.i = Error;
2374 a.s = g_strdup_printf("Syntax error in searchengines file '%s'", searchengines_file);
2375 echo(&a);
2376 break;
2377 case READING_FAILED:
2378 a.i = Error;
2379 a.s = g_strdup_printf("Could not read searchengines file '%s'", searchengines_file);
2380 echo(&a);
2381 break;
2382 default:
2383 break;
2384 }
2385 g_free(searchengines_file);
2386
2387 /* command line argument: URL */
2388 if (argc > 1) {
2389 strncpy(url, argv[argc - 1], 255);
2390 } else {
2391 strncpy(url, startpage, 255);
2392 }
2393
2394 a.i = TargetCurrent;
2395 a.s = url;
2396 open_arg(&a);
2397 gtk_main();
2398
2399 mop_up();
2400
2401 return EXIT_SUCCESS;
2402 }
Vimprobable is a web browser like Vimperator using libwebkit instead.