diff options
Diffstat (limited to 'src')
57 files changed, 17688 insertions, 0 deletions
diff --git a/src/.cvsignore b/src/.cvsignore new file mode 100644 index 000000000..27d9d0cd0 --- /dev/null +++ b/src/.cvsignore @@ -0,0 +1,6 @@ +*.o +Makefile +Makefile.in +.deps +.libs +epiphany diff --git a/src/Makefile.am b/src/Makefile.am new file mode 100644 index 000000000..5ec49453d --- /dev/null +++ b/src/Makefile.am @@ -0,0 +1,101 @@ +SUBDIRS = bookmarks + +INCLUDES = \ + -I$(top_srcdir)/embed \ + -I$(top_srcdir)/lib \ + -I$(top_srcdir)/lib/widgets \ + -I$(top_srcdir)/lib/toolbar \ + -I$(top_srcdir)/src/bookmarks \ + $(WARN_CFLAGS) \ + $(EPIPHANY_DEPENDENCY_CFLAGS) \ + -DSHARE_DIR=\"$(pkgdatadir)\" \ + -DDATADIR=\""$(datadir)"\" \ + -DPIXMAP_DIR=\""$(datadir)/pixmaps"\" \ + -DGNOMELOCALEDIR=\""$(datadir)/locale"\" \ + -DG_DISABLE_DEPRECATED \ + -DGDK_DISABLE_DEPRECATED \ + -DGTK_DISABLE_DEPRECATED \ + -DGDK_PIXBUF_DISABLE_DEPRECATED \ + -DGNOME_DISABLE_DEPRECATED + +bin_PROGRAMS = epiphany + +CXXLD = $(CXX) +LINK = $(LIBTOOL) --mode=link $(CXXLD) $(AM_CFLAGS) $(CFLAGS) $(LDFLAGS) -o $@ + + +ephy_automation_interface_idl_sources = \ + EphyAutomation-common.c \ + EphyAutomation-stubs.c \ + EphyAutomation-skels.c \ + EphyAutomation.h + +if ENABLE_NAUTILUS_VIEW +nautilus_view_sources = \ + ephy-nautilus-view.c \ + ephy-nautilus-view.h +else +nautilus_view_sources = +endif + +epiphany_SOURCES = \ + $(ephy_automation_interface_idl_sources) \ + $(nautilus_view_sources) \ + ui-prefs.c \ + ui-prefs.h \ + prefs-dialog.c \ + prefs-dialog.h \ + toolbar.c \ + toolbar.h \ + statusbar.c \ + statusbar.h \ + ephy-main.c \ + ephy-automation.c \ + ephy-automation.h \ + ephy-shell.c \ + ephy-shell.h \ + ephy-tab.c \ + ephy-tab.h \ + ephy-window.c \ + ephy-window.h \ + window-commands.c \ + window-commands.h \ + popup-commands.c \ + popup-commands.h \ + history-dialog.c \ + history-dialog.h \ + ppview-toolbar.c \ + ppview-toolbar.h \ + session.c \ + session.h \ + general-prefs.c \ + general-prefs.h \ + language-editor.c \ + language-editor.h \ + appearance-prefs.c \ + appearance-prefs.h \ + pdm-dialog.c \ + pdm-dialog.h \ + ephy-favorites-menu.c \ + ephy-favorites-menu.h \ + ephy-history-model.c \ + ephy-history-model.h + +epiphany_LDADD = \ + $(top_builddir)/embed/libephyembed.la \ + $(top_builddir)/lib/libephy.la \ + $(top_builddir)/src/bookmarks/libephybookmarks.la \ + $(MOZILLA_COMPONENT_LIBS) \ + $(EPIPHANY_DEPENDENCY_LIBS) \ + $(INTLLIBS) + + +BUILT_SOURCES= \ + EphyAutomation.h EphyAutomation-common.c EphyAutomation-stubs.c EphyAutomation-skels.c + +CLEAN_FILES = $(BUILT_SOURCES) + +EphyAutomation-common.c EphyAutomation-stubs.c EphyAutomation-skels.c EphyAutomation.h: $(top_srcdir)/idl/EphyAutomation.idl + $(ORBIT_IDL) -I $(LIBBONOBO_IDL) -I $(BONOBO_ACTIVATION_IDL) $(top_srcdir)/idl/EphyAutomation.idl + +EXTRA_DIST = $(top_srcdir)/idl/EphyAutomation.idl diff --git a/src/appearance-prefs.c b/src/appearance-prefs.c new file mode 100755 index 000000000..da1056f3f --- /dev/null +++ b/src/appearance-prefs.c @@ -0,0 +1,458 @@ +/* + * Copyright (C) 2002 Marco Pesenti Gritti + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include "appearance-prefs.h" +#include "ephy-shell.h" +#include "ephy-prefs.h" +#include "ephy-embed-prefs.h" +#include "eel-gconf-extensions.h" + +#include <string.h> +#include <gtk/gtkcombo.h> +#include <gtk/gtkspinbutton.h> +#include <gtk/gtkeditable.h> +#include <gtk/gtkoptionmenu.h> + +static void appearance_prefs_class_init (AppearancePrefsClass *klass); +static void appearance_prefs_init (AppearancePrefs *dialog); +static void appearance_prefs_finalize (GObject *object); + +/* Glade callbacks */ +void +fonts_language_optionmenu_changed_cb (GtkWidget *optionmenu, EphyDialog *dialog); + +static GObjectClass *parent_class = NULL; + +struct AppearancePrefsPrivate +{ + int language; + gboolean switching; +}; + +enum +{ + SERIF_PROP, + SANSSERIF_PROP, + MONOSPACE_PROP, + FIXED_SIZE_PROP, + VARIABLE_SIZE_PROP, + MIN_SIZE_PROP, + PROPORTIONAL_PROP, + BACKGROUND_PROP, + TEXT_PROP, + UNVISITED_PROP, + VISITED_PROP, + USE_SYSCOLORS_PROP, + USE_COLORS_PROP, + USE_FONTS_PROP, +}; + +static const +EphyDialogProperty properties [] = +{ + { SERIF_PROP, "serif_combo", NULL, PT_NORMAL, NULL }, + { SANSSERIF_PROP, "sansserif_combo", NULL, PT_NORMAL, NULL }, + { MONOSPACE_PROP, "monospace_combo", NULL, PT_NORMAL, NULL }, + { FIXED_SIZE_PROP, "fixed_size_spinbutton", NULL, PT_NORMAL, NULL }, + { VARIABLE_SIZE_PROP, "variable_size_spinbutton", NULL, PT_NORMAL, NULL }, + { MIN_SIZE_PROP, "min_size_spinbutton", NULL, PT_NORMAL, NULL }, + { PROPORTIONAL_PROP, "proportional_optionmenu", CONF_RENDERING_DEFAULT_FONT, PT_AUTOAPPLY, NULL }, + { BACKGROUND_PROP, "background_cpick", CONF_RENDERING_BG_COLOR, PT_AUTOAPPLY, NULL }, + { TEXT_PROP, "text_cpick", CONF_RENDERING_TEXT_COLOR, PT_AUTOAPPLY, NULL }, + { UNVISITED_PROP, "unvisited_cpick", CONF_RENDERING_UNVISITED_LINKS, PT_AUTOAPPLY, NULL }, + { VISITED_PROP, "visited_cpick", CONF_RENDERING_VISITED_LINKS, PT_AUTOAPPLY, NULL }, + { USE_SYSCOLORS_PROP, "use_syscolors_checkbutton", CONF_RENDERING_USE_SYSTEM_COLORS, PT_AUTOAPPLY, NULL }, + { USE_COLORS_PROP, "use_colors_checkbutton", CONF_RENDERING_USE_OWN_COLORS, PT_AUTOAPPLY, NULL }, + { USE_FONTS_PROP, "use_fonts_checkbutton", CONF_RENDERING_USE_OWN_FONTS, PT_AUTOAPPLY, NULL }, + + { -1, NULL, NULL } +}; + +/* FIXME duped in mozilla/ */ +const +char *lang_encode[] = +{ + "x-western", + "x-central-euro", + "ja", + "zh-TW", + "zh-CN", + "ko", + "x-cyrillic", + "x-baltic", + "el", + "tr", + "x-unicode", + "th", + "he", + "ar" +}; + +enum +{ + FONT_TYPE_SERIF, + FONT_TYPE_SANSSERIF, + FONT_TYPE_MONOSPACE +}; + +const +char *fonts_types[] = +{ + "serif", + "sans-serif", + "monospace" +}; + +enum +{ + FONT_SIZE_FIXED, + FONT_SIZE_VAR, + FONT_SIZE_MIN +}; + +const +char *size_prefs[] = +{ + CONF_RENDERING_FONT_FIXED_SIZE, + CONF_RENDERING_FONT_VAR_SIZE, + CONF_RENDERING_FONT_MIN_SIZE +}; + +GType +appearance_prefs_get_type (void) +{ + static GType appearance_prefs_type = 0; + + if (appearance_prefs_type == 0) + { + static const GTypeInfo our_info = + { + sizeof (AppearancePrefsClass), + NULL, /* base_init */ + NULL, /* base_finalize */ + (GClassInitFunc) appearance_prefs_class_init, + NULL, + NULL, /* class_data */ + sizeof (AppearancePrefs), + 0, /* n_preallocs */ + (GInstanceInitFunc) appearance_prefs_init + }; + + appearance_prefs_type = g_type_register_static (EPHY_DIALOG_TYPE, + "AppearancePrefs", + &our_info, 0); + } + + return appearance_prefs_type; + +} + +static void +appearance_prefs_class_init (AppearancePrefsClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + object_class->finalize = appearance_prefs_finalize; +} + +static void +setup_font_menu (AppearancePrefs *dialog, + const char *type, + GtkWidget *combo) +{ + char *default_font; + GList *fonts; + EphyEmbedShell *shell; + const char *name; + char key[255]; + int pos; + GtkWidget *entry = GTK_COMBO(combo)->entry; + + shell = ephy_shell_get_embed_shell (ephy_shell); + + ephy_embed_shell_get_font_list (shell, + lang_encode[dialog->priv->language], + type, &fonts, &default_font); + + /* Get the default font */ + sprintf (key, "%s_%s_%s", CONF_RENDERING_FONT, type, + lang_encode[dialog->priv->language]); + name = eel_gconf_get_string (key); + if (name == NULL) + { + name = default_font; + } + + /* put the default font at the top in the list */ + if (name != NULL) + { + fonts = g_list_prepend (fonts, + (gpointer)g_strdup(name)); + } + + /* set popdown doesnt like NULL */ + if (fonts == NULL) + { + fonts = g_list_alloc (); + } + + gtk_combo_set_popdown_strings (GTK_COMBO(combo), fonts); + + /* set the default value */ + if (name != NULL) + { + gtk_editable_delete_text (GTK_EDITABLE(entry), 0, -1); + gtk_editable_insert_text (GTK_EDITABLE(entry), + name, g_utf8_strlen (name, -1), + &pos); + } + + g_free (default_font); + + /* FIXME free the list */ +} + +static void +save_font_menu (AppearancePrefs *dialog, + int type, + GtkWidget *entry) +{ + char *name; + char key[255]; + + name = gtk_editable_get_chars + (GTK_EDITABLE(entry), 0, -1); + + /* do not save empty fonts */ + if (!name || *name == '\0') + { + g_free (name); + return; + } + + sprintf (key, "%s_%s_%s", CONF_RENDERING_FONT, + fonts_types[type], + lang_encode[dialog->priv->language]); + eel_gconf_set_string (key, name); + g_free (name); +} + +static void +font_entry_changed_cb (GtkWidget *entry, AppearancePrefs *dialog) +{ + int type; + + if (dialog->priv->switching) return; + + type = GPOINTER_TO_INT (g_object_get_data (G_OBJECT(entry), + "type")); + save_font_menu (dialog, type, entry); +} + +static void +attach_font_signal (AppearancePrefs *dialog, int prop, + gpointer type) +{ + GtkWidget *combo; + GtkWidget *entry; + + combo = ephy_dialog_get_control (EPHY_DIALOG(dialog), + prop); + entry = GTK_COMBO(combo)->entry; + g_object_set_data (G_OBJECT(entry), "type", type); + g_signal_connect (entry, "changed", + G_CALLBACK(font_entry_changed_cb), + dialog); +} + +static void +attach_fonts_signals (AppearancePrefs *dialog) +{ + attach_font_signal (dialog, SERIF_PROP, + GINT_TO_POINTER(FONT_TYPE_SERIF)); + attach_font_signal (dialog, SANSSERIF_PROP, + GINT_TO_POINTER(FONT_TYPE_SANSSERIF)); + attach_font_signal (dialog, MONOSPACE_PROP, + GINT_TO_POINTER(FONT_TYPE_MONOSPACE)); +} + +static void +size_spinbutton_changed_cb (GtkWidget *spin, AppearancePrefs *dialog) +{ + int type; + char key[255]; + + if (dialog->priv->switching) return; + + type = GPOINTER_TO_INT(g_object_get_data (G_OBJECT(spin), "type")); + + sprintf (key, "%s_%s", + size_prefs[type], + lang_encode[dialog->priv->language]); + eel_gconf_set_integer (key, gtk_spin_button_get_value (GTK_SPIN_BUTTON (spin))); +} + +static void +attach_size_controls_signals (AppearancePrefs *dialog) +{ + GtkWidget *spin; + + spin = ephy_dialog_get_control (EPHY_DIALOG(dialog), + FIXED_SIZE_PROP); + g_object_set_data (G_OBJECT(spin), "type", + GINT_TO_POINTER(FONT_SIZE_FIXED)); + g_signal_connect (spin, "value_changed", + G_CALLBACK(size_spinbutton_changed_cb), + dialog); + + spin = ephy_dialog_get_control (EPHY_DIALOG(dialog), + VARIABLE_SIZE_PROP); + g_object_set_data (G_OBJECT(spin), "type", + GINT_TO_POINTER(FONT_SIZE_VAR)); + g_signal_connect (spin, "value_changed", + G_CALLBACK(size_spinbutton_changed_cb), + dialog); + + spin = ephy_dialog_get_control (EPHY_DIALOG(dialog), + MIN_SIZE_PROP); + g_object_set_data (G_OBJECT(spin), "type", + GINT_TO_POINTER(FONT_SIZE_MIN)); + g_signal_connect (spin, "value_changed", + G_CALLBACK(size_spinbutton_changed_cb), + dialog); +} + +static void +setup_size_control (AppearancePrefs *dialog, + const char *pref, + int default_size, + GtkWidget *spin) +{ + char key[255]; + int size; + + sprintf (key, "%s_%s", pref, + lang_encode[dialog->priv->language]); + size = eel_gconf_get_integer (key); + + if (size == 0) size = default_size; + + gtk_spin_button_set_value (GTK_SPIN_BUTTON(spin), size); +} + +static void +setup_size_controls (AppearancePrefs *dialog) +{ + GtkWidget *spin; + + spin = ephy_dialog_get_control (EPHY_DIALOG(dialog), + FIXED_SIZE_PROP); + setup_size_control (dialog, CONF_RENDERING_FONT_FIXED_SIZE, 12, spin); + + spin = ephy_dialog_get_control (EPHY_DIALOG(dialog), + VARIABLE_SIZE_PROP); + setup_size_control (dialog, CONF_RENDERING_FONT_VAR_SIZE, 16, spin); + + spin = ephy_dialog_get_control (EPHY_DIALOG(dialog), + MIN_SIZE_PROP); + setup_size_control (dialog, CONF_RENDERING_FONT_MIN_SIZE, 0, spin); +} + +static void +setup_fonts (AppearancePrefs *dialog) +{ + GtkWidget *combo; + + dialog->priv->switching = TRUE; + + combo = ephy_dialog_get_control (EPHY_DIALOG(dialog), + SERIF_PROP); + setup_font_menu (dialog, "serif", combo); + + combo = ephy_dialog_get_control (EPHY_DIALOG(dialog), + SANSSERIF_PROP); + setup_font_menu (dialog, "sans-serif", combo); + + combo = ephy_dialog_get_control (EPHY_DIALOG(dialog), + MONOSPACE_PROP); + setup_font_menu (dialog, "monospace", combo); + + dialog->priv->switching = FALSE; +} + +static void +appearance_prefs_init (AppearancePrefs *dialog) +{ + dialog->priv = g_new0 (AppearancePrefsPrivate, 1); + dialog->priv->switching = FALSE; + + ephy_dialog_construct (EPHY_DIALOG(dialog), + properties, + "prefs-dialog.glade", + "appearance_page_box"); + + setup_fonts (dialog); + setup_size_controls (dialog); + attach_fonts_signals (dialog); + attach_size_controls_signals (dialog); +} + +static void +appearance_prefs_finalize (GObject *object) +{ + AppearancePrefs *dialog; + + g_return_if_fail (object != NULL); + g_return_if_fail (IS_appearance_PREFS (object)); + + dialog = appearance_PREFS (object); + + g_return_if_fail (dialog->priv != NULL); + + g_free (dialog->priv); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +EphyDialog * +appearance_prefs_new (void) +{ + AppearancePrefs *dialog; + + dialog = appearance_PREFS (g_object_new (appearance_PREFS_TYPE, + NULL)); + + return EPHY_DIALOG(dialog); +} + +void +fonts_language_optionmenu_changed_cb (GtkWidget *optionmenu, + EphyDialog *dialog) +{ + int i; + + i = gtk_option_menu_get_history + (GTK_OPTION_MENU (optionmenu)); + + appearance_PREFS(dialog)->priv->language = i; + + setup_fonts (appearance_PREFS(dialog)); + setup_size_controls (appearance_PREFS(dialog)); +} diff --git a/src/appearance-prefs.h b/src/appearance-prefs.h new file mode 100644 index 000000000..17067b7e9 --- /dev/null +++ b/src/appearance-prefs.h @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2002 Marco Pesenti Gritti + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef APPEARANCE_PREFS_H +#define APPEARANCE_PREFS_H + +#include "ephy-dialog.h" + +#include <glib-object.h> +#include <glib.h> + +G_BEGIN_DECLS + +typedef struct AppearancePrefs AppearancePrefs; +typedef struct AppearancePrefsClass AppearancePrefsClass; + +#define appearance_PREFS_TYPE (appearance_prefs_get_type ()) +#define appearance_PREFS(obj) (GTK_CHECK_CAST ((obj), appearance_PREFS_TYPE, AppearancePrefs)) +#define appearance_PREFS_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), appearance_PREFS, AppearancePrefsClass)) +#define IS_appearance_PREFS(obj) (GTK_CHECK_TYPE ((obj), appearance_PREFS_TYPE)) +#define IS_appearance_PREFS_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), appearance_PREFS)) + +typedef struct AppearancePrefsPrivate AppearancePrefsPrivate; + +struct AppearancePrefs +{ + EphyDialog parent; + AppearancePrefsPrivate *priv; +}; + +struct AppearancePrefsClass +{ + EphyDialogClass parent_class; +}; + +GType appearance_prefs_get_type (void); + +EphyDialog *appearance_prefs_new (void); + +G_END_DECLS + +#endif + diff --git a/src/bookmarks/.cvsignore b/src/bookmarks/.cvsignore new file mode 100644 index 000000000..6e5ca7ed4 --- /dev/null +++ b/src/bookmarks/.cvsignore @@ -0,0 +1,6 @@ +Makefile +Makefile.in +.deps +.libs +*.lo +*.la diff --git a/src/bookmarks/Makefile.am b/src/bookmarks/Makefile.am new file mode 100644 index 000000000..4dd24c1bd --- /dev/null +++ b/src/bookmarks/Makefile.am @@ -0,0 +1,31 @@ +INCLUDES = \ + -I$(top_srcdir)/lib \ + -I$(top_srcdir)/src \ + -I$(top_srcdir)/embed \ + -I$(top_srcdir)/lib/widgets \ + $(WARN_CFLAGS) \ + $(EPIPHANY_DEPENDENCY_CFLAGS) \ + -DSHARE_DIR=\"$(pkgdatadir)\" \ + -DDATADIR=\""$(datadir)"\" \ + -DGNOMELOCALEDIR=\""$(datadir)/locale"\" \ + -DG_DISABLE_DEPRECATED \ + -DGDK_DISABLE_DEPRECATED \ + -DGTK_DISABLE_DEPRECATED \ + -DGDK_PIXBUF_DISABLE_DEPRECATED \ + -DGNOME_DISABLE_DEPRECATED + +noinst_LTLIBRARIES = libephybookmarks.la + +libephybookmarks_la_SOURCES = \ + ephy-bookmarks.c \ + ephy-bookmarks.h \ + ephy-tree-model-node.c \ + ephy-tree-model-node.h \ + ephy-node-view.c \ + ephy-node-view.h \ + ephy-bookmarks-editor.c \ + ephy-bookmarks-editor.h \ + ephy-keywords-entry.c \ + ephy-keywords-entry.h \ + ephy-new-bookmark.c \ + ephy-new-bookmark.h diff --git a/src/bookmarks/ephy-bookmarks-editor.c b/src/bookmarks/ephy-bookmarks-editor.c new file mode 100644 index 000000000..2888950df --- /dev/null +++ b/src/bookmarks/ephy-bookmarks-editor.c @@ -0,0 +1,534 @@ +/* + * Copyright (C) 2002 Jorn Baayen <jorn@nl.linux.org> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + */ + +#include <gtk/gtktable.h> +#include <gtk/gtklabel.h> +#include <gtk/gtkentry.h> +#include <gtk/gtkstock.h> +#include <gtk/gtkhbox.h> +#include <gtk/gtkvbox.h> +#include <libgnome/gnome-i18n.h> +#include <string.h> + +#include "ephy-bookmarks-editor.h" +#include "ephy-node-view.h" +#include "ephy-window.h" +#include "ephy-keywords-entry.h" +#include "ephy-dnd.h" + +//#define DEBUG_MSG(x) g_print x +#define DEBUG_MSG(x) + +static void ephy_bookmarks_editor_class_init (EphyBookmarksEditorClass *klass); +static void ephy_bookmarks_editor_init (EphyBookmarksEditor *editor); +static void ephy_bookmarks_editor_finalize (GObject *object); +static void ephy_bookmarks_editor_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec); +static void ephy_bookmarks_editor_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec); + +struct EphyBookmarksEditorPrivate +{ + EphyBookmarks *bookmarks; + EphyNodeView *bm_view; + EphyNodeView *key_view; + EphyNodeFilter *bookmarks_filter; + GtkWidget *title_entry; + GtkWidget *keywords_entry; + GtkWidget *search_entry; +}; + +enum +{ + PROP_0, + PROP_BOOKMARKS +}; + +enum +{ + RESPONSE_REMOVE +}; + +static GObjectClass *parent_class = NULL; + +GType +ephy_bookmarks_editor_get_type (void) +{ + static GType ephy_bookmarks_editor_type = 0; + + if (ephy_bookmarks_editor_type == 0) + { + static const GTypeInfo our_info = + { + sizeof (EphyBookmarksEditorClass), + NULL, + NULL, + (GClassInitFunc) ephy_bookmarks_editor_class_init, + NULL, + NULL, + sizeof (EphyBookmarksEditor), + 0, + (GInstanceInitFunc) ephy_bookmarks_editor_init + }; + + ephy_bookmarks_editor_type = g_type_register_static (GTK_TYPE_DIALOG, + "EphyBookmarksEditor", + &our_info, 0); + } + + return ephy_bookmarks_editor_type; +} + +static void +ephy_bookmarks_editor_class_init (EphyBookmarksEditorClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + object_class->finalize = ephy_bookmarks_editor_finalize; + + object_class->set_property = ephy_bookmarks_editor_set_property; + object_class->get_property = ephy_bookmarks_editor_get_property; + + g_object_class_install_property (object_class, + PROP_BOOKMARKS, + g_param_spec_object ("bookmarks", + "Bookmarks set", + "Bookmarks set", + EPHY_BOOKMARKS_TYPE, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); +} + +static void +ephy_bookmarks_editor_finalize (GObject *object) +{ + EphyBookmarksEditor *editor; + + g_return_if_fail (object != NULL); + g_return_if_fail (EPHY_IS_BOOKMARKS_EDITOR (object)); + + editor = EPHY_BOOKMARKS_EDITOR (object); + + g_return_if_fail (editor->priv != NULL); + + g_object_unref (G_OBJECT (editor->priv->bookmarks_filter)); + + g_free (editor->priv); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static void +ephy_bookmarks_editor_node_selected_cb (GtkWidget *view, + EphyNode *node, + EphyBookmarksEditor *editor) +{ + const char *title; + const char *keywords; + + if (node != NULL) + { + g_assert (EPHY_IS_NODE (node)); + + title = ephy_node_get_property_string + (node, EPHY_NODE_BMK_PROP_TITLE); + keywords = ephy_node_get_property_string + (node, EPHY_NODE_BMK_PROP_KEYWORDS); + gtk_entry_set_text (GTK_ENTRY (editor->priv->title_entry), + title ? g_strdup (title) : ""); + gtk_entry_set_text (GTK_ENTRY (editor->priv->keywords_entry), + keywords ? g_strdup (keywords) : ""); + gtk_widget_set_sensitive (GTK_WIDGET (editor->priv->title_entry), TRUE); + gtk_widget_set_sensitive (GTK_WIDGET (editor->priv->keywords_entry), TRUE); + } + else + { + gtk_entry_set_text (GTK_ENTRY (editor->priv->title_entry), ""); + gtk_entry_set_text (GTK_ENTRY (editor->priv->keywords_entry), ""); + gtk_widget_set_sensitive (GTK_WIDGET (editor->priv->title_entry), FALSE); + gtk_widget_set_sensitive (GTK_WIDGET (editor->priv->keywords_entry), FALSE); + } +} + +static void +ephy_bookmarks_editor_node_activated_cb (GtkWidget *view, + EphyNode *node, + EphyBookmarksEditor *editor) +{ + const char *location; + GtkWindow *window; + + g_return_if_fail (EPHY_IS_NODE (node)); + location = ephy_node_get_property_string + (node, EPHY_NODE_BMK_PROP_LOCATION); + g_return_if_fail (location != NULL); + + window = gtk_window_get_transient_for (GTK_WINDOW (editor)); + g_return_if_fail (IS_EPHY_WINDOW (window)); + ephy_window_load_url (EPHY_WINDOW (window), location); +} + +static void +ephy_bookmarks_editor_response_cb (GtkDialog *dialog, + int response_id, + EphyBookmarksEditor *editor) +{ + switch (response_id) + { + case GTK_RESPONSE_CLOSE: + gtk_widget_destroy (GTK_WIDGET (dialog)); + break; + case RESPONSE_REMOVE: + ephy_node_view_remove (editor->priv->bm_view); + break; + } +} + +static void +update_prop_from_entry (EphyBookmarksEditor *editor, + GtkWidget *entry, + guint id) +{ + GList *selection; + GValue value = { 0, }; + + selection = ephy_node_view_get_selection (editor->priv->bm_view); + if (selection) + { + EphyNode *bm = EPHY_NODE (selection->data); + char *tmp; + + tmp = gtk_editable_get_chars + (GTK_EDITABLE (entry), 0, -1); + g_value_init (&value, G_TYPE_STRING); + g_value_set_string (&value, tmp); + ephy_node_set_property (bm, id, &value); + g_value_unset (&value); + g_free (tmp); + } + g_list_free (selection); +} + +static void +title_entry_changed_cb (GtkWidget *entry, EphyBookmarksEditor *editor) +{ + update_prop_from_entry (editor, editor->priv->title_entry, + EPHY_NODE_BMK_PROP_TITLE); +} + +static void +keywords_changed_cb (GtkWidget *entry, + EphyBookmarksEditor *editor) +{ + EphyNode *node; + GList *selection; + char *keywords; + + selection = ephy_node_view_get_selection (editor->priv->bm_view); + if (selection == NULL) return; + node = EPHY_NODE (selection->data); + g_list_free (selection); + + keywords = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1); + ephy_bookmarks_update_keywords (editor->priv->bookmarks, + keywords, node); + g_free (keywords); + + update_prop_from_entry (editor, editor->priv->keywords_entry, + EPHY_NODE_BMK_PROP_KEYWORDS); +} + +static GtkWidget * +build_editing_table (EphyBookmarksEditor *editor) +{ + GtkWidget *table, *label, *entry; + + table = gtk_table_new (2, 2, FALSE); + gtk_table_set_row_spacings (GTK_TABLE (table), 6); + gtk_table_set_col_spacings (GTK_TABLE (table), 6); + gtk_widget_show (table); + + label = gtk_label_new (NULL); + gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); + gtk_label_set_markup (GTK_LABEL (label), _("<b>Title:</b>")); + gtk_widget_show (label); + entry = gtk_entry_new (); + editor->priv->title_entry = entry; + gtk_widget_set_sensitive (GTK_WIDGET (entry), FALSE); + gtk_widget_show (entry); + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, GTK_FILL, 0, 0, 0); + gtk_table_attach_defaults (GTK_TABLE (table), entry, 1, 2, 0, 1); + g_signal_connect (G_OBJECT (entry), "changed", + G_CALLBACK (title_entry_changed_cb), + editor); + + label = gtk_label_new (NULL); + gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); + gtk_label_set_markup (GTK_LABEL (label), _("<b>Keywords:</b>")); + gtk_widget_show (label); + entry = ephy_keywords_entry_new (); + ephy_keywords_entry_set_bookmarks (EPHY_KEYWORDS_ENTRY (entry), + editor->priv->bookmarks); + editor->priv->keywords_entry = entry; + gtk_widget_set_sensitive (GTK_WIDGET (entry), FALSE); + gtk_widget_show (entry); + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, GTK_FILL, 0, 0, 0); + gtk_table_attach_defaults (GTK_TABLE (table), entry, 1, 2, 1, 2); + g_signal_connect (G_OBJECT (entry), "keywords_changed", + G_CALLBACK (keywords_changed_cb), + editor); + + return table; +} + +static void +bookmarks_filter (EphyBookmarksEditor *editor, + EphyNode *keyword) +{ + ephy_node_filter_empty (editor->priv->bookmarks_filter); + ephy_node_filter_add_expression (editor->priv->bookmarks_filter, + ephy_node_filter_expression_new (EPHY_NODE_FILTER_EXPRESSION_HAS_PARENT, + keyword), + 0); + ephy_node_filter_done_changing (editor->priv->bookmarks_filter); +} + +static void +keyword_node_selected_cb (EphyNodeView *view, + EphyNode *node, + EphyBookmarksEditor *editor) +{ + if (node == NULL) + { + ephy_node_view_select_node + (editor->priv->key_view, + ephy_bookmarks_get_bookmarks + (editor->priv->bookmarks)); + } + else + { + bookmarks_filter (editor, node); + } +} + +static void +search_entry_changed_cb (GtkWidget *entry, EphyBookmarksEditor *editor) +{ + char *search_text; + + search_text = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1); + + GDK_THREADS_ENTER (); + + ephy_node_filter_empty (editor->priv->bookmarks_filter); + ephy_node_filter_add_expression (editor->priv->bookmarks_filter, + ephy_node_filter_expression_new (EPHY_NODE_FILTER_EXPRESSION_STRING_PROP_CONTAINS, + EPHY_NODE_BMK_PROP_TITLE, + search_text), + 0); + ephy_node_filter_add_expression (editor->priv->bookmarks_filter, + ephy_node_filter_expression_new (EPHY_NODE_FILTER_EXPRESSION_STRING_PROP_CONTAINS, + EPHY_NODE_BMK_PROP_KEYWORDS, + search_text), + 0); + ephy_node_filter_done_changing (editor->priv->bookmarks_filter); + + GDK_THREADS_LEAVE (); + + g_free (search_text); +} + +static GtkWidget * +build_search_box (EphyBookmarksEditor *editor) +{ + GtkWidget *box; + GtkWidget *label; + GtkWidget *entry; + + box = gtk_hbox_new (FALSE, 6); + gtk_widget_show (box); + + label = gtk_label_new (NULL); + gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); + gtk_label_set_markup (GTK_LABEL (label), _("<b>Search:</b>")); + gtk_widget_show (label); + gtk_box_pack_start (GTK_BOX (box), + label, FALSE, TRUE, 0); + + entry = gtk_entry_new (); + editor->priv->search_entry = entry; + gtk_widget_show (entry); + gtk_box_pack_start (GTK_BOX (box), + entry, TRUE, TRUE, 0); + g_signal_connect (G_OBJECT (entry), "changed", + G_CALLBACK (search_entry_changed_cb), + editor); + return box; +} + +static void +ephy_bookmarks_editor_construct (EphyBookmarksEditor *editor) +{ + GtkWidget *hbox, *vbox; + EphyNodeView *bm_view, *key_view; + EphyNode *node; + + gtk_dialog_set_has_separator (GTK_DIALOG (editor), FALSE); + gtk_container_set_border_width (GTK_CONTAINER (editor), 6); + gtk_widget_set_size_request (GTK_WIDGET (editor), 500, 400); + g_signal_connect (G_OBJECT (editor), + "response", + G_CALLBACK (ephy_bookmarks_editor_response_cb), + editor); + + hbox = gtk_hbox_new (FALSE, 6); + gtk_container_set_border_width (GTK_CONTAINER (hbox), 6); + gtk_box_pack_start (GTK_BOX (GTK_DIALOG (editor)->vbox), + hbox, TRUE, TRUE, 0); + gtk_widget_show (hbox); + + g_assert (editor->priv->bookmarks); + + node = ephy_bookmarks_get_keywords (editor->priv->bookmarks); + key_view = ephy_node_view_new (node, NULL); + ephy_node_view_set_browse_mode (key_view); + ephy_node_view_add_column (key_view, _("Keywords"), + EPHY_TREE_MODEL_NODE_COL_KEYWORD, FALSE); + gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (key_view), FALSE, TRUE, 0); + gtk_widget_set_size_request (GTK_WIDGET (key_view), 120, -1); + gtk_widget_show (GTK_WIDGET (key_view)); + editor->priv->key_view = key_view; + g_signal_connect (G_OBJECT (key_view), + "node_selected", + G_CALLBACK (keyword_node_selected_cb), + editor); + + vbox = gtk_vbox_new (FALSE, 6); + gtk_box_pack_start (GTK_BOX (hbox), + vbox, TRUE, TRUE, 0); + gtk_widget_show (vbox); + + gtk_box_pack_start (GTK_BOX (vbox), + build_search_box (editor), + FALSE, FALSE, 0); + + node = ephy_bookmarks_get_bookmarks (editor->priv->bookmarks); + editor->priv->bookmarks_filter = ephy_node_filter_new (); + bm_view = ephy_node_view_new (node, editor->priv->bookmarks_filter); + ephy_node_view_enable_drag_source (bm_view); + ephy_node_view_add_column (bm_view, _("Title"), + EPHY_TREE_MODEL_NODE_COL_BOOKMARK, TRUE); + ephy_node_view_add_column (bm_view, _("Location"), + EPHY_TREE_MODEL_NODE_COL_LOCATION, TRUE); + gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (bm_view), TRUE, TRUE, 0); + gtk_widget_show (GTK_WIDGET (bm_view)); + editor->priv->bm_view = bm_view; + g_signal_connect (G_OBJECT (bm_view), + "node_activated", + G_CALLBACK (ephy_bookmarks_editor_node_activated_cb), + editor); + g_signal_connect (G_OBJECT (bm_view), + "node_selected", + G_CALLBACK (ephy_bookmarks_editor_node_selected_cb), + editor); + + gtk_box_pack_start (GTK_BOX (vbox), + build_editing_table (editor), + FALSE, FALSE, 0); + + gtk_dialog_add_button (GTK_DIALOG (editor), + GTK_STOCK_REMOVE, + RESPONSE_REMOVE); + gtk_dialog_add_button (GTK_DIALOG (editor), + GTK_STOCK_CLOSE, + GTK_RESPONSE_CLOSE); + gtk_dialog_set_default_response (GTK_DIALOG (editor), GTK_RESPONSE_CLOSE); +} + +GtkWidget * +ephy_bookmarks_editor_new (EphyBookmarks *bookmarks, + GtkWindow *parent) +{ + EphyBookmarksEditor *editor; + + g_assert (bookmarks != NULL); + + editor = EPHY_BOOKMARKS_EDITOR (g_object_new + (EPHY_TYPE_BOOKMARKS_EDITOR, + "bookmarks", bookmarks, + NULL)); + + if (parent) + { + gtk_window_set_transient_for (GTK_WINDOW (editor), parent); + } + + ephy_bookmarks_editor_construct (editor); + + return GTK_WIDGET (editor); +} + +static void +ephy_bookmarks_editor_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + EphyBookmarksEditor *editor = EPHY_BOOKMARKS_EDITOR (object); + + switch (prop_id) + { + case PROP_BOOKMARKS: + editor->priv->bookmarks = g_value_get_object (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +ephy_bookmarks_editor_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + EphyBookmarksEditor *editor = EPHY_BOOKMARKS_EDITOR (object); + + switch (prop_id) + { + case PROP_BOOKMARKS: + g_value_set_object (value, editor->priv->bookmarks); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +ephy_bookmarks_editor_init (EphyBookmarksEditor *editor) +{ + editor->priv = g_new0 (EphyBookmarksEditorPrivate, 1); +} diff --git a/src/bookmarks/ephy-bookmarks-editor.h b/src/bookmarks/ephy-bookmarks-editor.h new file mode 100644 index 000000000..f79dfa673 --- /dev/null +++ b/src/bookmarks/ephy-bookmarks-editor.h @@ -0,0 +1,59 @@ +/* + * Copyright (C) 2002 Jorn Baayen <jorn@nl.linux.org> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * $Id$ + */ + +#ifndef EPHY_BOOKMARKS_EDITOR_H +#define EPHY_BOOKMARKS_EDITOR_H + +#include <gtk/gtkdialog.h> + +#include "ephy-node-view.h" +#include "ephy-bookmarks.h" + +G_BEGIN_DECLS + +#define EPHY_TYPE_BOOKMARKS_EDITOR (ephy_bookmarks_editor_get_type ()) +#define EPHY_BOOKMARKS_EDITOR(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), EPHY_TYPE_BOOKMARKS_EDITOR, EphyBookmarksEditor)) +#define EPHY_BOOKMARKS_EDITOR_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), EPHY_TYPE_BOOKMARKS_EDITOR, EphyBookmarksEditorClass)) +#define EPHY_IS_BOOKMARKS_EDITOR(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), EPHY_TYPE_BOOKMARKS_EDITOR)) +#define EPHY_IS_BOOKMARKS_EDITOR_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), EPHY_TYPE_BOOKMARKS_EDITOR)) +#define EPHY_BOOKMARKS_EDITOR_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), EPHY_TYPE_BOOKMARKS_EDITOR, EphyBookmarksEditorClass)) + +typedef struct EphyBookmarksEditorPrivate EphyBookmarksEditorPrivate; + +typedef struct +{ + GtkDialog parent; + + EphyBookmarksEditorPrivate *priv; +} EphyBookmarksEditor; + +typedef struct +{ + GtkDialogClass parent; +} EphyBookmarksEditorClass; + +GType ephy_bookmarks_editor_get_type (void); + +GtkWidget *ephy_bookmarks_editor_new (EphyBookmarks *bookmarks, + GtkWindow *parent); + +G_END_DECLS + +#endif /* EPHY_BOOKMARKS_EDITOR_H */ diff --git a/src/bookmarks/ephy-bookmarks.c b/src/bookmarks/ephy-bookmarks.c new file mode 100644 index 000000000..e27a30496 --- /dev/null +++ b/src/bookmarks/ephy-bookmarks.c @@ -0,0 +1,988 @@ +/* + * Copyright (C) 2002 Marco Pesenti Gritti + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include "ephy-bookmarks.h" +#include "ephy-file-helpers.h" +#include "ephy-shell.h" +#include "ephy-history.h" + +#include <string.h> +#include <libgnome/gnome-i18n.h> + +//#define DEBUG_MSG(x) g_print x +#define DEBUG_MSG(x) + +#define EPHY_BOOKMARKS_XML_VERSION "0.1" + +#define MAX_FAVORITES_NUM 10 + +struct EphyBookmarksPrivate +{ + char *xml_file; + EphyNode *bookmarks; + EphyNode *keywords; + EphyNode *favorites; + EphyNode *lower_fav; + double lower_score; + GHashTable *bookmarks_hash; + GStaticRWLock *bookmarks_hash_lock; + GHashTable *favorites_hash; + GStaticRWLock *favorites_hash_lock; + GHashTable *keywords_hash; + GStaticRWLock *keywords_hash_lock; +}; + +static void +ephy_bookmarks_class_init (EphyBookmarksClass *klass); +static void +ephy_bookmarks_init (EphyBookmarks *tab); +static void +ephy_bookmarks_finalize (GObject *object); +static void +ephy_bookmarks_autocompletion_source_init (EphyAutocompletionSourceIface *iface); + +static GObjectClass *parent_class = NULL; + +GType +ephy_bookmarks_get_type (void) +{ + static GType ephy_bookmarks_type = 0; + + if (ephy_bookmarks_type == 0) + { + static const GTypeInfo our_info = + { + sizeof (EphyBookmarksClass), + NULL, /* base_init */ + NULL, /* base_finalize */ + (GClassInitFunc) ephy_bookmarks_class_init, + NULL, + NULL, /* class_data */ + sizeof (EphyBookmarks), + 0, /* n_preallocs */ + (GInstanceInitFunc) ephy_bookmarks_init + }; + + static const GInterfaceInfo autocompletion_source_info = + { + (GInterfaceInitFunc) ephy_bookmarks_autocompletion_source_init, + NULL, + NULL + }; + + ephy_bookmarks_type = g_type_register_static (G_TYPE_OBJECT, + "EphyBookmarks", + &our_info, 0); + + g_type_add_interface_static (ephy_bookmarks_type, + EPHY_TYPE_AUTOCOMPLETION_SOURCE, + &autocompletion_source_info); + } + + return ephy_bookmarks_type; +} + +static void +ephy_bookmarks_autocompletion_source_set_basic_key (EphyAutocompletionSource *source, + const gchar *basic_key) +{ + /* nothing to do here */ +} + +static void +ephy_bookmarks_autocompletion_source_foreach (EphyAutocompletionSource *source, + const gchar *current_text, + EphyAutocompletionSourceForeachFunc func, + gpointer data) +{ + GPtrArray *children; + int i; + EphyBookmarks *eb = EPHY_BOOKMARKS (source); + + children = ephy_node_get_children (eb->priv->bookmarks); + for (i = 0; i < children->len; i++) + { + EphyNode *kid; + const char *url, *smart_url, *title, *keywords; + char *item; + + kid = g_ptr_array_index (children, i); + url = ephy_node_get_property_string + (kid, EPHY_NODE_BMK_PROP_LOCATION); + smart_url = ephy_node_get_property_string + (kid, EPHY_NODE_BMK_PROP_SMART_LOCATION); + title = ephy_node_get_property_string + (kid, EPHY_NODE_BMK_PROP_TITLE); + keywords = ephy_node_get_property_string + (kid, EPHY_NODE_BMK_PROP_KEYWORDS); + item = g_strconcat (title, keywords, NULL); + + if (smart_url == NULL || + g_utf8_strlen (smart_url, -1) == 0) + { + smart_url = NULL; + } + + func (source, + smart_url ? NULL : item, + title, + smart_url ? smart_url : url, + (smart_url != NULL), + TRUE, 0, data); + + g_free (item); + } + ephy_node_thaw (eb->priv->bookmarks); +} + +static void +ephy_bookmarks_emit_data_changed (EphyBookmarks *eb) +{ + g_signal_emit_by_name (eb, "data-changed"); +} + +static void +ephy_bookmarks_autocompletion_source_init (EphyAutocompletionSourceIface *iface) +{ + iface->foreach = ephy_bookmarks_autocompletion_source_foreach; + iface->set_basic_key = ephy_bookmarks_autocompletion_source_set_basic_key; +} + +static void +ephy_bookmarks_class_init (EphyBookmarksClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + object_class->finalize = ephy_bookmarks_finalize; +} + +static gboolean +ephy_bookmarks_clean_empty_keywords (EphyBookmarks *eb) +{ + GPtrArray *children; + int i; + + children = ephy_node_get_children (eb->priv->keywords); + ephy_node_thaw (eb->priv->keywords); + for (i = 0; i < children->len; i++) + { + EphyNode *kid; + + kid = g_ptr_array_index (children, i); + + if (ephy_node_get_n_children (kid) == 0) + { + DEBUG_MSG (("Remove empty keyword: %s\n", + ephy_node_get_property_string (kid, + EPHY_NODE_KEYWORD_PROP_NAME))); + ephy_node_unref (kid); + } + } + + return FALSE; +} + +static void +ephy_bookmarks_load (EphyBookmarks *eb) +{ + xmlDocPtr doc; + xmlNodePtr root, child; + char *tmp; + + if (g_file_test (eb->priv->xml_file, G_FILE_TEST_EXISTS) == FALSE) + return; + + doc = xmlParseFile (eb->priv->xml_file); + g_assert (doc != NULL); + + root = xmlDocGetRootElement (doc); + + tmp = xmlGetProp (root, "version"); + g_assert (tmp != NULL && strcmp (tmp, EPHY_BOOKMARKS_XML_VERSION) == 0); + g_free (tmp); + + for (child = root->children; child != NULL; child = child->next) + { + EphyNode *node; + + node = ephy_node_new_from_xml (child); + } + + xmlFreeDoc (doc); +} + +static void +ephy_bookmarks_save (EphyBookmarks *eb) +{ + xmlDocPtr doc; + xmlNodePtr root; + GPtrArray *children; + int i; + + DEBUG_MSG (("Saving bookmarks\n")); + + /* save nodes to xml */ + xmlIndentTreeOutput = TRUE; + doc = xmlNewDoc ("1.0"); + + root = xmlNewDocNode (doc, NULL, "ephy_bookmarks", NULL); + xmlSetProp (root, "version", EPHY_BOOKMARKS_XML_VERSION); + xmlDocSetRootElement (doc, root); + + children = ephy_node_get_children (eb->priv->keywords); + for (i = 0; i < children->len; i++) + { + EphyNode *kid; + + kid = g_ptr_array_index (children, i); + + if (kid != eb->priv->bookmarks) + { + ephy_node_save_to_xml (kid, root); + } + } + ephy_node_thaw (eb->priv->keywords); + + children = ephy_node_get_children (eb->priv->bookmarks); + for (i = 0; i < children->len; i++) + { + EphyNode *kid; + + kid = g_ptr_array_index (children, i); + + ephy_node_save_to_xml (kid, root); + } + ephy_node_thaw (eb->priv->bookmarks); + + xmlSaveFormatFile (eb->priv->xml_file, doc, 1); +} + +static double +get_history_item_score (EphyHistory *eh, const char *page) +{ + return ephy_history_get_page_visits (eh, page); +} + +static EphyNode * +compute_lower_fav (EphyNode *favorites, double *score) +{ + GPtrArray *children; + int i; + EphyEmbedShell *embed_shell; + EphyHistory *history; + EphyNode *result = NULL; + + embed_shell = ephy_shell_get_embed_shell (ephy_shell); + history = ephy_embed_shell_get_global_history (embed_shell); + + *score = DBL_MAX; + children = ephy_node_get_children (favorites); + for (i = 0; i < children->len; i++) + { + const char *url; + EphyNode *child; + double item_score; + + child = g_ptr_array_index (children, i); + url = ephy_node_get_property_string + (child, EPHY_NODE_BMK_PROP_LOCATION); + item_score = get_history_item_score (history, url); + if (*score > item_score) + { + *score = item_score; + result = child; + } + } + ephy_node_thaw (favorites); + + if (result == NULL) *score = 0; + + return result; +} + +static void +ephy_bookmarks_update_favorites (EphyBookmarks *eb) +{ + eb->priv->lower_fav = compute_lower_fav (eb->priv->favorites, + &eb->priv->lower_score); +} + +static gboolean +add_to_favorites (EphyBookmarks *eb, EphyNode *node, EphyHistory *eh) +{ + const char *url; + EphyNode *fav_node; + gboolean full_menu; + double score; + + url = ephy_node_get_property_string (node, EPHY_NODE_BMK_PROP_LOCATION); + g_static_rw_lock_reader_lock (eb->priv->favorites_hash_lock); + fav_node = g_hash_table_lookup (eb->priv->favorites_hash, url); + g_static_rw_lock_reader_unlock (eb->priv->favorites_hash_lock); + if (fav_node) return FALSE; + + score = get_history_item_score (eh, url); + full_menu = ephy_node_get_n_children (eb->priv->favorites) + > MAX_FAVORITES_NUM; + if (full_menu && score < eb->priv->lower_score) return FALSE; + + if (eb->priv->lower_fav && full_menu) + { + ephy_node_remove_child (eb->priv->favorites, + eb->priv->lower_fav); + } + + ephy_node_add_child (eb->priv->favorites, node); + ephy_bookmarks_update_favorites (eb); + + return TRUE; +} + +static void +update_favorites_menus () +{ + Session *session; + GList *l; + + session = ephy_shell_get_session (ephy_shell); + l = session_get_windows (session); + + for (; l != NULL; l = l->next) + { + EphyWindow *window = EPHY_WINDOW (l->data); + + ephy_window_update_control (window, FavoritesControl); + } +} + +static void +history_site_visited_cb (EphyHistory *gh, const char *url, EphyBookmarks *eb) +{ + EphyNode *node; + + g_static_rw_lock_reader_lock (eb->priv->bookmarks_hash_lock); + node = g_hash_table_lookup (eb->priv->bookmarks_hash, url); + g_static_rw_lock_reader_unlock (eb->priv->bookmarks_hash_lock); + if (!node) return; + + if (add_to_favorites (eb, node, gh)) + { + update_favorites_menus (); + } +} + +static void +ephy_setup_history_notifiers (EphyBookmarks *eb) +{ + EphyEmbedShell *embed_shell; + EphyHistory *history; + + embed_shell = ephy_shell_get_embed_shell (ephy_shell); + history = ephy_embed_shell_get_global_history (embed_shell); + + g_signal_connect (history, "visited", + G_CALLBACK (history_site_visited_cb), eb); +} + +static void +keywords_added_cb (EphyNode *node, + EphyNode *child, + EphyBookmarks *eb) +{ + g_static_rw_lock_writer_lock (eb->priv->keywords_hash_lock); + + g_hash_table_insert (eb->priv->keywords_hash, + (char *) ephy_node_get_property_string (child, EPHY_NODE_KEYWORD_PROP_NAME), + child); + + g_static_rw_lock_writer_unlock (eb->priv->keywords_hash_lock); +} + +static void +keywords_removed_cb (EphyNode *node, + EphyNode *child, + EphyBookmarks *eb) +{ + g_static_rw_lock_writer_lock (eb->priv->keywords_hash_lock); + + g_hash_table_remove (eb->priv->keywords_hash, + ephy_node_get_property_string (child, EPHY_NODE_KEYWORD_PROP_NAME)); + + g_static_rw_lock_writer_unlock (eb->priv->keywords_hash_lock); +} + +static void +favorites_added_cb (EphyNode *node, + EphyNode *child, + EphyBookmarks *eb) +{ + g_static_rw_lock_writer_lock (eb->priv->favorites_hash_lock); + + g_hash_table_insert (eb->priv->favorites_hash, + (char *) ephy_node_get_property_string (child, EPHY_NODE_BMK_PROP_LOCATION), + child); + + g_static_rw_lock_writer_unlock (eb->priv->favorites_hash_lock); +} + +static void +favorites_removed_cb (EphyNode *node, + EphyNode *child, + EphyBookmarks *eb) +{ + g_static_rw_lock_writer_lock (eb->priv->favorites_hash_lock); + + g_hash_table_remove (eb->priv->favorites_hash, + ephy_node_get_property_string (child, EPHY_NODE_BMK_PROP_LOCATION)); + + g_static_rw_lock_writer_unlock (eb->priv->favorites_hash_lock); +} + +static void +bookmarks_added_cb (EphyNode *node, + EphyNode *child, + EphyBookmarks *eb) +{ + g_static_rw_lock_writer_lock (eb->priv->bookmarks_hash_lock); + + g_hash_table_insert (eb->priv->bookmarks_hash, + (char *) ephy_node_get_property_string (child, EPHY_NODE_BMK_PROP_LOCATION), + child); + + g_static_rw_lock_writer_unlock (eb->priv->bookmarks_hash_lock); +} + +static void +bookmarks_removed_cb (EphyNode *node, + EphyNode *child, + EphyBookmarks *eb) +{ + ephy_bookmarks_emit_data_changed (eb); + g_idle_add ((GSourceFunc)ephy_bookmarks_clean_empty_keywords, eb); + + g_static_rw_lock_writer_lock (eb->priv->bookmarks_hash_lock); + + g_hash_table_remove (eb->priv->bookmarks_hash, + ephy_node_get_property_string (child, EPHY_NODE_BMK_PROP_LOCATION)); + + g_static_rw_lock_writer_unlock (eb->priv->bookmarks_hash_lock); +} + +static void +ephy_bookmarks_init (EphyBookmarks *eb) +{ + GValue value = { 0, }; + + eb->priv = g_new0 (EphyBookmarksPrivate, 1); + + eb->priv->xml_file = g_build_filename (ephy_dot_dir (), + "bookmarks.xml", + NULL); + + eb->priv->bookmarks_hash = g_hash_table_new (g_str_hash, + g_str_equal); + eb->priv->bookmarks_hash_lock = g_new0 (GStaticRWLock, 1); + g_static_rw_lock_init (eb->priv->bookmarks_hash_lock); + + eb->priv->keywords_hash = g_hash_table_new (g_str_hash, + g_str_equal); + eb->priv->keywords_hash_lock = g_new0 (GStaticRWLock, 1); + g_static_rw_lock_init (eb->priv->keywords_hash_lock); + + eb->priv->favorites_hash = g_hash_table_new (g_str_hash, + g_str_equal); + eb->priv->favorites_hash_lock = g_new0 (GStaticRWLock, 1); + g_static_rw_lock_init (eb->priv->favorites_hash_lock); + + /* Bookmarks */ + eb->priv->bookmarks = ephy_node_new (); + ephy_node_ref (eb->priv->bookmarks); + g_value_init (&value, G_TYPE_STRING); + g_value_set_string (&value, _("All")); + ephy_node_set_property (eb->priv->bookmarks, + EPHY_NODE_KEYWORD_PROP_NAME, + &value); + g_value_unset (&value); + g_signal_connect_object (G_OBJECT (eb->priv->bookmarks), + "child_added", + G_CALLBACK (bookmarks_added_cb), + G_OBJECT (eb), + 0); + g_signal_connect_object (G_OBJECT (eb->priv->bookmarks), + "child_removed", + G_CALLBACK (bookmarks_removed_cb), + G_OBJECT (eb), + 0); + + /* Keywords */ + eb->priv->keywords = ephy_node_new (); + ephy_node_ref (eb->priv->keywords); + + ephy_node_add_child (eb->priv->keywords, + eb->priv->bookmarks); + g_signal_connect_object (G_OBJECT (eb->priv->keywords), + "child_added", + G_CALLBACK (keywords_added_cb), + G_OBJECT (eb), + 0); + g_signal_connect_object (G_OBJECT (eb->priv->keywords), + "child_removed", + G_CALLBACK (keywords_removed_cb), + G_OBJECT (eb), + 0); + + eb->priv->favorites = ephy_node_new (); + ephy_node_ref (eb->priv->favorites); + g_signal_connect_object (G_OBJECT (eb->priv->favorites), + "child_added", + G_CALLBACK (favorites_added_cb), + G_OBJECT (eb), + 0); + g_signal_connect_object (G_OBJECT (eb->priv->favorites), + "child_removed", + G_CALLBACK (favorites_removed_cb), + G_OBJECT (eb), + 0); + + ephy_bookmarks_load (eb); + ephy_bookmarks_emit_data_changed (eb); + + ephy_setup_history_notifiers (eb); + ephy_bookmarks_update_favorites (eb); +} + +static void +ephy_bookmarks_finalize (GObject *object) +{ + EphyBookmarks *eb; + + g_return_if_fail (IS_EPHY_BOOKMARKS (object)); + + eb = EPHY_BOOKMARKS (object); + + g_return_if_fail (eb->priv != NULL); + + ephy_bookmarks_save (eb); + + ephy_node_unref (eb->priv->bookmarks); + ephy_node_unref (eb->priv->keywords); + ephy_node_unref (eb->priv->favorites); + + g_hash_table_destroy (eb->priv->bookmarks_hash); + g_static_rw_lock_free (eb->priv->bookmarks_hash_lock); + g_hash_table_destroy (eb->priv->favorites_hash); + g_static_rw_lock_free (eb->priv->favorites_hash_lock); + g_hash_table_destroy (eb->priv->keywords_hash); + g_static_rw_lock_free (eb->priv->keywords_hash_lock); + + g_free (eb->priv); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +EphyBookmarks * +ephy_bookmarks_new () +{ + EphyBookmarks *tab; + + tab = EPHY_BOOKMARKS (g_object_new (EPHY_BOOKMARKS_TYPE, NULL)); + + return tab; +} + +EphyNode * +ephy_bookmarks_add (EphyBookmarks *eb, + const char *title, + const char *url, + const char *smart_url, + const char *keywords) +{ + EphyNode *bm; + GValue value = { 0, }; + + bm = ephy_node_new (); + + g_value_init (&value, G_TYPE_STRING); + g_value_set_string (&value, title); + ephy_node_set_property (bm, EPHY_NODE_BMK_PROP_TITLE, + &value); + g_value_unset (&value); + + g_value_init (&value, G_TYPE_STRING); + g_value_set_string (&value, url); + ephy_node_set_property (bm, EPHY_NODE_BMK_PROP_LOCATION, + &value); + g_value_unset (&value); + + g_value_init (&value, G_TYPE_STRING); + g_value_set_string (&value, smart_url); + ephy_node_set_property (bm, EPHY_NODE_BMK_PROP_SMART_LOCATION, + &value); + g_value_unset (&value); + + ephy_bookmarks_update_keywords (eb, keywords, bm); + + g_value_init (&value, G_TYPE_STRING); + g_value_set_string (&value, keywords); + ephy_node_set_property (bm, EPHY_NODE_BMK_PROP_KEYWORDS, + &value); + g_value_unset (&value); + + ephy_node_add_child (eb->priv->bookmarks, bm); + + ephy_bookmarks_emit_data_changed (eb); + + return bm; +} + +static gchar * +options_skip_spaces (const gchar *str) +{ + const gchar *ret = str; + while (*ret && g_ascii_isspace (*ret)) + { + ++ret; + } + return (gchar *) ret; +} + +static char * +options_find_value_end (const gchar *value_start) +{ + const gchar *value_end; + if (*value_start == '"') + { + for (value_end = value_start + 1; + *value_end && (*value_end != '"' || *(value_end - 1) == '\\'); + ++value_end) ; + } + else + { + for (value_end = value_start; + *value_end && ! (g_ascii_isspace (*value_end) + || *value_end == ',' + || *value_end == ';'); + ++value_end) ; + } + return (gchar *) value_end; +} + +static char * +options_find_next_option (const char *current) +{ + const gchar *value_start; + const gchar *value_end; + const gchar *ret; + value_start = strchr (current, '='); + if (!value_start) return NULL; + value_start = options_skip_spaces (value_start + 1); + value_end = options_find_value_end (value_start); + if (! (*value_end)) return NULL; + for (ret = value_end + 1; + *ret && (g_ascii_isspace (*ret) + || *ret == ',' + || *ret == ';'); + ++ret); + return (char *) ret; +} + +/** + * Very simple parser for option strings in the + * form a=b,c=d,e="f g",... + */ +static gchar * +smart_url_options_get (const gchar *options, const gchar *option) +{ + gchar *ret = NULL; + gsize optionlen = strlen (option); + const gchar *current = options_skip_spaces (options); + + while (current) + { + if (!strncmp (option, current, optionlen)) + { + if (g_ascii_isspace (*(current + optionlen)) || *(current + optionlen) == '=') + { + const gchar *value_start; + const gchar *value_end; + value_start = strchr (current + optionlen, '='); + if (!value_start) continue; + value_start = options_skip_spaces (value_start + 1); + value_end = options_find_value_end (value_start); + if (*value_start == '"') value_start++; + if (value_end >= value_start) + { + ret = g_strndup (value_start, value_end - value_start); + break; + } + } + } + current = options_find_next_option (current); + } + + return ret; +} + +static char * +get_smarturl_only (const char *smarturl) +{ + const gchar *openbrace; + const gchar *closebrace; + const gchar *c; + + openbrace = strchr (smarturl, '{'); + if (!openbrace) return g_strdup (smarturl); + for (c = smarturl; c < openbrace; ++c) + { + if (!strchr (" \t\n", *c)) return g_strdup (smarturl); + } + + closebrace = strchr (openbrace + 1, '}'); + if (!closebrace) return g_strdup (smarturl); + + return g_strdup (closebrace + 1); +} + +char * +ephy_bookmarks_solve_smart_url (EphyBookmarks *eb, + const char *smart_url, + const char *content) +{ + gchar *ret; + GString *s; + gchar *t1; + gchar *t2; + gchar *encoding; + gchar *smarturl_only; + gchar *arg; + + g_return_val_if_fail (content != NULL, NULL); + + smarturl_only = get_smarturl_only (smart_url); + + s = g_string_new (""); + + encoding = smart_url_options_get (smart_url, "encoding"); + if (!encoding) + { + encoding = g_strdup ("UTF-8"); + } + + arg = g_convert (content, strlen (content), + encoding, "UTF-8", NULL, NULL, NULL); + + t1 = smarturl_only; + t2 = strstr (t1, "%s"); + g_return_val_if_fail (t2 != NULL, NULL); + g_string_append_len (s, t1, t2 - t1); + g_string_append (s, arg); + t1 = t2 + 2; + g_string_append (s, t1); + ret = s->str; + g_string_free (s, FALSE); + + g_free (arg); + g_free (encoding); + g_free (smarturl_only); + + return ret; +} + +EphyNode * +ephy_bookmarks_add_keyword (EphyBookmarks *eb, + const char *name) +{ + EphyNode *key; + GValue value = { 0, }; + + key = ephy_node_new (); + + g_value_init (&value, G_TYPE_STRING); + g_value_set_string (&value, name); + ephy_node_set_property (key, EPHY_NODE_KEYWORD_PROP_NAME, + &value); + g_value_unset (&value); + + ephy_node_add_child (eb->priv->keywords, key); + + return key; +} + +EphyNode * +ephy_bookmarks_find_keyword (EphyBookmarks *eb, + const char *name, + gboolean partial_match) +{ + EphyNode *node; + + g_return_val_if_fail (name != NULL, NULL); + + if (!partial_match) + { + g_static_rw_lock_reader_lock (eb->priv->keywords_hash_lock); + node = g_hash_table_lookup (eb->priv->keywords_hash, name); + g_static_rw_lock_reader_unlock (eb->priv->keywords_hash_lock); + } + else + { + GPtrArray *children; + int i; + + if (g_utf8_strlen (name, -1) == 0) + { + DEBUG_MSG (("Empty name, no keyword matches.\n")); + return NULL; + } + + children = ephy_node_get_children (eb->priv->keywords); + node = NULL; + for (i = 0; i < children->len; i++) + { + EphyNode *kid; + const char *key; + + kid = g_ptr_array_index (children, i); + key = ephy_node_get_property_string (kid, EPHY_NODE_KEYWORD_PROP_NAME); + + if (g_str_has_prefix (key, name) > 0) + { + node = kid; + } + } + ephy_node_thaw (eb->priv->keywords); + } + + return node; +} + +void +ephy_bookmarks_set_keyword (EphyBookmarks *eb, + EphyNode *keyword, + EphyNode *bookmark) +{ + ephy_node_add_child (keyword, bookmark); +} + +void +ephy_bookmarks_unset_keyword (EphyBookmarks *eb, + EphyNode *keyword, + EphyNode *bookmark) +{ + ephy_node_remove_child (keyword, bookmark); + ephy_bookmarks_clean_empty_keywords (eb); +} + +static GList * +diff_keywords (char **ks1, char **ks2) +{ + GList *result = NULL; + int i, j; + + for (i = 0; ks1 != NULL && ks1[i] != NULL; i++) + { + gboolean found = FALSE; + + DEBUG_MSG (("Diff keywords, keyword:\"%s\"\n", ks1[i])); + + for (j = 0; ks2 != NULL && ks2[j] != NULL; j++) + { + if (strcmp (ks1[i], ks2[j]) == 0) + { + found = TRUE; + } + } + + if (!found && g_utf8_strlen (ks1[i], -1) > 0) + { + result = g_list_append (result, ks1[i]); + } + } + + return result; +} + +void +ephy_bookmarks_update_keywords (EphyBookmarks *eb, + const char *keywords, + EphyNode *node) +{ + const char *prop; + char **ks, **old_ks = NULL; + GList *diffs, *l; + EphyNode *keyword; + + prop = ephy_node_get_property_string (node, EPHY_NODE_BMK_PROP_KEYWORDS); + ks = g_strsplit (keywords, " ", 10); + if (prop != NULL) + { + old_ks = g_strsplit (prop, " ", 10); + } + + diffs = diff_keywords (ks, old_ks); + for (l = diffs; l != NULL; l = l->next) + { + char *word = (char *)l->data; + + keyword = ephy_bookmarks_find_keyword + (eb, word, FALSE); + + if (!keyword) + { + keyword = ephy_bookmarks_add_keyword + (eb, word); + } + + ephy_bookmarks_set_keyword (eb, keyword, node); + } + g_list_free (diffs); + + diffs = diff_keywords (old_ks, ks); + for (l = diffs; l != NULL; l = l->next) + { + keyword = ephy_bookmarks_find_keyword (eb, + (char *)l->data, FALSE); + g_return_if_fail (keyword != NULL); + + ephy_bookmarks_unset_keyword (eb, keyword, node); + } + g_list_free (diffs); + + g_strfreev (ks); + g_strfreev (old_ks); +} + +EphyNode * +ephy_bookmarks_get_keywords (EphyBookmarks *eb) +{ + return eb->priv->keywords; +} + +EphyNode * +ephy_bookmarks_get_bookmarks (EphyBookmarks *eb) +{ + return eb->priv->bookmarks; +} + +EphyNode * +ephy_bookmarks_get_favorites (EphyBookmarks *eb) +{ + return eb->priv->favorites; +} + diff --git a/src/bookmarks/ephy-bookmarks.h b/src/bookmarks/ephy-bookmarks.h new file mode 100644 index 000000000..e355950c4 --- /dev/null +++ b/src/bookmarks/ephy-bookmarks.h @@ -0,0 +1,108 @@ +/* + * Copyright (C) 2000, 2001, 2002 Marco Pesenti Gritti + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef EPHY_BOOKMARKS_H +#define EPHY_BOOKMARKS_H + +#include <glib-object.h> + +#include "ephy-node.h" + +G_BEGIN_DECLS + +typedef struct EphyBookmarksClass EphyBookmarksClass; + +#define EPHY_BOOKMARKS_TYPE (ephy_bookmarks_get_type ()) +#define EPHY_BOOKMARKS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), EPHY_BOOKMARKS_TYPE, EphyBookmarks)) +#define EPHY_BOOKMARKS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), EPHY_BOOKMARKS_TYPE, EphyBookmarksClass)) +#define IS_EPHY_BOOKMARKS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EPHY_BOOKMARKS_TYPE)) +#define IS_EPHY_BOOKMARKS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), EPHY_BOOKMARKS_TYPE)) + +typedef struct EphyBookmarks EphyBookmarks; +typedef struct EphyBookmarksPrivate EphyBookmarksPrivate; + +enum +{ + EPHY_NODE_BMK_PROP_TITLE = 2, + EPHY_NODE_BMK_PROP_LOCATION = 3, + EPHY_NODE_BMK_PROP_KEYWORDS = 4, + EPHY_NODE_KEYWORD_PROP_NAME = 5, + EPHY_NODE_BMK_PROP_SMART_LOCATION = 6 +}; + +struct EphyBookmarks +{ + GObject parent; + EphyBookmarksPrivate *priv; +}; + +struct EphyBookmarksClass +{ + GObjectClass parent_class; +}; + +GType ephy_bookmarks_get_type (void); + +EphyBookmarks *ephy_bookmarks_new (void); + +/* Bookmarks */ + +EphyNode *ephy_bookmarks_add (EphyBookmarks *eb, + const char *title, + const char *url, + const char *smart_url, + const char *keywords); + +char *ephy_bookmarks_solve_smart_url (EphyBookmarks *eb, + const char *smart_url, + const char *content); + +/* Keywords */ + +EphyNode *ephy_bookmarks_add_keyword (EphyBookmarks *eb, + const char *name); + +EphyNode *ephy_bookmarks_find_keyword (EphyBookmarks *eb, + const char *name, + gboolean partial_match); + +void ephy_bookmarks_set_keyword (EphyBookmarks *eb, + EphyNode *keyword, + EphyNode *bookmark); + +void ephy_bookmarks_unset_keyword (EphyBookmarks *eb, + EphyNode *keyword, + EphyNode *bookmark); + +void ephy_bookmarks_update_keywords (EphyBookmarks *eb, + const char *keywords, + EphyNode *bookmark_node); + +/* Favorites */ + +EphyNode *ephy_bookmarks_get_favorites (EphyBookmarks *eb); + +/* Root */ + +EphyNode *ephy_bookmarks_get_keywords (EphyBookmarks *eb); + +EphyNode *ephy_bookmarks_get_bookmarks (EphyBookmarks *eb); + +G_END_DECLS + +#endif diff --git a/src/bookmarks/ephy-keywords-entry.c b/src/bookmarks/ephy-keywords-entry.c new file mode 100644 index 000000000..94d6c93a9 --- /dev/null +++ b/src/bookmarks/ephy-keywords-entry.c @@ -0,0 +1,286 @@ +/* + * Copyright (C) 2002 Marco Pesenti Gritti + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include "ephy-keywords-entry.h" +#include "ephy-marshal.h" +#include "ephy-gobject-misc.h" + +#include <gdk/gdkkeysyms.h> + +//#define DEBUG_MSG(x) g_print x +#define DEBUG_MSG(x) + +#define NOT_IMPLEMENTED g_warning ("not implemented: " G_STRLOC); + +/** + * Private data + */ +struct _EphyKeywordsEntryPrivate +{ + EphyBookmarks *bookmarks; +}; + +/** + * Private functions, only availble from this file + */ +static void ephy_keywords_entry_class_init (EphyKeywordsEntryClass *klass); +static void ephy_keywords_entry_init (EphyKeywordsEntry *w); +static void ephy_keywords_entry_finalize_impl (GObject *o); +static gint ephy_keywords_entry_key_press (GtkWidget *widget, + GdkEventKey *event); + +enum +{ + KEYWORDS_CHANGED, + LAST_SIGNAL +}; + +static GObjectClass *parent_class = NULL; + +static guint keywords_entry_signals[LAST_SIGNAL] = { 0 }; + +MAKE_GET_TYPE (ephy_keywords_entry, "EphyKeywordsEntry", EphyKeywordsEntry, + ephy_keywords_entry_class_init, + ephy_keywords_entry_init, GTK_TYPE_ENTRY); + +static void +ephy_keywords_entry_class_init (EphyKeywordsEntryClass *class) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (class); + GtkWidgetClass *widget_class; + + parent_class = g_type_class_peek_parent (class); + widget_class = (GtkWidgetClass*) class; + + gobject_class->finalize = ephy_keywords_entry_finalize_impl; + + widget_class->key_press_event = ephy_keywords_entry_key_press; + + keywords_entry_signals[KEYWORDS_CHANGED] = + g_signal_new ("keywords_changed", + G_OBJECT_CLASS_TYPE (gobject_class), + G_SIGNAL_RUN_FIRST, + G_STRUCT_OFFSET (EphyKeywordsEntryClass, keywords_changed), + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); +} + +static void +try_to_expand_keyword (GtkEditable *editable) +{ + char *entry_text; + char *user_text; + const char *expand_text; + char *insert_text; + int user_text_length; + int expand_text_length; + int keyword_offset = 0; + int tmp; + EphyKeywordsEntry *entry = EPHY_KEYWORDS_ENTRY (editable); + EphyNode *node; + + entry_text = gtk_editable_get_chars (editable, 0, -1); + g_return_if_fail (entry_text != NULL); + + DEBUG_MSG (("Entry text \"%s\"\n", entry_text)); + + user_text = g_utf8_strrchr (entry_text, -1, ' '); + + if (user_text) + { + user_text = g_utf8_find_next_char (user_text, NULL); + keyword_offset = g_utf8_pointer_to_offset + (entry_text, user_text); + } + else + { + user_text = entry_text; + } + + DEBUG_MSG (("User text \"%s\"\n", user_text)); + + node = ephy_bookmarks_find_keyword (entry->priv->bookmarks, + user_text, TRUE); + if (node) + { + expand_text = ephy_node_get_property_string + (node, EPHY_NODE_KEYWORD_PROP_NAME); + + DEBUG_MSG (("Expand text %s\n", expand_text)); + + expand_text_length = g_utf8_strlen (expand_text, -1); + user_text_length = g_utf8_strlen (user_text, -1); + + insert_text = g_utf8_offset_to_pointer (expand_text, user_text_length); + gtk_editable_insert_text (editable, + insert_text, + g_utf8_strlen (insert_text, -1), + &tmp); + gtk_editable_select_region (editable, user_text_length + keyword_offset, -1); + } + else + { + DEBUG_MSG (("No expansion.\n")); + } + + g_free (entry_text); +} + +/* Until we have a more elegant solution, this is how we figure out if + * the GtkEntry inserted characters, assuming that the return value is + * TRUE indicating that the GtkEntry consumed the key event for some + * reason. This is a clone of code from GtkEntry. + */ +static gboolean +entry_would_have_inserted_characters (const GdkEventKey *event) +{ + switch (event->keyval) { + case GDK_BackSpace: + case GDK_Clear: + case GDK_Insert: + case GDK_Delete: + case GDK_Home: + case GDK_End: + case GDK_Left: + case GDK_Right: + case GDK_Return: + return FALSE; + default: + if (event->keyval >= 0x20 && event->keyval <= 0xFF) { + if ((event->state & GDK_CONTROL_MASK) != 0) { + return FALSE; + } + if ((event->state & GDK_MOD1_MASK) != 0) { + return FALSE; + } + } + return event->length > 0; + } +} + +static int +get_editable_number_of_chars (GtkEditable *editable) +{ + char *text; + int length; + + text = gtk_editable_get_chars (editable, 0, -1); + length = g_utf8_strlen (text, -1); + g_free (text); + return length; +} + +static void +set_position_and_selection_to_end (GtkEditable *editable) +{ + int end; + + end = get_editable_number_of_chars (editable); + gtk_editable_select_region (editable, end, end); + gtk_editable_set_position (editable, end); +} + +static gboolean +position_and_selection_are_at_end (GtkEditable *editable) +{ + int end; + int start_sel, end_sel; + + end = get_editable_number_of_chars (editable); + if (gtk_editable_get_selection_bounds (editable, &start_sel, &end_sel)) + { + if (start_sel != end || end_sel != end) + { + return FALSE; + } + } + return gtk_editable_get_position (editable) == end; +} + +static gint +ephy_keywords_entry_key_press (GtkWidget *widget, + GdkEventKey *event) +{ + GtkEditable *editable; + GdkEventKey *keyevent; + EphyKeywordsEntry *entry; + gboolean result; + + entry = EPHY_KEYWORDS_ENTRY (widget); + editable = GTK_EDITABLE (entry); + keyevent = (GdkEventKey *)event; + + /* After typing the right arrow key we move the selection to + * the end, if we have a valid selection - since this is most + * likely an auto-completion. We ignore shift / control since + * they can validly be used to extend the selection. + */ + if ((keyevent->keyval == GDK_Right || keyevent->keyval == GDK_End) && + !(keyevent->state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK)) && + gtk_editable_get_selection_bounds (editable, NULL, NULL)) + { + set_position_and_selection_to_end (editable); + } + + result = GTK_WIDGET_CLASS (parent_class)->key_press_event (widget, event); + + /* Only do expanding when we are typing at the end of the + * text. + */ + if (entry_would_have_inserted_characters (event) + && position_and_selection_are_at_end (editable)) + { + try_to_expand_keyword (editable); + } + + g_signal_emit (G_OBJECT (entry), keywords_entry_signals[KEYWORDS_CHANGED], 0); + + return result; +} + +static void +ephy_keywords_entry_init (EphyKeywordsEntry *w) +{ + w->priv = g_new0 (EphyKeywordsEntryPrivate, 1); + w->priv->bookmarks = NULL; +} + +static void +ephy_keywords_entry_finalize_impl (GObject *o) +{ + EphyKeywordsEntry *w = EPHY_KEYWORDS_ENTRY (o); + EphyKeywordsEntryPrivate *p = w->priv; + + g_free (p); + G_OBJECT_CLASS (parent_class)->finalize (o); +} + +GtkWidget * +ephy_keywords_entry_new (void) +{ + return GTK_WIDGET (g_object_new (EPHY_TYPE_LOCATION_ENTRY, NULL)); +} + +void +ephy_keywords_entry_set_bookmarks (EphyKeywordsEntry *w, + EphyBookmarks *bookmarks) +{ + w->priv->bookmarks = bookmarks; +} diff --git a/src/bookmarks/ephy-keywords-entry.h b/src/bookmarks/ephy-keywords-entry.h new file mode 100644 index 000000000..5ab5df257 --- /dev/null +++ b/src/bookmarks/ephy-keywords-entry.h @@ -0,0 +1,68 @@ +/* + * Copyright (C) 2002 Ricardo Fernández Pascual + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef EPHY_KEYWORDS_ENTRY_H +#define EPHY_KEYWORDS_ENTRY_H + +#include "ephy-bookmarks.h" + +#include <glib-object.h> +#include <gtk/gtkentry.h> + +/* object forward declarations */ + +typedef struct _EphyKeywordsEntry EphyKeywordsEntry; +typedef struct _EphyKeywordsEntryClass EphyKeywordsEntryClass; +typedef struct _EphyKeywordsEntryPrivate EphyKeywordsEntryPrivate; + +/** + * EphyFolderTbWidget object + */ + +#define EPHY_TYPE_LOCATION_ENTRY (ephy_keywords_entry_get_type()) +#define EPHY_KEYWORDS_ENTRY(object) (G_TYPE_CHECK_INSTANCE_CAST((object), EPHY_TYPE_LOCATION_ENTRY,\ + EphyKeywordsEntry)) +#define EPHY_KEYWORDS_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), EPHY_TYPE_LOCATION_ENTRY,\ + EphyKeywordsEntryClass)) +#define EPHY_IS_LOCATION_ENTRY(object) (G_TYPE_CHECK_INSTANCE_TYPE((object), EPHY_TYPE_LOCATION_ENTRY)) +#define EPHY_IS_LOCATION_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), EPHY_TYPE_LOCATION_ENTRY)) +#define EPHY_KEYWORDS_ENTRY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), EPHY_TYPE_LOCATION_ENTRY,\ + EphyKeywordsEntryClass)) + +struct _EphyKeywordsEntryClass +{ + GtkEntryClass parent_class; + + void (* keywords_changed) (EphyKeywordsEntry *entry); +}; + +struct _EphyKeywordsEntry +{ + GtkEntry parent_object; + + EphyKeywordsEntryPrivate *priv; +}; + +GType ephy_keywords_entry_get_type (void); + +GtkWidget *ephy_keywords_entry_new (void); + +void ephy_keywords_entry_set_bookmarks (EphyKeywordsEntry *w, + EphyBookmarks *bookmarks); + +#endif diff --git a/src/bookmarks/ephy-new-bookmark.c b/src/bookmarks/ephy-new-bookmark.c new file mode 100644 index 000000000..ee0d4b983 --- /dev/null +++ b/src/bookmarks/ephy-new-bookmark.c @@ -0,0 +1,340 @@ +/* + * Copyright (C) 2002 Jorn Baayen <jorn@nl.linux.org> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + */ + +#include <gtk/gtktable.h> +#include <gtk/gtklabel.h> +#include <gtk/gtkentry.h> +#include <gtk/gtkhbox.h> +#include <gtk/gtkvbox.h> +#include <gtk/gtkstock.h> +#include <gtk/gtkeditable.h> +#include <libgnome/gnome-i18n.h> + +#include "ephy-new-bookmark.h" +#include "ephy-keywords-entry.h" + +//#define DEBUG_MSG(x) g_print x +#define DEBUG_MSG(x) + +static void ephy_new_bookmark_class_init (EphyNewBookmarkClass *klass); +static void ephy_new_bookmark_init (EphyNewBookmark *editor); +static void ephy_new_bookmark_finalize (GObject *object); +static void ephy_new_bookmark_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec); +static void ephy_new_bookmark_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec); + +struct EphyNewBookmarkPrivate +{ + EphyBookmarks *bookmarks; + char *location; + char *smarturl; + + GtkWidget *title_entry; + GtkWidget *keywords_entry; +}; + +enum +{ + PROP_0, + PROP_BOOKMARKS, + PROP_LOCATION +}; + +static GObjectClass *parent_class = NULL; + +GType +ephy_new_bookmark_get_type (void) +{ + static GType ephy_new_bookmark_type = 0; + + if (ephy_new_bookmark_type == 0) + { + static const GTypeInfo our_info = + { + sizeof (EphyNewBookmarkClass), + NULL, + NULL, + (GClassInitFunc) ephy_new_bookmark_class_init, + NULL, + NULL, + sizeof (EphyNewBookmark), + 0, + (GInstanceInitFunc) ephy_new_bookmark_init + }; + + ephy_new_bookmark_type = g_type_register_static (GTK_TYPE_DIALOG, + "EphyNewBookmark", + &our_info, 0); + } + + return ephy_new_bookmark_type; +} + +static void +ephy_new_bookmark_class_init (EphyNewBookmarkClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + object_class->finalize = ephy_new_bookmark_finalize; + + object_class->set_property = ephy_new_bookmark_set_property; + object_class->get_property = ephy_new_bookmark_get_property; + + g_object_class_install_property (object_class, + PROP_BOOKMARKS, + g_param_spec_object ("bookmarks", + "Bookmarks set", + "Bookmarks set", + EPHY_BOOKMARKS_TYPE, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); + g_object_class_install_property (object_class, + PROP_LOCATION, + g_param_spec_string ("location", + "Bookmark location", + "Bookmark location", + "", + G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); +} + +static void +ephy_new_bookmark_finalize (GObject *object) +{ + EphyNewBookmark *editor; + + g_return_if_fail (object != NULL); + g_return_if_fail (EPHY_IS_NEW_BOOKMARK (object)); + + editor = EPHY_NEW_BOOKMARK (object); + + g_return_if_fail (editor->priv != NULL); + + g_free (editor->priv->location); + g_free (editor->priv->smarturl); + + g_free (editor->priv); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static void +ephy_new_bookmark_add (EphyNewBookmark *new_bookmark) +{ + char *title; + char *keywords; + + title = gtk_editable_get_chars + (GTK_EDITABLE (new_bookmark->priv->title_entry), 0, -1); + keywords = gtk_editable_get_chars + (GTK_EDITABLE (new_bookmark->priv->keywords_entry), 0, -1); + ephy_bookmarks_add (new_bookmark->priv->bookmarks, title, + new_bookmark->priv->location, + new_bookmark->priv->smarturl, keywords); +} + +static void +ephy_new_bookmark_response_cb (GtkDialog *dialog, + int response_id, + EphyNewBookmark *new_bookmark) +{ + switch (response_id) + { + case GTK_RESPONSE_CANCEL: + break; + case GTK_RESPONSE_OK: + ephy_new_bookmark_add (new_bookmark); + break; + } + + gtk_widget_destroy (GTK_WIDGET (dialog)); +} + +static GtkWidget * +build_editing_table (EphyNewBookmark *editor) +{ + GtkWidget *table, *label, *entry; + + table = gtk_table_new (2, 2, FALSE); + gtk_table_set_row_spacings (GTK_TABLE (table), 6); + gtk_table_set_col_spacings (GTK_TABLE (table), 6); + gtk_widget_show (table); + + label = gtk_label_new (NULL); + gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); + gtk_label_set_markup (GTK_LABEL (label), _("<b>Title:</b>")); + gtk_widget_show (label); + entry = gtk_entry_new (); + editor->priv->title_entry = entry; + gtk_widget_set_size_request (entry, 200, -1); + gtk_widget_show (entry); + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, GTK_FILL, 0, 0, 0); + gtk_table_attach_defaults (GTK_TABLE (table), entry, 1, 2, 0, 1); + + label = gtk_label_new (NULL); + gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); + gtk_label_set_markup (GTK_LABEL (label), _("<b>Keywords:</b>")); + gtk_widget_show (label); + entry = ephy_keywords_entry_new (); + ephy_keywords_entry_set_bookmarks (EPHY_KEYWORDS_ENTRY (entry), + editor->priv->bookmarks); + editor->priv->keywords_entry = entry; + gtk_widget_show (entry); + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, GTK_FILL, 0, 0, 0); + gtk_table_attach_defaults (GTK_TABLE (table), entry, 1, 2, 1, 2); + + return table; +} + +static void +ephy_new_bookmark_construct (EphyNewBookmark *editor) +{ + GtkWidget *hbox, *vbox; + + gtk_window_set_title (GTK_WINDOW (editor), + _("Add bookmark")); + + gtk_dialog_set_has_separator (GTK_DIALOG (editor), FALSE); + gtk_container_set_border_width (GTK_CONTAINER (editor), 6); + g_signal_connect (G_OBJECT (editor), + "response", + G_CALLBACK (ephy_new_bookmark_response_cb), + editor); + + hbox = gtk_hbox_new (FALSE, 6); + gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (editor)->vbox), 12); + gtk_box_pack_start (GTK_BOX (GTK_DIALOG (editor)->vbox), + hbox, TRUE, TRUE, 0); + gtk_widget_show (hbox); + + vbox = gtk_vbox_new (FALSE, 6); + gtk_box_pack_start (GTK_BOX (hbox), + vbox, TRUE, TRUE, 0); + gtk_widget_show (vbox); + + gtk_box_pack_start (GTK_BOX (vbox), + build_editing_table (editor), + FALSE, FALSE, 0); + + gtk_dialog_add_button (GTK_DIALOG (editor), + GTK_STOCK_CANCEL, + GTK_RESPONSE_CANCEL); + gtk_dialog_add_button (GTK_DIALOG (editor), + GTK_STOCK_OK, + GTK_RESPONSE_OK); + gtk_dialog_set_default_response (GTK_DIALOG (editor), GTK_RESPONSE_OK); +} + +GtkWidget * +ephy_new_bookmark_new (EphyBookmarks *bookmarks, + GtkWindow *parent, + const char *location) +{ + EphyNewBookmark *editor; + + g_assert (bookmarks != NULL); + + editor = EPHY_NEW_BOOKMARK (g_object_new + (EPHY_TYPE_NEW_BOOKMARK, + "bookmarks", bookmarks, + "location", location, + NULL)); + + if (parent) + { + gtk_window_set_transient_for (GTK_WINDOW (editor), parent); + } + + ephy_new_bookmark_construct (editor); + + return GTK_WIDGET (editor); +} + +static void +ephy_new_bookmark_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + EphyNewBookmark *editor = EPHY_NEW_BOOKMARK (object); + + switch (prop_id) + { + case PROP_BOOKMARKS: + editor->priv->bookmarks = g_value_get_object (value); + break; + case PROP_LOCATION: + g_free (editor->priv->location); + editor->priv->location = g_strdup (g_value_get_string (value)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +ephy_new_bookmark_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + EphyNewBookmark *editor = EPHY_NEW_BOOKMARK (object); + + switch (prop_id) + { + case PROP_LOCATION: + g_value_set_string (value, editor->priv->location); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +ephy_new_bookmark_init (EphyNewBookmark *editor) +{ + editor->priv = g_new0 (EphyNewBookmarkPrivate, 1); + editor->priv->location = NULL; + editor->priv->smarturl = NULL; +} + +void +ephy_new_bookmark_set_title (EphyNewBookmark *bookmark, + const char *title) +{ + DEBUG_MSG (("Setting new bookmark title to: \"%s\"", title)); + gtk_entry_set_text (GTK_ENTRY (bookmark->priv->title_entry), + g_strdup (title)); +} + +void +ephy_new_bookmark_set_smarturl (EphyNewBookmark *bookmark, + const char *url) +{ + g_free (bookmark->priv->smarturl); + bookmark->priv->smarturl = g_strdup (url); +} + diff --git a/src/bookmarks/ephy-new-bookmark.h b/src/bookmarks/ephy-new-bookmark.h new file mode 100644 index 000000000..7e1091f50 --- /dev/null +++ b/src/bookmarks/ephy-new-bookmark.h @@ -0,0 +1,65 @@ +/* + * Copyright (C) 2002 Jorn Baayen <jorn@nl.linux.org> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * $Id$ + */ + +#ifndef EPHY_NEW_BOOKMARK_H +#define EPHY_NEW_BOOKMARK_H + +#include <gtk/gtkdialog.h> + +#include "ephy-bookmarks.h" + +G_BEGIN_DECLS + +#define EPHY_TYPE_NEW_BOOKMARK (ephy_new_bookmark_get_type ()) +#define EPHY_NEW_BOOKMARK(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), EPHY_TYPE_NEW_BOOKMARK, EphyNewBookmark)) +#define EPHY_NEW_BOOKMARK_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), EPHY_TYPE_NEW_BOOKMARK, EphyNewBookmarkClass)) +#define EPHY_IS_NEW_BOOKMARK(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), EPHY_TYPE_NEW_BOOKMARK)) +#define EPHY_IS_NEW_BOOKMARK_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), EPHY_TYPE_NEW_BOOKMARK)) +#define EPHY_NEW_BOOKMARK_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), EPHY_TYPE_NEW_BOOKMARK, EphyNewBookmarkClass)) + +typedef struct EphyNewBookmarkPrivate EphyNewBookmarkPrivate; + +typedef struct +{ + GtkDialog parent; + + EphyNewBookmarkPrivate *priv; +} EphyNewBookmark; + +typedef struct +{ + GtkDialogClass parent; +} EphyNewBookmarkClass; + +GType ephy_new_bookmark_get_type (void); + +GtkWidget *ephy_new_bookmark_new (EphyBookmarks *bookmarks, + GtkWindow *parent, + const char *location); + +void ephy_new_bookmark_set_title (EphyNewBookmark *bookmark, + const char *title); + +void ephy_new_bookmark_set_smarturl (EphyNewBookmark *bookmark, + const char *url); + +G_END_DECLS + +#endif /* EPHY_NEW_BOOKMARK_H */ diff --git a/src/bookmarks/ephy-node-view.c b/src/bookmarks/ephy-node-view.c new file mode 100644 index 000000000..f537855d8 --- /dev/null +++ b/src/bookmarks/ephy-node-view.c @@ -0,0 +1,531 @@ +/* + * Copyright (C) 2002 Jorn Baayen <jorn@nl.linux.org> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + */ + +#include <gtk/gtktreeview.h> +#include <gtk/gtktreeselection.h> +#include <gtk/gtktreeviewcolumn.h> +#include <gtk/gtkcellrenderertext.h> +#include <libgnome/gnome-i18n.h> + +#include "eggtreemodelfilter.h" +#include "ephy-tree-model-node.h" +#include "ephy-node-view.h" +#include "ephy-tree-model-sort.h" +#include "eggtreemultidnd.h" +#include "ephy-dnd.h" + +static void ephy_node_view_class_init (EphyNodeViewClass *klass); +static void ephy_node_view_init (EphyNodeView *view); +static void ephy_node_view_finalize (GObject *object); +static void ephy_node_view_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec); +static void ephy_node_view_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec); + +struct EphyNodeViewPrivate +{ + EphyNode *root; + + EphyTreeModelNode *nodemodel; + GtkTreeModel *filtermodel; + GtkTreeModel *sortmodel; + + EphyNodeFilter *filter; + + GtkWidget *treeview; +}; + +enum +{ + NODE_ACTIVATED, + NODE_SELECTED, + SHOW_POPUP, + LAST_SIGNAL +}; + +enum +{ + PROP_0, + PROP_ROOT, + PROP_FILTER +}; + +static GObjectClass *parent_class = NULL; + +static guint ephy_node_view_signals[LAST_SIGNAL] = { 0 }; + +GType +ephy_node_view_get_type (void) +{ + static GType ephy_node_view_type = 0; + + if (ephy_node_view_type == 0) + { + static const GTypeInfo our_info = + { + sizeof (EphyNodeViewClass), + NULL, + NULL, + (GClassInitFunc) ephy_node_view_class_init, + NULL, + NULL, + sizeof (EphyNodeView), + 0, + (GInstanceInitFunc) ephy_node_view_init + }; + + ephy_node_view_type = g_type_register_static (GTK_TYPE_SCROLLED_WINDOW, + "EphyNodeView", + &our_info, 0); + } + + return ephy_node_view_type; +} + +static void +ephy_node_view_class_init (EphyNodeViewClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + object_class->finalize = ephy_node_view_finalize; + + object_class->set_property = ephy_node_view_set_property; + object_class->get_property = ephy_node_view_get_property; + + g_object_class_install_property (object_class, + PROP_ROOT, + g_param_spec_object ("root", + "Root node", + "Root node", + EPHY_TYPE_NODE, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); + g_object_class_install_property (object_class, + PROP_FILTER, + g_param_spec_object ("filter", + "Filter object", + "Filter object", + EPHY_TYPE_NODE_FILTER, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); + + ephy_node_view_signals[NODE_ACTIVATED] = + g_signal_new ("node_activated", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (EphyNodeViewClass, node_activated), + NULL, NULL, + g_cclosure_marshal_VOID__OBJECT, + G_TYPE_NONE, + 1, + EPHY_TYPE_NODE); + ephy_node_view_signals[NODE_SELECTED] = + g_signal_new ("node_selected", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (EphyNodeViewClass, node_selected), + NULL, NULL, + g_cclosure_marshal_VOID__OBJECT, + G_TYPE_NONE, + 1, + EPHY_TYPE_NODE); + ephy_node_view_signals[SHOW_POPUP] = + g_signal_new ("show_popup", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (EphyNodeViewClass, show_popup), + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); +} + +static void +ephy_node_view_finalize (GObject *object) +{ + EphyNodeView *view; + + g_return_if_fail (object != NULL); + g_return_if_fail (EPHY_IS_NODE_VIEW (object)); + + view = EPHY_NODE_VIEW (object); + + g_return_if_fail (view->priv != NULL); + + g_object_unref (G_OBJECT (view->priv->sortmodel)); + g_object_unref (G_OBJECT (view->priv->filtermodel)); + g_object_unref (G_OBJECT (view->priv->nodemodel)); + + g_free (view->priv); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static void +filter_changed_cb (EphyNodeFilter *filter, + EphyNodeView *view) +{ + GtkWidget *window; + + g_return_if_fail (EPHY_IS_NODE_VIEW (view)); + + window = gtk_widget_get_toplevel (GTK_WIDGET (view)); + + if (window != NULL && window->window != NULL) + { + /* nice busy cursor */ + GdkCursor *cursor; + + cursor = gdk_cursor_new (GDK_WATCH); + gdk_window_set_cursor (window->window, cursor); + gdk_cursor_unref (cursor); + + gdk_flush (); + + gdk_window_set_cursor (window->window, NULL); + + /* no flush: this will cause the cursor to be reset + * only when the UI is free again */ + } +} + +static void +ephy_node_view_selection_changed_cb (GtkTreeSelection *selection, + EphyNodeView *view) +{ + GList *list; + EphyNode *node = NULL; + + list = ephy_node_view_get_selection (view); + if (list) + { + node = EPHY_NODE (list->data); + } + g_list_free (list); + + g_signal_emit (G_OBJECT (view), ephy_node_view_signals[NODE_SELECTED], 0, node); +} + +static void +ephy_node_view_row_activated_cb (GtkTreeView *treeview, + GtkTreePath *path, + GtkTreeViewColumn *column, + EphyNodeView *view) +{ + GtkTreeIter iter, iter2; + EphyNode *node; + + gtk_tree_model_get_iter (view->priv->sortmodel, &iter, path); + gtk_tree_model_sort_convert_iter_to_child_iter + (GTK_TREE_MODEL_SORT (view->priv->sortmodel), &iter2, &iter); + egg_tree_model_filter_convert_iter_to_child_iter + (EGG_TREE_MODEL_FILTER (view->priv->filtermodel), &iter, &iter2); + + node = ephy_tree_model_node_node_from_iter (view->priv->nodemodel, &iter); + + g_signal_emit (G_OBJECT (view), ephy_node_view_signals[NODE_ACTIVATED], 0, node); +} + +static gboolean +ephy_node_view_button_press_cb (GtkTreeView *treeview, + GdkEventButton *event, + EphyNodeView *view) +{ + if (event->button == 3) + { + g_signal_emit (G_OBJECT (view), ephy_node_view_signals[SHOW_POPUP], 0); + } + + return FALSE; +} + +static void +ephy_node_view_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + EphyNodeView *view = EPHY_NODE_VIEW (object); + + switch (prop_id) + { + case PROP_ROOT: + view->priv->root = g_value_get_object (value); + break; + case PROP_FILTER: + view->priv->filter = g_value_get_object (value); + + if (view->priv->filter != NULL) + { + g_signal_connect_object (G_OBJECT (view->priv->filter), + "changed", + G_CALLBACK (filter_changed_cb), + G_OBJECT (view), + 0); + } + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +ephy_node_view_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + EphyNodeView *view = EPHY_NODE_VIEW (object); + + switch (prop_id) + { + case PROP_ROOT: + g_value_set_object (value, view->priv->root); + break; + case PROP_FILTER: + g_value_set_object (value, view->priv->filter); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +node_from_sort_iter_cb (EphyTreeModelSort *model, + GtkTreeIter *iter, + void **node, + EphyNodeView *view) +{ + GtkTreeIter filter_iter, node_iter; + + gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (model), + &filter_iter, iter); + egg_tree_model_filter_convert_iter_to_child_iter (EGG_TREE_MODEL_FILTER (view->priv->filtermodel), + &node_iter, &filter_iter); + *node = ephy_tree_model_node_node_from_iter + (EPHY_TREE_MODEL_NODE (view->priv->nodemodel), &node_iter); +} + +static void +ephy_node_view_construct (EphyNodeView *view) +{ + GtkTreeSelection *selection; + + + view->priv->nodemodel = ephy_tree_model_node_new (view->priv->root, + view->priv->filter); + view->priv->filtermodel = egg_tree_model_filter_new (GTK_TREE_MODEL (view->priv->nodemodel), + NULL); + egg_tree_model_filter_set_visible_column (EGG_TREE_MODEL_FILTER (view->priv->filtermodel), + EPHY_TREE_MODEL_NODE_COL_VISIBLE); + view->priv->sortmodel = ephy_tree_model_sort_new (view->priv->filtermodel); + g_signal_connect_object (G_OBJECT (view->priv->sortmodel), + "node_from_iter", + G_CALLBACK (node_from_sort_iter_cb), + view, + 0); + view->priv->treeview = gtk_tree_view_new_with_model + (GTK_TREE_MODEL (view->priv->sortmodel)); + gtk_widget_show (view->priv->treeview); + g_signal_connect_object (G_OBJECT (view->priv->treeview), + "button_press_event", + G_CALLBACK (ephy_node_view_button_press_cb), + view, + 0); + g_signal_connect_object (G_OBJECT (view->priv->treeview), + "row_activated", + G_CALLBACK (ephy_node_view_row_activated_cb), + view, + 0); + + selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (view->priv->treeview)); + gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE); + g_signal_connect_object (G_OBJECT (selection), + "changed", + G_CALLBACK (ephy_node_view_selection_changed_cb), + view, + 0); + + gtk_container_add (GTK_CONTAINER (view), view->priv->treeview); +} + +EphyNodeView * +ephy_node_view_new (EphyNode *root, + EphyNodeFilter *filter) +{ + EphyNodeView *view; + + view = EPHY_NODE_VIEW (g_object_new (EPHY_TYPE_NODE_VIEW, + "filter", filter, + "hadjustment", NULL, + "vadjustment", NULL, + "hscrollbar_policy", GTK_POLICY_AUTOMATIC, + "vscrollbar_policy", GTK_POLICY_AUTOMATIC, + "shadow_type", GTK_SHADOW_IN, + "root", root, + NULL)); + + ephy_node_view_construct (view); + + g_return_val_if_fail (view->priv != NULL, NULL); + + return view; +} + +void +ephy_node_view_add_column (EphyNodeView *view, + const char *title, + EphyTreeModelNodeColumn column, + gboolean sortable) +{ + GtkTreeViewColumn *gcolumn; + GtkCellRenderer *renderer; + + gcolumn = (GtkTreeViewColumn *) gtk_tree_view_column_new (); + renderer = gtk_cell_renderer_text_new (); + gtk_tree_view_column_pack_start (gcolumn, renderer, TRUE); + gtk_tree_view_column_set_attributes (gcolumn, renderer, + "text", column, + NULL); + gtk_tree_view_column_set_sizing (gcolumn, + GTK_TREE_VIEW_COLUMN_AUTOSIZE); + gtk_tree_view_column_set_title (gcolumn, title); + gtk_tree_view_append_column (GTK_TREE_VIEW (view->priv->treeview), + gcolumn); + if (sortable) + { + gtk_tree_view_column_set_sort_column_id (gcolumn, column); + } +} + +static void +ephy_node_view_init (EphyNodeView *view) +{ + view->priv = g_new0 (EphyNodeViewPrivate, 1); +} + +static void +get_selection (GtkTreeModel *model, + GtkTreePath *path, + GtkTreeIter *iter, + void **data) +{ + GtkTreeModelSort *sortmodel = GTK_TREE_MODEL_SORT (model); + EggTreeModelFilter *filtermodel = EGG_TREE_MODEL_FILTER (sortmodel->child_model); + EphyTreeModelNode *nodemodel = EPHY_TREE_MODEL_NODE (filtermodel->child_model); + GList **list = (GList **) data; + GtkTreeIter *iter2 = gtk_tree_iter_copy (iter); + GtkTreeIter iter3; + GtkTreeIter iter4; + EphyNode *node; + + gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (model), + &iter3, iter2); + egg_tree_model_filter_convert_iter_to_child_iter (filtermodel, &iter4, &iter3); + + node = ephy_tree_model_node_node_from_iter (nodemodel, &iter4); + + gtk_tree_iter_free (iter2); + + *list = g_list_prepend (*list, node); +} + +GList * +ephy_node_view_get_selection (EphyNodeView *view) +{ + GList *list = NULL; + GtkTreeSelection *selection; + + selection = gtk_tree_view_get_selection + (GTK_TREE_VIEW (view->priv->treeview)); + + gtk_tree_selection_selected_foreach (selection, + (GtkTreeSelectionForeachFunc) get_selection, + (void **) &list); + + return list; +} + +void +ephy_node_view_remove (EphyNodeView *view) +{ + GList *list; + + list = ephy_node_view_get_selection (view); + + for (; list != NULL; list = list->next) + { + ephy_node_unref (EPHY_NODE (list->data)); + } + + g_list_free (list); +} + +void +ephy_node_view_set_browse_mode (EphyNodeView *view) +{ + GtkTreeSelection *selection; + + selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (view->priv->treeview)); + gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE); +} + +void +ephy_node_view_select_node (EphyNodeView *view, + EphyNode *node) +{ + GtkTreeIter iter, iter2; + GValue val = { 0, }; + gboolean visible; + GtkTreeSelection *selection; + + selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (view->priv->treeview)); + + g_return_if_fail (node != NULL); + + ephy_tree_model_node_iter_from_node (EPHY_TREE_MODEL_NODE (view->priv->nodemodel), + node, &iter); + gtk_tree_model_get_value (GTK_TREE_MODEL (view->priv->nodemodel), &iter, + EPHY_TREE_MODEL_NODE_COL_VISIBLE, &val); + visible = g_value_get_boolean (&val); + g_value_unset (&val); + if (visible == FALSE) return; + + egg_tree_model_filter_convert_child_iter_to_iter (EGG_TREE_MODEL_FILTER (view->priv->filtermodel), + &iter2, &iter); + gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (view->priv->sortmodel), + &iter, &iter2); + + gtk_tree_selection_select_iter (selection, &iter); +} + +void +ephy_node_view_enable_drag_source (EphyNodeView *view) +{ + g_return_if_fail (view != NULL); + + egg_tree_multi_drag_add_drag_support (GTK_TREE_VIEW (view->priv->treeview)); + ephy_dnd_enable_model_drag_source (GTK_WIDGET (view->priv->treeview)); +} diff --git a/src/bookmarks/ephy-node-view.h b/src/bookmarks/ephy-node-view.h new file mode 100644 index 000000000..71f19d7c7 --- /dev/null +++ b/src/bookmarks/ephy-node-view.h @@ -0,0 +1,82 @@ +/* + * Copyright (C) 2002 Jorn Baayen <jorn@nl.linux.org> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * $Id$ + */ + +#ifndef __EPHY_NODE_VIEW_H +#define __EPHY_NODE_VIEW_H + +#include <gtk/gtkscrolledwindow.h> +#include <gtk/gtkdnd.h> + +#include "ephy-tree-model-node.h" +#include "ephy-node-filter.h" + +G_BEGIN_DECLS + +#define EPHY_TYPE_NODE_VIEW (ephy_node_view_get_type ()) +#define EPHY_NODE_VIEW(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), EPHY_TYPE_NODE_VIEW, EphyNodeView)) +#define EPHY_NODE_VIEW_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), EPHY_TYPE_NODE_VIEW, EphyNodeViewClass)) +#define EPHY_IS_NODE_VIEW(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), EPHY_TYPE_NODE_VIEW)) +#define EPHY_IS_NODE_VIEW_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), EPHY_TYPE_NODE_VIEW)) +#define EPHY_NODE_VIEW_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), EPHY_TYPE_NODE_VIEW, EphyNodeViewClass)) + +typedef struct EphyNodeViewPrivate EphyNodeViewPrivate; + +typedef struct +{ + GtkScrolledWindow parent; + + EphyNodeViewPrivate *priv; +} EphyNodeView; + +typedef struct +{ + GtkScrolledWindowClass parent; + + void (*node_activated) (EphyNodeView *view, EphyNode *node); + void (*node_selected) (EphyNodeView *view, EphyNode *node); + void (*show_popup) (EphyNodeView *view); +} EphyNodeViewClass; + +GType ephy_node_view_get_type (void); + +EphyNodeView *ephy_node_view_new (EphyNode *root, + EphyNodeFilter *filter); + +void ephy_node_view_enable_dnd (EphyNodeView *view); + +void ephy_node_view_add_column (EphyNodeView *view, + const char *title, + EphyTreeModelNodeColumn column, + gboolean sortable); + +void ephy_node_view_remove (EphyNodeView *view); + +GList *ephy_node_view_get_selection (EphyNodeView *view); + +void ephy_node_view_set_browse_mode (EphyNodeView *view); + +void ephy_node_view_select_node (EphyNodeView *view, + EphyNode *node); + +void ephy_node_view_enable_drag_source (EphyNodeView *view); + +G_END_DECLS + +#endif /* EPHY_NODE_VIEW_H */ diff --git a/src/bookmarks/ephy-tree-model-node.c b/src/bookmarks/ephy-tree-model-node.c new file mode 100644 index 000000000..d1030d5da --- /dev/null +++ b/src/bookmarks/ephy-tree-model-node.c @@ -0,0 +1,702 @@ +/* + * Copyright (C) 2002 Jorn Baayen <jorn@nl.linux.org> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * $Id$ + */ + +#include <config.h> +#include <gtk/gtktreeview.h> +#include <gdk-pixbuf/gdk-pixbuf.h> +#include <libgnome/gnome-i18n.h> +#include <time.h> +#include <string.h> + +#include "ephy-node-filter.h" +#include "ephy-bookmarks.h" +#include "ephy-tree-model-node.h" +#include "ephy-stock-icons.h" +#include "ephy-node.h" + +static void ephy_tree_model_node_class_init (EphyTreeModelNodeClass *klass); +static void ephy_tree_model_node_init (EphyTreeModelNode *model); +static void ephy_tree_model_node_finalize (GObject *object); +static void ephy_tree_model_node_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec); +static void ephy_tree_model_node_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec); +static guint ephy_tree_model_node_get_flags (GtkTreeModel *tree_model); +static int ephy_tree_model_node_get_n_columns (GtkTreeModel *tree_model); +static GType ephy_tree_model_node_get_column_type (GtkTreeModel *tree_model, + int index); +static gboolean ephy_tree_model_node_get_iter (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreePath *path); +static GtkTreePath *ephy_tree_model_node_get_path (GtkTreeModel *tree_model, + GtkTreeIter *iter); +static void ephy_tree_model_node_get_value (GtkTreeModel *tree_model, + GtkTreeIter *iter, + int column, + GValue *value); +static gboolean ephy_tree_model_node_iter_next (GtkTreeModel *tree_model, + GtkTreeIter *iter); +static gboolean ephy_tree_model_node_iter_children (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *parent); +static gboolean ephy_tree_model_node_iter_has_child (GtkTreeModel *tree_model, + GtkTreeIter *iter); +static int ephy_tree_model_node_iter_n_children (GtkTreeModel *tree_model, + GtkTreeIter *iter); +static gboolean ephy_tree_model_node_iter_nth_child (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *parent, + int n); +static gboolean ephy_tree_model_node_iter_parent (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *child); +static void ephy_tree_model_node_tree_model_init (GtkTreeModelIface *iface); +static void root_child_removed_cb (EphyNode *node, + EphyNode *child, + EphyTreeModelNode *model); +static void root_child_added_cb (EphyNode *node, + EphyNode *child, + EphyTreeModelNode *model); +static void root_child_changed_cb (EphyNode *node, + EphyNode *child, + EphyTreeModelNode *model); +static inline void ephy_tree_model_node_update_node (EphyTreeModelNode *model, + EphyNode *node, + int idx); +static void root_destroyed_cb (EphyNode *node, + EphyTreeModelNode *model); +static inline GtkTreePath *get_path_real (EphyTreeModelNode *model, + EphyNode *node); + +struct EphyTreeModelNodePrivate +{ + EphyNode *root; + + EphyNodeFilter *filter; +}; + +enum +{ + PROP_0, + PROP_ROOT, + PROP_FILTER +}; + +static GObjectClass *parent_class = NULL; + +GType +ephy_tree_model_node_get_type (void) +{ + static GType ephy_tree_model_node_type = 0; + + if (ephy_tree_model_node_type == 0) + { + static const GTypeInfo our_info = + { + sizeof (EphyTreeModelNodeClass), + NULL, + NULL, + (GClassInitFunc) ephy_tree_model_node_class_init, + NULL, + NULL, + sizeof (EphyTreeModelNode), + 0, + (GInstanceInitFunc) ephy_tree_model_node_init + }; + + static const GInterfaceInfo tree_model_info = + { + (GInterfaceInitFunc) ephy_tree_model_node_tree_model_init, + NULL, + NULL + }; + + ephy_tree_model_node_type = g_type_register_static (G_TYPE_OBJECT, + "EphyTreeModelNode", + &our_info, 0); + + g_type_add_interface_static (ephy_tree_model_node_type, + GTK_TYPE_TREE_MODEL, + &tree_model_info); + } + + return ephy_tree_model_node_type; +} + +static void +ephy_tree_model_node_class_init (EphyTreeModelNodeClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + object_class->finalize = ephy_tree_model_node_finalize; + + object_class->set_property = ephy_tree_model_node_set_property; + object_class->get_property = ephy_tree_model_node_get_property; + + g_object_class_install_property (object_class, + PROP_ROOT, + g_param_spec_object ("root", + "Root node", + "Root node", + EPHY_TYPE_NODE, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); + g_object_class_install_property (object_class, + PROP_FILTER, + g_param_spec_object ("filter", + "Filter object", + "Filter object", + EPHY_TYPE_NODE_FILTER, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); +} + +static void +ephy_tree_model_node_init (EphyTreeModelNode *model) +{ + GtkWidget *dummy; + + do + { + model->stamp = g_random_int (); + } + while (model->stamp == 0); + + model->priv = g_new0 (EphyTreeModelNodePrivate, 1); + + dummy = gtk_tree_view_new (); + + gtk_widget_destroy (dummy); +} + +static void +ephy_tree_model_node_finalize (GObject *object) +{ + EphyTreeModelNode *model; + + g_return_if_fail (object != NULL); + g_return_if_fail (EPHY_IS_TREE_MODEL_NODE (object)); + + model = EPHY_TREE_MODEL_NODE (object); + + g_return_if_fail (model->priv != NULL); + + g_free (model->priv); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static void +filter_changed_cb (EphyNodeFilter *filter, + EphyTreeModelNode *model) +{ + GPtrArray *kids; + int i; + + kids = ephy_node_get_children (model->priv->root); + + for (i = 0; i < kids->len; i++) + { + ephy_tree_model_node_update_node (model, + g_ptr_array_index (kids, i), + i); + } + + ephy_node_thaw (model->priv->root); +} + +static void +ephy_tree_model_node_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + EphyTreeModelNode *model = EPHY_TREE_MODEL_NODE (object); + + switch (prop_id) + { + case PROP_ROOT: + model->priv->root = g_value_get_object (value); + + g_signal_connect_object (G_OBJECT (model->priv->root), + "child_added", + G_CALLBACK (root_child_added_cb), + G_OBJECT (model), + 0); + g_signal_connect_object (G_OBJECT (model->priv->root), + "child_removed", + G_CALLBACK (root_child_removed_cb), + G_OBJECT (model), + 0); + g_signal_connect_object (G_OBJECT (model->priv->root), + "child_changed", + G_CALLBACK (root_child_changed_cb), + G_OBJECT (model), + 0); + g_signal_connect_object (G_OBJECT (model->priv->root), + "destroyed", + G_CALLBACK (root_destroyed_cb), + G_OBJECT (model), + 0); + + break; + case PROP_FILTER: + model->priv->filter = g_value_get_object (value); + + if (model->priv->filter != NULL) + { + g_signal_connect_object (G_OBJECT (model->priv->filter), + "changed", + G_CALLBACK (filter_changed_cb), + G_OBJECT (model), + 0); + } + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +ephy_tree_model_node_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + EphyTreeModelNode *model = EPHY_TREE_MODEL_NODE (object); + + switch (prop_id) + { + case PROP_ROOT: + g_value_set_object (value, model->priv->root); + break; + case PROP_FILTER: + g_value_set_object (value, model->priv->filter); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +EphyTreeModelNode * +ephy_tree_model_node_new (EphyNode *root, + EphyNodeFilter *filter) +{ + EphyTreeModelNode *model; + + model = EPHY_TREE_MODEL_NODE (g_object_new (EPHY_TYPE_TREE_MODEL_NODE, + "filter", filter, + "root", root, + NULL)); + + g_return_val_if_fail (model->priv != NULL, NULL); + + return model; +} + +static void +ephy_tree_model_node_tree_model_init (GtkTreeModelIface *iface) +{ + iface->get_flags = ephy_tree_model_node_get_flags; + iface->get_n_columns = ephy_tree_model_node_get_n_columns; + iface->get_column_type = ephy_tree_model_node_get_column_type; + iface->get_iter = ephy_tree_model_node_get_iter; + iface->get_path = ephy_tree_model_node_get_path; + iface->get_value = ephy_tree_model_node_get_value; + iface->iter_next = ephy_tree_model_node_iter_next; + iface->iter_children = ephy_tree_model_node_iter_children; + iface->iter_has_child = ephy_tree_model_node_iter_has_child; + iface->iter_n_children = ephy_tree_model_node_iter_n_children; + iface->iter_nth_child = ephy_tree_model_node_iter_nth_child; + iface->iter_parent = ephy_tree_model_node_iter_parent; +} + +static guint +ephy_tree_model_node_get_flags (GtkTreeModel *tree_model) +{ + return 0; +} + +static int +ephy_tree_model_node_get_n_columns (GtkTreeModel *tree_model) +{ + return EPHY_TREE_MODEL_NODE_NUM_COLUMNS; +} + +static GType +ephy_tree_model_node_get_column_type (GtkTreeModel *tree_model, + int index) +{ + g_return_val_if_fail (EPHY_IS_TREE_MODEL_NODE (tree_model), G_TYPE_INVALID); + g_return_val_if_fail ((index < EPHY_TREE_MODEL_NODE_NUM_COLUMNS) && (index >= 0), G_TYPE_INVALID); + + switch (index) + { + case EPHY_TREE_MODEL_NODE_COL_BOOKMARK: + case EPHY_TREE_MODEL_NODE_COL_LOCATION: + case EPHY_TREE_MODEL_NODE_COL_KEYWORD: + return G_TYPE_STRING; + case EPHY_TREE_MODEL_NODE_COL_VISIBLE: + return G_TYPE_BOOLEAN; + default: + g_assert_not_reached (); + return G_TYPE_INVALID; + } +} + +static gboolean +ephy_tree_model_node_get_iter (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreePath *path) +{ + EphyTreeModelNode *model = EPHY_TREE_MODEL_NODE (tree_model); + int i; + + g_return_val_if_fail (EPHY_IS_TREE_MODEL_NODE (model), FALSE); + g_return_val_if_fail (gtk_tree_path_get_depth (path) > 0, FALSE); + + if (model->priv->root == NULL) + return FALSE; + + i = gtk_tree_path_get_indices (path)[0]; + + iter->stamp = model->stamp; + iter->user_data = ephy_node_get_nth_child (model->priv->root, i); + + if (iter->user_data == NULL) + { + iter->stamp = 0; + return FALSE; + } + + return TRUE; +} + +static inline GtkTreePath * +get_path_real (EphyTreeModelNode *model, + EphyNode *node) +{ + GtkTreePath *retval; + + retval = gtk_tree_path_new (); + gtk_tree_path_append_index (retval, ephy_node_get_child_index (model->priv->root, node)); + + return retval; +} + +static GtkTreePath * +ephy_tree_model_node_get_path (GtkTreeModel *tree_model, + GtkTreeIter *iter) +{ + EphyTreeModelNode *model = EPHY_TREE_MODEL_NODE (tree_model); + EphyNode *node; + + g_return_val_if_fail (EPHY_IS_TREE_MODEL_NODE (tree_model), NULL); + g_return_val_if_fail (iter != NULL, NULL); + g_return_val_if_fail (iter->user_data != NULL, NULL); + g_return_val_if_fail (iter->stamp == model->stamp, NULL); + + if (model->priv->root == NULL) + return NULL; + + node = EPHY_NODE (iter->user_data); + + if (node == model->priv->root) + return gtk_tree_path_new (); + + return get_path_real (model, node); +} + +static void +ephy_tree_model_node_get_value (GtkTreeModel *tree_model, + GtkTreeIter *iter, + int column, + GValue *value) +{ + EphyTreeModelNode *model = EPHY_TREE_MODEL_NODE (tree_model); + EphyNode *node; + + g_return_if_fail (EPHY_IS_TREE_MODEL_NODE (tree_model)); + g_return_if_fail (iter != NULL); + g_return_if_fail (iter->stamp == model->stamp); + g_return_if_fail (EPHY_IS_NODE (iter->user_data)); + g_return_if_fail (column < EPHY_TREE_MODEL_NODE_NUM_COLUMNS); + + if (model->priv->root == NULL) + return; + + node = EPHY_NODE (iter->user_data); + + switch (column) + { + case EPHY_TREE_MODEL_NODE_COL_BOOKMARK: + ephy_node_get_property (node, + EPHY_NODE_BMK_PROP_TITLE, + value); + break; + case EPHY_TREE_MODEL_NODE_COL_LOCATION: + ephy_node_get_property (node, + EPHY_NODE_BMK_PROP_LOCATION, + value); + break; + case EPHY_TREE_MODEL_NODE_COL_KEYWORD: + ephy_node_get_property (node, + EPHY_NODE_KEYWORD_PROP_NAME, + value); + break; + case EPHY_TREE_MODEL_NODE_COL_VISIBLE: + g_value_init (value, G_TYPE_BOOLEAN); + + if (model->priv->filter != NULL) + { + g_value_set_boolean (value, + ephy_node_filter_evaluate (model->priv->filter, node)); + } + else + { + g_value_set_boolean (value, TRUE); + } + break; + default: + g_assert_not_reached (); + break; + } +} + +static gboolean +ephy_tree_model_node_iter_next (GtkTreeModel *tree_model, + GtkTreeIter *iter) +{ + EphyTreeModelNode *model = EPHY_TREE_MODEL_NODE (tree_model); + EphyNode *node; + + g_return_val_if_fail (iter != NULL, FALSE); + g_return_val_if_fail (iter->user_data != NULL, FALSE); + g_return_val_if_fail (iter->stamp == EPHY_TREE_MODEL_NODE (tree_model)->stamp, FALSE); + + if (model->priv->root == NULL) + return FALSE; + + node = EPHY_NODE (iter->user_data); + + if (node == model->priv->root) + return FALSE; + + iter->user_data = ephy_node_get_next_child (model->priv->root, node); + + return (iter->user_data != NULL); +} + +static gboolean +ephy_tree_model_node_iter_children (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *parent) +{ + EphyTreeModelNode *model = EPHY_TREE_MODEL_NODE (tree_model); + + if (model->priv->root == NULL) + return FALSE; + + if (parent != NULL) + return FALSE; + + iter->stamp = model->stamp; + iter->user_data = model->priv->root; + + return TRUE; +} + +static gboolean +ephy_tree_model_node_iter_has_child (GtkTreeModel *tree_model, + GtkTreeIter *iter) +{ + return FALSE; +} + +static int +ephy_tree_model_node_iter_n_children (GtkTreeModel *tree_model, + GtkTreeIter *iter) +{ + EphyTreeModelNode *model = EPHY_TREE_MODEL_NODE (tree_model); + + g_return_val_if_fail (EPHY_IS_TREE_MODEL_NODE (tree_model), -1); + + if (model->priv->root == NULL) + return 0; + + if (iter == NULL) + return ephy_node_get_n_children (model->priv->root); + + g_return_val_if_fail (model->stamp == iter->stamp, -1); + + return 0; +} + +static gboolean +ephy_tree_model_node_iter_nth_child (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *parent, + int n) +{ + EphyTreeModelNode *model = EPHY_TREE_MODEL_NODE (tree_model); + EphyNode *node; + + g_return_val_if_fail (EPHY_IS_TREE_MODEL_NODE (tree_model), FALSE); + + if (model->priv->root == NULL) + return FALSE; + + if (parent != NULL) + return FALSE; + + node = ephy_node_get_nth_child (model->priv->root, n); + + if (node != NULL) + { + iter->stamp = model->stamp; + iter->user_data = node; + return TRUE; + } + else + return FALSE; +} + +static gboolean +ephy_tree_model_node_iter_parent (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *child) +{ + return FALSE; +} + +EphyNode * +ephy_tree_model_node_node_from_iter (EphyTreeModelNode *model, + GtkTreeIter *iter) +{ + return EPHY_NODE (iter->user_data); +} + +void +ephy_tree_model_node_iter_from_node (EphyTreeModelNode *model, + EphyNode *node, + GtkTreeIter *iter) +{ + iter->stamp = model->stamp; + iter->user_data = node; +} + +static void +root_child_removed_cb (EphyNode *node, + EphyNode *child, + EphyTreeModelNode *model) +{ + GtkTreePath *path; + + path = get_path_real (model, child); + gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path); + gtk_tree_path_free (path); +} + +static void +root_child_added_cb (EphyNode *node, + EphyNode *child, + EphyTreeModelNode *model) +{ + GtkTreePath *path; + GtkTreeIter iter; + + ephy_tree_model_node_iter_from_node (model, child, &iter); + + path = get_path_real (model, child); + gtk_tree_model_row_inserted (GTK_TREE_MODEL (model), path, &iter); + gtk_tree_path_free (path); +} + +static inline void +ephy_tree_model_node_update_node (EphyTreeModelNode *model, + EphyNode *node, + int idx) +{ + GtkTreePath *path; + GtkTreeIter iter; + + ephy_tree_model_node_iter_from_node (model, node, &iter); + + if (idx >= 0) + { + path = gtk_tree_path_new (); + gtk_tree_path_append_index (path, idx); + } + else + { + path = get_path_real (model, node); + } + + gtk_tree_model_row_changed (GTK_TREE_MODEL (model), path, &iter); + gtk_tree_path_free (path); +} + +static void +root_child_changed_cb (EphyNode *node, + EphyNode *child, + EphyTreeModelNode *model) +{ + ephy_tree_model_node_update_node (model, child, -1); +} + +static void +root_destroyed_cb (EphyNode *node, + EphyTreeModelNode *model) +{ + model->priv->root = NULL; + + /* no need to do other stuff since we should have had a bunch of child_removed + * signals already */ +} + +GType +ephy_tree_model_node_column_get_type (void) +{ + static GType etype = 0; + + if (etype == 0) + { + static const GEnumValue values[] = + { + { EPHY_TREE_MODEL_NODE_COL_BOOKMARK, "EPHY_TREE_MODEL_NODE_COL_BOOKMARK", "bookmark" }, + { EPHY_TREE_MODEL_NODE_COL_LOCATION, "EPHY_TREE_MODEL_NODE_COL_LOCATION", "location" }, + { EPHY_TREE_MODEL_NODE_COL_KEYWORD, "EPHY_TREE_MODEL_NODE_COL_KEYWORD", "keyword" }, + { EPHY_TREE_MODEL_NODE_COL_VISIBLE, "EPHY_TREE_MODEL_NODE_COL_VISIBLE", "visible" }, + + { 0, 0, 0 } + }; + + etype = g_enum_register_static ("EphyTreeModelNodeColumn", values); + } + + return etype; +} + diff --git a/src/bookmarks/ephy-tree-model-node.h b/src/bookmarks/ephy-tree-model-node.h new file mode 100644 index 000000000..a48bc6ad5 --- /dev/null +++ b/src/bookmarks/ephy-tree-model-node.h @@ -0,0 +1,81 @@ +/* + * Copyright (C) 2002 Jorn Baayen <jorn@nl.linux.org> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * $Id$ + */ + +#ifndef __EPHY_TREE_MODEL_NODE_H +#define __EPHY_TREE_MODEL_NODE_H + +#include <gtk/gtktreemodel.h> + +#include "ephy-node.h" +#include "ephy-node-filter.h" + +G_BEGIN_DECLS + +#define EPHY_TYPE_TREE_MODEL_NODE (ephy_tree_model_node_get_type ()) +#define EPHY_TREE_MODEL_NODE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), EPHY_TYPE_TREE_MODEL_NODE, EphyTreeModelNode)) +#define EPHY_TREE_MODEL_NODE_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), EPHY_TYPE_TREE_MODEL_NODE, EphyTreeModelNodeClass)) +#define EPHY_IS_TREE_MODEL_NODE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), EPHY_TYPE_TREE_MODEL_NODE)) +#define EPHY_IS_TREE_MODEL_NODE_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), EPHY_TYPE_TREE_MODEL_NODE)) +#define EPHY_TREE_MODEL_NODE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), EPHY_TYPE_TREE_MODEL_NODE, EphyTreeModelNodeClass)) + +typedef enum +{ + EPHY_TREE_MODEL_NODE_COL_BOOKMARK, + EPHY_TREE_MODEL_NODE_COL_LOCATION, + EPHY_TREE_MODEL_NODE_COL_KEYWORD, + EPHY_TREE_MODEL_NODE_COL_VISIBLE, + EPHY_TREE_MODEL_NODE_NUM_COLUMNS +} EphyTreeModelNodeColumn; + +GType ephy_tree_model_node_column_get_type (void); + +#define EPHY_TYPE_TREE_MODEL_NODE_COLUMN (ephy_tree_model_node_column_get_type ()) + +typedef struct EphyTreeModelNodePrivate EphyTreeModelNodePrivate; + +typedef struct +{ + GObject parent; + + EphyTreeModelNodePrivate *priv; + + int stamp; +} EphyTreeModelNode; + +typedef struct +{ + GObjectClass parent; +} EphyTreeModelNodeClass; + +GType ephy_tree_model_node_get_type (void); + +EphyTreeModelNode *ephy_tree_model_node_new (EphyNode *root, + EphyNodeFilter *filter); + +EphyNode *ephy_tree_model_node_node_from_iter (EphyTreeModelNode *model, + GtkTreeIter *iter); + +void ephy_tree_model_node_iter_from_node (EphyTreeModelNode *model, + EphyNode *node, + GtkTreeIter *iter); + +G_END_DECLS + +#endif /* EPHY_TREE_MODEL_NODE_H */ diff --git a/src/ephy-automation.c b/src/ephy-automation.c new file mode 100644 index 000000000..d7757fe75 --- /dev/null +++ b/src/ephy-automation.c @@ -0,0 +1,217 @@ +/* + * Copyright (C) 2000, 2001, 2002 Marco Pesenti Gritti + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include "ephy-automation.h" +#include "ephy-shell.h" +#include "EphyAutomation.h" +#include "ephy-embed.h" +#include "ephy-window.h" + +#include <string.h> +#include <bonobo/bonobo-generic-factory.h> +#include <bonobo/bonobo-main.h> +#include <bonobo/bonobo-context.h> + +static CORBA_boolean +impl_ephy_automation_add_bookmark (PortableServer_Servant _servant, + const CORBA_char * url, + CORBA_Environment * ev); +static CORBA_boolean +impl_ephy_automation_quit (PortableServer_Servant _servant, + const CORBA_boolean disableServer, + CORBA_Environment * ev); +static CORBA_boolean +impl_ephy_automation_load_session (PortableServer_Servant _servant, + const CORBA_char * filename, + CORBA_Environment * ev); +static void +ephy_automation_class_init (EphyAutomationClass *klass); +static void +ephy_automation_init (EphyAutomation *a); +static void +ephy_automation_object_finalize (GObject *object); +static BonoboObject * +ephy_automation_factory (BonoboGenericFactory *this_factory, + const char *iid, + gpointer user_data); + +static GObjectClass *ephy_automation_parent_class; + +#define EPHY_FACTORY_OAFIID "OAFIID:GNOME_Epiphany_Automation_Factory" + +static BonoboObject * +ephy_automation_factory (BonoboGenericFactory *this_factory, + const char *iid, + gpointer user_data) +{ + EphyAutomation *a; + + a = g_object_new (EPHY_AUTOMATION_TYPE, NULL); + + return BONOBO_OBJECT(a); +} + +BonoboObject * +ephy_automation_new (void) +{ + BonoboGenericFactory *factory; + + factory = bonobo_generic_factory_new (EPHY_FACTORY_OAFIID, + ephy_automation_factory, + NULL); + + g_return_val_if_fail (factory != NULL, NULL); + + return BONOBO_OBJECT (factory); +} + +static CORBA_boolean +impl_ephy_automation_loadurl (PortableServer_Servant _servant, + const CORBA_char * url, + const CORBA_char * geometry, + const CORBA_boolean fullscreen, + const CORBA_boolean open_in_existing_tab, + const CORBA_boolean open_in_new_window, + const CORBA_boolean open_in_new_tab, + const CORBA_boolean raise, + CORBA_Environment * ev) +{ + EphyNewTabFlags flags = 0; + const char *load_page = NULL; + EphyWindow *window; + Session *session; + + session = ephy_shell_get_session (ephy_shell); + + /* no window open, let's try to autoresume */ + if (session_get_windows (session) == NULL) + { + gboolean res; + res = session_autoresume (session); + /* no need to open the homepage, + * we did already open session windows */ + if (res && *url == '\0') return TRUE; + } + + window = ephy_shell_get_active_window (ephy_shell); + + if (open_in_existing_tab && window != NULL) + { + ephy_window_load_url (window, url); + return TRUE; + } + + if (*url == '\0') + { + flags = EPHY_NEW_TAB_HOMEPAGE; + } + else + { + load_page = url; + } + + if (open_in_new_window) + { + flags |= EPHY_NEW_TAB_IN_NEW_WINDOW; + } + + if (open_in_new_tab) + { + flags |= EPHY_NEW_TAB_IN_EXISTING_WINDOW; + } + + ephy_shell_new_tab (ephy_shell, window, NULL, load_page, + flags); + + return TRUE; +} + +static CORBA_boolean +impl_ephy_automation_add_bookmark (PortableServer_Servant _servant, + const CORBA_char * url, + CORBA_Environment * ev) +{ + CORBA_boolean retval = TRUE; + return retval; +} + +static CORBA_boolean +impl_ephy_automation_quit (PortableServer_Servant _servant, + const CORBA_boolean disableServer, + CORBA_Environment * ev) +{ + CORBA_boolean retval = TRUE; + + Session *session; + + session = ephy_shell_get_session (ephy_shell); + + session_close (session); + + return retval; +} + +static CORBA_boolean +impl_ephy_automation_load_session (PortableServer_Servant _servant, + const CORBA_char * filename, + CORBA_Environment * ev) +{ + CORBA_boolean retval = TRUE; + Session *session; + + session = ephy_shell_get_session (ephy_shell); + session_load (session, filename); + + return retval; +} + +static void +ephy_automation_class_init (EphyAutomationClass *klass) +{ + GObjectClass *object_class = (GObjectClass *) klass; + POA_GNOME_EphyAutomation__epv *epv = &klass->epv; + + ephy_automation_parent_class = g_type_class_peek_parent (klass); + + object_class->finalize = ephy_automation_object_finalize; + + /* connect implementation callbacks */ + epv->loadurl = impl_ephy_automation_loadurl; + epv->addBookmark = impl_ephy_automation_add_bookmark; + epv->quit = impl_ephy_automation_quit; + epv->loadSession = impl_ephy_automation_load_session; +} + +static void +ephy_automation_init (EphyAutomation *c) +{ +} + +static void +ephy_automation_object_finalize (GObject *object) +{ + EphyAutomation *a = EPHY_AUTOMATION (object); + + ephy_automation_parent_class->finalize (G_OBJECT (a)); +} + +BONOBO_TYPE_FUNC_FULL ( + EphyAutomation, + GNOME_EphyAutomation, + BONOBO_TYPE_OBJECT, + ephy_automation); diff --git a/src/ephy-automation.h b/src/ephy-automation.h new file mode 100644 index 000000000..4b3701605 --- /dev/null +++ b/src/ephy-automation.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2000, 2001, 2002 Marco Pesenti Gritti + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef _EPHY_AUTOMATION_H_ +#define _EPHY_AUTOMATION_H_ + +#include "EphyAutomation.h" + +#include <bonobo/bonobo-control.h> +#include <bonobo/bonobo-object.h> + +G_BEGIN_DECLS + +#define EPHY_AUTOMATION_TYPE (ephy_automation_get_type ()) +#define EPHY_AUTOMATION(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), EPHY_AUTOMATION_TYPE, EphyAutomation)) +#define EPHY_AUTOMATION_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), EPHY_AUTOMATION_TYPE, EphyAutomationClass)) +#define EPHY_AUTOMATION_IS_OBJECT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), EPHY_AUTOMATION_TYPE)) +#define EPHY_AUTOMATION_IS_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), EPHY_AUTOMATION_TYPE)) +#define EPHY_AUTOMATION_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), EPHY_AUTOMATION_TYPE, EphyAutomationClass)) + +typedef struct { + BonoboObject parent; +} EphyAutomation; + +typedef struct { + BonoboObjectClass parent_class; + + POA_GNOME_EphyAutomation__epv epv; +} EphyAutomationClass; + +GType ephy_automation_get_type (void); + +BonoboObject *ephy_automation_new (void); + +G_END_DECLS + +#endif /* _EPHY_AUTOMATION_H_ */ diff --git a/src/ephy-favorites-menu.c b/src/ephy-favorites-menu.c new file mode 100644 index 000000000..d8f44f852 --- /dev/null +++ b/src/ephy-favorites-menu.c @@ -0,0 +1,275 @@ +/* + * Copyright (C) 2002 Ricardo Fernández Pascual + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "ephy-favorites-menu.h" +#include "ephy-gobject-misc.h" +#include "ephy-string.h" +#include "ephy-bonobo-extensions.h" +#include "ephy-marshal.h" +#include "ephy-shell.h" + +#include <string.h> +#include <stdlib.h> +#include <libxml/entities.h> + +#define NOT_IMPLEMENTED g_warning ("not implemented: " G_STRLOC); +//#define DEBUG_MSG(x) g_print x +#define DEBUG_MSG(x) + +#define MAX_LABEL_LENGTH 30 + +/** + * Private data + */ +struct _EphyFavoritesMenuPrivate +{ + gchar *path; + EphyWindow *window; + EphyBookmarks *bookmarks; +}; + +typedef struct +{ + EphyWindow *window; + const char *url; +} FavoriteData; + +/** + * Private functions, only availble from this file + */ +static void ephy_favorites_menu_class_init (EphyFavoritesMenuClass *klass); +static void ephy_favorites_menu_init (EphyFavoritesMenu *wrhm); +static void ephy_favorites_menu_finalize_impl (GObject *o); +static void ephy_favorites_menu_rebuild (EphyFavoritesMenu *wrhm); +static void ephy_favorites_menu_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec); +static void ephy_favorites_menu_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec); + +enum +{ + PROP_0, + PROP_EPHY_WINDOW +}; + +static gpointer g_object_class; + +/** + * EphyFavoritesMenu object + */ +MAKE_GET_TYPE (ephy_favorites_menu, + "EphyFavoritesMenu", EphyFavoritesMenu, + ephy_favorites_menu_class_init, ephy_favorites_menu_init, + G_TYPE_OBJECT); + +static void +ephy_favorites_menu_class_init (EphyFavoritesMenuClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + G_OBJECT_CLASS (klass)->finalize = ephy_favorites_menu_finalize_impl; + g_object_class = g_type_class_peek_parent (klass); + + object_class->set_property = ephy_favorites_menu_set_property; + object_class->get_property = ephy_favorites_menu_get_property; + + g_object_class_install_property (object_class, + PROP_EPHY_WINDOW, + g_param_spec_object ("EphyWindow", + "EphyWindow", + "Parent window", + EPHY_WINDOW_TYPE, + G_PARAM_READWRITE)); +} + +static void +ephy_favorites_menu_init (EphyFavoritesMenu *wrhm) +{ + EphyFavoritesMenuPrivate *p = g_new0 (EphyFavoritesMenuPrivate, 1); + wrhm->priv = p; + + wrhm->priv->bookmarks = ephy_shell_get_bookmarks (ephy_shell); +} + +static void +ephy_favorites_menu_finalize_impl (GObject *o) +{ + EphyFavoritesMenu *wrhm = EPHY_FAVORITES_MENU (o); + EphyFavoritesMenuPrivate *p = wrhm->priv; + + if (p->path) + { + g_free (p->path); + } + + g_free (p); + + G_OBJECT_CLASS (g_object_class)->finalize (o); +} + +static void +ephy_favorites_menu_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + EphyFavoritesMenu *m = EPHY_FAVORITES_MENU (object); + + switch (prop_id) + { + case PROP_EPHY_WINDOW: + m->priv->window = g_value_get_object (value); + break; + } +} + +static void +ephy_favorites_menu_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + EphyFavoritesMenu *m = EPHY_FAVORITES_MENU (object); + + switch (prop_id) + { + case PROP_EPHY_WINDOW: + g_value_set_object (value, m->priv->window); + break; + } +} + +EphyFavoritesMenu * +ephy_favorites_menu_new (EphyWindow *window) +{ + EphyFavoritesMenu *ret = g_object_new (EPHY_TYPE_FAVORITES_MENU, + "EphyWindow", window, + NULL); + return ret; +} + +void +ephy_favorites_menu_set_path (EphyFavoritesMenu *wrhm, + const gchar *path) +{ + EphyFavoritesMenuPrivate *p; + + g_return_if_fail (EPHY_IS_FAVORITES_MENU (wrhm)); + g_return_if_fail (path != NULL); + + p = wrhm->priv; + + if (p->path) + { + g_free (p->path); + } + p->path = g_strdup (path); + + ephy_favorites_menu_update (wrhm); +} + +static void +ephy_favorites_menu_verb_cb (BonoboUIComponent *uic, + FavoriteData *data, + const char *cname) +{ + ephy_window_load_url (data->window, data->url); +} + +static void +ephy_favorites_menu_rebuild (EphyFavoritesMenu *wrhm) +{ + EphyFavoritesMenuPrivate *p = wrhm->priv; + GString *xml; + gint i; + EphyNode *fav; + GPtrArray *children; + BonoboUIComponent *uic = BONOBO_UI_COMPONENT (p->window->ui_component); + + if (!p->path) return; + + ephy_bonobo_clear_path (uic, p->path); + + DEBUG_MSG (("Rebuilding recent history menu\n")); + + fav = ephy_bookmarks_get_favorites (p->bookmarks); + children = ephy_node_get_children (fav); + + xml = g_string_new (NULL); + g_string_append_printf (xml, "<placeholder name=\"wrhm%x\">\n", (guint) wrhm); + + for (i = 0; i < children->len; i++) + { + char *verb = g_strdup_printf ("Wrhm%xn%d", (guint) wrhm, i); + char *title_s; + const char *title; + const char *url; + xmlChar *label_x; + EphyNode *child; + FavoriteData *data; + + child = g_ptr_array_index (children, i); + title = ephy_node_get_property_string (child, EPHY_NODE_BMK_PROP_TITLE); + url = ephy_node_get_property_string (child, EPHY_NODE_BMK_PROP_LOCATION); + title_s = ephy_string_shorten (title, MAX_LABEL_LENGTH); + label_x = xmlEncodeSpecialChars (NULL, title_s); + + g_string_append (xml, "<menuitem name=\""); + g_string_append (xml, verb); + g_string_append (xml, "\" label=\""); + g_string_append (xml, label_x); + g_string_append (xml, "\" verb=\""); + g_string_append (xml, verb); + g_string_append (xml, "\"/>\n"); + + data = g_new0 (FavoriteData, 1); + data->window = wrhm->priv->window; + data->url = url; + bonobo_ui_component_add_verb_full (uic, verb, g_cclosure_new + (G_CALLBACK (ephy_favorites_menu_verb_cb), data, + (GClosureNotify)g_free)); + + xmlFree (label_x); + g_free (title_s); + g_free (verb); + } + + ephy_node_thaw (fav); + + g_string_append (xml, "</placeholder>\n"); + DEBUG_MSG (("\n%s\n", xml->str)); + if (children->len > 0) + { + bonobo_ui_component_set (uic, p->path, + xml->str, NULL); + } + g_string_free (xml, TRUE); +} + +void ephy_favorites_menu_update (EphyFavoritesMenu *wrhm) +{ + ephy_favorites_menu_rebuild (wrhm); +} diff --git a/src/ephy-favorites-menu.h b/src/ephy-favorites-menu.h new file mode 100644 index 000000000..b76e8d2d8 --- /dev/null +++ b/src/ephy-favorites-menu.h @@ -0,0 +1,66 @@ +/* + * Copyright (C) 2002 Ricardo Fernández Pascual + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef EPHY_FAVORITES_MENU_H +#define EPHY_FAVORITES_MENU_H + +#include "ephy-window.h" + +#include <bonobo/bonobo-ui-component.h> + +/* object forward declarations */ + +typedef struct _EphyFavoritesMenu EphyFavoritesMenu; +typedef struct _EphyFavoritesMenuClass EphyFavoritesMenuClass; +typedef struct _EphyFavoritesMenuPrivate EphyFavoritesMenuPrivate; + +/** + * Editor object + */ + +#define EPHY_TYPE_FAVORITES_MENU (ephy_favorites_menu_get_type()) +#define EPHY_FAVORITES_MENU(object) (G_TYPE_CHECK_INSTANCE_CAST((object), EPHY_TYPE_FAVORITES_MENU, EphyFavoritesMenu)) +#define EPHY_FAVORITES_MENU_CLASS(klass)(G_TYPE_CHECK_CLASS_CAST((klass), EPHY_TYPE_FAVORITES_MENU, EphyFavoritesMenuClass)) +#define EPHY_IS_FAVORITES_MENU(object) (G_TYPE_CHECK_INSTANCE_TYPE((object), EPHY_TYPE_FAVORITES_MENU)) +#define EPHY_IS_FAVORITES_MENU_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), EPHY_TYPE_FAVORITES_MENU)) +#define EPHY_FAVORITES_MENU_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), EPHY_TYPE_FAVORITES_MENU, EphyFavoritesMenuClass)) + +struct _EphyFavoritesMenuClass +{ + GObjectClass parent_class; +}; + +/* Remember: fields are public read-only */ +struct _EphyFavoritesMenu +{ + GObject parent_object; + + EphyFavoritesMenuPrivate *priv; +}; + +GType ephy_favorites_menu_get_type (void); + +EphyFavoritesMenu *ephy_favorites_menu_new (EphyWindow *window); + +void ephy_favorites_menu_update (EphyFavoritesMenu *wrhm); + +void ephy_favorites_menu_set_path (EphyFavoritesMenu *wrhm, + const gchar *path); + +#endif + diff --git a/src/ephy-history-model.c b/src/ephy-history-model.c new file mode 100644 index 000000000..c4e694bcd --- /dev/null +++ b/src/ephy-history-model.c @@ -0,0 +1,838 @@ +/* + * Copyright (C) 2002 Jorn Baayen <jorn@nl.linux.org> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * $Id$ + */ + +#include <config.h> +#include <gtk/gtktreeview.h> +#include <gdk-pixbuf/gdk-pixbuf.h> +#include <libgnome/gnome-i18n.h> +#include <time.h> +#include <string.h> + +#include "ephy-node-filter.h" +#include "ephy-history-model.h" +#include "ephy-history.h" +#include "ephy-tree-model-node.h" +#include "ephy-stock-icons.h" +#include "ephy-node.h" + +static void ephy_history_model_class_init (EphyHistoryModelClass *klass); +static void ephy_history_model_init (EphyHistoryModel *model); +static void ephy_history_model_finalize (GObject *object); +static void ephy_history_model_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec); +static void ephy_history_model_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec); +static guint ephy_history_model_get_flags (GtkTreeModel *tree_model); +static int ephy_history_model_get_n_columns (GtkTreeModel *tree_model); +static GType ephy_history_model_get_column_type (GtkTreeModel *tree_model, + int index); +static gboolean ephy_history_model_get_iter (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreePath *path); +static GtkTreePath *ephy_history_model_get_path (GtkTreeModel *tree_model, + GtkTreeIter *iter); +static void ephy_history_model_get_value (GtkTreeModel *tree_model, + GtkTreeIter *iter, + int column, + GValue *value); +static gboolean ephy_history_model_iter_next (GtkTreeModel *tree_model, + GtkTreeIter *iter); +static gboolean ephy_history_model_iter_children (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *parent); +static gboolean ephy_history_model_iter_has_child (GtkTreeModel *tree_model, + GtkTreeIter *iter); +static int ephy_history_model_iter_n_children (GtkTreeModel *tree_model, + GtkTreeIter *iter); +static gboolean ephy_history_model_iter_nth_child (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *parent, + int n); +static gboolean ephy_history_model_iter_parent (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *child); +static void ephy_history_model_tree_model_init (GtkTreeModelIface *iface); +static void root_child_removed_cb (EphyNode *node, + EphyNode *child, + EphyHistoryModel *model); +static void root_child_added_cb (EphyNode *node, + EphyNode *child, + EphyHistoryModel *model); +static void root_child_changed_cb (EphyNode *node, + EphyNode *child, + EphyHistoryModel *model); +static inline void ephy_history_model_update_node (EphyHistoryModel *model, + EphyNode *node, + int idx); + +struct EphyHistoryModelPrivate +{ + EphyNode *root; + EphyNode *pages; + + EphyNodeFilter *filter; +}; + +enum +{ + PROP_0, + PROP_ROOT, + PROP_PAGES, + PROP_FILTER +}; + +static GObjectClass *parent_class = NULL; + +GType +ephy_history_model_get_type (void) +{ + static GType ephy_history_model_type = 0; + + if (ephy_history_model_type == 0) + { + static const GTypeInfo our_info = + { + sizeof (EphyHistoryModelClass), + NULL, + NULL, + (GClassInitFunc) ephy_history_model_class_init, + NULL, + NULL, + sizeof (EphyHistoryModel), + 0, + (GInstanceInitFunc) ephy_history_model_init + }; + + static const GInterfaceInfo tree_model_info = + { + (GInterfaceInitFunc) ephy_history_model_tree_model_init, + NULL, + NULL + }; + + ephy_history_model_type = g_type_register_static (G_TYPE_OBJECT, + "EphyHistoryModel", + &our_info, 0); + + g_type_add_interface_static (ephy_history_model_type, + GTK_TYPE_TREE_MODEL, + &tree_model_info); + } + + return ephy_history_model_type; +} + +static void +ephy_history_model_class_init (EphyHistoryModelClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + object_class->finalize = ephy_history_model_finalize; + + object_class->set_property = ephy_history_model_set_property; + object_class->get_property = ephy_history_model_get_property; + + g_object_class_install_property (object_class, + PROP_ROOT, + g_param_spec_object ("root", + "Root node", + "Root node", + EPHY_TYPE_NODE, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); + g_object_class_install_property (object_class, + PROP_PAGES, + g_param_spec_object ("pages", + "Pages node", + "Pages node", + EPHY_TYPE_NODE, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); + + g_object_class_install_property (object_class, + PROP_FILTER, + g_param_spec_object ("filter", + "Filter object", + "Filter object", + EPHY_TYPE_NODE_FILTER, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)); +} + +static void +ephy_history_model_init (EphyHistoryModel *model) +{ + GtkWidget *dummy; + + do + { + model->stamp = g_random_int (); + } + while (model->stamp == 0); + + model->priv = g_new0 (EphyHistoryModelPrivate, 1); + + dummy = gtk_tree_view_new (); + + gtk_widget_destroy (dummy); +} + +static void +ephy_history_model_finalize (GObject *object) +{ + EphyHistoryModel *model; + + g_return_if_fail (object != NULL); + g_return_if_fail (EPHY_IS_HISTORY_MODEL (object)); + + model = EPHY_HISTORY_MODEL (object); + + g_return_if_fail (model->priv != NULL); + + g_free (model->priv); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static void +filter_changed_cb (EphyNodeFilter *filter, + EphyHistoryModel *model) +{ + GPtrArray *kids; + int i; + + kids = ephy_node_get_children (model->priv->root); + + for (i = 0; i < kids->len; i++) + { + ephy_history_model_update_node (model, + g_ptr_array_index (kids, i), + i); + } + + ephy_node_thaw (model->priv->root); +} + +static void +ephy_history_model_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + EphyHistoryModel *model = EPHY_HISTORY_MODEL (object); + + switch (prop_id) + { + case PROP_ROOT: + model->priv->root = g_value_get_object (value); + g_signal_connect_object (G_OBJECT (model->priv->root), + "child_added", + G_CALLBACK (root_child_added_cb), + G_OBJECT (model), + 0); + g_signal_connect_object (G_OBJECT (model->priv->root), + "child_removed", + G_CALLBACK (root_child_removed_cb), + G_OBJECT (model), + 0); + g_signal_connect_object (G_OBJECT (model->priv->root), + "child_changed", + G_CALLBACK (root_child_changed_cb), + G_OBJECT (model), + 0); + break; + case PROP_PAGES: + model->priv->pages = g_value_get_object (value); + g_signal_connect_object (G_OBJECT (model->priv->pages), + "child_added", + G_CALLBACK (root_child_added_cb), + G_OBJECT (model), + 0); + g_signal_connect_object (G_OBJECT (model->priv->pages), + "child_removed", + G_CALLBACK (root_child_removed_cb), + G_OBJECT (model), + 0); + g_signal_connect_object (G_OBJECT (model->priv->pages), + "child_changed", + G_CALLBACK (root_child_changed_cb), + G_OBJECT (model), + 0); + break; + case PROP_FILTER: + model->priv->filter = g_value_get_object (value); + + if (model->priv->filter != NULL) + { + g_signal_connect_object (G_OBJECT (model->priv->filter), + "changed", + G_CALLBACK (filter_changed_cb), + G_OBJECT (model), + 0); + } + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +ephy_history_model_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + EphyHistoryModel *model = EPHY_HISTORY_MODEL (object); + + switch (prop_id) + { + case PROP_ROOT: + g_value_set_object (value, model->priv->root); + break; + case PROP_PAGES: + g_value_set_object (value, model->priv->root); + break; + case PROP_FILTER: + g_value_set_object (value, model->priv->filter); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +EphyHistoryModel * +ephy_history_model_new (EphyNode *root, + EphyNode *pages, + EphyNodeFilter *filter) +{ + EphyHistoryModel *model; + + model = EPHY_HISTORY_MODEL (g_object_new (EPHY_TYPE_HISTORY_MODEL, + "filter", filter, + "root", root, + "pages", pages, + NULL)); + + g_return_val_if_fail (model->priv != NULL, NULL); + + return model; +} + +static void +ephy_history_model_tree_model_init (GtkTreeModelIface *iface) +{ + iface->get_flags = ephy_history_model_get_flags; + iface->get_n_columns = ephy_history_model_get_n_columns; + iface->get_column_type = ephy_history_model_get_column_type; + iface->get_iter = ephy_history_model_get_iter; + iface->get_path = ephy_history_model_get_path; + iface->get_value = ephy_history_model_get_value; + iface->iter_next = ephy_history_model_iter_next; + iface->iter_children = ephy_history_model_iter_children; + iface->iter_has_child = ephy_history_model_iter_has_child; + iface->iter_n_children = ephy_history_model_iter_n_children; + iface->iter_nth_child = ephy_history_model_iter_nth_child; + iface->iter_parent = ephy_history_model_iter_parent; +} + +static guint +ephy_history_model_get_flags (GtkTreeModel *tree_model) +{ + return 0; +} + +static int +ephy_history_model_get_n_columns (GtkTreeModel *tree_model) +{ + return EPHY_HISTORY_MODEL_NUM_COLUMNS; +} + +static GType +ephy_history_model_get_column_type (GtkTreeModel *tree_model, + int index) +{ + g_return_val_if_fail (EPHY_IS_HISTORY_MODEL (tree_model), G_TYPE_INVALID); + g_return_val_if_fail ((index < EPHY_HISTORY_MODEL_NUM_COLUMNS) && (index >= 0), G_TYPE_INVALID); + + switch (index) + { + case EPHY_HISTORY_MODEL_COL_TITLE: + case EPHY_HISTORY_MODEL_COL_LOCATION: + case EPHY_HISTORY_MODEL_COL_VISITS: + case EPHY_HISTORY_MODEL_COL_LAST_VISIT: + case EPHY_HISTORY_MODEL_COL_FIRST_VISIT: + return G_TYPE_STRING; + case EPHY_HISTORY_MODEL_COL_VISIBLE: + return G_TYPE_BOOLEAN; + default: + g_assert_not_reached (); + return G_TYPE_INVALID; + } +} + +static gboolean +ephy_history_model_get_iter (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreePath *path) +{ + EphyHistoryModel *model = EPHY_HISTORY_MODEL (tree_model); + gint *indices; + gint depth; + EphyNode *host; + + g_return_val_if_fail (EPHY_IS_HISTORY_MODEL (model), FALSE); + + indices = gtk_tree_path_get_indices (path); + depth = gtk_tree_path_get_depth (path); + + g_return_val_if_fail (depth > 0, FALSE); + + iter->stamp = model->stamp; + host = ephy_node_get_nth_child (model->priv->root, indices [0]); + + if (depth == 2 && host != NULL) + { + iter->user_data = ephy_node_get_nth_child (host, indices [1]); + } + else + { + iter->user_data = host; + } + + if (iter->user_data == NULL) + { + iter->stamp = 0; + return FALSE; + } + + return TRUE; +} + +static EphyNode * +ensure_iter (EphyHistoryModel *model, GtkTreeIter *parent) +{ + EphyNode *node; + + if (parent) + { + node = EPHY_NODE (parent->user_data); + } + else + { + node = model->priv->root; + } + + return node; +} + +static EphyNode * +get_parent_node (EphyHistoryModel *model, EphyNode *node) +{ + int host_id; + + host_id = ephy_node_get_property_int (node, EPHY_NODE_PAGE_PROP_HOST_ID); + + if (host_id < 0) + { + return model->priv->root; + } + else + { + EphyNode *host; + host = ephy_node_get_from_id (host_id); + return host; + } +} + +static inline GtkTreePath * +get_one_level_path_real (EphyHistoryModel *model, + EphyNode *node) +{ + GtkTreePath *retval; + EphyNode *my_parent; + + retval = gtk_tree_path_new (); + + my_parent = get_parent_node (model, node); + + gtk_tree_path_append_index (retval, ephy_node_get_child_index (my_parent, node)); + + return retval; +} + +static inline GtkTreePath * +get_path_real (EphyHistoryModel *model, + EphyNode *page) +{ + GtkTreePath *retval; + EphyNode *host; + + retval = gtk_tree_path_new (); + host = get_parent_node (model, page); + + gtk_tree_path_append_index (retval, ephy_node_get_child_index (model->priv->root, host)); + gtk_tree_path_append_index (retval, ephy_node_get_child_index (host, page)); + + return retval; +} + +static GtkTreePath * +ephy_history_model_get_path (GtkTreeModel *tree_model, + GtkTreeIter *iter) +{ + EphyHistoryModel *model = EPHY_HISTORY_MODEL (tree_model); + EphyNode *node; + + g_return_val_if_fail (EPHY_IS_HISTORY_MODEL (tree_model), NULL); + g_return_val_if_fail (iter != NULL, NULL); + g_return_val_if_fail (iter->user_data != NULL, NULL); + g_return_val_if_fail (iter->stamp == model->stamp, NULL); + + node = EPHY_NODE (iter->user_data); + + if (node == model->priv->root) + return gtk_tree_path_new (); + + return get_one_level_path_real (model, node); +} + +static void +get_property_as_date (EphyNode *node, + int id, + GValue *value) +{ + GTime time; + char s[50]; + GDate *date; + + time = ephy_node_get_property_int (node, id); + date = g_date_new (); + g_date_set_time (date, time); + g_date_strftime (s, 50, "%c", date); + + g_value_init (value, G_TYPE_STRING); + g_value_set_string (value, s); + + g_date_free (date); +} + +static void +ephy_history_model_get_value (GtkTreeModel *tree_model, + GtkTreeIter *iter, + int column, + GValue *value) +{ + EphyHistoryModel *model = EPHY_HISTORY_MODEL (tree_model); + EphyNode *node; + + g_return_if_fail (EPHY_IS_HISTORY_MODEL (tree_model)); + g_return_if_fail (iter != NULL); + g_return_if_fail (iter->stamp == model->stamp); + g_return_if_fail (EPHY_IS_NODE (iter->user_data)); + g_return_if_fail (column < EPHY_HISTORY_MODEL_NUM_COLUMNS); + + node = EPHY_NODE (iter->user_data); + + if (ephy_node_get_property_int (node, EPHY_NODE_PAGE_PROP_HOST_ID) < 0 && + (column == EPHY_HISTORY_MODEL_COL_LOCATION || + column == EPHY_HISTORY_MODEL_COL_FIRST_VISIT || + column == EPHY_HISTORY_MODEL_COL_LAST_VISIT || + column == EPHY_HISTORY_MODEL_COL_VISITS)) + { + g_value_init (value, G_TYPE_STRING); + g_value_set_string (value, ""); + return; + } + + switch (column) + { + case EPHY_HISTORY_MODEL_COL_TITLE: + ephy_node_get_property (node, + EPHY_NODE_PAGE_PROP_TITLE, + value); + break; + case EPHY_HISTORY_MODEL_COL_LOCATION: + ephy_node_get_property (node, + EPHY_NODE_PAGE_PROP_LOCATION, + value); + break; + case EPHY_HISTORY_MODEL_COL_VISITS: + ephy_node_get_property (node, + EPHY_NODE_PAGE_PROP_VISITS, + value); + break; + case EPHY_HISTORY_MODEL_COL_FIRST_VISIT: + get_property_as_date (node, + EPHY_NODE_PAGE_PROP_FIRST_VISIT, + value); + break; + case EPHY_HISTORY_MODEL_COL_LAST_VISIT: + get_property_as_date (node, + EPHY_NODE_PAGE_PROP_LAST_VISIT, + value); + break; + case EPHY_HISTORY_MODEL_COL_VISIBLE: + g_value_init (value, G_TYPE_BOOLEAN); + + if (model->priv->filter != NULL) + { + g_value_set_boolean (value, + ephy_node_filter_evaluate (model->priv->filter, node)); + } + else + { + g_value_set_boolean (value, TRUE); + } + break; + default: + g_assert_not_reached (); + break; + } +} + +static gboolean +ephy_history_model_iter_next (GtkTreeModel *tree_model, + GtkTreeIter *iter) +{ + EphyHistoryModel *model = EPHY_HISTORY_MODEL (tree_model); + EphyNode *node; + + g_return_val_if_fail (iter != NULL, FALSE); + g_return_val_if_fail (iter->user_data != NULL, FALSE); + g_return_val_if_fail (iter->stamp == EPHY_HISTORY_MODEL (tree_model)->stamp, FALSE); + + node = EPHY_NODE (iter->user_data); + + iter->user_data = ephy_node_get_next_child + (get_parent_node (model, node), node); + + return (iter->user_data != NULL); +} + +static gboolean +ephy_history_model_iter_children (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *parent) +{ + EphyHistoryModel *model = EPHY_HISTORY_MODEL (tree_model); + EphyNode *node; + + node = ensure_iter (model, parent); + + iter->user_data = ephy_node_get_nth_child (node, 0); + iter->stamp = model->stamp; + + return (iter->user_data != NULL); +} + +static gboolean +ephy_history_model_iter_has_child (GtkTreeModel *tree_model, + GtkTreeIter *iter) +{ + EphyHistoryModel *model = EPHY_HISTORY_MODEL (tree_model); + EphyNode *node; + int host_id; + + node = EPHY_NODE (iter->user_data); + host_id = ephy_node_get_property_int (node, EPHY_NODE_PAGE_PROP_HOST_ID); + if (host_id < 0) + { + return ephy_node_has_child (model->priv->root, node); + } + else + { + return FALSE; + } +} + +static int +ephy_history_model_iter_n_children (GtkTreeModel *tree_model, + GtkTreeIter *iter) +{ + EphyHistoryModel *model = EPHY_HISTORY_MODEL (tree_model); + EphyNode *node; + + g_return_val_if_fail (iter == NULL || iter->user_data != NULL, FALSE); + + node = ensure_iter (model, iter); + + return ephy_node_get_n_children (node); +} + +static gboolean +ephy_history_model_iter_nth_child (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *parent, + int n) +{ + EphyHistoryModel *model = EPHY_HISTORY_MODEL (tree_model); + EphyNode *node; + + node = ensure_iter (model, parent); + + iter->user_data = ephy_node_get_nth_child (node, n); + iter->stamp = model->stamp; + + return (iter->user_data != NULL); +} + +static gboolean +ephy_history_model_iter_parent (GtkTreeModel *tree_model, + GtkTreeIter *iter, + GtkTreeIter *child) +{ + EphyHistoryModel *model = EPHY_HISTORY_MODEL (tree_model); + EphyNode *parent, *node; + + node = EPHY_NODE (iter->user_data); + parent = get_parent_node (model, node); + + if (parent != model->priv->root) + { + iter->user_data = parent; + iter->stamp = model->stamp; + return TRUE; + } + else + { + return FALSE; + } +} + +EphyNode * +ephy_history_model_node_from_iter (EphyHistoryModel *model, + GtkTreeIter *iter) +{ + return EPHY_NODE (iter->user_data); +} + +void +ephy_history_model_iter_from_node (EphyHistoryModel *model, + EphyNode *node, + GtkTreeIter *iter) +{ + iter->stamp = model->stamp; + iter->user_data = node; +} + +static inline void +ephy_history_model_update_node (EphyHistoryModel *model, + EphyNode *node, + int idx) +{ + GtkTreePath *path; + GtkTreeIter iter; + + ephy_history_model_iter_from_node (model, node, &iter); + + if (idx >= 0) + { + path = gtk_tree_path_new (); + gtk_tree_path_append_index (path, idx); + } + else + { + path = get_one_level_path_real (model, node); + } + + gtk_tree_model_row_changed (GTK_TREE_MODEL (model), path, &iter); + gtk_tree_path_free (path); +} + +static void +root_child_removed_cb (EphyNode *node, + EphyNode *child, + EphyHistoryModel *model) +{ + GtkTreePath *path; + + if (node == model->priv->root) + { + path = get_one_level_path_real (model, child); + } + else + { + path = get_path_real (model, child); + } + gtk_tree_model_row_deleted (GTK_TREE_MODEL (model), path); + gtk_tree_path_free (path); +} + +static void +root_child_added_cb (EphyNode *node, + EphyNode *child, + EphyHistoryModel *model) +{ + GtkTreePath *path; + GtkTreeIter iter; + + ephy_history_model_iter_from_node (model, child, &iter); + + if (node == model->priv->root) + { + path = get_one_level_path_real (model, child); + } + else + { + path = get_path_real (model, child); + } + + gtk_tree_model_row_inserted (GTK_TREE_MODEL (model), path, &iter); + gtk_tree_path_free (path); +} + +static void +root_child_changed_cb (EphyNode *node, + EphyNode *child, + EphyHistoryModel *model) +{ + ephy_history_model_update_node (model, child, -1); +} + +GType +ephy_history_model_column_get_type (void) +{ + static GType etype = 0; + + if (etype == 0) + { + static const GEnumValue values[] = + { + { EPHY_HISTORY_MODEL_COL_TITLE, "EPHY_HISTORY_MODEL_COL_TITLE", "title" }, + { EPHY_HISTORY_MODEL_COL_LOCATION, "EPHY_HISTORY_MODEL_COL_LOCATION", "location" }, + { EPHY_HISTORY_MODEL_COL_VISITS, "EPHY_HISTORY_MODEL_COL_VISITS", "visits" }, + { EPHY_HISTORY_MODEL_COL_FIRST_VISIT, "EPHY_HISTORY_MODEL_COL_FIRST_VISIT", "last_visit" }, + { EPHY_HISTORY_MODEL_COL_LAST_VISIT, "EPHY_HISTORY_MODEL_COL_LAST_VISIT", "last_visit" }, + { EPHY_HISTORY_MODEL_COL_VISIBLE, "EPHY_HISTORY_MODEL_COL_FIRST_VISIT", "first_visit" }, + + { 0, 0, 0 } + }; + + etype = g_enum_register_static ("EphyHistoryModelColumn", values); + } + + return etype; +} + diff --git a/src/ephy-history-model.h b/src/ephy-history-model.h new file mode 100644 index 000000000..6ff0058de --- /dev/null +++ b/src/ephy-history-model.h @@ -0,0 +1,84 @@ +/* + * Copyright (C) 2002 Jorn Baayen <jorn@nl.linux.org> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * $Id$ + */ + +#ifndef __EPHY_HISTORY_MODEL_H +#define __EPHY_HISTORY_MODEL_H + +#include <gtk/gtktreemodel.h> + +#include "ephy-node.h" +#include "ephy-node-filter.h" + +G_BEGIN_DECLS + +#define EPHY_TYPE_HISTORY_MODEL (ephy_history_model_get_type ()) +#define EPHY_HISTORY_MODEL(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), EPHY_TYPE_HISTORY_MODEL, EphyHistoryModel)) +#define EPHY_HISTORY_MODEL_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), EPHY_TYPE_HISTORY_MODEL, EphyHistoryModelClass)) +#define EPHY_IS_HISTORY_MODEL(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), EPHY_TYPE_HISTORY_MODEL)) +#define EPHY_IS_HISTORY_MODEL_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), EPHY_TYPE_HISTORY_MODEL)) +#define EPHY_HISTORY_MODEL_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), EPHY_TYPE_HISTORY_MODEL, EphyHistoryModelClass)) + +typedef enum +{ + EPHY_HISTORY_MODEL_COL_TITLE, + EPHY_HISTORY_MODEL_COL_LOCATION, + EPHY_HISTORY_MODEL_COL_VISITS, + EPHY_HISTORY_MODEL_COL_FIRST_VISIT, + EPHY_HISTORY_MODEL_COL_LAST_VISIT, + EPHY_HISTORY_MODEL_COL_VISIBLE, + EPHY_HISTORY_MODEL_NUM_COLUMNS +} EphyHistoryModelColumn; + +GType ephy_history_model_column_get_type (void); + +#define EPHY_TYPE_HISTORY_MODEL_COLUMN (ephy_history_model_column_get_type ()) + +typedef struct EphyHistoryModelPrivate EphyHistoryModelPrivate; + +typedef struct +{ + GObject parent; + + EphyHistoryModelPrivate *priv; + + int stamp; +} EphyHistoryModel; + +typedef struct +{ + GObjectClass parent; +} EphyHistoryModelClass; + +GType ephy_history_model_get_type (void); + +EphyHistoryModel *ephy_history_model_new (EphyNode *root, + EphyNode *pages, + EphyNodeFilter *filter); + +EphyNode *ephy_history_model_node_from_iter (EphyHistoryModel *model, + GtkTreeIter *iter); + +void ephy_history_model_iter_from_node (EphyHistoryModel *model, + EphyNode *node, + GtkTreeIter *iter); + +G_END_DECLS + +#endif /* EPHY_HISTORY_MODEL_H */ diff --git a/src/ephy-main.c b/src/ephy-main.c new file mode 100644 index 000000000..0a0093974 --- /dev/null +++ b/src/ephy-main.c @@ -0,0 +1,340 @@ +/* + * Copyright (C) 2000-2002 Marco Pesenti Gritti + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include "ephy-shell.h" +#include "ephy-automation.h" +#include "ephy-window.h" +#include "EphyAutomation.h" + +#include <libbonoboui.h> +#include <libgnome/gnome-program.h> +#include <libgnomeui/gnome-ui-init.h> +#include <libgnomeui/gnome-window-icon.h> +#include <libgnomevfs/gnome-vfs-init.h> +#include <glade/glade-init.h> + +#define EPHY_FACTORY_OAFIID "OAFIID:GNOME_Epiphany_Automation_Factory" + +static gboolean +ephy_main_automation_init (void); +static gint +ephy_main_translate_url_arguments (poptContext context, gchar ***urls); +static gboolean +ephy_main_start (gpointer data); + +GnomeProgram *program; +CORBA_Environment corba_env; /* Global for downloader */ +static gboolean open_in_existing = FALSE; /* load in existing window? */ +static gboolean open_in_new_tab = FALSE; /* force open in a new tab? */ +static gboolean noraise = FALSE; /* no raise */ +static gboolean open_in_new_window = FALSE; /* force open in a new window? */ +static gboolean open_fullscreen = FALSE; /* open ephy in full screen ? */ +static gchar *session_filename = NULL; /* the session filename */ +static gchar *geometry_string = NULL; /* the geometry string */ +static gchar *bookmark_url = NULL; /* the temp bookmark to add */ +static gboolean close_option = FALSE; /* --close */ +static gboolean quit_option = FALSE; /* --quit */ +static gboolean ephy_server_mode = FALSE; +static gboolean open_as_nautilus_view = FALSE; + +static BonoboObject *automation_object; +static gint n_urls; +static gchar **url; +static gboolean first_instance; + +/* command line argument parsing structure */ +static struct poptOption popt_options[] = +{ + { NULL, '\0', POPT_ARG_INCLUDE_TABLE, &bonobo_activation_popt_options, 0, NULL, + NULL }, + { "new-tab", 'n', POPT_ARG_NONE, &open_in_new_tab, 0, + N_("Open a new tab in an existing Ephy window"), + NULL }, + { "new-window", 'w', POPT_ARG_NONE, &open_in_new_window, 0, + N_("Open a new window in an existing Ephy process"), + NULL }, + { "noraise", '\0', POPT_ARG_NONE, &noraise, 0, + N_("Do not raise the window when opening a page in an existing Ephy process"), + NULL }, + { "fullscreen", 'f', POPT_ARG_NONE, &open_fullscreen, 0, + N_("Run Ephy in full screen mode"), + NULL }, + { "existing", 'x', POPT_ARG_NONE, &open_in_existing, 0, + N_("Attempt to load URL in existing Ephy window"), + NULL }, + { "load-session", 'l', POPT_ARG_STRING, &session_filename, 0, + N_("Load the given session file"), + N_("FILE") }, + { "server", 's', POPT_ARG_NONE, &ephy_server_mode, 0, + N_("Don't open any windows; instead act as a server " + "for quick startup of new Ephy instances"), + NULL }, + { "add-bookmark", 't', POPT_ARG_STRING, &bookmark_url, + 0, N_("Add a bookmark (don't open any window)"), + N_("URL")}, + { "geometry", 'g', POPT_ARG_STRING, &geometry_string, + 0, N_("Create the initial window with the given geometry.\n" + "see X(1) for the GEOMETRY format"), + N_("GEOMETRY")}, + { "close", 'c', POPT_ARG_NONE, &close_option, 0, + N_("Close all Ephy windows"), + NULL }, + { "quit", 'q', POPT_ARG_NONE, &quit_option, 0, + N_("Same as --close, but exits server mode too"), + NULL }, + { "nautilus-view", 'v', POPT_ARG_NONE, &open_as_nautilus_view, 0, + N_("Used internally by the nautilus view"), + NULL }, + + /* terminator, must be last */ + { NULL, 0, 0, NULL, 0, NULL, NULL } +}; + +int +main (int argc, char *argv[]) +{ + poptContext context; + GValue context_as_value = { 0 }; + GnomeProgram *program; + +#ifdef ENABLE_NLS + /* Initialize the i18n stuff */ + bindtextdomain(GETTEXT_PACKAGE, GNOMELOCALEDIR); + bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8"); + textdomain(GETTEXT_PACKAGE); +#endif + + program = gnome_program_init (PACKAGE, VERSION, + LIBGNOMEUI_MODULE, argc, argv, + GNOME_PARAM_POPT_TABLE, popt_options, + GNOME_PARAM_HUMAN_READABLE_NAME, _("Ephy"), + GNOME_PARAM_APP_DATADIR, DATADIR, + NULL); + + g_object_get_property (G_OBJECT (program), + GNOME_PARAM_POPT_CONTEXT, + g_value_init (&context_as_value, G_TYPE_POINTER)); + + context = g_value_get_pointer (&context_as_value); + + /* load arguments that aren't regular options (urls to load) */ + n_urls = ephy_main_translate_url_arguments (context, &url); + + first_instance = ephy_main_automation_init (); + + if (first_instance) + { + gnome_vfs_init (); + + glade_gnome_init (); + + gnome_window_icon_set_default_from_file (PIXMAP_DIR "/ephy.png"); + + ephy_shell_new (); + + g_idle_add ((GSourceFunc) ephy_main_start, NULL); + + bonobo_main (); + + gnome_vfs_shutdown (); + } + + return 0; +} + +static gboolean +ephy_main_start (gpointer data) +{ + GNOME_EphyAutomation gaserver; + int i; + + CORBA_exception_init (&corba_env); + + gaserver = bonobo_activation_activate_from_id ("OAFIID:GNOME_Epiphany_Automation", + 0, NULL, &corba_env); + + if (gaserver == NULL) + { + GtkWidget *dialog; + dialog = gtk_message_dialog_new + (NULL, + GTK_DIALOG_MODAL, + GTK_MESSAGE_ERROR, + GTK_BUTTONS_CLOSE, + "Ephy can't be used now. " + "Running the command \"bonobo-slay\" " + "from the console may fix the problem. If not, " + "you can try rebooting the computer or " + "installing Ephy again.\n\n" + "Bonobo couldn't locate the GNOME_Epiphany_Automation.server. "); + gtk_dialog_run (GTK_DIALOG (dialog)); + + } + /* FIXME ephy --server doesnt work when not first istance */ + /* Server mode */ + else if (ephy_server_mode) + { + g_object_ref (G_OBJECT(ephy_shell)); + } + /* load the session if requested */ + else if (session_filename) + { + GNOME_EphyAutomation_loadSession + (gaserver, session_filename, &corba_env); + } + /* if found and we're given a bookmark to add... */ + else if (bookmark_url != NULL) + { + GNOME_EphyAutomation_addBookmark + (gaserver, bookmark_url, &corba_env); + } + else if (close_option || quit_option) + { + GNOME_EphyAutomation_quit + (gaserver, quit_option, &corba_env); + } + /* provided with urls? */ + else if (n_urls == 0 && + !open_as_nautilus_view) + { + /* no, open a default window */ + GNOME_EphyAutomation_loadurl + (gaserver, "", + geometry_string ? + geometry_string : "", + open_fullscreen, + open_in_existing, + open_in_new_window, + open_in_new_tab, + !noraise, + &corba_env); + } + else + { + /* open all of the urls */ + for (i = 0; i < n_urls; i++) + { + GNOME_EphyAutomation_loadurl + (gaserver, url[i], + geometry_string ? + geometry_string : "", + open_fullscreen, + open_in_existing, + open_in_new_window, + open_in_new_tab, + !noraise, + &corba_env); + } + } + + /* Unref so it will exit if no more used */ + if (first_instance) + { + g_object_unref (G_OBJECT(ephy_shell)); + } + + if (gaserver) + { + bonobo_object_release_unref (gaserver, &corba_env); + } + + CORBA_exception_free (&corba_env); + + return FALSE; +} + +static gboolean +ephy_main_automation_init (void) +{ + CORBA_Object factory; + + factory = bonobo_activation_activate_from_id + (EPHY_FACTORY_OAFIID, + Bonobo_ACTIVATION_FLAG_EXISTING_ONLY, + NULL, NULL); + + if (!factory) + { + automation_object = ephy_automation_new (); + return TRUE; + } + else + { + ephy_main_start (NULL); + g_message (_("Ephy already running, using existing process")); + return FALSE; + } +} + +/** + * translate_url_arguments: gather URL arguments and expand them fully + * with realpath if they're filenames + */ +static gint +ephy_main_translate_url_arguments (poptContext context, gchar ***urls) +{ + gchar buffer[PATH_MAX]; + gchar **args; + gint i, n; + + /* any context remaining? */ + if (context == NULL) + { + *urls = NULL; + return 0; + } + + /* get the args and check */ + args = (gchar **) poptGetArgs (context); + if (args == NULL) + { + poptFreeContext (context); + *urls = NULL; + return 0; + } + + /* count args */ + for (n = 0; args[n] != NULL; n++) + /* nothing */; + + /* allocate pointer array */ + *urls = g_new0 (gchar *, n + 1); + + /* translate each one */ + for (i = 0; i < n; i++) + { + /* try to expand as files */ + if (realpath (args[i], buffer) != NULL) + { + (*urls)[i] = g_strconcat ("file://", buffer, NULL); + } + else + { + (*urls)[i] = g_strdup (args[i]); + } + } + poptFreeContext (context); + (*urls)[i] = NULL; + + /* return the number of urls */ + return n; +} diff --git a/src/ephy-nautilus-view.c b/src/ephy-nautilus-view.c new file mode 100644 index 000000000..f7a0ff867 --- /dev/null +++ b/src/ephy-nautilus-view.c @@ -0,0 +1,954 @@ +/* + * Copyright (C) 2001, 2002 Ricardo Fernández Pascual + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + +#include <config.h> +#include <libgnome/gnome-macros.h> +#include <bonobo/bonobo-zoomable.h> +#include <bonobo/bonobo-ui-util.h> +#include <string.h> +#include "ephy-embed-popup-control.h" +#include "ephy-nautilus-view.h" +#include "ephy-embed.h" +#include "ephy-embed-utils.h" +#include "find-dialog.h" +#include "print-dialog.h" +#include "ephy-prefs.h" +#include "eel-gconf-extensions.h" + +#define NOT_IMPLEMENTED g_warning ("not implemented: " G_STRLOC); +#define DEBUG_MSG(x) g_print x +//#define DEBUG_MSG(x) + +static void gnv_embed_location_cb (EphyEmbed *embed, + EphyNautilusView *view); +static void gnv_embed_title_cb (EphyEmbed *embed, + EphyNautilusView *view); +static void gnv_embed_new_window_cb (EphyEmbed *embed, + EphyEmbed **new_embed, + EmbedChromeMask chromemask, + EphyNautilusView *view); +static void gnv_embed_link_message_cb (EphyEmbed *embed, + const char *message, + EphyNautilusView *view); +static gint gnv_embed_dom_mouse_down_cb (EphyEmbed *embed, + EphyEmbedEvent *event, + EphyNautilusView *view); +static void gnv_embed_zoom_change_cb (EphyNautilusView *embed, + guint new_zoom, + EphyNautilusView *view); + + +static void gnv_load_location_cb (EphyNautilusView *view, + const char *location, + gpointer user_data); +static void gnv_stop_loading_cb (EphyNautilusView *view, + gpointer user_data); +static void gnv_bonobo_control_activate_cb (BonoboControl *control, + gboolean state, + EphyNautilusView *view); + +/* zoomable */ +static void gnv_zoomable_set_zoom_level_cb (BonoboZoomable *zoomable, + float level, + EphyNautilusView *view); +static void gnv_zoomable_zoom_in_cb (BonoboZoomable *zoomable, + EphyNautilusView *view); +static void gnv_zoomable_zoom_out_cb (BonoboZoomable *zoomable, + EphyNautilusView *view); +static void gnv_zoomable_zoom_to_fit_cb (BonoboZoomable *zoomable, + EphyNautilusView *view); +static void gnv_zoomable_zoom_to_default_cb (BonoboZoomable *zoomable, + EphyNautilusView *view); +/* commands */ +static void gnv_cmd_set_charset (BonoboUIComponent *uic, + EncodingMenuData *data, + const char* verbname); +static void gnv_cmd_file_print (BonoboUIComponent *uic, + EphyNautilusView *view, + const char* verbname); +static void gnv_cmd_edit_find (BonoboUIComponent *uic, + EphyNautilusView *view, + const char* verbname); + + +/* popups */ +static EphyNautilusView *gnv_view_from_popup (EphyEmbedPopup *popup); + +static void gnv_popup_cmd_new_window (BonoboUIComponent *uic, + EphyEmbedPopup *popup, + const char* verbname); +static void gnv_popup_cmd_image_in_new_window (BonoboUIComponent *uic, + EphyEmbedPopup *popup, + const char* verbname); +static void gnv_popup_cmd_frame_in_new_window (BonoboUIComponent *uic, + EphyEmbedPopup *popup, + const char* verbname); + + +static float preferred_zoom_levels[] = { + 0.2, 0.4, 0.6, 0.8, + 1.0, 1.2, 1.4, 1.6, 1.8, + 2.0, 2.2, 2.4, 2.6, 2.8, + 3.0, 3.2, 3.4, 3.6, 3.8, + 4.0, 4.2, 4.4, 4.6, 4.8, + 5.0, 5.2, 5.4, 5.6, 5.8, + 6.0, 6.2, 6.4, 6.6, 6.8, + 7.0, 7.2, 7.4, 7.6, 7.8, + 8.0, 8.2, 8.4, 8.6, 8.8, + 9.0, 9.2, 9.4, 9.6, 9.8, +}; + +static const gchar *preferred_zoom_level_names[] = { + "20%", "40%", "60%", "80%", + "100%", "120%", "140%", "160%", "180%", + "200%", "220%", "240%", "260%", "280%", + "300%", "320%", "340%", "360%", "380%", + "400%", "420%", "440%", "460%", "480%", + "500%", "520%", "540%", "560%", "580%", + "600%", "620%", "640%", "660%", "680%", + "700%", "720%", "740%", "760%", "780%", + "800%", "820%", "840%", "860%", "880%", + "900%", "920%", "940%", "960%", "980%", +}; +#define NUM_ZOOM_LEVELS (sizeof (preferred_zoom_levels) / sizeof (float)) + +struct EphyNautilusViewPrivate { + EphyEmbed *embed; + char *title; + char *location; + int load_percent; + + /* + BonoboPropertyBag *property_bag; + */ + + EphyEmbedPopupControl *popup; + BonoboUIComponent *popup_ui; + BonoboControl *control; + BonoboUIComponent *ui; + BonoboZoomable *zoomable; + + EphyDialog *find_dialog; +}; + +static BonoboUIVerb ephy_popup_verbs [] = { + BONOBO_UI_VERB ("EPOpenInNewWindow", (BonoboUIVerbFn) gnv_popup_cmd_new_window), + BONOBO_UI_VERB ("EPOpenImageInNewWindow", (BonoboUIVerbFn) gnv_popup_cmd_image_in_new_window), + BONOBO_UI_VERB ("DPOpenFrameInNewWindow", (BonoboUIVerbFn) gnv_popup_cmd_frame_in_new_window), + + BONOBO_UI_VERB_END +}; + +BonoboUIVerb ephy_verbs [] = { + BONOBO_UI_VERB ("FilePrint", (BonoboUIVerbFn) gnv_cmd_file_print), + BONOBO_UI_VERB ("EditFind", (BonoboUIVerbFn) gnv_cmd_edit_find), + BONOBO_UI_VERB_END +}; + +#define CHARSET_MENU_PATH "/menu/View/Encoding" + + +BONOBO_CLASS_BOILERPLATE (EphyNautilusView, ephy_nautilus_view, + NautilusView, NAUTILUS_TYPE_VIEW) + +static void +ephy_nautilus_view_instance_init (EphyNautilusView *view) +{ + GtkWidget *w; + EphyNautilusViewPrivate *p = g_new0 (EphyNautilusViewPrivate, 1); + + view->priv = p; + view->priv->embed = ephy_embed_new (G_OBJECT (ephy_shell_get_embed_shell (ephy_shell))); + + g_object_ref (G_OBJECT (ephy_shell)); + + g_signal_connect (view->priv->embed, "ge_link_message", + GTK_SIGNAL_FUNC (gnv_embed_link_message_cb), + view); + g_signal_connect (view->priv->embed, "ge_location", + GTK_SIGNAL_FUNC (gnv_embed_location_cb), + view); + g_signal_connect (view->priv->embed, "ge_title", + GTK_SIGNAL_FUNC (gnv_embed_title_cb), + view); +/* + g_signal_connect (view->priv->embed, "ge_js_status", + GTK_SIGNAL_FUNC (gnv_embed_js_status_cb), + view); + g_signal_connect (view->priv->embed, "ge_progress", + GTK_SIGNAL_FUNC (gnv_embed_progress_cb), + view); + g_signal_connect (view->priv->embed, "ge_net_state", + GTK_SIGNAL_FUNC (gnv_embed_net_state_cb), + view); +*/ + g_signal_connect (view->priv->embed, "ge_new_window", + GTK_SIGNAL_FUNC (gnv_embed_new_window_cb), + view); +/* + g_signal_connect (view->priv->embed, "ge_visibility", + GTK_SIGNAL_FUNC (gnv_embed_visibility_cb), + view); + g_signal_connect (view->priv->embed, "ge_destroy_brsr", + GTK_SIGNAL_FUNC (gnv_embed_destroy_brsr_cb), + view); + g_signal_connect (view->priv->embed, "ge_open_uri", + GTK_SIGNAL_FUNC (gnv_embed_open_uri_cb), + view); + g_signal_connect (view->priv->embed, "ge_size_to", + GTK_SIGNAL_FUNC (gnv_embed_size_to_cb), + view); + g_signal_connect (view->priv->embed, "ge_dom_mouse_click", + GTK_SIGNAL_FUNC (gnv_embed_dom_mouse_click_cb), + view); +*/ + g_signal_connect (view->priv->embed, "ge_dom_mouse_down", + GTK_SIGNAL_FUNC (gnv_embed_dom_mouse_down_cb), + view); +/* + g_signal_connect (view->priv->embed, "ge_security_change", + GTK_SIGNAL_FUNC (gnv_embed_security_change_cb), + view); +*/ + g_signal_connect (view->priv->embed, "ge_zoom_change", + GTK_SIGNAL_FUNC (gnv_embed_zoom_change_cb), + view); + + w = GTK_WIDGET (view->priv->embed); + gtk_widget_show (w); + + nautilus_view_construct (NAUTILUS_VIEW (view), w); + + g_signal_connect (G_OBJECT (view), "load_location", + G_CALLBACK (gnv_load_location_cb), NULL); + + g_signal_connect (G_OBJECT (view), "stop_loading", + G_CALLBACK (gnv_stop_loading_cb), NULL); + + g_signal_connect (G_OBJECT (nautilus_view_get_bonobo_control (NAUTILUS_VIEW (view))), + "activate", + G_CALLBACK (gnv_bonobo_control_activate_cb), view); + + view->priv->zoomable = bonobo_zoomable_new (); + bonobo_object_add_interface (BONOBO_OBJECT (view), + BONOBO_OBJECT (view->priv->zoomable)); + + bonobo_zoomable_set_parameters_full (view->priv->zoomable, + 1.0, + preferred_zoom_levels [0], + preferred_zoom_levels [NUM_ZOOM_LEVELS - 1], + FALSE, FALSE, TRUE, + preferred_zoom_levels, + preferred_zoom_level_names, + NUM_ZOOM_LEVELS); + + bonobo_object_add_interface (BONOBO_OBJECT (view), + BONOBO_OBJECT (view->priv->zoomable)); + + g_signal_connect (view->priv->zoomable, "set_zoom_level", + G_CALLBACK (gnv_zoomable_set_zoom_level_cb), view); + g_signal_connect (view->priv->zoomable, "zoom_in", + G_CALLBACK (gnv_zoomable_zoom_in_cb), view); + g_signal_connect (view->priv->zoomable, "zoom_out", + G_CALLBACK (gnv_zoomable_zoom_out_cb), view); + g_signal_connect (view->priv->zoomable, "zoom_to_fit", + G_CALLBACK (gnv_zoomable_zoom_to_fit_cb), view); + g_signal_connect (view->priv->zoomable, "zoom_to_default", + G_CALLBACK (gnv_zoomable_zoom_to_default_cb), view); + + p->control = nautilus_view_get_bonobo_control (NAUTILUS_VIEW (view)); + + p->popup_ui = bonobo_control_get_popup_ui_component (p->control); + g_assert (BONOBO_IS_UI_COMPONENT (p->popup_ui)); + bonobo_ui_util_set_ui (p->popup_ui, DATADIR, + "nautilus-ephy-view-ui.xml", + "EphyNutilusView", NULL); + p->popup = ephy_embed_popup_control_new (p->control); + ephy_embed_popup_connect_verbs (EPHY_EMBED_POPUP (p->popup), p->popup_ui); + g_object_set_data (G_OBJECT (p->popup), "NautilisView", view); + + bonobo_ui_component_add_verb_list_with_data (p->popup_ui, ephy_popup_verbs, p->popup); +} + +/** + * Returns a new EphyNautilusView as a BonoboObject + **/ +BonoboObject * +ephy_nautilus_view_new_component (EphyShell *gs) +{ + EphyNautilusView *view; + view = EPHY_NAUTILUS_VIEW (g_object_new (EPHY_TYPE_NAUTILUS_VIEW, NULL)); + return BONOBO_OBJECT (view); +} + +static void +ephy_nautilus_view_finalize (GObject *object) +{ + EphyNautilusView *view = EPHY_NAUTILUS_VIEW (object); + EphyNautilusViewPrivate *p = view->priv; + + if (p->find_dialog) + { + g_object_unref (p->find_dialog); + } + + g_object_unref (p->popup); + + g_free (p->title); + g_free (p->location); + g_free (p); + + GNOME_CALL_PARENT (G_OBJECT_CLASS, finalize, (object)); + + g_object_unref (G_OBJECT (ephy_shell)); +} + +static void +ephy_nautilus_view_class_init (EphyNautilusViewClass *class) +{ + G_OBJECT_CLASS (class)->finalize = ephy_nautilus_view_finalize; +} + + + +static gint +gnv_embed_dom_mouse_down_cb (EphyEmbed *embed, + EphyEmbedEvent *event, + EphyNautilusView *view) +{ + EphyNautilusViewPrivate *p = view->priv; + int button; + EmbedEventContext context; + + ephy_embed_event_get_mouse_button (event, &button); + ephy_embed_event_get_context (event, &context); + + if (button == 2) + { + ephy_embed_popup_set_event (EPHY_EMBED_POPUP (p->popup), event); + ephy_embed_popup_show (EPHY_EMBED_POPUP (p->popup), embed); + return TRUE; + + } + else if (button == 1 + && (context & EMBED_CONTEXT_LINK)) + { + GValue *value; + const gchar *url; + ephy_embed_event_get_property (event, "link", &value); + url = g_value_get_string (value); + + g_return_val_if_fail (url, FALSE); + + nautilus_view_open_location_force_new_window (NAUTILUS_VIEW (view), + url, NULL); + } + + return FALSE; +} + +static void +gnv_embed_link_message_cb (EphyEmbed *embed, const char *message, EphyNautilusView *view) +{ + g_return_if_fail (EPHY_IS_NAUTILUS_VIEW (view)); + g_return_if_fail (message != NULL); + + nautilus_view_report_status (NAUTILUS_VIEW (view), message); +} + +static void +gnv_embed_location_cb (EphyEmbed *embed, EphyNautilusView *view) +{ + EphyNautilusViewPrivate *p; + const gchar *prefixes_to_ignore[] = + { + "about:", + "javascript:", + NULL + }; + int i = 0; + gchar *new_uri; + + g_return_if_fail (EPHY_IS_NAUTILUS_VIEW (view)); + p = view->priv; + g_return_if_fail (view->priv->embed == embed); + + ephy_embed_get_location (embed, TRUE, FALSE, + &new_uri); + + g_return_if_fail (new_uri != NULL); + + + /* don't inform nautilus about uris that it can't understand */ + while (prefixes_to_ignore[i] != NULL) + { + if (!strncmp (prefixes_to_ignore[i], new_uri, strlen (prefixes_to_ignore[i]))) + { + g_free (new_uri); + return; + } + ++i; + } + + nautilus_view_report_location_change (NAUTILUS_VIEW (view), new_uri, NULL, new_uri); + + /* TODO, FIXME + nautilus_view_report_redirect (view, p->location, new_uri, NULL, new_uri); + */ + + + g_free (p->location); + p->location = new_uri; + + +} + +static void +gnv_embed_title_cb (EphyEmbed *embed, EphyNautilusView *view) +{ + EphyNautilusViewPrivate *p; + + g_return_if_fail (EPHY_IS_NAUTILUS_VIEW (view)); + p = view->priv; + g_return_if_fail (view->priv->embed == embed); + + g_free (p->title); + ephy_embed_get_title (embed, &p->title); + + nautilus_view_set_title (NAUTILUS_VIEW (view), p->title); +} + +static void +gnv_load_location_cb (EphyNautilusView *view, const char *location, gpointer user_data) +{ + g_return_if_fail (EPHY_IS_NAUTILUS_VIEW (view)); + g_return_if_fail (location != NULL); + + nautilus_view_report_load_underway (NAUTILUS_VIEW (view)); + ephy_embed_load_url (view->priv->embed, location); + +} + +static void +gnv_stop_loading_cb (EphyNautilusView *view, gpointer user_data) +{ +} + +static void +gnv_embed_new_window_cb (EphyEmbed *embed, EphyEmbed **new_embed, + EmbedChromeMask chromemask, EphyNautilusView *view) +{ + EphyTab *new_tab; + EphyWindow *window; + + window = ephy_window_new (); + if (!(chromemask & EMBED_CHROME_OPENASCHROME)) + { + ephy_window_set_chrome (window, + chromemask | + EMBED_CHROME_OPENASPOPUP); + } + new_tab = ephy_tab_new (); + ephy_window_add_tab (window, new_tab, FALSE); + + *new_embed = ephy_tab_get_embed (new_tab); +} + + +static void +gnv_bonobo_control_activate_cb (BonoboControl *control, gboolean state, EphyNautilusView *view) +{ + if (state) + { + EphyNautilusViewPrivate *p = view->priv; + + p->ui = nautilus_view_set_up_ui (NAUTILUS_VIEW (view), DATADIR, + "nautilus-ephy-view-ui.xml", "EphyNutilusView"); + g_return_if_fail (BONOBO_IS_UI_COMPONENT (p->ui)); + + ephy_embed_utils_build_charsets_submenu (p->ui, + CHARSET_MENU_PATH, + (BonoboUIVerbFn) gnv_cmd_set_charset, + view); + + bonobo_ui_component_add_verb_list_with_data (p->ui, ephy_verbs, view); + } +} + +static EphyNautilusView * +gnv_view_from_popup (EphyEmbedPopup *popup) +{ + return g_object_get_data (G_OBJECT (popup), "NautilisView"); +} + + +static void +gnv_popup_cmd_new_window (BonoboUIComponent *uic, + EphyEmbedPopup *popup, + const char* verbname) +{ + EphyEmbedEvent *info; + EphyNautilusView *view; + GValue *value; + + view = gnv_view_from_popup (popup); + + info = ephy_embed_popup_get_event (popup); + + ephy_embed_event_get_property (info, "link", &value); + + nautilus_view_open_location_force_new_window (NAUTILUS_VIEW (view), + g_value_get_string (value), NULL); +} + +static void +gnv_popup_cmd_image_in_new_window (BonoboUIComponent *uic, + EphyEmbedPopup *popup, + const char* verbname) +{ + EphyEmbedEvent *info; + EphyNautilusView *view; + GValue *value; + + view = gnv_view_from_popup (popup); + + info = ephy_embed_popup_get_event (popup); + + ephy_embed_event_get_property (info, "image", &value); + + nautilus_view_open_location_force_new_window (NAUTILUS_VIEW (view), + g_value_get_string (value), NULL); +} + +static void +gnv_popup_cmd_frame_in_new_window (BonoboUIComponent *uic, + EphyEmbedPopup *popup, + const char* verbname) +{ + EphyEmbedEvent *info; + EphyNautilusView *view; + gchar *location; + + view = gnv_view_from_popup (popup); + + info = ephy_embed_popup_get_event (popup); + + ephy_embed_get_location (view->priv->embed, FALSE, FALSE, &location); + + nautilus_view_open_location_force_new_window (NAUTILUS_VIEW (view), + location, NULL); +} + +void +gnv_cmd_set_charset (BonoboUIComponent *uic, + EncodingMenuData *data, + const char* verbname) +{ + EphyNautilusView *view = data->data; + EphyNautilusViewPrivate *p; + + g_return_if_fail (EPHY_IS_NAUTILUS_VIEW (view)); + + p = view->priv; + + DEBUG_MSG ((data->encoding)); + ephy_embed_set_charset (p->embed, data->encoding); +} + +static void +gnv_cmd_file_print (BonoboUIComponent *uic, + EphyNautilusView *view, + const char* verbname) +{ + EphyDialog *dialog; + EphyNautilusViewPrivate *p = view->priv; + + dialog = print_dialog_new (p->embed, NULL); + + //g_signal_connect (G_OBJECT(dialog), + // "preview", + // G_CALLBACK (print_dialog_preview_cb), + // window); + + ephy_dialog_set_modal (dialog, TRUE); + ephy_dialog_show (dialog); + +} + +static void +gnv_cmd_edit_find (BonoboUIComponent *uic, + EphyNautilusView *view, + const char* verbname) +{ + EphyNautilusViewPrivate *p = view->priv; + + if (!p->find_dialog) + { + p->find_dialog = find_dialog_new (p->embed); + } + + ephy_dialog_show (p->find_dialog); +} + + +/* zoomable */ +static void +gnv_zoomable_set_zoom_level_cb (BonoboZoomable *zoomable, + float level, + EphyNautilusView *view) +{ + gint zoom = level * 100; + g_return_if_fail (EPHY_IS_NAUTILUS_VIEW (view)); + if (zoom < 10) return; + if (zoom > 1000) return; + ephy_embed_zoom_set (view->priv->embed, zoom, TRUE); +} + +static void +gnv_zoomable_zoom_in_cb (BonoboZoomable *zoomable, + EphyNautilusView *view) +{ + gint zoom; + g_return_if_fail (EPHY_IS_NAUTILUS_VIEW (view)); + ephy_embed_zoom_get (view->priv->embed, &zoom); + if (zoom > 990) return; + ephy_embed_zoom_set (view->priv->embed, zoom + 10, TRUE); +} + +static void +gnv_zoomable_zoom_out_cb (BonoboZoomable *zoomable, + EphyNautilusView *view) +{ + gint zoom; + g_return_if_fail (EPHY_IS_NAUTILUS_VIEW (view)); + ephy_embed_zoom_get (view->priv->embed, &zoom); + if (zoom < 20) return; + ephy_embed_zoom_set (view->priv->embed, zoom - 10, TRUE); +} + +static void +gnv_zoomable_zoom_to_fit_cb (BonoboZoomable *zoomable, + EphyNautilusView *view) +{ + gnv_zoomable_zoom_to_default_cb (zoomable, view); +} + +static void +gnv_zoomable_zoom_to_default_cb (BonoboZoomable *zoomable, + EphyNautilusView *view) +{ + g_return_if_fail (EPHY_IS_NAUTILUS_VIEW (view)); + ephy_embed_zoom_set (view->priv->embed, 100, TRUE); +} + +static void +gnv_embed_zoom_change_cb (EphyNautilusView *embed, + guint new_zoom, + EphyNautilusView *view) +{ + float flevel; + g_return_if_fail (EPHY_IS_NAUTILUS_VIEW (view)); + + flevel = ((float) new_zoom) / 100.0; + + bonobo_zoomable_report_zoom_level_changed (view->priv->zoomable, + flevel, NULL); + +} + + +#ifdef IM_TOO_LAZY_TO_MOVE_THIS_TO_ANOTHER_FILE + + +/* property bag properties */ +enum { + ICON_NAME, + COMPONENT_INFO +}; + + +static void +get_bonobo_properties (BonoboPropertyBag *bag, + BonoboArg *arg, + guint arg_id, + CORBA_Environment *ev, + gpointer callback_data) +{ + EphyNautilusView *content_view; + + content_view = (EphyNautilusView*) callback_data; + + switch (arg_id) { + case ICON_NAME: + if (!strncmp (content_view->priv->uri, "man:", 4)) { + BONOBO_ARG_SET_STRING (arg, "manual"); + } else if (!strncmp (content_view->priv->uri, "http:", 5)) { + BONOBO_ARG_SET_STRING (arg, "i-web"); + } else if (!strncmp (content_view->priv->uri, "https:", 6)) { + /* FIXME: put a nice icon for secure sites */ + BONOBO_ARG_SET_STRING (arg, "i-web"); + } else { + BONOBO_ARG_SET_STRING (arg, ""); + } + break; + + case COMPONENT_INFO: + BONOBO_ARG_SET_STRING (arg, ""); + break; + + default: + g_warning ("Unhandled arg %d", arg_id); + break; + } +} + +/* there are no settable properties, so complain if someone tries to set one */ +static void +set_bonobo_properties (BonoboPropertyBag *bag, + const BonoboArg *arg, + guint arg_id, + CORBA_Environment *ev, + gpointer callback_data) +{ + g_warning ("Bad Property set on view: property ID %d", + arg_id); +} + +static void +ephy_nautilus_view_initialize (EphyNautilusView *view) +{ + + +#ifdef NOT_PORTED + bonobo_control_set_properties (nautilus_view_get_bonobo_control (view->priv->nautilus_view), + view->priv->property_bag); +#endif + bonobo_property_bag_add (view->priv->property_bag, "icon_name", ICON_NAME, + BONOBO_ARG_STRING, NULL, + _("name of icon for the mozilla view"), 0); + bonobo_property_bag_add (view->priv->property_bag, "summary_info", COMPONENT_INFO, + BONOBO_ARG_STRING, NULL, + _("mozilla summary info"), 0); +} + + + /* free the property bag */ + if (view->priv->property_bag != NULL) { + bonobo_object_unref (BONOBO_OBJECT (view->priv->property_bag)); + view->priv->property_bag = NULL; + } + +} + + + +void +ephy_nautilus_view_report_load_progress (EphyNautilusView *view, + double value) +{ + g_return_if_fail (EPHY_IS_NAUTILUS_VIEW (view)); + + if (value < 0.0) value = 0.0; + if (value > 1.0) value = 1.0; + + nautilus_view_report_load_progress (view->priv->nautilus_view, value); +} + +/***********************************************************************************/ + +/** + * vfs_open_cb + * + * Callback for gnome_vfs_async_open. Attempt to read data from handle + * and pass to mozilla streaming callback. + * + **/ +static void +vfs_open_cb (GnomeVFSAsyncHandle *handle, GnomeVFSResult result, gpointer data) +{ + EphyNautilusView *view = data; + + DEBUG_MSG (("+%s GnomeVFSResult: %u\n", G_GNUC_FUNCTION, (unsigned)result)); + + if (result != GNOME_VFS_OK) + { + gtk_moz_embed_close_stream (GTK_MOZ_EMBED (view->priv->embed->mozembed)); + /* NOTE: the view may go away after a call to report_load_failed */ + DEBUG_MSG ((">nautilus_view_report_load_failed\n")); + nautilus_view_report_load_failed (view->priv->nautilus_view); + } else { + if (view->priv->vfs_read_buffer == NULL) { + view->priv->vfs_read_buffer = g_malloc (VFS_READ_BUFFER_SIZE); + } + gtk_moz_embed_open_stream (GTK_MOZ_EMBED (view->priv->embed->mozembed), "file:///", "text/html"); + gnome_vfs_async_read (handle, view->priv->vfs_read_buffer, VFS_READ_BUFFER_SIZE, vfs_read_cb, view); + } + DEBUG_MSG (("-%s\n", G_GNUC_FUNCTION)); +} + +/** + * vfs_read_cb: + * + * Read data from buffer and copy into mozilla stream. + **/ + +static void +vfs_read_cb (GnomeVFSAsyncHandle *handle, GnomeVFSResult result, gpointer buffer, + GnomeVFSFileSize bytes_requested, + GnomeVFSFileSize bytes_read, + gpointer data) +{ + EphyNautilusView *view = data; + + DEBUG_MSG (("+%s %ld/%ld bytes\n", G_GNUC_FUNCTION, (long)bytes_requested, (long) bytes_read)); + + if (bytes_read != 0) { + gtk_moz_embed_append_data (GTK_MOZ_EMBED (view->priv->embed->mozembed), buffer, bytes_read); + } + + if (bytes_read == 0 || result != GNOME_VFS_OK) { + gtk_moz_embed_close_stream (GTK_MOZ_EMBED (view->priv->embed->mozembed)); + view->priv->vfs_handle = NULL; + g_free (view->priv->vfs_read_buffer); + view->priv->vfs_read_buffer = NULL; + + gnome_vfs_async_close (handle, (GnomeVFSAsyncCloseCallback) gtk_true, NULL); + + DEBUG_MSG ((">nautilus_view_report_load_complete\n")); + nautilus_view_report_load_complete (view->priv->nautilus_view); + + DEBUG_MSG (("=%s load complete\n", G_GNUC_FUNCTION)); + } else { + gnome_vfs_async_read (handle, view->priv->vfs_read_buffer, VFS_READ_BUFFER_SIZE, vfs_read_cb, view); + } + + DEBUG_MSG (("-%s\n", G_GNUC_FUNCTION)); +} + +/***********************************************************************************/ + +static void +cancel_pending_vfs_operation (EphyNautilusView *view) +{ + if (view->priv->vfs_handle != NULL) { + gnome_vfs_async_cancel (view->priv->vfs_handle); + gtk_moz_embed_close_stream (GTK_MOZ_EMBED (view->priv->embed->mozembed)); + } + + view->priv->vfs_handle = NULL; + g_free (view->priv->vfs_read_buffer); + view->priv->vfs_read_buffer = NULL; +} + + +/* this takes a "nautilus" uri, not a "mozilla" uri and uses (sometimes) GnomeVFS */ +static void +navigate_mozilla_to_nautilus_uri (EphyNautilusView *view, + const char *uri) +{ + char *old_uri; + + cancel_pending_vfs_operation (view); + + if (!GTK_WIDGET_REALIZED (view->priv->embed->mozembed)) { + + /* Doing certain things to gtkmozembed before + * the widget has realized (specifically, opening + * content streams) can cause crashes. To avoid + * this, we postpone all navigations + * until the widget has realized (we believe + * premature realization may cause other issues) + */ + + DEBUG_MSG (("=%s: Postponing navigation request to widget realization\n", G_GNUC_FUNCTION)); + /* Note that view->priv->uri is still set below */ + } else { + if (should_mozilla_load_uri_directly (uri)) { + + /* See if the current URI is the same as what mozilla already + * has. If so, issue a reload rather than a load. + * We ask mozilla for it's uri rather than using view->priv->uri because, + * from time to time, our understanding of mozilla's URI can become inaccurate + * (in particular, certain errors may cause embedded mozilla to not change + * locations) + */ + + old_uri = view->priv->embed->location; + + if (old_uri != NULL && uris_identical (uri, old_uri)) { + DEBUG_MSG (("=%s uri's identical, telling ephy to reload\n", G_GNUC_FUNCTION)); + embed_reload (view->priv->embed, + GTK_MOZ_EMBED_FLAG_RELOADBYPASSCACHE); + } else { + embed_load_url (view->priv->embed, uri); + } + + } else { + DEBUG_MSG (("=%s loading URI via gnome-vfs\n", G_GNUC_FUNCTION)); + gnome_vfs_async_open (&(view->priv->vfs_handle), uri, + GNOME_VFS_OPEN_READ, GNOME_VFS_PRIORITY_DEFAULT, + vfs_open_cb, view); + } + } + + g_free (view->priv->uri); + view->priv->uri = g_strdup (uri); + + DEBUG_MSG (("=%s current URI is now '%s'\n", G_GNUC_FUNCTION, view->priv->uri)); +} + +/* + * This a list of URI schemes that mozilla should load directly, rather than load through gnome-vfs + */ +static gboolean +should_mozilla_load_uri_directly (const char *uri) +{ + static const char *handled_by_mozilla[] = + { + "http", + "file", + "toc", + "man", + "info", + "ghelp", + "gnome-help", + "https", + NULL + }; + gint i; + gint uri_length; + + if (uri == NULL) return FALSE; + + uri_length = strlen (uri); + + for (i = 0; handled_by_mozilla[i] != NULL; i++) + { + const gchar *current = handled_by_mozilla[i]; + gint current_length = strlen (current); + if ((uri_length >= current_length) + && (!strncasecmp (uri, current, current_length))) + return TRUE; + } + return FALSE; +} + + + +#endif diff --git a/src/ephy-nautilus-view.h b/src/ephy-nautilus-view.h new file mode 100644 index 000000000..3dd13560b --- /dev/null +++ b/src/ephy-nautilus-view.h @@ -0,0 +1,84 @@ +/* + * Copyright (C) 2001, 2002 Ricardo Fernández Pascual + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + +#ifndef EPHY_NAUTILUS_VIEW_H +#define EPHY_NAUTILUS_VIEW_H + +#include <libnautilus/nautilus-view.h> +#include "ephy-shell.h" + +G_BEGIN_DECLS + +#define EPHY_TYPE_NAUTILUS_VIEW (ephy_nautilus_view_get_type ()) +#define EPHY_NAUTILUS_VIEW(obj) (GTK_CHECK_CAST ((obj), EPHY_TYPE_NAUTILUS_VIEW, \ + EphyNautilusView)) +#define EPHY_NAUTILUS_VIEW_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), EPHY_TYPE_NAUTILUS_VIEW, \ + EphyNautilusViewClass)) +#define EPHY_IS_NAUTILUS_VIEW(obj) (GTK_CHECK_TYPE ((obj), EPHY_TYPE_NAUTILUS_VIEW)) +#define EPHY_IS_NAUTILUS_VIEW_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), EPHY_IS_NAUTILUS_VIEW_CLASS)) + +typedef struct EphyNautilusView EphyNautilusView; +typedef struct EphyNautilusViewClass EphyNautilusViewClass; +typedef struct EphyNautilusViewPrivate EphyNautilusViewPrivate; + +struct EphyNautilusView +{ + NautilusView parent; + EphyNautilusViewPrivate *priv; +}; + +struct EphyNautilusViewClass +{ + NautilusViewClass parent_class; +}; + + +GType ephy_nautilus_view_get_type (void); +BonoboObject * ephy_nautilus_view_new_component (EphyShell *gs); + +/* old public methods, probably all of them are going to be killed */ + +void +ephy_nautilus_view_set_title (EphyNautilusView *view, + const gchar *title); +void +ephy_nautilus_view_set_location (EphyNautilusView *view, + const gchar *uri); +void +ephy_nautilus_view_set_statusbar (EphyNautilusView *view, + const gchar *message); +void +ephy_nautilus_view_report_load_underway (EphyNautilusView *view); + +void +ephy_nautilus_view_report_load_complete (EphyNautilusView *view); + +void +ephy_nautilus_view_report_load_progress (EphyNautilusView *view, + double value); +void +ephy_nautilus_view_report_zoom (EphyNautilusView *view, + gint level); + +void ephy_nautilus_view_open_in_new_window (EphyNautilusView *view, + const gchar *url); + +G_END_DECLS + +#endif diff --git a/src/ephy-shell.c b/src/ephy-shell.c new file mode 100644 index 000000000..eeacdf819 --- /dev/null +++ b/src/ephy-shell.c @@ -0,0 +1,525 @@ +/* + * Copyright (C) 2000, 2001, 2002 Marco Pesenti Gritti + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include "ephy-shell.h" +#include "ephy-embed-shell.h" +#include "eel-gconf-extensions.h" +#include "ephy-prefs.h" +#include "ephy-favicon-cache.h" +#include "ephy-stock-icons.h" +#include "ephy-filesystem-autocompletion.h" +#include "ephy-window.h" +#include "ephy-file-helpers.h" +#include "ephy-thread-helpers.h" + +#include <libgnomeui/gnome-client.h> +#include <bonobo/bonobo-main.h> +#include <bonobo/bonobo-i18n.h> +#include <gtk/gtksignal.h> +#include <gtk/gtkmain.h> +#include <gtk/gtkmessagedialog.h> + +#ifdef ENABLE_NAUTILUS_VIEW + +#include <bonobo/bonobo-generic-factory.h> +#include "ephy-nautilus-view.h" + +#define EPHY_NAUTILUS_VIEW_OAFIID "OAFIID:GNOME_Ephy_NautilusViewFactory" + +#endif + +struct EphyShellPrivate +{ + EphyEmbedShell *embed_shell; + Session *session; + EphyAutocompletion *autocompletion; + EphyBookmarks *bookmarks; +}; + +enum +{ + STARTPAGE_HOME, + STARTPAGE_LAST, + STARTPAGE_BLANK, +}; + +static void +ephy_shell_class_init (EphyShellClass *klass); +static void +ephy_shell_init (EphyShell *gs); +static void +ephy_shell_finalize (GObject *object); +static void +ephy_init_services (EphyShell *gs); + +#ifdef ENABLE_NAUTILUS_VIEW + +static void +ephy_nautilus_view_init_factory (EphyShell *gs); +static BonoboObject * +ephy_nautilus_view_new (BonoboGenericFactory *factory, + const char *id, + EphyShell *gs); + +#endif + +static GObjectClass *parent_class = NULL; + +EphyShell *ephy_shell; + +GType +ephy_shell_get_type (void) +{ + static GType ephy_shell_type = 0; + + if (ephy_shell_type == 0) + { + static const GTypeInfo our_info = + { + sizeof (EphyShellClass), + NULL, /* base_init */ + NULL, /* base_finalize */ + (GClassInitFunc) ephy_shell_class_init, + NULL, + NULL, /* class_data */ + sizeof (EphyShell), + 0, /* n_preallocs */ + (GInstanceInitFunc) ephy_shell_init + }; + + ephy_shell_type = g_type_register_static (G_TYPE_OBJECT, + "EphyShell", + &our_info, 0); + } + + return ephy_shell_type; + +} + +static void +ephy_shell_class_init (EphyShellClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + object_class->finalize = ephy_shell_finalize; +} + +static void +ephy_shell_new_window_cb (EphyEmbedShell *shell, + EphyEmbed **new_embed, + EmbedChromeMask chromemask, + gpointer data) +{ + EphyTab *new_tab; + EphyWindow *window; + gboolean open_in_tab; + + g_assert (new_embed != NULL); + + open_in_tab = (chromemask & EMBED_CHROME_OPENASCHROME) ? + FALSE : + eel_gconf_get_boolean (CONF_TABS_TABBED_POPUPS); + + if (open_in_tab) + { + window = ephy_shell_get_active_window (ephy_shell); + } + else + { + window = ephy_window_new (); + ephy_window_set_chrome (window, chromemask); + } + + new_tab = ephy_tab_new (); + ephy_window_add_tab (window, new_tab, FALSE); + *new_embed = ephy_tab_get_embed (new_tab); +} + +static void +ephy_shell_init (EphyShell *gs) +{ + ephy_shell = gs; + g_object_add_weak_pointer (G_OBJECT(ephy_shell), + (gpointer *)&ephy_shell); + + ephy_thread_helpers_init (); + ephy_node_system_init (); + ephy_file_helpers_init (); + ephy_stock_icons_init (); + ephy_ensure_dir_exists (ephy_dot_dir ()); + + gs->priv = g_new0 (EphyShellPrivate, 1); + gs->priv->session = NULL; + gs->priv->bookmarks = NULL; + + gs->priv->embed_shell = ephy_embed_shell_new ("mozilla"); + + g_assert (gs->priv->embed_shell != NULL); + + g_signal_connect (G_OBJECT(embed_shell), + "new_window_orphan", + G_CALLBACK(ephy_shell_new_window_cb), + NULL); + + ephy_init_services (gs); +} + +static void +ephy_shell_finalize (GObject *object) +{ + EphyShell *gs; + + g_return_if_fail (object != NULL); + g_return_if_fail (IS_EPHY_SHELL (object)); + + gs = EPHY_SHELL (object); + + g_return_if_fail (gs->priv != NULL); + + g_assert (ephy_shell == NULL); + + g_return_if_fail (IS_EPHY_EMBED_SHELL (gs->priv->embed_shell)); + g_object_unref (G_OBJECT (gs->priv->embed_shell)); + + if (gs->priv->session) + { + g_return_if_fail (IS_SESSION(gs->priv->session)); + g_object_remove_weak_pointer + (G_OBJECT(gs->priv->session), + (gpointer *)&gs->priv->session); + g_object_unref (G_OBJECT (gs->priv->session)); + } + + if (gs->priv->autocompletion) + { + g_object_unref (gs->priv->autocompletion); + } + + if (gs->priv->bookmarks) + { + g_object_unref (gs->priv->bookmarks); + } + + ephy_file_helpers_shutdown (); + ephy_node_system_shutdown (); + + g_free (gs->priv); + + G_OBJECT_CLASS (parent_class)->finalize (object); + +#ifdef DEBUG_MARCO + g_print ("Ephy shell finalized\n"); +#endif + + bonobo_main_quit (); + +#ifdef DEBUG_MARCO + g_print ("Bonobo quit done\n"); +#endif +} + +EphyShell * +ephy_shell_new (void) +{ + return EPHY_SHELL (g_object_new (EPHY_SHELL_TYPE, NULL)); +} + +/** + * ephy_shell_get_embed_shell: + * @gs: a #EphyShell + * + * Returns the embed shell created by the #EphyShell + * + * Return value: the embed shell + **/ +EphyEmbedShell * +ephy_shell_get_embed_shell (EphyShell *gs) +{ + g_return_val_if_fail (IS_EPHY_SHELL (gs), NULL); + + return gs->priv->embed_shell; +} + +static void +ephy_init_services (EphyShell *gs) +{ + /* preload the prefs */ + /* it also enables notifiers support */ + eel_gconf_monitor_add ("/apps/epiphany"); + eel_gconf_monitor_add ("/apps/nautilus/preferences"); + +#ifdef ENABLE_NAUTILUS_VIEW + + ephy_nautilus_view_init_factory (gs); + +#endif + +} + +static char * +build_homepage_url (EphyShell *gs, + EphyEmbed *previous_embed) +{ + const gchar *last_page_url; + gchar *home_page_url; + gint page_type; + EphyHistory *gh; + char *result = NULL; + + if (previous_embed == NULL) + { + page_type = STARTPAGE_HOME; + } + else + { + page_type = eel_gconf_get_integer (CONF_GENERAL_NEWPAGE_TYPE); + } + + /* return the appropriate page */ + if (page_type == STARTPAGE_HOME) + { + /* get location of home page */ + home_page_url = eel_gconf_get_string(CONF_GENERAL_HOMEPAGE); + result = home_page_url; + } + else if (page_type == STARTPAGE_LAST) + { + if (previous_embed != NULL) + { + ephy_embed_get_location (previous_embed, + TRUE, TRUE, + &result); + } + + if (result == NULL) + { + /* get location of last page */ + gh = ephy_embed_shell_get_global_history + (gs->priv->embed_shell); + last_page_url = ephy_history_get_last_page (gh); + result = g_strdup (last_page_url); + } + } + + if (result == NULL) + { + /* even in case of error, it's a good default */ + result = g_strdup ("about:blank"); + } + + return result; +} + +/** + * ephy_shell_get_active_window: + * @gs: a #EphyShell + * + * Get the current active window. Use it when you + * need to take an action (like opening an url) on + * a window but you dont have a target window. + * Ex. open a new tab from command line. + * + * Return value: the current active window + **/ +EphyWindow * +ephy_shell_get_active_window (EphyShell *gs) +{ + Session *session; + GList *windows; + + session = ephy_shell_get_session (gs); + windows = session_get_windows (session); + + if (windows == NULL) return NULL; + + return EPHY_WINDOW(windows->data); +} + +/** + * ephy_shell_new_tab: + * @shell: a #EphyShell + * @parent_window: the target #EphyWindow or %NULL + * @previous_tab: the referrer tab or %NULL + * @url: an url to load or %NULL + * + * Create a new tab and the parent window when necessary. + * Ever use this function to open urls in new window/tabs. + * + * ReturnValue: the created #EphyTab + **/ +EphyTab * +ephy_shell_new_tab (EphyShell *shell, + EphyWindow *parent_window, + EphyTab *previous_tab, + const char *url, + EphyNewTabFlags flags) +{ + EphyWindow *window; + EphyTab *tab; + EphyEmbed *embed; + gboolean in_new_window; + gboolean jump_to; + EphyEmbed *previous_embed = NULL; + + in_new_window = !eel_gconf_get_boolean (CONF_TABS_TABBED); + + if (flags & EPHY_NEW_TAB_IN_NEW_WINDOW) in_new_window = TRUE; + if (flags & EPHY_NEW_TAB_IN_EXISTING_WINDOW) in_new_window = FALSE; + + jump_to = eel_gconf_get_boolean (CONF_TABS_TABBED_AUTOJUMP); + + if (flags & EPHY_NEW_TAB_JUMP) jump_to = TRUE; + if (flags & EPHY_NEW_TAB_DONT_JUMP_TO) jump_to = FALSE; + + if (!in_new_window && parent_window != NULL) + { + window = parent_window; + } + else + { + window = ephy_window_new (); + } + + if (previous_tab) + { + previous_embed = ephy_tab_get_embed (previous_tab); + } + + tab = ephy_tab_new (); + embed = ephy_tab_get_embed (tab); + gtk_widget_show (GTK_WIDGET(embed)); + ephy_window_add_tab (window, tab, + jump_to); + gtk_widget_show (GTK_WIDGET(window)); + + if (flags & EPHY_NEW_TAB_HOMEPAGE) + { + char *homepage; + + homepage = build_homepage_url (shell, previous_embed); + g_assert (homepage != NULL); + + ephy_embed_load_url (embed, homepage); + + g_free (homepage); + } + else if ((flags & EPHY_NEW_TAB_IS_A_COPY) || + (flags & EPHY_NEW_TAB_VIEW_SOURCE)) + { + EmbedDisplayType display_type = + (flags & EPHY_NEW_TAB_VIEW_SOURCE) ? + DISPLAY_AS_SOURCE : DISPLAY_NORMAL; + EphyEmbed *source = ephy_tab_get_embed(previous_tab); + ephy_embed_load_url (embed, "about:blank"); + ephy_embed_copy_page (embed, source, display_type); + } + else if (url) + { + ephy_embed_load_url (embed, url); + } + + return tab; +} + +#ifdef ENABLE_NAUTILUS_VIEW + +static void +ephy_nautilus_view_init_factory (EphyShell *gs) +{ + BonoboGenericFactory *ephy_nautilusview_factory; + ephy_nautilusview_factory = bonobo_generic_factory_new + (EPHY_NAUTILUS_VIEW_OAFIID, + (BonoboFactoryCallback) ephy_nautilus_view_new, gs); + if (!BONOBO_IS_GENERIC_FACTORY (ephy_nautilusview_factory)) + g_warning ("Couldn't create the factory!"); + +} + +static BonoboObject * +ephy_nautilus_view_new (BonoboGenericFactory *factory, const char *id, + EphyShell *gs) +{ + return ephy_nautilus_view_new_component (gs); +} + +#endif + +/** + * ephy_shell_get_session: + * @gs: a #EphyShell + * + * Returns current session. + * + * Return value: the current session. + **/ +Session * +ephy_shell_get_session (EphyShell *gs) +{ + if (!gs->priv->session) + { + gs->priv->session = session_new (); + g_object_add_weak_pointer + (G_OBJECT(gs->priv->session), + (gpointer *)&gs->priv->session); + } + + return gs->priv->session; +} + +EphyAutocompletion * +ephy_shell_get_autocompletion (EphyShell *gs) +{ + EphyShellPrivate *p = gs->priv; + + if (!p->autocompletion) + { + static const gchar *prefixes[] = { + EPHY_AUTOCOMPLETION_USUAL_WEB_PREFIXES, + NULL + }; + + EphyHistory *gh = ephy_embed_shell_get_global_history (gs->priv->embed_shell); + EphyFilesystemAutocompletion *fa = ephy_filesystem_autocompletion_new (); + p->autocompletion = ephy_autocompletion_new (); + ephy_autocompletion_set_prefixes (p->autocompletion, prefixes); + + ephy_autocompletion_add_source (p->autocompletion, + EPHY_AUTOCOMPLETION_SOURCE (gh)); + ephy_autocompletion_add_source (p->autocompletion, + EPHY_AUTOCOMPLETION_SOURCE (fa)); + ephy_autocompletion_add_source (p->autocompletion, + EPHY_AUTOCOMPLETION_SOURCE (gs->priv->bookmarks)); + + g_object_unref (fa); + g_object_unref (gs->priv->bookmarks); + } + return p->autocompletion; +} + +EphyBookmarks * +ephy_shell_get_bookmarks (EphyShell *gs) +{ + if (gs->priv->bookmarks == NULL) + { + gs->priv->bookmarks = ephy_bookmarks_new (); + } + + return gs->priv->bookmarks; +} diff --git a/src/ephy-shell.h b/src/ephy-shell.h new file mode 100644 index 000000000..3590931f9 --- /dev/null +++ b/src/ephy-shell.h @@ -0,0 +1,101 @@ +/* + * Copyright (C) 2000, 2001, 2002 Marco Pesenti Gritti + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef EPHY_SHELL_H +#define EPHY_SHELL_H + +#include "ephy-autocompletion.h" +#include "prefs-dialog.h" +#include "downloader-view.h" +#include "ephy-embed-shell.h" +#include "session.h" +#include "ephy-bookmarks.h" + +#include <glib-object.h> +#include <glib.h> + +G_BEGIN_DECLS + +#ifndef EPHY_SHELL_TYPE_DEF +typedef struct EphyShell EphyShell; +#define EPHY_SHELL_TYPE_DEF +#endif + +typedef struct EphyShellClass EphyShellClass; + +#define EPHY_SHELL_TYPE (ephy_shell_get_type ()) +#define EPHY_SHELL(obj) (GTK_CHECK_CAST ((obj), EPHY_SHELL_TYPE, EphyShell)) +#define EPHY_SHELL_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), EPHY_SHELL, EphyShellClass)) +#define IS_EPHY_SHELL(obj) (GTK_CHECK_TYPE ((obj), EPHY_SHELL_TYPE)) +#define IS_EPHY_SHELL_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), EPHY_SHELL)) + +typedef struct EphyShellPrivate EphyShellPrivate; + +extern EphyShell *ephy_shell; + +typedef enum +{ + EPHY_NEW_TAB_HOMEPAGE = 1 << 0, + EPHY_NEW_TAB_FULLSCREEN = 1 << 1, + EPHY_NEW_TAB_APPEND = 1 << 2, + EPHY_NEW_TAB_PREPEND = 1 << 3, + EPHY_NEW_TAB_APPEND_AFTER_CURRENT = 1 << 4, + EPHY_NEW_TAB_JUMP = 1 << 5, + EPHY_NEW_TAB_DONT_JUMP_TO = 1 << 6, + EPHY_NEW_TAB_RAISE_WINDOW = 1 << 7, + EPHY_NEW_TAB_DONT_RAISE_WINDOW = 1 << 8, + EPHY_NEW_TAB_IN_NEW_WINDOW = 1 << 9, + EPHY_NEW_TAB_IN_EXISTING_WINDOW = 1 << 10, + EPHY_NEW_TAB_IS_A_COPY = 1 << 11, + EPHY_NEW_TAB_VIEW_SOURCE = 1 << 12 +} EphyNewTabFlags; + +struct EphyShell +{ + GObject parent; + EphyShellPrivate *priv; +}; + +struct EphyShellClass +{ + GObjectClass parent_class; +}; + +GType ephy_shell_get_type (void); + +EphyShell *ephy_shell_new (void); + +EphyEmbedShell *ephy_shell_get_embed_shell (EphyShell *gs); + +EphyWindow *ephy_shell_get_active_window (EphyShell *gs); + +EphyTab *ephy_shell_new_tab (EphyShell *shell, + EphyWindow *parent_window, + EphyTab *previous_tab, + const char *url, + EphyNewTabFlags flags); + +Session *ephy_shell_get_session (EphyShell *gs); + +EphyAutocompletion *ephy_shell_get_autocompletion (EphyShell *gs); + +EphyBookmarks *ephy_shell_get_bookmarks (EphyShell *gs); + +G_END_DECLS + +#endif diff --git a/src/ephy-tab.c b/src/ephy-tab.c new file mode 100644 index 000000000..b1fe71fb6 --- /dev/null +++ b/src/ephy-tab.c @@ -0,0 +1,945 @@ +/* + * Copyright (C) 2000, 2001, 2002 Marco Pesenti Gritti + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#define DEBUG_MSG(x) g_print x +//#define DEBUG_MSG(x) + +#define NOT_IMPLEMENTED g_warning ("not implemented: " G_STRLOC); + +#include "ephy-tab.h" +#include "ephy-shell.h" +#include "ephy-embed-popup-bw.h" +#include "eel-gconf-extensions.h" +#include "ephy-prefs.h" +#include "ephy-embed-prefs.h" + +#include <bonobo/bonobo-i18n.h> +#include <libgnomevfs/gnome-vfs-uri.h> +#include <gtk/gtklabel.h> +#include <gtk/gtkbutton.h> +#include <gtk/gtkstock.h> +#include <gtk/gtkmisc.h> +#include <gtk/gtkhbox.h> +#include <gtk/gtkimage.h> +#include <gtk/gtkiconfactory.h> +#include <gtk/gtkstyle.h> +#include <gtk/gtkselection.h> +#include <string.h> + +struct EphyTabPrivate +{ + EphyEmbed *embed; + EphyWindow *window; + gboolean is_active; + TabLoadStatus load_status; + char status_message[255]; + char *title; + char *location; + int load_percent; + gboolean visibility; + int cur_requests; + int total_requests; + int width; + int height; +}; + +static void +ephy_tab_class_init (EphyTabClass *klass); +static void +ephy_tab_init (EphyTab *tab); +static void +ephy_tab_finalize (GObject *object); + +enum +{ + PROP_0, + PROP_EPHY_SHELL +}; + +static void +ephy_tab_link_message_cb (EphyEmbed *embed, + const char *message, + EphyTab *tab); +static void +ephy_tab_js_status_cb (EphyEmbed *embed, + const char *status, + EphyTab *tab); +static void +ephy_tab_location_cb (EphyEmbed *embed, EphyTab *tab); +static void +ephy_tab_title_cb (EphyEmbed *embed, EphyTab *tab); +static void +ephy_tab_net_state_cb (EphyEmbed *embed, const char *uri, + EmbedState state, EphyTab *tab); +static void +ephy_tab_new_window_cb (EphyEmbed *embed, EphyEmbed **new_embed, + EmbedChromeMask chromemask, EphyTab *tab); +static void +ephy_tab_visibility_cb (EphyEmbed *embed, gboolean visibility, + EphyTab *tab); +static void +ephy_tab_destroy_brsr_cb (EphyEmbed *embed, EphyTab *tab); +static gint +ephy_tab_open_uri_cb (EphyEmbed *embed, const char *uri, + EphyTab *tab); +static void +ephy_tab_size_to_cb (EphyEmbed *embed, gint width, gint height, + EphyTab *tab); +static gint +ephy_tab_dom_mouse_click_cb (EphyEmbed *embed, + EphyEmbedEvent *event, + EphyTab *tab); +static gint +ephy_tab_dom_mouse_down_cb (EphyEmbed *embed, + EphyEmbedEvent *event, + EphyTab *tab); +static void +ephy_tab_security_change_cb (EphyEmbed *embed, EmbedSecurityLevel level, + EphyTab *tab); +static void +ephy_tab_zoom_changed_cb (EphyEmbed *embed, gint zoom, + EphyTab *tab); + +static GObjectClass *parent_class = NULL; + +/* Class functions */ + +GType +ephy_tab_get_type (void) +{ + static GType ephy_tab_type = 0; + + if (ephy_tab_type == 0) + { + static const GTypeInfo our_info = + { + sizeof (EphyTabClass), + NULL, /* base_init */ + NULL, /* base_finalize */ + (GClassInitFunc) ephy_tab_class_init, + NULL, + NULL, /* class_data */ + sizeof (EphyTab), + 0, /* n_preallocs */ + (GInstanceInitFunc) ephy_tab_init + }; + + ephy_tab_type = g_type_register_static (G_TYPE_OBJECT, + "EphyTab", + &our_info, 0); + } + + return ephy_tab_type; +} + +static void +ephy_tab_class_init (EphyTabClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + object_class->finalize = ephy_tab_finalize; +} + +static void +ephy_tab_parent_set_cb (GtkWidget *widget, GtkWidget *previous_parent, + EphyTab *tab) +{ + GtkWidget *toplevel; + + /* FIXME maybe we dont need to set the tab parent explicitly + * anymore with this callback taking care of it */ + + if (widget->parent == NULL) return; + + toplevel = gtk_widget_get_toplevel (widget); + + tab->priv->window = EPHY_WINDOW (toplevel); +} + +static void +ephy_tab_embed_destroy_cb (GtkWidget *widget, EphyTab *tab) +{ +#ifdef DEBUG_MARCO + g_print ("GtkMozEmbed destroy signal on EphyTab\n"); +#endif + g_object_unref (tab); +} + +static void +ephy_tab_init (EphyTab *tab) +{ + GObject *embed, *embed_widget; + EphyEmbedShell *shell; + + tab->priv = g_new0 (EphyTabPrivate, 1); + + shell = ephy_shell_get_embed_shell (ephy_shell); + + tab->priv->embed = ephy_embed_new (G_OBJECT(shell)); + + tab->priv->window = NULL; + tab->priv->is_active = FALSE; + *tab->priv->status_message = '\0'; + tab->priv->load_status = TAB_LOAD_NONE; + tab->priv->load_percent = 0; + tab->priv->title = NULL; + tab->priv->location = NULL; + tab->priv->total_requests = 0; + tab->priv->cur_requests = 0; + tab->priv->width = -1; + tab->priv->height = -1; + + + embed = G_OBJECT (tab->priv->embed); + embed_widget = G_OBJECT (tab->priv->embed); + + /* set a pointer in the embed's widget back to the tab */ + g_object_set_data (embed_widget, "EphyTab", tab); + + g_signal_connect (embed_widget, "parent_set", + G_CALLBACK (ephy_tab_parent_set_cb), + tab); + g_signal_connect (embed_widget, "destroy", + GTK_SIGNAL_FUNC (ephy_tab_embed_destroy_cb), + tab); + g_signal_connect (embed, "ge_link_message", + GTK_SIGNAL_FUNC (ephy_tab_link_message_cb), + tab); + g_signal_connect (embed, "ge_js_status", + GTK_SIGNAL_FUNC (ephy_tab_js_status_cb), + tab); + g_signal_connect (embed, "ge_location", + GTK_SIGNAL_FUNC (ephy_tab_location_cb), + tab); + g_signal_connect (embed, "ge_title", + GTK_SIGNAL_FUNC (ephy_tab_title_cb), + tab); + g_signal_connect (embed, "ge_zoom_change", + GTK_SIGNAL_FUNC (ephy_tab_zoom_changed_cb), + tab); + g_signal_connect (embed, "ge_net_state", + GTK_SIGNAL_FUNC (ephy_tab_net_state_cb), + tab); + g_signal_connect (embed, "ge_new_window", + GTK_SIGNAL_FUNC (ephy_tab_new_window_cb), + tab); + g_signal_connect (embed, "ge_visibility", + GTK_SIGNAL_FUNC (ephy_tab_visibility_cb), + tab); + g_signal_connect (embed, "ge_destroy_brsr", + GTK_SIGNAL_FUNC (ephy_tab_destroy_brsr_cb), + tab); + g_signal_connect (embed, "ge_open_uri", + GTK_SIGNAL_FUNC (ephy_tab_open_uri_cb), + tab); + g_signal_connect (embed, "ge_size_to", + GTK_SIGNAL_FUNC (ephy_tab_size_to_cb), + tab); + g_signal_connect (embed, "ge_dom_mouse_click", + GTK_SIGNAL_FUNC (ephy_tab_dom_mouse_click_cb), + tab); + g_signal_connect (embed, "ge_dom_mouse_down", + GTK_SIGNAL_FUNC (ephy_tab_dom_mouse_down_cb), + tab); + g_signal_connect (embed, "ge_security_change", + GTK_SIGNAL_FUNC (ephy_tab_security_change_cb), + tab); +} + +/* Destructor */ + +static void +ephy_tab_finalize (GObject *object) +{ + EphyTab *tab; + + g_return_if_fail (IS_EPHY_TAB (object)); + + tab = EPHY_TAB (object); + + g_return_if_fail (tab->priv != NULL); + + g_idle_remove_by_data (tab->priv->embed); + + g_free (tab->priv); + + G_OBJECT_CLASS (parent_class)->finalize (object); + +#ifdef DEBUG_MARCO + g_print ("EphyTab finalized %p\n", tab); +#endif +} + +/* Public functions */ + +EphyTab * +ephy_tab_new () +{ + EphyTab *tab; + + tab = EPHY_TAB (g_object_new (EPHY_TAB_TYPE, NULL)); + g_return_val_if_fail (tab->priv != NULL, NULL); + return tab; +} + +static void +ephy_tab_set_load_status (EphyTab *tab, + TabLoadStatus status) +{ + if (status == TAB_LOAD_COMPLETED) + { + Session *s; + s = ephy_shell_get_session (ephy_shell); + session_save (s, SESSION_CRASHED); + } + + if (ephy_tab_get_is_active (tab) && + status == TAB_LOAD_COMPLETED) + { + tab->priv->load_status = TAB_LOAD_NONE; + } + else + { + tab->priv->load_status = status; + } +} + +EphyEmbed * +ephy_tab_get_embed (EphyTab *tab) +{ + g_return_val_if_fail (IS_EPHY_TAB (G_OBJECT (tab)), NULL); + + return tab->priv->embed; +} + +void +ephy_tab_set_window (EphyTab *tab, EphyWindow *window) +{ + g_return_if_fail (IS_EPHY_TAB (G_OBJECT (tab))); + if (window) g_return_if_fail (IS_EPHY_WINDOW (G_OBJECT (window))); + + tab->priv->window = window; +} + +EphyWindow * +ephy_tab_get_window (EphyTab *tab) +{ + g_return_val_if_fail (IS_EPHY_TAB (G_OBJECT (tab)), NULL); + + return tab->priv->window; +} + +static void +ephy_tab_update_color (EphyTab *tab) +{ + TabLoadStatus status = ephy_tab_get_load_status (tab); + EphyNotebookPageLoadStatus page_status = 0; + GtkWidget *nb; + + nb = ephy_window_get_notebook (tab->priv->window); + + switch (status) + { + case TAB_LOAD_NONE: + page_status = EPHY_NOTEBOOK_TAB_LOAD_NORMAL; + break; + case TAB_LOAD_STARTED: + page_status = EPHY_NOTEBOOK_TAB_LOAD_LOADING; + break; + case TAB_LOAD_COMPLETED: + page_status = EPHY_NOTEBOOK_TAB_LOAD_COMPLETED; + break; + } + + ephy_notebook_set_page_status (EPHY_NOTEBOOK (nb), + GTK_WIDGET (tab->priv->embed), + page_status); +} + +void +ephy_tab_set_is_active (EphyTab *tab, gboolean is_active) +{ + TabLoadStatus status; + + g_return_if_fail (IS_EPHY_TAB (G_OBJECT (tab))); + + tab->priv->is_active = is_active; + + status = ephy_tab_get_load_status (tab); + if (status == TAB_LOAD_COMPLETED) + { + ephy_tab_set_load_status (tab, TAB_LOAD_NONE); + } + ephy_tab_update_color (tab); +} + +gboolean +ephy_tab_get_is_active (EphyTab *tab) +{ + g_return_val_if_fail (IS_EPHY_TAB (G_OBJECT (tab)), FALSE); + + return tab->priv->is_active; +} + +gboolean +ephy_tab_get_visibility (EphyTab *tab) +{ + return tab->priv->visibility; +} + +void +ephy_tab_get_size (EphyTab *tab, int *width, int *height) +{ + *width = tab->priv->width; + *height = tab->priv->height; +} + +static void +ephy_tab_set_visibility (EphyTab *tab, + gboolean visible) +{ + g_return_if_fail (tab->priv->window != NULL); + + /* FIXME show/hide the tab widget */ + + tab->priv->visibility = visible; +} + +/* Private callbacks for embed signals */ + +static void +ephy_tab_link_message_cb (EphyEmbed *embed, + const char *message, + EphyTab *tab) +{ + if (!tab->priv->is_active) return; + + g_strlcpy (tab->priv->status_message, + message, 255); + + ephy_window_update_control (tab->priv->window, + StatusbarMessageControl); +} + +static void +ephy_tab_js_status_cb (EphyEmbed *embed, + const char *status, + EphyTab *tab) +{ + if (!tab->priv->is_active) + return; + + g_strlcpy (tab->priv->status_message, + status, 255); + + ephy_window_update_control (tab->priv->window, + StatusbarMessageControl); +} + +static void +ephy_tab_location_cb (EphyEmbed *embed, EphyTab *tab) +{ + if (tab->priv->location) g_free (tab->priv->location); + ephy_embed_get_location (embed, TRUE, FALSE, + &tab->priv->location); + + if (tab->priv->is_active) + { + ephy_window_update_control (tab->priv->window, LocationControl); + ephy_window_update_control (tab->priv->window, NavControl); + } +} + +static void +ephy_tab_zoom_changed_cb (EphyEmbed *embed, gint zoom, EphyTab *tab) +{ + if (tab->priv->is_active) + { + ephy_window_update_control (tab->priv->window, ZoomControl); + } +} + +static void +ephy_tab_set_title (EphyTab *tab, const char *title) +{ + GtkWidget *nb; + + nb = ephy_window_get_notebook (tab->priv->window); + ephy_notebook_set_page_title (EPHY_NOTEBOOK (nb), + GTK_WIDGET (tab->priv->embed), + title); +} + +static void +ephy_tab_title_cb (EphyEmbed *embed, EphyTab *tab) +{ + if (tab->priv->title) g_free (tab->priv->title); + ephy_embed_get_title (embed, &tab->priv->title); + + if (*(tab->priv->title) == '\0') + { + g_free (tab->priv->title); + tab->priv->title = g_strdup (_("Untitled")); + } + + ephy_tab_set_title (tab, tab->priv->title); + + if (tab->priv->is_active) + { + ephy_window_update_control (tab->priv->window, + TitleControl); + } +} + +static int +build_load_percent (int bytes_loaded, int max_bytes_loaded) +{ + if (max_bytes_loaded > 0) + { + return (bytes_loaded * 100) / max_bytes_loaded; + } + else + { + return -1; + } +} + +static char * +get_host_name_from_uri (const char *uri) +{ + GnomeVFSURI *vfs_uri = NULL; + const char *host = NULL; + char *result; + + if (uri) + { + vfs_uri = gnome_vfs_uri_new (uri); + } + + if (vfs_uri) + { + host = gnome_vfs_uri_get_host_name (vfs_uri); + } + + if (!host) + { + host = _("site"); + } + + result = g_strdup (host); + + if (vfs_uri) gnome_vfs_uri_unref (vfs_uri); + + return result; +} + +static void +build_net_state_message (char *message, + const char *uri, + EmbedState flags) +{ + const char *msg = NULL; + char *host; + + host = get_host_name_from_uri (uri); + + /* IS_REQUEST and IS_NETWORK can be both set */ + + if (flags & EMBED_STATE_IS_REQUEST) + { + if (flags & EMBED_STATE_REDIRECTING) + { + msg = _("Redirecting to %s..."); + } + else if (flags & EMBED_STATE_TRANSFERRING) + { + msg = _("Transferring data from %s..."); + } + else if (flags & EMBED_STATE_NEGOTIATING) + { + msg = _("Waiting for authorization from %s..."); + } + } + + if (flags & EMBED_STATE_IS_NETWORK) + { + if (flags & EMBED_STATE_START) + { + msg = _("Loading %s..."); + } + else if (flags & EMBED_STATE_STOP) + { + msg = _("Done."); + } + } + + if (msg) + { + g_snprintf (message, 255, msg, host); + } + + g_free (host); +} + +static void +build_progress_from_requests (EphyTab *tab, EmbedState state) +{ + int load_percent; + + if (state & EMBED_STATE_IS_REQUEST) + { + if (state & EMBED_STATE_START) + { + tab->priv->total_requests ++; + } + else if (state & EMBED_STATE_STOP) + { + tab->priv->cur_requests ++; + } + + load_percent = build_load_percent (tab->priv->cur_requests, + tab->priv->total_requests); + if (load_percent > tab->priv->load_percent) + { + tab->priv->load_percent = load_percent; + } + } +} + +static void +ensure_location (EphyTab *tab, const char *uri) +{ + if (tab->priv->location == NULL) + { + tab->priv->location = g_strdup (uri); + ephy_window_update_control (tab->priv->window, + LocationControl); + } +} + +static void +ephy_tab_net_state_cb (EphyEmbed *embed, const char *uri, + EmbedState state, EphyTab *tab) +{ + build_net_state_message (tab->priv->status_message, uri, state); + + ephy_window_update_control (tab->priv->window, + StatusbarMessageControl); + + if (state & EMBED_STATE_IS_NETWORK) + { + if (state & EMBED_STATE_START) + { + tab->priv->total_requests = 0; + tab->priv->cur_requests = 0; + tab->priv->load_percent = 0; + + ensure_location (tab, uri); + + ephy_tab_set_load_status (tab, TAB_LOAD_STARTED); + + ephy_window_update_control (tab->priv->window, + NavControl); + ephy_window_update_control (tab->priv->window, + SpinnerControl); + ephy_tab_update_color (tab); + } + else if (state & EMBED_STATE_STOP) + { + tab->priv->load_percent = 0; + + ephy_tab_set_load_status (tab, TAB_LOAD_COMPLETED); + + ephy_window_update_control (tab->priv->window, + NavControl); + ephy_window_update_control (tab->priv->window, + SpinnerControl); + ephy_tab_update_color (tab); + } + } + + build_progress_from_requests (tab, state); + + ephy_window_update_control (tab->priv->window, + StatusbarProgressControl); +} + +static void +ephy_tab_new_window_cb (EphyEmbed *embed, EphyEmbed **new_embed, + EmbedChromeMask chromemask, EphyTab *tab) +{ + EphyTab *new_tab; + EphyWindow *window; + gboolean open_in_tab; + + open_in_tab = (chromemask & EMBED_CHROME_OPENASCHROME) ? + FALSE : + eel_gconf_get_boolean (CONF_TABS_TABBED_POPUPS); + + if (open_in_tab) + { + window = ephy_tab_get_window (tab); + } + else + { + window = ephy_window_new (); + ephy_window_set_chrome (window, chromemask); + } + + new_tab = ephy_tab_new (); + ephy_window_add_tab (window, new_tab, FALSE); + + *new_embed = ephy_tab_get_embed (new_tab); +} + +static gboolean +let_me_resize_hack (gpointer data) +{ + gtk_widget_set_size_request (GTK_WIDGET(data), + -1, -1); + return FALSE; +} + +static void +ephy_tab_visibility_cb (EphyEmbed *embed, gboolean visibility, + EphyTab *tab) +{ + EphyWindow *window; + + if (visibility) + { + gtk_widget_show (GTK_WIDGET(embed)); + } + else + { + gtk_widget_hide (GTK_WIDGET(embed)); + } + + ephy_tab_set_visibility (tab, visibility); + + window = ephy_tab_get_window (tab); + g_return_if_fail (window != NULL); + + ephy_window_update_control (window, WindowVisibilityControl); +} + +static void +ephy_tab_destroy_brsr_cb (EphyEmbed *embed, EphyTab *tab) +{ + EphyWindow *window; + + window = ephy_tab_get_window (tab); + + ephy_window_remove_tab (window, tab); +} + +static gint +ephy_tab_open_uri_cb (EphyEmbed *embed, const char *uri, + EphyTab *tab) +{ + return FALSE; +} + +static void +ephy_tab_size_to_cb (EphyEmbed *embed, gint width, gint height, + EphyTab *tab) +{ + GList *tabs; + EphyWindow *window; + GtkWidget *widget; + EmbedChromeMask chromemask; + + tab->priv->width = width; + tab->priv->height = height; + + window = ephy_tab_get_window (tab); + tabs = (GList *) ephy_window_get_tabs (window); + widget = GTK_WIDGET (embed); + chromemask = ephy_window_get_chrome (window); + + /* Do not resize window with multiple tabs. + * Do not resize window already showed because + * it's not possible to calculate a sensible window + * size based on the embed size */ + if (g_list_length (tabs) == 1 && !tab->priv->visibility) + { + gtk_widget_set_size_request + (widget, width, height); + + /* HACK reset widget requisition after the container + * has been resized. It appears to be the only way + * to have the window sized according to embed + * size correctly. + * We dont do it for XUL dialogs because in that case + * a "forced" requisition appear correct. + */ + if (!(chromemask & EMBED_CHROME_OPENASCHROME)) + { + g_idle_add (let_me_resize_hack, embed); + } + } +} + +static gint +ephy_tab_dom_mouse_click_cb (EphyEmbed *embed, + EphyEmbedEvent *event, + EphyTab *tab) +{ + return FALSE; +} + +static void +ephy_tab_show_embed_popup (EphyTab *tab, EphyEmbedEvent *event) +{ + EphyEmbedPopup *popup; + EphyWindow *window; + EphyEmbed *embed; + + window = ephy_tab_get_window (tab); + embed = ephy_tab_get_embed (tab); + + popup = EPHY_EMBED_POPUP (ephy_window_get_popup_factory (window)); + ephy_embed_popup_set_event (popup, event); + ephy_embed_popup_show (popup, embed); +} + +static gint +ephy_tab_dom_mouse_down_cb (EphyEmbed *embed, + EphyEmbedEvent *event, + EphyTab *tab) +{ + EphyWindow *window; + int button; + EmbedEventContext context; + + g_assert (IS_EPHY_EMBED_EVENT(event)); + + window = ephy_tab_get_window (tab); + g_return_val_if_fail (window != NULL, FALSE); + + ephy_embed_event_get_mouse_button (event, &button); + ephy_embed_event_get_context (event, &context); + + if (button == 2) + { + ephy_tab_show_embed_popup (tab, event); + } + else if (button == 1 + && (context & EMBED_CONTEXT_LINK)) + { + GValue *value; + + ephy_embed_event_get_property (event, "link", &value); + ephy_shell_new_tab (ephy_shell, window, tab, + g_value_get_string (value), 0); + } + else if (button == 1 + && !(context & EMBED_CONTEXT_LINK + || context & EMBED_CONTEXT_EMAIL_LINK + || context & EMBED_CONTEXT_INPUT)) + { + /* paste url */ + gtk_selection_convert (GTK_WIDGET (window), + GDK_SELECTION_PRIMARY, + GDK_SELECTION_TYPE_STRING, + GDK_CURRENT_TIME); + } + + return FALSE; +} + +static void +ephy_tab_security_change_cb (EphyEmbed *embed, EmbedSecurityLevel level, + EphyTab *tab) +{ + if (!tab->priv->is_active) return; + + ephy_window_update_control (tab->priv->window, + StatusbarSecurityControl); +} + +TabLoadStatus +ephy_tab_get_load_status (EphyTab *tab) +{ + return tab->priv->load_status; +} + +int +ephy_tab_get_load_percent (EphyTab *tab) +{ + return tab->priv->load_percent; +} + +const char * +ephy_tab_get_status_message (EphyTab *tab) +{ + if (tab->priv->status_message) + { + return tab->priv->status_message; + } + else + { + return " "; + } +} + +const char * +ephy_tab_get_title (EphyTab *tab) +{ + if (tab->priv->title && + g_utf8_strlen(tab->priv->title, -1)) + { + return tab->priv->title; + } + else + { + return _("Untitled"); + } +} + +const char * +ephy_tab_get_location (EphyTab *tab) +{ + return tab->priv->location; +} + +void +ephy_tab_set_location (EphyTab *tab, + char *location) +{ + if (tab->priv->location) g_free (tab->priv->location); + tab->priv->location = location; +} + +void +ephy_tab_update_control (EphyTab *tab, + TabControlID id) +{ + switch (id) + { + case TAB_CONTROL_TITLE: + ephy_tab_set_title (tab, tab->priv->title); + break; + } +} diff --git a/src/ephy-tab.h b/src/ephy-tab.h new file mode 100644 index 000000000..02e06746f --- /dev/null +++ b/src/ephy-tab.h @@ -0,0 +1,105 @@ +/* + * Copyright (C) 2000, 2001, 2002 Marco Pesenti Gritti + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef EPHY_TAB_H +#define EPHY_TAB_H + +#include "ephy-embed.h" + +#include <glib-object.h> + +G_BEGIN_DECLS + +typedef struct EphyTabClass EphyTabClass; + +#define EPHY_TAB_TYPE (ephy_tab_get_type ()) +#define EPHY_TAB(obj) (GTK_CHECK_CAST ((obj), EPHY_TAB_TYPE, EphyTab)) +#define EPHY_TAB_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), EPHY_TAB, EphyTabClass)) +#define IS_EPHY_TAB(obj) (GTK_CHECK_TYPE ((obj), EPHY_TAB_TYPE)) +#define IS_EPHY_TAB_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), EPHY_TAB)) + +typedef struct EphyTab EphyTab; +typedef struct EphyTabPrivate EphyTabPrivate; + +typedef enum +{ + TAB_CONTROL_TITLE +} TabControlID; + +typedef enum +{ + TAB_LOAD_NONE, + TAB_LOAD_STARTED, + TAB_LOAD_COMPLETED +} TabLoadStatus; + +struct EphyTab +{ + GObject parent; + EphyTabPrivate *priv; +}; + +struct EphyTabClass +{ + GObjectClass parent_class; +}; + +/* Include the header down here to resolve circular dependency */ +#include "ephy-window.h" + +GType ephy_tab_get_type (void); + +EphyTab *ephy_tab_new (void); + +EphyEmbed *ephy_tab_get_embed (EphyTab *tab); + +void ephy_tab_set_window (EphyTab *tab, + EphyWindow *window); + +EphyWindow *ephy_tab_get_window (EphyTab *tab); + +void ephy_tab_set_is_active (EphyTab *tab, + gboolean is_active); + +gboolean ephy_tab_get_is_active (EphyTab *tab); + +gboolean ephy_tab_get_visibility (EphyTab *tab); + +TabLoadStatus ephy_tab_get_load_status (EphyTab *tab); + +int ephy_tab_get_load_percent (EphyTab *tab); + +const char *ephy_tab_get_status_message (EphyTab *tab); + +const char *ephy_tab_get_title (EphyTab *tab); + +const char *ephy_tab_get_location (EphyTab *tab); + +void ephy_tab_set_location (EphyTab *tab, + char *location); + +void ephy_tab_get_size (EphyTab *tab, + int *width, + int *height); + +void ephy_tab_update_control (EphyTab *tab, + TabControlID id); + +G_END_DECLS + +#endif diff --git a/src/ephy-window.c b/src/ephy-window.c new file mode 100644 index 000000000..311d6202c --- /dev/null +++ b/src/ephy-window.c @@ -0,0 +1,1428 @@ +/* + * Copyright (C) 2000, 2001, 2002 Marco Pesenti Gritti + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include "ephy-window.h" +#include "ephy-favorites-menu.h" +#include "ephy-state.h" +#include "ephy-gobject-misc.h" +#include "statusbar.h" +#include "toolbar.h" +#include "ppview-toolbar.h" +#include "window-commands.h" +#include "find-dialog.h" +#include "history-dialog.h" +#include "popup-commands.h" +#include "ephy-shell.h" +#include "ephy-bonobo-extensions.h" +#include "eel-gconf-extensions.h" +#include "ephy-prefs.h" +#include "ephy-embed-utils.h" + +#include <string.h> +#include <bonobo/bonobo-window.h> +#include <bonobo/bonobo-i18n.h> +#include <bonobo/bonobo-ui-util.h> +#include <bonobo/bonobo-ui-component.h> +#include <libgnomevfs/gnome-vfs-uri.h> +#include <gtk/gtk.h> +#include <X11/X.h> +#include <X11/Xlib.h> +#include <gdk/gdkx.h> +#include <gdk/gdkkeysyms.h> + +#define CHARSET_MENU_PATH "/menu/View/EncodingMenuPlaceholder" +#define GO_FAVORITES_PATH "/menu/Go/Favorites" + +#define GO_BACK_CMD_PATH "/commands/GoBack" +#define GO_FORWARD_CMD_PATH "/commands/GoForward" +#define GO_UP_CMD_PATH "/commands/GoUp" +#define EDIT_FIND_NEXT_CMD_PATH "/commands/EditFindNext" +#define EDIT_FIND_PREV_CMD_PATH "/commands/EditFindPrev" +#define VIEW_MENUBAR_PATH "/commands/View Menubar" +#define VIEW_STATUSBAR_PATH "/commands/View Statusbar" +#define VIEW_TOOLBAR_PATH "/commands/View Toolbar" +#define VIEW_BOOKMARKSBAR_PATH "/commands/View BookmarksBar" +#define VIEW_FULLSCREEN_PATH "/commands/View Fullscreen" + +#define ID_VIEW_MENUBAR "View Menubar" +#define ID_VIEW_STATUSBAR "View Statusbar" +#define ID_VIEW_TOOLBAR "View Toolbar" +#define ID_VIEW_BOOKMARKSBAR "View BookmarksBar" +#define ID_VIEW_FULLSCREEN "View Fullscreen" + +static BonoboUIVerb ephy_verbs [] = { + BONOBO_UI_VERB ("EditFind", (BonoboUIVerbFn)window_cmd_edit_find), + BONOBO_UI_VERB ("FilePrint", (BonoboUIVerbFn)window_cmd_file_print), + BONOBO_UI_VERB ("GoStop", (BonoboUIVerbFn)window_cmd_go_stop), + BONOBO_UI_VERB ("GoReload", (BonoboUIVerbFn)window_cmd_go_reload), + BONOBO_UI_VERB ("GoBack", (BonoboUIVerbFn)window_cmd_go_back), + BONOBO_UI_VERB ("GoForward", (BonoboUIVerbFn)window_cmd_go_forward), + BONOBO_UI_VERB ("GoGo", (BonoboUIVerbFn)window_cmd_go_go), + BONOBO_UI_VERB ("GoUp", (BonoboUIVerbFn)window_cmd_go_up), + BONOBO_UI_VERB ("GoHome", (BonoboUIVerbFn)window_cmd_go_home), + BONOBO_UI_VERB ("GoMyportal", (BonoboUIVerbFn)window_cmd_go_myportal), + BONOBO_UI_VERB ("GoLocation", (BonoboUIVerbFn)window_cmd_go_location), + BONOBO_UI_VERB ("FileNew", (BonoboUIVerbFn)window_cmd_new), + BONOBO_UI_VERB ("FileNewWindow", (BonoboUIVerbFn)window_cmd_new_window), + BONOBO_UI_VERB ("FileNewTab", (BonoboUIVerbFn)window_cmd_new_tab), + BONOBO_UI_VERB ("FileOpen", (BonoboUIVerbFn)window_cmd_file_open), + BONOBO_UI_VERB ("FileSaveAs", (BonoboUIVerbFn)window_cmd_file_save_as), + BONOBO_UI_VERB ("FileCloseTab", (BonoboUIVerbFn)window_cmd_file_close_tab), + BONOBO_UI_VERB ("FileCloseWindow", (BonoboUIVerbFn)window_cmd_file_close_window), + BONOBO_UI_VERB ("FileSendTo", (BonoboUIVerbFn)window_cmd_file_send_to), + BONOBO_UI_VERB ("EditCut", (BonoboUIVerbFn)window_cmd_edit_cut), + BONOBO_UI_VERB ("EditCopy", (BonoboUIVerbFn)window_cmd_edit_copy), + BONOBO_UI_VERB ("EditPaste", (BonoboUIVerbFn)window_cmd_edit_paste), + BONOBO_UI_VERB ("EditSelectAll", (BonoboUIVerbFn)window_cmd_edit_select_all), + BONOBO_UI_VERB ("EditPrefs", (BonoboUIVerbFn)window_cmd_edit_prefs), + BONOBO_UI_VERB ("SettingsToolbarEditor", (BonoboUIVerbFn)window_cmd_settings_toolbar_editor), + BONOBO_UI_VERB ("Zoom In", (BonoboUIVerbFn)window_cmd_view_zoom_in), + BONOBO_UI_VERB ("EditFindNext", (BonoboUIVerbFn)window_cmd_edit_find_next), + BONOBO_UI_VERB ("EditFindPrev", (BonoboUIVerbFn)window_cmd_edit_find_prev), + BONOBO_UI_VERB ("Zoom Out", (BonoboUIVerbFn)window_cmd_view_zoom_out), + BONOBO_UI_VERB ("Zoom Normal", (BonoboUIVerbFn)window_cmd_view_zoom_normal), + BONOBO_UI_VERB ("ViewPageSource", (BonoboUIVerbFn)window_cmd_view_page_source), + BONOBO_UI_VERB ("BookmarksAddDefault", (BonoboUIVerbFn)window_cmd_bookmarks_add_default), + BONOBO_UI_VERB ("BookmarksEdit", (BonoboUIVerbFn)window_cmd_bookmarks_edit), + BONOBO_UI_VERB ("ToolsHistory", (BonoboUIVerbFn)window_cmd_tools_history), + BONOBO_UI_VERB ("ToolsPDM", (BonoboUIVerbFn)window_cmd_tools_pdm), + BONOBO_UI_VERB ("TabsNext", (BonoboUIVerbFn)window_cmd_tabs_next), + BONOBO_UI_VERB ("TabsPrevious", (BonoboUIVerbFn)window_cmd_tabs_previous), + BONOBO_UI_VERB ("TabsMoveLeft", (BonoboUIVerbFn)window_cmd_tabs_move_left), + BONOBO_UI_VERB ("TabsMoveRight", (BonoboUIVerbFn)window_cmd_tabs_move_right), + BONOBO_UI_VERB ("TabsDetach", (BonoboUIVerbFn)window_cmd_tabs_detach), + BONOBO_UI_VERB ("HelpContents", (BonoboUIVerbFn)window_cmd_help_manual), + BONOBO_UI_VERB ("About", (BonoboUIVerbFn)window_cmd_help_about), + + BONOBO_UI_VERB_END +}; + +static BonoboUIVerb ephy_popup_verbs [] = { + BONOBO_UI_VERB ("EPOpenInNewWindow", (BonoboUIVerbFn)popup_cmd_new_window), + BONOBO_UI_VERB ("EPOpenInNewTab", (BonoboUIVerbFn)popup_cmd_new_tab), + BONOBO_UI_VERB ("EPAddBookmark", (BonoboUIVerbFn)popup_cmd_add_bookmark), + BONOBO_UI_VERB ("EPOpenImageInNewWindow", (BonoboUIVerbFn)popup_cmd_image_in_new_window), + BONOBO_UI_VERB ("EPOpenImageInNewTab", (BonoboUIVerbFn)popup_cmd_image_in_new_tab), + BONOBO_UI_VERB ("DPOpenFrameInNewWindow", (BonoboUIVerbFn)popup_cmd_frame_in_new_window), + BONOBO_UI_VERB ("DPOpenFrameInNewTab", (BonoboUIVerbFn)popup_cmd_frame_in_new_tab), + BONOBO_UI_VERB ("DPAddFrameBookmark", (BonoboUIVerbFn)popup_cmd_add_frame_bookmark), + BONOBO_UI_VERB ("DPViewSource", (BonoboUIVerbFn)popup_cmd_view_source), + + BONOBO_UI_VERB_END +}; + +struct EphyWindowPrivate +{ + EphyFavoritesMenu *fav_menu; + PPViewToolbar *ppview_toolbar; + Toolbar *toolbar; + Statusbar *statusbar; + GtkNotebook *notebook; + EphyTab *active_tab; + GtkWidget *sidebar; + EphyEmbedPopupBW *embed_popup; + EphyDialog *find_dialog; + EphyDialog *history_dialog; + EphyDialog *history_sidebar; + EmbedChromeMask chrome_mask; + gboolean ignore_layout_toggles; + gboolean has_default_size; + gboolean closing; +}; + +static void +ephy_window_class_init (EphyWindowClass *klass); +static void +ephy_window_init (EphyWindow *gs); +static void +ephy_window_finalize (GObject *object); +static void +ephy_window_show (GtkWidget *widget); +static void +ephy_window_notebook_switch_page_cb (GtkNotebook *notebook, + GtkNotebookPage *page, + guint page_num, + EphyWindow *window); + +static void +ephy_window_tab_detached_cb (EphyNotebook *notebook, gint page, + gint x, gint y, gpointer data); + + +static GObjectClass *parent_class = NULL; + +GType +ephy_window_get_type (void) +{ + static GType ephy_window_type = 0; + + if (ephy_window_type == 0) + { + static const GTypeInfo our_info = + { + sizeof (EphyWindowClass), + NULL, /* base_init */ + NULL, /* base_finalize */ + (GClassInitFunc) ephy_window_class_init, + NULL, + NULL, /* class_data */ + sizeof (EphyWindow), + 0, /* n_preallocs */ + (GInstanceInitFunc) ephy_window_init + }; + + ephy_window_type = g_type_register_static (BONOBO_TYPE_WINDOW, + "EphyWindow", + &our_info, 0); + } + + return ephy_window_type; +} + +static void +ephy_window_class_init (EphyWindowClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + object_class->finalize = ephy_window_finalize; + + widget_class->show = ephy_window_show; +} + +static +gboolean +ephy_window_key_press_event_cb (GtkWidget *widget, + GdkEventKey *event, + EphyWindow *window) +{ + int page; + + if ((event->state & GDK_Shift_L) || (event->state & GDK_Shift_R)) + return FALSE; + + if ((event->state & GDK_Alt_L) || (event->state & GDK_Alt_R)) + { + page = event->keyval - GDK_0 -1; + + if (page == -1) page = 9; + + if (page>=-1 && page<=9) + { + gtk_notebook_set_current_page + (GTK_NOTEBOOK (window->priv->notebook), + page == -1 ? -1 : page); + return TRUE; + } + } + + return FALSE; +} + +static void +ephy_window_selection_received_cb (GtkWidget *widget, + GtkSelectionData *selection_data, + guint time, EphyWindow *window) +{ + EphyTab *tab; + + if (selection_data->length <= 0 || selection_data->data == NULL) + return; + + tab = ephy_window_get_active_tab (window); + ephy_shell_new_tab (ephy_shell, window, tab, + selection_data->data, 0); +} + +static void +save_window_state (GtkWidget *win) +{ + EphyWindow *window = EPHY_WINDOW (win); + + if (!(window->priv->chrome_mask & EMBED_CHROME_OPENASPOPUP) && + !(window->priv->chrome_mask & EMBED_CHROME_OPENASFULLSCREEN)) + { + ephy_state_save_window (win, "main_window"); + } +} + +static gboolean +ephy_window_configure_event_cb (GtkWidget *widget, + GdkEventConfigure *event, + gpointer data) +{ + save_window_state (widget); + return FALSE; +} + +static gboolean +ephy_window_state_event_cb (GtkWidget *widget, + GdkEventWindowState *event, + gpointer data) +{ + save_window_state (widget); + return FALSE; +} + +static void +setup_bonobo_window (EphyWindow *window, + BonoboUIComponent **ui_component) +{ + BonoboWindow *win = BONOBO_WINDOW(window); + BonoboUIContainer *container; + Bonobo_UIContainer corba_container; + + container = bonobo_window_get_ui_container (win); + + bonobo_ui_engine_config_set_path (bonobo_window_get_ui_engine (win), + "/apps/ephy/UIConfig/kvps"); + + corba_container = BONOBO_OBJREF (container); + + *ui_component = bonobo_ui_component_new_default (); + + bonobo_ui_component_set_container (*ui_component, + corba_container, + NULL); + + bonobo_ui_util_set_ui (*ui_component, + DATADIR, + "epiphany-ui.xml", + "ephy", NULL); + + /* Key handling */ + g_signal_connect(G_OBJECT(win), + "key-press-event", + G_CALLBACK(ephy_window_key_press_event_cb), + window); + + g_signal_connect (G_OBJECT(win), "configure_event", + G_CALLBACK (ephy_window_configure_event_cb), NULL); + g_signal_connect (G_OBJECT(win), "window_state_event", + G_CALLBACK (ephy_window_state_event_cb), NULL); + + g_signal_connect (G_OBJECT(win), + "selection-received", + G_CALLBACK (ephy_window_selection_received_cb), + window); +} + +static EphyEmbedPopupBW * +setup_popup_factory (EphyWindow *window, + BonoboUIComponent *ui_component) +{ + EphyEmbedPopupBW *popup; + + popup = ephy_window_get_popup_factory (window); + g_object_set_data (G_OBJECT(popup), "EphyWindow", window); + bonobo_ui_component_add_verb_list_with_data (ui_component, + ephy_popup_verbs, + popup); + + return popup; +} + +static GtkNotebook * +setup_notebook (EphyWindow *window) +{ + GtkNotebook *notebook; + + notebook = GTK_NOTEBOOK (ephy_notebook_new ()); + gtk_notebook_set_scrollable (notebook, TRUE); + gtk_notebook_set_show_border (notebook, FALSE); + gtk_notebook_set_show_tabs (notebook, FALSE); + + g_signal_connect_after (G_OBJECT (notebook), "switch_page", + G_CALLBACK ( + ephy_window_notebook_switch_page_cb), + window); + + g_signal_connect (G_OBJECT (notebook), "tab_detached", + G_CALLBACK (ephy_window_tab_detached_cb), + NULL); + + gtk_widget_show (GTK_WIDGET (notebook)); + + return notebook; +} + +static void +view_toolbar_changed_cb (BonoboUIComponent *component, + const char *path, + Bonobo_UIComponent_EventType type, + const char *state, + EphyWindow *window) +{ + EmbedChromeMask mask; + + if (window->priv->ignore_layout_toggles) return; + + mask = ephy_window_get_chrome (window); + mask ^= EMBED_CHROME_TOOLBARON; + ephy_window_set_chrome (window, mask); +} + +static void +view_statusbar_changed_cb (BonoboUIComponent *component, + const char *path, + Bonobo_UIComponent_EventType type, + const char *state, + EphyWindow *window) +{ + EmbedChromeMask mask; + + if (window->priv->ignore_layout_toggles) return; + + mask = ephy_window_get_chrome (window); + mask ^= EMBED_CHROME_STATUSBARON; + ephy_window_set_chrome (window, mask); +} + +static void +view_fullscreen_changed_cb (BonoboUIComponent *component, + const char *path, + Bonobo_UIComponent_EventType type, + const char *state, + EphyWindow *window) +{ + EmbedChromeMask mask; + + if (window->priv->ignore_layout_toggles) return; + + mask = ephy_window_get_chrome (window); + mask ^= EMBED_CHROME_OPENASFULLSCREEN; + mask |= EMBED_CHROME_DEFAULT; + ephy_window_set_chrome (window, mask); +} + +static void +update_layout_toggles (EphyWindow *window) +{ + BonoboUIComponent *ui_component = BONOBO_UI_COMPONENT (window->ui_component); + EmbedChromeMask mask = window->priv->chrome_mask; + + window->priv->ignore_layout_toggles = TRUE; + + ephy_bonobo_set_toggle_state (ui_component, VIEW_TOOLBAR_PATH, + mask & EMBED_CHROME_TOOLBARON); + ephy_bonobo_set_toggle_state (ui_component, VIEW_STATUSBAR_PATH, + mask & EMBED_CHROME_STATUSBARON); + ephy_bonobo_set_toggle_state (ui_component, VIEW_FULLSCREEN_PATH, + mask & EMBED_CHROME_OPENASFULLSCREEN); + + window->priv->ignore_layout_toggles = FALSE; +} + +static void +setup_layout_menus (EphyWindow *window) +{ + BonoboUIComponent *ui_component = BONOBO_UI_COMPONENT (window->ui_component); + + bonobo_ui_component_add_listener (ui_component, ID_VIEW_TOOLBAR, + (BonoboUIListenerFn)view_toolbar_changed_cb, + window); + bonobo_ui_component_add_listener (ui_component, ID_VIEW_STATUSBAR, + (BonoboUIListenerFn)view_statusbar_changed_cb, + window); + bonobo_ui_component_add_listener (ui_component, ID_VIEW_FULLSCREEN, + (BonoboUIListenerFn)view_fullscreen_changed_cb, + window); +} + +static void +ephy_window_init (EphyWindow *window) +{ + BonoboUIComponent *ui_component; + Session *session; + + session = ephy_shell_get_session (ephy_shell); + + window->priv = g_new0 (EphyWindowPrivate, 1); + window->priv->embed_popup = NULL; + window->priv->active_tab = NULL; + window->priv->chrome_mask = 0; + window->priv->ignore_layout_toggles = FALSE; + window->priv->closing = FALSE; + window->priv->has_default_size = FALSE; + + /* Setup the window and connect verbs */ + setup_bonobo_window (window, &ui_component); + window->ui_component = G_OBJECT (ui_component); + bonobo_ui_component_add_verb_list_with_data (ui_component, + ephy_verbs, + window); + setup_layout_menus (window); + + /* Setup the embed popups factory */ + window->priv->embed_popup = setup_popup_factory (window, + ui_component); + + bonobo_ui_component_freeze (ui_component, NULL); + + /* Setup menubar */ + ephy_embed_utils_build_charsets_submenu (ui_component, + CHARSET_MENU_PATH, + (BonoboUIVerbFn)window_cmd_set_charset, + window); + window->priv->fav_menu = ephy_favorites_menu_new (window); + ephy_favorites_menu_set_path (window->priv->fav_menu, GO_FAVORITES_PATH); + + /* Setup toolbar and statusbar */ + window->priv->toolbar = toolbar_new (window); + window->priv->statusbar = statusbar_new (window); + window->priv->ppview_toolbar = ppview_toolbar_new (window); + + /* Setup window contents */ + window->priv->notebook = setup_notebook (window); + bonobo_window_set_contents (BONOBO_WINDOW (window), + GTK_WIDGET (window->priv->notebook)); + + bonobo_ui_component_thaw (ui_component, NULL); + + g_object_ref (ephy_shell); + + /*Once window is fully created, add it to the session list*/ + session_add_window (session, window); +} + +static void +save_window_chrome (EphyWindow *window) +{ + EmbedChromeMask flags = window->priv->chrome_mask; + + if (flags & EMBED_CHROME_OPENASPOPUP) + { + } + else if (flags & EMBED_CHROME_PPVIEWTOOLBARON) + { + } + else if (flags & EMBED_CHROME_OPENASFULLSCREEN) + { + eel_gconf_set_boolean (CONF_WINDOWS_FS_SHOW_TOOLBARS, + flags & EMBED_CHROME_TOOLBARON); + eel_gconf_set_boolean (CONF_WINDOWS_FS_SHOW_STATUSBAR, + flags & EMBED_CHROME_STATUSBARON); + } + else + { + eel_gconf_set_boolean (CONF_WINDOWS_SHOW_TOOLBARS, + flags & EMBED_CHROME_TOOLBARON); + eel_gconf_set_boolean (CONF_WINDOWS_SHOW_STATUSBAR, + flags & EMBED_CHROME_STATUSBARON); + } +} + +static void +remove_from_session (EphyWindow *window) +{ + Session *session; + + session = ephy_shell_get_session (ephy_shell); + g_return_if_fail (session != NULL); + + session_remove_window (session, window); +} + +static void +ephy_window_finalize (GObject *object) +{ + EphyWindow *window; + + g_return_if_fail (IS_EPHY_WINDOW (object)); + + window = EPHY_WINDOW (object); + + g_return_if_fail (window->priv != NULL); + + remove_from_session (window); + + if (window->priv->embed_popup) + { + g_object_unref (G_OBJECT (window->priv->embed_popup)); + } + + g_object_unref (G_OBJECT (window->priv->toolbar)); + g_object_unref (G_OBJECT (window->priv->statusbar)); + + if (window->priv->find_dialog) + { + g_object_unref (G_OBJECT (window->priv->find_dialog)); + } + + if (window->priv->history_dialog) + { + g_object_remove_weak_pointer + (G_OBJECT(window->priv->history_dialog), + (gpointer *)&window->priv->history_dialog); + } + + g_free (window->priv); + + G_OBJECT_CLASS (parent_class)->finalize (object); + +#ifdef DEBUG_MARCO + g_print ("Ephy Window finalized %p\n", window); +#endif + + g_object_unref (ephy_shell); +} + +EphyWindow * +ephy_window_new (void) +{ + return EPHY_WINDOW (g_object_new (EPHY_WINDOW_TYPE, NULL)); +} + +static void +dock_item_set_visibility (EphyWindow *window, + const char *path, + gboolean visibility) +{ + ephy_bonobo_set_hidden (BONOBO_UI_COMPONENT(window->ui_component), + path, + !visibility); +} + +EmbedChromeMask +ephy_window_get_chrome (EphyWindow *window) +{ + return window->priv->chrome_mask; +} + +static void +wmspec_change_state (gboolean add, + GdkWindow *window, + GdkAtom state1, + GdkAtom state2) +{ + XEvent xev; + + #define _NET_WM_STATE_REMOVE 0 /* remove/unset property */ + #define _NET_WM_STATE_ADD 1 /* add/set property */ + #define _NET_WM_STATE_TOGGLE 2 /* toggle property */ + + xev.xclient.type = ClientMessage; + xev.xclient.serial = 0; + xev.xclient.send_event = True; + xev.xclient.display = gdk_display; + xev.xclient.window = GDK_WINDOW_XID (window); + xev.xclient.message_type = gdk_x11_get_xatom_by_name ("_NET_WM_STATE"); + xev.xclient.format = 32; + xev.xclient.data.l[0] = add ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE; + xev.xclient.data.l[1] = gdk_x11_atom_to_xatom (state1); + xev.xclient.data.l[2] = gdk_x11_atom_to_xatom (state2); + + XSendEvent (gdk_display, GDK_WINDOW_XID (gdk_get_default_root_window ()), + False, + SubstructureRedirectMask | SubstructureNotifyMask, + &xev); +} + +static void +window_set_fullscreen_mode (EphyWindow *window, gboolean active) +{ + GdkWindow *gdk_window; + + gdk_window = GTK_WIDGET(window)->window; + + if (gdk_net_wm_supports (gdk_atom_intern ("_NET_WM_STATE_FULLSCREEN", + FALSE))) + { + wmspec_change_state (active, + gdk_window, + gdk_atom_intern ("_NET_WM_STATE_FULLSCREEN", + FALSE), + GDK_NONE); + } + else + { + g_warning ("NET_WM_STATE_FULLSCREEN not supported"); + } +} + +static void +translate_default_chrome (EmbedChromeMask *chrome_mask) +{ + /* keep only not layout flags */ + *chrome_mask &= (EMBED_CHROME_WINDOWRAISED | + EMBED_CHROME_WINDOWLOWERED | + EMBED_CHROME_CENTERSCREEN | + EMBED_CHROME_OPENASDIALOG | + EMBED_CHROME_OPENASCHROME | + EMBED_CHROME_OPENASPOPUP | + EMBED_CHROME_OPENASFULLSCREEN); + + /* Load defaults */ + if (*chrome_mask & EMBED_CHROME_OPENASFULLSCREEN) + { + if (eel_gconf_get_boolean (CONF_WINDOWS_FS_SHOW_STATUSBAR)) + { + *chrome_mask |= EMBED_CHROME_STATUSBARON; + } + if (eel_gconf_get_boolean (CONF_WINDOWS_FS_SHOW_TOOLBARS)) + { + *chrome_mask |= EMBED_CHROME_TOOLBARON; + } + } + else + { + if (eel_gconf_get_boolean (CONF_WINDOWS_SHOW_STATUSBAR)) + { + *chrome_mask |= EMBED_CHROME_STATUSBARON; + } + if (eel_gconf_get_boolean (CONF_WINDOWS_SHOW_TOOLBARS)) + { + *chrome_mask |= EMBED_CHROME_TOOLBARON; + } + + *chrome_mask |= EMBED_CHROME_PERSONALTOOLBARON; + *chrome_mask |= EMBED_CHROME_MENUBARON; + } +} + +void +ephy_window_set_chrome (EphyWindow *window, + EmbedChromeMask flags) +{ + gboolean toolbar, ppvtoolbar, statusbar; + + if (flags & EMBED_CHROME_DEFAULT) + { + translate_default_chrome (&flags); + } + + dock_item_set_visibility (window, "/menu", + flags & EMBED_CHROME_MENUBARON); + + toolbar = (flags & EMBED_CHROME_TOOLBARON) != FALSE; + toolbar_set_visibility (window->priv->toolbar, + toolbar); + + statusbar = (flags & EMBED_CHROME_STATUSBARON) != FALSE; + statusbar_set_visibility (window->priv->statusbar, + statusbar); + + ppvtoolbar = (flags & EMBED_CHROME_PPVIEWTOOLBARON) != FALSE; + ppview_toolbar_set_old_chrome (window->priv->ppview_toolbar, + window->priv->chrome_mask); + ppview_toolbar_set_visibility (window->priv->ppview_toolbar, + ppvtoolbar); + + /* set fullscreen only when it's really changed */ + if ((window->priv->chrome_mask & EMBED_CHROME_OPENASFULLSCREEN) != + (flags & EMBED_CHROME_OPENASFULLSCREEN)) + { + save_window_chrome (window); + window_set_fullscreen_mode (window, + flags & EMBED_CHROME_OPENASFULLSCREEN); + } + + window->priv->chrome_mask = flags; + + update_layout_toggles (window); + + save_window_chrome (window); +} + +GtkWidget * +ephy_window_get_notebook (EphyWindow *window) +{ + return GTK_WIDGET (window->priv->notebook); +} + +void +ephy_window_add_tab (EphyWindow *window, + EphyTab *tab, + gboolean jump_to) +{ + GtkWidget *widget; + + g_return_if_fail (IS_EPHY_WINDOW (window)); + g_return_if_fail (IS_EPHY_TAB (tab)); + + ephy_tab_set_window (tab, window); + + widget = GTK_WIDGET(ephy_tab_get_embed (tab)); + + ephy_notebook_insert_page (EPHY_NOTEBOOK (window->priv->notebook), + widget, + EPHY_NOTEBOOK_INSERT_GROUPED, + jump_to); +} + +void +ephy_window_jump_to_tab (EphyWindow *window, + EphyTab *tab) +{ + GtkWidget *widget; + int page; + + widget = GTK_WIDGET(ephy_tab_get_embed (tab)); + + page = gtk_notebook_page_num + (window->priv->notebook, widget); + gtk_notebook_set_current_page + (window->priv->notebook, page); +} + +static EphyTab * +get_tab_from_page_num (GtkNotebook *notebook, gint page_num) +{ + EphyTab *tab; + GtkWidget *embed_widget; + + if (page_num < 0) return NULL; + + embed_widget = gtk_notebook_get_nth_page (notebook, page_num); + + g_return_val_if_fail (GTK_IS_WIDGET (embed_widget), NULL); + tab = g_object_get_data (G_OBJECT (embed_widget), "EphyTab"); + g_return_val_if_fail (IS_EPHY_TAB (G_OBJECT (tab)), NULL); + + return tab; +} + +static EphyTab * +real_get_active_tab (EphyWindow *window, int page_num) +{ + if (page_num == -1) + { + page_num = gtk_notebook_get_current_page (window->priv->notebook); + } + + return get_tab_from_page_num (window->priv->notebook, page_num); +} + +void +ephy_window_remove_tab (EphyWindow *window, + EphyTab *tab) +{ + GtkWidget *embed; + + g_return_if_fail (IS_EPHY_WINDOW (window)); + g_return_if_fail (IS_EPHY_TAB (tab)); + + window->priv->active_tab = NULL; + + embed = GTK_WIDGET (ephy_tab_get_embed (tab)); + + ephy_notebook_remove_page (EPHY_NOTEBOOK (window->priv->notebook), + embed); +} + +void +ephy_window_load_url (EphyWindow *window, + const char *url) +{ + EphyEmbed *embed; + + g_return_if_fail (IS_EPHY_WINDOW(window)); + embed = ephy_window_get_active_embed (window); + g_return_if_fail (embed != NULL); + g_return_if_fail (url != NULL); + + ephy_embed_load_url (embed, url); +} + +void ephy_window_activate_location (EphyWindow *window) +{ + toolbar_activate_location (window->priv->toolbar); +} + +void +ephy_window_show (GtkWidget *widget) +{ + EphyWindow *window = EPHY_WINDOW(widget); + EphyTab *tab; + int w = -1, h = -1; + + if (!window->priv->chrome_mask) + { + ephy_window_set_chrome (window, EMBED_CHROME_DEFAULT); + } + + tab = ephy_window_get_active_tab (window); + if (tab) ephy_tab_get_size (tab, &w, &h); + + if (!window->priv->has_default_size && w == -1 && h == -1) + { + ephy_state_load_window (GTK_WIDGET(window), + "main_window", + 600, 500, TRUE); + window->priv->has_default_size = TRUE; + } + + GTK_WIDGET_CLASS (parent_class)->show (widget); +} + +static void +update_status_message (EphyWindow *window) +{ + const char *message; + EphyTab *tab; + + tab = ephy_window_get_active_tab (window); + g_return_if_fail (tab != NULL); + + message = ephy_tab_get_status_message (tab); + g_return_if_fail (message != NULL); + + statusbar_set_message (STATUSBAR(window->priv->statusbar), + message); +} + +static void +update_progress (EphyWindow *window) +{ + EphyTab *tab; + int load_percent; + + tab = ephy_window_get_active_tab (window); + g_return_if_fail (tab != NULL); + + load_percent = ephy_tab_get_load_percent (tab); + + statusbar_set_progress (STATUSBAR(window->priv->statusbar), + load_percent); +} + +static void +update_security (EphyWindow *window) +{ + EphyEmbed *embed; + EmbedSecurityLevel level; + char *description; + char *state = NULL; + gboolean secure; + char *tooltip; + + embed = ephy_window_get_active_embed (window); + g_return_if_fail (embed != NULL); + + if (ephy_embed_get_security_level (embed, &level, &description) != G_OK) + { + level = STATE_IS_UNKNOWN; + description = NULL; + } + + secure = FALSE; + switch (level) + { + case STATE_IS_UNKNOWN: + state = _("Unknown"); + break; + case STATE_IS_INSECURE: + state = _("Insecure"); + break; + case STATE_IS_BROKEN: + state = _("Broken"); + break; + case STATE_IS_SECURE_MED: + state = _("Medium"); + secure = TRUE; + break; + case STATE_IS_SECURE_LOW: + state = _("Low"); + secure = TRUE; + break; + case STATE_IS_SECURE_HIGH: + state = _("High"); + secure = TRUE; + break; + default: + g_assert_not_reached (); + break; + } + + if (description != NULL) + { + tooltip = g_strdup_printf (_("Security level: %s\n%s"), + state, description); + g_free (description); + } + else + { + tooltip = g_strdup_printf (_("Security level: %s"), state); + + } + + statusbar_set_security_state (STATUSBAR (window->priv->statusbar), + secure, tooltip); + g_free (tooltip); +} + +static void +update_nav_control (EphyWindow *window) +{ + /* the zoom control is updated at the same time than the navigation + controls. This keeps it synched most of the time, but not always, + because we don't get a notification when zoom changes */ + + gresult back, forward, up, stop; + EphyEmbed *embed; + EphyTab *tab; + gint zoom; + + g_return_if_fail (window != NULL); + + tab = ephy_window_get_active_tab (window); + g_return_if_fail (tab != NULL); + + embed = ephy_window_get_active_embed (window); + g_return_if_fail (embed != NULL); + + back = ephy_embed_can_go_back (embed); + forward = ephy_embed_can_go_forward (embed); + up = ephy_embed_can_go_up (embed); + stop = ephy_tab_get_load_status (tab) & TAB_LOAD_STARTED; + + toolbar_button_set_sensitive (window->priv->toolbar, + TOOLBAR_BACK_BUTTON, + back == G_OK ? TRUE : FALSE); + toolbar_button_set_sensitive (window->priv->toolbar, + TOOLBAR_FORWARD_BUTTON, + forward == G_OK ? TRUE : FALSE); + toolbar_button_set_sensitive (window->priv->toolbar, + TOOLBAR_UP_BUTTON, + up == G_OK ? TRUE : FALSE); + toolbar_button_set_sensitive (window->priv->toolbar, + TOOLBAR_STOP_BUTTON, + stop); + if (ephy_embed_zoom_get (embed, &zoom) == G_OK) + { + toolbar_set_zoom (window->priv->toolbar, zoom); + } + + ephy_bonobo_set_sensitive (BONOBO_UI_COMPONENT(window->ui_component), + GO_BACK_CMD_PATH, !back); + ephy_bonobo_set_sensitive (BONOBO_UI_COMPONENT(window->ui_component), + GO_FORWARD_CMD_PATH, !forward); + ephy_bonobo_set_sensitive (BONOBO_UI_COMPONENT(window->ui_component), + GO_UP_CMD_PATH, !up); +} + +static void +update_title_control (EphyWindow *window) +{ + EphyTab *tab; + const char *title; + + tab = ephy_window_get_active_tab (window); + g_return_if_fail (tab != NULL); + + title = ephy_tab_get_title (tab); + + if (title) + { + gtk_window_set_title (GTK_WINDOW(window), + title); + } +} + +static void +update_location_control (EphyWindow *window) +{ + EphyTab *tab; + const char *location; + + tab = ephy_window_get_active_tab (window); + g_return_if_fail (tab != NULL); + + location = ephy_tab_get_location (tab); + + if (!location) location = ""; + + toolbar_set_location (window->priv->toolbar, + location); +} + +static void +update_favorites_control (EphyWindow *window) +{ + ephy_favorites_menu_update (window->priv->fav_menu); +} + +static void +update_favicon_control (EphyWindow *window) +{ + toolbar_update_favicon (window->priv->toolbar); +} + +static void +update_find_control (EphyWindow *window) +{ + gboolean can_go_next, can_go_prev; + + if (window->priv->find_dialog) + { + can_go_next = find_dialog_can_go_next + (FIND_DIALOG(window->priv->find_dialog)); + can_go_prev = find_dialog_can_go_prev + (FIND_DIALOG(window->priv->find_dialog)); + + ephy_bonobo_set_sensitive (BONOBO_UI_COMPONENT(window->ui_component), + EDIT_FIND_NEXT_CMD_PATH, can_go_next); + ephy_bonobo_set_sensitive (BONOBO_UI_COMPONENT(window->ui_component), + EDIT_FIND_PREV_CMD_PATH, can_go_prev); + } +} + +static void +update_window_visibility (EphyWindow *window) +{ + GList *l; + + l = ephy_window_get_tabs (window); + for (; l != NULL; l = l->next) + { + EphyTab *tab = EPHY_TAB(l->data); + g_return_if_fail (IS_EPHY_TAB(tab)); + + if (ephy_tab_get_visibility (tab)) + { + gtk_widget_show (GTK_WIDGET(window)); + return; + } + } + g_list_free (l); + + if (GTK_WIDGET_VISIBLE (GTK_WIDGET (window))) + { + gtk_widget_hide (GTK_WIDGET (window)); + } +} + +static void +update_spinner_control (EphyWindow *window) +{ + GList *l; + + l = ephy_window_get_tabs (window); + for (; l != NULL; l = l->next) + { + EphyTab *tab = EPHY_TAB(l->data); + g_return_if_fail (IS_EPHY_TAB(tab)); + + if (ephy_tab_get_load_status (tab) & TAB_LOAD_STARTED) + { + toolbar_spinner_start (window->priv->toolbar); + return; + } + } + g_list_free (l); + + toolbar_spinner_stop (window->priv->toolbar); +} + +void +ephy_window_update_control (EphyWindow *window, + ControlID control) +{ + g_return_if_fail (IS_EPHY_WINDOW (window)); + + switch (control) + { + case StatusbarMessageControl: + update_status_message (window); + break; + case StatusbarProgressControl: + update_progress (window); + break; + case StatusbarSecurityControl: + update_security (window); + break; + case FindControl: + update_find_control (window); + break; + case ZoomControl: + /* the zoom control is updated at the same time than the navigation + controls. This keeps it synched most of the time, but not always, + because we don't get a notification when zoom changes */ + case NavControl: + update_nav_control (window); + break; + case TitleControl: + update_title_control (window); + break; + case WindowVisibilityControl: + update_window_visibility (window); + break; + case SpinnerControl: + update_spinner_control (window); + break; + case LocationControl: + update_location_control (window); + break; + case FaviconControl: + update_favicon_control (window); + break; + case FavoritesControl: + update_favorites_control (window); + break; + default: + g_warning ("unknown control specified for updating"); + break; + } +} + +void +ephy_window_update_all_controls (EphyWindow *window) +{ + g_return_if_fail (IS_EPHY_WINDOW (window)); + + if (ephy_window_get_active_tab (window) != NULL) + { + update_nav_control (window); + update_title_control (window); + update_location_control (window); + update_favicon_control (window); + update_status_message (window); + update_progress (window); + update_security (window); + update_find_control (window); + update_spinner_control (window); + } +} + +EphyTab * +ephy_window_get_active_tab (EphyWindow *window) +{ + g_return_val_if_fail (IS_EPHY_WINDOW (window), NULL); + + return window->priv->active_tab; +} + +EphyEmbed * +ephy_window_get_active_embed (EphyWindow *window) +{ + EphyTab *tab; + + tab = ephy_window_get_active_tab (window); + + if (tab) + { + g_return_val_if_fail (IS_EPHY_WINDOW (G_OBJECT (window)), + NULL); + return ephy_tab_get_embed (tab); + } + else return NULL; +} + +EphyEmbedPopupBW * +ephy_window_get_popup_factory (EphyWindow *window) +{ + if (!window->priv->embed_popup) + { + window->priv->embed_popup = ephy_embed_popup_bw_new + (BONOBO_WINDOW(window)); + ephy_embed_popup_connect_verbs + (EPHY_EMBED_POPUP (window->priv->embed_popup), + BONOBO_UI_COMPONENT (window->ui_component)); + } + + return window->priv->embed_popup; +} + +GList * +ephy_window_get_tabs (EphyWindow *window) +{ + GList *tabs = NULL; + GtkWidget *w; + int i = 0; + + while ((w = gtk_notebook_get_nth_page (window->priv->notebook, i)) != NULL) + { + EphyTab *tab; + + tab = g_object_get_data (G_OBJECT (w), "EphyTab"); + g_return_val_if_fail (IS_EPHY_TAB (G_OBJECT (tab)), NULL); + + tabs = g_list_append (tabs, tab); + i++; + } + + return tabs; +} + +static void +save_old_embed_status (EphyTab *tab, EphyWindow *window) +{ + /* save old tab location status */ + ephy_tab_set_location (tab, toolbar_get_location (window->priv->toolbar)); +} + +static void +update_embed_dialogs (EphyWindow *window, + EphyTab *tab) +{ + EphyEmbed *embed; + EphyDialog *find_dialog = window->priv->find_dialog; + EphyDialog *history_dialog = window->priv->history_dialog; + EphyDialog *history_sidebar = window->priv->history_sidebar; + + embed = ephy_tab_get_embed (tab); + + if (find_dialog) + { + ephy_embed_dialog_set_embed + (EPHY_EMBED_DIALOG(find_dialog), + embed); + } + + if (history_dialog) + { + ephy_embed_dialog_set_embed + (EPHY_EMBED_DIALOG(history_dialog), + embed); + } + + if (history_sidebar) + { + ephy_embed_dialog_set_embed + (EPHY_EMBED_DIALOG(history_sidebar), + embed); + } +} + +static void +ephy_window_notebook_switch_page_cb (GtkNotebook *notebook, + GtkNotebookPage *page, + guint page_num, + EphyWindow *window) +{ + EphyTab *tab, *old_tab; + + if (window->priv->closing) return; + + g_return_if_fail (IS_EPHY_WINDOW (window)); + + /* get the new tab */ + tab = real_get_active_tab (window, page_num); + + /* update old tab */ + old_tab = window->priv->active_tab; + if (old_tab && tab != old_tab) + { + g_return_if_fail (IS_EPHY_TAB (G_OBJECT (old_tab))); + ephy_tab_set_is_active (old_tab, FALSE); + save_old_embed_status (old_tab, window); + } + + /* update new tab */ + window->priv->active_tab = tab; + ephy_tab_set_is_active (tab, TRUE); + + update_embed_dialogs (window, tab); + + /* update window controls */ + ephy_window_update_all_controls (window); +} + +static void +find_dialog_search_cb (FindDialog *dialog, EphyWindow *window) +{ + ephy_window_update_control (window, FindControl); +} + +EphyDialog * +ephy_window_get_find_dialog (EphyWindow *window) +{ + EphyDialog *dialog; + EphyEmbed *embed; + + if (window->priv->find_dialog) + { + return window->priv->find_dialog; + } + + embed = ephy_window_get_active_embed (window); + g_return_val_if_fail (GTK_IS_WINDOW(window), NULL); + dialog = find_dialog_new_with_parent (GTK_WIDGET(window), + embed); + + g_signal_connect (dialog, "search", + G_CALLBACK (find_dialog_search_cb), + window); + + window->priv->find_dialog = dialog; + + return dialog; +} + +void +ephy_window_show_history (EphyWindow *window) +{ + EphyEmbed *embed; + + embed = ephy_window_get_active_embed (window); + g_return_if_fail (embed != NULL); + + window->priv->history_dialog = history_dialog_new_with_parent + (GTK_WIDGET(window), + embed, + FALSE); + g_object_add_weak_pointer + (G_OBJECT(window->priv->history_dialog), + (gpointer *)&window->priv->history_dialog); + + ephy_dialog_show (window->priv->history_dialog); +} + +void +ephy_window_set_zoom (EphyWindow *window, + gint zoom) +{ + EphyEmbed *embed; + + g_return_if_fail (IS_EPHY_WINDOW (window)); + + embed = ephy_window_get_active_embed (window); + g_return_if_fail (embed != NULL); + + ephy_embed_zoom_set (embed, zoom, TRUE); +} + +Toolbar * +ephy_window_get_toolbar (EphyWindow *window) +{ + return window->priv->toolbar; +} + +void +ephy_window_tab_detached_cb (EphyNotebook *notebook, gint page, + gint x, gint y, gpointer data) +{ + EphyTab *tab; + EphyWindow *window; + GtkWidget *src_page; + + src_page = gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), page); + tab = get_tab_from_page_num (GTK_NOTEBOOK (notebook), page); + window = ephy_window_new (); + ephy_notebook_move_page (notebook, + EPHY_NOTEBOOK (ephy_window_get_notebook (window)), + src_page, 0); + ephy_tab_set_window (tab, window); + gtk_widget_show (GTK_WIDGET (window)); +} diff --git a/src/ephy-window.h b/src/ephy-window.h new file mode 100644 index 000000000..315cd8cca --- /dev/null +++ b/src/ephy-window.h @@ -0,0 +1,140 @@ +/* + * Copyright (C) 2000, 2001, 2002 Marco Pesenti Gritti + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef EPHY_WINDOW_H +#define EPHY_WINDOW_H + +#include "ephy-embed.h" +#include "ephy-embed-persist.h" +#include "ephy-embed-popup-bw.h" +#include "ephy-dialog.h" +#include "ephy-notebook.h" +#include <glib-object.h> +#include <glib.h> +#include <bonobo/bonobo-window.h> + +G_BEGIN_DECLS + +typedef struct EphyWindowClass EphyWindowClass; + +#define EPHY_WINDOW_TYPE (ephy_window_get_type ()) +#define EPHY_WINDOW(obj) (GTK_CHECK_CAST ((obj), EPHY_WINDOW_TYPE, EphyWindow)) +#define EPHY_WINDOW_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), EPHY_WINDOW, EphyWindowClass)) +#define IS_EPHY_WINDOW(obj) (GTK_CHECK_TYPE ((obj), EPHY_WINDOW_TYPE)) +#define IS_EPHY_WINDOW_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), EPHY_WINDOW)) + +typedef struct EphyWindow EphyWindow; +typedef struct EphyWindowPrivate EphyWindowPrivate; +typedef struct Toolbar Toolbar; + +struct EphyWindow +{ + BonoboWindow parent; + EphyWindowPrivate *priv; + + /* Public to toolbar and statusbar, dont use outside */ + GObject *ui_component; +}; + +struct EphyWindowClass +{ + BonoboWindowClass parent_class; +}; + +typedef enum +{ + NormalMode, + FullscreenMode +} EphyWindowMode; + +typedef enum +{ + TabsControl, + NavControl, + FindControl, + ZoomControl, + CharsetsControl, + TitleControl, + LocationControl, + FaviconControl, + StatusbarSecurityControl, + StatusbarMessageControl, + StatusbarProgressControl, + SpinnerControl, + WindowVisibilityControl, + BMAndHistoryControl, + TabsAppeareanceControl, + FavoritesControl +} ControlID; + +/* Include the header down here to resolve circular dependency */ +#include "ephy-tab.h" + +GType ephy_window_get_type (void); + +EphyWindow *ephy_window_new (void); + +void ephy_window_set_chrome (EphyWindow *window, + EmbedChromeMask chrome_flags); + +EmbedChromeMask ephy_window_get_chrome (EphyWindow *window); + +GtkWidget *ephy_window_get_notebook (EphyWindow *window); + +void ephy_window_add_tab (EphyWindow *window, + EphyTab *tab, + gboolean jump_to); + +void ephy_window_remove_tab (EphyWindow *window, + EphyTab *tab); + +void ephy_window_jump_to_tab (EphyWindow *window, + EphyTab *tab); + +void ephy_window_load_url (EphyWindow *window, + const char *url); + +void ephy_window_set_zoom (EphyWindow *window, + gint zoom); + +void ephy_window_activate_location (EphyWindow *window); + +void ephy_window_update_control (EphyWindow *window, + ControlID control); + +void ephy_window_update_all_controls (EphyWindow *window); + +EphyTab *ephy_window_get_active_tab (EphyWindow *window); + +EphyEmbed *ephy_window_get_active_embed (EphyWindow *window); + +EphyEmbedPopupBW *ephy_window_get_popup_factory (EphyWindow *window); + +GList *ephy_window_get_tabs (EphyWindow *window); + +Toolbar *ephy_window_get_toolbar (EphyWindow *window); + +/* Dialogs */ + +EphyDialog *ephy_window_get_find_dialog (EphyWindow *window); + +void ephy_window_show_history (EphyWindow *window); + +G_END_DECLS + +#endif diff --git a/src/general-prefs.c b/src/general-prefs.c new file mode 100755 index 000000000..f9eecf4e6 --- /dev/null +++ b/src/general-prefs.c @@ -0,0 +1,484 @@ +/* + * Copyright (C) 2002 Marco Pesenti Gritti + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include "general-prefs.h" +#include "ephy-shell.h" +#include "ephy-prefs.h" +#include "ephy-embed-prefs.h" +#include "ephy-shell.h" +#include "eel-gconf-extensions.h" +#include "language-editor.h" + +#include <string.h> +#include <gtk/gtkeditable.h> +#include <gtk/gtkmenu.h> +#include <gtk/gtkoptionmenu.h> +#include <gtk/gtkmenuitem.h> +#include <bonobo/bonobo-i18n.h> + +static void general_prefs_class_init (GeneralPrefsClass *klass); +static void general_prefs_init (GeneralPrefs *dialog); +static void general_prefs_finalize (GObject *object); + +/* Glade callbacks */ +void +prefs_homepage_current_button_clicked_cb (GtkWidget *button, + EphyDialog *dialog); +void +prefs_homepage_blank_button_clicked_cb (GtkWidget *button, + EphyDialog *dialog); +void +prefs_language_more_button_clicked_cb (GtkWidget *button, + EphyDialog *dialog); + +static GObjectClass *parent_class = NULL; + +struct GeneralPrefsPrivate +{ + gpointer dummy; +}; + +enum +{ + HOMEPAGE_ENTRY_PROP, + NEW_PAGE_PROP, + AUTOCHARSET_PROP, + DEFAULT_CHARSET_PROP, + LANGUAGE_PROP +}; + +static const +EphyDialogProperty properties [] = +{ + { HOMEPAGE_ENTRY_PROP, "homepage_entry", CONF_GENERAL_HOMEPAGE, PT_AUTOAPPLY, NULL }, + { NEW_PAGE_PROP, "new_page_show_homepage", CONF_GENERAL_NEWPAGE_TYPE, PT_AUTOAPPLY, NULL }, + { AUTOCHARSET_PROP, "autocharset_optionmenu", CONF_LANGUAGE_AUTODETECT_CHARSET, PT_AUTOAPPLY, NULL }, + { DEFAULT_CHARSET_PROP, "default_charset_optionmenu", NULL, PT_NORMAL, NULL }, + { LANGUAGE_PROP, "language_optionmenu", NULL, PT_NORMAL, NULL }, + + { -1, NULL, NULL } +}; + +static const +struct +{ + char *name; + char *code; +} +languages [] = +{ + { _("Afrikaans"), "ak" }, + { _("Albanian"), "sq" }, + { _("Arabic"), "ar" }, + { _("Azerbaijani"), "az" }, + { _("Basque"), "eu" }, + { _("Breton"), "br" }, + { _("Bulgarian"), "bg" }, + { _("Byelorussian"), "be" }, + { _("Catalan"), "ca" }, + { _("Chinese"), "zh" }, + { _("Croatian"), "hr" }, + { _("Czech"), "cs" }, + { _("Danish"), "da" }, + { _("Dutch"), "nl" }, + { _("English"), "en" }, + { _("Esperanto"), "eo" }, + { _("Estonian"), "et" }, + { _("Faeroese"), "fo" }, + { _("Finnish"), "fi" }, + { _("French"), "fr" }, + { _("Galician"), "gl" }, + { _("German"), "de" }, + { _("Greek"), "el" }, + { _("Hebrew"), "he" }, + { _("Hungarian"), "hu" }, + { _("Icelandic"), "is" }, + { _("Indonesian"), "id" }, + { _("Irish"), "ga" }, + { _("Italian"), "it" }, + { _("Japanese"), "ja" }, + { _("Korean"), "ko" }, + { _("Latvian"), "lv" }, + { _("Lithuanian"), "lt" }, + { _("Macedonian"), "mk" }, + { _("Malay"), "ms" }, + { _("Norwegian/Nynorsk"), "nn" }, + { _("Norwegian/Bokmaal"), "nb" }, + { _("Norwegian"), "no" }, + { _("Polish"), "pl" }, + { _("Portuguese"), "pt" }, + { _("Portuguese of Brazil"), "pt-BR" }, + { _("Romanian"), "ro" }, + { _("Russian"), "ru" }, + { _("Scottish"), "gd" }, + { _("Serbian"), "sr" }, + { _("Slovak"), "sk" }, + { _("Slovenian"), "sl" }, + { _("Spanish"), "es" }, + { _("Swedish"), "sv" }, + { _("Tamil"), "ta" }, + { _("Turkish"), "tr" }, + { _("Ukrainian"), "uk" }, + { _("Vietnamian"), "vi" }, + { _("Walloon"), "wa" }, + { NULL, NULL } +}; + +GType +general_prefs_get_type (void) +{ + static GType general_prefs_type = 0; + + if (general_prefs_type == 0) + { + static const GTypeInfo our_info = + { + sizeof (GeneralPrefsClass), + NULL, /* base_init */ + NULL, /* base_finalize */ + (GClassInitFunc) general_prefs_class_init, + NULL, + NULL, /* class_data */ + sizeof (GeneralPrefs), + 0, /* n_preallocs */ + (GInstanceInitFunc) general_prefs_init + }; + + general_prefs_type = g_type_register_static (EPHY_DIALOG_TYPE, + "GeneralPrefs", + &our_info, 0); + } + + return general_prefs_type; + +} + +static void +general_prefs_class_init (GeneralPrefsClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + object_class->finalize = general_prefs_finalize; +} + +static void +default_charset_menu_changed_cb (GtkOptionMenu *option_menu, + EphyEmbedShell *shell) +{ + GList *charsets; + int i; + CharsetInfo *info; + + ephy_embed_shell_get_charset_titles (shell, NULL, &charsets); + + i = gtk_option_menu_get_history (option_menu); + charsets = g_list_nth (charsets, i); + g_assert (charsets != NULL); + info = (CharsetInfo *) charsets->data; + eel_gconf_set_string (CONF_LANGUAGE_DEFAULT_CHARSET, + info->name); + + g_list_free (charsets); +} + +static gint +find_charset_in_list_cmp (gconstpointer a, + gconstpointer b) +{ + CharsetInfo *info = (CharsetInfo *)a; + const char *value = b; + + return (strcmp (info->name, value)); +} + +static void +create_default_charset_menu (GeneralPrefs *dialog) +{ + EphyEmbedShell *shell; + GList *l; + GList *charsets; + GtkWidget *menu; + GtkWidget *optionmenu; + char *value; + + shell = ephy_shell_get_embed_shell (ephy_shell); + ephy_embed_shell_get_charset_titles (shell, NULL, &l); + + menu = gtk_menu_new (); + + optionmenu = ephy_dialog_get_control (EPHY_DIALOG (dialog), + DEFAULT_CHARSET_PROP); + + for (charsets = l; charsets != NULL; charsets = charsets->next) + { + CharsetInfo *info = (CharsetInfo *) charsets->data; + GtkWidget *item; + + item = gtk_menu_item_new_with_label (info->title); + gtk_menu_shell_append (GTK_MENU_SHELL(menu), + item); + gtk_widget_show (item); + } + + gtk_option_menu_set_menu (GTK_OPTION_MENU(optionmenu), menu); + + /* init value */ + charsets = l; + value = eel_gconf_get_string (CONF_LANGUAGE_DEFAULT_CHARSET); + charsets = g_list_find_custom (charsets, (gconstpointer)value, + (GCompareFunc)find_charset_in_list_cmp); + gtk_option_menu_set_history (GTK_OPTION_MENU(optionmenu), + g_list_position (l, charsets)); + g_free (value); + + g_signal_connect (optionmenu, "changed", + G_CALLBACK (default_charset_menu_changed_cb), + shell); + + g_list_free (l); +} + +static GtkWidget * +general_prefs_new_language_menu (GeneralPrefs *dialog) +{ + int i; + GtkWidget *menu; + + menu = gtk_menu_new (); + + for (i = 0; languages[i].name != NULL; i++) + { + GtkWidget *item; + + item = gtk_menu_item_new_with_label (languages[i].name); + gtk_menu_shell_append (GTK_MENU_SHELL(menu), + item); + gtk_widget_show (item); + g_object_set_data (G_OBJECT(item), "desc", + languages[i].name); + } + + return menu; +} + +static void +language_menu_changed_cb (GtkOptionMenu *option_menu, + gpointer data) +{ + GSList *list; + GSList *l = NULL; + int history; + + list = eel_gconf_get_string_list (CONF_RENDERING_LANGUAGE); + l = g_slist_copy (list); + + /* Subst the first item according to the optionmenu */ + history = gtk_option_menu_get_history (option_menu); + l->data = languages [history].code; + + eel_gconf_set_string_list (CONF_RENDERING_LANGUAGE, l); + + g_slist_free (l); +} + +static void +create_language_menu (GeneralPrefs *dialog) +{ + GtkWidget *optionmenu; + GtkWidget *menu; + const char *value; + int i; + GSList *list; + + optionmenu = ephy_dialog_get_control (EPHY_DIALOG (dialog), + LANGUAGE_PROP); + + menu = general_prefs_new_language_menu (dialog); + + gtk_option_menu_set_menu (GTK_OPTION_MENU(optionmenu), menu); + + /* init value */ + list = eel_gconf_get_string_list (CONF_RENDERING_LANGUAGE); + g_return_if_fail (list != NULL); + value = (const char *)list->data; + + i = 0; + while (languages[i].code && strcmp (languages[i].code, value) != 0) + { + i++; + } + + gtk_option_menu_set_history (GTK_OPTION_MENU(optionmenu), i); + + g_signal_connect (optionmenu, "changed", + G_CALLBACK (language_menu_changed_cb), + NULL); +} + +static void +general_prefs_init (GeneralPrefs *dialog) +{ + dialog->priv = g_new0 (GeneralPrefsPrivate, 1); + + ephy_dialog_construct (EPHY_DIALOG(dialog), + properties, + "prefs-dialog.glade", + "general_page_box"); + + create_default_charset_menu (dialog); + create_language_menu (dialog); +} + +static void +general_prefs_finalize (GObject *object) +{ + GeneralPrefs *dialog; + + g_return_if_fail (object != NULL); + g_return_if_fail (IS_GENERAL_PREFS (object)); + + dialog = GENERAL_PREFS (object); + + g_return_if_fail (dialog->priv != NULL); + + g_free (dialog->priv); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +EphyDialog * +general_prefs_new (void) +{ + GeneralPrefs *dialog; + + dialog = GENERAL_PREFS (g_object_new (GENERAL_PREFS_TYPE, + NULL)); + + return EPHY_DIALOG(dialog); +} + +static void +set_homepage_entry (EphyDialog *dialog, + const char *new_location) +{ + GtkWidget *entry; + int pos; + + entry = ephy_dialog_get_control (dialog, HOMEPAGE_ENTRY_PROP); + + gtk_editable_delete_text (GTK_EDITABLE (entry), 0, -1); + gtk_editable_insert_text (GTK_EDITABLE (entry), new_location, + g_utf8_strlen (new_location, -1), + &pos); +} + +void +prefs_homepage_current_button_clicked_cb (GtkWidget *button, + EphyDialog *dialog) +{ + EphyWindow *window; + EphyTab *tab; + + window = ephy_shell_get_active_window (ephy_shell); + g_return_if_fail (window != NULL); + + tab = ephy_window_get_active_tab (window); + g_return_if_fail (tab != NULL); + + set_homepage_entry (dialog, ephy_tab_get_location (tab)); +} + +void +prefs_homepage_blank_button_clicked_cb (GtkWidget *button, + EphyDialog *dialog) +{ + set_homepage_entry (dialog, "about:blank"); +} + +static void +fill_language_editor (LanguageEditor *le) +{ + GSList *strings; + GSList *tmp; + int i; + + /* Fill the list */ + strings = eel_gconf_get_string_list (CONF_RENDERING_LANGUAGE); + + for (tmp = strings; tmp != NULL; tmp = g_slist_next (tmp)) + { + char *value = (char *)tmp->data; + + i = 0; + while (languages[i].code && strcmp (languages[i].code, value) != 0) + { + i++; + } + + /* FIXME unsafe, bad prefs could cause it to access random memory */ + language_editor_add (le, languages[i].name, i); + } +} + +static void +language_dialog_changed_cb (LanguageEditor *le, + GSList *list, + GeneralPrefs *dialog) +{ + GtkWidget *optionmenu; + GSList *l = list; + GSList *langs = NULL; + + optionmenu = ephy_dialog_get_control (EPHY_DIALOG (dialog), + LANGUAGE_PROP); + gtk_option_menu_set_history (GTK_OPTION_MENU(optionmenu), + (int)(l->data)); + + for (; l != NULL; l = l->next) + { + int i = (int)l->data; + langs = g_slist_append (langs, languages[i].code); + } + + eel_gconf_set_string_list (CONF_RENDERING_LANGUAGE, langs); +} + +void +prefs_language_more_button_clicked_cb (GtkWidget *button, + EphyDialog *dialog) +{ + LanguageEditor *editor; + GtkWidget *menu; + GtkWidget *toplevel; + + menu = general_prefs_new_language_menu (GENERAL_PREFS(dialog)); + + toplevel = gtk_widget_get_toplevel (button); + editor = language_editor_new (toplevel); + language_editor_set_menu (editor, menu); + fill_language_editor (editor); + ephy_dialog_set_modal (EPHY_DIALOG(editor), TRUE); + + g_signal_connect (editor, "changed", + G_CALLBACK(language_dialog_changed_cb), + dialog); + + ephy_dialog_show (EPHY_DIALOG(editor)); +} diff --git a/src/general-prefs.h b/src/general-prefs.h new file mode 100644 index 000000000..74cfa26a7 --- /dev/null +++ b/src/general-prefs.h @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2002 Jorn Baayen + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef GENERAL_PREFS_H +#define GENERAL_PREFS_H + +#include "ephy-embed-dialog.h" + +#include <glib-object.h> +#include <glib.h> + +G_BEGIN_DECLS + +typedef struct GeneralPrefs GeneralPrefs; +typedef struct GeneralPrefsClass GeneralPrefsClass; + +#define GENERAL_PREFS_TYPE (general_prefs_get_type ()) +#define GENERAL_PREFS(obj) (GTK_CHECK_CAST ((obj), GENERAL_PREFS_TYPE, GeneralPrefs)) +#define GENERAL_PREFS_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), GENERAL_PREFS, GeneralPrefsClass)) +#define IS_GENERAL_PREFS(obj) (GTK_CHECK_TYPE ((obj), GENERAL_PREFS_TYPE)) +#define IS_GENERAL_PREFS_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GENERAL_PREFS)) + +typedef struct GeneralPrefsPrivate GeneralPrefsPrivate; + +struct GeneralPrefs +{ + EphyDialog parent; + GeneralPrefsPrivate *priv; +}; + +struct GeneralPrefsClass +{ + EphyDialogClass parent_class; +}; + +GType general_prefs_get_type (void); + +EphyDialog *general_prefs_new (void); + +G_END_DECLS + +#endif + diff --git a/src/history-dialog.c b/src/history-dialog.c new file mode 100755 index 000000000..4f5b5cc2b --- /dev/null +++ b/src/history-dialog.c @@ -0,0 +1,478 @@ +/* + * Copyright (C) 2002 Jorn Baayen + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include "history-dialog.h" +#include "ephy-shell.h" +#include "ephy-embed-shell.h" +#include "ephy-string.h" +#include "ephy-gui.h" +#include "ephy-dnd.h" +#include "ephy-node-filter.h" +#include "ephy-history-model.h" +#include "eggtreemodelfilter.h" +#include "eggtreemultidnd.h" +#include "ephy-tree-model-sort.h" + +#include <gtk/gtktreeview.h> +#include <gtk/gtktreestore.h> +#include <gtk/gtkcellrenderertext.h> +#include <bonobo/bonobo-i18n.h> + +#define CONF_HISTORY_SEARCH_TEXT "/apps/epiphany/history/search_text" +#define CONF_HISTORY_SEARCH_TIME "/apps/epiphany/history/search_time" + +static void history_dialog_class_init (HistoryDialogClass *klass); +static void history_dialog_init (HistoryDialog *dialog); +static void history_dialog_finalize (GObject *object); +static void history_dialog_set_embedded (HistoryDialog *d, + gboolean embedded); + + +/* Glade callbacks */ +void +history_host_checkbutton_toggled_cb (GtkWidget *widget, + HistoryDialog *dialog); +void +history_time_optionmenu_changed_cb (GtkWidget *widget, + HistoryDialog *dialog); +void +history_entry_changed_cb (GtkWidget *widget, + HistoryDialog *dialog); +void +history_ok_button_clicked_cb (GtkWidget *button, + HistoryDialog *dialog); +void +history_clear_button_clicked_cb (GtkWidget *button, + HistoryDialog *dialog); + + +static GObjectClass *parent_class = NULL; + +struct HistoryDialogPrivate +{ + EphyHistory *gh; + EphyNode *root; + EphyNode *pages; + EphyNodeFilter *filter; + GtkTreeView *treeview; + GtkTreeModel *model; + EphyHistoryModel *nodemodel; + GtkTreeModel *filtermodel; + EphyTreeModelSort *sortmodel; + gboolean group; + gboolean embedded; +}; + +enum +{ + PROP_0, + PROP_EMBEDDED +}; + +enum +{ + PROP_TREEVIEW, + PROP_WORD, + PROP_TIME +}; + +static const +EphyDialogProperty properties [] = +{ + { PROP_TREEVIEW, "history_treeview", NULL, PT_NORMAL, NULL }, + { PROP_WORD, "history_entry", CONF_HISTORY_SEARCH_TEXT, PT_NORMAL, NULL }, + { PROP_TIME, "history_time_optionmenu", CONF_HISTORY_SEARCH_TIME, PT_NORMAL, NULL }, + { -1, NULL, NULL } +}; + +GType +history_dialog_get_type (void) +{ + static GType history_dialog_type = 0; + + if (history_dialog_type == 0) + { + static const GTypeInfo our_info = + { + sizeof (HistoryDialogClass), + NULL, /* base_init */ + NULL, /* base_finalize */ + (GClassInitFunc) history_dialog_class_init, + NULL, + NULL, /* class_data */ + sizeof (HistoryDialog), + 0, /* n_preallocs */ + (GInstanceInitFunc) history_dialog_init + }; + + history_dialog_type = g_type_register_static (EPHY_EMBED_DIALOG_TYPE, + "HistoryDialog", + &our_info, 0); + } + + return history_dialog_type; + +} + +static void +history_dialog_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + HistoryDialog *d = HISTORY_DIALOG (object); + + switch (prop_id) + { + case PROP_EMBEDDED: + history_dialog_set_embedded + (d, g_value_get_boolean (value)); + break; + } +} + +static void +history_dialog_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + HistoryDialog *d = HISTORY_DIALOG (object); + + switch (prop_id) + { + case PROP_EMBEDDED: + g_value_set_boolean (value, d->priv->embedded); + break; + } +} + + +static void +history_dialog_class_init (HistoryDialogClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + object_class->finalize = history_dialog_finalize; + object_class->set_property = history_dialog_set_property; + object_class->get_property = history_dialog_get_property; + + g_object_class_install_property (object_class, + PROP_EMBEDDED, + g_param_spec_boolean ("embedded", + "Show embedded in another widget", + "Show embedded in another widget", + TRUE, + G_PARAM_READWRITE)); +} + +static void +add_column (HistoryDialog *dialog, + const char *title, + EphyHistoryModelColumn column) +{ + GtkTreeViewColumn *gcolumn; + GtkCellRenderer *renderer; + + gcolumn = (GtkTreeViewColumn *) gtk_tree_view_column_new (); + renderer = gtk_cell_renderer_text_new (); + gtk_tree_view_column_pack_start (gcolumn, renderer, TRUE); + gtk_tree_view_column_set_attributes (gcolumn, renderer, + "text", column, + NULL); + gtk_tree_view_column_set_sizing (gcolumn, + GTK_TREE_VIEW_COLUMN_AUTOSIZE); + gtk_tree_view_column_set_sort_column_id (gcolumn, column); + gtk_tree_view_column_set_title (gcolumn, title); + gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->priv->treeview), + gcolumn); +} + +static void +history_view_row_activated_cb (GtkTreeView *treeview, + GtkTreePath *path, + GtkTreeViewColumn *column, + HistoryDialog *dialog) +{ + GtkTreeIter iter, iter2; + EphyNode *node; + EphyEmbed *embed; + const char *location; + + gtk_tree_model_get_iter (GTK_TREE_MODEL (dialog->priv->sortmodel), &iter, path); + gtk_tree_model_sort_convert_iter_to_child_iter + (GTK_TREE_MODEL_SORT (dialog->priv->sortmodel), &iter2, &iter); + egg_tree_model_filter_convert_iter_to_child_iter + (EGG_TREE_MODEL_FILTER (dialog->priv->filtermodel), &iter, &iter2); + + node = ephy_history_model_node_from_iter (dialog->priv->nodemodel, &iter); + location = ephy_node_get_property_string (node, EPHY_NODE_PAGE_PROP_LOCATION); + g_return_if_fail (location != NULL); + embed = ephy_embed_dialog_get_embed (EPHY_EMBED_DIALOG(dialog)); + ephy_embed_load_url (embed, location); +} + +static void +node_from_sort_iter_cb (EphyTreeModelSort *model, + GtkTreeIter *iter, + void **node, + HistoryDialog *dialog) +{ + GtkTreeIter filter_iter, node_iter; + + gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (model), + &filter_iter, iter); + egg_tree_model_filter_convert_iter_to_child_iter (EGG_TREE_MODEL_FILTER (dialog->priv->filtermodel), + &node_iter, &filter_iter); + *node = ephy_history_model_node_from_iter (EPHY_HISTORY_MODEL (dialog->priv->nodemodel), &node_iter); + g_return_if_fail (*node != NULL); +} + +static void +history_dialog_setup_view (HistoryDialog *dialog) +{ + dialog->priv->nodemodel = ephy_history_model_new (dialog->priv->root, + dialog->priv->pages, + dialog->priv->filter); + dialog->priv->filtermodel = egg_tree_model_filter_new (GTK_TREE_MODEL (dialog->priv->nodemodel), + NULL); + egg_tree_model_filter_set_visible_column (EGG_TREE_MODEL_FILTER (dialog->priv->filtermodel), + EPHY_HISTORY_MODEL_COL_VISIBLE); + dialog->priv->sortmodel = EPHY_TREE_MODEL_SORT ( + ephy_tree_model_sort_new (GTK_TREE_MODEL (dialog->priv->filtermodel))); + g_signal_connect_object (G_OBJECT (dialog->priv->sortmodel), + "node_from_iter", + G_CALLBACK (node_from_sort_iter_cb), + dialog, + 0); + gtk_tree_view_set_model (dialog->priv->treeview, + GTK_TREE_MODEL (dialog->priv->sortmodel)); + + egg_tree_multi_drag_add_drag_support (GTK_TREE_VIEW (dialog->priv->treeview)); + ephy_dnd_enable_model_drag_source (GTK_WIDGET (dialog->priv->treeview)); + + add_column (dialog, _("Title"), EPHY_HISTORY_MODEL_COL_TITLE); + add_column (dialog, _("Location"), EPHY_HISTORY_MODEL_COL_LOCATION); + add_column (dialog, _("Last Visit"), EPHY_HISTORY_MODEL_COL_LAST_VISIT); + + g_signal_connect (dialog->priv->treeview, + "row_activated", + G_CALLBACK (history_view_row_activated_cb), + dialog); +} + +static GTime +get_date_filter (int filter_type, + GTime atime) +{ + GDate date, current_date; + struct tm tm; + + g_date_clear (¤t_date, 1); + g_date_set_time (¤t_date, time (NULL)); + + g_date_clear (&date, 1); + g_date_set_time (&date, atime); + + switch (filter_type) + { + /* Always */ + case 0: + return 0; + /* Today */ + case 1: + break; + /* Last two days */ + case 2: + g_date_subtract_days (¤t_date, 1); + break; + /* Last three days */ + case 3: + g_date_subtract_days (¤t_date, 2); + break; + /* Week */ + case 4: + g_date_subtract_days (¤t_date, 7); + break; + /* Month */ + case 5: + g_date_subtract_months (¤t_date, 1); + break; + default: + break; + } + + g_date_to_struct_tm (¤t_date, &tm); + return mktime (&tm); +} + +static void +history_dialog_setup_filter (HistoryDialog *dialog) +{ + GValue word = {0, }; + GValue atime = {0, }; + const char *search_text; + GTime date_filter; + + ephy_dialog_get_value (EPHY_DIALOG(dialog), PROP_WORD, &word); + search_text = g_value_get_string (&word); + ephy_dialog_get_value (EPHY_DIALOG(dialog), PROP_TIME, &atime); + date_filter = get_date_filter (g_value_get_int (&atime), time (NULL)); + + GDK_THREADS_ENTER (); + + ephy_node_filter_empty (dialog->priv->filter); + ephy_node_filter_add_expression (dialog->priv->filter, + ephy_node_filter_expression_new (EPHY_NODE_FILTER_EXPRESSION_STRING_PROP_CONTAINS, + EPHY_NODE_PAGE_PROP_TITLE, + search_text), + 0); + ephy_node_filter_add_expression (dialog->priv->filter, + ephy_node_filter_expression_new (EPHY_NODE_FILTER_EXPRESSION_STRING_PROP_CONTAINS, + EPHY_NODE_PAGE_PROP_LOCATION, + search_text), + 0); + ephy_node_filter_add_expression (dialog->priv->filter, + ephy_node_filter_expression_new (EPHY_NODE_FILTER_EXPRESSION_INT_PROP_BIGGER_THAN, + EPHY_NODE_PAGE_PROP_LAST_VISIT, + date_filter), + 1); + + ephy_node_filter_done_changing (dialog->priv->filter); + + GDK_THREADS_LEAVE (); +} + +static void +history_dialog_init (HistoryDialog *dialog) +{ + EphyEmbedShell *ges; + + dialog->priv = g_new0 (HistoryDialogPrivate, 1); + + ges = ephy_shell_get_embed_shell (ephy_shell); + dialog->priv->gh = ephy_embed_shell_get_global_history (ges); + g_return_if_fail (dialog->priv->gh != NULL); + + dialog->priv->root = ephy_history_get_hosts (dialog->priv->gh); + dialog->priv->pages = ephy_history_get_pages (dialog->priv->gh); + dialog->priv->filter = ephy_node_filter_new (); +} + +static void +history_dialog_set_embedded (HistoryDialog *dialog, + gboolean embedded) +{ + dialog->priv->embedded = embedded; + + ephy_dialog_construct (EPHY_DIALOG(dialog), + properties, + "epiphany.glade", + embedded ? + "history_dock_box" : + "history_dialog"); + + dialog->priv->treeview = GTK_TREE_VIEW ( + ephy_dialog_get_control (EPHY_DIALOG(dialog), + PROP_TREEVIEW)); + history_dialog_setup_view (dialog); + history_dialog_setup_filter (dialog); +} + +static void +history_dialog_finalize (GObject *object) +{ + HistoryDialog *dialog; + + g_return_if_fail (object != NULL); + g_return_if_fail (IS_HISTORY_DIALOG (object)); + + dialog = HISTORY_DIALOG (object); + + g_return_if_fail (dialog->priv != NULL); + + g_object_unref (G_OBJECT (dialog->priv->sortmodel)); + g_object_unref (G_OBJECT (dialog->priv->filtermodel)); + g_object_unref (G_OBJECT (dialog->priv->nodemodel)); + + g_free (dialog->priv); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +EphyDialog * +history_dialog_new (EphyEmbed *embed, + gboolean embedded) +{ + HistoryDialog *dialog; + + dialog = HISTORY_DIALOG (g_object_new (HISTORY_DIALOG_TYPE, + "embedded", embedded, + "EphyEmbed", embed, + NULL)); + + return EPHY_DIALOG(dialog); +} + +EphyDialog * +history_dialog_new_with_parent (GtkWidget *window, + EphyEmbed *embed, + gboolean embedded) +{ + HistoryDialog *dialog; + + dialog = HISTORY_DIALOG (g_object_new (HISTORY_DIALOG_TYPE, + "embedded", embedded, + "EphyEmbed", embed, + "ParentWindow", window, + NULL)); + + return EPHY_DIALOG(dialog); +} + +void +history_entry_changed_cb (GtkWidget *widget, + HistoryDialog *dialog) +{ + if (dialog->priv->treeview == NULL) return; + history_dialog_setup_filter (dialog); +} + +void +history_time_optionmenu_changed_cb (GtkWidget *widget, + HistoryDialog *dialog) +{ + if (dialog->priv->treeview == NULL) return; + history_dialog_setup_filter (dialog); +} + +void +history_ok_button_clicked_cb (GtkWidget *button, + HistoryDialog *dialog) +{ + g_object_unref (G_OBJECT(dialog)); +} + +void +history_clear_button_clicked_cb (GtkWidget *button, + HistoryDialog *dialog) +{ + ephy_history_clear (dialog->priv->gh); +} diff --git a/src/history-dialog.h b/src/history-dialog.h new file mode 100644 index 000000000..9a064de5c --- /dev/null +++ b/src/history-dialog.h @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2002 Jorn Baayen + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef HISTORY_DIALOG_H +#define HISTORY_DIALOG_H + +#include "ephy-embed-dialog.h" + +#include <glib-object.h> +#include <glib.h> + +G_BEGIN_DECLS + +typedef struct HistoryDialog HistoryDialog; +typedef struct HistoryDialogClass HistoryDialogClass; + +#define HISTORY_DIALOG_TYPE (history_dialog_get_type ()) +#define HISTORY_DIALOG(obj) (GTK_CHECK_CAST ((obj), HISTORY_DIALOG_TYPE, HistoryDialog)) +#define HISTORY_DIALOG_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), HISTORY_DIALOG, HistoryDialogClass)) +#define IS_HISTORY_DIALOG(obj) (GTK_CHECK_TYPE ((obj), HISTORY_DIALOG_TYPE)) +#define IS_HISTORY_DIALOG_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), HISTORY_DIALOG)) + +typedef struct HistoryDialogPrivate HistoryDialogPrivate; + +struct HistoryDialog +{ + EphyEmbedDialog parent; + HistoryDialogPrivate *priv; +}; + +struct HistoryDialogClass +{ + EphyEmbedDialogClass parent_class; +}; + +GType history_dialog_get_type (void); + +EphyDialog *history_dialog_new (EphyEmbed *embed, + gboolean embedded); + +EphyDialog *history_dialog_new_with_parent (GtkWidget *window, + EphyEmbed *embed, + gboolean embedded); + +G_END_DECLS + +#endif + diff --git a/src/language-editor.c b/src/language-editor.c new file mode 100644 index 000000000..7c24f99fd --- /dev/null +++ b/src/language-editor.c @@ -0,0 +1,388 @@ +/* + * Copyright (C) 2000, 2001, 2002 Marco Pesenti Gritti + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include "language-editor.h" +#include "ephy-gui.h" +#include "ephy-prefs.h" +#include "eel-gconf-extensions.h" + +#include <gtk/gtklabel.h> +#include <gtk/gtkoptionmenu.h> +#include <gtk/gtksignal.h> +#include <gtk/gtkbutton.h> +#include <gtk/gtkeditable.h> +#include <gtk/gtktreeview.h> +#include <gtk/gtktreeselection.h> +#include <gtk/gtkliststore.h> +#include <gtk/gtkcellrenderertext.h> + +enum +{ + COL_DESCRIPTION, + COL_DATA +}; + +enum +{ + TREEVIEW_PROP, + ADD_PROP, + REMOVE_PROP, + LANGUAGE_PROP +}; + +static const +EphyDialogProperty properties [] = +{ + { TREEVIEW_PROP, "languages_treeview", NULL, PT_NORMAL, NULL }, + { ADD_PROP, "add_button", NULL, PT_NORMAL, NULL }, + { REMOVE_PROP, "remove_button", NULL, PT_NORMAL, NULL }, + { LANGUAGE_PROP, "languages_optionmenu", NULL, PT_NORMAL, NULL }, + + { -1, NULL, NULL } +}; + + +struct LanguageEditorPrivate +{ + GtkWidget *treeview; + GtkTreeModel *model; + GtkWidget *optionmenu; +}; + +enum +{ + CHANGED, + LAST_SIGNAL +}; + +static void +language_editor_class_init (LanguageEditorClass *klass); +static void +language_editor_init (LanguageEditor *ge); +static void +language_editor_finalize (GObject *object); + +/* Glade callbacks */ + +void +language_editor_close_button_cb (GtkWidget *button, EphyDialog *dialog); + +static GObjectClass *parent_class = NULL; + +static gint signals[LAST_SIGNAL]; + +GType +language_editor_get_type (void) +{ + static GType language_editor_type = 0; + + if (language_editor_type == 0) + { + static const GTypeInfo our_info = + { + sizeof (LanguageEditorClass), + NULL, /* base_init */ + NULL, /* base_finalize */ + (GClassInitFunc) language_editor_class_init, + NULL, + NULL, /* class_data */ + sizeof (LanguageEditor), + 0, /* n_preallocs */ + (GInstanceInitFunc) language_editor_init + }; + + language_editor_type = g_type_register_static (EPHY_DIALOG_TYPE, + "LanguageEditor", + &our_info, 0); + } + + return language_editor_type; + +} + +static void +language_editor_class_init (LanguageEditorClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + object_class->finalize = language_editor_finalize; + + signals[CHANGED] = + g_signal_new ("changed", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_FIRST, + G_STRUCT_OFFSET (LanguageEditorClass, changed), + NULL, NULL, + g_cclosure_marshal_VOID__POINTER, + G_TYPE_NONE, + 1, + G_TYPE_POINTER); +} + +static void +language_editor_update_pref (LanguageEditor *editor) +{ + GtkTreeIter iter; + int index; + GSList *strings = NULL; + + if (!gtk_tree_model_get_iter_first (GTK_TREE_MODEL (editor->priv->model), &iter)) + { + return; + } + + do + { + GValue val = {0, }; + gtk_tree_model_get_value (GTK_TREE_MODEL (editor->priv->model), + &iter, COL_DATA, &val); + index = g_value_get_int (&val); + + strings = g_slist_append(strings, GINT_TO_POINTER(index)); + } + while (gtk_tree_model_iter_next (GTK_TREE_MODEL (editor->priv->model), &iter)); + + g_signal_emit (editor, signals[CHANGED], 0, strings); + + g_slist_free (strings); +} + +static void +language_editor_add_button_clicked_cb (GtkButton *button, + LanguageEditor *editor) +{ + const char *description; + GtkTreeIter iter; + GtkWidget *menu; + GtkWidget *item; + int history; + + history = gtk_option_menu_get_history (GTK_OPTION_MENU(editor->priv->optionmenu)); + menu = gtk_option_menu_get_menu (GTK_OPTION_MENU(editor->priv->optionmenu)); + item = gtk_menu_get_active (GTK_MENU(menu)); + description = (const char *) g_object_get_data (G_OBJECT(item), "desc"); + + g_return_if_fail (description != NULL); + + gtk_list_store_append (GTK_LIST_STORE (editor->priv->model), + &iter); + + gtk_list_store_set (GTK_LIST_STORE (editor->priv->model), + &iter, + COL_DESCRIPTION, description, + COL_DATA, history, + -1); + + language_editor_update_pref (editor); +} + +static void +language_editor_remove_button_clicked_cb (GtkButton *button, + LanguageEditor *editor) +{ + GList *l, *r = NULL; + GtkTreeIter iter; + GtkTreeSelection *selection; + GtkTreeModel *model; + + selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(editor->priv->treeview)); + l = gtk_tree_selection_get_selected_rows (selection, &model); + for (;l != NULL; l = l->next) + { + r = g_list_append (r, gtk_tree_row_reference_new + (model, (GtkTreePath *)l->data)); + } + + for (; r != NULL; r = r->next) + { + GtkTreePath *node; + + node = gtk_tree_row_reference_get_path + ((GtkTreeRowReference *)r->data); + + gtk_tree_model_get_iter (model, &iter, node); + + gtk_list_store_remove (GTK_LIST_STORE (model), &iter); + + gtk_tree_row_reference_free ((GtkTreeRowReference *)r->data); + } + + l = g_list_first (l); + g_list_foreach (l, (GFunc)gtk_tree_path_free, NULL); + g_list_free (l); + g_list_free (r); + + language_editor_update_pref (editor); +} + +static void +language_editor_treeview_drag_end_cb (GtkWidget *widget, + GdkDragContext *context, + LanguageEditor *editor) +{ + language_editor_update_pref (editor); +} + +static void +language_editor_set_view (LanguageEditor *ge, + GtkWidget *treeview, + GtkWidget *add_button, + GtkWidget *remove_button, + GtkWidget *optionmenu) +{ + GtkTreeViewColumn *column; + GtkCellRenderer *renderer; + GtkListStore *liststore; + GtkTreeSelection *selection; + + ge->priv->treeview = treeview; + ge->priv->optionmenu = optionmenu; + + gtk_tree_view_set_reorderable (GTK_TREE_VIEW(ge->priv->treeview), TRUE); + + liststore = gtk_list_store_new (2, + G_TYPE_STRING, + G_TYPE_INT); + + ge->priv->model = GTK_TREE_MODEL (liststore); + + gtk_tree_view_set_model (GTK_TREE_VIEW(ge->priv->treeview), + ge->priv->model); + gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(ge->priv->treeview), + FALSE); + + renderer = gtk_cell_renderer_text_new (); + + gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW(ge->priv->treeview), + 0, "Language", + renderer, + "text", 0, + NULL); + column = gtk_tree_view_get_column (GTK_TREE_VIEW(ge->priv->treeview), 0); + gtk_tree_view_column_set_resizable (column, TRUE); + gtk_tree_view_column_set_sort_column_id (column, COL_DESCRIPTION); + + selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(ge->priv->treeview)); + gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE); + + /* Connect treeview signals */ + g_signal_connect + (G_OBJECT (ge->priv->treeview), + "drag_end", + G_CALLBACK(language_editor_treeview_drag_end_cb), + ge); + + /* Connect buttons signals */ + g_signal_connect + (G_OBJECT (add_button), + "clicked", + G_CALLBACK(language_editor_add_button_clicked_cb), + ge); + + g_signal_connect + (G_OBJECT (remove_button), + "clicked", + G_CALLBACK(language_editor_remove_button_clicked_cb), + ge); +} + +static void +language_editor_init (LanguageEditor *le) +{ + GtkWidget *treeview; + GtkWidget *optionmenu; + GtkWidget *add_button; + GtkWidget *remove_button; + + le->priv = g_new0 (LanguageEditorPrivate, 1); + + ephy_dialog_construct (EPHY_DIALOG(le), + properties, + "prefs-dialog.glade", + "languages_dialog"); + + treeview = ephy_dialog_get_control (EPHY_DIALOG(le), + TREEVIEW_PROP); + add_button = ephy_dialog_get_control (EPHY_DIALOG(le), + ADD_PROP); + remove_button = ephy_dialog_get_control (EPHY_DIALOG(le), + REMOVE_PROP); + optionmenu = ephy_dialog_get_control (EPHY_DIALOG(le), + LANGUAGE_PROP); + + language_editor_set_view (le, treeview, add_button, remove_button, + optionmenu); +} + +static void +language_editor_finalize (GObject *object) +{ + LanguageEditor *ge; + + g_return_if_fail (object != NULL); + g_return_if_fail (IS_LANGUAGE_EDITOR (object)); + + ge = LANGUAGE_EDITOR (object); + + g_return_if_fail (ge->priv != NULL); + + g_free (ge->priv); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +LanguageEditor * +language_editor_new (GtkWidget *parent) +{ + return LANGUAGE_EDITOR (g_object_new (LANGUAGE_EDITOR_TYPE, + "ParentWindow", parent, + NULL)); +} + +void +language_editor_set_menu (LanguageEditor *editor, + GtkWidget *menu) +{ + gtk_option_menu_set_menu (GTK_OPTION_MENU(editor->priv->optionmenu), + menu); +} + +void +language_editor_add (LanguageEditor *ge, + const char *language, + int id) +{ + GtkTreeIter iter; + + gtk_list_store_append (GTK_LIST_STORE (ge->priv->model), + &iter); + + gtk_list_store_set (GTK_LIST_STORE (ge->priv->model), + &iter, + COL_DESCRIPTION, language, + COL_DATA, id, + -1); +} + +void +language_editor_close_button_cb (GtkWidget *button, EphyDialog *dialog) +{ + g_object_unref (dialog); +} diff --git a/src/language-editor.h b/src/language-editor.h new file mode 100644 index 000000000..153fa136a --- /dev/null +++ b/src/language-editor.h @@ -0,0 +1,67 @@ +/* + * Copyright (C) 2000, 2001, 2002 Marco Pesenti Gritti + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef LANGUAGE_EDITOR_H +#define LANGUAGE_EDITOR_H + +#include "general-prefs.h" + +#include <gtk/gtkwidget.h> +#include <glib-object.h> +#include <glib.h> + +G_BEGIN_DECLS + +typedef struct LanguageEditor LanguageEditor; +typedef struct LanguageEditorClass LanguageEditorClass; + +#define LANGUAGE_EDITOR_TYPE (language_editor_get_type ()) +#define LANGUAGE_EDITOR(obj) (GTK_CHECK_CAST ((obj), LANGUAGE_EDITOR_TYPE, LanguageEditor)) +#define LANGUAGE_EDITOR_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), LANGUAGE_EDITOR, LanguageEditorClass)) +#define IS_LANGUAGE_EDITOR(obj) (GTK_CHECK_TYPE ((obj), LANGUAGE_EDITOR_TYPE)) +#define IS_LANGUAGE_EDITOR_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), LANGUAGE_EDITOR)) + +typedef struct LanguageEditorPrivate LanguageEditorPrivate; + +struct LanguageEditor +{ + EphyDialog parent; + LanguageEditorPrivate *priv; +}; + +struct LanguageEditorClass +{ + EphyDialogClass parent_class; + + void (* changed) (GSList *languages); +}; + +GType language_editor_get_type (void); + +LanguageEditor *language_editor_new (GtkWidget *parent); + +void language_editor_set_menu (LanguageEditor *editor, + GtkWidget *menu); + +void language_editor_add (LanguageEditor *editor, + const char *language, + int id); + +G_END_DECLS + +#endif diff --git a/src/pdm-dialog.c b/src/pdm-dialog.c new file mode 100755 index 000000000..5e077972a --- /dev/null +++ b/src/pdm-dialog.c @@ -0,0 +1,669 @@ +/* + * Copyright (C) 2002 Jorn Baayen + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include "pdm-dialog.h" +#include "ephy-shell.h" +#include "ephy-embed-shell.h" +#include "ephy-gui.h" +#include "ephy-ellipsizing-label.h" + +#include <gtk/gtktreeview.h> +#include <gtk/gtkliststore.h> +#include <gtk/gtkcellrenderertext.h> +#include <bonobo/bonobo-i18n.h> + +typedef struct PdmActionInfo PdmActionInfo; + +typedef void (* PDM_add) (PdmActionInfo *info, gpointer data); +typedef void (* PDM_remove) (PdmActionInfo *info, GList *data); +typedef void (* PDM_free) (PdmActionInfo *info, GList *data); + +static void pdm_dialog_class_init (PdmDialogClass *klass); +static void pdm_dialog_init (PdmDialog *dialog); +static void pdm_dialog_finalize (GObject *object); + +/* Glade callbacks */ +void +pdm_dialog_close_button_clicked_cb (GtkWidget *button, + PdmDialog *dialog); +void +pdm_dialog_cookies_properties_button_clicked_cb (GtkWidget *button, + PdmDialog *dialog); +void +pdm_dialog_cookies_treeview_selection_changed_cb (GtkTreeSelection *selection, + PdmDialog *dialog); +void +pdm_dialog_passwords_treeview_selection_changed_cb (GtkTreeSelection *selection, + PdmDialog *dialog); + +static GObjectClass *parent_class = NULL; + +struct PdmActionInfo +{ + PDM_add add; + PDM_remove remove; + PDM_free free; + GtkWidget *treeview; + GList *list; + int remove_id; + int data_col; + PdmDialog *dialog; +}; + +struct PdmDialogPrivate +{ + GtkTreeModel *model; + PdmActionInfo *cookies; + PdmActionInfo *passwords; +}; + +enum +{ + PROP_COOKIES_TREEVIEW, + PROP_COOKIES_REMOVE, + PROP_PASSWORDS_TREEVIEW, + PROP_PASSWORDS_REMOVE, + PROP_DIALOG, + PROP_COOKIES_PROPERTIES +}; + +enum +{ + COL_COOKIES_HOST, + COL_COOKIES_NAME, + COL_COOKIES_DATA +}; + +enum +{ + COL_PASSWORDS_HOST, + COL_PASSWORDS_USER, + COL_PASSWORDS_DATA +}; + +static const +EphyDialogProperty properties [] = +{ + { PROP_COOKIES_TREEVIEW, "cookies_treeview", NULL, PT_NORMAL, NULL }, + { PROP_COOKIES_REMOVE, "cookies_remove_button", NULL, PT_NORMAL, NULL }, + { PROP_PASSWORDS_TREEVIEW, "passwords_treeview", NULL, PT_NORMAL, NULL }, + { PROP_PASSWORDS_REMOVE, "passwords_remove_button", NULL, PT_NORMAL, NULL }, + { PROP_DIALOG, "pdm_dialog", NULL, PT_NORMAL, NULL }, + { PROP_COOKIES_PROPERTIES, "cookies_properties_button", NULL, PT_NORMAL, NULL }, + + { -1, NULL, NULL } +}; + +GType +pdm_dialog_get_type (void) +{ + static GType pdm_dialog_type = 0; + + if (pdm_dialog_type == 0) + { + static const GTypeInfo our_info = + { + sizeof (PdmDialogClass), + NULL, /* base_init */ + NULL, /* base_finalize */ + (GClassInitFunc) pdm_dialog_class_init, + NULL, + NULL, /* class_data */ + sizeof (PdmDialog), + 0, /* n_preallocs */ + (GInstanceInitFunc) pdm_dialog_init + }; + + pdm_dialog_type = g_type_register_static (EPHY_DIALOG_TYPE, + "PdmDialog", + &our_info, 0); + } + + return pdm_dialog_type; + +} + +static void +pdm_dialog_class_init (PdmDialogClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + object_class->finalize = pdm_dialog_finalize; +} + +static void +cookies_treeview_selection_changed_cb (GtkTreeSelection *selection, + PdmDialog *dialog) +{ + GtkWidget *widget; + GList *l; + EphyDialog *d = EPHY_DIALOG(dialog); + gboolean has_selection; + GtkTreeModel *model; + + l = gtk_tree_selection_get_selected_rows + (selection, &model); + + has_selection = l != NULL; + + widget = ephy_dialog_get_control (d, PROP_COOKIES_PROPERTIES); + gtk_widget_set_sensitive (widget, has_selection); + + g_list_foreach (l, (GFunc)gtk_tree_path_free, NULL); + g_list_free (l); +} + +static void +action_treeview_selection_changed_cb (GtkTreeSelection *selection, + PdmActionInfo *action) +{ + GtkWidget *widget; + GList *l; + EphyDialog *d = EPHY_DIALOG(action->dialog); + gboolean has_selection; + GtkTreeModel *model; + + l = gtk_tree_selection_get_selected_rows + (selection, &model); + + has_selection = l != NULL; + + widget = ephy_dialog_get_control (d, action->remove_id); + gtk_widget_set_sensitive (widget, has_selection); + + g_list_foreach (l, (GFunc)gtk_tree_path_free, NULL); + g_list_free (l); +} + +static GtkWidget * +setup_passwords_treeview (PdmDialog *dialog) +{ + + GtkTreeView *treeview; + GtkListStore *liststore; + GtkCellRenderer *renderer; + GtkTreeViewColumn *column; + GtkTreeSelection *selection; + + treeview = GTK_TREE_VIEW(ephy_dialog_get_control + (EPHY_DIALOG(dialog), + PROP_PASSWORDS_TREEVIEW)); + + /* set tree model */ + liststore = gtk_list_store_new (3, + G_TYPE_STRING, + G_TYPE_STRING, + G_TYPE_POINTER); + gtk_tree_view_set_model (treeview, GTK_TREE_MODEL(liststore)); + gtk_tree_view_set_headers_visible (treeview, TRUE); + selection = gtk_tree_view_get_selection (treeview); + gtk_tree_selection_set_mode (selection, + GTK_SELECTION_MULTIPLE); + + renderer = gtk_cell_renderer_text_new (); + + gtk_tree_view_insert_column_with_attributes (treeview, + COL_PASSWORDS_HOST, + _("Host"), + renderer, + "text", COL_PASSWORDS_HOST, + NULL); + column = gtk_tree_view_get_column (treeview, COL_PASSWORDS_HOST); + gtk_tree_view_column_set_resizable (column, TRUE); + gtk_tree_view_column_set_reorderable (column, TRUE); + gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); + gtk_tree_view_column_set_sort_column_id (column, COL_PASSWORDS_HOST); + + gtk_tree_view_insert_column_with_attributes (treeview, + COL_PASSWORDS_USER, + _("User Name"), + renderer, + "text", COL_PASSWORDS_USER, + NULL); + column = gtk_tree_view_get_column (treeview, COL_PASSWORDS_USER); + gtk_tree_view_column_set_resizable (column, TRUE); + gtk_tree_view_column_set_reorderable (column, TRUE); + gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); + gtk_tree_view_column_set_sort_column_id (column, COL_PASSWORDS_USER); + + return GTK_WIDGET (treeview); +} + +static GtkWidget * +setup_cookies_treeview (PdmDialog *dialog) +{ + GtkTreeView *treeview; + GtkListStore *liststore; + GtkCellRenderer *renderer; + GtkTreeViewColumn *column; + GtkTreeSelection *selection; + + treeview = GTK_TREE_VIEW (ephy_dialog_get_control + (EPHY_DIALOG(dialog), + PROP_COOKIES_TREEVIEW)); + + /* set tree model */ + liststore = gtk_list_store_new (3, + G_TYPE_STRING, + G_TYPE_STRING, + G_TYPE_POINTER); + gtk_tree_view_set_model (treeview, GTK_TREE_MODEL(liststore)); + gtk_tree_view_set_headers_visible (treeview, TRUE); + selection = gtk_tree_view_get_selection (treeview); + gtk_tree_selection_set_mode (selection, + GTK_SELECTION_MULTIPLE); + + g_signal_connect (selection, "changed", + G_CALLBACK(cookies_treeview_selection_changed_cb), + dialog); + + renderer = gtk_cell_renderer_text_new (); + + gtk_tree_view_insert_column_with_attributes (treeview, + COL_COOKIES_HOST, + _("Domain"), + renderer, + "text", COL_COOKIES_HOST, + NULL); + column = gtk_tree_view_get_column (treeview, COL_COOKIES_HOST); + gtk_tree_view_column_set_resizable (column, TRUE); + gtk_tree_view_column_set_reorderable (column, TRUE); + gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); + gtk_tree_view_column_set_sort_column_id (column, COL_COOKIES_HOST); + + gtk_tree_view_insert_column_with_attributes (treeview, + COL_COOKIES_NAME, + _("Name"), + renderer, + "text", COL_COOKIES_NAME, + NULL); + column = gtk_tree_view_get_column (treeview, COL_COOKIES_NAME); + gtk_tree_view_column_set_resizable (column, TRUE); + gtk_tree_view_column_set_reorderable (column, TRUE); + gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); + gtk_tree_view_column_set_sort_column_id (column, COL_COOKIES_NAME); + + return GTK_WIDGET(treeview); +} + +static void +pdm_dialog_remove_button_clicked_cb (GtkWidget *button, + PdmActionInfo *action) +{ + GList *l, *r = NULL; + GList *remove_list = NULL; + GtkTreeModel *model; + GtkTreeSelection *selection; + + selection = gtk_tree_view_get_selection + (GTK_TREE_VIEW(action->treeview)); + l = gtk_tree_selection_get_selected_rows + (selection, &model); + for (;l != NULL; l = l->next) + { + r = g_list_append (r, gtk_tree_row_reference_new + (model, (GtkTreePath *)l->data)); + } + + for (; r != NULL; r = r->next) + { + GtkTreeIter iter; + gpointer data; + GtkTreePath *path; + GValue val = {0, }; + + path = gtk_tree_row_reference_get_path + ((GtkTreeRowReference *)r->data); + + gtk_tree_model_get_iter + (model, &iter, path); + gtk_tree_model_get_value + (model, &iter, action->data_col, &val); + data = g_value_get_pointer (&val); + + gtk_list_store_remove (GTK_LIST_STORE(model), + &iter); + + action->list = g_list_remove (action->list, data); + remove_list = g_list_append (remove_list, data); + + gtk_tree_row_reference_free ((GtkTreeRowReference *)r->data); + } + + if (remove_list) + { + action->remove (action, remove_list); + action->free (action, remove_list); + } + + l = g_list_first (l); + g_list_foreach (l, (GFunc)gtk_tree_path_free, NULL); + g_list_free (l); + g_list_free (r); +} + +static void +setup_action (PdmActionInfo *action) +{ + GList *l; + GtkWidget *widget; + GtkTreeSelection *selection; + + for (l = action->list; l != NULL; l = l->next) + { + action->add (action, l->data); + } + + widget = ephy_dialog_get_control (EPHY_DIALOG(action->dialog), + action->remove_id); + g_signal_connect (widget, "clicked", + G_CALLBACK(pdm_dialog_remove_button_clicked_cb), + action); + + selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(action->treeview)); + g_signal_connect (selection, "changed", + G_CALLBACK(action_treeview_selection_changed_cb), + action); +} + +static void +pdm_dialog_cookie_add (PdmActionInfo *info, + gpointer cookie) +{ + GtkListStore *store; + GtkTreeIter iter; + CookieInfo *cinfo = (CookieInfo *)cookie; + + store = GTK_LIST_STORE(gtk_tree_view_get_model + (GTK_TREE_VIEW(info->treeview))); + + gtk_list_store_append (store, &iter); + gtk_list_store_set (store, + &iter, + COL_COOKIES_HOST, cinfo->base.domain, + COL_COOKIES_NAME, cinfo->name, + COL_COOKIES_DATA, cinfo, + -1); +} + +static void +pdm_dialog_password_add (PdmActionInfo *info, + gpointer password) +{ + GtkListStore *store; + GtkTreeIter iter; + PasswordInfo *pinfo = (PasswordInfo *)password; + + store = GTK_LIST_STORE(gtk_tree_view_get_model + (GTK_TREE_VIEW(info->treeview))); + + gtk_list_store_append (store, &iter); + gtk_list_store_set (store, + &iter, + COL_PASSWORDS_HOST, pinfo->host, + COL_PASSWORDS_USER, pinfo->username, + COL_PASSWORDS_DATA, pinfo, + -1); +} + +static void +pdm_dialog_cookie_remove (PdmActionInfo *info, + GList *data) +{ + EphyEmbedShell *shell; + shell = ephy_shell_get_embed_shell (ephy_shell); + ephy_embed_shell_remove_cookies (shell, data); +} + +static void +pdm_dialog_password_remove (PdmActionInfo *info, + GList *data) +{ + EphyEmbedShell *shell; + shell = ephy_shell_get_embed_shell (ephy_shell); + ephy_embed_shell_remove_passwords (shell, data, PASSWORD_PASSWORD); +} + +static void +pdm_dialog_cookies_free (PdmActionInfo *info, + GList *data) +{ + EphyEmbedShell *shell; + GList *l; + + shell = ephy_shell_get_embed_shell (ephy_shell); + l = data ? data : info->list; + ephy_embed_shell_free_cookies (shell, l); +} + +static void +pdm_dialog_passwords_free (PdmActionInfo *info, + GList *data) +{ + EphyEmbedShell *shell; + GList *l; + + shell = ephy_shell_get_embed_shell (ephy_shell); + l = data ? data : info->list; + ephy_embed_shell_free_passwords (shell, l); +} + +static void +pdm_dialog_init (PdmDialog *dialog) +{ + EphyEmbedShell *shell; + PdmActionInfo *cookies; + PdmActionInfo *passwords; + GtkWidget *cookies_tv; + GtkWidget *passwords_tv; + + shell = ephy_shell_get_embed_shell (ephy_shell); + + dialog->priv = g_new0 (PdmDialogPrivate, 1); + dialog->priv->cookies = NULL; + dialog->priv->passwords = NULL; + + ephy_dialog_construct (EPHY_DIALOG(dialog), + properties, + "epiphany.glade", + "pdm_dialog"); + + cookies_tv = setup_cookies_treeview (dialog); + passwords_tv = setup_passwords_treeview (dialog); + + cookies = g_new0 (PdmActionInfo, 1); + ephy_embed_shell_list_cookies (shell, &cookies->list); + cookies->dialog = dialog; + cookies->remove_id = PROP_COOKIES_REMOVE; + cookies->add = pdm_dialog_cookie_add; + cookies->remove = pdm_dialog_cookie_remove; + cookies->free = pdm_dialog_cookies_free; + cookies->treeview = cookies_tv; + cookies->data_col = COL_COOKIES_DATA; + setup_action (cookies); + + passwords = g_new0 (PdmActionInfo, 1); + ephy_embed_shell_list_passwords (shell, PASSWORD_PASSWORD, + &passwords->list); + passwords->dialog = dialog; + passwords->remove_id = PROP_PASSWORDS_REMOVE; + passwords->add = pdm_dialog_password_add; + passwords->remove = pdm_dialog_password_remove; + passwords->free = pdm_dialog_passwords_free; + passwords->treeview = passwords_tv; + passwords->data_col = COL_PASSWORDS_DATA; + setup_action (passwords); + + dialog->priv->cookies = cookies; + dialog->priv->passwords = passwords; +} + +static void +pdm_dialog_finalize (GObject *object) +{ + PdmDialog *dialog; + + g_return_if_fail (object != NULL); + g_return_if_fail (IS_PDM_DIALOG (object)); + + dialog = PDM_DIALOG (object); + + g_return_if_fail (dialog->priv != NULL); + + pdm_dialog_passwords_free (dialog->priv->passwords, NULL); + pdm_dialog_cookies_free (dialog->priv->cookies, NULL); + + g_free (dialog->priv); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +EphyDialog * +pdm_dialog_new (GtkWidget *window) +{ + PdmDialog *dialog; + + dialog = PDM_DIALOG (g_object_new (PDM_DIALOG_TYPE, + "ParentWindow", window, + NULL)); + + return EPHY_DIALOG(dialog); +} + +static void +show_cookies_properties (PdmDialog *dialog, + CookieInfo *info) +{ + GtkWidget *gdialog; + GtkWidget *table; + GtkWidget *label; + GtkWidget *parent; + GtkWidget *dialog_vbox; + + parent = ephy_dialog_get_control (EPHY_DIALOG(dialog), + PROP_DIALOG); + + gdialog = gtk_dialog_new_with_buttons + (_("Cookie properties"), + GTK_WINDOW(parent), + GTK_DIALOG_MODAL, + GTK_STOCK_CLOSE, 0, NULL); + gtk_dialog_set_has_separator (GTK_DIALOG(gdialog), FALSE); + gtk_container_set_border_width (GTK_CONTAINER(gdialog), 6); + + table = gtk_table_new (2, 4, FALSE); + gtk_container_set_border_width (GTK_CONTAINER(table), 6); + gtk_table_set_row_spacings (GTK_TABLE(table), 10); + gtk_table_set_col_spacings (GTK_TABLE(table), 10); + gtk_widget_show (table); + + label = gtk_label_new (_("<b>Value</b>")); + gtk_label_set_use_markup (GTK_LABEL(label), TRUE); + gtk_misc_set_alignment (GTK_MISC(label), 0, 0); + gtk_widget_show (label); + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, + GTK_FILL, GTK_FILL, 0, 0); + + label = ephy_ellipsizing_label_new (info->value); + gtk_misc_set_alignment (GTK_MISC(label), 0, 0); + gtk_widget_show (label); + gtk_table_attach_defaults (GTK_TABLE (table), label, 1, 2, 0, 1); + + label = gtk_label_new (_("<b>Path</b>")); + gtk_label_set_use_markup (GTK_LABEL(label), TRUE); + gtk_misc_set_alignment (GTK_MISC(label), 0, 0); + gtk_widget_show (label); + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, + GTK_FILL, GTK_FILL, 0, 0); + + label = gtk_label_new (info->path); + gtk_misc_set_alignment (GTK_MISC(label), 0, 0); + gtk_widget_show (label); + gtk_table_attach_defaults (GTK_TABLE (table), label, 1, 2, 1, 2); + + label = gtk_label_new (_("<b>Secure</b>")); + gtk_label_set_use_markup (GTK_LABEL(label), TRUE); + gtk_misc_set_alignment (GTK_MISC(label), 0, 0); + gtk_widget_show (label); + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3, + GTK_FILL, GTK_FILL, 0, 0); + + label = gtk_label_new (info->secure); + gtk_misc_set_alignment (GTK_MISC(label), 0, 0); + gtk_widget_show (label); + gtk_table_attach_defaults (GTK_TABLE (table), label, 1, 2, 2, 3); + + label = gtk_label_new (_("<b>Expire</b>")); + gtk_label_set_use_markup (GTK_LABEL(label), TRUE); + gtk_misc_set_alignment (GTK_MISC(label), 0, 0); + gtk_widget_show (label); + gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4, + GTK_FILL, GTK_FILL, 0, 0); + + label = gtk_label_new (info->expire); + gtk_misc_set_alignment (GTK_MISC(label), 0, 0.5); + gtk_widget_show (label); + gtk_table_attach_defaults (GTK_TABLE (table), label, 1, 2, 3, 4); + + dialog_vbox = GTK_DIALOG(gdialog)->vbox; + gtk_box_pack_start (GTK_BOX(dialog_vbox), + table, + FALSE, FALSE, 0); + + gtk_dialog_run (GTK_DIALOG(gdialog)); + + gtk_widget_destroy (gdialog); +} + +void +pdm_dialog_cookies_properties_button_clicked_cb (GtkWidget *button, + PdmDialog *dialog) +{ + GtkTreeModel *model; + GValue val = {0, }; + GtkTreeIter iter; + GtkTreePath *path; + CookieInfo *info; + GList *l; + GtkWidget *treeview = dialog->priv->cookies->treeview; + GtkTreeSelection *selection; + + selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); + l = gtk_tree_selection_get_selected_rows + (selection, &model); + + path = (GtkTreePath *)l->data; + gtk_tree_model_get_iter (model, &iter, path); + gtk_tree_model_get_value + (model, &iter, COL_COOKIES_DATA, &val); + info = (CookieInfo *)g_value_get_pointer (&val); + + show_cookies_properties (dialog, info); + + g_list_foreach (l, (GFunc)gtk_tree_path_free, NULL); + g_list_free (l); +} + +void +pdm_dialog_close_button_clicked_cb (GtkWidget *button, + PdmDialog *dialog) +{ + g_object_unref (dialog); +} diff --git a/src/pdm-dialog.h b/src/pdm-dialog.h new file mode 100644 index 000000000..7216d4ac0 --- /dev/null +++ b/src/pdm-dialog.h @@ -0,0 +1,56 @@ +/* + * Copyright (C) 2002 Jorn Baayen + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef PDM_DIALOG_H +#define PDM_DIALOG_H + +#include "ephy-dialog.h" +#include <glib.h> + +G_BEGIN_DECLS + +typedef struct PdmDialog PdmDialog; +typedef struct PdmDialogClass PdmDialogClass; + +#define PDM_DIALOG_TYPE (pdm_dialog_get_type ()) +#define PDM_DIALOG(obj) (GTK_CHECK_CAST ((obj), PDM_DIALOG_TYPE, PdmDialog)) +#define PDM_DIALOG_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), PDM_DIALOG, PdmDialogClass)) +#define IS_PDM_DIALOG(obj) (GTK_CHECK_TYPE ((obj), PDM_DIALOG_TYPE)) +#define IS_PDM_DIALOG_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), PDM_DIALOG)) + +typedef struct PdmDialogPrivate PdmDialogPrivate; + +struct PdmDialog +{ + EphyDialog parent; + PdmDialogPrivate *priv; +}; + +struct PdmDialogClass +{ + EphyDialogClass parent_class; +}; + +GType pdm_dialog_get_type (void); + +EphyDialog *pdm_dialog_new (GtkWidget *window); + +G_END_DECLS + +#endif + diff --git a/src/popup-commands.c b/src/popup-commands.c new file mode 100644 index 000000000..bf187d981 --- /dev/null +++ b/src/popup-commands.c @@ -0,0 +1,222 @@ +/* + * Copyright (C) 2000, 2001, 2002 Marco Pesenti Gritti + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include "popup-commands.h" +#include "ephy-shell.h" + +static EphyWindow * +get_window_from_popup (EphyEmbedPopup *popup) +{ + return EPHY_WINDOW (g_object_get_data(G_OBJECT(popup), "EphyWindow")); +} + +void popup_cmd_new_window (BonoboUIComponent *uic, + EphyEmbedPopup *popup, + const char* verbname) +{ + EphyEmbedEvent *info; + EphyTab *tab; + GValue *value; + + tab = ephy_window_get_active_tab (get_window_from_popup (popup)); + + info = ephy_embed_popup_get_event (popup); + + ephy_embed_event_get_property (info, "link", &value); + + ephy_shell_new_tab (ephy_shell, NULL, tab, + g_value_get_string (value), + EPHY_NEW_TAB_IN_NEW_WINDOW); +} + +void popup_cmd_new_tab (BonoboUIComponent *uic, + EphyEmbedPopup *popup, + const char* verbname) +{ + EphyEmbedEvent *info; + EphyTab *tab; + EphyWindow *window; + GValue *value; + + window = get_window_from_popup (popup); + g_return_if_fail (window != NULL); + + tab = ephy_window_get_active_tab (window); + + info = ephy_embed_popup_get_event (popup); + + ephy_embed_event_get_property (info, "link", &value); + + ephy_shell_new_tab (ephy_shell, window, tab, + g_value_get_string (value), + EPHY_NEW_TAB_IN_EXISTING_WINDOW); +} + +void popup_cmd_image_in_new_tab (BonoboUIComponent *uic, + EphyEmbedPopup *popup, + const char* verbname) +{ + EphyEmbedEvent *info; + EphyTab *tab; + EphyWindow *window; + GValue *value; + + window = get_window_from_popup (popup); + g_return_if_fail (window != NULL); + + tab = ephy_window_get_active_tab (window); + + info = ephy_embed_popup_get_event (popup); + + ephy_embed_event_get_property (info, "image", &value); + + ephy_shell_new_tab (ephy_shell, window, tab, + g_value_get_string (value), + EPHY_NEW_TAB_IN_EXISTING_WINDOW); +} + +void popup_cmd_image_in_new_window (BonoboUIComponent *uic, + EphyEmbedPopup *popup, + const char* verbname) +{ + EphyEmbedEvent *info; + EphyTab *tab; + GValue *value; + + tab = ephy_window_get_active_tab (get_window_from_popup (popup)); + + info = ephy_embed_popup_get_event (popup); + + ephy_embed_event_get_property (info, "image", &value); + + ephy_shell_new_tab (ephy_shell, NULL, tab, + g_value_get_string (value), + EPHY_NEW_TAB_IN_NEW_WINDOW); +} + +void popup_cmd_add_bookmark (BonoboUIComponent *uic, + EphyEmbedPopup *popup, + const char* verbname) +{ + GtkWidget *new_bookmark; + EphyBookmarks *bookmarks; + EphyEmbedEvent *info = ephy_embed_popup_get_event (popup); + EphyEmbed *embed; + GtkWidget *window; + GValue *link_title; + GValue *link_rel; + GValue *link; + GValue *link_is_smart; + const char *title; + const char *location; + const char *rel; + gboolean is_smart; + + embed = ephy_embed_popup_get_embed (popup); + window = gtk_widget_get_toplevel (GTK_WIDGET (embed)); + + ephy_embed_event_get_property (info, "link_is_smart", &link_is_smart); + ephy_embed_event_get_property (info, "link", &link); + ephy_embed_event_get_property (info, "link_title", &link_title); + ephy_embed_event_get_property (info, "link_rel", &link_rel); + + title = g_value_get_string (link_title); + location = g_value_get_string (link); + rel = g_value_get_string (link_rel); + is_smart = g_value_get_int (link_is_smart); + + g_return_if_fail (location); + + if (!title || !title[0]) + { + title = location; + } + + bookmarks = ephy_shell_get_bookmarks (ephy_shell); + new_bookmark = ephy_new_bookmark_new + (bookmarks, GTK_WINDOW (window), location); + ephy_new_bookmark_set_title + (EPHY_NEW_BOOKMARK (new_bookmark), title); + ephy_new_bookmark_set_smarturl + (EPHY_NEW_BOOKMARK (new_bookmark), rel); + gtk_widget_show (new_bookmark); +} + +void popup_cmd_frame_in_new_tab (BonoboUIComponent *uic, + EphyEmbedPopup *popup, + const char* verbname) +{ + EphyTab *tab; + EphyWindow *window; + EphyEmbed *embed; + char *location; + + window = get_window_from_popup (popup); + g_return_if_fail (window != NULL); + + tab = ephy_window_get_active_tab (window); + + embed = ephy_window_get_active_embed (window); + + ephy_embed_get_location (embed, FALSE, FALSE, &location); + + ephy_shell_new_tab (ephy_shell, window, tab, + location, + EPHY_NEW_TAB_IN_EXISTING_WINDOW); + + g_free (location); +} + +void popup_cmd_frame_in_new_window (BonoboUIComponent *uic, + EphyEmbedPopup *popup, + const char* verbname) +{ + EphyTab *tab; + EphyEmbed *embed; + EphyWindow *window; + char *location; + + window = get_window_from_popup (popup); + g_return_if_fail (window != NULL); + + tab = ephy_window_get_active_tab (window); + + embed = ephy_window_get_active_embed (window); + + ephy_embed_get_location (embed, FALSE, FALSE, &location); + + ephy_shell_new_tab (ephy_shell, NULL, tab, + location, + EPHY_NEW_TAB_IN_NEW_WINDOW); + + g_free (location); +} + +void popup_cmd_add_frame_bookmark (BonoboUIComponent *uic, + EphyEmbedPopup *popup, + const char* verbname) +{ + /* FIXME implement */ +} + +void popup_cmd_view_source (BonoboUIComponent *uic, + EphyEmbedPopup *popup, + const char* verbname) +{ + /* FIXME implement */ +} diff --git a/src/popup-commands.h b/src/popup-commands.h new file mode 100644 index 000000000..e5b369c76 --- /dev/null +++ b/src/popup-commands.h @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2000, 2001, 2002 Marco Pesenti Gritti + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include "ephy-embed-popup.h" +#include "ephy-new-bookmark.h" + +#include <bonobo/bonobo-ui-component.h> + +void popup_cmd_new_window (BonoboUIComponent *uic, + EphyEmbedPopup *popup, + const char* verbname); + +void popup_cmd_new_tab (BonoboUIComponent *uic, + EphyEmbedPopup *popup, + const char* verbname); + +void popup_cmd_image_in_new_tab (BonoboUIComponent *uic, + EphyEmbedPopup *popup, + const char* verbname); + +void popup_cmd_image_in_new_window (BonoboUIComponent *uic, + EphyEmbedPopup *popup, + const char* verbname); + +void popup_cmd_add_bookmark (BonoboUIComponent *uic, + EphyEmbedPopup *popup, + const char* verbname); + +void popup_cmd_frame_in_new_tab (BonoboUIComponent *uic, + EphyEmbedPopup *popup, + const char* verbname); + +void popup_cmd_frame_in_new_window (BonoboUIComponent *uic, + EphyEmbedPopup *popup, + const char* verbname); + +void popup_cmd_add_frame_bookmark (BonoboUIComponent *uic, + EphyEmbedPopup *popup, + const char* verbname); + +void popup_cmd_view_source (BonoboUIComponent *uic, + EphyEmbedPopup *popup, + const char* verbname); diff --git a/src/ppview-toolbar.c b/src/ppview-toolbar.c new file mode 100755 index 000000000..06b2cbb6e --- /dev/null +++ b/src/ppview-toolbar.c @@ -0,0 +1,388 @@ +/* + * Copyright (C) 2002 Marco Pesenti Gritti + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + + +#include "ppview-toolbar.h" +#include "ephy-window.h" +#include "ephy-bonobo-extensions.h" +#include "ephy-string.h" +#include "ephy-gui.h" + +#include <string.h> +#include <bonobo/bonobo-i18n.h> +#include <bonobo/bonobo-window.h> +#include <bonobo/bonobo-control.h> +#include <bonobo/bonobo-ui-toolbar-button-item.h> +#include <bonobo/bonobo-property-bag.h> +#include <gtk/gtkentry.h> +#include <gtk/gtkmenu.h> + +#define PPV_GOTO_FIRST_PATH "/commands/PPVGotoFirst" +#define PPV_GOTO_LAST_PATH "/commands/PPVGotoLast" +#define PPV_GO_BACK_PATH "/commands/PPVGoBack" +#define PPV_GO_FORWARD_PATH "/commands/PPVGoForward" + +static void ppview_toolbar_class_init (PPViewToolbarClass *klass); +static void ppview_toolbar_init (PPViewToolbar *t); +static void ppview_toolbar_finalize (GObject *object); +static void ppview_toolbar_set_window (PPViewToolbar *t, EphyWindow *window); +static void +ppview_toolbar_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec); +static void +ppview_toolbar_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec); + +enum +{ + PROP_0, + PROP_EPHY_WINDOW +}; + +static GObjectClass *parent_class = NULL; + +struct PPViewToolbarPrivate +{ + EphyWindow *window; + BonoboUIComponent *ui_component; + gboolean visibility; + EmbedChromeMask old_chrome; + int current_page; +}; + +static void +toolbar_cmd_ppv_goto_first (BonoboUIComponent *uic, + PPViewToolbar *t, + const char* verbname); + +static void +toolbar_cmd_ppv_goto_last (BonoboUIComponent *uic, + PPViewToolbar *t, + const char* verbname); + +static void +toolbar_cmd_ppv_go_back (BonoboUIComponent *uic, + PPViewToolbar *t, + const char* verbname); + +static void +toolbar_cmd_ppv_go_forward (BonoboUIComponent *uic, + PPViewToolbar *t, + const char* verbname); + +static void +toolbar_cmd_ppv_close (BonoboUIComponent *uic, + PPViewToolbar *t, + const char* verbname); + +BonoboUIVerb ppview_toolbar_verbs [] = { + BONOBO_UI_VERB ("PPVGotoFirst", (BonoboUIVerbFn)toolbar_cmd_ppv_goto_first), + BONOBO_UI_VERB ("PPVGotoLast", (BonoboUIVerbFn)toolbar_cmd_ppv_goto_last), + BONOBO_UI_VERB ("PPVGoBack", (BonoboUIVerbFn)toolbar_cmd_ppv_go_back), + BONOBO_UI_VERB ("PPVGoForward", (BonoboUIVerbFn)toolbar_cmd_ppv_go_forward), + BONOBO_UI_VERB ("PPVClose", (BonoboUIVerbFn)toolbar_cmd_ppv_close), + + BONOBO_UI_VERB_END +}; + +GType +ppview_toolbar_get_type (void) +{ + static GType ppview_toolbar_type = 0; + + if (ppview_toolbar_type == 0) + { + static const GTypeInfo our_info = + { + sizeof (PPViewToolbarClass), + NULL, /* base_init */ + NULL, /* base_finalize */ + (GClassInitFunc) ppview_toolbar_class_init, + NULL, + NULL, /* class_data */ + sizeof (PPViewToolbar), + 0, /* n_preallocs */ + (GInstanceInitFunc) ppview_toolbar_init + }; + + ppview_toolbar_type = g_type_register_static (G_TYPE_OBJECT, + "PPViewToolbar", + &our_info, 0); + } + + return ppview_toolbar_type; + +} + +static void +ppview_toolbar_class_init (PPViewToolbarClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + object_class->finalize = ppview_toolbar_finalize; + + object_class->set_property = ppview_toolbar_set_property; + object_class->get_property = ppview_toolbar_get_property; + + g_object_class_install_property (object_class, + PROP_EPHY_WINDOW, + g_param_spec_object ("EphyWindow", + "EphyWindow", + "Parent window", + EPHY_WINDOW_TYPE, + G_PARAM_READWRITE)); +} + +static void +ppview_toolbar_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + PPViewToolbar *t = PPVIEW_TOOLBAR (object); + + switch (prop_id) + { + case PROP_EPHY_WINDOW: + ppview_toolbar_set_window (t, g_value_get_object (value)); + break; + } +} + +static void +ppview_toolbar_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + PPViewToolbar *t = PPVIEW_TOOLBAR (object); + + switch (prop_id) + { + case PROP_EPHY_WINDOW: + g_value_set_object (value, t->priv->window); + break; + } +} + +static void +ppview_toolbar_set_window (PPViewToolbar *t, EphyWindow *window) +{ + g_return_if_fail (t->priv->window == NULL); + + t->priv->window = window; + t->priv->ui_component = BONOBO_UI_COMPONENT + (t->priv->window->ui_component); + + bonobo_ui_component_add_verb_list_with_data (t->priv->ui_component, + ppview_toolbar_verbs, + t); +} + +static void +ppview_toolbar_init (PPViewToolbar *t) +{ + t->priv = g_new0 (PPViewToolbarPrivate, 1); + + t->priv->window = NULL; + t->priv->ui_component = NULL; + t->priv->visibility = TRUE; +} + +static void +ppview_toolbar_finalize (GObject *object) +{ + PPViewToolbar *t; + + g_return_if_fail (object != NULL); + g_return_if_fail (IS_PPVIEW_TOOLBAR (object)); + + t = PPVIEW_TOOLBAR (object); + + g_return_if_fail (t->priv != NULL); + + g_free (t->priv); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +PPViewToolbar * +ppview_toolbar_new (EphyWindow *window) +{ + PPViewToolbar *t; + + t = PPVIEW_TOOLBAR (g_object_new (PPVIEW_TOOLBAR_TYPE, + "EphyWindow", window, + NULL)); + + g_return_val_if_fail (t->priv != NULL, NULL); + + return t; +} + +void +ppview_toolbar_set_old_chrome (PPViewToolbar *t, + EmbedChromeMask chrome) +{ + t->priv->old_chrome = chrome; +} + +static void +toolbar_update_sensitivity (PPViewToolbar *t) +{ + int pages, c_page; + EphyWindow *window = t->priv->window; + EphyEmbed *embed; + + embed = ephy_window_get_active_embed (window); + g_return_if_fail (embed != NULL); + + ephy_embed_print_preview_num_pages (embed, &pages); + c_page = t->priv->current_page; + + ephy_bonobo_set_sensitive (t->priv->ui_component, + PPV_GO_BACK_PATH, c_page > 1); + ephy_bonobo_set_sensitive (t->priv->ui_component, + PPV_GOTO_FIRST_PATH, c_page > 1); + ephy_bonobo_set_sensitive (t->priv->ui_component, + PPV_GO_FORWARD_PATH, c_page < pages); + ephy_bonobo_set_sensitive (t->priv->ui_component, + PPV_GOTO_LAST_PATH, c_page < pages); +} + +void +ppview_toolbar_set_visibility (PPViewToolbar *t, gboolean visibility) +{ + if (visibility == t->priv->visibility) return; + + t->priv->visibility = visibility; + + if (visibility) + { + t->priv->current_page = 1; + toolbar_update_sensitivity (t); + } + + ephy_bonobo_set_hidden (BONOBO_UI_COMPONENT(t->priv->ui_component), + "/PrintPreview", + !visibility); +} + +static void +toolbar_cmd_ppv_goto_first (BonoboUIComponent *uic, + PPViewToolbar *t, + const char* verbname) +{ + EphyWindow *window = t->priv->window; + EphyEmbed *embed; + + embed = ephy_window_get_active_embed (window); + g_return_if_fail (embed != NULL); + + ephy_embed_print_preview_navigate (embed, PRINTPREVIEW_HOME, 0); + + t->priv->current_page = 1; + + toolbar_update_sensitivity (t); +} + +static void +toolbar_cmd_ppv_goto_last (BonoboUIComponent *uic, + PPViewToolbar *t, + const char* verbname) +{ + EphyWindow *window = t->priv->window; + EphyEmbed *embed; + + embed = ephy_window_get_active_embed (window); + g_return_if_fail (embed != NULL); + + ephy_embed_print_preview_navigate (embed, + PRINTPREVIEW_END, + 0); + + ephy_embed_print_preview_num_pages (embed, + &t->priv->current_page); + + toolbar_update_sensitivity (t); +} + +static void +toolbar_cmd_ppv_go_back (BonoboUIComponent *uic, + PPViewToolbar *t, + const char* verbname) +{ + EphyWindow *window = t->priv->window; + EphyEmbed *embed; + + embed = ephy_window_get_active_embed (window); + g_return_if_fail (embed != NULL); + + ephy_embed_print_preview_navigate (embed, + PRINTPREVIEW_PREV_PAGE, + 0); + + t->priv->current_page --; + + toolbar_update_sensitivity (t); +} + +static void +toolbar_cmd_ppv_go_forward (BonoboUIComponent *uic, + PPViewToolbar *t, + const char* verbname) +{ + EphyWindow *window = t->priv->window; + EphyEmbed *embed; + + embed = ephy_window_get_active_embed (window); + g_return_if_fail (embed != NULL); + + ephy_embed_print_preview_navigate (embed, + PRINTPREVIEW_NEXT_PAGE, + 0); + + t->priv->current_page ++; + + toolbar_update_sensitivity (t); +} + +static void +toolbar_cmd_ppv_close (BonoboUIComponent *uic, + PPViewToolbar *t, + const char* verbname) +{ + EphyWindow *window = t->priv->window; + EphyEmbed *embed; + + embed = ephy_window_get_active_embed (window); + g_return_if_fail (embed != NULL); + + ephy_window_set_chrome (window, t->priv->old_chrome); + + ephy_embed_print_preview_close (embed); + + toolbar_update_sensitivity (t); +} + diff --git a/src/ppview-toolbar.h b/src/ppview-toolbar.h new file mode 100644 index 000000000..3e6a4b504 --- /dev/null +++ b/src/ppview-toolbar.h @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2002 Jorn Baayen + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef PPVIEW_TOOLBAR_H +#define PPVIEW_TOOLBAR_H + +#include "ephy-window.h" +#include <glib-object.h> +#include <glib.h> +#include <gtk/gtkbutton.h> + +G_BEGIN_DECLS + +typedef struct PPViewToolbar PPViewToolbar; +typedef struct PPViewToolbarClass PPViewToolbarClass; + +#define PPVIEW_TOOLBAR_TYPE (ppview_toolbar_get_type ()) +#define PPVIEW_TOOLBAR(obj) (GTK_CHECK_CAST ((obj), PPVIEW_TOOLBAR_TYPE, PPViewToolbar)) +#define PPVIEW_TOOLBAR_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), PPVIEW_TOOLBAR, PPViewToolbarClass)) +#define IS_PPVIEW_TOOLBAR(obj) (GTK_CHECK_TYPE ((obj), PPVIEW_TOOLBAR_TYPE)) +#define IS_PPVIEW_TOOLBAR_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), PPVIEW_TOOLBAR)) + +typedef struct PPViewToolbarPrivate PPViewToolbarPrivate; + +struct PPViewToolbar +{ + GObject parent; + PPViewToolbarPrivate *priv; +}; + +struct PPViewToolbarClass +{ + GObjectClass parent_class; +}; + +GType ppview_toolbar_get_type (void); + +PPViewToolbar *ppview_toolbar_new (EphyWindow *window); + +void ppview_toolbar_set_visibility (PPViewToolbar *t, + gboolean visibility); + +void ppview_toolbar_set_old_chrome (PPViewToolbar *t, + EmbedChromeMask chrome); + +G_END_DECLS + +#endif diff --git a/src/prefs-dialog.c b/src/prefs-dialog.c new file mode 100644 index 000000000..8f010420c --- /dev/null +++ b/src/prefs-dialog.c @@ -0,0 +1,335 @@ +/* + * Copyright (C) 2000, 2001, 2002 Marco Pesenti Gritti + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "prefs-dialog.h" +#include "general-prefs.h" +#include "appearance-prefs.h" +#include "ui-prefs.h" +#include "ephy-dialog.h" +#include "ephy-prefs.h" +#include "ephy-embed-prefs.h" +#include "ephy-shell.h" +#include "ephy-state.h" + +#include <bonobo/bonobo-i18n.h> +#include <gtk/gtkframe.h> +#include <gtk/gtkhbox.h> +#include <gtk/gtkvbox.h> +#include <gtk/gtkradiobutton.h> +#include <gtk/gtktogglebutton.h> +#include <gtk/gtkimage.h> +#include <gtk/gtklabel.h> +#include <gtk/gtkstock.h> + +static void +prefs_dialog_class_init (PrefsDialogClass *klass); +static void +prefs_dialog_init (PrefsDialog *pd); +static void +prefs_dialog_finalize (GObject *object); + +/* Glade callbacks */ +void +prefs_proxy_auto_url_reload_cb (GtkWidget *button, + EphyDialog *dialog); +void +prefs_clear_memory_cache_button_clicked_cb (GtkWidget *button, + gpointer data); +void +prefs_clear_disk_cache_button_clicked_cb (GtkWidget *button, + gpointer data); + + +/* Proxy page */ + +enum +{ + CACHE_COMPARE_PROP, + DISK_CACHE_PROP, + MEMORY_CACHE_PROP +}; + +static const +EphyDialogProperty network_properties [] = +{ + { CACHE_COMPARE_PROP, "cache_compare_radiobutton", CONF_NETWORK_CACHE_COMPARE, PT_AUTOAPPLY, NULL }, + { DISK_CACHE_PROP, "disk_cache_spin", CONF_NETWORK_DISK_CACHE, PT_AUTOAPPLY, NULL }, + { MEMORY_CACHE_PROP, "memory_cache_spin", CONF_NETWORK_MEMORY_CACHE, PT_AUTOAPPLY, NULL }, + + { -1, NULL, NULL } +}; + +struct PrefsDialogPrivate +{ + GtkWidget *notebook; +}; + +static GObjectClass *parent_class = NULL; + +GType +prefs_dialog_get_type (void) +{ + static GType prefs_dialog_type = 0; + + if (prefs_dialog_type == 0) + { + static const GTypeInfo our_info = + { + sizeof (PrefsDialogClass), + NULL, /* base_init */ + NULL, /* base_finalize */ + (GClassInitFunc) prefs_dialog_class_init, + NULL, + NULL, /* class_data */ + sizeof (PrefsDialog), + 0, /* n_preallocs */ + (GInstanceInitFunc) prefs_dialog_init + }; + + prefs_dialog_type = g_type_register_static (GTK_TYPE_DIALOG, + "PrefsDialog", + &our_info, 0); + } + + return prefs_dialog_type; + +} + +GtkDialog * +prefs_dialog_new (void) +{ + GtkDialog *dialog; + + dialog = GTK_DIALOG (g_object_new (PREFS_DIALOG_TYPE, NULL)); + + return dialog; +} + +static void +prefs_dialog_class_init (PrefsDialogClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + object_class->finalize = prefs_dialog_finalize; +} + +static void +prefs_dialog_finalize (GObject *object) +{ + PrefsDialog *pd; + + g_return_if_fail (object != NULL); + g_return_if_fail (IS_PREFS_DIALOG (object)); + + pd = PREFS_DIALOG (object); + + g_return_if_fail (pd->priv != NULL); + + g_free (pd->priv); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +static EphyDialog * +create_page (PrefsPageID id, + const char *page_widget, + const EphyDialogProperty *prop) +{ + EphyDialog *page = NULL; + + switch (id) + { + case PREFS_PAGE_GENERAL: + page = general_prefs_new (); + break; + case PREFS_PAGE_APPEARANCE: + page = appearance_prefs_new (); + break; + case PREFS_PAGE_UI: + page = ui_prefs_new (); + break; + case PREFS_PAGE_ADVANCED: + page = ephy_dialog_new (); + ephy_dialog_construct (EPHY_DIALOG(page), + prop, + "prefs-dialog.glade", + page_widget); + break; + } + + return page; +} + +static EphyDialog * +prefs_dialog_get_page (PrefsDialog *pd, + PrefsPageID id) +{ + const char *page_widget = NULL; + EphyDialog *page; + const EphyDialogProperty *prop = NULL; + + switch (id) + { + case PREFS_PAGE_APPEARANCE: + page_widget = "appearance_page_box"; + break; + case PREFS_PAGE_GENERAL: + page_widget = "general_page_box"; + break; + case PREFS_PAGE_UI: + page_widget = "ui_page_box"; + break; + case PREFS_PAGE_ADVANCED: + page_widget = "network_page_box"; + prop = network_properties; + break; + } + + g_assert (page_widget != NULL); + + page = create_page (id, page_widget, prop); + g_assert (page != NULL); + + return page; +} + +void +prefs_dialog_show_page (PrefsDialog *pd, + PrefsPageID id) +{ + gtk_notebook_set_current_page (GTK_NOTEBOOK (pd->priv->notebook), id); +} + +static void +prefs_dialog_response_cb (GtkDialog *dialog, gint response_id, gpointer data) +{ + if (response_id == GTK_RESPONSE_CLOSE) + { + gtk_widget_destroy (GTK_WIDGET(dialog)); + } +} + +static void +prefs_build_notebook (PrefsDialog *pd) +{ + int i; + GtkWidget *nb; + + struct + { + char *name; + int id; + } + pages[] = + { + { _("General"), PREFS_PAGE_GENERAL }, + { _("Appearance"), PREFS_PAGE_APPEARANCE }, + { _("User Interface"), PREFS_PAGE_UI }, + { _("Advanced"), PREFS_PAGE_ADVANCED }, + + { NULL, 0 } + }; + + gtk_dialog_add_button (GTK_DIALOG (pd), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); + + g_signal_connect (pd, "response", + G_CALLBACK (prefs_dialog_response_cb), + NULL); + + gtk_container_set_border_width (GTK_CONTAINER (pd), 5); + + nb = gtk_notebook_new (); + gtk_container_set_border_width (GTK_CONTAINER (nb), 5); + gtk_widget_show (nb); + gtk_container_add (GTK_CONTAINER (GTK_DIALOG (pd)->vbox), nb); + gtk_notebook_set_show_tabs (GTK_NOTEBOOK (nb), TRUE); + pd->priv->notebook = nb; + + for (i = 0; pages[i].name != NULL; i++) + { + GtkWidget *label, *child; + EphyDialog *page; + + page = prefs_dialog_get_page (pd, pages[i].id); + + child = gtk_hbox_new (FALSE, 0); + gtk_widget_show (child); + label = gtk_label_new (pages[i].name); + gtk_notebook_append_page (GTK_NOTEBOOK (nb), + child, label); + + ephy_dialog_show_embedded (page, child); + } +} + +static gboolean +prefs_dialog_configure_event_cb (GtkWidget *widget, + GdkEventConfigure *event, + gpointer data) +{ + ephy_state_save_window (widget, "prefs_dialog"); + + return FALSE; +} + +static void +prefs_dialog_init (PrefsDialog *pd) +{ + pd->priv = g_new0 (PrefsDialogPrivate, 1); + + gtk_window_set_title (GTK_WINDOW(pd), _("Preferences")); + gtk_dialog_set_has_separator (GTK_DIALOG(pd), FALSE); + + ephy_state_load_window (GTK_WIDGET(pd), + "prefs_dialog", -1, -1, FALSE); + + g_signal_connect (pd, + "configure_event", + G_CALLBACK (prefs_dialog_configure_event_cb), + NULL); + + prefs_build_notebook (pd); +} + +/* Network page callbacks */ + +void +prefs_clear_memory_cache_button_clicked_cb (GtkWidget *button, + gpointer data) +{ + EphyEmbedShell *shell; + + shell = ephy_shell_get_embed_shell (ephy_shell); + ephy_embed_shell_clear_cache (shell, MEMORY_CACHE); +} + +void +prefs_clear_disk_cache_button_clicked_cb (GtkWidget *button, + gpointer data) +{ + EphyEmbedShell *shell; + + shell = ephy_shell_get_embed_shell (ephy_shell); + ephy_embed_shell_clear_cache (shell, DISK_CACHE); +} diff --git a/src/prefs-dialog.h b/src/prefs-dialog.h new file mode 100644 index 000000000..3c5528b2f --- /dev/null +++ b/src/prefs-dialog.h @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2000, 2001, 2002 Marco Pesenti Gritti + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef PREFS_DIALOG_H +#define PREFS_DIALOG_H + +#include <gtk/gtkdialog.h> +#include <glib-object.h> +#include <glib.h> + +typedef struct PrefsDialog PrefsDialog; +typedef struct PrefsDialogClass PrefsDialogClass; + +#define PREFS_DIALOG_TYPE (prefs_dialog_get_type ()) +#define PREFS_DIALOG(obj) (GTK_CHECK_CAST ((obj), PREFS_DIALOG_TYPE, PrefsDialog)) +#define PREFS_DIALOG_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), PREFS_DIALOG, PrefsDialogClass)) +#define IS_PREFS_DIALOG(obj) (GTK_CHECK_TYPE ((obj), PREFS_DIALOG_TYPE)) +#define IS_PREFS_DIALOG_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), PREFS_DIALOG)) + +typedef struct PrefsDialogPrivate PrefsDialogPrivate; + +typedef enum +{ + PREFS_PAGE_GENERAL, + PREFS_PAGE_APPEARANCE, + PREFS_PAGE_UI, + PREFS_PAGE_ADVANCED +} PrefsPageID; + +struct PrefsDialog +{ + GtkDialog parent; + PrefsDialogPrivate *priv; +}; + +struct PrefsDialogClass +{ + GtkDialogClass parent_class; +}; + +GType prefs_dialog_get_type (void); + +GtkDialog *prefs_dialog_new (void); + +void prefs_dialog_show_page (PrefsDialog *pd, + PrefsPageID id); + +#endif diff --git a/src/session.c b/src/session.c new file mode 100644 index 000000000..920b49df9 --- /dev/null +++ b/src/session.c @@ -0,0 +1,690 @@ +/* + * Copyright (C) 2002 Jorn Baayen + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include "session.h" +#include "ephy-shell.h" +#include "ephy-tab.h" +#include "ephy-window.h" +#include "ephy-prefs.h" +#include "ephy-string.h" +#include "ephy-file-helpers.h" +#include "eel-gconf-extensions.h" + +#include <libgnome/gnome-i18n.h> +#include <string.h> +#include <gtk/gtkdialog.h> +#include <gtk/gtkimage.h> +#include <gtk/gtklabel.h> +#include <gtk/gtkstock.h> +#include <gtk/gtkhbox.h> +#include <gtk/gtkvbox.h> +#include <libxml/parser.h> +#include <libxml/tree.h> +#include <libxml/xmlmemory.h> +#include <libgnomevfs/gnome-vfs-ops.h> +#include <libgnomeui/gnome-client.h> + +enum +{ + RESTORE_TYPE_PROP +}; + +enum +{ + RESTORE_SESSION, + RESTORE_AS_BOOKMARKS, + DISCARD_SESSION +}; + +static void session_class_init (SessionClass *klass); +static void session_init (Session *t); +static void session_finalize (GObject *object); +static void session_dispose (GObject *object); + +static GObjectClass *parent_class = NULL; + +struct SessionPrivate +{ + GList *windows; + gboolean dont_remove_crashed; +}; + +enum +{ + NEW_WINDOW, + CLOSE_WINDOW, + LAST_SIGNAL +}; + +static guint session_signals[LAST_SIGNAL] = { 0 }; + +GType +session_get_type (void) +{ + static GType session_type = 0; + + if (session_type == 0) + { + static const GTypeInfo our_info = + { + sizeof (SessionClass), + NULL, /* base_init */ + NULL, /* base_finalize */ + (GClassInitFunc) session_class_init, + NULL, + NULL, /* class_data */ + sizeof (Session), + 0, /* n_preallocs */ + (GInstanceInitFunc) session_init + }; + + session_type = g_type_register_static (G_TYPE_OBJECT, + "Session", + &our_info, 0); + } + + return session_type; + +} + +static void +session_class_init (SessionClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + object_class->finalize = session_finalize; + object_class->dispose = session_dispose; + + session_signals[NEW_WINDOW] = + g_signal_new ("new_window", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_FIRST, + G_STRUCT_OFFSET (SessionClass, new_window), + NULL, NULL, + g_cclosure_marshal_VOID__OBJECT, + G_TYPE_NONE, + 1, + G_TYPE_OBJECT); + + session_signals[CLOSE_WINDOW] = + g_signal_new ("close_window", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_FIRST, + G_STRUCT_OFFSET (SessionClass, close_window), + NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, + 0); +} + +static char * +get_session_filename (const char *filename) +{ + char *save_to; + + g_return_val_if_fail (filename != NULL, NULL); + + if (strcmp (filename, SESSION_CRASHED) == 0) + { + save_to = g_build_filename (ephy_dot_dir (), + "session_crashed.xml", + NULL); + } + else if (strcmp (filename, SESSION_GNOME) == 0) + { + char *tmp; + + save_to = g_build_filename (ephy_dot_dir (), + "session_gnome-XXXXXX", + NULL); + tmp = ephy_file_tmp_filename (save_to, "xml"); + g_free (save_to); + save_to = tmp; + } + else + { + save_to = g_strdup (filename); + } + + return save_to; +} + +static void +do_session_resume (Session *session) +{ + const char *crashed_session; + + crashed_session = get_session_filename (SESSION_CRASHED); + session_load (session, crashed_session); +} + +static void +crashed_resume_dialog (Session *session) +{ + GtkWidget *dialog; + GtkWidget *label; + GtkWidget *vbox; + GtkWidget *hbox; + GtkWidget *image; + + dialog = gtk_dialog_new_with_buttons + (_("Crash Recovery"), NULL, + GTK_DIALOG_NO_SEPARATOR, + GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, + _("_Recover"), GTK_RESPONSE_OK, + NULL); + gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE); + gtk_container_set_border_width (GTK_CONTAINER (dialog), 6); + gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), 12); + + hbox = gtk_hbox_new (FALSE, 6); + gtk_widget_show (hbox); + gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, + TRUE, TRUE, 0); + + image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, + GTK_ICON_SIZE_DIALOG); + gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0); + gtk_widget_show (image); + gtk_box_pack_start (GTK_BOX (hbox), image, + TRUE, TRUE, 0); + + vbox = gtk_vbox_new (FALSE, 6); + gtk_widget_show (vbox); + gtk_box_pack_start (GTK_BOX (hbox), vbox, + TRUE, TRUE, 0); + + label = gtk_label_new (NULL); + gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); + gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); + gtk_widget_show (label); + gtk_label_set_markup (GTK_LABEL (label), + _("<b>Epiphany appears to have crashed or been killed the last time it was run.</b>")); + gtk_box_pack_start (GTK_BOX (vbox), label, + TRUE, TRUE, 0); + + label = gtk_label_new (_("You can recover the opened tabs and windows.")); + gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); + gtk_widget_show (label); + gtk_box_pack_start (GTK_BOX (vbox), label, + TRUE, TRUE, 0); + + if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK) + { + do_session_resume (session); + } + + gtk_widget_destroy (dialog); +} + +/** + * session_autoresume: + * @session: a #Session + * + * Resume a crashed session when necessary (interactive) + * + * Return value: return false if no window has been opened + **/ +gboolean +session_autoresume (Session *session) +{ + char *saved_session; + gboolean loaded = FALSE; + + saved_session = get_session_filename (SESSION_CRASHED); + + if (g_file_test (saved_session, G_FILE_TEST_EXISTS)) + { + crashed_resume_dialog (session); + loaded = TRUE; + } + + g_free (saved_session); + + /* return false if no window has been opened */ + return (session->priv->windows != NULL); +} + +static void +create_session_directory (void) +{ + char *dir; + + dir = g_build_filename (ephy_dot_dir (), + "/sessions", + NULL); + + if (!g_file_test (dir, G_FILE_TEST_EXISTS)) + { + if (mkdir (dir, 488) != 0) + { + g_error ("couldn't make %s' directory", dir); + } + } + + g_free (dir); +} + +static gboolean +save_yourself_cb (GnomeClient *client, + gint phase, + GnomeSaveStyle save_style, + gboolean shutdown, + GnomeInteractStyle interact_style, + gboolean fast, + Session *session) +{ + char *argv[] = { "ephy", "--load-session", NULL }; + char *discard_argv[] = { "rm", "-r", NULL }; + + argv[2] = get_session_filename (SESSION_GNOME); + gnome_client_set_restart_command + (client, 3, argv); + + discard_argv[2] = argv[2]; + gnome_client_set_discard_command (client, 3, + discard_argv); + + session_save (session, argv[2]); + + g_free (argv[2]); + + return TRUE; +} + +static void +session_die_cb (GnomeClient* client, + Session *session) +{ + session_close (session); +} + +static void +gnome_session_init (Session *session) +{ + GnomeClient *client; + + client = gnome_master_client (); + + g_signal_connect (G_OBJECT (client), + "save_yourself", + G_CALLBACK (save_yourself_cb), + session); + + g_signal_connect (G_OBJECT (client), + "die", + G_CALLBACK (session_die_cb), + session); +} + +static void +session_init (Session *session) +{ + session->priv = g_new0 (SessionPrivate, 1); + session->priv->windows = NULL; + session->priv->dont_remove_crashed = FALSE; + + create_session_directory (); + + gnome_session_init (session); +} + +/* + * session_close: + * @session: a #Session + * + * Close the session and all the owned windows + **/ +void +session_close (Session *session) +{ + GList *l; + + /* close all windows */ + l = g_list_copy (session->priv->windows); + for (; l != NULL; l = l->next) + { + EphyWindow *window = EPHY_WINDOW(l->data); + gtk_widget_destroy (GTK_WIDGET(window)); + } +} + +static void +session_delete (Session *session, + const char *filename) +{ + char *save_to; + + save_to = get_session_filename (filename); + + gnome_vfs_unlink (save_to); + + g_free (save_to); +} + +static void +session_dispose (GObject *object) +{ + Session *session = SESSION(object); + + if (!session->priv->dont_remove_crashed) + { + session_delete (session, SESSION_CRASHED); + } +} + +static void +session_finalize (GObject *object) +{ + Session *t; + + g_return_if_fail (object != NULL); + g_return_if_fail (IS_SESSION (object)); + + t = SESSION (object); + + g_return_if_fail (t->priv != NULL); + + g_list_free (t->priv->windows); + + g_free (t->priv); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +/** + * session_new: + * + * Create a #Session. A session hold the information + * about the windows currently opened and is able to persist + * and restore his status. + **/ +Session * +session_new (void) +{ + Session *t; + + t = SESSION (g_object_new (SESSION_TYPE, NULL)); + + g_return_val_if_fail (t->priv != NULL, NULL); + + return t; +} + +static void +save_tab (EphyWindow *window, + EphyTab *tab, + xmlDocPtr doc, + xmlNodePtr window_node) +{ + EmbedChromeMask chrome; + const char *location; + const char *title; + xmlNodePtr embed_node; + + chrome = ephy_window_get_chrome (window); + + /* skip if it's a XUL dialog */ + if (chrome & EMBED_CHROME_OPENASCHROME) return; + + /* make a new XML node */ + embed_node = xmlNewDocNode (doc, NULL, + "embed", NULL); + + /* store title in the node */ + title = ephy_tab_get_title (tab); + xmlSetProp (embed_node, "title", title); + + /* otherwise, use the actual location. */ + location = ephy_tab_get_location (tab); + xmlSetProp (embed_node, "url", location); + + /* insert node into the tree */ + xmlAddChild (window_node, embed_node); +} + +/* + * session_save: + * @session: a #Session + * @filename: path of the xml file where the session is saved. + * + * Save the session on disk. Keep information about window size, + * opened urls ... + **/ +void +session_save (Session *session, + const char *filename) +{ + GList *w; + xmlNodePtr root_node; + xmlNodePtr window_node; + xmlDocPtr doc; + gchar buffer[32]; + char *save_to; + + save_to = get_session_filename (filename); + + doc = xmlNewDoc ("1.0"); + + /* create and set the root node for the session */ + root_node = xmlNewDocNode (doc, NULL, "session", NULL); + xmlDocSetRootElement (doc, root_node); + + w = session_get_windows (session); + + /* iterate through all the windows */ + for (; w != NULL; w = w->next) + { + const GList *tabs; + int x = 0, y = 0, width = 0, height = 0; + EphyWindow *window = EPHY_WINDOW(w->data); + GtkWidget *wmain; + + tabs = ephy_window_get_tabs (window); + g_return_if_fail (tabs != NULL); + + /* make a new XML node */ + window_node = xmlNewDocNode (doc, NULL, "window", NULL); + + /* get window geometry */ + wmain = GTK_WIDGET (window); + gtk_window_get_size (GTK_WINDOW(wmain), &width, &height); + gtk_window_get_position (GTK_WINDOW(wmain), &x, &y); + + /* set window properties */ + snprintf(buffer, 32, "%d", x); + xmlSetProp (window_node, "x", buffer); + snprintf(buffer, 32, "%d", y); + + xmlSetProp (window_node, "y", buffer); + snprintf(buffer, 32, "%d", width); + xmlSetProp (window_node, "width", buffer); + snprintf(buffer, 32, "%d", height); + xmlSetProp (window_node, "height", buffer); + + for (; tabs != NULL; tabs = tabs->next) + { + EphyTab *tab = EPHY_TAB(tabs->data); + save_tab (window, tab, doc, window_node); + } + + xmlAddChild (root_node, window_node); + } + + /* save it all out to disk */ + xmlSaveFile (save_to, doc); + xmlFreeDoc (doc); + + g_free (save_to); +} + +static void +parse_embed (xmlNodePtr child, EphyWindow *window) +{ + EphyTab *tab; + EphyEmbed *embed; + + while (child != NULL) + { + if (strcmp (child->name, "embed") == 0) + { + char *url; + char *title; + + g_return_if_fail (window != NULL); + + url = xmlGetProp (child, "url"); + title = xmlGetProp (child, "title"); + + tab = ephy_tab_new (); + embed = ephy_tab_get_embed (tab); + + gtk_widget_show (GTK_WIDGET(embed)); + + ephy_window_add_tab (window, tab, FALSE); + + ephy_embed_load_url (embed, url); + + xmlFree (url); + xmlFree (title); + } + + child = child->next; + } +} + +/* + * session_load: + * @session: a #Session + * @filename: the path of the source file + * + * Load a session from disk, restoring the windows and their state + **/ +void +session_load (Session *session, + const char *filename) +{ + xmlDocPtr doc; + xmlNodePtr child; + GtkWidget *wmain; + EphyWindow *window; + char *save_to; + + save_to = get_session_filename (filename); + + doc = xmlParseFile (save_to); + + child = xmlDocGetRootElement (doc); + + /* skip the session node */ + child = child->children; + + while (child != NULL) + { + if (strcmp (child->name, "window") == 0) + { + gint x = 0, y = 0, width = 0, height = 0; + xmlChar *tmp; + + tmp = xmlGetProp (child, "x"); + ephy_str_to_int (tmp, &x); + xmlFree (tmp); + tmp = xmlGetProp (child, "y"); + ephy_str_to_int (tmp, &y); + xmlFree (tmp); + tmp = xmlGetProp (child, "width"); + ephy_str_to_int (tmp, &width); + xmlFree (tmp); + tmp = xmlGetProp (child, "height"); + ephy_str_to_int (tmp, &height); + xmlFree (tmp); + + window = ephy_window_new (); + wmain = GTK_WIDGET (window); + gtk_widget_show (GTK_WIDGET(window)); + + gtk_window_move (GTK_WINDOW(wmain), x, y); + gtk_window_set_default_size (GTK_WINDOW (wmain), + width, height); + + parse_embed (child->children, window); + } + + child = child->next; + } + + xmlFreeDoc (doc); + + g_free (save_to); +} + +GList * +session_get_windows (Session *session) +{ + g_return_val_if_fail (IS_SESSION (session), NULL); + + return session->priv->windows; +} + +/** + * session_add_window: + * @session: a #Session + * @window: a #EphyWindow + * + * Add a window to the session. #EphyWindow take care of adding + * itself to session. + **/ +void +session_add_window (Session *session, + EphyWindow *window) +{ + session->priv->windows = g_list_append (session->priv->windows, window); + + g_signal_emit (G_OBJECT (session), + session_signals[NEW_WINDOW], + 0, window); +} + +/** + * session_remove_window: + * @session: a #Session + * @window: a #EphyWindow + * + * Remove a window from the session. #EphyWindow take care of removing + * itself to session. + **/ +void +session_remove_window (Session *session, + EphyWindow *window) +{ + g_signal_emit (G_OBJECT (session), + session_signals[CLOSE_WINDOW], + 0); + + session->priv->windows = g_list_remove (session->priv->windows, window); + + /* autodestroy of the session, necessay to avoid + * conflicts with the nautilus view */ + if (session->priv->windows == NULL) + { + g_object_unref (session); + } +} + diff --git a/src/session.h b/src/session.h new file mode 100644 index 000000000..e2ac6b9b2 --- /dev/null +++ b/src/session.h @@ -0,0 +1,84 @@ +/* + * Copyright (C) 2002 Jorn Baayen + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef SESSION_H +#define SESSION_H + +#define SESSION_CRASHED "type:session_crashed" +#define SESSION_GNOME "type:session_gnome" + +#include "ephy-window.h" + +G_BEGIN_DECLS + +#include <glib-object.h> +#include <glib.h> + +typedef struct Session Session; +typedef struct SessionClass SessionClass; + +#define SESSION_TYPE (session_get_type ()) +#define SESSION(obj) (GTK_CHECK_CAST ((obj), SESSION_TYPE, Session)) +#define SESSION_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), SESSION, SessionClass)) +#define IS_SESSION(obj) (GTK_CHECK_TYPE ((obj), SESSION_TYPE)) +#define IS_SESSION_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), SESSION)) + +typedef struct SessionPrivate SessionPrivate; + +struct Session +{ + GObject parent; + SessionPrivate *priv; +}; + +struct SessionClass +{ + GObjectClass parent_class; + + void ( *new_window) (Session *session, + EphyWindow *window); + void ( *close_window) (Session *session); +}; + +GType session_get_type (void); + +Session *session_new (void); + +void session_close (Session *session); + +void session_load (Session *session, + const char *filename); + +void session_save (Session *session, + const char *filename); + +gboolean session_autoresume (Session *session); + +GList *session_get_windows (Session *session); + +void session_add_window (Session *session, + EphyWindow *window); + +void session_remove_window (Session *session, + EphyWindow *window); + +EphyWindow *session_get_active_window (Session *session); + +G_END_DECLS + +#endif diff --git a/src/statusbar.c b/src/statusbar.c new file mode 100755 index 000000000..8ac84cfb9 --- /dev/null +++ b/src/statusbar.c @@ -0,0 +1,321 @@ +/* + * Copyright (C) 2002 Jorn Baayen + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include "statusbar.h" +#include "ephy-stock-icons.h" +#include "ephy-bonobo-extensions.h" + +#include <string.h> +#include <time.h> +#include <gtk/gtkprogressbar.h> +#include <gtk/gtkeventbox.h> +#include <gtk/gtkimage.h> +#include <gtk/gtkframe.h> +#include <gtk/gtktooltips.h> +#include <bonobo/bonobo-window.h> +#include <bonobo/bonobo-control.h> + +static void statusbar_class_init (StatusbarClass *klass); +static void statusbar_init (Statusbar *t); +static void statusbar_finalize (GObject *object); +static void +statusbar_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec); +static void +statusbar_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec); +static void +statusbar_set_window (Statusbar *t, EphyWindow *window); + +enum +{ + PROP_0, + PROP_EPHY_WINDOW +}; + +static GObjectClass *parent_class = NULL; + +struct StatusbarPrivate +{ + EphyWindow *window; + BonoboUIComponent *ui_component; + GtkWidget *security_icon; + GtkWidget *progress; + GtkTooltips *tooltips; + GtkWidget *security_evbox; + gboolean visibility; +}; + +GType +statusbar_get_type (void) +{ + static GType statusbar_type = 0; + + if (statusbar_type == 0) + { + static const GTypeInfo our_info = + { + sizeof (StatusbarClass), + NULL, /* base_init */ + NULL, /* base_finalize */ + (GClassInitFunc) statusbar_class_init, + NULL, + NULL, /* class_data */ + sizeof (Statusbar), + 0, /* n_preallocs */ + (GInstanceInitFunc) statusbar_init + }; + + statusbar_type = g_type_register_static (G_TYPE_OBJECT, + "Statusbar", + &our_info, 0); + } + + return statusbar_type; + +} + +static void +statusbar_class_init (StatusbarClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + object_class->finalize = statusbar_finalize; + object_class->set_property = statusbar_set_property; + object_class->get_property = statusbar_get_property; + + g_object_class_install_property (object_class, + PROP_EPHY_WINDOW, + g_param_spec_object ("EphyWindow", + "EphyWindow", + "Parent window", + EPHY_WINDOW_TYPE, + G_PARAM_READWRITE)); +} + +static void +statusbar_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + Statusbar *s = STATUSBAR (object); + + switch (prop_id) + { + case PROP_EPHY_WINDOW: + statusbar_set_window (s, g_value_get_object (value)); + break; + } +} + +static void +statusbar_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + Statusbar *s = STATUSBAR (object); + + switch (prop_id) + { + case PROP_EPHY_WINDOW: + g_value_set_object (value, s->priv->window); + break; + } +} + +static void +create_statusbar_security_icon (Statusbar *s) +{ + GtkWidget *security_frame; + BonoboControl *control; + + security_frame = gtk_frame_new (NULL); + gtk_frame_set_shadow_type (GTK_FRAME (security_frame), + GTK_SHADOW_IN); + + s->priv->security_icon = gtk_image_new (); + s->priv->security_evbox = gtk_event_box_new (); + gtk_container_add (GTK_CONTAINER (security_frame), + GTK_WIDGET (s->priv->security_evbox)); + gtk_container_add (GTK_CONTAINER (s->priv->security_evbox), + GTK_WIDGET (s->priv->security_icon)); + /* + g_signal_connect (G_OBJECT (security_eventbox), + "button_release_event", + GTK_SIGNAL_FUNC + (security_icon_button_release_cb), t); + */ + + control = bonobo_control_new (security_frame); + bonobo_ui_component_object_set (s->priv->ui_component, + "/status/SecurityIconWrapper", + BONOBO_OBJREF (control), + NULL); + bonobo_object_unref (control); + + statusbar_set_security_state (s, FALSE, NULL); + + gtk_widget_show_all (security_frame); +} + +static void +create_statusbar_progress (Statusbar *s) +{ + BonoboControl *control; + + s->priv->progress = gtk_progress_bar_new (); + + control = bonobo_control_new (s->priv->progress); + bonobo_ui_component_object_set (s->priv->ui_component, + "/status/ProgressWrapper", + BONOBO_OBJREF (control), + NULL); + + gtk_widget_show_all (s->priv->progress); +} + +static void +statusbar_set_window (Statusbar *s, EphyWindow *window) +{ + g_return_if_fail (s->priv->window == NULL); + + s->priv->window = window; + s->priv->ui_component = BONOBO_UI_COMPONENT + (s->priv->window->ui_component); + + create_statusbar_progress (s); + create_statusbar_security_icon (s); +} + +static void +statusbar_init (Statusbar *t) +{ + t->priv = g_new0 (StatusbarPrivate, 1); + t->priv->visibility = TRUE; + + t->priv->tooltips = gtk_tooltips_new (); +} + +static void +statusbar_finalize (GObject *object) +{ + Statusbar *t; + + g_return_if_fail (object != NULL); + g_return_if_fail (IS_STATUSBAR (object)); + + t = STATUSBAR (object); + + g_return_if_fail (t->priv != NULL); + + gtk_object_destroy (GTK_OBJECT (t->priv->tooltips)); + + g_free (t->priv); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +Statusbar * +statusbar_new (EphyWindow *window) +{ + Statusbar *t; + + t = STATUSBAR (g_object_new (STATUSBAR_TYPE, + "EphyWindow", window, + NULL)); + + g_return_val_if_fail (t->priv != NULL, NULL); + + return t; +} + +void +statusbar_set_visibility (Statusbar *t, + gboolean visibility) +{ + if (visibility == t->priv->visibility) return; + + t->priv->visibility = visibility; + + ephy_bonobo_set_hidden (BONOBO_UI_COMPONENT(t->priv->ui_component), + "/status", + !visibility); +} + +void +statusbar_set_security_state (Statusbar *t, + gboolean state, + const char *tooltip) +{ + const char *stock; + + stock = state ? EPHY_STOCK_SECURE : EPHY_STOCK_UNSECURE; + + gtk_image_set_from_stock (GTK_IMAGE (t->priv->security_icon), stock, + GTK_ICON_SIZE_MENU); + + gtk_tooltips_set_tip (t->priv->tooltips, t->priv->security_evbox, + tooltip, NULL); +} + +void +statusbar_set_progress (Statusbar *t, + int progress) +{ + if (progress == -1) + { + gtk_progress_bar_pulse (GTK_PROGRESS_BAR(t->priv->progress)); + } + else + { + float tmp; + tmp = (float)(progress) / 100; + gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR(t->priv->progress), + tmp); + } +} + +void +statusbar_set_message (Statusbar *s, + const char *message) +{ + g_return_if_fail (BONOBO_IS_UI_COMPONENT(s->priv->ui_component)); + g_return_if_fail (message != NULL); + + /* Bonobo doesnt like 0 length messages */ + if (g_utf8_strlen (message, -1) == 0) + { + message = " "; + } + + if (bonobo_ui_component_get_container (s->priv->ui_component)) /* should not do this here... */ + { + bonobo_ui_component_set_status (s->priv->ui_component, + message, + NULL); + } +} + diff --git a/src/statusbar.h b/src/statusbar.h new file mode 100644 index 000000000..590b89394 --- /dev/null +++ b/src/statusbar.h @@ -0,0 +1,70 @@ +/* + * Copyright (C) 2002 Jorn Baayen + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef STATUSBAR_H +#define STATUSBAR_H + +#include "ephy-window.h" + +G_BEGIN_DECLS + +#include <glib-object.h> +#include <glib.h> + +typedef struct Statusbar Statusbar; +typedef struct StatusbarClass StatusbarClass; + +#define STATUSBAR_TYPE (statusbar_get_type ()) +#define STATUSBAR(obj) (GTK_CHECK_CAST ((obj), STATUSBAR_TYPE, Statusbar)) +#define STATUSBAR_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), STATUSBAR, StatusbarClass)) +#define IS_STATUSBAR(obj) (GTK_CHECK_TYPE ((obj), STATUSBAR_TYPE)) +#define IS_STATUSBAR_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), STATUSBAR)) + +typedef struct StatusbarPrivate StatusbarPrivate; + +struct Statusbar +{ + GObject parent; + StatusbarPrivate *priv; +}; + +struct StatusbarClass +{ + GObjectClass parent_class; +}; + +GType statusbar_get_type (void); + +Statusbar *statusbar_new (EphyWindow *window); + +void statusbar_set_visibility (Statusbar *s, + gboolean visibility); + +void statusbar_set_security_state (Statusbar *s, + gboolean state, + const char *tooltip); + +void statusbar_set_progress (Statusbar *s, + int progress); + +void statusbar_set_message (Statusbar *s, + const gchar *message); + +G_END_DECLS + +#endif diff --git a/src/toolbar.c b/src/toolbar.c new file mode 100755 index 000000000..4bff4615e --- /dev/null +++ b/src/toolbar.c @@ -0,0 +1,982 @@ +/* + * Copyright (C) 2000 Marco Pesenti Gritti + * (C) 2001, 2002 Jorn Baayen + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +//#define DEBUG_MSG(x) g_print x +#define DEBUG_MSG(x) +#define NOT_IMPLEMENTED g_warning ("not implemented: " G_STRLOC); + +#include "toolbar.h" +#include "ephy-spinner.h" +#include "ephy-window.h" +#include "ephy-bonobo-extensions.h" +#include "ephy-string.h" +#include "ephy-gui.h" +#include "ephy-location-entry.h" +#include "ephy-shell.h" +#include "ephy-embed-favicon.h" +#include "ephy-dnd.h" +#include "ephy-toolbar-bonobo-view.h" +#include "ephy-prefs.h" +#include "eel-gconf-extensions.h" + +#include <string.h> +#include <bonobo/bonobo-i18n.h> +#include <bonobo/bonobo-window.h> +#include <bonobo/bonobo-control.h> +#include <bonobo/bonobo-ui-toolbar-button-item.h> +#include <bonobo/bonobo-property-bag.h> +#include <gtk/gtkentry.h> +#include <gtk/gtkmenu.h> + +#define DEFAULT_TOOLBAR_SETUP \ + "back=std_toolitem(item=back);" \ + "back_history=navigation_history(direction=back);" \ + "up=std_toolitem(item=up);" \ + "up_history=navigation_history(direction=up);" \ + "forward=std_toolitem(item=forward);" \ + "forward_history=navigation_history(direction=forward);" \ + "stop=std_toolitem(item=stop);" \ + "reload=std_toolitem(item=reload);" \ + "home=std_toolitem(item=home);" \ + "favicon=favicon;" \ + "location=location;" \ + "zoom=zoom;" \ + "spinner=spinner;" + +#define ZOOM_DELAY 50 + +static void toolbar_class_init (ToolbarClass *klass); +static void toolbar_init (Toolbar *t); +static void toolbar_finalize (GObject *object); +static void toolbar_set_window (Toolbar *t, EphyWindow *window); +static void toolbar_get_widgets (Toolbar *t); +static void toolbar_changed_cb (EphyToolbar *gt, Toolbar *t); +static void +toolbar_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec); +static void +toolbar_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec); + + +enum +{ + PROP_0, + PROP_EPHY_WINDOW +}; + +enum +{ + TOOLBAR_ITEM_STYLE_PROP, + TOOLBAR_ITEM_ORIENTATION_PROP, + TOOLBAR_ITEM_PRIORITY_PROP +}; + +static GObjectClass *parent_class = NULL; + +struct ToolbarPrivate +{ + EphyWindow *window; + BonoboUIComponent *ui_component; + EphyTbBonoboView *bview; + + GtkWidget *spinner; + gboolean visibility; + /* This field is unused... what is it? + GdkPixbufAnimation *animation; + */ + GtkWidget *back_button; + GtkWidget *forward_button; + GtkWidget *up_button; + GtkWidget *location_entry; + GtkTooltips *tooltips; + GtkWidget *favicon; + GtkWidget *favicon_ebox; + GtkWidget *zoom_spinbutton; + guint zoom_timeout_id; + gboolean zoom_lock; +}; + +GType +toolbar_get_type (void) +{ + static GType toolbar_type = 0; + + if (toolbar_type == 0) + { + static const GTypeInfo our_info = + { + sizeof (ToolbarClass), + NULL, /* base_init */ + NULL, /* base_finalize */ + (GClassInitFunc) toolbar_class_init, + NULL, + NULL, /* class_data */ + sizeof (Toolbar), + 0, /* n_preallocs */ + (GInstanceInitFunc) toolbar_init + }; + + toolbar_type = g_type_register_static (EPHY_TYPE_TOOLBAR, + "Toolbar", + &our_info, 0); + } + + return toolbar_type; + +} + +static void +toolbar_class_init (ToolbarClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + object_class->finalize = toolbar_finalize; + + object_class->set_property = toolbar_set_property; + object_class->get_property = toolbar_get_property; + + g_object_class_install_property (object_class, + PROP_EPHY_WINDOW, + g_param_spec_object ("EphyWindow", + "EphyWindow", + "Parent window", + EPHY_WINDOW_TYPE, + G_PARAM_READWRITE)); +} + +static void +toolbar_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + Toolbar *t = TOOLBAR (object); + + switch (prop_id) + { + case PROP_EPHY_WINDOW: + toolbar_set_window (t, g_value_get_object (value)); + break; + } +} + +static void +toolbar_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + Toolbar *t = TOOLBAR (object); + + switch (prop_id) + { + case PROP_EPHY_WINDOW: + g_value_set_object (value, t->priv->window); + break; + } +} + +static GtkWidget * +new_history_menu_item (gint num, gchar *origtext, gboolean lettersok, + GtkWidget *menu, const GdkPixbuf *ico) +{ + GtkWidget *item = gtk_image_menu_item_new (); + GtkWidget *hb = gtk_hbox_new (FALSE, 0); + GtkWidget *label = gtk_label_new (origtext); + + gtk_box_pack_start (GTK_BOX (hb), label, FALSE, FALSE, 0); + gtk_container_add (GTK_CONTAINER (item), hb); + + gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), + gtk_image_new_from_pixbuf ((GdkPixbuf *) ico)); + + gtk_widget_show_all (item); + + return item; +} + +static void +activate_back_or_forward_menu_item_cb (GtkWidget *menu, EphyWindow *window) +{ + EphyEmbed *embed; + int go_nth; + + embed = ephy_window_get_active_embed (window); + g_return_if_fail (embed != NULL); + + go_nth = (int)g_object_get_data (G_OBJECT(menu), "go_nth"); + + ephy_embed_shistory_go_nth (embed, go_nth); +} + +static void +activate_up_menu_item_cb (GtkWidget *menu, EphyWindow *window) +{ + EphyEmbed *embed; + int go_nth; + GSList *l; + gchar *url; + + embed = ephy_window_get_active_embed (window); + g_return_if_fail (embed != NULL); + + go_nth = (int)g_object_get_data (G_OBJECT(menu), "go_nth"); + + ephy_embed_get_go_up_list (embed, &l); + + url = g_slist_nth_data (l, go_nth); + if (url) + { + ephy_embed_load_url (embed, url); + } + + g_slist_foreach (l, (GFunc) g_free, NULL); + g_slist_free (l); +} + +static gboolean +back_or_forward_button_pressed_callback (GtkWidget *widget, + GdkEventButton *event, + gpointer *user_data) +{ + Toolbar *t; + GtkWidget *menu; + int pos, count; + EphyEmbed *embed; + int start, end, accell_count = 0; + + g_return_val_if_fail (GTK_IS_BUTTON (widget), FALSE); + + t = TOOLBAR (user_data); + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE); + + embed = ephy_window_get_active_embed (t->priv->window); + g_return_val_if_fail (embed != NULL, FALSE); + + ephy_embed_shistory_get_pos (embed, &pos); + ephy_embed_shistory_count (embed, &count); + + if (count == 0) return FALSE; + + if (widget == t->priv->back_button) + { + start = pos - 1; + end = -1; + } + else + { + start = pos + 1; + end = count; + } + + menu = gtk_menu_new (); + + while (start != end) + { + char *title, *url; + GtkWidget *item; + ephy_embed_shistory_get_nth (embed, start, FALSE, + &url, &title); + item = new_history_menu_item (accell_count, url, TRUE, + menu, NULL); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + g_object_set_data (G_OBJECT(item), "go_nth", GINT_TO_POINTER (start)); + g_signal_connect (item, "activate", + G_CALLBACK (activate_back_or_forward_menu_item_cb), + t->priv->window); + gtk_widget_show_all (item); + + g_free (url); + g_free (title); + + accell_count++; + if (start < end) start++; + else start--; + } + + + gnome_popup_menu_do_popup_modal (menu, + ephy_gui_menu_position_under_widget, widget, event, widget, widget); + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE); + + return TRUE; +} + +static gboolean +up_button_pressed_callback (GtkWidget *widget, + GdkEventButton *event, + gpointer *user_data) +{ + Toolbar *t; + GtkWidget *menu; + EphyEmbed *embed; + int accell_count = 0; + GSList *l; + GSList *li; + + g_return_val_if_fail (GTK_IS_BUTTON (widget), FALSE); + + t = TOOLBAR (user_data); + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE); + + embed = ephy_window_get_active_embed (t->priv->window); + g_return_val_if_fail (embed != NULL, FALSE); + + ephy_embed_get_go_up_list (embed, &l); + + if (l == NULL) return FALSE; + + menu = gtk_menu_new (); + + for (li = l; li; li = li->next) + { + char *url = li->data; + GtkWidget *item; + item = new_history_menu_item (accell_count, url, TRUE, + menu, NULL); + gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); + g_object_set_data (G_OBJECT(item), "go_nth", GINT_TO_POINTER (accell_count)); + g_signal_connect (item, "activate", + G_CALLBACK (activate_up_menu_item_cb), + t->priv->window); + gtk_widget_show_all (item); + + accell_count++; + } + + g_slist_foreach (l, (GFunc) g_free, NULL); + g_slist_free (l); + + gnome_popup_menu_do_popup_modal (menu, + ephy_gui_menu_position_under_widget, widget, event, widget, widget); + + gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), FALSE); + + return TRUE; +} + +static gboolean +back_or_forward_key_pressed_callback (GtkWidget *widget, + GdkEventKey *event, + gpointer *user_data) +{ + if (event->keyval == GDK_space || + event->keyval == GDK_KP_Space || + event->keyval == GDK_Return || + event->keyval == GDK_KP_Enter) + { + back_or_forward_button_pressed_callback (widget, NULL, user_data); + } + + return FALSE; +} + +static gboolean +up_key_pressed_callback (GtkWidget *widget, + GdkEventKey *event, + gpointer *user_data) +{ + if (event->keyval == GDK_space || + event->keyval == GDK_KP_Space || + event->keyval == GDK_Return || + event->keyval == GDK_KP_Enter) + { + up_button_pressed_callback (widget, NULL, user_data); + } + + return FALSE; +} + +static void +toolbar_setup_navigation_button (Toolbar *t, GtkWidget *w, const char *tooltip) +{ + g_signal_connect_object (w, "key_press_event", + G_CALLBACK (back_or_forward_key_pressed_callback), + t, 0); + g_signal_connect_object (w, "button_press_event", + G_CALLBACK (back_or_forward_button_pressed_callback), + t, 0); + + gtk_tooltips_set_tip (t->priv->tooltips, w, tooltip, NULL); +} + +static void +toolbar_setup_up_button (Toolbar *t, GtkWidget *w, const char *tooltip) +{ + g_signal_connect_object (w, "key_press_event", + G_CALLBACK (up_key_pressed_callback), + t, 0); + g_signal_connect_object (w, "button_press_event", + G_CALLBACK (up_button_pressed_callback), + t, 0); + + gtk_tooltips_set_tip (t->priv->tooltips, w, tooltip, NULL); +} + + +static void +toolbar_location_url_activate_cb (EphyLocationEntry *entry, + const char *content, + const char *target, + EphyWindow *window) +{ + EphyBookmarks *bookmarks; + + bookmarks = ephy_shell_get_bookmarks (ephy_shell); + + if (!content) + { + ephy_window_load_url (window, target); + } + else + { + char *url; + + url = ephy_bookmarks_solve_smart_url + (bookmarks, target, content); + g_return_if_fail (url != NULL); + ephy_window_load_url (window, url); + g_free (url); + } +} + +static void +each_url_get_data_binder (EphyDragEachSelectedItemDataGet iteratee, + gpointer iterator_context, gpointer data) +{ + const char *location; + EphyTab *tab; + EphyWindow *window = EPHY_WINDOW(iterator_context); + + tab = ephy_window_get_active_tab (window); + location = ephy_tab_get_location (tab); + + iteratee (location, -1, -1, -1, -1, data); +} + +static void +favicon_drag_data_get_cb (GtkWidget *widget, + GdkDragContext *context, + GtkSelectionData *selection_data, + guint info, + guint32 time, + EphyWindow *window) +{ + g_assert (widget != NULL); + g_return_if_fail (context != NULL); + + ephy_dnd_drag_data_get (widget, context, selection_data, + info, time, window, each_url_get_data_binder); +} + +static void +toolbar_setup_favicon_ebox (Toolbar *t, GtkWidget *w) +{ + ToolbarPrivate *p = t->priv; + + g_return_if_fail (w == p->favicon_ebox); + + p->favicon = g_object_ref (ephy_embed_favicon_new + (ephy_window_get_active_embed (p->window))); + gtk_container_add (GTK_CONTAINER (p->favicon_ebox), p->favicon); + gtk_container_set_border_width (GTK_CONTAINER (p->favicon_ebox), 2); + + ephy_dnd_url_drag_source_set (p->favicon_ebox); + + g_signal_connect (G_OBJECT (p->favicon_ebox), + "drag_data_get", + G_CALLBACK (favicon_drag_data_get_cb), + p->window); + gtk_widget_show_all (p->favicon_ebox); +} + +static gboolean +toolbar_zoom_timeout_cb (gpointer data) +{ + Toolbar *t = data; + gint zoom = toolbar_get_zoom (t); + + g_return_val_if_fail (IS_EPHY_WINDOW (t->priv->window), FALSE); + + ephy_window_set_zoom (t->priv->window, zoom); + + return FALSE; +} + +static void +toolbar_zoom_spinbutton_value_changed_cb (GtkSpinButton *sb, Toolbar *t) +{ + ToolbarPrivate *p = t->priv; + if (p->zoom_timeout_id != 0) + { + g_source_remove (p->zoom_timeout_id); + } + if (!p->zoom_lock) + { + p->zoom_timeout_id = g_timeout_add (ZOOM_DELAY, toolbar_zoom_timeout_cb, t); + } +} + +static void +toolbar_setup_zoom_spinbutton (Toolbar *t, GtkWidget *w) +{ + g_signal_connect (w, "value_changed", + G_CALLBACK (toolbar_zoom_spinbutton_value_changed_cb), t); + gtk_tooltips_set_tip (t->priv->tooltips, w, _("Zoom"), NULL); +} + +static void +toolbar_setup_location_entry (Toolbar *t, GtkWidget *w) +{ + EphyAutocompletion *ac = ephy_shell_get_autocompletion (ephy_shell); + EphyLocationEntry *e; + + g_return_if_fail (w == t->priv->location_entry); + g_return_if_fail (EPHY_IS_LOCATION_ENTRY (w)); + + e = EPHY_LOCATION_ENTRY (w); + ephy_location_entry_set_autocompletion (e, ac); + + g_signal_connect (e, "activated", + GTK_SIGNAL_FUNC(toolbar_location_url_activate_cb), + t->priv->window); +} + +static void +toolbar_setup_spinner (Toolbar *t, GtkWidget *w) +{ + ToolbarPrivate *p = t->priv; + GtkWidget *spinner; + + g_return_if_fail (w == p->spinner); + + /* build the spinner and insert it into the box */ + spinner = ephy_spinner_new (); + ephy_spinner_set_small_mode (EPHY_SPINNER (spinner), TRUE); + gtk_container_add (GTK_CONTAINER (p->spinner), spinner); + gtk_widget_show (spinner); + + /* don't care about the box anymore */ + g_object_unref (p->spinner); + p->spinner = g_object_ref (spinner); +} + + +static void +toolbar_set_window (Toolbar *t, EphyWindow *window) +{ + g_return_if_fail (t->priv->window == NULL); + + t->priv->window = window; + t->priv->ui_component = g_object_ref (t->priv->window->ui_component); + + ephy_tb_bonobo_view_set_path (t->priv->bview, t->priv->ui_component, "/Toolbar"); + + toolbar_get_widgets (t); +} + +static void +toolbar_get_widgets (Toolbar *t) +{ + ToolbarPrivate *p; + EphyToolbar *gt; + EphyTbItem *it; + + DEBUG_MSG (("in toolbar_get_widgets\n")); + + g_return_if_fail (IS_TOOLBAR (t)); + p = t->priv; + g_return_if_fail (IS_EPHY_WINDOW (p->window)); + g_return_if_fail (BONOBO_IS_UI_COMPONENT (p->ui_component)); + + /* release all the widgets */ + + if (p->back_button) + { + g_object_unref (p->back_button); + p->back_button = NULL; + } + + if (p->forward_button) + { + g_object_unref (p->forward_button); + p->forward_button = NULL; + } + + if (p->up_button) + { + g_object_unref (p->up_button); + p->up_button = NULL; + } + + if (p->favicon_ebox) + { + g_object_unref (p->favicon_ebox); + p->favicon_ebox = NULL; + } + + if (p->favicon) + { + g_object_unref (p->favicon); + p->favicon = NULL; + } + + if (p->location_entry) + { + g_object_unref (p->location_entry); + p->location_entry = NULL; + } + + if (p->spinner) + { + g_object_unref (p->spinner); + p->spinner = NULL; + } + + if (p->zoom_spinbutton) + { + g_object_unref (p->zoom_spinbutton); + p->zoom_spinbutton = NULL; + } + + gt = EPHY_TOOLBAR (t); + + it = ephy_toolbar_get_item_by_id (gt, "back_history"); + if (it) + { + p->back_button = ephy_tb_item_get_widget (it); + g_object_ref (p->back_button); + toolbar_setup_navigation_button (t, p->back_button, _("Go back a number of pages")); + + DEBUG_MSG ((" got a back_history button\n")); + } + + it = ephy_toolbar_get_item_by_id (gt, "forward_history"); + if (it) + { + p->forward_button = ephy_tb_item_get_widget (it); + g_object_ref (p->forward_button); + toolbar_setup_navigation_button (t, p->forward_button, _("Go forward a number of pages")); + + DEBUG_MSG ((" got a forward_history button\n")); + } + + it = ephy_toolbar_get_item_by_id (gt, "up_history"); + if (it) + { + p->up_button = ephy_tb_item_get_widget (it); + g_object_ref (p->up_button); + toolbar_setup_up_button (t, p->up_button, _("Go up a number of levels")); + + DEBUG_MSG ((" got a up_history button\n")); + } + + it = ephy_toolbar_get_item_by_id (gt, "location"); + if (it) + { + p->location_entry = ephy_tb_item_get_widget (it); + g_object_ref (p->location_entry); + toolbar_setup_location_entry (t, p->location_entry); + + DEBUG_MSG ((" got a location entry\n")); + } + + it = ephy_toolbar_get_item_by_id (gt, "favicon"); + if (it) + { + p->favicon_ebox = ephy_tb_item_get_widget (it); + g_object_ref (p->favicon_ebox); + toolbar_setup_favicon_ebox (t, p->favicon_ebox); + + DEBUG_MSG ((" got a favicon ebox\n")); + } + + it = ephy_toolbar_get_item_by_id (gt, "spinner"); + if (it) + { + p->spinner = ephy_tb_item_get_widget (it); + g_object_ref (p->spinner); + toolbar_setup_spinner (t, p->spinner); + + DEBUG_MSG ((" got a spinner\n")); + } + + it = ephy_toolbar_get_item_by_id (gt, "zoom"); + if (it) + { + p->zoom_spinbutton = ephy_tb_item_get_widget (it); + g_object_ref (p->zoom_spinbutton); + toolbar_setup_zoom_spinbutton (t, p->zoom_spinbutton); + + DEBUG_MSG ((" got a zoom control\n")); + } + + /* update the controls */ + ephy_window_update_all_controls (p->window); +} + +static void +toolbar_init (Toolbar *t) +{ + t->priv = g_new0 (ToolbarPrivate, 1); + + t->priv->window = NULL; + t->priv->ui_component = NULL; + t->priv->visibility = TRUE; + t->priv->tooltips = gtk_tooltips_new (); + g_object_ref (t->priv->tooltips); + gtk_object_sink (GTK_OBJECT (t->priv->tooltips)); + + if (!ephy_toolbar_listen_to_gconf (EPHY_TOOLBAR (t), CONF_TOOLBAR_SETUP)) + { + /* FIXME: make this a dialog? */ + g_warning ("An incorrect toolbar configuration has been found, resetting to the default"); + + /* this is to make sure we get a toolbar, even if the + setup is wrong or there is no schema */ + eel_gconf_set_string (CONF_TOOLBAR_SETUP, DEFAULT_TOOLBAR_SETUP); + } + + g_signal_connect (t, "changed", G_CALLBACK (toolbar_changed_cb), t); + + t->priv->bview = ephy_tb_bonobo_view_new (); + ephy_tb_bonobo_view_set_toolbar (t->priv->bview, EPHY_TOOLBAR (t)); +} + +static void +toolbar_changed_cb (EphyToolbar *gt, Toolbar *t) +{ + g_return_if_fail (gt == EPHY_TOOLBAR (t)); + + if (t->priv->window) + { + toolbar_get_widgets (t); + } +} + +static void +toolbar_finalize (GObject *object) +{ + Toolbar *t; + ToolbarPrivate *p; + + g_return_if_fail (object != NULL); + g_return_if_fail (IS_TOOLBAR (object)); + + t = TOOLBAR (object); + p = t->priv; + + g_return_if_fail (p != NULL); + + if (p->location_entry) g_object_unref (p->location_entry); + if (p->back_button) g_object_unref (p->back_button); + if (p->forward_button) g_object_unref (p->forward_button); + if (p->up_button) g_object_unref (p->up_button); + if (p->favicon_ebox) g_object_unref (p->favicon_ebox); + if (p->favicon) g_object_unref (p->favicon); + if (p->spinner) g_object_unref (p->spinner); + if (p->tooltips) g_object_unref (p->tooltips); + if (p->zoom_spinbutton) g_object_unref (p->zoom_spinbutton); + if (p->zoom_timeout_id != 0) + { + g_source_remove (p->zoom_timeout_id); + } + + g_object_unref (t->priv->bview); + + g_free (t->priv); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +Toolbar * +toolbar_new (EphyWindow *window) +{ + Toolbar *t; + + t = TOOLBAR (g_object_new (TOOLBAR_TYPE, + "EphyWindow", window, + NULL)); + + g_return_val_if_fail (t->priv != NULL, NULL); + + return t; +} + +void +toolbar_set_visibility (Toolbar *t, gboolean visibility) +{ + if (visibility == t->priv->visibility) return; + + t->priv->visibility = visibility; + + ephy_bonobo_set_hidden (BONOBO_UI_COMPONENT(t->priv->ui_component), + "/Toolbar", + !visibility); +} + +void +toolbar_activate_location (Toolbar *t) +{ + if (t->priv->location_entry) + { + ephy_location_entry_activate + (EPHY_LOCATION_ENTRY(t->priv->location_entry)); + } +} + +void +toolbar_spinner_start (Toolbar *t) +{ + if (t->priv->spinner) + { + ephy_spinner_start (EPHY_SPINNER(t->priv->spinner)); + } +} + +void +toolbar_spinner_stop (Toolbar *t) +{ + if (t->priv->spinner) + { + ephy_spinner_stop (EPHY_SPINNER(t->priv->spinner)); + } +} + +void +toolbar_button_set_sensitive (Toolbar *t, + ToolbarButtonID id, + gboolean sensitivity) +{ + switch (id) + { + case TOOLBAR_BACK_BUTTON: + ephy_bonobo_set_sensitive (t->priv->ui_component, + "/commands/GoBack", + sensitivity); + if (t->priv->back_button) + { + gtk_widget_set_sensitive (t->priv->back_button, + sensitivity); + } + break; + case TOOLBAR_FORWARD_BUTTON: + ephy_bonobo_set_sensitive (t->priv->ui_component, + "/commands/GoForward", + sensitivity); + if (t->priv->forward_button) + { + gtk_widget_set_sensitive (t->priv->forward_button, + sensitivity); + } + break; + case TOOLBAR_STOP_BUTTON: + ephy_bonobo_set_sensitive (t->priv->ui_component, + "/commands/GoStop", + sensitivity); + break; + case TOOLBAR_UP_BUTTON: + ephy_bonobo_set_sensitive (t->priv->ui_component, + "/commands/GoUp", + sensitivity); + if (t->priv->up_button) + { + gtk_widget_set_sensitive (t->priv->up_button, + sensitivity); + } + break; + } +} + +void +toolbar_set_location (Toolbar *t, + const char *location) +{ + g_return_if_fail (location != NULL); + + if (t->priv->location_entry) + { + ephy_location_entry_set_location + (EPHY_LOCATION_ENTRY (t->priv->location_entry), location); + } +} + +void +toolbar_update_favicon (Toolbar *t) +{ + if (t->priv->favicon) + { + ephy_embed_favicon_set_embed (EPHY_EMBED_FAVICON (t->priv->favicon), + ephy_window_get_active_embed (t->priv->window)); + } +} + +char * +toolbar_get_location (Toolbar *t) +{ + gchar *location; + if (t->priv->location_entry) + { + location = ephy_location_entry_get_location + (EPHY_LOCATION_ENTRY (t->priv->location_entry)); + } + else + { + location = g_strdup (""); + } + return location; +} + +gint +toolbar_get_zoom (Toolbar *t) +{ + gint zoom; + if (t->priv->zoom_spinbutton) + { + zoom = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (t->priv->zoom_spinbutton)); + } + else + { + zoom = 100; + } + return zoom; +} + +void +toolbar_set_zoom (Toolbar *t, gint zoom) +{ + ToolbarPrivate *p = t->priv; + if (p->zoom_spinbutton) + { + p->zoom_lock = TRUE; + gtk_spin_button_set_value (GTK_SPIN_BUTTON (p->zoom_spinbutton), zoom); + p->zoom_lock = FALSE; + } +} + diff --git a/src/toolbar.h b/src/toolbar.h new file mode 100644 index 000000000..5764c14e1 --- /dev/null +++ b/src/toolbar.h @@ -0,0 +1,88 @@ +/* + * Copyright (C) 2002 Jorn Baayen + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef TOOLBAR_H +#define TOOLBAR_H + +#include "ephy-window.h" +#include <glib-object.h> +#include <glib.h> +#include "ephy-toolbar.h" + +G_BEGIN_DECLS + +typedef struct ToolbarClass ToolbarClass; + +#define TOOLBAR_TYPE (toolbar_get_type ()) +#define TOOLBAR(obj) (GTK_CHECK_CAST ((obj), TOOLBAR_TYPE, Toolbar)) +#define TOOLBAR_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), TOOLBAR, ToolbarClass)) +#define IS_TOOLBAR(obj) (GTK_CHECK_TYPE ((obj), TOOLBAR_TYPE)) +#define IS_TOOLBAR_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), TOOLBAR)) + +typedef struct ToolbarPrivate ToolbarPrivate; + +typedef enum +{ + TOOLBAR_BACK_BUTTON, + TOOLBAR_FORWARD_BUTTON, + TOOLBAR_STOP_BUTTON, + TOOLBAR_UP_BUTTON +} ToolbarButtonID; + +struct Toolbar +{ + EphyToolbar parent_object; + ToolbarPrivate *priv; +}; + +struct ToolbarClass +{ + EphyToolbarClass parent_class; +}; + +GType toolbar_get_type (void); + +Toolbar *toolbar_new (EphyWindow *window); + +void toolbar_set_visibility (Toolbar *t, + gboolean visibility); + +void toolbar_button_set_sensitive (Toolbar *t, + ToolbarButtonID id, + gboolean sensitivity); + +void toolbar_spinner_start (Toolbar *t); + +void toolbar_spinner_stop (Toolbar *t); + +char *toolbar_get_location (Toolbar *t); + +void toolbar_set_location (Toolbar *t, + const char *location); + +gint toolbar_get_zoom (Toolbar *t); + +void toolbar_set_zoom (Toolbar *t, gint zoom); + +void toolbar_activate_location (Toolbar *t); + +void toolbar_update_favicon (Toolbar *t); + +G_END_DECLS + +#endif diff --git a/src/ui-prefs.c b/src/ui-prefs.c new file mode 100755 index 000000000..e461bf7e6 --- /dev/null +++ b/src/ui-prefs.c @@ -0,0 +1,232 @@ +/* + * Copyright (C) 2002 Marco Pesenti Gritti + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include "ui-prefs.h" +#include "ephy-shell.h" +#include "ephy-prefs.h" +#include "eel-gconf-extensions.h" +#include "ephy-spinner.h" + +#include <string.h> +#include <libgnome/gnome-util.h> +#include <libgnomeui/gnome-icon-list.h> + +static void ui_prefs_class_init (UIPrefsClass *klass); +static void ui_prefs_init (UIPrefs *dialog); +static void ui_prefs_finalize (GObject *object); + +/* Glade callbacks */ +void +spinners_iconlist_select_icon_cb (GtkWidget *iconlist, gint num, + GdkEvent *event, UIPrefs *dialog); + +static GObjectClass *parent_class = NULL; + +struct UIPrefsPrivate +{ + gpointer dummy; + GList *spinner_list; +}; + +enum +{ + SPINNERS_PROP, + OPEN_IN_TABS_PROP, + JUMP_TO_PROP, + POPUPS_PROP +}; + +static const +EphyDialogProperty properties [] = +{ + { SPINNERS_PROP, "spinners_iconlist", NULL, PT_NORMAL, NULL }, + { OPEN_IN_TABS_PROP, "open_in_tabs_checkbutton", CONF_TABS_TABBED, PT_AUTOAPPLY, NULL }, + { JUMP_TO_PROP, "jump_to_checkbutton", CONF_TABS_TABBED_AUTOJUMP, PT_AUTOAPPLY, NULL }, + { POPUPS_PROP, "popups_checkbutton", CONF_TABS_TABBED_POPUPS, PT_AUTOAPPLY, NULL }, + + { -1, NULL, NULL } +}; + +GType +ui_prefs_get_type (void) +{ + static GType ui_prefs_type = 0; + + if (ui_prefs_type == 0) + { + static const GTypeInfo our_info = + { + sizeof (UIPrefsClass), + NULL, /* base_init */ + NULL, /* base_finalize */ + (GClassInitFunc) ui_prefs_class_init, + NULL, + NULL, /* class_data */ + sizeof (UIPrefs), + 0, /* n_preallocs */ + (GInstanceInitFunc) ui_prefs_init + }; + + ui_prefs_type = g_type_register_static (EPHY_DIALOG_TYPE, + "UIPrefs", + &our_info, 0); + } + + return ui_prefs_type; + +} + +static void +ui_prefs_class_init (UIPrefsClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + parent_class = g_type_class_peek_parent (klass); + + object_class->finalize = ui_prefs_finalize; +} + +/** + * Free any existing spinner list. + */ +static void +free_spinner_list (UIPrefs *dialog) +{ + GList *node; + + for (node = dialog->priv->spinner_list; node; node = node->next) + g_free(node->data); + + g_list_free(dialog->priv->spinner_list); + dialog->priv->spinner_list = NULL; +} + +/** + * spinner_get_path_from_index: used in prefs_callbacks.c to get the + * path of selected icon + */ +static const gchar * +spinner_get_path_from_index (UIPrefs *dialog, gint index) +{ + gchar *path; + + path = g_list_nth_data (dialog->priv->spinner_list, index); + + return path; +} + +/* + * spinner_fill_iconlist: fill a gnome icon list with icons of available spinners + */ +static void +spinner_fill_iconlist (UIPrefs *dialog, GnomeIconList *icon_list) +{ + GList *spinners, *tmp; + gchar *pref_spinner_path; + gint index; + + /* clear spinner list */ + free_spinner_list (dialog); + gnome_icon_list_clear (GNOME_ICON_LIST (icon_list)); + + pref_spinner_path = + eel_gconf_get_string (CONF_TOOLBAR_SPINNER_THEME); + index = gnome_icon_list_get_num_icons (icon_list); + + spinners = ephy_spinner_list_spinners (); + for (tmp = spinners; tmp != NULL; tmp = g_list_next (tmp)) + { + EphySpinnerInfo *info = tmp->data; + + dialog->priv->spinner_list = + g_list_append (dialog->priv->spinner_list, + g_strdup (info->name)); + + gnome_icon_list_append (icon_list, info->filename, info->name); + + /* Select the icon configured in prefs */ + if (pref_spinner_path && + strcmp (pref_spinner_path, info->name) == 0) + { + gnome_icon_list_select_icon (icon_list, index); + } + index++; + } + g_list_foreach (spinners, (GFunc)ephy_spinner_info_free, NULL); + g_list_free (spinners); + + g_free (pref_spinner_path); +} + +static void +ui_prefs_init (UIPrefs *dialog) +{ + GtkWidget *icon_list; + + dialog->priv = g_new0 (UIPrefsPrivate, 1); + dialog->priv->spinner_list = NULL; + + ephy_dialog_construct (EPHY_DIALOG(dialog), + properties, + "prefs-dialog.glade", + "ui_page_box"); + + icon_list = ephy_dialog_get_control (EPHY_DIALOG(dialog), + SPINNERS_PROP); + + spinner_fill_iconlist (dialog, GNOME_ICON_LIST (icon_list)); +} + +static void +ui_prefs_finalize (GObject *object) +{ + UIPrefs *dialog; + + g_return_if_fail (object != NULL); + g_return_if_fail (IS_UI_PREFS (object)); + + dialog = UI_PREFS (object); + + g_return_if_fail (dialog->priv != NULL); + + free_spinner_list (dialog); + + g_free (dialog->priv); + + G_OBJECT_CLASS (parent_class)->finalize (object); +} + +EphyDialog * +ui_prefs_new (void) +{ + UIPrefs *dialog; + + dialog = UI_PREFS (g_object_new (UI_PREFS_TYPE, + NULL)); + + return EPHY_DIALOG(dialog); +} + +void +spinners_iconlist_select_icon_cb (GtkWidget *iconlist, gint num, + GdkEvent *event, UIPrefs *dialog) +{ + const char *path; + path = spinner_get_path_from_index (dialog, num); + eel_gconf_set_string (CONF_TOOLBAR_SPINNER_THEME, path); +} diff --git a/src/ui-prefs.h b/src/ui-prefs.h new file mode 100644 index 000000000..bbd3dbe75 --- /dev/null +++ b/src/ui-prefs.h @@ -0,0 +1,58 @@ +/* + * Copyright (C) 2002 Jorn Baayen + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef UI_PREFS_H +#define UI_PREFS_H + +#include "ephy-dialog.h" + +#include <glib-object.h> +#include <glib.h> + +G_BEGIN_DECLS + +typedef struct UIPrefs UIPrefs; +typedef struct UIPrefsClass UIPrefsClass; + +#define UI_PREFS_TYPE (ui_prefs_get_type ()) +#define UI_PREFS(obj) (GTK_CHECK_CAST ((obj), UI_PREFS_TYPE, UIPrefs)) +#define UI_PREFS_CLASS(klass) (GTK_CHECK_CLASS_CAST ((klass), UI_PREFS, UIPrefsClass)) +#define IS_UI_PREFS(obj) (GTK_CHECK_TYPE ((obj), UI_PREFS_TYPE)) +#define IS_UI_PREFS_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), UI_PREFS)) + +typedef struct UIPrefsPrivate UIPrefsPrivate; + +struct UIPrefs +{ + EphyDialog parent; + UIPrefsPrivate *priv; +}; + +struct UIPrefsClass +{ + EphyDialogClass parent_class; +}; + +GType ui_prefs_get_type (void); + +EphyDialog *ui_prefs_new (void); + +G_END_DECLS + +#endif + diff --git a/src/window-commands.c b/src/window-commands.c new file mode 100644 index 000000000..cef1d675c --- /dev/null +++ b/src/window-commands.c @@ -0,0 +1,917 @@ +/* + * Copyright (C) 2000, 2001, 2002 Marco Pesenti Gritti + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include <config.h> + +#include "ephy-shell.h" +#include "window-commands.h" +#include "find-dialog.h" +#include "print-dialog.h" +#include "eel-gconf-extensions.h" +#include "ephy-prefs.h" +#include "ephy-embed-utils.h" +#include "pdm-dialog.h" +#include "toolbar.h" +#include "ephy-toolbar-editor.h" +#include "ephy-bookmarks-editor.h" +#include "ephy-new-bookmark.h" + +#include <string.h> +#include <libgnomevfs/gnome-vfs-uri.h> +#include <libgnomevfs/gnome-vfs-utils.h> +#include <bonobo/bonobo-i18n.h> +#include <libgnomeui/gnome-about.h> +#include <libgnome/gnome-help.h> +#include <gtk/gtkmessagedialog.h> +#include <gtk/gtkeditable.h> + +#define AVAILABLE_TOOLBAR_ITEMS \ + "new=std_toolitem(item=new);" \ + "back=std_toolitem(item=back);" \ + "back_history=navigation_history(direction=back);" \ + "up=std_toolitem(item=up);" \ + "up_history=navigation_history(direction=up);" \ + "forward=std_toolitem(item=forward);" \ + "forward_history=navigation_history(direction=forward);" \ + "stop=std_toolitem(item=stop);" \ + "reload=std_toolitem(item=reload);" \ + "home=std_toolitem(item=home);" \ + "favicon=favicon;" \ + "location=location;" \ + "go=std_toolitem(item=go);" \ + "zoom=zoom;" \ + "spinner=spinner;" \ + "separator;" + + + +void +window_cmd_edit_find (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + EphyDialog *dialog; + dialog = ephy_window_get_find_dialog (window); + + g_object_ref (dialog); + + ephy_dialog_show (dialog); +} + +static void +print_dialog_preview_cb (PrintDialog *dialog, + EphyWindow *window) +{ + ephy_window_set_chrome (window, EMBED_CHROME_PPVIEWTOOLBARON); +} + +void +window_cmd_file_print (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + EphyDialog *dialog; + EphyEmbed *embed; + + embed = ephy_window_get_active_embed (window); + g_return_if_fail (embed != NULL); + + dialog = print_dialog_new_with_parent (GTK_WIDGET(window), + embed, NULL); + g_signal_connect (G_OBJECT(dialog), + "preview", + G_CALLBACK (print_dialog_preview_cb), + window); + ephy_dialog_set_modal (dialog, TRUE); + ephy_dialog_show (dialog); +} + +void +window_cmd_go_back (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + EphyEmbed *embed; + + embed = ephy_window_get_active_embed (window); + g_return_if_fail (embed != NULL); + + ephy_embed_go_back (embed); +} + +void +window_cmd_go_up (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + EphyEmbed *embed; + + embed = ephy_window_get_active_embed (window); + g_return_if_fail (embed != NULL); + + ephy_embed_go_up (embed); +} + +void +window_cmd_file_send_to (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + char *url; + EphyTab *tab; + EphyEmbed *embed; + char *location; + char *title; + + tab = ephy_window_get_active_tab (window); + g_return_if_fail (tab); + + embed = ephy_window_get_active_embed (window); + g_return_if_fail (tab); + + location = gnome_vfs_escape_string (ephy_tab_get_location (tab)); + if (ephy_embed_get_title (embed, &title) == G_OK) + { + char *tmp = gnome_vfs_escape_string (title); + g_free (title); + title = tmp; + } + else + { + title = gnome_vfs_escape_string (_("Check this out!")); + } + + url = g_strconcat ("mailto:", + "?Subject=", title, + "&Body=", location, NULL); + + ephy_embed_load_url (embed, url); + + g_free (title); + g_free (location); + g_free (url); +} + +void +window_cmd_go_forward (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + EphyEmbed *embed; + + embed = ephy_window_get_active_embed (window); + g_return_if_fail (embed != NULL); + + ephy_embed_go_forward (embed); +} + +void +window_cmd_go_go (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + Toolbar *tb; + + g_return_if_fail (IS_EPHY_WINDOW (window)); + + tb = ephy_window_get_toolbar (window); + + if (tb) + { + char *location = toolbar_get_location (tb); + ephy_window_load_url (window, location); + g_free (location); + } +} + +void +window_cmd_go_home (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + EphyEmbed *embed; + char *location; + + embed = ephy_window_get_active_embed (window); + g_return_if_fail (embed != NULL); + + location = eel_gconf_get_string (CONF_GENERAL_HOMEPAGE); + g_return_if_fail (location != NULL); + + ephy_embed_load_url (embed, location); + + g_free (location); +} + +void +window_cmd_go_myportal (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + EphyEmbed *embed; + + embed = ephy_window_get_active_embed (window); + g_return_if_fail (embed != NULL); + + ephy_embed_load_url (embed, "myportal:"); +} + +void +window_cmd_go_location (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + ephy_window_activate_location (window); +} + +void +window_cmd_go_stop (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + EphyEmbed *embed; + + embed = ephy_window_get_active_embed (window); + g_return_if_fail (embed != NULL); + + ephy_embed_stop_load (embed); +} + +void +window_cmd_go_reload (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + EphyEmbed *embed; + + embed = ephy_window_get_active_embed (window); + g_return_if_fail (embed != NULL); + + ephy_embed_reload (embed, EMBED_RELOAD_NORMAL); +} + +void +window_cmd_new (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + EphyTab *tab; + + tab = ephy_window_get_active_tab (window); + + ephy_shell_new_tab (ephy_shell, window, tab, NULL, + EPHY_NEW_TAB_HOMEPAGE | + EPHY_NEW_TAB_JUMP); +} + +void +window_cmd_new_window (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + EphyTab *tab; + + tab = ephy_window_get_active_tab (window); + + ephy_shell_new_tab (ephy_shell, NULL, tab, NULL, + EPHY_NEW_TAB_HOMEPAGE | + EPHY_NEW_TAB_IN_NEW_WINDOW | + EPHY_NEW_TAB_JUMP); +} + +void +window_cmd_new_tab (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + EphyTab *tab; + + tab = ephy_window_get_active_tab (window); + + ephy_shell_new_tab (ephy_shell, window, tab, NULL, + EPHY_NEW_TAB_HOMEPAGE | + EPHY_NEW_TAB_IN_EXISTING_WINDOW | + EPHY_NEW_TAB_JUMP); +} + +void +window_cmd_bookmarks_edit (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + GtkWidget *dialog; + EphyBookmarks *bookmarks; + + bookmarks = ephy_shell_get_bookmarks (ephy_shell); + g_assert (bookmarks != NULL); + dialog = ephy_bookmarks_editor_new (bookmarks, GTK_WINDOW (window)); + gtk_widget_show (dialog); +} + +void +window_cmd_bookmarks_add_default (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + EphyTab *tab; + EphyEmbed *embed; + EphyBookmarks *bookmarks; + GtkWidget *new_bookmark; + const char *location; + char *title; + + tab = ephy_window_get_active_tab (window); + g_return_if_fail (tab); + + embed = ephy_window_get_active_embed (window); + g_return_if_fail (tab); + + location = ephy_tab_get_location (tab); + if (ephy_embed_get_title (embed, &title) != G_OK) + { + title = _("Untitled"); + } + + bookmarks = ephy_shell_get_bookmarks (ephy_shell); + new_bookmark = ephy_new_bookmark_new + (bookmarks, GTK_WINDOW (window), location); + ephy_new_bookmark_set_title + (EPHY_NEW_BOOKMARK (new_bookmark), title); + gtk_widget_show (new_bookmark); +} + +void +window_cmd_file_open (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + gchar *dir, *retDir; + gchar *file = NULL; + GnomeVFSURI *uri; + GtkWidget *wmain; + EphyEmbedShell *embed_shell; + gresult result; + + embed_shell = ephy_shell_get_embed_shell (ephy_shell); + g_return_if_fail (embed_shell != NULL); + + wmain = GTK_WIDGET (window); + g_return_if_fail (wmain != NULL); + + dir = eel_gconf_get_string (CONF_STATE_OPEN_DIR); + + result = ephy_embed_shell_show_file_picker + (embed_shell, wmain, + _("Select the file to open"), + dir, NULL, modeOpen, + &file, NULL, NULL, NULL); + + if (result == G_OK) + { + uri = gnome_vfs_uri_new (file); + if (uri) + { + + ephy_window_load_url(window, file); + + retDir = gnome_vfs_uri_extract_dirname (uri); + + /* set default open dir */ + eel_gconf_set_string (CONF_STATE_OPEN_DIR, + retDir); + + g_free (retDir); + gnome_vfs_uri_unref (uri); + } + } + + g_free (dir); + g_free (file); +} + +void +window_cmd_file_save_as (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + EphyEmbed *embed; + EphyEmbedPersist *persist; + + embed = ephy_window_get_active_embed (window); + g_return_if_fail (embed != NULL); + + persist = ephy_embed_persist_new (embed); + ephy_embed_persist_set_flags (persist, + EMBED_PERSIST_MAINDOC); + + ephy_embed_utils_save (GTK_WIDGET(window), + CONF_STATE_SAVE_DIR, + TRUE, + TRUE, + persist); + + g_object_unref (G_OBJECT(persist)); +} + +void +window_cmd_file_close_tab (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + EphyTab *tab; + + tab = ephy_window_get_active_tab (window); + g_return_if_fail (tab != NULL); + + ephy_window_remove_tab (window, tab); +} + +void +window_cmd_file_close_window (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + gtk_widget_destroy (GTK_WIDGET(window)); +} + +void +window_cmd_edit_cut (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + GtkWidget *widget = gtk_window_get_focus (GTK_WINDOW (window)); + + if (GTK_IS_EDITABLE (widget)) + { + gtk_editable_cut_clipboard (GTK_EDITABLE (widget)); + } + else + { + EphyEmbed *embed; + embed = ephy_window_get_active_embed (window); + g_return_if_fail (embed != NULL); + + ephy_embed_selection_cut (embed); + } +} + +void +window_cmd_edit_copy (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + GtkWidget *widget = gtk_window_get_focus (GTK_WINDOW (window)); + + if (GTK_IS_EDITABLE (widget)) + { + gtk_editable_copy_clipboard (GTK_EDITABLE (widget)); + } + else + { + EphyEmbed *embed; + + embed = ephy_window_get_active_embed (window); + g_return_if_fail (embed != NULL); + + ephy_embed_selection_copy (embed); + } +} + +void +window_cmd_edit_paste (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + GtkWidget *widget = gtk_window_get_focus (GTK_WINDOW (window)); + + if (GTK_IS_EDITABLE (widget)) + { + gtk_editable_paste_clipboard (GTK_EDITABLE (widget)); + } + else + { + EphyEmbed *embed; + + embed = ephy_window_get_active_embed (window); + g_return_if_fail (embed != NULL); + + ephy_embed_paste (embed); + } +} + +void +window_cmd_edit_select_all (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + GtkWidget *widget = gtk_window_get_focus (GTK_WINDOW (window)); + + if (GTK_IS_EDITABLE (widget)) + { + gtk_editable_select_region (GTK_EDITABLE (widget), 0, -1); + } + else + { + EphyEmbed *embed; + + embed = ephy_window_get_active_embed (window); + g_return_if_fail (embed != NULL); + + ephy_embed_select_all (embed); + } +} + +void +window_cmd_edit_find_next (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + EphyDialog *dialog; + + dialog = ephy_window_get_find_dialog (window); + + find_dialog_go_next (FIND_DIALOG(dialog), FALSE); + + ephy_window_update_control (window, FindControl); +} + +void +window_cmd_edit_find_prev (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + EphyDialog *dialog; + + dialog = ephy_window_get_find_dialog (window); + + find_dialog_go_prev (FIND_DIALOG(dialog), FALSE); + + ephy_window_update_control (window, FindControl); +} + +void +window_cmd_view_zoom_in (BonoboUIComponent *uic, + EphyWindow *window, + const char *verbname) +{ + EphyEmbed *embed; + int zoom; + + embed = ephy_window_get_active_embed (window); + g_return_if_fail (embed != NULL); + + ephy_embed_zoom_get (embed, &zoom); + ephy_window_set_zoom (window, zoom + 10); +} + +void +window_cmd_view_zoom_out (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + EphyEmbed *embed; + int zoom; + + embed = ephy_window_get_active_embed (window); + g_return_if_fail (embed != NULL); + + ephy_embed_zoom_get (embed, &zoom); + if (zoom >= 10) + { + ephy_window_set_zoom (window, zoom - 10); + } +} + +void +window_cmd_view_zoom_normal (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + ephy_window_set_zoom (window, 100); +} + +void +window_cmd_view_page_source (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + EphyTab *tab; + + tab = ephy_window_get_active_tab (window); + g_return_if_fail (tab != NULL); + + ephy_shell_new_tab (ephy_shell, window, tab, NULL, + EPHY_NEW_TAB_VIEW_SOURCE); +} + +void +window_cmd_tools_history (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + ephy_window_show_history (window); +} + +void +window_cmd_tools_pdm (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + EphyDialog *dialog; + + dialog = pdm_dialog_new (GTK_WIDGET(window)); + + ephy_dialog_show (dialog); +} + +void +window_cmd_edit_prefs (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + GtkDialog *dialog; + + dialog = prefs_dialog_new (); + prefs_dialog_show_page (PREFS_DIALOG(dialog), + PREFS_PAGE_GENERAL); + gtk_window_set_transient_for (GTK_WINDOW (dialog), + GTK_WINDOW (window)); + gtk_widget_show (GTK_WIDGET(dialog)); +} + +static void +window_cmd_settings_toolbar_editor_revert_clicked_cb (GtkButton *b, EphyTbEditor *tbe) +{ + gchar *def; + + g_return_if_fail (EPHY_IS_TB_EDITOR (tbe)); + + eel_gconf_unset (CONF_TOOLBAR_SETUP); + def = eel_gconf_get_string (CONF_TOOLBAR_SETUP); + if (def) + { + EphyToolbar *current; + EphyToolbar *avail; + current = ephy_tb_editor_get_toolbar (tbe); + ephy_toolbar_parse (current, def); + g_free (def); + + avail = ephy_tb_editor_get_available (tbe); + g_object_ref (avail); + ephy_toolbar_parse (avail, AVAILABLE_TOOLBAR_ITEMS); + ephy_tb_editor_set_available (tbe, avail); + g_object_unref (avail); + } + +} + +static void +window_cmd_settings_toolbar_editor_current_changed_cb (EphyToolbar *tb, gpointer data) +{ + gchar *current_str; + + g_return_if_fail (EPHY_IS_TOOLBAR (tb)); + + current_str = ephy_toolbar_to_string (tb); + eel_gconf_set_string (CONF_TOOLBAR_SETUP, current_str); + g_free (current_str); +} + +void +window_cmd_settings_toolbar_editor (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + static EphyTbEditor *tbe = NULL; + EphyToolbar *avail; + EphyToolbar *current; + gchar *current_str; + GtkButton *revert_button; + + avail = ephy_toolbar_new (); + ephy_toolbar_parse (avail, AVAILABLE_TOOLBAR_ITEMS); + + current_str = eel_gconf_get_string (CONF_TOOLBAR_SETUP); + current = ephy_toolbar_new (); + if (current_str) + { + ephy_toolbar_parse (current, current_str); + g_free (current_str); + } + + if (!tbe) + { + tbe = ephy_tb_editor_new (); + g_object_add_weak_pointer (G_OBJECT (tbe), + (void **)&tbe); + ephy_tb_editor_set_parent (tbe, + GTK_WIDGET(window)); + } + else + { + ephy_tb_editor_show (tbe); + return; + } + + ephy_tb_editor_set_toolbar (tbe, current); + ephy_tb_editor_set_available (tbe, avail); + g_object_unref (avail); + g_object_unref (current); + + g_signal_connect (current, "changed", + G_CALLBACK (window_cmd_settings_toolbar_editor_current_changed_cb), NULL); + + revert_button = ephy_tb_editor_get_revert_button (tbe); + gtk_widget_show (GTK_WIDGET (revert_button)); + + g_signal_connect (revert_button, "clicked", + G_CALLBACK (window_cmd_settings_toolbar_editor_revert_clicked_cb), tbe); + + ephy_tb_editor_show (tbe); +} + +void +window_cmd_help_about (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + static GtkWidget *about = NULL; + + static gchar *authors[] = { + "Marco Pesenti Gritti <mpeseng@tin.it>", + NULL + }; + + gchar *documenters[] = { + NULL + }; + + /* Translator credits */ + gchar *translator_credits = _("translator_credits"); + + if (about != NULL) + { + gdk_window_show(about->window); + gdk_window_raise(about->window); + return; + } + + about = gnome_about_new( + _("Epiphany"), VERSION, + /* Translators: Please change the (C) to a real + * copyright character if your character set allows it + * (Hint: iso-8859-1 is one of the character sets that + * has this symbol). */ + _("Copyright (C) 2002 Marco Pesenti Gritti"), + _("A GNOME browser based on Mozilla"), + (const char **)authors, + (const char **)documenters, + strcmp (translator_credits, "translator_credits") != 0 ? translator_credits : NULL, + NULL); + + gtk_window_set_transient_for (GTK_WINDOW (about), + GTK_WINDOW (window)); + g_object_add_weak_pointer (G_OBJECT (about), (gpointer *)&about); + gtk_widget_show (about); +} + +void +window_cmd_set_charset (BonoboUIComponent *uic, + EncodingMenuData *data, + const char* verbname) +{ + EphyWindow *window = data->data; + EphyEmbed *embed; + + embed = ephy_window_get_active_embed (window); + g_return_if_fail (embed != NULL); + + g_print (data->encoding); + ephy_embed_set_charset (embed, data->encoding); +} + +void +window_cmd_tabs_next (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + GList *tabs; + EphyTab *tab; + + tab = ephy_window_get_active_tab (window); + tabs = ephy_window_get_tabs (window); + g_return_if_fail (tab != NULL); + + tabs = g_list_find (tabs, (gpointer)tab); + tabs = tabs->next; + + if (tabs) + { + tab = EPHY_TAB (tabs->data); + ephy_window_jump_to_tab (window, tab); + g_list_free (tabs); + } +} + +void +window_cmd_tabs_previous (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + GList *tabs; + EphyTab *tab; + + tab = ephy_window_get_active_tab (window); + tabs = ephy_window_get_tabs (window); + g_return_if_fail (tab != NULL); + + tabs = g_list_find (tabs, (gpointer)tab); + tabs = tabs->prev; + + if (tabs) + { + tab = EPHY_TAB (tabs->data); + ephy_window_jump_to_tab (window, tab); + g_list_free (tabs); + } +} + +void +window_cmd_tabs_move_left (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ +} + +void window_cmd_tabs_move_right (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ +} + +void +window_cmd_tabs_detach (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname) +{ + EphyTab *tab; + GtkWidget *src_page; + EphyWindow *new_win; + + if (g_list_length (ephy_window_get_tabs (window)) <= 1) { + return; + } + + tab = ephy_window_get_active_tab (window); + src_page = GTK_WIDGET (ephy_tab_get_embed (tab)); + new_win = ephy_window_new (); + ephy_notebook_move_page (EPHY_NOTEBOOK (ephy_window_get_notebook (window)), + EPHY_NOTEBOOK (ephy_window_get_notebook (new_win)), + src_page, 0); + ephy_tab_set_window (tab, new_win); + gtk_widget_show (GTK_WIDGET (new_win)); +} + +void +window_cmd_help_manual (BonoboUIComponent *uic, + char *filename, + const char* verbname) +{ + GError *error; + GtkWidget *dialog; + + error = NULL; + gnome_help_display ("Ephy.xml", NULL, &error); + + if (error) + { + dialog = gtk_message_dialog_new (NULL, + GTK_DIALOG_MODAL, + GTK_MESSAGE_ERROR, + GTK_BUTTONS_CLOSE, + _("There was an error displaying help: \n%s"), + error->message); + g_signal_connect (G_OBJECT (dialog), "response", + G_CALLBACK (gtk_widget_destroy), + NULL); + + gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); + gtk_widget_show (dialog); + g_error_free (error); + } +} diff --git a/src/window-commands.h b/src/window-commands.h new file mode 100644 index 000000000..df05a4d50 --- /dev/null +++ b/src/window-commands.h @@ -0,0 +1,196 @@ +/* + * Copyright (C) 2000, 2001, 2002 Marco Pesenti Gritti + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include "ephy-window.h" +#include "ephy-embed-utils.h" + +#include <bonobo/bonobo-ui-component.h> + +void window_cmd_edit_find (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_file_print (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_go_stop (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_go_back (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_go_forward (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_go_go (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_go_up (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_go_home (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_go_myportal (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_go_location (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_go_reload (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_new (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_new_window (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_new_tab (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_bookmarks_add_default (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_bookmarks_edit (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_file_open (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_file_save_as (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_file_send_to (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_file_close_tab (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_file_close_window (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_edit_cut (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_edit_copy (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_edit_paste (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_edit_select_all (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_edit_find_next (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_edit_find_prev (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_view_zoom_in (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_view_zoom_out (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_view_zoom_normal(BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_view_page_source(BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_tools_history (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_tools_pdm (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_edit_prefs (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void +window_cmd_settings_toolbar_editor (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_help_about (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_set_charset (BonoboUIComponent *uic, + EncodingMenuData *data, + const char* verbname); + +void window_cmd_tabs_next (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_tabs_previous (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_tabs_move_left (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_tabs_move_right (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_tabs_detach (BonoboUIComponent *uic, + EphyWindow *window, + const char* verbname); + +void window_cmd_help_manual (BonoboUIComponent *uic, + char *filename, + const char* verbname); + |