debian/midori
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Actually handle non web view tabs, and a View Source tab

Browse source
This commit is contained in:
Christian Dywan 2008-07-13 21:49:57 +02:00
parent 30c6102763
commit 96fef89ece
5 changed files with 608 additions and 376 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

618
midori/midori-browser.c
View file

@ -63,10 +63,10 @@ struct _MidoriBrowser
GtkWidget* statusbar; GtkWidget* statusbar;
GtkWidget* progressbar; GtkWidget* progressbar;
gchar* uri;
gchar* title;
gchar* statusbar_text; gchar* statusbar_text;
MidoriWebSettings* settings; MidoriWebSettings* settings;
GList* tab_titles;
GList* close_buttons;
KatzeXbelItem* proxy_xbel_folder; KatzeXbelItem* proxy_xbel_folder;
MidoriWebList* trash; MidoriWebList* trash;
@ -145,10 +145,84 @@ _action_set_active (MidoriBrowser* browser,
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), active); gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), active);
} }
static const gchar*
_midori_browser_get_tab_uri (MidoriBrowser* browser,
GtkWidget* widget)
{
const gchar* uri;
if (MIDORI_IS_WEB_VIEW (widget))
return midori_web_view_get_display_uri (MIDORI_WEB_VIEW (widget));
uri = g_object_get_data (G_OBJECT (widget), "browser-tab-uri");
return uri ? uri : "file://";
}
/* Note: The return value is valid only
until the next call to this function */
static const gchar*
_midori_browser_get_tab_title (MidoriBrowser* browser,
GtkWidget* widget)
{
const gchar* uri;
static gchar* title = NULL;
if (MIDORI_IS_WEB_VIEW (widget))
return midori_web_view_get_display_title (MIDORI_WEB_VIEW (widget));
uri = g_object_get_data (G_OBJECT (widget), "browser-tab-uri");
if (g_str_has_prefix (uri, "view-source:"))
{
g_free (title);
title = g_strconcat (_("Source"), ": ", uri, NULL);
return title;
}
return "untitled";
}
static GdkPixbuf*
_midori_browser_get_tab_icon (MidoriBrowser* browser,
GtkWidget* widget)
{
const gchar* uri;
GdkPixbuf* icon;
if (MIDORI_IS_WEB_VIEW (widget))
return midori_web_view_get_icon (MIDORI_WEB_VIEW (widget));
uri = g_object_get_data (G_OBJECT (widget), "browser-tab-uri");
if (g_str_has_prefix (uri, "view-source:"))
icon = gtk_widget_render_icon (widget, GTK_STOCK_EDIT,
GTK_ICON_SIZE_MENU, NULL);
else
icon = gtk_widget_render_icon (widget, GTK_STOCK_FILE,
GTK_ICON_SIZE_MENU, NULL);
return icon;
}
static void
_midori_browser_open_uri (MidoriBrowser* browser,
const gchar* uri)
{
GtkWidget* web_view;
gint n;
web_view = midori_browser_get_current_web_view (browser);
if (web_view)
webkit_web_view_open (WEBKIT_WEB_VIEW (web_view), uri);
else
{
n = midori_browser_add_uri (browser, uri);
midori_browser_set_current_page (browser, n);
}
}
static void static void
_midori_browser_update_actions (MidoriBrowser* browser) _midori_browser_update_actions (MidoriBrowser* browser)
{ {
guint n = gtk_notebook_get_n_pages (GTK_NOTEBOOK (browser->notebook)); guint n;
n = gtk_notebook_get_n_pages (GTK_NOTEBOOK (browser->notebook));
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (browser->notebook), n > 1); gtk_notebook_set_show_tabs (GTK_NOTEBOOK (browser->notebook), n > 1);
_action_set_sensitive (browser, "TabClose", n > 1); _action_set_sensitive (browser, "TabClose", n > 1);
_action_set_sensitive (browser, "TabPrevious", n > 1); _action_set_sensitive (browser, "TabPrevious", n > 1);
@ -166,26 +240,31 @@ static void
_midori_browser_update_interface (MidoriBrowser* browser) _midori_browser_update_interface (MidoriBrowser* browser)
{ {
gboolean loading; gboolean loading;
GtkWidget* widget;
GtkWidget* web_view; GtkWidget* web_view;
GdkPixbuf* pixbuf; GdkPixbuf* icon;
loading = FALSE; widget = midori_browser_get_current_tab (browser);
web_view = midori_browser_get_current_web_view (browser); web_view = widget && MIDORI_IS_WEB_VIEW (widget) ? widget : NULL;
if (web_view) loading = web_view != NULL
{ && midori_web_view_is_loading (MIDORI_WEB_VIEW (web_view));
loading = midori_web_view_is_loading (MIDORI_WEB_VIEW (web_view));
_action_set_sensitive (browser, "ZoomNormal", _action_set_sensitive (browser, "Reload", web_view != NULL && !loading);
webkit_web_view_get_zoom_level (WEBKIT_WEB_VIEW (web_view)) != 1.0); _action_set_sensitive (browser, "Stop", web_view != NULL && loading);
_action_set_sensitive (browser, "Back", _action_set_sensitive (browser, "Back", web_view != NULL
webkit_web_view_can_go_back (WEBKIT_WEB_VIEW (web_view))); && webkit_web_view_can_go_back (WEBKIT_WEB_VIEW (web_view)));
_action_set_sensitive (browser, "Forward", _action_set_sensitive (browser, "Forward", web_view != NULL
webkit_web_view_can_go_forward (WEBKIT_WEB_VIEW (web_view))); && webkit_web_view_can_go_forward (WEBKIT_WEB_VIEW (web_view)));
_action_set_sensitive (browser, "Reload", !loading);
_action_set_sensitive (browser, "Stop", loading); _action_set_sensitive (browser, "Print", web_view != NULL);
_action_set_sensitive (browser, "Print", TRUE); _action_set_sensitive (browser, "ZoomIn", web_view != NULL);
} _action_set_sensitive (browser, "ZoomOut", web_view != NULL);
else _action_set_sensitive (browser, "ZoomNormal", web_view != NULL
_action_set_sensitive (browser, "Print", FALSE); && webkit_web_view_get_zoom_level (WEBKIT_WEB_VIEW (web_view)) != 1.0);
_action_set_sensitive (browser, "SourceView", web_view != NULL);
_action_set_sensitive (browser, "FindNext", web_view != NULL);
_action_set_sensitive (browser, "FindPrevious", web_view != NULL);
/* _action_set_sensitive (browser, "FindQuick", web_view != NULL); */
GtkAction* action = gtk_action_group_get_action (browser->action_group, GtkAction* action = gtk_action_group_get_action (browser->action_group,
"ReloadStop"); "ReloadStop");
@ -196,6 +275,7 @@ _midori_browser_update_interface (MidoriBrowser* browser)
"stock-id", GTK_STOCK_REFRESH, "stock-id", GTK_STOCK_REFRESH,
"tooltip", _("Reload the current page"), NULL); "tooltip", _("Reload the current page"), NULL);
gtk_widget_hide (browser->progressbar); gtk_widget_hide (browser->progressbar);
gtk_action_set_sensitive (action, web_view != NULL);
} }
else else
{ {
@ -206,15 +286,9 @@ _midori_browser_update_interface (MidoriBrowser* browser)
gtk_widget_show (browser->progressbar); gtk_widget_show (browser->progressbar);
} }
katze_throbber_set_animated (KATZE_THROBBER (browser->throbber), loading); katze_throbber_set_animated (KATZE_THROBBER (browser->throbber), loading);
if (web_view && MIDORI_IS_WEB_VIEW (web_view)) icon = _midori_browser_get_tab_icon (browser, widget);
{ gtk_image_set_from_pixbuf (GTK_IMAGE (browser->location_icon), icon);
pixbuf = midori_web_view_get_icon (MIDORI_WEB_VIEW (web_view)); g_object_unref (icon);
gtk_image_set_from_pixbuf (GTK_IMAGE (browser->location_icon), pixbuf);
g_object_unref (pixbuf);
}
else
gtk_image_set_from_stock (GTK_IMAGE (browser->location_icon),
GTK_STOCK_FILE, GTK_ICON_SIZE_MENU);
} }
static GtkWidget* static GtkWidget*
@ -419,15 +493,12 @@ midori_browser_edit_bookmark_dialog_new (MidoriBrowser* browser,
if (new_bookmark) if (new_bookmark)
{ {
GtkWidget* web_view = midori_browser_get_current_web_view (browser); GtkWidget* widget = midori_browser_get_current_tab (browser);
bookmark = katze_xbel_bookmark_new (); bookmark = katze_xbel_bookmark_new ();
if (MIDORI_IS_WEB_VIEW (web_view)) katze_xbel_item_set_title (bookmark,
{ _midori_browser_get_tab_title (browser, widget));
katze_xbel_item_set_title (bookmark, katze_xbel_bookmark_set_href (bookmark,
midori_web_view_get_display_title (MIDORI_WEB_VIEW (web_view))); _midori_browser_get_tab_uri (browser, widget));
katze_xbel_bookmark_set_href (bookmark,
midori_web_view_get_display_uri (MIDORI_WEB_VIEW (web_view)));
}
} }
GtkWidget* hbox = gtk_hbox_new (FALSE, 8); GtkWidget* hbox = gtk_hbox_new (FALSE, 8);
@ -595,9 +666,9 @@ midori_web_view_populate_popup_cb (GtkWidget* web_view,
} }
static gboolean static gboolean
midori_web_view_leave_notify_event_cb (GtkWidget* web_view, midori_browser_tab_leave_notify_event_cb (GtkWidget* widget,
GdkEventCrossing* event, GdkEventCrossing* event,
MidoriBrowser* browser) MidoriBrowser* browser)
{ {
_midori_browser_set_statusbar_text (browser, NULL); _midori_browser_set_statusbar_text (browser, NULL);
return TRUE; return TRUE;
@ -620,49 +691,101 @@ midori_web_view_new_window_cb (GtkWidget* web_view,
g_signal_emit (browser, signals[NEW_WINDOW], 0, uri); g_signal_emit (browser, signals[NEW_WINDOW], 0, uri);
} }
static void static gboolean
midori_web_view_close_cb (GtkWidget* web_view, midori_browser_tab_destroy_cb (GtkWidget* widget,
MidoriBrowser* browser) MidoriBrowser* browser)
{ {
if (browser->proxy_xbel_folder) KatzeXbelItem* xbel_item;
const gchar* uri;
if (browser->proxy_xbel_folder && MIDORI_IS_WEB_VIEW (widget))
{ {
KatzeXbelItem* xbel_item = midori_web_view_get_proxy_xbel_item ( xbel_item = midori_web_view_get_proxy_xbel_item (
MIDORI_WEB_VIEW (web_view)); MIDORI_WEB_VIEW (widget));
const gchar* uri = katze_xbel_bookmark_get_href (xbel_item); uri = katze_xbel_bookmark_get_href (xbel_item);
if (browser->trash && uri && *uri) if (browser->trash && uri && *uri)
midori_web_list_add_item (browser->trash, xbel_item); midori_web_list_add_item (browser->trash, xbel_item);
katze_xbel_folder_remove_item (browser->proxy_xbel_folder, xbel_item); katze_xbel_folder_remove_item (browser->proxy_xbel_folder, xbel_item);
katze_xbel_item_unref (xbel_item); katze_xbel_item_unref (xbel_item);
} }
GtkWidget* scrolled = _midori_browser_scrolled_for_child (browser, web_view); GtkWidget* scrolled = _midori_browser_scrolled_for_child (browser, widget);
guint n = gtk_notebook_page_num (GTK_NOTEBOOK (browser->notebook), scrolled); guint n = gtk_notebook_page_num (GTK_NOTEBOOK (browser->notebook), scrolled);
gtk_notebook_remove_page (GTK_NOTEBOOK (browser->notebook), n); gtk_notebook_remove_page (GTK_NOTEBOOK (browser->notebook), n);
_midori_browser_update_actions (browser); _midori_browser_update_actions (browser);
}
static gboolean
midori_web_view_destroy_cb (GtkWidget* widget,
MidoriBrowser* browser)
{
_midori_browser_update_actions (browser);
return FALSE; return FALSE;
} }
static void static void
midori_browser_window_menu_item_activate_cb (GtkWidget* widget, midori_browser_window_menu_item_activate_cb (GtkWidget* menuitem,
GtkWidget* web_view) GtkWidget* widget)
{ {
MidoriBrowser* browser = MIDORI_BROWSER (gtk_widget_get_toplevel (web_view)); MidoriBrowser* browser;
if (!browser) GtkWidget* scrolled;
guint n;
g_return_if_fail (GTK_IS_WIDGET (widget));
browser = MIDORI_BROWSER (gtk_widget_get_toplevel (widget));
g_return_if_fail (MIDORI_IS_BROWSER (browser));
scrolled = _midori_browser_scrolled_for_child (browser, widget);
n = gtk_notebook_page_num (GTK_NOTEBOOK (browser->notebook), scrolled);
gtk_notebook_set_current_page (GTK_NOTEBOOK (browser->notebook), n);
}
static void
_update_label_size (GtkWidget* label,
gint size)
{
gint width, height;
if (size > -1)
{ {
g_warning ("Orphaned web view"); sokoke_widget_get_text_size (label, "M", &width, &height);
return; gtk_widget_set_size_request (label, width * size, -1);
gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
}
else
{
gtk_widget_set_size_request (label, -1, -1);
gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_NONE);
}
}
static gboolean
midori_browser_tab_label_button_release_event (GtkWidget* tab_label,
GdkEventButton* event,
GtkWidget* widget)
{
if (event->button == 2)
{
/* Close the widget on middle click */
gtk_widget_destroy (widget);
return TRUE;
} }
GtkWidget* scrolled = _midori_browser_scrolled_for_child (browser, web_view); return FALSE;
guint n = gtk_notebook_page_num (GTK_NOTEBOOK (browser->notebook), scrolled); }
gtk_notebook_set_current_page (GTK_NOTEBOOK (browser->notebook), n);
static void
midori_browser_tab_close_style_set (GtkWidget* tab_close,
GtkStyle* previous_style)
{
GtkSettings* gtk_settings;
gint width, height;
gtk_settings = gtk_widget_get_settings (tab_close);
gtk_icon_size_lookup_for_settings (gtk_settings, GTK_ICON_SIZE_BUTTON,
&width, &height);
gtk_widget_set_size_request (tab_close, width + 2, height + 2);
}
static void
midori_browser_tab_close_clicked (GtkWidget* tab_close,
GtkWidget* widget)
{
gtk_widget_destroy (widget);
} }
static gint static gint
@ -672,9 +795,17 @@ _midori_browser_add_tab (MidoriBrowser* browser,
GtkWidget* scrolled; GtkWidget* scrolled;
GtkWidget* child; GtkWidget* child;
GObjectClass* gobject_class; GObjectClass* gobject_class;
GtkWidget* label; GdkPixbuf* icon;
GtkWidget* tab_icon;
const gchar* title;
GtkWidget* tab_title;
GtkWidget* menuitem; GtkWidget* menuitem;
KatzeXbelItem* xbel_item; KatzeXbelItem* xbel_item;
GtkWidget* event_box;
GtkWidget* hbox;
GtkWidget* close_button;
GtkRcStyle* rcstyle;
GtkWidget* image;
guint n; guint n;
scrolled = gtk_scrolled_window_new (NULL, NULL); scrolled = gtk_scrolled_window_new (NULL, NULL);
@ -694,11 +825,10 @@ _midori_browser_add_tab (MidoriBrowser* browser,
gtk_container_add (GTK_CONTAINER (scrolled), child); gtk_container_add (GTK_CONTAINER (scrolled), child);
gtk_widget_show (scrolled); gtk_widget_show (scrolled);
label = NULL;
menuitem = NULL;
if (MIDORI_IS_WEB_VIEW (widget)) if (MIDORI_IS_WEB_VIEW (widget))
{ {
label = midori_web_view_get_proxy_tab_label (MIDORI_WEB_VIEW (widget)); tab_icon = midori_web_view_get_proxy_tab_icon (MIDORI_WEB_VIEW (widget));
tab_title = midori_web_view_get_proxy_tab_title (MIDORI_WEB_VIEW (widget));
menuitem = midori_web_view_get_proxy_menu_item (MIDORI_WEB_VIEW (widget)); menuitem = midori_web_view_get_proxy_menu_item (MIDORI_WEB_VIEW (widget));
if (browser->proxy_xbel_folder) if (browser->proxy_xbel_folder)
@ -732,38 +862,93 @@ _midori_browser_add_tab (MidoriBrowser* browser,
midori_web_view_element_motion_cb, browser, midori_web_view_element_motion_cb, browser,
"signal::console-message", "signal::console-message",
midori_web_view_console_message_cb, browser, midori_web_view_console_message_cb, browser,
"signal::close",
midori_web_view_close_cb, browser,
"signal::new-tab", "signal::new-tab",
midori_web_view_new_tab_cb, browser, midori_web_view_new_tab_cb, browser,
"signal::new-window", "signal::new-window",
midori_web_view_new_window_cb, browser, midori_web_view_new_window_cb, browser,
"signal::populate-popup", "signal::populate-popup",
midori_web_view_populate_popup_cb, browser, midori_web_view_populate_popup_cb, browser,
"signal::leave-notify-event",
midori_web_view_leave_notify_event_cb, browser,
"signal::destroy",
midori_web_view_destroy_cb, browser,
NULL); NULL);
} }
else
if (menuitem)
{ {
gtk_widget_show (menuitem); icon = _midori_browser_get_tab_icon (browser, widget);
g_signal_connect (menuitem, "activate", tab_icon = gtk_image_new_from_pixbuf (icon);
G_CALLBACK (midori_browser_window_menu_item_activate_cb), scrolled); title = _midori_browser_get_tab_title (browser, widget);
gtk_menu_shell_append (GTK_MENU_SHELL (browser->menu_window), menuitem); tab_title = gtk_label_new (title);
menuitem = gtk_image_menu_item_new_with_label (title);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem),
gtk_image_new_from_pixbuf (icon));
g_object_unref (icon);
if (browser->proxy_xbel_folder)
{
xbel_item = katze_xbel_bookmark_new ();
katze_xbel_item_set_title (xbel_item, title);
katze_xbel_bookmark_set_href (xbel_item,
_midori_browser_get_tab_uri (browser, widget));
katze_xbel_folder_append_item (browser->proxy_xbel_folder,
xbel_item);
}
} }
browser->tab_titles = g_list_prepend (browser->tab_titles, tab_title);
g_signal_connect (widget, "leave-notify-event",
G_CALLBACK (midori_browser_tab_leave_notify_event_cb), browser);
event_box = gtk_event_box_new ();
gtk_event_box_set_visible_window (GTK_EVENT_BOX (event_box), FALSE);
hbox = gtk_hbox_new (FALSE, 1);
gtk_container_add (GTK_CONTAINER (event_box), GTK_WIDGET (hbox));
gtk_box_pack_start (GTK_BOX (hbox), tab_icon, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (tab_title), 0.0, 0.5);
/* TODO: make the tab initially look "unvisited" until it's focused */
gtk_box_pack_start (GTK_BOX (hbox), tab_title, FALSE, TRUE, 0);
_update_label_size (tab_title,
sokoke_object_get_int (browser->settings, "tab-label-size"));
close_button = gtk_button_new ();
gtk_button_set_relief (GTK_BUTTON (close_button), GTK_RELIEF_NONE);
gtk_button_set_focus_on_click (GTK_BUTTON (close_button), FALSE);
rcstyle = gtk_rc_style_new ();
rcstyle->xthickness = rcstyle->ythickness = 0;
gtk_widget_modify_style(close_button, rcstyle);
image = gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU);
gtk_button_set_image (GTK_BUTTON (close_button), image);
gtk_box_pack_end (GTK_BOX (hbox), close_button, FALSE, FALSE, 0);
gtk_widget_show_all (GTK_WIDGET (event_box));
if (!sokoke_object_get_boolean (browser->settings, "close-buttons-on-tabs"))
gtk_widget_hide (close_button);
browser->close_buttons = g_list_prepend (browser->close_buttons, close_button);
g_signal_connect (event_box, "button-release-event",
G_CALLBACK (midori_browser_tab_label_button_release_event), widget);
g_signal_connect (close_button, "style-set",
G_CALLBACK (midori_browser_tab_close_style_set), NULL);
g_signal_connect (close_button, "clicked",
G_CALLBACK (midori_browser_tab_close_clicked), widget);
n = gtk_notebook_get_current_page (GTK_NOTEBOOK (browser->notebook)); n = gtk_notebook_get_current_page (GTK_NOTEBOOK (browser->notebook));
gtk_notebook_insert_page (GTK_NOTEBOOK (browser->notebook), scrolled, gtk_notebook_insert_page (GTK_NOTEBOOK (browser->notebook), scrolled,
label, n + 1); event_box, n + 1);
#if GTK_CHECK_VERSION(2, 10, 0) #if GTK_CHECK_VERSION(2, 10, 0)
gtk_notebook_set_tab_reorderable (GTK_NOTEBOOK (browser->notebook), gtk_notebook_set_tab_reorderable (GTK_NOTEBOOK (browser->notebook),
scrolled, TRUE); scrolled, TRUE);
gtk_notebook_set_tab_detachable (GTK_NOTEBOOK (browser->notebook), gtk_notebook_set_tab_detachable (GTK_NOTEBOOK (browser->notebook),
scrolled, TRUE); scrolled, TRUE);
#endif #endif
gtk_widget_show (menuitem);
g_signal_connect (menuitem, "activate",
G_CALLBACK (midori_browser_window_menu_item_activate_cb), scrolled);
gtk_menu_shell_append (GTK_MENU_SHELL (browser->menu_window), menuitem);
/* We want the tab to be removed if the widget is destroyed */
g_signal_connect_swapped (widget, "destroy",
G_CALLBACK (gtk_widget_destroy), menuitem);
g_signal_connect (widget, "destroy",
G_CALLBACK (midori_browser_tab_destroy_cb), browser);
_midori_browser_update_actions (browser); _midori_browser_update_actions (browser);
n = gtk_notebook_page_num (GTK_NOTEBOOK (browser->notebook), scrolled); n = gtk_notebook_page_num (GTK_NOTEBOOK (browser->notebook), scrolled);
@ -1138,7 +1323,9 @@ _action_open_activate (GtkAction* action,
static gchar* last_dir = NULL; static gchar* last_dir = NULL;
gchar* uri = NULL; gchar* uri = NULL;
gboolean folder_set = FALSE; gboolean folder_set = FALSE;
GtkWidget* dialog = gtk_file_chooser_dialog_new ( GtkWidget* dialog;
dialog = gtk_file_chooser_dialog_new (
("Open file"), GTK_WINDOW (browser), ("Open file"), GTK_WINDOW (browser),
GTK_FILE_CHOOSER_ACTION_OPEN, GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
@ -1148,10 +1335,8 @@ _action_open_activate (GtkAction* action,
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (browser)); gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (browser));
/* base the start folder on the current web view's uri if it is local */ /* base the start folder on the current web view's uri if it is local */
GtkWidget* web_view = midori_browser_get_current_web_view (browser); GtkWidget* widget = midori_browser_get_current_tab (browser);
if (web_view) if ((uri = (gchar*)_midori_browser_get_tab_uri (browser, widget)))
g_object_get (web_view, "uri", &uri, NULL);
if (uri)
{ {
gchar* filename = g_filename_from_uri (uri, NULL, NULL); gchar* filename = g_filename_from_uri (uri, NULL, NULL);
if (filename) if (filename)
@ -1166,7 +1351,6 @@ _action_open_activate (GtkAction* action,
g_free (dirname); g_free (dirname);
g_free (filename); g_free (filename);
} }
g_free (uri);
} }
if (!folder_set && last_dir && *last_dir) if (!folder_set && last_dir && *last_dir)
@ -1176,7 +1360,7 @@ _action_open_activate (GtkAction* action,
{ {
uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (dialog)); uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (dialog));
gchar* folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog)); gchar* folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
g_object_set (web_view, "uri", uri, NULL); _midori_browser_open_uri (browser, uri);
g_free (last_dir); g_free (last_dir);
last_dir = folder; last_dir = folder;
@ -1190,8 +1374,7 @@ _action_tab_close_activate (GtkAction* action,
MidoriBrowser* browser) MidoriBrowser* browser)
{ {
GtkWidget* widget = midori_browser_get_current_tab (browser); GtkWidget* widget = midori_browser_get_current_tab (browser);
GtkWidget* scrolled = _midori_browser_scrolled_for_child (browser, widget); gtk_widget_destroy (widget);
gtk_widget_destroy (scrolled);
} }
static void static void
@ -1223,7 +1406,7 @@ _action_edit_activate (GtkAction* action,
{ {
GtkWidget* widget = gtk_window_get_focus (GTK_WINDOW (browser)); GtkWidget* widget = gtk_window_get_focus (GTK_WINDOW (browser));
gboolean can_cut = FALSE, can_copy = FALSE, can_paste = FALSE; gboolean can_cut = FALSE, can_copy = FALSE, can_paste = FALSE;
gboolean has_selection; gboolean has_selection, can_select_all = FALSE;
if (WEBKIT_IS_WEB_VIEW (widget)) if (WEBKIT_IS_WEB_VIEW (widget))
{ {
@ -1231,6 +1414,7 @@ _action_edit_activate (GtkAction* action,
can_cut = webkit_web_view_can_cut_clipboard (web_view); can_cut = webkit_web_view_can_cut_clipboard (web_view);
can_copy = webkit_web_view_can_copy_clipboard (web_view); can_copy = webkit_web_view_can_copy_clipboard (web_view);
can_paste = webkit_web_view_can_paste_clipboard (web_view); can_paste = webkit_web_view_can_paste_clipboard (web_view);
can_select_all = TRUE;
} }
else if (GTK_IS_EDITABLE (widget)) else if (GTK_IS_EDITABLE (widget))
{ {
@ -1239,13 +1423,24 @@ _action_edit_activate (GtkAction* action,
can_cut = has_selection && gtk_editable_get_editable (editable); can_cut = has_selection && gtk_editable_get_editable (editable);
can_copy = has_selection; can_copy = has_selection;
can_paste = gtk_editable_get_editable (editable); can_paste = gtk_editable_get_editable (editable);
can_select_all = TRUE;
}
else if (GTK_IS_TEXT_VIEW (widget))
{
GtkTextView* text_view = GTK_TEXT_VIEW (widget);
GtkTextBuffer* buffer = gtk_text_view_get_buffer (text_view);
has_selection = gtk_text_buffer_get_has_selection (buffer);
can_cut = gtk_text_view_get_editable (text_view);
can_copy = has_selection;
can_paste = gtk_text_view_get_editable (text_view) && has_selection;
can_select_all = TRUE;
} }
_action_set_sensitive (browser, "Cut", can_cut); _action_set_sensitive (browser, "Cut", can_cut);
_action_set_sensitive (browser, "Copy", can_copy); _action_set_sensitive (browser, "Copy", can_copy);
_action_set_sensitive (browser, "Paste", can_paste); _action_set_sensitive (browser, "Paste", can_paste);
_action_set_sensitive (browser, "Delete", can_cut); _action_set_sensitive (browser, "Delete", can_cut);
_action_set_sensitive (browser, "SelectAll", FALSE); _action_set_sensitive (browser, "SelectAll", can_select_all);
} }
static void static void
@ -1284,8 +1479,11 @@ _action_delete_activate (GtkAction* action,
{ {
if (WEBKIT_IS_WEB_VIEW (widget)) if (WEBKIT_IS_WEB_VIEW (widget))
webkit_web_view_delete_selection (WEBKIT_WEB_VIEW (widget)); webkit_web_view_delete_selection (WEBKIT_WEB_VIEW (widget));
else if (GTK_IS_EDITABLE(widget)) else if (GTK_IS_EDITABLE (widget))
gtk_editable_delete_selection (GTK_EDITABLE (widget)); gtk_editable_delete_selection (GTK_EDITABLE (widget));
else if (GTK_IS_TEXT_VIEW (widget))
gtk_text_buffer_delete_selection (
gtk_text_view_get_buffer (GTK_TEXT_VIEW (widget)), TRUE, FALSE);
} }
} }
@ -1299,18 +1497,60 @@ _action_select_all_activate (GtkAction* action,
if (GTK_IS_EDITABLE (widget)) if (GTK_IS_EDITABLE (widget))
gtk_editable_select_region (GTK_EDITABLE (widget), 0, -1); gtk_editable_select_region (GTK_EDITABLE (widget), 0, -1);
else else
g_signal_emit_by_name (widget, "select-all"); g_signal_emit_by_name (widget, "select-all", TRUE);
} }
} }
static void
_midori_browser_tab_unmark_text_matches (MidoriBrowser* browser,
GtkWidget* widget)
{
if (WEBKIT_IS_WEB_VIEW (widget))
webkit_web_view_unmark_text_matches (WEBKIT_WEB_VIEW (widget));
}
static gboolean
_midori_browser_tab_search_text (MidoriBrowser* browser,
GtkWidget* widget,
const gchar* text,
gboolean case_sensitive,
gboolean forward)
{
if (WEBKIT_IS_WEB_VIEW (widget))
return webkit_web_view_search_text (WEBKIT_WEB_VIEW (widget),
text, case_sensitive, forward, TRUE);
return FALSE;
}
static void
_midori_browser_tab_mark_text_matches (MidoriBrowser* browser,
GtkWidget* widget,
const gchar* text,
gboolean case_sensitive)
{
if (WEBKIT_IS_WEB_VIEW (widget))
webkit_web_view_mark_text_matches (WEBKIT_WEB_VIEW (widget),
text, case_sensitive, 0);
}
static void
_midori_browser_tab_set_highlight_text_matches (MidoriBrowser* browser,
GtkWidget* widget,
gboolean highlight)
{
if (WEBKIT_IS_WEB_VIEW (widget))
webkit_web_view_set_highlight_text_matches (
WEBKIT_WEB_VIEW (widget), highlight);
}
static void static void
_action_find_activate(GtkAction* action, _action_find_activate(GtkAction* action,
MidoriBrowser* browser) MidoriBrowser* browser)
{ {
if (GTK_WIDGET_VISIBLE (browser->find)) if (GTK_WIDGET_VISIBLE (browser->find))
{ {
GtkWidget* web_view = midori_browser_get_current_web_view (browser); GtkWidget* widget = midori_browser_get_current_tab (browser);
webkit_web_view_unmark_text_matches (WEBKIT_WEB_VIEW (web_view)); _midori_browser_tab_unmark_text_matches (browser, widget);
gtk_toggle_tool_button_set_active ( gtk_toggle_tool_button_set_active (
GTK_TOGGLE_TOOL_BUTTON (browser->find_highlight), FALSE); GTK_TOGGLE_TOOL_BUTTON (browser->find_highlight), FALSE);
gtk_widget_hide (browser->find); gtk_widget_hide (browser->find);
@ -1334,11 +1574,11 @@ _midori_browser_find (MidoriBrowser* browser,
const gchar* text = gtk_entry_get_text (GTK_ENTRY (browser->find_text)); const gchar* text = gtk_entry_get_text (GTK_ENTRY (browser->find_text));
const gboolean case_sensitive = gtk_toggle_tool_button_get_active ( const gboolean case_sensitive = gtk_toggle_tool_button_get_active (
GTK_TOGGLE_TOOL_BUTTON(browser->find_case)); GTK_TOGGLE_TOOL_BUTTON(browser->find_case));
GtkWidget* web_view = midori_browser_get_current_web_view (browser); GtkWidget* widget = midori_browser_get_current_tab (browser);
if (GTK_WIDGET_VISIBLE (browser->find)) if (GTK_WIDGET_VISIBLE (browser->find))
webkit_web_view_unmark_text_matches (WEBKIT_WEB_VIEW (web_view)); _midori_browser_tab_unmark_text_matches (browser, widget);
gboolean found = webkit_web_view_search_text (WEBKIT_WEB_VIEW (web_view), gboolean found = _midori_browser_tab_search_text (browser, widget,
text, case_sensitive, forward, TRUE); text, case_sensitive, forward);
if (GTK_WIDGET_VISIBLE (browser->find)) if (GTK_WIDGET_VISIBLE (browser->find))
{ {
GtkWidget* icon; GtkWidget* icon;
@ -1348,12 +1588,12 @@ _midori_browser_find (MidoriBrowser* browser,
icon = gtk_image_new_from_stock (GTK_STOCK_STOP, GTK_ICON_SIZE_MENU); icon = gtk_image_new_from_stock (GTK_STOCK_STOP, GTK_ICON_SIZE_MENU);
sexy_icon_entry_set_icon (SEXY_ICON_ENTRY (browser->find_text), sexy_icon_entry_set_icon (SEXY_ICON_ENTRY (browser->find_text),
SEXY_ICON_ENTRY_PRIMARY, GTK_IMAGE (icon)); SEXY_ICON_ENTRY_PRIMARY, GTK_IMAGE (icon));
webkit_web_view_mark_text_matches (WEBKIT_WEB_VIEW (web_view), text, _midori_browser_tab_mark_text_matches (browser, widget,
case_sensitive, 0); text, case_sensitive);
const gboolean highlight = gtk_toggle_tool_button_get_active ( const gboolean highlight = gtk_toggle_tool_button_get_active (
GTK_TOGGLE_TOOL_BUTTON (browser->find_highlight)); GTK_TOGGLE_TOOL_BUTTON (browser->find_highlight));
webkit_web_view_set_highlight_text_matches (WEBKIT_WEB_VIEW (web_view), _midori_browser_tab_set_highlight_text_matches (browser, widget,
highlight); highlight);
} }
} }
@ -1375,10 +1615,10 @@ static void
_find_highlight_toggled (GtkToggleToolButton* toolitem, _find_highlight_toggled (GtkToggleToolButton* toolitem,
MidoriBrowser* browser) MidoriBrowser* browser)
{ {
GtkWidget* web_view = midori_browser_get_current_web_view (browser); GtkWidget* widget = midori_browser_get_current_tab (browser);
const gboolean highlight = gtk_toggle_tool_button_get_active (toolitem); const gboolean highlight = gtk_toggle_tool_button_get_active (toolitem);
webkit_web_view_set_highlight_text_matches (WEBKIT_WEB_VIEW (web_view), _midori_browser_tab_set_highlight_text_matches (browser, widget,
highlight); highlight);
} }
static void static void
@ -1550,15 +1790,53 @@ _action_zoom_normal_activate (GtkAction* action,
webkit_web_view_set_zoom_level (WEBKIT_WEB_VIEW (web_view), 1.0); webkit_web_view_set_zoom_level (WEBKIT_WEB_VIEW (web_view), 1.0);
} }
/*static void static void
_action_source_view_activate (GtkAction* action, _action_source_view_activate (GtkAction* action,
MidoriBrowser* browser) MidoriBrowser* browser)
{ {
GtkWidget* web_view = midori_browser_get_current_web_view (browser); GtkWidget* web_view;
gchar* source = webkit_web_view_copy_source (WEBKIT_WEB_VIEW (web_view)); const gchar* uri;
webkit_web_view_load_html_string (WEBKIT_WEB_VIEW (web_view), source, ""); GFile* file;
g_free (source); gchar* contents;
}*/ gchar* tag;
gchar* contents_utf8;
GtkTextBuffer* buffer;
GtkWidget* text_view;
gint n;
web_view = midori_browser_get_current_web_view (browser);
if (!(web_view && MIDORI_IS_WEB_VIEW (web_view)))
return;
uri = midori_web_view_get_display_uri (MIDORI_WEB_VIEW (web_view));
file = g_file_new_for_uri (uri);
contents = NULL;
g_file_load_contents (file, NULL, &contents, NULL, &tag, NULL);
g_object_unref (file);
if (contents && !g_utf8_validate (contents, -1, NULL))
{
contents_utf8 = g_convert (contents, -1, "UTF-8", "ISO-8859-1",
NULL, NULL, NULL);
g_free (contents);
}
else
contents_utf8 = contents;
buffer = gtk_text_buffer_new (NULL);
if (contents_utf8)
gtk_text_buffer_set_text (buffer, contents_utf8, -1);
text_view = gtk_text_view_new_with_buffer (buffer);
gtk_text_view_set_editable (GTK_TEXT_VIEW (text_view), FALSE);
g_object_set_data (G_OBJECT (text_view), "browser-tab-uri",
g_strconcat ("view-source:", uri, NULL));
gtk_widget_show (text_view);
n = midori_browser_add_tab (browser, text_view);
midori_browser_set_current_page (browser, n);
g_object_unref (buffer);
g_free (contents_utf8);
g_free (tag);
}
static void static void
_action_fullscreen_activate (GtkAction* action, _action_fullscreen_activate (GtkAction* action,
@ -1593,9 +1871,8 @@ _action_homepage_activate (GtkAction* action,
{ {
gchar* homepage; gchar* homepage;
GtkWidget* web_view = midori_browser_get_current_web_view (browser);
g_object_get (browser->settings, "homepage", &homepage, NULL); g_object_get (browser->settings, "homepage", &homepage, NULL);
g_object_set (web_view, "uri", homepage, NULL); _midori_browser_open_uri (browser, homepage);
g_free (homepage); g_free (homepage);
} }
@ -1627,18 +1904,16 @@ midori_browser_location_key_press_event_cb (GtkWidget* widget,
Completion should be generated from history, that is Completion should be generated from history, that is
the uri as well as the title. */ the uri as well as the title. */
sokoke_entry_append_completion (GTK_ENTRY (widget), uri); sokoke_entry_append_completion (GTK_ENTRY (widget), uri);
GtkWidget* web_view = midori_browser_get_current_web_view (browser); _midori_browser_open_uri (browser, new_uri);
g_object_set (web_view, "uri", new_uri, NULL);
g_free (new_uri); g_free (new_uri);
gtk_widget_grab_focus (web_view); gtk_widget_grab_focus (midori_browser_get_current_tab (browser));
} }
return TRUE; return TRUE;
} }
case GDK_Escape: case GDK_Escape:
{ {
GtkWidget* web_view = midori_browser_get_current_web_view (browser); const gchar* uri = _midori_browser_get_tab_uri (
const gchar* uri = midori_web_view_get_display_uri ( browser, midori_browser_get_current_tab (browser));
MIDORI_WEB_VIEW (web_view));
gtk_entry_set_text (GTK_ENTRY (widget), uri); gtk_entry_set_text (GTK_ENTRY (widget), uri);
return TRUE; return TRUE;
} }
@ -1712,9 +1987,8 @@ midori_panel_bookmarks_row_activated_cb (GtkTreeView* treeview,
gtk_tree_model_get (model, &iter, 0, &item, -1); gtk_tree_model_get (model, &iter, 0, &item, -1);
if (katze_xbel_item_is_bookmark (item)) if (katze_xbel_item_is_bookmark (item))
{ {
GtkWidget* web_view = midori_browser_get_current_web_view (browser);
const gchar* uri = katze_xbel_bookmark_get_href (item); const gchar* uri = katze_xbel_bookmark_get_href (item);
g_object_set (web_view, "uri", uri, NULL); _midori_browser_open_uri (browser, uri);
} }
} }
} }
@ -1930,9 +2204,8 @@ midori_browser_menu_bookmarks_item_activate_cb (GtkWidget* widget,
{ {
KatzeXbelItem* item = (KatzeXbelItem*)g_object_get_data (G_OBJECT (widget), KatzeXbelItem* item = (KatzeXbelItem*)g_object_get_data (G_OBJECT (widget),
"KatzeXbelItem"); "KatzeXbelItem");
GtkWidget* web_view = midori_browser_get_current_web_view (browser); _midori_browser_open_uri (browser, katze_xbel_bookmark_get_href (item));
g_object_set (web_view, "uri", katze_xbel_bookmark_get_href (item), NULL); gtk_widget_grab_focus (midori_browser_get_current_tab (browser));
gtk_widget_grab_focus (web_view);
} }
static void static void
@ -2084,8 +2357,8 @@ static void
_action_open_in_panel_activate (GtkAction* action, _action_open_in_panel_activate (GtkAction* action,
MidoriBrowser* browser) MidoriBrowser* browser)
{ {
GtkWidget* web_view = midori_browser_get_current_web_view (browser); GtkWidget* widget = midori_browser_get_current_tab (browser);
const gchar* uri = midori_web_view_get_display_uri (MIDORI_WEB_VIEW (web_view)); const gchar* uri = _midori_browser_get_tab_uri (browser, widget);
/* FIXME: Don't assign the uri here, update it properly while navigating */ /* FIXME: Don't assign the uri here, update it properly while navigating */
g_object_set (browser->settings, "last-pageholder-uri", uri, NULL); g_object_set (browser->settings, "last-pageholder-uri", uri, NULL);
gint n = midori_panel_page_num (MIDORI_PANEL (browser->panel), gint n = midori_panel_page_num (MIDORI_PANEL (browser->panel),
@ -2114,18 +2387,22 @@ midori_panel_close_cb (MidoriPanel* panel,
} }
static void static void
gtk_notebook_switch_page_cb (GtkWidget* widget, gtk_notebook_switch_page_cb (GtkWidget* notebook,
GtkNotebookPage* page, GtkNotebookPage* page,
guint page_num, guint page_num,
MidoriBrowser* browser) MidoriBrowser* browser)
{ {
GtkWidget* web_view = midori_browser_get_current_web_view (browser); GtkWidget* widget;
const gchar* uri = midori_web_view_get_display_uri (MIDORI_WEB_VIEW (web_view)); const gchar* uri;
const gchar* title;
gchar* window_title;
widget = midori_browser_get_current_tab (browser);
uri = _midori_browser_get_tab_uri (browser, widget);
gtk_entry_set_text (GTK_ENTRY (browser->location), uri); gtk_entry_set_text (GTK_ENTRY (browser->location), uri);
const gchar* title = midori_web_view_get_display_title ( title = _midori_browser_get_tab_title (browser, widget);
MIDORI_WEB_VIEW (web_view)); window_title = g_strconcat (title, " - ",
gchar* window_title = g_strconcat (title, " - ", g_get_application_name (), NULL);
g_get_application_name (), NULL);
gtk_window_set_title (GTK_WINDOW (browser), window_title); gtk_window_set_title (GTK_WINDOW (browser), window_title);
g_free (window_title); g_free (window_title);
_midori_browser_set_statusbar_text (browser, NULL); _midori_browser_set_statusbar_text (browser, NULL);
@ -2356,8 +2633,8 @@ static const GtkActionEntry entries[] = {
NULL, "<Ctrl>0", NULL, "<Ctrl>0",
N_("Reset the zoom level"), G_CALLBACK (_action_zoom_normal_activate) }, N_("Reset the zoom level"), G_CALLBACK (_action_zoom_normal_activate) },
{ "SourceView", NULL, { "SourceView", NULL,
N_("View Source"), "", N_("View _Source"), "",
N_("View the source code of the page"), /*G_CALLBACK (_action_source_view_activate)*/ }, N_("View the source code of the page"), G_CALLBACK (_action_source_view_activate) },
{ "SelectionSourceView", NULL, { "SelectionSourceView", NULL,
N_("View Selection Source"), "", N_("View Selection Source"), "",
N_("View the source code of the selection"), NULL/*G_CALLBACK (_action_selection_source_view_activate)*/ }, N_("View the source code of the selection"), NULL/*G_CALLBACK (_action_selection_source_view_activate)*/ },
@ -2692,8 +2969,7 @@ midori_browser_search_activate_cb (GtkWidget* widget,
else else
search = g_strconcat (url, " ", keywords, NULL); search = g_strconcat (url, " ", keywords, NULL);
sokoke_entry_append_completion (GTK_ENTRY (widget), keywords); sokoke_entry_append_completion (GTK_ENTRY (widget), keywords);
GtkWidget* web_view = midori_browser_get_current_web_view (browser); _midori_browser_open_uri (browser, search);
webkit_web_view_open (WEBKIT_WEB_VIEW (web_view), search);
g_free (search); g_free (search);
g_free (location_entry_search); g_free (location_entry_search);
} }
@ -3067,20 +3343,24 @@ midori_browser_init (MidoriBrowser* browser)
GtkWidget* icon = gtk_image_new_from_stock (GTK_STOCK_FIND, GtkWidget* icon = gtk_image_new_from_stock (GTK_STOCK_FIND,
GTK_ICON_SIZE_MENU); GTK_ICON_SIZE_MENU);
sexy_icon_entry_set_icon (SEXY_ICON_ENTRY(browser->find_text), sexy_icon_entry_set_icon (SEXY_ICON_ENTRY(browser->find_text),
SEXY_ICON_ENTRY_PRIMARY, GTK_IMAGE(icon)); SEXY_ICON_ENTRY_PRIMARY, GTK_IMAGE (icon));
sexy_icon_entry_add_clear_button (SEXY_ICON_ENTRY(browser->find_text)); sexy_icon_entry_add_clear_button (SEXY_ICON_ENTRY (browser->find_text));
g_signal_connect (browser->find_text, "activate", g_signal_connect (browser->find_text, "activate",
G_CALLBACK (_action_find_next_activate), browser); G_CALLBACK (_action_find_next_activate), browser);
toolitem = gtk_tool_item_new (); toolitem = gtk_tool_item_new ();
gtk_container_add (GTK_CONTAINER (toolitem), browser->find_text); gtk_container_add (GTK_CONTAINER (toolitem), browser->find_text);
gtk_tool_item_set_expand (GTK_TOOL_ITEM (toolitem), TRUE); gtk_tool_item_set_expand (GTK_TOOL_ITEM (toolitem), TRUE);
gtk_toolbar_insert (GTK_TOOLBAR(browser->find), toolitem, -1); gtk_toolbar_insert (GTK_TOOLBAR(browser->find), toolitem, -1);
toolitem = gtk_tool_button_new_from_stock (GTK_STOCK_GO_BACK); toolitem = (GtkToolItem*)gtk_action_create_tool_item
(_action_by_name (browser, "FindPrevious"));
gtk_tool_button_set_label (GTK_TOOL_BUTTON (toolitem), NULL);
gtk_tool_item_set_is_important (toolitem, TRUE); gtk_tool_item_set_is_important (toolitem, TRUE);
g_signal_connect (toolitem, "clicked", g_signal_connect (toolitem, "clicked",
G_CALLBACK (_action_find_previous_activate), browser); G_CALLBACK (_action_find_previous_activate), browser);
gtk_toolbar_insert (GTK_TOOLBAR (browser->find), toolitem, -1); gtk_toolbar_insert (GTK_TOOLBAR (browser->find), toolitem, -1);
toolitem = gtk_tool_button_new_from_stock (GTK_STOCK_GO_FORWARD); toolitem = (GtkToolItem*)gtk_action_create_tool_item
(_action_by_name (browser, "FindNext"));
gtk_tool_button_set_label (GTK_TOOL_BUTTON (toolitem), NULL);
gtk_tool_item_set_is_important (toolitem, TRUE); gtk_tool_item_set_is_important (toolitem, TRUE);
g_signal_connect (toolitem, "clicked", g_signal_connect (toolitem, "clicked",
G_CALLBACK (_action_find_next_activate), browser); G_CALLBACK (_action_find_next_activate), browser);
@ -3136,6 +3416,9 @@ midori_browser_init (MidoriBrowser* browser)
_action_set_sensitive (browser, "ZoomIn", FALSE); _action_set_sensitive (browser, "ZoomIn", FALSE);
_action_set_sensitive (browser, "ZoomOut", FALSE); _action_set_sensitive (browser, "ZoomOut", FALSE);
#endif #endif
browser->tab_titles = NULL;
browser->close_buttons = NULL;
} }
static void static void
@ -3143,9 +3426,9 @@ midori_browser_finalize (GObject* object)
{ {
MidoriBrowser* browser = MIDORI_BROWSER (object); MidoriBrowser* browser = MIDORI_BROWSER (object);
g_free (browser->uri);
g_free (browser->title);
g_free (browser->statusbar_text); g_free (browser->statusbar_text);
g_list_free (browser->tab_titles);
g_list_free (browser->close_buttons);
if (browser->proxy_xbel_folder) if (browser->proxy_xbel_folder)
katze_xbel_item_unref (browser->proxy_xbel_folder); katze_xbel_item_unref (browser->proxy_xbel_folder);
@ -3204,6 +3487,10 @@ _midori_browser_update_settings (MidoriBrowser* browser)
MidoriToolbarStyle toolbar_style; MidoriToolbarStyle toolbar_style;
gint last_web_search; gint last_web_search;
gchar* last_pageholder_uri; gchar* last_pageholder_uri;
gint tab_label_size;
gboolean close_buttons_on_tabs;
guint i, n;
g_object_get (browser->settings, g_object_get (browser->settings,
"remember-last-window-size", &remember_last_window_size, "remember-last-window-size", &remember_last_window_size,
@ -3223,6 +3510,8 @@ _midori_browser_update_settings (MidoriBrowser* browser)
"toolbar-style", &toolbar_style, "toolbar-style", &toolbar_style,
"last-web-search", &last_web_search, "last-web-search", &last_web_search,
"last-pageholder-uri", &last_pageholder_uri, "last-pageholder-uri", &last_pageholder_uri,
"tab-label-size", &tab_label_size,
"close-buttons-on-tabs", &close_buttons_on_tabs,
NULL); NULL);
GdkScreen* screen = gtk_window_get_screen (GTK_WINDOW (browser)); GdkScreen* screen = gtk_window_get_screen (GTK_WINDOW (browser));
@ -3268,6 +3557,16 @@ _midori_browser_update_settings (MidoriBrowser* browser)
sokoke_widget_set_visible (browser->search, show_web_search); sokoke_widget_set_visible (browser->search, show_web_search);
sokoke_widget_set_visible (browser->button_trash, show_trash); sokoke_widget_set_visible (browser->button_trash, show_trash);
/* We assume that tab_titles has the same length as close_buttons */
n = g_list_length (browser->tab_titles);
for (i = 0; i < n; i++)
{
_update_label_size (g_list_nth_data (browser->tab_titles, i),
tab_label_size);
sokoke_widget_set_visible (g_list_nth_data (browser->close_buttons, i),
close_buttons_on_tabs);
}
g_free (last_pageholder_uri); g_free (last_pageholder_uri);
} }
@ -3276,9 +3575,12 @@ midori_browser_settings_notify (MidoriWebSettings* web_settings,
GParamSpec* pspec, GParamSpec* pspec,
MidoriBrowser* browser) MidoriBrowser* browser)
{ {
const gchar* name = g_intern_string (pspec->name); const gchar* name;
GValue value = {0, }; GValue value = {0, };
guint i;
guint n;
name = g_intern_string (pspec->name);
g_value_init (&value, pspec->value_type); g_value_init (&value, pspec->value_type);
g_object_get_property (G_OBJECT (browser->settings), name, &value); g_object_get_property (G_OBJECT (browser->settings), name, &value);
@ -3300,6 +3602,20 @@ midori_browser_settings_notify (MidoriWebSettings* web_settings,
else if (name == g_intern_string ("show-trash")) else if (name == g_intern_string ("show-trash"))
sokoke_widget_set_visible (browser->button_trash, sokoke_widget_set_visible (browser->button_trash,
g_value_get_boolean (&value)); g_value_get_boolean (&value));
else if (name == g_intern_string ("tab-label-size"))
{
n = g_list_length (browser->tab_titles);
for (i = 0; i < n; i++)
_update_label_size (g_list_nth_data (browser->tab_titles, i),
g_value_get_int (&value));
}
else if (name == g_intern_string ("close-buttons-on-tabs"))
{
n = g_list_length (browser->close_buttons);
for (i = 0; i < n; i++)
sokoke_widget_set_visible (g_list_nth_data (browser->close_buttons, i),
g_value_get_boolean (&value));
}
else if (!g_object_class_find_property (G_OBJECT_GET_CLASS (web_settings), else if (!g_object_class_find_property (G_OBJECT_GET_CLASS (web_settings),
name)) name))
g_warning (_("Unexpected setting '%s'"), name); g_warning (_("Unexpected setting '%s'"), name);
@ -3542,9 +3858,7 @@ midori_browser_set_current_page (MidoriBrowser* browser,
gtk_notebook_set_current_page (GTK_NOTEBOOK (browser->notebook), n); gtk_notebook_set_current_page (GTK_NOTEBOOK (browser->notebook), n);
GtkWidget* scrolled = gtk_notebook_get_nth_page (GTK_NOTEBOOK (browser->notebook), n); GtkWidget* scrolled = gtk_notebook_get_nth_page (GTK_NOTEBOOK (browser->notebook), n);
GtkWidget* widget = _midori_browser_child_for_scrolled (browser, scrolled); GtkWidget* widget = _midori_browser_child_for_scrolled (browser, scrolled);
if (widget && MIDORI_IS_WEB_VIEW (widget) if (widget && !strcmp (_midori_browser_get_tab_uri (browser, widget), ""))
&& !strcmp (midori_web_view_get_display_uri (
MIDORI_WEB_VIEW (widget)), ""))
gtk_widget_grab_focus (browser->location); gtk_widget_grab_focus (browser->location);
else else
gtk_widget_grab_focus (widget); gtk_widget_grab_focus (widget);
@ -3584,9 +3898,7 @@ midori_browser_set_current_tab (MidoriBrowser* browser,
GtkWidget* scrolled = _midori_browser_scrolled_for_child (browser, widget); GtkWidget* scrolled = _midori_browser_scrolled_for_child (browser, widget);
gint n = gtk_notebook_page_num (GTK_NOTEBOOK (browser->notebook), scrolled); gint n = gtk_notebook_page_num (GTK_NOTEBOOK (browser->notebook), scrolled);
gtk_notebook_set_current_page (GTK_NOTEBOOK (browser->notebook), n); gtk_notebook_set_current_page (GTK_NOTEBOOK (browser->notebook), n);
if (widget && MIDORI_IS_WEB_VIEW (widget) if (widget && !strcmp (_midori_browser_get_tab_uri (browser, widget), ""))
&& !strcmp (midori_web_view_get_display_uri (
MIDORI_WEB_VIEW (widget)), ""))
gtk_widget_grab_focus (browser->location); gtk_widget_grab_focus (browser->location);
else else
gtk_widget_grab_focus (widget); gtk_widget_grab_focus (widget);

217
midori/midori-webview.c
View file

@ -29,9 +29,6 @@ struct _MidoriWebView
{ {
WebKitWebView parent_instance; WebKitWebView parent_instance;
GtkWidget* tab_icon;
GtkWidget* tab_label;
GtkWidget* tab_close;
gchar* uri; gchar* uri;
gchar* title; gchar* title;
gboolean is_loading; gboolean is_loading;
@ -39,14 +36,13 @@ struct _MidoriWebView
gchar* statusbar_text; gchar* statusbar_text;
gchar* link_uri; gchar* link_uri;
gint tab_label_size;
gboolean close_button;
gboolean middle_click_opens_selection; gboolean middle_click_opens_selection;
MidoriWebSettings* settings; MidoriWebSettings* settings;
GtkWidget* proxy_menu_item; GtkWidget* menu_item;
GtkWidget* proxy_tab_label; GtkWidget* tab_icon;
KatzeXbelItem* proxy_xbel_item; GtkWidget* tab_title;
KatzeXbelItem* xbel_item;
}; };
G_DEFINE_TYPE (MidoriWebView, midori_web_view, WEBKIT_TYPE_WEB_VIEW) G_DEFINE_TYPE (MidoriWebView, midori_web_view, WEBKIT_TYPE_WEB_VIEW)
@ -68,7 +64,6 @@ enum {
PROGRESS_DONE, PROGRESS_DONE,
LOAD_DONE, LOAD_DONE,
ELEMENT_MOTION, ELEMENT_MOTION,
CLOSE,
NEW_TAB, NEW_TAB,
NEW_WINDOW, NEW_WINDOW,
@ -150,16 +145,6 @@ midori_web_view_class_init (MidoriWebViewClass* class)
G_TYPE_NONE, 1, G_TYPE_NONE, 1,
G_TYPE_STRING); G_TYPE_STRING);
signals[CLOSE] = g_signal_new (
"close",
G_TYPE_FROM_CLASS (class),
(GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
G_STRUCT_OFFSET (MidoriWebViewClass, close),
0,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[NEW_TAB] = g_signal_new ( signals[NEW_TAB] = g_signal_new (
"new-tab", "new-tab",
G_TYPE_FROM_CLASS (class), G_TYPE_FROM_CLASS (class),
@ -235,10 +220,10 @@ _midori_web_view_set_uri (MidoriWebView* web_view,
const gchar* uri) const gchar* uri)
{ {
katze_assign (web_view->uri, g_strdup (uri)); katze_assign (web_view->uri, g_strdup (uri));
if (web_view->proxy_xbel_item) if (web_view->xbel_item)
{ {
const gchar* uri = midori_web_view_get_display_uri (web_view); const gchar* uri = midori_web_view_get_display_uri (web_view);
katze_xbel_bookmark_set_href (web_view->proxy_xbel_item, uri); katze_xbel_bookmark_set_href (web_view->xbel_item, uri);
} }
g_object_set (web_view, "title", NULL, NULL); g_object_set (web_view, "title", NULL, NULL);
} }
@ -504,36 +489,10 @@ webkit_web_view_populate_popup_cb (GtkWidget* web_view,
} }
} }
static void
_midori_web_view_update_tab_label_size (MidoriWebView* web_view)
{
if (web_view->tab_label)
{
if (web_view->tab_label_size > -1)
{
gint width, height;
sokoke_widget_get_text_size (web_view->tab_label, "M",
&width, &height);
gtk_widget_set_size_request (web_view->tab_label,
width * web_view->tab_label_size, -1);
gtk_label_set_ellipsize (GTK_LABEL (web_view->tab_label),
PANGO_ELLIPSIZE_END);
}
else
{
gtk_widget_set_size_request (web_view->tab_label, -1, -1);
gtk_label_set_ellipsize (GTK_LABEL (web_view->tab_label),
PANGO_ELLIPSIZE_NONE);
}
}
}
static void static void
_midori_web_view_update_settings (MidoriWebView* web_view) _midori_web_view_update_settings (MidoriWebView* web_view)
{ {
g_object_get (G_OBJECT (web_view->settings), g_object_get (G_OBJECT (web_view->settings),
"tab-label-size", &web_view->tab_label_size,
"close-buttons-on-tabs", &web_view->close_button,
"middle-click-opens-selection", &web_view->middle_click_opens_selection, "middle-click-opens-selection", &web_view->middle_click_opens_selection,
NULL); NULL);
} }
@ -548,18 +507,7 @@ midori_web_view_settings_notify (MidoriWebSettings* web_settings,
g_value_init (&value, pspec->value_type); g_value_init (&value, pspec->value_type);
g_object_get_property (G_OBJECT (web_view->settings), name, &value); g_object_get_property (G_OBJECT (web_view->settings), name, &value);
if (name == g_intern_string ("tab-label-size")) if (name == g_intern_string ("middle-click-opens-selection"))
{
web_view->tab_label_size = g_value_get_int (&value);
_midori_web_view_update_tab_label_size (web_view);
}
else if (name == g_intern_string ("close-buttons-on-tabs"))
{
web_view->close_button = g_value_get_boolean (&value);
if (web_view->tab_close)
sokoke_widget_set_visible (web_view->tab_close, web_view->close_button);
}
else if (name == g_intern_string ("middle-click-opens-selection"))
web_view->middle_click_opens_selection = g_value_get_boolean (&value); web_view->middle_click_opens_selection = g_value_get_boolean (&value);
else if (!g_object_class_find_property (G_OBJECT_GET_CLASS (web_settings), else if (!g_object_class_find_property (G_OBJECT_GET_CLASS (web_settings),
name)) name))
@ -626,10 +574,8 @@ midori_web_view_finalize (GObject* object)
g_free (web_view->statusbar_text); g_free (web_view->statusbar_text);
g_free (web_view->link_uri); g_free (web_view->link_uri);
if (web_view->proxy_menu_item) if (web_view->xbel_item)
gtk_widget_destroy (web_view->proxy_menu_item); katze_xbel_item_unref (web_view->xbel_item);
if (web_view->proxy_xbel_item)
katze_xbel_item_unref (web_view->proxy_xbel_item);
if (web_view->settings) if (web_view->settings)
{ {
@ -665,16 +611,16 @@ midori_web_view_set_property (GObject* object,
case PROP_TITLE: case PROP_TITLE:
katze_assign (web_view->title, g_value_dup_string (value)); katze_assign (web_view->title, g_value_dup_string (value));
const gchar* title = midori_web_view_get_display_title (web_view); const gchar* title = midori_web_view_get_display_title (web_view);
if (web_view->tab_label) if (web_view->tab_title)
{ {
gtk_label_set_text (GTK_LABEL (web_view->tab_label), title); gtk_label_set_text (GTK_LABEL (web_view->tab_title), title);
gtk_widget_set_tooltip_text (web_view->tab_label, title); gtk_widget_set_tooltip_text (web_view->tab_title, title);
} }
if (web_view->proxy_menu_item) if (web_view->menu_item)
gtk_label_set_text (GTK_LABEL (gtk_bin_get_child (GTK_BIN ( gtk_label_set_text (GTK_LABEL (gtk_bin_get_child (GTK_BIN (
web_view->proxy_menu_item))), title); web_view->menu_item))), title);
if (web_view->proxy_xbel_item) if (web_view->xbel_item)
katze_xbel_item_set_title (web_view->proxy_xbel_item, title); katze_xbel_item_set_title (web_view->xbel_item, title);
break; break;
case PROP_SETTINGS: case PROP_SETTINGS:
g_signal_handlers_disconnect_by_func (web_view->settings, g_signal_handlers_disconnect_by_func (web_view->settings,
@ -774,7 +720,7 @@ midori_web_view_get_proxy_menu_item (MidoriWebView* web_view)
g_return_val_if_fail (MIDORI_IS_WEB_VIEW (web_view), FALSE); g_return_val_if_fail (MIDORI_IS_WEB_VIEW (web_view), FALSE);
if (!web_view->proxy_menu_item) if (!web_view->menu_item)
{ {
title = midori_web_view_get_display_title (web_view); title = midori_web_view_get_display_title (web_view);
menu_item = gtk_image_menu_item_new_with_label (title); menu_item = gtk_image_menu_item_new_with_label (title);
@ -783,9 +729,9 @@ midori_web_view_get_proxy_menu_item (MidoriWebView* web_view)
gtk_image_new_from_pixbuf (icon)); gtk_image_new_from_pixbuf (icon));
g_object_unref (icon); g_object_unref (icon);
web_view->proxy_menu_item = menu_item; web_view->menu_item = menu_item;
} }
return web_view->proxy_menu_item; return web_view->menu_item;
} }
/** /**
@ -816,115 +762,43 @@ midori_web_view_get_proxy_tab_icon (MidoriWebView* web_view)
katze_throbber_set_static_pixbuf (KATZE_THROBBER (web_view->tab_icon), katze_throbber_set_static_pixbuf (KATZE_THROBBER (web_view->tab_icon),
icon); icon);
g_object_unref (icon); g_object_unref (icon);
g_signal_connect (web_view->tab_icon, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&web_view->tab_icon);
} }
return web_view->tab_icon; return web_view->tab_icon;
} }
static gboolean
midori_web_view_tab_label_button_release_event (GtkWidget* tab_label,
GdkEventButton* event,
MidoriWebView* web_view)
{
if (event->button == 2)
{
/* Close the web view on middle click */
g_signal_emit (web_view, signals[CLOSE], 0);
return TRUE;
}
return FALSE;
}
static void
midori_web_view_tab_close_style_set (GtkWidget* tab_close,
GtkStyle* previous_style,
MidoriWebView* web_view)
{
GtkSettings* gtk_settings = gtk_widget_get_settings (tab_close);
gint width, height;
gtk_icon_size_lookup_for_settings (gtk_settings, GTK_ICON_SIZE_BUTTON,
&width, &height);
gtk_widget_set_size_request (tab_close, width + 2, height + 2);
}
static void
midori_web_view_tab_close_clicked (GtkWidget* tab_close,
MidoriWebView* web_view)
{
g_signal_emit (web_view, signals[CLOSE], 0);
}
/** /**
* midori_web_view_get_proxy_tab_label: * midori_web_view_get_proxy_tab_title:
* @web_view: a #MidoriWebView * @web_view: a #MidoriWebView
* *
* Retrieves a proxy tab label that is typically used as the label * Retrieves a proxy tab title that is typically used as the label
* of a #GtkNotebook page. * of a #GtkNotebook page.
* *
* The label is created on the first call and will be updated to * The title is created on the first call and will be updated to
* reflect changes to the icon and title automatically. * reflect changes automatically.
* *
* The icon embedded in the label will reflect the loading status * Return value: the proxy #GtkLabel
* of the web view.
*
* Note: This fails if a proxy tab icon has been created already.
*
* Return value: the proxy #GtkEventBox
**/ **/
GtkWidget* GtkWidget*
midori_web_view_get_proxy_tab_label (MidoriWebView* web_view) midori_web_view_get_proxy_tab_title (MidoriWebView* web_view)
{ {
const gchar* title;
g_return_val_if_fail (MIDORI_IS_WEB_VIEW (web_view), NULL); g_return_val_if_fail (MIDORI_IS_WEB_VIEW (web_view), NULL);
GtkWidget* proxy_tab_icon = web_view->tab_icon; if (!web_view->tab_title)
g_return_val_if_fail (!proxy_tab_icon, NULL);
if (!web_view->proxy_tab_label)
{ {
web_view->tab_icon = midori_web_view_get_proxy_tab_icon (web_view); title = midori_web_view_get_display_title (web_view);
web_view->tab_title = gtk_label_new (title);
GtkWidget* event_box = gtk_event_box_new (); g_signal_connect (web_view->tab_title, "destroy",
gtk_event_box_set_visible_window (GTK_EVENT_BOX (event_box), FALSE);
GtkWidget* hbox = gtk_hbox_new (FALSE, 1);
gtk_container_add (GTK_CONTAINER (event_box), GTK_WIDGET (hbox));
gtk_box_pack_start (GTK_BOX (hbox), web_view->tab_icon, FALSE, FALSE, 0);
const gchar* title = midori_web_view_get_display_title (web_view);
web_view->tab_label = gtk_label_new (title);
gtk_misc_set_alignment (GTK_MISC (web_view->tab_label), 0.0, 0.5);
/* TODO: make the tab initially look "unvisited" until it's focused */
gtk_box_pack_start (GTK_BOX (hbox), web_view->tab_label, FALSE, TRUE, 0);
web_view->proxy_tab_label = event_box;
_midori_web_view_update_tab_label_size (web_view);
GtkWidget* close_button = gtk_button_new ();
gtk_button_set_relief (GTK_BUTTON (close_button), GTK_RELIEF_NONE);
gtk_button_set_focus_on_click (GTK_BUTTON (close_button), FALSE);
GtkRcStyle* rcstyle = gtk_rc_style_new ();
rcstyle->xthickness = rcstyle->ythickness = 0;
gtk_widget_modify_style(close_button, rcstyle);
GtkWidget* image = gtk_image_new_from_stock (GTK_STOCK_CLOSE,
GTK_ICON_SIZE_MENU);
gtk_button_set_image (GTK_BUTTON(close_button), image);
gtk_box_pack_end (GTK_BOX (hbox), close_button, FALSE, FALSE, 0);
gtk_widget_show_all (GTK_WIDGET (event_box));
if (!web_view->close_button)
gtk_widget_hide (close_button);
web_view->tab_close = close_button;
g_signal_connect (web_view->proxy_tab_label, "button-release-event",
G_CALLBACK (midori_web_view_tab_label_button_release_event),
web_view);
g_signal_connect (web_view->tab_icon, "destroy",
G_CALLBACK (gtk_widget_destroyed), G_CALLBACK (gtk_widget_destroyed),
&web_view->tab_icon); &web_view->tab_title);
g_signal_connect (web_view->tab_close, "style-set",
G_CALLBACK (midori_web_view_tab_close_style_set),
web_view);
g_signal_connect (web_view->tab_close, "clicked",
G_CALLBACK (midori_web_view_tab_close_clicked),
web_view);
} }
return web_view->proxy_tab_label; return web_view->tab_title;
} }
/** /**
@ -945,17 +819,20 @@ midori_web_view_get_proxy_tab_label (MidoriWebView* web_view)
KatzeXbelItem* KatzeXbelItem*
midori_web_view_get_proxy_xbel_item (MidoriWebView* web_view) midori_web_view_get_proxy_xbel_item (MidoriWebView* web_view)
{ {
const gchar* uri;
const gchar* title;
g_return_val_if_fail (MIDORI_IS_WEB_VIEW (web_view), NULL); g_return_val_if_fail (MIDORI_IS_WEB_VIEW (web_view), NULL);
if (!web_view->proxy_xbel_item) if (!web_view->xbel_item)
{ {
web_view->proxy_xbel_item = katze_xbel_bookmark_new (); web_view->xbel_item = katze_xbel_bookmark_new ();
const gchar* uri = midori_web_view_get_display_uri (web_view); uri = midori_web_view_get_display_uri (web_view);
katze_xbel_bookmark_set_href (web_view->proxy_xbel_item, uri); katze_xbel_bookmark_set_href (web_view->xbel_item, uri);
const gchar* title = midori_web_view_get_display_title (web_view); title = midori_web_view_get_display_title (web_view);
katze_xbel_item_set_title (web_view->proxy_xbel_item, title); katze_xbel_item_set_title (web_view->xbel_item, title);
} }
return web_view->proxy_xbel_item; return web_view->xbel_item;
} }
/** /**

5
midori/midori-webview.h
View file

@ -79,7 +79,10 @@ GtkWidget*
midori_web_view_get_proxy_menu_item (MidoriWebView* web_view); midori_web_view_get_proxy_menu_item (MidoriWebView* web_view);
GtkWidget* GtkWidget*
midori_web_view_get_proxy_tab_label (MidoriWebView* web_view); midori_web_view_get_proxy_tab_icon (MidoriWebView* web_view);
GtkWidget*
midori_web_view_get_proxy_tab_title (MidoriWebView* web_view);
KatzeXbelItem* KatzeXbelItem*
midori_web_view_get_proxy_xbel_item (MidoriWebView* web_view); midori_web_view_get_proxy_xbel_item (MidoriWebView* web_view);

32
midori/sokoke.c
View file

@ -503,10 +503,12 @@ sokoke_web_icon (const gchar* icon,
else else
{ {
gint width, height; gint width, height;
gtk_icon_size_lookup (size, &width, &height);
if (gtk_widget_has_screen (widget)) if (gtk_widget_has_screen (widget))
{ {
GdkScreen* screen = gtk_widget_get_screen (widget); GdkScreen* screen = gtk_widget_get_screen (widget);
gtk_icon_size_lookup_for_settings (
gtk_settings_get_for_screen (screen),
size, &width, &height);
pixbuf = gtk_icon_theme_load_icon ( pixbuf = gtk_icon_theme_load_icon (
gtk_icon_theme_get_for_screen (screen), icon, gtk_icon_theme_get_for_screen (screen), icon,
MAX (width, height), GTK_ICON_LOOKUP_USE_BUILTIN, NULL); MAX (width, height), GTK_ICON_LOOKUP_USE_BUILTIN, NULL);
@ -519,3 +521,31 @@ sokoke_web_icon (const gchar* icon,
pixbuf = gtk_widget_render_icon (widget, GTK_STOCK_FIND, size, NULL); pixbuf = gtk_widget_render_icon (widget, GTK_STOCK_FIND, size, NULL);
return pixbuf; return pixbuf;
} }
gint
sokoke_object_get_int (gpointer object,
const gchar* property)
{
gint value;
g_return_val_if_fail (object != NULL, FALSE);
g_return_val_if_fail (G_IS_OBJECT (object), FALSE);
/* FIXME: Check value type */
g_object_get (object, property, &value, NULL);
return value;
}
gboolean
sokoke_object_get_boolean (gpointer object,
const gchar* property)
{
gboolean value;
g_return_val_if_fail (object != NULL, FALSE);
g_return_val_if_fail (G_IS_OBJECT (object), FALSE);
/* FIXME: Check value type */
g_object_get (object, property, &value, NULL);
return value;
}

112
midori/sokoke.h
View file

@ -20,15 +20,15 @@
#define GTK_ICON_SIZE_SMALL_TOOLBAR GTK_ICON_SIZE_BUTTON #define GTK_ICON_SIZE_SMALL_TOOLBAR GTK_ICON_SIZE_BUTTON
gchar* gchar*
sokoke_magic_uri (const gchar* uri, sokoke_magic_uri (const gchar* uri,
MidoriWebList* search_engines); MidoriWebList* search_engines);
void void
sokoke_entry_setup_completion (GtkEntry* entry); sokoke_entry_setup_completion (GtkEntry* entry);
void void
sokoke_entry_append_completion (GtkEntry* entry, sokoke_entry_append_completion (GtkEntry* entry,
const gchar* text); const gchar* text);
typedef enum { typedef enum {
SOKOKE_MENU_POSITION_CURSOR = 0, SOKOKE_MENU_POSITION_CURSOR = 0,
@ -37,81 +37,91 @@ typedef enum {
} SokokeMenuPos; } SokokeMenuPos;
void void
sokoke_combo_box_add_strings (GtkComboBox* combobox, sokoke_combo_box_add_strings (GtkComboBox* combobox,
const gchar* label_first, ...); const gchar* label_first,
...);
void void
sokoke_widget_set_visible (GtkWidget* widget, sokoke_widget_set_visible (GtkWidget* widget,
gboolean visible); gboolean visible);
void void
sokoke_container_show_children (GtkContainer* container); sokoke_container_show_children (GtkContainer* container);
void void
sokoke_widget_popup (GtkWidget* widget, sokoke_widget_popup (GtkWidget* widget,
GtkMenu* menu, GtkMenu* menu,
GdkEventButton* event, GdkEventButton* event,
SokokeMenuPos pos); SokokeMenuPos pos);
GtkWidget* GtkWidget*
sokoke_xfce_header_new (const gchar* icon, sokoke_xfce_header_new (const gchar* icon,
const gchar* title); const gchar* title);
GtkWidget* GtkWidget*
sokoke_superuser_warning_new (void); sokoke_superuser_warning_new (void);
GtkWidget* GtkWidget*
sokoke_hig_frame_new (const gchar* title); sokoke_hig_frame_new (const gchar* title);
void void
sokoke_widget_set_pango_font_style (GtkWidget* widget, sokoke_widget_set_pango_font_style (GtkWidget* widget,
PangoStyle style); PangoStyle style);
void void
sokoke_entry_set_default_text(GtkEntry*, const gchar*); sokoke_entry_set_default_text (GtkEntry* entry,
const gchar* default_text);
gchar* gchar*
sokoke_key_file_get_string_default (GKeyFile* key_file, sokoke_key_file_get_string_default (GKeyFile* key_file,
const gchar* group, const gchar* group,
const gchar* key, const gchar* key,
const gchar* default_value, const gchar* default_value,
GError** error); GError** error);
gint gint
sokoke_key_file_get_integer_default (GKeyFile* key_file, sokoke_key_file_get_integer_default (GKeyFile* key_file,
const gchar* group, const gchar* group,
const gchar* key, const gchar* key,
const gint default_value, const gint default_value,
GError** error); GError** error);
gdouble gdouble
sokoke_key_file_get_double_default (GKeyFile* key_file, sokoke_key_file_get_double_default (GKeyFile* key_file,
const gchar* group, const gchar* group,
const gchar* key, const gchar* key,
gdouble default_value, gdouble default_value,
GError** error); GError** error);
gboolean gboolean
sokoke_key_file_get_boolean_default (GKeyFile* key_file, sokoke_key_file_get_boolean_default (GKeyFile* key_file,
const gchar* group, const gchar* group,
const gchar* key, const gchar* key,
gboolean default_value, gboolean default_value,
GError** error); GError** error);
gboolean gboolean
sokoke_key_file_save_to_file (GKeyFile* key_file, sokoke_key_file_save_to_file (GKeyFile* key_file,
const gchar* filename, const gchar* filename,
GError** error); GError** error);
void void
sokoke_widget_get_text_size (GtkWidget* widget, sokoke_widget_get_text_size (GtkWidget* widget,
const gchar* text, const gchar* text,
gint* width, gint* width,
gint* height); gint* height);
GdkPixbuf* GdkPixbuf*
sokoke_web_icon (const gchar* icon, sokoke_web_icon (const gchar* icon,
GtkIconSize size, GtkIconSize size,
GtkWidget* widget); GtkWidget* widget);
gint
sokoke_object_get_int (gpointer object,
const gchar* property);
gboolean
sokoke_object_get_boolean (gpointer object,
const gchar* property);
#endif /* !__SOKOKE_H__ */ #endif /* !__SOKOKE_H__ */