X-Git-Url: https://vcs.maemo.org/git/?a=blobdiff_plain;f=uzbl.c;h=1bb5ee2d304d32aa41b087e87796cd2a23334c31;hb=HEAD;hp=c31b41c7faa910875028268a272e37064e08d9ec;hpb=fe84dba46082f9cc949b86e2fd32c6e055aec0a0;p=uzbl-mobile diff --git a/uzbl.c b/uzbl.c index c31b41c..1bb5ee2 100644 --- a/uzbl.c +++ b/uzbl.c @@ -31,7 +31,6 @@ #define LENGTH(x) (sizeof x / sizeof x[0]) -#define MAX_BINDINGS 256 #define _POSIX_SOURCE #include @@ -54,113 +53,146 @@ #include #include #include +#include +#include +#include +#include +#include #include "uzbl.h" #include "config.h" -static Uzbl uzbl; - - +Uzbl uzbl; /* commandline arguments (set initial values for the state variables) */ -static const +const GOptionEntry entries[] = { - { "uri", 'u', 0, G_OPTION_ARG_STRING, &uzbl.state.uri, - "Uri to load at startup (equivalent to 'set uri = URI')", "URI" }, - { "verbose", 'v', 0, G_OPTION_ARG_NONE, &uzbl.state.verbose, + { "uri", 'u', 0, G_OPTION_ARG_STRING, &uzbl.state.uri, + "Uri to load at startup (equivalent to 'uzbl ' or 'set uri = URI' after uzbl has launched)", "URI" }, + { "verbose", 'v', 0, G_OPTION_ARG_NONE, &uzbl.state.verbose, "Whether to print all messages or just errors.", NULL }, - { "name", 'n', 0, G_OPTION_ARG_STRING, &uzbl.state.instance_name, + { "name", 'n', 0, G_OPTION_ARG_STRING, &uzbl.state.instance_name, "Name of the current instance (defaults to Xorg window id)", "NAME" }, - { "config", 'c', 0, G_OPTION_ARG_STRING, &uzbl.state.config_file, - "Config file (this is pretty much equivalent to uzbl < FILE )", "FILE" }, - { "socket", 's', 0, G_OPTION_ARG_INT, &uzbl.state.socket_id, + { "config", 'c', 0, G_OPTION_ARG_STRING, &uzbl.state.config_file, + "Path to config file or '-' for stdin", "FILE" }, + { "socket", 's', 0, G_OPTION_ARG_INT, &uzbl.state.socket_id, "Socket ID", "SOCKET" }, + { "geometry", 'g', 0, G_OPTION_ARG_STRING, &uzbl.gui.geometry, + "Set window geometry (format: WIDTHxHEIGHT+-X+-Y)", "GEOMETRY" }, { "version", 'V', 0, G_OPTION_ARG_NONE, &uzbl.behave.print_version, "Print the version and exit", NULL }, { NULL, 0, 0, 0, NULL, NULL, NULL } }; +enum ptr_type {TYPE_INT, TYPE_STR, TYPE_FLOAT}; + /* associate command names to their properties */ -typedef const struct { - void **ptr; - int type; +typedef struct { + enum ptr_type type; + union { + int *i; + float *f; + gchar **s; + } ptr; int dump; - void (*func)(void); + int writeable; + /*@null@*/ void (*func)(void); } uzbl_cmdprop; -enum {TYPE_INT, TYPE_STR, TYPE_FLOAT}; +/* abbreviations to help keep the table's width humane */ +#define PTR_V_STR(var, d, fun) { .ptr.s = &(var), .type = TYPE_STR, .dump = d, .writeable = 1, .func = fun } +#define PTR_V_INT(var, d, fun) { .ptr.i = (int*)&(var), .type = TYPE_INT, .dump = d, .writeable = 1, .func = fun } +#define PTR_V_FLOAT(var, d, fun) { .ptr.f = &(var), .type = TYPE_FLOAT, .dump = d, .writeable = 1, .func = fun } +#define PTR_C_STR(var, fun) { .ptr.s = &(var), .type = TYPE_STR, .dump = 0, .writeable = 0, .func = fun } +#define PTR_C_INT(var, fun) { .ptr.i = (int*)&(var), .type = TYPE_INT, .dump = 0, .writeable = 0, .func = fun } +#define PTR_C_FLOAT(var, fun) { .ptr.f = &(var), .type = TYPE_FLOAT, .dump = 0, .writeable = 0, .func = fun } -/* an abbreviation to help keep the table's width humane */ -#define PTR(var, t, d, fun) { .ptr = (void*)&(var), .type = TYPE_##t, .dump = d, .func = fun } - -const struct { - char *name; +const struct var_name_to_ptr_t { + const char *name; uzbl_cmdprop cp; } var_name_to_ptr[] = { -/* variable name pointer to variable in code type dump callback function */ -/* --------------------------------------------------------------------------------------- */ - { "uri", PTR(uzbl.state.uri, STR, 1, cmd_load_uri)}, - { "verbose", PTR(uzbl.state.verbose, INT, 1, NULL)}, - { "mode", PTR(uzbl.behave.mode, INT, 0, NULL)}, - { "inject_html", PTR(uzbl.behave.inject_html, STR, 0, cmd_inject_html)}, - { "base_url", PTR(uzbl.behave.base_url, STR, 1, NULL)}, - { "html_endmarker", PTR(uzbl.behave.html_endmarker, STR, 1, NULL)}, - { "html_mode_timeout", PTR(uzbl.behave.html_timeout, INT, 1, NULL)}, - { "status_message", PTR(uzbl.gui.sbar.msg, STR, 1, update_title)}, - { "show_status", PTR(uzbl.behave.show_status, INT, 1, cmd_set_status)}, - { "status_top", PTR(uzbl.behave.status_top, INT, 1, move_statusbar)}, - { "status_format", PTR(uzbl.behave.status_format, STR, 1, update_title)}, - { "status_pbar_done", PTR(uzbl.gui.sbar.progress_s, STR, 1, update_title)}, - { "status_pbar_pending", PTR(uzbl.gui.sbar.progress_u, STR, 1, update_title)}, - { "status_pbar_width", PTR(uzbl.gui.sbar.progress_w, INT, 1, update_title)}, - { "status_background", PTR(uzbl.behave.status_background, STR, 1, update_title)}, - { "insert_indicator", PTR(uzbl.behave.insert_indicator, STR, 1, update_title)}, - { "command_indicator", PTR(uzbl.behave.cmd_indicator, STR, 1, update_title)}, - { "title_format_long", PTR(uzbl.behave.title_format_long, STR, 1, update_title)}, - { "title_format_short", PTR(uzbl.behave.title_format_short, STR, 1, update_title)}, - { "icon", PTR(uzbl.gui.icon, STR, 1, set_icon)}, - { "insert_mode", PTR(uzbl.behave.insert_mode, INT, 1, NULL)}, - { "always_insert_mode", PTR(uzbl.behave.always_insert_mode, INT, 1, cmd_always_insert_mode)}, - { "reset_command_mode", PTR(uzbl.behave.reset_command_mode, INT, 1, NULL)}, - { "modkey", PTR(uzbl.behave.modkey, STR, 1, cmd_modkey)}, - { "load_finish_handler", PTR(uzbl.behave.load_finish_handler, STR, 1, NULL)}, - { "load_start_handler", PTR(uzbl.behave.load_start_handler, STR, 1, NULL)}, - { "load_commit_handler", PTR(uzbl.behave.load_commit_handler, STR, 1, NULL)}, - { "history_handler", PTR(uzbl.behave.history_handler, STR, 1, NULL)}, - { "download_handler", PTR(uzbl.behave.download_handler, STR, 1, NULL)}, - { "cookie_handler", PTR(uzbl.behave.cookie_handler, STR, 1, cmd_cookie_handler)}, - { "new_window", PTR(uzbl.behave.new_window, STR, 1, cmd_new_window)}, - { "fifo_dir", PTR(uzbl.behave.fifo_dir, STR, 1, cmd_fifo_dir)}, - { "socket_dir", PTR(uzbl.behave.socket_dir, STR, 1, cmd_socket_dir)}, - { "http_debug", PTR(uzbl.behave.http_debug, INT, 1, cmd_http_debug)}, - { "shell_cmd", PTR(uzbl.behave.shell_cmd, STR, 1, NULL)}, - { "proxy_url", PTR(uzbl.net.proxy_url, STR, 1, set_proxy_url)}, - { "max_conns", PTR(uzbl.net.max_conns, INT, 1, cmd_max_conns)}, - { "max_conns_host", PTR(uzbl.net.max_conns_host, INT, 1, cmd_max_conns_host)}, - { "useragent", PTR(uzbl.net.useragent, STR, 1, cmd_useragent)}, +/* variable name pointer to variable in code dump callback function */ +/* ---------------------------------------------------------------------------------------------- */ + { "uri", PTR_V_STR(uzbl.state.uri, 1, cmd_load_uri)}, + { "verbose", PTR_V_INT(uzbl.state.verbose, 1, NULL)}, + { "inject_html", PTR_V_STR(uzbl.behave.inject_html, 0, cmd_inject_html)}, + { "keycmd", PTR_V_STR(uzbl.state.keycmd, 1, set_keycmd)}, + { "status_message", PTR_V_STR(uzbl.gui.sbar.msg, 1, update_title)}, + { "show_status", PTR_V_INT(uzbl.behave.show_status, 1, cmd_set_status)}, + { "status_top", PTR_V_INT(uzbl.behave.status_top, 1, move_statusbar)}, + { "status_format", PTR_V_STR(uzbl.behave.status_format, 1, update_title)}, + { "status_pbar_done", PTR_V_STR(uzbl.gui.sbar.progress_s, 1, update_title)}, + { "status_pbar_pending", PTR_V_STR(uzbl.gui.sbar.progress_u, 1, update_title)}, + { "status_pbar_width", PTR_V_INT(uzbl.gui.sbar.progress_w, 1, update_title)}, + { "status_background", PTR_V_STR(uzbl.behave.status_background, 1, update_title)}, + { "insert_indicator", PTR_V_STR(uzbl.behave.insert_indicator, 1, update_indicator)}, + { "command_indicator", PTR_V_STR(uzbl.behave.cmd_indicator, 1, update_indicator)}, + { "title_format_long", PTR_V_STR(uzbl.behave.title_format_long, 1, update_title)}, + { "title_format_short", PTR_V_STR(uzbl.behave.title_format_short, 1, update_title)}, + { "icon", PTR_V_STR(uzbl.gui.icon, 1, set_icon)}, + { "insert_mode", PTR_V_INT(uzbl.behave.insert_mode, 1, set_mode_indicator)}, + { "always_insert_mode", PTR_V_INT(uzbl.behave.always_insert_mode, 1, cmd_always_insert_mode)}, + { "reset_command_mode", PTR_V_INT(uzbl.behave.reset_command_mode, 1, NULL)}, + { "modkey", PTR_V_STR(uzbl.behave.modkey, 1, cmd_modkey)}, + { "load_finish_handler", PTR_V_STR(uzbl.behave.load_finish_handler, 1, NULL)}, + { "load_start_handler", PTR_V_STR(uzbl.behave.load_start_handler, 1, NULL)}, + { "load_commit_handler", PTR_V_STR(uzbl.behave.load_commit_handler, 1, NULL)}, + { "download_handler", PTR_V_STR(uzbl.behave.download_handler, 1, NULL)}, + { "cookie_handler", PTR_V_STR(uzbl.behave.cookie_handler, 1, cmd_cookie_handler)}, + { "new_window", PTR_V_STR(uzbl.behave.new_window, 1, NULL)}, + { "scheme_handler", PTR_V_STR(uzbl.behave.scheme_handler, 1, cmd_scheme_handler)}, + { "fifo_dir", PTR_V_STR(uzbl.behave.fifo_dir, 1, cmd_fifo_dir)}, + { "socket_dir", PTR_V_STR(uzbl.behave.socket_dir, 1, cmd_socket_dir)}, + { "http_debug", PTR_V_INT(uzbl.behave.http_debug, 1, cmd_http_debug)}, + { "shell_cmd", PTR_V_STR(uzbl.behave.shell_cmd, 1, NULL)}, + { "proxy_url", PTR_V_STR(uzbl.net.proxy_url, 1, set_proxy_url)}, + { "max_conns", PTR_V_INT(uzbl.net.max_conns, 1, cmd_max_conns)}, + { "max_conns_host", PTR_V_INT(uzbl.net.max_conns_host, 1, cmd_max_conns_host)}, + { "useragent", PTR_V_STR(uzbl.net.useragent, 1, cmd_useragent)}, + /* exported WebKitWebSettings properties */ - { "zoom_level", PTR(uzbl.behave.zoom_level, FLOAT,1, cmd_zoom_level)}, - { "font_size", PTR(uzbl.behave.font_size, INT, 1, cmd_font_size)}, - { "monospace_size", PTR(uzbl.behave.monospace_size, INT, 1, cmd_font_size)}, - { "minimum_font_size", PTR(uzbl.behave.minimum_font_size, INT, 1, cmd_minimum_font_size)}, - { "disable_plugins", PTR(uzbl.behave.disable_plugins, INT, 1, cmd_disable_plugins)}, - { "disable_scripts", PTR(uzbl.behave.disable_scripts, INT, 1, cmd_disable_scripts)}, - { "autoload_images", PTR(uzbl.behave.autoload_img, INT, 1, cmd_autoload_img)}, - { "autoshrink_images", PTR(uzbl.behave.autoshrink_img, INT, 1, cmd_autoshrink_img)}, - { "enable_spellcheck", PTR(uzbl.behave.enable_spellcheck, INT, 1, cmd_enable_spellcheck)}, - { "enable_private", PTR(uzbl.behave.enable_private, INT, 1, cmd_enable_private)}, - { "print_backgrounds", PTR(uzbl.behave.print_bg, INT, 1, cmd_print_bg)}, - { "stylesheet_uri", PTR(uzbl.behave.style_uri, STR, 1, cmd_style_uri)}, - { "resizable_text_areas",PTR(uzbl.behave.resizable_txt, INT, 1, cmd_resizable_txt)}, - { "default_encoding", PTR(uzbl.behave.default_encoding, STR, 1, cmd_default_encoding)}, - { "enforce_96_dpi", PTR(uzbl.behave.enforce_96dpi, INT, 1, cmd_enforce_96dpi)}, - { "caret_browsing", PTR(uzbl.behave.caret_browsing, INT, 1, cmd_caret_browsing)}, - - { NULL, {.ptr = NULL, .type = TYPE_INT, .dump = 0, .func = NULL}} -}, *n2v_p = var_name_to_ptr; + { "zoom_level", PTR_V_FLOAT(uzbl.behave.zoom_level, 1, cmd_zoom_level)}, + { "font_size", PTR_V_INT(uzbl.behave.font_size, 1, cmd_font_size)}, + { "default_font_family", PTR_V_STR(uzbl.behave.default_font_family, 1, cmd_default_font_family)}, + { "monospace_font_family", PTR_V_STR(uzbl.behave.monospace_font_family, 1, cmd_monospace_font_family)}, + { "cursive_font_family", PTR_V_STR(uzbl.behave.cursive_font_family, 1, cmd_cursive_font_family)}, + { "sans_serif_font_family", PTR_V_STR(uzbl.behave.sans_serif_font_family, 1, cmd_sans_serif_font_family)}, + { "serif_font_family", PTR_V_STR(uzbl.behave.serif_font_family, 1, cmd_serif_font_family)}, + { "fantasy_font_family", PTR_V_STR(uzbl.behave.fantasy_font_family, 1, cmd_fantasy_font_family)}, + { "monospace_size", PTR_V_INT(uzbl.behave.monospace_size, 1, cmd_font_size)}, + { "minimum_font_size", PTR_V_INT(uzbl.behave.minimum_font_size, 1, cmd_minimum_font_size)}, + { "disable_plugins", PTR_V_INT(uzbl.behave.disable_plugins, 1, cmd_disable_plugins)}, + { "disable_scripts", PTR_V_INT(uzbl.behave.disable_scripts, 1, cmd_disable_scripts)}, + { "autoload_images", PTR_V_INT(uzbl.behave.autoload_img, 1, cmd_autoload_img)}, + { "autoshrink_images", PTR_V_INT(uzbl.behave.autoshrink_img, 1, cmd_autoshrink_img)}, + { "enable_spellcheck", PTR_V_INT(uzbl.behave.enable_spellcheck, 1, cmd_enable_spellcheck)}, + { "enable_private", PTR_V_INT(uzbl.behave.enable_private, 1, cmd_enable_private)}, + { "print_backgrounds", PTR_V_INT(uzbl.behave.print_bg, 1, cmd_print_bg)}, + { "stylesheet_uri", PTR_V_STR(uzbl.behave.style_uri, 1, cmd_style_uri)}, + { "resizable_text_areas", PTR_V_INT(uzbl.behave.resizable_txt, 1, cmd_resizable_txt)}, + { "default_encoding", PTR_V_STR(uzbl.behave.default_encoding, 1, cmd_default_encoding)}, + { "enforce_96_dpi", PTR_V_INT(uzbl.behave.enforce_96dpi, 1, cmd_enforce_96dpi)}, + { "caret_browsing", PTR_V_INT(uzbl.behave.caret_browsing, 1, cmd_caret_browsing)}, + + /* constants (not dumpable or writeable) */ + { "WEBKIT_MAJOR", PTR_C_INT(uzbl.info.webkit_major, NULL)}, + { "WEBKIT_MINOR", PTR_C_INT(uzbl.info.webkit_minor, NULL)}, + { "WEBKIT_MICRO", PTR_C_INT(uzbl.info.webkit_micro, NULL)}, + { "ARCH_UZBL", PTR_C_STR(uzbl.info.arch, NULL)}, + { "COMMIT", PTR_C_STR(uzbl.info.commit, NULL)}, + { "LOAD_PROGRESS", PTR_C_INT(uzbl.gui.sbar.load_progress, NULL)}, + { "LOAD_PROGRESSBAR", PTR_C_STR(uzbl.gui.sbar.progress_bar, NULL)}, + { "TITLE", PTR_C_STR(uzbl.gui.main_title, NULL)}, + { "SELECTED_URI", PTR_C_STR(uzbl.state.selected_url, NULL)}, + { "MODE", PTR_C_STR(uzbl.gui.sbar.mode_indicator, NULL)}, + { "NAME", PTR_C_STR(uzbl.state.instance_name, NULL)}, + + { NULL, {.ptr.s = NULL, .type = TYPE_INT, .dump = 0, .writeable = 0, .func = NULL}} +}; + const struct { - char *key; + /*@null@*/ char *key; guint mask; } modkeys[] = { { "SHIFT", GDK_SHIFT_MASK }, // shift @@ -184,20 +216,22 @@ const struct { /* construct a hash from the var_name_to_ptr array for quick access */ -static void +void make_var_to_name_hash() { + const struct var_name_to_ptr_t *n2v_p = var_name_to_ptr; uzbl.comm.proto_var = g_hash_table_new(g_str_hash, g_str_equal); while(n2v_p->name) { - g_hash_table_insert(uzbl.comm.proto_var, n2v_p->name, (gpointer) &n2v_p->cp); + g_hash_table_insert(uzbl.comm.proto_var, + (gpointer) n2v_p->name, + (gpointer) &n2v_p->cp); n2v_p++; } } /* --- UTILITY FUNCTIONS --- */ - -enum {EXP_ERR, EXP_SIMPLE_VAR, EXP_BRACED_VAR, EXP_EXPR, EXP_JS}; -static guint -get_exp_type(gchar *s) { +enum exp_type {EXP_ERR, EXP_SIMPLE_VAR, EXP_BRACED_VAR, EXP_EXPR, EXP_JS, EXP_ESCAPE}; +enum exp_type +get_exp_type(const gchar *s) { /* variables */ if(*(s+1) == '(') return EXP_EXPR; @@ -205,9 +239,12 @@ get_exp_type(gchar *s) { return EXP_BRACED_VAR; else if(*(s+1) == '<') return EXP_JS; + else if(*(s+1) == '[') + return EXP_ESCAPE; else return EXP_SIMPLE_VAR; + /*@notreached@*/ return EXP_ERR; } @@ -215,15 +252,13 @@ return EXP_ERR; * recurse == 1: don't expand '@(command)@' * recurse == 2: don't expand '@@' */ -static gchar * -expand(char *s, guint recurse) { +gchar * +expand(const char *s, guint recurse) { uzbl_cmdprop *c; - guint etype; - char upto = ' '; + enum exp_type etype; char *end_simple_var = "^°!\"§$%&/()=?'`'+~*'#-.:,;@<>| \\{}[]¹²³¼½"; - char str_end[2]; - char ret[4096]; - char *vend; + char *ret = NULL; + char *vend = NULL; GError *err = NULL; gchar *cmd_stdout = NULL; gchar *mycmd = NULL; @@ -243,53 +278,51 @@ expand(char *s, guint recurse) { switch(etype) { case EXP_SIMPLE_VAR: - if( (vend = strpbrk(s, end_simple_var)) || - (vend = strchr(s, '\0')) ) { - strncpy(ret, s, vend-s); - ret[vend-s] = '\0'; - } + vend = strpbrk(s, end_simple_var); + if(!vend) vend = strchr(s, '\0'); break; case EXP_BRACED_VAR: - s++; upto = '}'; - if( (vend = strchr(s, upto)) || - (vend = strchr(s, '\0')) ) { - strncpy(ret, s, vend-s); - ret[vend-s] = '\0'; - } + s++; + vend = strchr(s, '}'); + if(!vend) vend = strchr(s, '\0'); break; case EXP_EXPR: s++; - strcpy(str_end, ")@"); - str_end[2] = '\0'; - if( (vend = strstr(s, str_end)) || - (vend = strchr(s, '\0')) ) { - strncpy(ret, s, vend-s); - ret[vend-s] = '\0'; - } + vend = strstr(s, ")@"); + if(!vend) vend = strchr(s, '\0'); break; case EXP_JS: s++; - strcpy(str_end, ">@"); - str_end[2] = '\0'; - if( (vend = strstr(s, str_end)) || - (vend = strchr(s, '\0')) ) { - strncpy(ret, s, vend-s); - ret[vend-s] = '\0'; - } + vend = strstr(s, ">@"); + if(!vend) vend = strchr(s, '\0'); + break; + case EXP_ESCAPE: + s++; + vend = strstr(s, "]@"); + if(!vend) vend = strchr(s, '\0'); + break; + /*@notreached@*/ + case EXP_ERR: break; } + assert(vend); + + ret = g_strndup(s, vend-s); if(etype == EXP_SIMPLE_VAR || etype == EXP_BRACED_VAR) { if( (c = g_hash_table_lookup(uzbl.comm.proto_var, ret)) ) { - if(c->type == TYPE_STR) - g_string_append(buf, (gchar *)*c->ptr); + if(c->type == TYPE_STR && *c->ptr.s != NULL) { + g_string_append(buf, (gchar *)*c->ptr.s); + } else if(c->type == TYPE_INT) { - char *b = itos((int)*c->ptr); - g_string_append(buf, b); - g_free(b); + g_string_append_printf(buf, "%d", *c->ptr.i); + } + else if(c->type == TYPE_FLOAT) { + g_string_append_printf(buf, "%f", *c->ptr.f); } } + if(etype == EXP_SIMPLE_VAR) s = vend; else @@ -306,6 +339,11 @@ expand(char *s, guint recurse) { g_error_free (err); } else if (*cmd_stdout) { + size_t len = strlen(cmd_stdout); + + if(len > 0 && cmd_stdout[len-1] == '\n') + cmd_stdout[--len] = '\0'; /* strip trailing newline */ + g_string_append(buf, cmd_stdout); g_free(cmd_stdout); } @@ -324,6 +362,19 @@ expand(char *s, guint recurse) { } s = vend+2; } + else if(etype == EXP_ESCAPE) { + mycmd = expand(ret, 0); + char *escaped = g_markup_escape_text(mycmd, strlen(mycmd)); + + g_string_append(buf, escaped); + + g_free(escaped); + g_free(mycmd); + s = vend+2; + } + + g_free(ret); + ret = NULL; break; default: @@ -344,13 +395,13 @@ itos(int val) { return g_strdup(tmp); } -static gchar* +gchar* strfree(gchar *str) { g_free(str); return NULL; } // for freeing & setting to null in one go -static gchar* +gchar* argv_idx(const GArray *a, const guint idx) { return g_array_index(a, gchar*, idx); } -static char * +char * str_replace (const char* search, const char* replace, const char* string) { gchar **buf; char *ret; @@ -362,8 +413,8 @@ str_replace (const char* search, const char* replace, const char* string) { return ret; } -static GArray* -read_file_by_line (gchar *path) { +GArray* +read_file_by_line (const gchar *path) { GIOChannel *chan = NULL; gchar *readbuf = NULL; gsize len; @@ -388,8 +439,8 @@ read_file_by_line (gchar *path) { return lines; } -static -gchar* parseenv (char* string) { +gchar* +parseenv (char* string) { extern char** environ; gchar* tmpstr = NULL; int i = 0; @@ -414,7 +465,7 @@ gchar* parseenv (char* string) { return string; } -static sigfunc* +sigfunc* setup_signal(int signr, sigfunc *shandler) { struct sigaction nh, oh; @@ -428,7 +479,7 @@ setup_signal(int signr, sigfunc *shandler) { return NULL; } -static void +void clean_up(void) { if (uzbl.behave.fifo_dir) unlink (uzbl.comm.fifo_path); @@ -436,52 +487,67 @@ clean_up(void) { unlink (uzbl.comm.socket_path); g_free(uzbl.state.executable_path); - g_string_free(uzbl.state.keycmd, TRUE); + g_free(uzbl.state.keycmd); g_hash_table_destroy(uzbl.bindings); g_hash_table_destroy(uzbl.behave.commands); } -/* used for html_mode_timeout - * be sure to extend this function to use - * more timers if needed in other places -*/ -static void -set_timeout(int seconds) { - struct itimerval t; - memset(&t, 0, sizeof t); - - t.it_value.tv_sec = seconds; - t.it_value.tv_usec = 0; - setitimer(ITIMER_REAL, &t, NULL); -} - /* --- SIGNAL HANDLER --- */ -static void +void catch_sigterm(int s) { (void) s; clean_up(); } -static void +void catch_sigint(int s) { (void) s; clean_up(); exit(EXIT_SUCCESS); } -static void -catch_alrm(int s) { - (void) s; +/* --- CALLBACKS --- */ - set_var_value("mode", "0"); - render_html(); -} +gboolean +navigation_decision_cb (WebKitWebView *web_view, WebKitWebFrame *frame, WebKitNetworkRequest *request, WebKitWebNavigationAction *navigation_action, WebKitWebPolicyDecision *policy_decision, gpointer user_data) { + (void) web_view; + (void) frame; + (void) navigation_action; + (void) user_data; + + const gchar* uri = webkit_network_request_get_uri (request); + gboolean decision_made = FALSE; + if (uzbl.state.verbose) + printf("Navigation requested -> %s\n", uri); -/* --- CALLBACKS --- */ + if (uzbl.behave.scheme_handler) { + GString *s = g_string_new (""); + g_string_printf(s, "'%s'", uri); + + run_handler(uzbl.behave.scheme_handler, s->str); + + if(uzbl.comm.sync_stdout && strcmp (uzbl.comm.sync_stdout, "") != 0) { + char *p = strchr(uzbl.comm.sync_stdout, '\n' ); + if ( p != NULL ) *p = '\0'; + if (!strcmp(uzbl.comm.sync_stdout, "USED")) { + webkit_web_policy_decision_ignore(policy_decision); + decision_made = TRUE; + } + } + if (uzbl.comm.sync_stdout) + uzbl.comm.sync_stdout = strfree(uzbl.comm.sync_stdout); + + g_string_free(s, TRUE); + } + if (!decision_made) + webkit_web_policy_decision_use(policy_decision); + + return TRUE; +} -static gboolean +gboolean new_window_cb (WebKitWebView *web_view, WebKitWebFrame *frame, WebKitNetworkRequest *request, WebKitWebNavigationAction *navigation_action, WebKitWebPolicyDecision *policy_decision, gpointer user_data) { (void) web_view; (void) frame; @@ -495,7 +561,7 @@ new_window_cb (WebKitWebView *web_view, WebKitWebFrame *frame, WebKitNetworkRequ return TRUE; } -static gboolean +gboolean mime_policy_cb(WebKitWebView *web_view, WebKitWebFrame *frame, WebKitNetworkRequest *request, gchar *mime_type, WebKitWebPolicyDecision *policy_decision, gpointer user_data) { (void) frame; (void) request; @@ -512,7 +578,7 @@ mime_policy_cb(WebKitWebView *web_view, WebKitWebFrame *frame, WebKitNetworkRequ return TRUE; } -WebKitWebView* +/*@null@*/ WebKitWebView* create_web_view_cb (WebKitWebView *web_view, WebKitWebFrame *frame, gpointer user_data) { (void) web_view; (void) frame; @@ -528,7 +594,7 @@ create_web_view_cb (WebKitWebView *web_view, WebKitWebFrame *frame, gpointer us return (NULL); } -static gboolean +gboolean download_cb (WebKitWebView *web_view, GObject *download, gpointer user_data) { (void) web_view; (void) user_data; @@ -537,13 +603,23 @@ download_cb (WebKitWebView *web_view, GObject *download, gpointer user_data) { if (uzbl.state.verbose) printf("Download -> %s\n",uri); /* if urls not escaped, we may have to escape and quote uri before this call */ - run_handler(uzbl.behave.download_handler, uri); + + GString *args = g_string_new(uri); + + if (uzbl.net.proxy_url) { + g_string_append_c(args, ' '); + g_string_append(args, uzbl.net.proxy_url); + } + + run_handler(uzbl.behave.download_handler, args->str); + + g_string_free(args, TRUE); } return (FALSE); } /* scroll a bar in a given direction */ -static void +void scroll (GtkAdjustment* bar, GArray *argv) { gchar *end; gdouble max_value; @@ -565,32 +641,46 @@ scroll (GtkAdjustment* bar, GArray *argv) { gtk_adjustment_set_value (bar, value); } -static void +void scroll_begin(WebKitWebView* page, GArray *argv, GString *result) { (void) page; (void) argv; (void) result; gtk_adjustment_set_value (uzbl.gui.bar_v, gtk_adjustment_get_lower(uzbl.gui.bar_v)); } -static void +void scroll_end(WebKitWebView* page, GArray *argv, GString *result) { (void) page; (void) argv; (void) result; gtk_adjustment_set_value (uzbl.gui.bar_v, gtk_adjustment_get_upper(uzbl.gui.bar_v) - gtk_adjustment_get_page_size(uzbl.gui.bar_v)); } -static void +void scroll_vert(WebKitWebView* page, GArray *argv, GString *result) { (void) page; (void) result; scroll(uzbl.gui.bar_v, argv); } -static void +void scroll_horz(WebKitWebView* page, GArray *argv, GString *result) { (void) page; (void) result; scroll(uzbl.gui.bar_h, argv); } -static void +void +cmd_set_geometry() { + if(!gtk_window_parse_geometry(GTK_WINDOW(uzbl.gui.main_window), uzbl.gui.geometry)) { + if(uzbl.state.verbose) + printf("Error in geometry string: %s\n", uzbl.gui.geometry); + } + /* update geometry var with the actual geometry + this is necessary as some WMs don't seem to honour + the above setting and we don't want to end up with + wrong geometry information + */ + retrieve_geometry(); +} + +void cmd_set_status() { if (!uzbl.behave.show_status) { gtk_widget_hide(uzbl.gui.mainbar); @@ -600,7 +690,7 @@ cmd_set_status() { update_title(); } -static void +void toggle_zoom_type (WebKitWebView* page, GArray *argv, GString *result) { (void)page; (void)argv; @@ -609,7 +699,7 @@ toggle_zoom_type (WebKitWebView* page, GArray *argv, GString *result) { webkit_web_view_set_full_content_zoom (page, !webkit_web_view_get_full_content_zoom (page)); } -static void +void toggle_status_cb (WebKitWebView* page, GArray *argv, GString *result) { (void)page; (void)argv; @@ -624,7 +714,7 @@ toggle_status_cb (WebKitWebView* page, GArray *argv, GString *result) { update_title(); } -static void +void link_hover_cb (WebKitWebView* page, const gchar* title, const gchar* link, gpointer data) { (void) page; (void) title; @@ -638,7 +728,7 @@ link_hover_cb (WebKitWebView* page, const gchar* title, const gchar* link, gpoin update_title(); } -static void +void title_change_cb (WebKitWebView* web_view, GParamSpec param_spec) { (void) web_view; (void) param_spec; @@ -649,15 +739,19 @@ title_change_cb (WebKitWebView* web_view, GParamSpec param_spec) { update_title(); } -static void +void progress_change_cb (WebKitWebView* page, gint progress, gpointer data) { (void) page; (void) data; uzbl.gui.sbar.load_progress = progress; + + g_free(uzbl.gui.sbar.progress_bar); + uzbl.gui.sbar.progress_bar = build_progressbar_ascii(uzbl.gui.sbar.load_progress); + update_title(); } -static void +void load_finish_cb (WebKitWebView* page, WebKitWebFrame* frame, gpointer data) { (void) page; (void) frame; @@ -666,18 +760,22 @@ load_finish_cb (WebKitWebView* page, WebKitWebFrame* frame, gpointer data) { run_handler(uzbl.behave.load_finish_handler, ""); } -static void +void clear_keycmd() { + g_free(uzbl.state.keycmd); + uzbl.state.keycmd = g_strdup(""); +} + +void load_start_cb (WebKitWebView* page, WebKitWebFrame* frame, gpointer data) { (void) page; (void) frame; (void) data; uzbl.gui.sbar.load_progress = 0; - g_string_truncate(uzbl.state.keycmd, 0); // don't need old commands to remain on new page? if (uzbl.behave.load_start_handler) run_handler(uzbl.behave.load_start_handler, ""); } -static void +void load_commit_cb (WebKitWebView* page, WebKitWebFrame* frame, gpointer data) { (void) page; (void) data; @@ -685,36 +783,23 @@ load_commit_cb (WebKitWebView* page, WebKitWebFrame* frame, gpointer data) { GString* newuri = g_string_new (webkit_web_frame_get_uri (frame)); uzbl.state.uri = g_string_free (newuri, FALSE); if (uzbl.behave.reset_command_mode && uzbl.behave.insert_mode) { - uzbl.behave.insert_mode = uzbl.behave.always_insert_mode; + set_insert_mode(uzbl.behave.always_insert_mode); update_title(); } if (uzbl.behave.load_commit_handler) run_handler(uzbl.behave.load_commit_handler, uzbl.state.uri); } -static void +void destroy_cb (GtkWidget* widget, gpointer data) { (void) widget; (void) data; gtk_main_quit (); } -static void -log_history_cb () { - if (uzbl.behave.history_handler) { - time_t rawtime; - struct tm * timeinfo; - char date [80]; - time ( &rawtime ); - timeinfo = localtime ( &rawtime ); - strftime (date, 80, "\"%Y-%m-%d %H:%M:%S\"", timeinfo); - run_handler(uzbl.behave.history_handler, date); - } -} - /* VIEW funcs (little webkit wrappers) */ -#define VIEWFUNC(name) static void view_##name(WebKitWebView *page, GArray *argv, GString *result){(void)argv; (void)result; webkit_web_view_##name(page);} +#define VIEWFUNC(name) void view_##name(WebKitWebView *page, GArray *argv, GString *result){(void)argv; (void)result; webkit_web_view_##name(page);} VIEWFUNC(reload) VIEWFUNC(reload_bypass_cache) VIEWFUNC(stop_loading) @@ -725,7 +810,7 @@ VIEWFUNC(go_forward) #undef VIEWFUNC /* -- command to callback/function map for things we cannot attach to any signals */ -static struct {char *key; CommandInfo value;} cmdlist[] = +struct {const char *key; CommandInfo value;} cmdlist[] = { /* key function no_split */ { "back", {view_go_back, 0} }, { "forward", {view_go_forward, 0} }, @@ -747,6 +832,7 @@ static struct {char *key; CommandInfo value;} cmdlist[] = { "sync_spawn", {spawn_sync, 0} }, // needed for cookie handler { "sh", {spawn_sh, 0} }, { "sync_sh", {spawn_sh_sync, 0} }, // needed for cookie handler + { "talk_to_socket", {talk_to_socket, 0} }, { "exit", {close_uzbl, 0} }, { "search", {search_forward_text, TRUE} }, { "search_reverse", {search_reverse_text, TRUE} }, @@ -760,17 +846,18 @@ static struct {char *key; CommandInfo value;} cmdlist[] = { "keycmd_nl", {keycmd_nl, TRUE} }, { "keycmd_bs", {keycmd_bs, 0} }, { "chain", {chain, 0} }, - { "print", {print, TRUE} } + { "print", {print, TRUE} }, + { "update_gui", {update_gui, TRUE} } }; -static void +void commands_hash(void) { unsigned int i; uzbl.behave.commands = g_hash_table_new(g_str_hash, g_str_equal); for (i = 0; i < LENGTH(cmdlist); i++) - g_hash_table_insert(uzbl.behave.commands, cmdlist[i].key, &cmdlist[i].value); + g_hash_table_insert(uzbl.behave.commands, (gpointer) cmdlist[i].key, &cmdlist[i].value); } /* -- CORE FUNCTIONS -- */ @@ -797,12 +884,12 @@ new_action(const gchar *name, const gchar *param) { return action; } -static bool +bool file_exists (const char * filename) { return (access(filename, F_OK) == 0); } -static void +void set_var(WebKitWebView *page, GArray *argv, GString *result) { (void) page; (void) result; gchar **split = g_strsplit(argv_idx(argv, 0), "=", 2); @@ -814,7 +901,14 @@ set_var(WebKitWebView *page, GArray *argv, GString *result) { g_strfreev(split); } -static void +void +update_gui(WebKitWebView *page, GArray *argv, GString *result) { + (void) page; (void) argv; (void) result; + + update_title(); +} + +void print(WebKitWebView *page, GArray *argv, GString *result) { (void) page; (void) result; gchar* buf; @@ -824,7 +918,7 @@ print(WebKitWebView *page, GArray *argv, GString *result) { g_free(buf); } -static void +void act_bind(WebKitWebView *page, GArray *argv, GString *result) { (void) page; (void) result; gchar **split = g_strsplit(argv_idx(argv, 0), " = ", 2); @@ -835,29 +929,53 @@ act_bind(WebKitWebView *page, GArray *argv, GString *result) { } -static void +void act_dump_config() { dump_config(); } -static void +void +set_keycmd() { + run_keycmd(FALSE); + update_title(); +} + +void +set_mode_indicator() { + uzbl.gui.sbar.mode_indicator = (uzbl.behave.insert_mode ? + uzbl.behave.insert_indicator : uzbl.behave.cmd_indicator); +} + +void +update_indicator() { + set_mode_indicator(); + update_title(); +} + +void +set_insert_mode(gboolean mode) { + uzbl.behave.insert_mode = mode; + set_mode_indicator(); +} + +void toggle_insert_mode(WebKitWebView *page, GArray *argv, GString *result) { (void) page; (void) result; if (argv_idx(argv, 0)) { if (strcmp (argv_idx(argv, 0), "0") == 0) { - uzbl.behave.insert_mode = FALSE; + set_insert_mode(FALSE); } else { - uzbl.behave.insert_mode = TRUE; + set_insert_mode(TRUE); } } else { - uzbl.behave.insert_mode = ! uzbl.behave.insert_mode; + set_insert_mode( !uzbl.behave.insert_mode ); } update_title(); } -static void +void load_uri (WebKitWebView *web_view, GArray *argv, GString *result) { (void) result; @@ -867,7 +985,7 @@ load_uri (WebKitWebView *web_view, GArray *argv, GString *result) { run_js(web_view, argv, NULL); return; } - if (g_strrstr (argv_idx(argv, 0), "://") == NULL && g_strstr_len (argv_idx(argv, 0), 5, "data:") == NULL) + if (!soup_uri_new(argv_idx(argv, 0))) g_string_prepend (newuri, "http://"); /* if we do handle cookies, ask our handler for them */ webkit_web_view_load_uri (web_view, newuri->str); @@ -875,10 +993,9 @@ load_uri (WebKitWebView *web_view, GArray *argv, GString *result) { } } - /* Javascript*/ -static JSValueRef +JSValueRef js_run_command (JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { @@ -906,11 +1023,11 @@ js_run_command (JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, return JSValueMakeString(ctx, js_result_string); } -static JSStaticFunction js_static_functions[] = { +JSStaticFunction js_static_functions[] = { {"run", js_run_command, kJSPropertyAttributeNone}, }; -static void +void js_init() { /* This function creates the class and its definition, only once */ if (!uzbl.js.initialized) { @@ -923,7 +1040,7 @@ js_init() { } -static void +void eval_js(WebKitWebView * web_view, gchar *script, GString *result) { WebKitWebFrame *frame; JSGlobalContextRef context; @@ -970,14 +1087,13 @@ eval_js(WebKitWebView * web_view, gchar *script, GString *result) { JSStringRelease(js_script); } -static void +void run_js (WebKitWebView * web_view, GArray *argv, GString *result) { - if (argv_idx(argv, 0)) eval_js(web_view, argv_idx(argv, 0), result); } -static void +void run_external_js (WebKitWebView * web_view, GArray *argv, GString *result) { (void) result; if (argv_idx(argv, 0)) { @@ -1011,7 +1127,7 @@ run_external_js (WebKitWebView * web_view, GArray *argv, GString *result) { } } -static void +void search_text (WebKitWebView *page, GArray *argv, const gboolean forward) { if (argv_idx(argv, 0) && (*argv_idx(argv, 0) != '\0')) { if (g_strcmp0 (uzbl.state.searchtx, argv_idx(argv, 0)) != 0) { @@ -1029,26 +1145,26 @@ search_text (WebKitWebView *page, GArray *argv, const gboolean forward) { } } -static void +void search_forward_text (WebKitWebView *page, GArray *argv, GString *result) { (void) result; search_text(page, argv, TRUE); } -static void +void search_reverse_text (WebKitWebView *page, GArray *argv, GString *result) { (void) result; search_text(page, argv, FALSE); } -static void +void dehilight (WebKitWebView *page, GArray *argv, GString *result) { (void) argv; (void) result; webkit_web_view_set_highlight_text_matches (page, FALSE); } -static void +void new_window_load_uri (const gchar * uri) { if (uzbl.behave.new_window) { GString *s = g_string_new (""); @@ -1073,7 +1189,7 @@ new_window_load_uri (const gchar * uri) { g_string_free (to_execute, TRUE); } -static void +void chain (WebKitWebView *page, GArray *argv, GString *result) { (void) page; (void) result; gchar *a = NULL; @@ -1081,44 +1197,46 @@ chain (WebKitWebView *page, GArray *argv, GString *result) { guint i = 0; while ((a = argv_idx(argv, i++))) { parts = g_strsplit (a, " ", 2); - parse_command(parts[0], parts[1], result); + if (parts[0]) + parse_command(parts[0], parts[1], result); g_strfreev (parts); } } -static void +void keycmd (WebKitWebView *page, GArray *argv, GString *result) { (void)page; (void)argv; (void)result; - g_string_assign(uzbl.state.keycmd, argv_idx(argv, 0)); + uzbl.state.keycmd = g_strdup(argv_idx(argv, 0)); run_keycmd(FALSE); update_title(); } -static void +void keycmd_nl (WebKitWebView *page, GArray *argv, GString *result) { (void)page; (void)argv; (void)result; - g_string_assign(uzbl.state.keycmd, argv_idx(argv, 0)); + uzbl.state.keycmd = g_strdup(argv_idx(argv, 0)); run_keycmd(TRUE); update_title(); } -static void +void keycmd_bs (WebKitWebView *page, GArray *argv, GString *result) { gchar *prev; (void)page; (void)argv; (void)result; - prev = g_utf8_find_prev_char(uzbl.state.keycmd->str, uzbl.state.keycmd->str + uzbl.state.keycmd->len); + int len = strlen(uzbl.state.keycmd); + prev = g_utf8_find_prev_char(uzbl.state.keycmd, uzbl.state.keycmd + len); if (prev) - g_string_truncate(uzbl.state.keycmd, prev - uzbl.state.keycmd->str); + uzbl.state.keycmd[prev - uzbl.state.keycmd] = '\0'; update_title(); } -static void +void close_uzbl (WebKitWebView *page, GArray *argv, GString *result) { (void)page; (void)argv; @@ -1127,7 +1245,7 @@ close_uzbl (WebKitWebView *page, GArray *argv, GString *result) { } /* --Statusbar functions-- */ -static char* +char* build_progressbar_ascii(int percent) { int width=uzbl.gui.sbar.progress_w; int i; @@ -1145,218 +1263,16 @@ build_progressbar_ascii(int percent) { return g_string_free(bar, FALSE); } - -static void -setup_scanner() { - const GScannerConfig scan_config = { - ( - "\t\r\n" - ) /* cset_skip_characters */, - ( - G_CSET_a_2_z - "_#" - G_CSET_A_2_Z - ) /* cset_identifier_first */, - ( - G_CSET_a_2_z - "_0123456789" - G_CSET_A_2_Z - G_CSET_LATINS - G_CSET_LATINC - ) /* cset_identifier_nth */, - ( "" ) /* cpair_comment_single */, - - TRUE /* case_sensitive */, - - FALSE /* skip_comment_multi */, - FALSE /* skip_comment_single */, - FALSE /* scan_comment_multi */, - TRUE /* scan_identifier */, - TRUE /* scan_identifier_1char */, - FALSE /* scan_identifier_NULL */, - TRUE /* scan_symbols */, - FALSE /* scan_binary */, - FALSE /* scan_octal */, - FALSE /* scan_float */, - FALSE /* scan_hex */, - FALSE /* scan_hex_dollar */, - FALSE /* scan_string_sq */, - FALSE /* scan_string_dq */, - TRUE /* numbers_2_int */, - FALSE /* int_2_float */, - FALSE /* identifier_2_string */, - FALSE /* char_2_token */, - FALSE /* symbol_2_token */, - TRUE /* scope_0_fallback */, - FALSE, - TRUE - }; - - uzbl.scan = g_scanner_new(&scan_config); - while(symp->symbol_name) { - g_scanner_scope_add_symbol(uzbl.scan, 0, - symp->symbol_name, - GINT_TO_POINTER(symp->symbol_token)); - symp++; - } -} - -static gchar * -expand_template(const char *template, gboolean escape_markup) { - if(!template) return NULL; - - GTokenType token = G_TOKEN_NONE; - GString *ret = g_string_new(""); - char *buf=NULL; - int sym; - - g_scanner_input_text(uzbl.scan, template, strlen(template)); - while(!g_scanner_eof(uzbl.scan) && token != G_TOKEN_LAST) { - token = g_scanner_get_next_token(uzbl.scan); - - if(token == G_TOKEN_SYMBOL) { - sym = GPOINTER_TO_INT(g_scanner_cur_value(uzbl.scan).v_symbol); - switch(sym) { - case SYM_URI: - if(escape_markup) { - buf = uzbl.state.uri? - g_markup_printf_escaped("%s", uzbl.state.uri):g_strdup(""); - g_string_append(ret, buf); - g_free(buf); - } - else - g_string_append(ret, uzbl.state.uri? - uzbl.state.uri:g_strdup("")); - break; - case SYM_LOADPRGS: - buf = itos(uzbl.gui.sbar.load_progress); - g_string_append(ret, buf); - g_free(buf); - break; - case SYM_LOADPRGSBAR: - buf = build_progressbar_ascii(uzbl.gui.sbar.load_progress); - g_string_append(ret, buf); - g_free(buf); - break; - case SYM_TITLE: - if(escape_markup) { - buf = uzbl.gui.main_title? - g_markup_printf_escaped("%s", uzbl.gui.main_title):g_strdup(""); - g_string_append(ret, buf); - g_free(buf); - } - else - g_string_append(ret, uzbl.gui.main_title? - uzbl.gui.main_title:g_strdup("")); - break; - case SYM_SELECTED_URI: - if(escape_markup) { - buf = uzbl.state.selected_url? - g_markup_printf_escaped("%s", uzbl.state.selected_url):g_strdup(""); - g_string_append(ret, buf); - g_free(buf); - } - else - g_string_append(ret, uzbl.state.selected_url? - uzbl.state.selected_url:g_strdup("")); - break; - case SYM_NAME: - buf = itos(uzbl.xwin); - g_string_append(ret, - uzbl.state.instance_name?uzbl.state.instance_name:buf); - g_free(buf); - break; - case SYM_KEYCMD: - if(escape_markup) { - buf = uzbl.state.keycmd->str? - g_markup_printf_escaped("%s", uzbl.state.keycmd->str):g_strdup(""); - g_string_append(ret, buf); - g_free(buf); - } - else - g_string_append(ret, uzbl.state.keycmd->str? - uzbl.state.keycmd->str:g_strdup("")); - break; - case SYM_MODE: - g_string_append(ret, - uzbl.behave.insert_mode? - uzbl.behave.insert_indicator:uzbl.behave.cmd_indicator); - break; - case SYM_MSG: - g_string_append(ret, - uzbl.gui.sbar.msg?uzbl.gui.sbar.msg:""); - break; - /* useragent syms */ - case SYM_WK_MAJ: - buf = itos(WEBKIT_MAJOR_VERSION); - g_string_append(ret, buf); - g_free(buf); - break; - case SYM_WK_MIN: - buf = itos(WEBKIT_MINOR_VERSION); - g_string_append(ret, buf); - g_free(buf); - break; - case SYM_WK_MIC: - buf = itos(WEBKIT_MICRO_VERSION); - g_string_append(ret, buf); - g_free(buf); - break; - case SYM_SYSNAME: - g_string_append(ret, uzbl.state.unameinfo.sysname); - break; - case SYM_NODENAME: - g_string_append(ret, uzbl.state.unameinfo.nodename); - break; - case SYM_KERNREL: - g_string_append(ret, uzbl.state.unameinfo.release); - break; - case SYM_KERNVER: - g_string_append(ret, uzbl.state.unameinfo.version); - break; - case SYM_ARCHSYS: - g_string_append(ret, uzbl.state.unameinfo.machine); - break; - case SYM_ARCHUZBL: - g_string_append(ret, ARCH); - break; -#ifdef _GNU_SOURCE - case SYM_DOMAINNAME: - g_string_append(ret, uzbl.state.unameinfo.domainname); - break; -#endif - case SYM_COMMIT: - g_string_append(ret, COMMIT); - break; - default: - break; - } - } - else if(token == G_TOKEN_INT) { - buf = itos(g_scanner_cur_value(uzbl.scan).v_int); - g_string_append(ret, buf); - g_free(buf); - } - else if(token == G_TOKEN_IDENTIFIER) { - g_string_append(ret, (gchar *)g_scanner_cur_value(uzbl.scan).v_identifier); - } - else if(token == G_TOKEN_CHAR) { - g_string_append_c(ret, (gchar)g_scanner_cur_value(uzbl.scan).v_char); - } - } - - return g_string_free(ret, FALSE); -} /* --End Statusbar functions-- */ -static void +void sharg_append(GArray *a, const gchar *str) { const gchar *s = (str ? str : ""); g_array_append_val(a, s); } // make sure that the args string you pass can properly be interpreted (eg properly escaped against whitespace, quotes etc) -static gboolean +gboolean run_command (const gchar *command, const guint npre, const gchar **args, const gboolean sync, char **output_stdout) { //command [args] @@ -1413,7 +1329,7 @@ run_command (const gchar *command, const guint npre, const gchar **args, return result; } -static gchar** +/*@null@*/ gchar** split_quoted(const gchar* src, const gboolean unquote) { /* split on unquoted space, return array of strings; remove a layer of quotes and backslashes if unquote */ @@ -1450,7 +1366,7 @@ split_quoted(const gchar* src, const gboolean unquote) { return ret; } -static void +void spawn(WebKitWebView *web_view, GArray *argv, GString *result) { (void)web_view; (void)result; //TODO: allow more control over argument order so that users can have some arguments before the default ones from run_command, and some after @@ -1458,7 +1374,7 @@ spawn(WebKitWebView *web_view, GArray *argv, GString *result) { run_command(argv_idx(argv, 0), 0, ((const gchar **) (argv->data + sizeof(gchar*))), FALSE, NULL); } -static void +void spawn_sync(WebKitWebView *web_view, GArray *argv, GString *result) { (void)web_view; (void)result; @@ -1467,7 +1383,7 @@ spawn_sync(WebKitWebView *web_view, GArray *argv, GString *result) { TRUE, &uzbl.comm.sync_stdout); } -static void +void spawn_sh(WebKitWebView *web_view, GArray *argv, GString *result) { (void)web_view; (void)result; if (!uzbl.behave.shell_cmd) { @@ -1488,7 +1404,7 @@ spawn_sh(WebKitWebView *web_view, GArray *argv, GString *result) { g_strfreev (cmd); } -static void +void spawn_sh_sync(WebKitWebView *web_view, GArray *argv, GString *result) { (void)web_view; (void)result; if (!uzbl.behave.shell_cmd) { @@ -1510,7 +1426,119 @@ spawn_sh_sync(WebKitWebView *web_view, GArray *argv, GString *result) { g_strfreev (cmd); } -static void +void +talk_to_socket(WebKitWebView *web_view, GArray *argv, GString *result) { + (void)web_view; (void)result; + + int fd, len; + struct sockaddr_un sa; + char* sockpath; + ssize_t ret; + struct pollfd pfd; + struct iovec* iov; + guint i; + + if(uzbl.comm.sync_stdout) uzbl.comm.sync_stdout = strfree(uzbl.comm.sync_stdout); + + /* This function could be optimised by storing a hash table of socket paths + and associated connected file descriptors rather than closing and + re-opening for every call. Also we could launch a script if socket connect + fails. */ + + /* First element argv[0] is path to socket. Following elements are tokens to + write to the socket. We write them as a single packet with each token + separated by an ASCII nul (\0). */ + if(argv->len < 2) { + g_printerr("talk_to_socket called with only %d args (need at least two).\n", + (int)argv->len); + return; + } + + /* copy socket path, null terminate result */ + sockpath = g_array_index(argv, char*, 0); + g_strlcpy(sa.sun_path, sockpath, sizeof(sa.sun_path)); + sa.sun_family = AF_UNIX; + + /* create socket file descriptor and connect it to path */ + fd = socket(AF_UNIX, SOCK_SEQPACKET, 0); + if(fd == -1) { + g_printerr("talk_to_socket: creating socket failed (%s)\n", strerror(errno)); + return; + } + if(connect(fd, (struct sockaddr*)&sa, sizeof(sa))) { + g_printerr("talk_to_socket: connect failed (%s)\n", strerror(errno)); + close(fd); + return; + } + + /* build request vector */ + iov = g_malloc(sizeof(struct iovec) * (argv->len - 1)); + if(!iov) { + g_printerr("talk_to_socket: unable to allocated memory for token vector\n"); + close(fd); + return; + } + for(i = 1; i < argv->len; ++i) { + iov[i - 1].iov_base = g_array_index(argv, char*, i); + iov[i - 1].iov_len = strlen(iov[i - 1].iov_base) + 1; /* string plus \0 */ + } + + /* write request */ + ret = writev(fd, iov, argv->len - 1); + g_free(iov); + if(ret == -1) { + g_printerr("talk_to_socket: write failed (%s)\n", strerror(errno)); + close(fd); + return; + } + + /* wait for a response, with a 500ms timeout */ + pfd.fd = fd; + pfd.events = POLLIN; + while(1) { + ret = poll(&pfd, 1, 500); + if(ret == 1) break; + if(ret == 0) errno = ETIMEDOUT; + if(errno == EINTR) continue; + g_printerr("talk_to_socket: poll failed while waiting for input (%s)\n", + strerror(errno)); + close(fd); + return; + } + + /* get length of response */ + if(ioctl(fd, FIONREAD, &len) == -1) { + g_printerr("talk_to_socket: cannot find daemon response length, " + "ioctl failed (%s)\n", strerror(errno)); + close(fd); + return; + } + + /* if there is a response, read it */ + if(len) { + uzbl.comm.sync_stdout = g_malloc(len + 1); + if(!uzbl.comm.sync_stdout) { + g_printerr("talk_to_socket: failed to allocate %d bytes\n", len); + close(fd); + return; + } + uzbl.comm.sync_stdout[len] = 0; /* ensure result is null terminated */ + + ret = read(fd, uzbl.comm.sync_stdout, len); + if(ret == -1) { + g_printerr("talk_to_socket: failed to read from socket (%s)\n", + strerror(errno)); + close(fd); + return; + } + } + + /* clean up */ + close(fd); + return; +} + +void parse_command(const char *cmd, const char *param, GString *result) { CommandInfo *c; @@ -1531,7 +1559,7 @@ parse_command(const char *cmd, const char *param, GString *result) { c->function(uzbl.gui.web_view, a, result_print); if (result_print->len) - printf("%*s\n", result_print->len, result_print->str); + printf("%*s\n", (int)result_print->len, result_print->str); g_string_free(result_print, TRUE); } else { @@ -1544,12 +1572,11 @@ parse_command(const char *cmd, const char *param, GString *result) { g_printerr ("command \"%s\" not understood. ignoring.\n", cmd); } -static void +void set_proxy_url() { SoupURI *suri; - if(*uzbl.net.proxy_url == ' ' - || uzbl.net.proxy_url == NULL) { + if(uzbl.net.proxy_url == NULL || *uzbl.net.proxy_url == ' ') { soup_session_remove_feature_by_type(uzbl.net.soup_session, (GType) SOUP_SESSION_PROXY_URI); } @@ -1563,7 +1590,7 @@ set_proxy_url() { return; } -static void +void set_icon() { if(file_exists(uzbl.gui.icon)) { if (uzbl.gui.main_window) @@ -1573,7 +1600,7 @@ set_icon() { } } -static void +void cmd_load_uri() { GArray *a = g_array_new (TRUE, FALSE, sizeof(gchar*)); g_array_append_val (a, uzbl.state.uri); @@ -1581,26 +1608,25 @@ cmd_load_uri() { g_array_free (a, TRUE); } -static void +void cmd_always_insert_mode() { - uzbl.behave.insert_mode = - uzbl.behave.always_insert_mode ? TRUE : FALSE; + set_insert_mode(uzbl.behave.always_insert_mode); update_title(); } -static void +void cmd_max_conns() { g_object_set(G_OBJECT(uzbl.net.soup_session), SOUP_SESSION_MAX_CONNS, uzbl.net.max_conns, NULL); } -static void +void cmd_max_conns_host() { g_object_set(G_OBJECT(uzbl.net.soup_session), SOUP_SESSION_MAX_CONNS_PER_HOST, uzbl.net.max_conns_host, NULL); } -static void +void cmd_http_debug() { soup_session_remove_feature (uzbl.net.soup_session, SOUP_SESSION_FEATURE(uzbl.net.soup_logger)); @@ -1612,12 +1638,12 @@ cmd_http_debug() { SOUP_SESSION_FEATURE(uzbl.net.soup_logger)); } -static WebKitWebSettings* +WebKitWebSettings* view_settings() { return webkit_web_view_get_settings(uzbl.gui.web_view); } -static void +void cmd_font_size() { WebKitWebSettings *ws = view_settings(); if (uzbl.behave.font_size > 0) { @@ -1633,91 +1659,127 @@ cmd_font_size() { } } -static void +void +cmd_default_font_family() { + g_object_set (G_OBJECT(view_settings()), "default-font-family", + uzbl.behave.default_font_family, NULL); +} + +void +cmd_monospace_font_family() { + g_object_set (G_OBJECT(view_settings()), "monospace-font-family", + uzbl.behave.monospace_font_family, NULL); +} + +void +cmd_sans_serif_font_family() { + g_object_set (G_OBJECT(view_settings()), "sans_serif-font-family", + uzbl.behave.sans_serif_font_family, NULL); +} + +void +cmd_serif_font_family() { + g_object_set (G_OBJECT(view_settings()), "serif-font-family", + uzbl.behave.serif_font_family, NULL); +} + +void +cmd_cursive_font_family() { + g_object_set (G_OBJECT(view_settings()), "cursive-font-family", + uzbl.behave.cursive_font_family, NULL); +} + +void +cmd_fantasy_font_family() { + g_object_set (G_OBJECT(view_settings()), "fantasy-font-family", + uzbl.behave.fantasy_font_family, NULL); +} + +void cmd_zoom_level() { webkit_web_view_set_zoom_level (uzbl.gui.web_view, uzbl.behave.zoom_level); } -static void +void cmd_disable_plugins() { g_object_set (G_OBJECT(view_settings()), "enable-plugins", !uzbl.behave.disable_plugins, NULL); } -static void +void cmd_disable_scripts() { g_object_set (G_OBJECT(view_settings()), "enable-scripts", !uzbl.behave.disable_scripts, NULL); } -static void +void cmd_minimum_font_size() { g_object_set (G_OBJECT(view_settings()), "minimum-font-size", uzbl.behave.minimum_font_size, NULL); } -static void +void cmd_autoload_img() { g_object_set (G_OBJECT(view_settings()), "auto-load-images", uzbl.behave.autoload_img, NULL); } -static void +void cmd_autoshrink_img() { g_object_set (G_OBJECT(view_settings()), "auto-shrink-images", uzbl.behave.autoshrink_img, NULL); } -static void +void cmd_enable_spellcheck() { g_object_set (G_OBJECT(view_settings()), "enable-spell-checking", uzbl.behave.enable_spellcheck, NULL); } -static void +void cmd_enable_private() { g_object_set (G_OBJECT(view_settings()), "enable-private-browsing", uzbl.behave.enable_private, NULL); } -static void +void cmd_print_bg() { g_object_set (G_OBJECT(view_settings()), "print-backgrounds", uzbl.behave.print_bg, NULL); } -static void +void cmd_style_uri() { g_object_set (G_OBJECT(view_settings()), "user-stylesheet-uri", uzbl.behave.style_uri, NULL); } -static void +void cmd_resizable_txt() { g_object_set (G_OBJECT(view_settings()), "resizable-text-areas", uzbl.behave.resizable_txt, NULL); } -static void +void cmd_default_encoding() { g_object_set (G_OBJECT(view_settings()), "default-encoding", uzbl.behave.default_encoding, NULL); } -static void +void cmd_enforce_96dpi() { g_object_set (G_OBJECT(view_settings()), "enforce-96-dpi", uzbl.behave.enforce_96dpi, NULL); } -static void +void cmd_caret_browsing() { g_object_set (G_OBJECT(view_settings()), "enable-caret-browsing", uzbl.behave.caret_browsing, NULL); } -static void +void cmd_cookie_handler() { gchar **split = g_strsplit(uzbl.behave.cookie_handler, " ", 2); /* pitfall: doesn't handle chain actions; must the sync_ action manually */ @@ -1730,30 +1792,30 @@ cmd_cookie_handler() { g_strfreev (split); } -static void -cmd_new_window() { - gchar **split = g_strsplit(uzbl.behave.new_window, " ", 2); +void +cmd_scheme_handler() { + gchar **split = g_strsplit(uzbl.behave.scheme_handler, " ", 2); /* pitfall: doesn't handle chain actions; must the sync_ action manually */ if ((g_strcmp0(split[0], "sh") == 0) || (g_strcmp0(split[0], "spawn") == 0)) { - g_free (uzbl.behave.new_window); - uzbl.behave.new_window = - g_strdup_printf("%s %s", split[0], split[1]); + g_free (uzbl.behave.scheme_handler); + uzbl.behave.scheme_handler = + g_strdup_printf("sync_%s %s", split[0], split[1]); } g_strfreev (split); } -static void +void cmd_fifo_dir() { uzbl.behave.fifo_dir = init_fifo(uzbl.behave.fifo_dir); } -static void +void cmd_socket_dir() { uzbl.behave.socket_dir = init_socket(uzbl.behave.socket_dir); } -static void +void cmd_inject_html() { if(uzbl.behave.inject_html) { webkit_web_view_load_html_string (uzbl.gui.web_view, @@ -1761,7 +1823,7 @@ cmd_inject_html() { } } -static void +void cmd_modkey() { int i; char *buf; @@ -1779,22 +1841,23 @@ cmd_modkey() { } } -static void +void cmd_useragent() { if (*uzbl.net.useragent == ' ') { g_free (uzbl.net.useragent); uzbl.net.useragent = NULL; } else { - gchar *ua = expand_template(uzbl.net.useragent, FALSE); - if (ua) - g_object_set(G_OBJECT(uzbl.net.soup_session), SOUP_SESSION_USER_AGENT, ua, NULL); - g_free(uzbl.net.useragent); - uzbl.net.useragent = ua; + g_object_set(G_OBJECT(uzbl.net.soup_session), SOUP_SESSION_USER_AGENT, + uzbl.net.useragent, NULL); } } -static void +void move_statusbar() { + if (!uzbl.gui.scrolled_win && + !uzbl.gui.mainbar) + return; + gtk_widget_ref(uzbl.gui.scrolled_win); gtk_widget_ref(uzbl.gui.mainbar); gtk_container_remove(GTK_CONTAINER(uzbl.gui.vbox), uzbl.gui.scrolled_win); @@ -1814,70 +1877,62 @@ move_statusbar() { return; } -static gboolean -set_var_value(gchar *name, gchar *val) { +gboolean +set_var_value(const gchar *name, gchar *val) { uzbl_cmdprop *c = NULL; char *endp = NULL; char *buf = NULL; + char *invalid_chars = "^°!\"§$%&/()=?'`'+~*'#-.:,;@<>| \\{}[]¹²³¼½"; if( (c = g_hash_table_lookup(uzbl.comm.proto_var, name)) ) { + if(!c->writeable) return FALSE; + /* check for the variable type */ if (c->type == TYPE_STR) { buf = expand(val, 0); - g_free(*c->ptr); - *c->ptr = buf; + g_free(*c->ptr.s); + *c->ptr.s = buf; } else if(c->type == TYPE_INT) { - int *ip = (int *)c->ptr; buf = expand(val, 0); - *ip = (int)strtoul(buf, &endp, 10); + *c->ptr.i = (int)strtoul(buf, &endp, 10); g_free(buf); } else if (c->type == TYPE_FLOAT) { - float *fp = (float *)c->ptr; buf = expand(val, 0); - *fp = strtod(buf, &endp); + *c->ptr.f = strtod(buf, &endp); g_free(buf); } /* invoke a command specific function */ if(c->func) c->func(); - } - return TRUE; -} - -static void -render_html() { - Behaviour *b = &uzbl.behave; + } else { + /* check wether name violates our naming scheme */ + if(strpbrk(name, invalid_chars)) { + if (uzbl.state.verbose) + printf("Invalid variable name\n"); + return FALSE; + } - if(b->html_buffer->str) { - webkit_web_view_load_html_string (uzbl.gui.web_view, - b->html_buffer->str, b->base_url); - g_string_free(b->html_buffer, TRUE); - b->html_buffer = g_string_new(""); + /* custom vars */ + c = malloc(sizeof(uzbl_cmdprop)); + c->type = TYPE_STR; + c->dump = 0; + c->func = NULL; + c->writeable = 1; + buf = expand(val, 0); + c->ptr.s = malloc(sizeof(char *)); + *c->ptr.s = buf; + g_hash_table_insert(uzbl.comm.proto_var, + g_strdup(name), (gpointer) c); } + return TRUE; } enum {M_CMD, M_HTML}; -static void +void parse_cmd_line(const char *ctl_line, GString *result) { - Behaviour *b = &uzbl.behave; size_t len=0; - if(b->mode == M_HTML) { - len = strlen(b->html_endmarker); - /* ctl_line has trailing '\n' so we check for strlen(ctl_line)-1 */ - if(len == strlen(ctl_line)-1 && - !strncmp(b->html_endmarker, ctl_line, len)) { - set_timeout(0); - set_var_value("mode", "0"); - render_html(); - return; - } - else { - set_timeout(b->html_timeout); - g_string_append(b->html_buffer, ctl_line); - } - } - else if((ctl_line[0] == '#') /* Comments */ + if((ctl_line[0] == '#') /* Comments */ || (ctl_line[0] == ' ') || (ctl_line[0] == '\n')) ; /* ignore these lines */ @@ -1897,27 +1952,22 @@ parse_cmd_line(const char *ctl_line, GString *result) { } } -static gchar* +/*@null@*/ gchar* build_stream_name(int type, const gchar* dir) { - char *xwin_str = NULL; State *s = &uzbl.state; gchar *str = NULL; - xwin_str = itos((int)uzbl.xwin); if (type == FIFO) { str = g_strdup_printf - ("%s/uzbl_fifo_%s", dir, - s->instance_name ? s->instance_name : xwin_str); + ("%s/uzbl_fifo_%s", dir, s->instance_name); } else if (type == SOCKET) { str = g_strdup_printf - ("%s/uzbl_socket_%s", dir, - s->instance_name ? s->instance_name : xwin_str ); + ("%s/uzbl_socket_%s", dir, s->instance_name); } - g_free(xwin_str); return str; } -static gboolean +gboolean control_fifo(GIOChannel *gio, GIOCondition condition) { if (uzbl.state.verbose) printf("triggered\n"); @@ -1943,7 +1993,7 @@ control_fifo(GIOChannel *gio, GIOCondition condition) { return TRUE; } -static gchar* +/*@null@*/ gchar* init_fifo(gchar *dir) { /* return dir or, on error, free dir and return NULL */ if (uzbl.comm.fifo_path) { /* get rid of the old fifo if one exists */ if (unlink(uzbl.comm.fifo_path) == -1) @@ -1952,11 +2002,6 @@ init_fifo(gchar *dir) { /* return dir or, on error, free dir and return NULL */ uzbl.comm.fifo_path = NULL; } - if (*dir == ' ') { /* space unsets the variable */ - g_free (dir); - return NULL; - } - GIOChannel *chan = NULL; GError *error = NULL; gchar *path = build_stream_name(FIFO, dir); @@ -1983,7 +2028,7 @@ init_fifo(gchar *dir) { /* return dir or, on error, free dir and return NULL */ return NULL; } -static gboolean +gboolean control_stdin(GIOChannel *gio, GIOCondition condition) { (void) condition; gchar *ctl_line = NULL; @@ -1999,7 +2044,7 @@ control_stdin(GIOChannel *gio, GIOCondition condition) { return TRUE; } -static void +void create_stdin () { GIOChannel *chan = NULL; GError *error = NULL; @@ -2018,7 +2063,7 @@ create_stdin () { if (error) g_error_free (error); } -static gboolean +gboolean control_socket(GIOChannel *chan) { struct sockaddr_un remote; unsigned int t = sizeof(remote); @@ -2036,7 +2081,7 @@ control_socket(GIOChannel *chan) { return TRUE; } -static gboolean +gboolean control_client_socket(GIOChannel *clientchan) { char *ctl_line; GString *result = g_string_new(""); @@ -2072,7 +2117,7 @@ control_client_socket(GIOChannel *clientchan) { return TRUE; } -static gchar* +/*@null@*/ gchar* init_socket(gchar *dir) { /* return dir or, on error, free dir and return NULL */ if (uzbl.comm.socket_path) { /* remove an existing socket should one exist */ if (unlink(uzbl.comm.socket_path) == -1) @@ -2121,20 +2166,20 @@ init_socket(gchar *dir) { /* return dir or, on error, free dir and return NULL * it will probably improve performance if we would "cache" the processed variant, but for now it works well enough... */ // this function may be called very early when the templates are not set (yet), hence the checks -static void +void update_title (void) { Behaviour *b = &uzbl.behave; gchar *parsed; if (b->show_status) { if (b->title_format_short) { - parsed = expand_template(b->title_format_short, FALSE); + parsed = expand(b->title_format_short, 0); if (uzbl.gui.main_window) gtk_window_set_title (GTK_WINDOW(uzbl.gui.main_window), parsed); g_free(parsed); } if (b->status_format) { - parsed = expand_template(b->status_format, TRUE); + parsed = expand(b->status_format, 0); gtk_label_set_markup(GTK_LABEL(uzbl.gui.mainbar_label), parsed); g_free(parsed); } @@ -2149,7 +2194,7 @@ update_title (void) { } } else { if (b->title_format_long) { - parsed = expand_template(b->title_format_long, FALSE); + parsed = expand(b->title_format_long, 0); if (uzbl.gui.main_window) gtk_window_set_title (GTK_WINDOW(uzbl.gui.main_window), parsed); g_free(parsed); @@ -2157,29 +2202,51 @@ update_title (void) { } } -static gboolean +gboolean +configure_event_cb(GtkWidget* window, GdkEventConfigure* event) { + (void) window; + (void) event; + + retrieve_geometry(); + return FALSE; +} + +gboolean key_press_cb (GtkWidget* window, GdkEventKey* event) { //TRUE to stop other handlers from being invoked for the event. FALSE to propagate the event further. (void) window; - if (event->type != GDK_KEY_PRESS || event->keyval == GDK_Page_Up || event->keyval == GDK_Page_Down - || event->keyval == GDK_Up || event->keyval == GDK_Down || event->keyval == GDK_Left || event->keyval == GDK_Right || event->keyval == GDK_Shift_L || event->keyval == GDK_Shift_R) + if (event->type != GDK_KEY_PRESS || + event->keyval == GDK_Page_Up || + event->keyval == GDK_Page_Down || + event->keyval == GDK_Home || + event->keyval == GDK_End || + event->keyval == GDK_Up || + event->keyval == GDK_Down || + event->keyval == GDK_Left || + event->keyval == GDK_Right || + event->keyval == GDK_Shift_L || + event->keyval == GDK_Shift_R) return FALSE; /* turn off insert mode (if always_insert_mode is not used) */ if (uzbl.behave.insert_mode && (event->keyval == GDK_Escape)) { - uzbl.behave.insert_mode = uzbl.behave.always_insert_mode; + set_insert_mode(uzbl.behave.always_insert_mode); update_title(); return TRUE; } - if (uzbl.behave.insert_mode && (((event->state & uzbl.behave.modmask) != uzbl.behave.modmask) || (!uzbl.behave.modmask))) + if (uzbl.behave.insert_mode && + ( ((event->state & uzbl.behave.modmask) != uzbl.behave.modmask) || + (!uzbl.behave.modmask) + ) + ) return FALSE; if (event->keyval == GDK_Escape) { - g_string_truncate(uzbl.state.keycmd, 0); + clear_keycmd(); update_title(); dehilight(uzbl.gui.web_view, NULL, NULL); return TRUE; @@ -2194,7 +2261,9 @@ key_press_cb (GtkWidget* window, GdkEventKey* event) str = gtk_clipboard_wait_for_text (gtk_clipboard_get (GDK_SELECTION_CLIPBOARD)); } if (str) { - g_string_append (uzbl.state.keycmd, str); + GString* keycmd = g_string_new(uzbl.state.keycmd); + g_string_append (keycmd, str); + uzbl.state.keycmd = g_string_free(keycmd, FALSE); update_title (); g_free (str); } @@ -2207,7 +2276,11 @@ key_press_cb (GtkWidget* window, GdkEventKey* event) gboolean key_ret = FALSE; if ((event->keyval == GDK_Return) || (event->keyval == GDK_KP_Enter)) key_ret = TRUE; - if (!key_ret) g_string_append(uzbl.state.keycmd, event->string); + if (!key_ret) { + GString* keycmd = g_string_new(uzbl.state.keycmd); + g_string_append(keycmd, event->string); + uzbl.state.keycmd = g_string_free(keycmd, FALSE); + } run_keycmd(key_ret); update_title(); @@ -2215,12 +2288,12 @@ key_press_cb (GtkWidget* window, GdkEventKey* event) return TRUE; } -static void +void run_keycmd(const gboolean key_ret) { /* run the keycmd immediately if it isn't incremental and doesn't take args */ Action *act; - if ((act = g_hash_table_lookup(uzbl.bindings, uzbl.state.keycmd->str))) { - g_string_truncate(uzbl.state.keycmd, 0); + if ((act = g_hash_table_lookup(uzbl.bindings, uzbl.state.keycmd))) { + clear_keycmd(); parse_command(act->name, act->param, NULL); return; } @@ -2229,8 +2302,9 @@ run_keycmd(const gboolean key_ret) { GString* short_keys = g_string_new (""); GString* short_keys_inc = g_string_new (""); guint i; - for (i=0; i<(uzbl.state.keycmd->len); i++) { - g_string_append_c(short_keys, uzbl.state.keycmd->str[i]); + guint len = strlen(uzbl.state.keycmd); + for (i=0; istr); g_string_append_c(short_keys, '_'); g_string_append_c(short_keys_inc, '*'); @@ -2238,11 +2312,11 @@ run_keycmd(const gboolean key_ret) { if (key_ret && (act = g_hash_table_lookup(uzbl.bindings, short_keys->str))) { /* run normal cmds only if return was pressed */ exec_paramcmd(act, i); - g_string_truncate(uzbl.state.keycmd, 0); + clear_keycmd(); break; } else if ((act = g_hash_table_lookup(uzbl.bindings, short_keys_inc->str))) { if (key_ret) /* just quit the incremental command on return */ - g_string_truncate(uzbl.state.keycmd, 0); + clear_keycmd(); else exec_paramcmd(act, i); /* otherwise execute the incremental */ break; } @@ -2253,9 +2327,9 @@ run_keycmd(const gboolean key_ret) { g_string_free (short_keys_inc, TRUE); } -static void +void exec_paramcmd(const Action *act, const guint i) { - GString *parampart = g_string_new (uzbl.state.keycmd->str); + GString *parampart = g_string_new (uzbl.state.keycmd); GString *actionname = g_string_new (""); GString *actionparam = g_string_new (""); g_string_erase (parampart, 0, i+1); @@ -2270,33 +2344,26 @@ exec_paramcmd(const Action *act, const guint i) { } -static GtkWidget* +void create_browser () { GUI *g = &uzbl.gui; - GtkWidget* scrolled_window = gtk_scrolled_window_new (NULL, NULL); - //main_window_ref = g_object_ref(scrolled_window); - gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_NEVER); //todo: some sort of display of position/total length. like what emacs does - g->web_view = WEBKIT_WEB_VIEW (webkit_web_view_new ()); - gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET (g->web_view)); g_signal_connect (G_OBJECT (g->web_view), "notify::title", G_CALLBACK (title_change_cb), NULL); g_signal_connect (G_OBJECT (g->web_view), "load-progress-changed", G_CALLBACK (progress_change_cb), g->web_view); g_signal_connect (G_OBJECT (g->web_view), "load-committed", G_CALLBACK (load_commit_cb), g->web_view); g_signal_connect (G_OBJECT (g->web_view), "load-started", G_CALLBACK (load_start_cb), g->web_view); - g_signal_connect (G_OBJECT (g->web_view), "load-finished", G_CALLBACK (log_history_cb), g->web_view); g_signal_connect (G_OBJECT (g->web_view), "load-finished", G_CALLBACK (load_finish_cb), g->web_view); g_signal_connect (G_OBJECT (g->web_view), "hovering-over-link", G_CALLBACK (link_hover_cb), g->web_view); + g_signal_connect (G_OBJECT (g->web_view), "navigation-policy-decision-requested", G_CALLBACK (navigation_decision_cb), g->web_view); g_signal_connect (G_OBJECT (g->web_view), "new-window-policy-decision-requested", G_CALLBACK (new_window_cb), g->web_view); g_signal_connect (G_OBJECT (g->web_view), "download-requested", G_CALLBACK (download_cb), g->web_view); g_signal_connect (G_OBJECT (g->web_view), "create-web-view", G_CALLBACK (create_web_view_cb), g->web_view); g_signal_connect (G_OBJECT (g->web_view), "mime-type-policy-decision-requested", G_CALLBACK (mime_policy_cb), g->web_view); - - return scrolled_window; } -static GtkWidget* +GtkWidget* create_mainbar () { GUI *g = &uzbl.gui; @@ -2315,19 +2382,20 @@ create_mainbar () { return g->mainbar; } -static -GtkWidget* create_window () { +GtkWidget* +create_window () { GtkWidget* window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size (GTK_WINDOW (window), 800, 600); gtk_widget_set_name (window, "Uzbl browser"); g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (destroy_cb), NULL); g_signal_connect (G_OBJECT (window), "key-press-event", G_CALLBACK (key_press_cb), NULL); + g_signal_connect (G_OBJECT (window), "configure-event", G_CALLBACK (configure_event_cb), NULL); return window; } -static -GtkPlug* create_plug () { +GtkPlug* +create_plug () { GtkPlug* plug = GTK_PLUG (gtk_plug_new (uzbl.state.socket_id)); g_signal_connect (G_OBJECT (plug), "destroy", G_CALLBACK (destroy_cb), NULL); g_signal_connect (G_OBJECT (plug), "key-press-event", G_CALLBACK (key_press_cb), NULL); @@ -2336,7 +2404,7 @@ GtkPlug* create_plug () { } -static gchar** +gchar** inject_handler_args(const gchar *actname, const gchar *origargs, const gchar *newargs) { /* If actname is one that calls an external command, this function will inject @@ -2344,7 +2412,7 @@ inject_handler_args(const gchar *actname, const gchar *origargs, const gchar *ne come become after the body of the script (in sh) or after the name of the command to execute (in spawn). i.e. sh becomes sh and - span becomes spawn . + spawn becomes spawn . The return value consist of two strings: the action (sh, ...) and its args. @@ -2352,13 +2420,15 @@ inject_handler_args(const gchar *actname, const gchar *origargs, const gchar *ne gets duplicated. */ GArray *rets = g_array_new(TRUE, FALSE, sizeof(gchar*)); + /* Arrr! Here be memory leaks */ gchar *actdup = g_strdup(actname); g_array_append_val(rets, actdup); if ((g_strcmp0(actname, "spawn") == 0) || (g_strcmp0(actname, "sh") == 0) || (g_strcmp0(actname, "sync_spawn") == 0) || - (g_strcmp0(actname, "sync_sh") == 0)) { + (g_strcmp0(actname, "sync_sh") == 0) || + (g_strcmp0(actname, "talk_to_socket") == 0)) { guint i; GString *a = g_string_new(""); gchar **spawnparts = split_quoted(origargs, FALSE); @@ -2378,7 +2448,7 @@ inject_handler_args(const gchar *actname, const gchar *origargs, const gchar *ne return (gchar**)g_array_free(rets, FALSE); } -static void +void run_handler (const gchar *act, const gchar *args) { /* Consider this code a temporary hack to make the handlers usable. In practice, all this splicing, injection, and reconstruction is @@ -2437,7 +2507,7 @@ run_handler (const gchar *act, const gchar *args) { g_strfreev(parts); } -static void +void add_binding (const gchar *key, const gchar *act) { char **parts = g_strsplit(act, " ", 2); Action *action; @@ -2456,7 +2526,7 @@ add_binding (const gchar *key, const gchar *act) { g_strfreev(parts); } -static gchar* +/*@null@*/ gchar* get_xdg_var (XDG_Var xdg) { const gchar* actual_value = getenv (xdg.environmental); const gchar* home = getenv ("HOME"); @@ -2475,8 +2545,8 @@ get_xdg_var (XDG_Var xdg) { return return_value; } -static gchar* -find_xdg_file (int xdg_type, char* filename) { +/*@null@*/ gchar* +find_xdg_file (int xdg_type, const char* filename) { /* xdg_type = 0 => config xdg_type = 1 => data xdg_type = 2 => cache*/ @@ -2505,10 +2575,11 @@ find_xdg_file (int xdg_type, char* filename) { if (file_exists (temporary_file)) { return temporary_file; } else { + g_free(temporary_file); return NULL; } } -static void +void settings_init () { State *s = &uzbl.state; Network *n = &uzbl.net; @@ -2516,7 +2587,7 @@ settings_init () { for (i = 0; default_config[i].command != NULL; i++) { parse_cmd_line(default_config[i].command, NULL); } - + if (g_strcmp0(s->config_file, "-") == 0) { s->config_file = NULL; create_stdin(); @@ -2545,7 +2616,7 @@ settings_init () { g_signal_connect_after(n->soup_session, "request-started", G_CALLBACK(handle_cookies), NULL); } -static void handle_cookies (SoupSession *session, SoupMessage *msg, gpointer user_data){ +void handle_cookies (SoupSession *session, SoupMessage *msg, gpointer user_data){ (void) session; (void) user_data; if (!uzbl.behave.cookie_handler) @@ -2568,7 +2639,7 @@ static void handle_cookies (SoupSession *session, SoupMessage *msg, gpointer use g_string_free(s, TRUE); } -static void +void save_cookies (SoupMessage *msg, gpointer user_data){ (void) user_data; GSList *ck; @@ -2586,14 +2657,14 @@ save_cookies (SoupMessage *msg, gpointer user_data){ } /* --- WEBINSPECTOR --- */ -static void +void hide_window_cb(GtkWidget *widget, gpointer data) { (void) data; gtk_widget_hide(widget); } -static WebKitWebView* +WebKitWebView* create_inspector_cb (WebKitWebInspector* web_inspector, WebKitWebView* page, gpointer data){ (void) data; (void) page; @@ -2622,7 +2693,7 @@ create_inspector_cb (WebKitWebInspector* web_inspector, WebKitWebView* page, gpo return WEBKIT_WEB_VIEW(new_web_view); } -static gboolean +gboolean inspector_show_window_cb (WebKitWebInspector* inspector){ (void) inspector; gtk_widget_show(uzbl.gui.inspector_window); @@ -2630,37 +2701,37 @@ inspector_show_window_cb (WebKitWebInspector* inspector){ } /* TODO: Add variables and code to make use of these functions */ -static gboolean +gboolean inspector_close_window_cb (WebKitWebInspector* inspector){ (void) inspector; return TRUE; } -static gboolean +gboolean inspector_attach_window_cb (WebKitWebInspector* inspector){ (void) inspector; return FALSE; } -static gboolean +gboolean inspector_detach_window_cb (WebKitWebInspector* inspector){ (void) inspector; return FALSE; } -static gboolean +gboolean inspector_uri_changed_cb (WebKitWebInspector* inspector){ (void) inspector; return FALSE; } -static gboolean +gboolean inspector_inspector_destroyed_cb (WebKitWebInspector* inspector){ (void) inspector; return FALSE; } -static void +void set_up_inspector() { GUI *g = &uzbl.gui; WebKitWebSettings *settings = view_settings(); @@ -2677,7 +2748,7 @@ set_up_inspector() { g_signal_connect (G_OBJECT (g->inspector), "notify::inspected-uri", G_CALLBACK (inspector_uri_changed_cb), NULL); } -static void +void dump_var_hash(gpointer k, gpointer v, gpointer ud) { (void) ud; uzbl_cmdprop *c = v; @@ -2686,12 +2757,14 @@ dump_var_hash(gpointer k, gpointer v, gpointer ud) { return; if(c->type == TYPE_STR) - printf("set %s = %s\n", (char *)k, *c->ptr?(char *)*c->ptr:" "); + printf("set %s = %s\n", (char *)k, *c->ptr.s ? *c->ptr.s : " "); else if(c->type == TYPE_INT) - printf("set %s = %d\n", (char *)k, (int)*c->ptr); + printf("set %s = %d\n", (char *)k, *c->ptr.i); + else if(c->type == TYPE_FLOAT) + printf("set %s = %f\n", (char *)k, *c->ptr.f); } -static void +void dump_key_hash(gpointer k, gpointer v, gpointer ud) { (void) ud; Action *a = v; @@ -2700,16 +2773,31 @@ dump_key_hash(gpointer k, gpointer v, gpointer ud) { (char *)a->name, a->param?(char *)a->param:""); } -static void +void dump_config() { g_hash_table_foreach(uzbl.comm.proto_var, dump_var_hash, NULL); g_hash_table_foreach(uzbl.bindings, dump_key_hash, NULL); } -/** -- MAIN -- **/ -int -main (int argc, char* argv[]) { - gtk_init (&argc, &argv); +void +retrieve_geometry() { + int w, h, x, y; + GString *buf = g_string_new(""); + + gtk_window_get_size(GTK_WINDOW(uzbl.gui.main_window), &w, &h); + gtk_window_get_position(GTK_WINDOW(uzbl.gui.main_window), &x, &y); + + g_string_printf(buf, "%dx%d+%d+%d", w, h, x, y); + + if(uzbl.gui.geometry) + g_free(uzbl.gui.geometry); + uzbl.gui.geometry = g_string_free(buf, FALSE); +} + +/* set up gtk, gobject, variable defaults and other things that tests and other + * external applications need to do anyhow */ +void +initialize(int argc, char *argv[]) { if (!g_thread_supported ()) g_thread_init (NULL); uzbl.state.executable_path = g_strdup(argv[0]); @@ -2724,52 +2812,58 @@ main (int argc, char* argv[]) { if (uzbl.behave.print_version) { printf("Commit: %s\n", COMMIT); - exit(0); + exit(EXIT_SUCCESS); } - gchar *uri_override = (uzbl.state.uri ? g_strdup(uzbl.state.uri) : NULL); - if (argc > 1 && !uzbl.state.uri) - uri_override = g_strdup(argv[1]); - gboolean verbose_override = uzbl.state.verbose; - /* initialize hash table */ uzbl.bindings = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, free_action); uzbl.net.soup_session = webkit_get_default_session(); - uzbl.state.keycmd = g_string_new(""); + uzbl.state.keycmd = g_strdup(""); if(setup_signal(SIGTERM, catch_sigterm) == SIG_ERR) fprintf(stderr, "uzbl: error hooking SIGTERM\n"); if(setup_signal(SIGINT, catch_sigint) == SIG_ERR) fprintf(stderr, "uzbl: error hooking SIGINT\n"); - if(setup_signal(SIGALRM, catch_alrm) == SIG_ERR) - fprintf(stderr, "uzbl: error hooking SIGALARM\n"); - - if(uname(&uzbl.state.unameinfo) == -1) - g_printerr("Can't retrieve unameinfo. Your useragent might appear wrong.\n"); - - uzbl.gui.sbar.progress_s = g_strdup("="); + uzbl.gui.sbar.progress_s = g_strdup("="); //TODO: move these to config.h uzbl.gui.sbar.progress_u = g_strdup("·"); uzbl.gui.sbar.progress_w = 10; - /* HTML mode defaults*/ - uzbl.behave.html_buffer = g_string_new(""); - uzbl.behave.html_endmarker = g_strdup("."); - uzbl.behave.html_timeout = 60; - uzbl.behave.base_url = g_strdup("http://invalid"); - /* default mode indicators */ uzbl.behave.insert_indicator = g_strdup("I"); uzbl.behave.cmd_indicator = g_strdup("C"); - setup_scanner(); + uzbl.info.webkit_major = WEBKIT_MAJOR_VERSION; + uzbl.info.webkit_minor = WEBKIT_MINOR_VERSION; + uzbl.info.webkit_micro = WEBKIT_MICRO_VERSION; + uzbl.info.arch = ARCH; + uzbl.info.commit = COMMIT; + commands_hash (); make_var_to_name_hash(); + create_browser(); +} + +#ifndef UZBL_LIBRARY +/** -- MAIN -- **/ +int +main (int argc, char* argv[]) { + initialize(argc, argv); + + gtk_init (&argc, &argv); + + uzbl.gui.scrolled_win = gtk_scrolled_window_new (NULL, NULL); + //main_window_ref = g_object_ref(scrolled_window); + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (uzbl.gui.scrolled_win), + GTK_POLICY_NEVER, GTK_POLICY_NEVER); //todo: some sort of display of position/total length. like what emacs does + + gtk_container_add (GTK_CONTAINER (uzbl.gui.scrolled_win), + GTK_WIDGET (uzbl.gui.web_view)); + uzbl.gui.vbox = gtk_vbox_new (FALSE, 0); - uzbl.gui.scrolled_win = create_browser(); create_mainbar(); /* initial packing */ @@ -2787,6 +2881,9 @@ main (int argc, char* argv[]) { uzbl.xwin = GDK_WINDOW_XID (GTK_WIDGET (uzbl.gui.main_window)->window); } + if(!uzbl.state.instance_name) + uzbl.state.instance_name = itos((int)uzbl.xwin); + gtk_widget_grab_focus (GTK_WIDGET (uzbl.gui.web_view)); if (uzbl.state.verbose) { @@ -2797,6 +2894,7 @@ main (int argc, char* argv[]) { printf("window_id %i\n",(int) uzbl.xwin); printf("pid %i\n", getpid ()); printf("name: %s\n", uzbl.state.instance_name); + printf("commit: %s\n", uzbl.info.commit); } uzbl.gui.scbar_v = (GtkScrollbar*) gtk_vscrollbar_new (NULL); @@ -2805,8 +2903,24 @@ main (int argc, char* argv[]) { uzbl.gui.bar_h = gtk_range_get_adjustment((GtkRange*) uzbl.gui.scbar_h); gtk_widget_set_scroll_adjustments ((GtkWidget*) uzbl.gui.web_view, uzbl.gui.bar_h, uzbl.gui.bar_v); + /* Check uzbl is in window mode before getting/setting geometry */ + if (uzbl.gui.main_window) { + if(uzbl.gui.geometry) + cmd_set_geometry(); + else + retrieve_geometry(); + } + + gchar *uri_override = (uzbl.state.uri ? g_strdup(uzbl.state.uri) : NULL); + if (argc > 1 && !uzbl.state.uri) + uri_override = g_strdup(argv[1]); + gboolean verbose_override = uzbl.state.verbose; + settings_init (); + if (!uzbl.behave.always_insert_mode) + set_insert_mode(FALSE); + if (!uzbl.behave.show_status) gtk_widget_hide(uzbl.gui.mainbar); else @@ -2822,12 +2936,13 @@ main (int argc, char* argv[]) { set_var_value("uri", uri_override); g_free(uri_override); } else if (uzbl.state.uri) - cmd_load_uri(uzbl.gui.web_view, NULL); + cmd_load_uri(); gtk_main (); clean_up(); return EXIT_SUCCESS; } +#endif /* vi: set et ts=4: */