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", '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,
+ { "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", '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,
+ { "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 }
/* associate command names to their properties */
typedef const struct {
+ /* TODO: Make this ambiguous void **ptr into a union { char *char_p; int *int_p; float *float_p; } val;
+ the PTR() macro is kind of preventing this change at the moment. */
void **ptr;
int type;
int dump;
{ "base_url", PTR_V(uzbl.behave.base_url, STR, 1, NULL)},
{ "html_endmarker", PTR_V(uzbl.behave.html_endmarker, STR, 1, NULL)},
{ "html_mode_timeout", PTR_V(uzbl.behave.html_timeout, INT, 1, NULL)},
- { "keycmd", PTR_V(uzbl.state.keycmd, STR, 1, NULL)}, /* XXX */
+ { "keycmd", PTR_V(uzbl.state.keycmd, STR, 1, set_keycmd)},
{ "status_message", PTR_V(uzbl.gui.sbar.msg, STR, 1, update_title)},
{ "show_status", PTR_V(uzbl.behave.show_status, INT, 1, cmd_set_status)},
{ "status_top", PTR_V(uzbl.behave.status_top, INT, 1, move_statusbar)},
{ "status_pbar_pending", PTR_V(uzbl.gui.sbar.progress_u, STR, 1, update_title)},
{ "status_pbar_width", PTR_V(uzbl.gui.sbar.progress_w, INT, 1, update_title)},
{ "status_background", PTR_V(uzbl.behave.status_background, STR, 1, update_title)},
- { "insert_indicator", PTR_V(uzbl.behave.insert_indicator, STR, 1, update_title)},
- { "command_indicator", PTR_V(uzbl.behave.cmd_indicator, STR, 1, update_title)},
+ { "insert_indicator", PTR_V(uzbl.behave.insert_indicator, STR, 1, update_indicator)},
+ { "command_indicator", PTR_V(uzbl.behave.cmd_indicator, STR, 1, update_indicator)},
{ "title_format_long", PTR_V(uzbl.behave.title_format_long, STR, 1, update_title)},
{ "title_format_short", PTR_V(uzbl.behave.title_format_short, STR, 1, update_title)},
{ "icon", PTR_V(uzbl.gui.icon, STR, 1, set_icon)},
- { "insert_mode", PTR_V(uzbl.behave.insert_mode, INT, 1, NULL)}, /* XXX */
+ { "insert_mode", PTR_V(uzbl.behave.insert_mode, INT, 1, set_mode_indicator)},
{ "always_insert_mode", PTR_V(uzbl.behave.always_insert_mode, INT, 1, cmd_always_insert_mode)},
{ "reset_command_mode", PTR_V(uzbl.behave.reset_command_mode, INT, 1, NULL)},
{ "modkey", PTR_V(uzbl.behave.modkey, STR, 1, cmd_modkey)},
{ "max_conns", PTR_V(uzbl.net.max_conns, INT, 1, cmd_max_conns)},
{ "max_conns_host", PTR_V(uzbl.net.max_conns_host, INT, 1, cmd_max_conns_host)},
{ "useragent", PTR_V(uzbl.net.useragent, STR, 1, cmd_useragent)},
+
/* exported WebKitWebSettings properties */
{ "zoom_level", PTR_V(uzbl.behave.zoom_level, FLOAT,1, cmd_zoom_level)},
{ "font_size", PTR_V(uzbl.behave.font_size, INT, 1, cmd_font_size)},
};
-/* construct a hash from the var_name_to_ptr and the const_name_to_ptr array
- * for quick access */
+/* construct a hash from the var_name_to_ptr array for quick access */
void
make_var_to_name_hash() {
uzbl.comm.proto_var = g_hash_table_new(g_str_hash, g_str_equal);
}
/* --- UTILITY FUNCTIONS --- */
-
enum {EXP_ERR, EXP_SIMPLE_VAR, EXP_BRACED_VAR, EXP_EXPR, EXP_JS, EXP_ESCAPE};
-static guint
+guint
get_exp_type(gchar *s) {
/* variables */
if(*(s+1) == '(')
guint etype;
char upto = ' ';
char *end_simple_var = "^°!\"§$%&/()=?'`'+~*'#-.:,;@<>| \\{}[]¹²³¼½";
- char str_end[2];
+ char str_end[3];
char ret[4096];
- char *vend;
+ char *vend = NULL;
GError *err = NULL;
gchar *cmd_stdout = NULL;
gchar *mycmd = NULL;
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';
- }
+ vend = strchr(s, upto);
+ 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, str_end);
+ 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, str_end);
+ if(!vend) vend = strchr(s, '\0');
break;
case EXP_ESCAPE:
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, str_end);
+ if(!vend) vend = strchr(s, '\0');
break;
}
+ if(vend) {
+ strncpy(ret, s, vend-s);
+ ret[vend-s] = '\0';
+ }
+
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 && *c->ptr != NULL) {
g_string_append(buf, (gchar *)*c->ptr);
} else if(c->type == TYPE_INT) {
- char *b = itos((uintptr_t)*c->ptr);
- g_string_append(buf, b);
- g_free(b);
+ g_string_append_printf(buf, "%d", (int)*c->ptr);
+ }
+ else if(c->type == TYPE_FLOAT) {
+ g_string_append_printf(buf, "%f", *(float *)c->ptr);
}
}
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;
return ret;
}
-static GArray*
+GArray*
read_file_by_line (gchar *path) {
GIOChannel *chan = NULL;
gchar *readbuf = NULL;
return lines;
}
-static
-gchar* parseenv (char* string) {
+gchar*
+parseenv (char* string) {
extern char** environ;
gchar* tmpstr = NULL;
int i = 0;
return string;
}
-static sigfunc*
+sigfunc*
setup_signal(int signr, sigfunc *shandler) {
struct sigaction nh, oh;
return NULL;
}
-static void
+void
clean_up(void) {
if (uzbl.behave.fifo_dir)
unlink (uzbl.comm.fifo_path);
* be sure to extend this function to use
* more timers if needed in other places
*/
-static void
+void
set_timeout(int seconds) {
struct itimerval t;
memset(&t, 0, sizeof t);
/* --- 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
+void
catch_alrm(int s) {
(void) s;
/* --- CALLBACKS --- */
-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;
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;
return (NULL);
}
-static gboolean
+gboolean
download_cb (WebKitWebView *web_view, GObject *download, gpointer user_data) {
(void) web_view;
(void) user_data;
}
/* scroll a bar in a given direction */
-static void
+void
scroll (GtkAdjustment* bar, GArray *argv) {
gchar *end;
gdouble max_value;
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
+ */
+ retreive_geometry();
+}
+
+void
cmd_set_status() {
if (!uzbl.behave.show_status) {
gtk_widget_hide(uzbl.gui.mainbar);
update_title();
}
-static void
+void
toggle_zoom_type (WebKitWebView* page, GArray *argv, GString *result) {
(void)page;
(void)argv;
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;
update_title();
}
-static void
+void
link_hover_cb (WebKitWebView* page, const gchar* title, const gchar* link, gpointer data) {
(void) page;
(void) title;
update_title();
}
-static void
+void
title_change_cb (WebKitWebView* web_view, GParamSpec param_spec) {
(void) web_view;
(void) param_spec;
update_title();
}
-static void
+void
load_finish_cb (WebKitWebView* page, WebKitWebFrame* frame, gpointer data) {
(void) page;
(void) frame;
uzbl.state.keycmd = g_strdup("");
}
-static void
+void
load_start_cb (WebKitWebView* page, WebKitWebFrame* frame, gpointer data) {
(void) page;
(void) frame;
run_handler(uzbl.behave.load_start_handler, "");
}
-static void
+void
load_commit_cb (WebKitWebView* page, WebKitWebFrame* frame, gpointer data) {
(void) page;
(void) data;
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
+void
log_history_cb () {
if (uzbl.behave.history_handler) {
time_t rawtime;
/* 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)
#undef VIEWFUNC
/* -- command to callback/function map for things we cannot attach to any signals */
-static struct {char *key; CommandInfo value;} cmdlist[] =
+struct {char *key; CommandInfo value;} cmdlist[] =
{ /* key function no_split */
{ "back", {view_go_back, 0} },
{ "forward", {view_go_forward, 0} },
{ "print", {print, TRUE} }
};
-static void
+void
commands_hash(void)
{
unsigned int i;
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);
g_strfreev(split);
}
-static void
+void
print(WebKitWebView *page, GArray *argv, GString *result) {
(void) page; (void) result;
gchar* buf;
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);
}
-static void
+void
act_dump_config() {
dump_config();
}
-/* XXX set_var_value instead? */
-void set_insert_mode(gboolean mode) {
- uzbl.behave.insert_mode = mode;
- uzbl.gui.sbar.mode_indicator = (mode ?
+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);
}
-static void
+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;
update_title();
}
-static void
+void
load_uri (WebKitWebView *web_view, GArray *argv, GString *result) {
(void) result;
}
}
-
/* Javascript*/
-static JSValueRef
+JSValueRef
js_run_command (JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject,
size_t argumentCount, const JSValueRef arguments[],
JSValueRef* exception) {
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) {
}
-static void
+void
eval_js(WebKitWebView * web_view, gchar *script, GString *result) {
WebKitWebFrame *frame;
JSGlobalContextRef context;
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)) {
}
}
-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) {
}
}
-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 ("");
g_string_free (to_execute, TRUE);
}
-static void
+void
chain (WebKitWebView *page, GArray *argv, GString *result) {
(void) page; (void) result;
gchar *a = NULL;
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;
update_title();
}
-static void
+void
keycmd_nl (WebKitWebView *page, GArray *argv, GString *result) {
(void)page;
(void)argv;
update_title();
}
-static void
+void
keycmd_bs (WebKitWebView *page, GArray *argv, GString *result) {
gchar *prev;
(void)page;
update_title();
}
-static void
+void
close_uzbl (WebKitWebView *page, GArray *argv, GString *result) {
(void)page;
(void)argv;
}
/* --Statusbar functions-- */
-static char*
+char*
build_progressbar_ascii(int percent) {
int width=uzbl.gui.sbar.progress_w;
int i;
}
/* --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 <uzbl conf> <uzbl pid> <uzbl win id> <uzbl fifo file> <uzbl socket file> [args]
return result;
}
-static gchar**
+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 */
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
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;
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) {
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) {
g_strfreev (cmd);
}
-static void
+void
parse_command(const char *cmd, const char *param, GString *result) {
CommandInfo *c;
g_printerr ("command \"%s\" not understood. ignoring.\n", cmd);
}
-static void
+void
set_proxy_url() {
SoupURI *suri;
return;
}
-static void
+void
set_icon() {
if(file_exists(uzbl.gui.icon)) {
if (uzbl.gui.main_window)
}
}
-static void
+void
cmd_load_uri() {
GArray *a = g_array_new (TRUE, FALSE, sizeof(gchar*));
g_array_append_val (a, uzbl.state.uri);
g_array_free (a, TRUE);
}
-static void
+void
cmd_always_insert_mode() {
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));
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) {
}
}
-static void
+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 */
g_strfreev (split);
}
-static void
+void
cmd_new_window() {
gchar **split = g_strsplit(uzbl.behave.new_window, " ", 2);
/* pitfall: doesn't handle chain actions; must the sync_ action manually */
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,
}
}
-static void
+void
cmd_modkey() {
int i;
char *buf;
}
}
-static void
+void
move_statusbar() {
gtk_widget_ref(uzbl.gui.scrolled_win);
gtk_widget_ref(uzbl.gui.mainbar);
char *buf = NULL;
if( (c = g_hash_table_lookup(uzbl.comm.proto_var, name)) ) {
- if(!c->writeable) return TRUE;
+ if(!c->writeable) return FALSE;
/* check for the variable type */
if (c->type == TYPE_STR) {
return TRUE;
}
-static void
+void
render_html() {
Behaviour *b = &uzbl.behave;
}
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;
}
}
-static gchar*
+gchar*
build_stream_name(int type, const gchar* dir) {
State *s = &uzbl.state;
gchar *str = NULL;
return str;
}
-static gboolean
+gboolean
control_fifo(GIOChannel *gio, GIOCondition condition) {
if (uzbl.state.verbose)
printf("triggered\n");
return TRUE;
}
-static gchar*
+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)
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);
return NULL;
}
-static gboolean
+gboolean
control_stdin(GIOChannel *gio, GIOCondition condition) {
(void) condition;
gchar *ctl_line = NULL;
return TRUE;
}
-static void
+void
create_stdin () {
GIOChannel *chan = NULL;
GError *error = NULL;
if (error) g_error_free (error);
}
-static gboolean
+gboolean
control_socket(GIOChannel *chan) {
struct sockaddr_un remote;
unsigned int t = sizeof(remote);
return TRUE;
}
-static gboolean
+gboolean
control_client_socket(GIOChannel *clientchan) {
char *ctl_line;
GString *result = g_string_new("");
return TRUE;
}
-static gchar*
+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)
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;
}
}
-static gboolean
+gboolean
+configure_event_cb(GtkWidget* window, GdkEventConfigure* event) {
+ (void) window;
+ (void) event;
+
+ retreive_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_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) */
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) {
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;
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);
GString *actionname = g_string_new ("");
return scrolled_window;
}
-static GtkWidget*
+GtkWidget*
create_mainbar () {
GUI *g = &uzbl.gui;
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);
}
-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
come become after the body of the script (in sh) or after the name of
the command to execute (in spawn).
i.e. sh <body> <userargs> becomes sh <body> <ARGS> <userargs> and
- span <command> <userargs> becomes spawn <command> <ARGS> <userargs>.
+ spawn <command> <userargs> becomes spawn <command> <ARGS> <userargs>.
The return value consist of two strings: the action (sh, ...) and its args.
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);
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
g_strfreev(parts);
}
-static void
+void
add_binding (const gchar *key, const gchar *act) {
char **parts = g_strsplit(act, " ", 2);
Action *action;
g_strfreev(parts);
}
-static gchar*
+gchar*
get_xdg_var (XDG_Var xdg) {
const gchar* actual_value = getenv (xdg.environmental);
const gchar* home = getenv ("HOME");
return return_value;
}
-static gchar*
+gchar*
find_xdg_file (int xdg_type, char* filename) {
/* xdg_type = 0 => config
xdg_type = 1 => data
return NULL;
}
}
-static void
+void
settings_init () {
State *s = &uzbl.state;
Network *n = &uzbl.net;
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();
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)
soup_message_add_header_handler(msg, "got-headers", "Set-Cookie", G_CALLBACK(save_cookies), NULL);
GString *s = g_string_new ("");
SoupURI * soup_uri = soup_message_get_uri(msg);
- g_string_printf(s, "GET '%s' '%s'", soup_uri->host, soup_uri->path);
+ g_string_printf(s, "GET '%s' '%s' '%s'", soup_uri->scheme, soup_uri->host, soup_uri->path);
run_handler(uzbl.behave.cookie_handler, s->str);
if(uzbl.comm.sync_stdout && strcmp (uzbl.comm.sync_stdout, "") != 0) {
g_string_free(s, TRUE);
}
-static void
+void
save_cookies (SoupMessage *msg, gpointer user_data){
(void) user_data;
GSList *ck;
cookie = soup_cookie_to_set_cookie_header(ck->data);
SoupURI * soup_uri = soup_message_get_uri(msg);
GString *s = g_string_new ("");
- g_string_printf(s, "PUT '%s' '%s' '%s'", soup_uri->host, soup_uri->path, cookie);
+ g_string_printf(s, "PUT '%s' '%s' '%s' '%s'", soup_uri->scheme, soup_uri->host, soup_uri->path, cookie);
run_handler(uzbl.behave.cookie_handler, s->str);
g_free (cookie);
g_string_free(s, TRUE);
}
/* --- 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;
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);
}
/* 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();
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;
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 ? (char *)*c->ptr : " ");
else if(c->type == TYPE_INT)
printf("set %s = %d\n", (char *)k, (int)*c->ptr);
+ else if(c->type == TYPE_FLOAT)
+ printf("set %s = %f\n", (char *)k, *(float *)c->ptr);
}
-static void
+void
dump_key_hash(gpointer k, gpointer v, gpointer ud) {
(void) ud;
Action *a = v;
(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);
}
+void
+retreive_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
if(setup_signal(SIGALRM, catch_alrm) == SIG_ERR)
fprintf(stderr, "uzbl: error hooking SIGALARM\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;
/* default mode indicators */
uzbl.behave.insert_indicator = g_strdup("I");
uzbl.behave.cmd_indicator = g_strdup("C");
- set_insert_mode(FALSE);
uzbl.info.webkit_major = WEBKIT_MAJOR_VERSION;
uzbl.info.webkit_minor = WEBKIT_MINOR_VERSION;
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);
+ if(uzbl.gui.geometry)
+ cmd_set_geometry();
+ else
+ retreive_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 ();
+ set_insert_mode(FALSE);
if (!uzbl.behave.show_status)
gtk_widget_hide(uzbl.gui.mainbar);
projects / uzbl-mobile / blobdiff