debian/midori
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
midori/midori/midori-browser.c

4870 lines
168 KiB
C
Raw Normal View History

Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
/*
Copyright (C) 2007-2008 Christian Dywan <christian@twotoasts.de>
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
Copyright (C) 2008 Dale Whittaker <dayul@users.sf.net>
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
See the file COPYING for the full license text.
*/
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
#if HAVE_CONFIG_H
#include <config.h>
#endif
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
#include "midori-browser.h"
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
#include "midori-view.h"
#include "midori-source.h"
Turn prefs into MidoriPreferences
2008-04-20 01:30:24 +00:00
#include "midori-preferences.h"
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
#include "midori-panel.h"
Initial addon panel feature, only userscripts for now.
2008-04-28 20:38:57 +00:00
#include "midori-addons.h"
Implement the Console panel for script messages.
2008-03-27 00:21:29 +00:00
#include "midori-console.h"
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
#include "midori-locationaction.h"
Implement the search widget as an action The most part of the search entry code is merely moved to the new action. We remove the original entry now, the action is all we need.
2008-10-05 21:25:02 +00:00
#include "midori-searchaction.h"
Rename main.h to midori-stock.h
2008-09-03 00:39:25 +00:00
#include "midori-stock.h"
#include "gtkiconentry.h"
Preliminary fix for crash after removing a bookmark
2008-07-16 12:24:30 +00:00
#include "compat.h"
Rename main.h to midori-stock.h
2008-09-03 00:39:25 +00:00
#include "sokoke.h"
Show news feeds in a menu if the icon is clicked
2008-08-02 02:25:05 +00:00
#include "gjs.h"
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
#include <glib/gi18n.h>
Show a dialog before clearing the history Plus you can now remove history items with Del.
2008-10-10 21:19:37 +00:00
#include <gdk/gdkkeysyms.h>
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
#include <gtk/gtk.h>
#include <string.h>
Implement View source with external Text editor
2008-10-20 19:32:25 +00:00
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
struct _MidoriBrowser
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
GtkWindow parent_instance;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
GtkActionGroup* action_group;
GtkWidget* menubar;
GtkWidget* menu_tools;
GtkWidget* throbber;
GtkWidget* navigationbar;
GtkWidget* button_fullscreen;
GtkWidget* bookmarkbar;
GtkWidget* panel;
GtkWidget* panel_bookmarks;
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
GtkWidget* panel_history;
Implement the Console panel for script messages.
2008-03-27 00:21:29 +00:00
GtkWidget* panel_console;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
GtkWidget* panel_pageholder;
GtkWidget* notebook;
Initial support for the Web Inspector
2008-11-01 18:15:58 +00:00
GtkWidget* inspector;
GtkWidget* inspector_view;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
GtkWidget* find;
GtkWidget* find_text;
GtkToolItem* find_case;
GtkToolItem* find_highlight;
GtkWidget* statusbar;
GtkWidget* progressbar;
gchar* statusbar_text;
Finish refactoring the toolbar to use only actions Finally the trash, which was the last item that needed to be implemented as an action, is an action, a KatzeArrayAction to be exact. This simplifies more code and also makes Window and RecentlyVisited generically implementable. Incidentally this change also fixes a bug where the browser tried to add a new tab when the last one was closed, even while destroying itself. Furthermore sokoke_image_menu_item_ellipsized and sokoke_widget_popup were promoted to Katze. We're still keeping the old functions for now.
2008-10-10 20:31:37 +00:00
MidoriWebSettings* settings;
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
KatzeArray* proxy_array;
Finish refactoring the toolbar to use only actions Finally the trash, which was the last item that needed to be implemented as an action, is an action, a KatzeArrayAction to be exact. This simplifies more code and also makes Window and RecentlyVisited generically implementable. Incidentally this change also fixes a bug where the browser tried to add a new tab when the last one was closed, even while destroying itself. Furthermore sokoke_image_menu_item_ellipsized and sokoke_widget_popup were promoted to Katze. We're still keeping the old functions for now.
2008-10-10 20:31:37 +00:00
KatzeArray* bookmarks;
Rework MidoriWebList into KatzeList and KatzeArray
2008-08-25 23:19:38 +00:00
KatzeArray* trash;
KatzeArray* search_engines;
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
KatzeArray* history;
Implement View source with external Text editor
2008-10-20 19:32:25 +00:00
Implement KatzeNet as a generic URI loader KatzeNet can from now on be used where URIs are handled and one would have used libSoup and/ or local file handling as appropriate, whereas KatzeNet does both. Since we are displaying icons in several places KatzeNet also provides an icon loader that saves us from doublicating even more code. All bookmarks and also history items have icons now, since KatzeNet makes that incredibly easy. Search engines are also using favicons now, and right now custom icons don't work, we still need to fix that. Note that only icons are cached, nothing else and the code is known to have a hidden, hard to reproduce crasher which may appear when an icon is newly loaded.
2008-10-23 22:09:12 +00:00
KatzeNet* net;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
};
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
G_DEFINE_TYPE (MidoriBrowser, midori_browser, GTK_TYPE_WINDOW)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
enum
{
PROP_0,
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
PROP_MENUBAR,
PROP_NAVIGATIONBAR,
Save the session whenever it changes, instead of on quit.
2008-07-23 18:17:13 +00:00
PROP_URI,
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
PROP_TAB,
PROP_STATUSBAR,
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
PROP_STATUSBAR_TEXT,
Make bookmarks a property of browser and app This means we have removed the last remaining global variable.
2008-09-03 00:28:54 +00:00
PROP_SETTINGS,
PROP_BOOKMARKS,
Complete move of webSearch, third step of refactoring web search
2008-06-15 02:02:56 +00:00
PROP_TRASH,
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
PROP_SEARCH_ENGINES,
PROP_HISTORY
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
};
Integrate panel toolbars properly outside scrolled areas.
2008-04-26 00:43:32 +00:00
enum
{
Initial addon panel feature, only userscripts for now.
2008-04-28 20:38:57 +00:00
WINDOW_OBJECT_CLEARED,
NEW_WINDOW,
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Provide action signals as javascript functions From javscript C functions cannot be called, but signals are available through the GObject type system. So we allow javascript to call action signals like functions. At the same time we modify a few browser functions, so that they are functions that are available as signals.
2008-05-31 22:21:08 +00:00
ADD_TAB,
Save the session whenever it changes, instead of on quit.
2008-07-23 18:17:13 +00:00
REMOVE_TAB,
Provide action signals as javascript functions From javscript C functions cannot be called, but signals are available through the GObject type system. So we allow javascript to call action signals like functions. At the same time we modify a few browser functions, so that they are functions that are available as signals.
2008-05-31 22:21:08 +00:00
ACTIVATE_ACTION,
QUIT,
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
LAST_SIGNAL
};
static guint signals[LAST_SIGNAL];
Ensure REMOVE_TAB emission, don't alter session when destroying
2008-07-25 10:45:50 +00:00
static void
midori_browser_dispose (GObject* object);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static void
midori_browser_finalize (GObject* object);
static void
Implement the Console panel for script messages.
2008-03-27 00:21:29 +00:00
midori_browser_set_property (GObject* object,
guint prop_id,
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
const GValue* value,
Implement the Console panel for script messages.
2008-03-27 00:21:29 +00:00
GParamSpec* pspec);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static void
Implement the Console panel for script messages.
2008-03-27 00:21:29 +00:00
midori_browser_get_property (GObject* object,
guint prop_id,
GValue* value,
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
GParamSpec* pspec);
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
static void
midori_browser_new_history_item (MidoriBrowser* browser,
KatzeItem* item);
Introduce MidoriLocationEntry and GtkIconEntry
2008-07-17 19:02:14 +00:00
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static GtkAction*
_action_by_name (MidoriBrowser* browser,
const gchar* name)
{
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
return gtk_action_group_get_action (browser->action_group, name);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
static void
_action_set_sensitive (MidoriBrowser* browser,
const gchar* name,
gboolean sensitive)
{
gtk_action_set_sensitive (_action_by_name (browser, name), sensitive);
}
static void
_action_set_active (MidoriBrowser* browser,
const gchar* name,
gboolean active)
{
GtkAction* action = _action_by_name (browser, name);
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), active);
}
Add Always Show Tabbar preference
2008-10-03 23:45:17 +00:00
static void
_toggle_tabbar_smartly (MidoriBrowser* browser)
{
guint n;
gboolean always_show_tabbar;
n = gtk_notebook_get_n_pages (GTK_NOTEBOOK (browser->notebook));
if (n < 2)
{
g_object_get (browser->settings, "always-show-tabbar",
&always_show_tabbar, NULL);
if (always_show_tabbar)
n++;
}
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (browser->notebook), n > 1);
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static void
_midori_browser_update_actions (MidoriBrowser* browser)
{
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
guint n;
Rework MidoriWebList into KatzeList and KatzeArray
2008-08-25 23:19:38 +00:00
gboolean trash_empty;
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
Add Always Show Tabbar preference
2008-10-03 23:45:17 +00:00
_toggle_tabbar_smartly (browser);
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
n = gtk_notebook_get_n_pages (GTK_NOTEBOOK (browser->notebook));
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
_action_set_sensitive (browser, "TabClose", n > 1);
_action_set_sensitive (browser, "TabPrevious", n > 1);
_action_set_sensitive (browser, "TabNext", n > 1);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
if (browser->trash)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Rework MidoriWebList into KatzeList and KatzeArray
2008-08-25 23:19:38 +00:00
trash_empty = katze_array_is_empty (browser->trash);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
_action_set_sensitive (browser, "UndoTabClose", !trash_empty);
_action_set_sensitive (browser, "Trash", !trash_empty);
}
}
static void
_midori_browser_update_interface (MidoriBrowser* browser)
{
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
GtkWidget* view;
Basic favicon support through GIO
2008-07-06 14:12:27 +00:00
gboolean loading;
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
gboolean can_reload;
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
GtkAction* action;
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
view = midori_browser_get_current_tab (browser);
loading = midori_view_get_load_status (MIDORI_VIEW (view))
Revamp the loading signals of MidoriWebView
2008-07-23 15:54:24 +00:00
!= MIDORI_LOAD_FINISHED;
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
can_reload = midori_view_can_reload (MIDORI_VIEW (view));
_action_set_sensitive (browser, "Reload", can_reload && !loading);
_action_set_sensitive (browser, "Stop", can_reload && loading);
_action_set_sensitive (browser, "Back",
midori_view_can_go_back (MIDORI_VIEW (view)));
_action_set_sensitive (browser, "Forward",
midori_view_can_go_forward (MIDORI_VIEW (view)));
Implement Save As functionality
2008-10-26 16:07:59 +00:00
/* Currently views that don't support source, don't support
saving either. If that changes, we need to thinkof something. */
_action_set_sensitive (browser, "SaveAs",
midori_view_can_view_source (MIDORI_VIEW (view)));
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
_action_set_sensitive (browser, "Print",
midori_view_can_print (MIDORI_VIEW (view)));
_action_set_sensitive (browser, "ZoomIn",
midori_view_can_zoom_in (MIDORI_VIEW (view)));
_action_set_sensitive (browser, "ZoomOut",
midori_view_can_zoom_out (MIDORI_VIEW (view)));
_action_set_sensitive (browser, "ZoomNormal",
midori_view_get_zoom_level (MIDORI_VIEW (view)) != 1.0);
_action_set_sensitive (browser, "SourceView",
midori_view_can_view_source (MIDORI_VIEW (view)));
_action_set_sensitive (browser, "Find",
midori_view_can_find (MIDORI_VIEW (view)));
_action_set_sensitive (browser, "FindNext",
midori_view_can_find (MIDORI_VIEW (view)));
_action_set_sensitive (browser, "FindPrevious",
midori_view_can_find (MIDORI_VIEW (view)));
/* _action_set_sensitive (browser, "FindQuick",
midori_view_can_find (MIDORI_VIEW (view))); */
Make Find work again, and disable it for source tabs
2008-09-28 14:29:41 +00:00
gtk_widget_set_sensitive (GTK_WIDGET (browser->find_highlight),
midori_view_can_find (MIDORI_VIEW (view)));
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
action = gtk_action_group_get_action (browser->action_group, "ReloadStop");
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
if (!loading)
{
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_widget_set_sensitive (browser->throbber, FALSE);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
g_object_set (action,
"stock-id", GTK_STOCK_REFRESH,
Show progress in location entry if statusbar is hidden
2008-08-31 00:45:13 +00:00
"tooltip", _("Reload the current page"),
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
"sensitive", can_reload, NULL);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_widget_hide (browser->progressbar);
Show progress in location independant of statusbar visibility
2008-10-21 22:26:20 +00:00
if (!sokoke_object_get_boolean (browser->settings, "show-navigationbar")
&& !sokoke_object_get_boolean (browser->settings, "show-statusbar"))
gtk_widget_hide (browser->navigationbar);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
else
{
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_widget_set_sensitive (browser->throbber, TRUE);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
g_object_set (action,
"stock-id", GTK_STOCK_STOP,
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
"tooltip", _("Stop loading the current page"), NULL);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_widget_show (browser->progressbar);
Initial support for the Web Inspector
2008-11-01 18:15:58 +00:00
if (!GTK_WIDGET_VISIBLE (browser->statusbar)
&& !GTK_WIDGET_VISIBLE (browser->navigationbar))
Show progress in location independant of statusbar visibility
2008-10-21 22:26:20 +00:00
gtk_widget_show (browser->navigationbar);
action = _action_by_name (browser, "Location");
midori_location_action_set_progress (MIDORI_LOCATION_ACTION (action),
midori_view_get_progress (MIDORI_VIEW (view)));
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
katze_throbber_set_animated (KATZE_THROBBER (browser->throbber), loading);
Show news feeds in a menu if the icon is clicked
2008-08-02 02:25:05 +00:00
/* FIXME: This won't work due to a bug in GtkIconEntry */
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
/* if (view && midori_view_get_news_feeds (MIDORI_VIEW (view)))
Show news feeds in a menu if the icon is clicked
2008-08-02 02:25:05 +00:00
gtk_icon_entry_set_icon_from_stock (GTK_ICON_ENTRY (
gtk_bin_get_child (GTK_BIN (browser->location))),
Use fallbacks for all icons, we don't want "broken" icons
2008-08-17 14:14:15 +00:00
GTK_ICON_ENTRY_SECONDARY, STOCK_NEWS_FEED);
Show news feeds in a menu if the icon is clicked
2008-08-02 02:25:05 +00:00
else
gtk_icon_entry_set_icon_from_pixbuf (GTK_ICON_ENTRY (
Make the web view aware of news feeds This introduces the logic needed to lookup news feeds and implements a signal news-feed-ready in MidoriWebView, similar to icon-ready. The interface in the browser still needs to be done.
2008-07-21 13:55:08 +00:00
gtk_bin_get_child (GTK_BIN (browser->location))),
Show news feeds in a menu if the icon is clicked
2008-08-02 02:25:05 +00:00
GTK_ICON_ENTRY_SECONDARY, NULL);*/
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
static void
_midori_browser_set_statusbar_text (MidoriBrowser* browser,
const gchar* text)
{
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
katze_assign (browser->statusbar_text, g_strdup (text));
gtk_statusbar_pop (GTK_STATUSBAR (browser->statusbar), 1);
gtk_statusbar_push (GTK_STATUSBAR (browser->statusbar), 1,
browser->statusbar_text ? browser->statusbar_text : "");
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
Attempt to fix handling of background and foreground tabs.
2008-04-24 22:20:43 +00:00
static void
_midori_browser_set_current_page_smartly (MidoriBrowser* browser,
gint n)
{
Reverse Open tabs in the background with Ctrl
2008-07-16 16:08:47 +00:00
if (!sokoke_object_get_boolean (browser->settings,
"open-tabs-in-the-background"))
Attempt to fix handling of background and foreground tabs.
2008-04-24 22:20:43 +00:00
midori_browser_set_current_page (browser, n);
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static void
_midori_browser_update_progress (MidoriBrowser* browser,
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
MidoriView* view)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Show progress in location entry if statusbar is hidden
2008-08-31 00:45:13 +00:00
MidoriLocationAction* action;
Revamp the loading signals of MidoriWebView
2008-07-23 15:54:24 +00:00
gdouble progress;
gchar* message;
Show progress in location entry if statusbar is hidden
2008-08-31 00:45:13 +00:00
action = MIDORI_LOCATION_ACTION (_action_by_name (browser, "Location"));
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
progress = midori_view_get_progress (view);
Show progress in location entry if statusbar is hidden
2008-08-31 00:45:13 +00:00
/* When we are finished, we don't want to *see* progress anymore */
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
if (midori_view_get_load_status (view) == MIDORI_LOAD_FINISHED)
Show progress in location entry if statusbar is hidden
2008-08-31 00:45:13 +00:00
progress = 0.0;
Revamp the loading signals of MidoriWebView
2008-07-23 15:54:24 +00:00
if (progress > 0.0)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (browser->progressbar),
Revamp the loading signals of MidoriWebView
2008-07-23 15:54:24 +00:00
progress);
message = g_strdup_printf (_("%d%% loaded"), (gint)(progress * 100));
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (browser->progressbar),
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
message);
g_free (message);
Show progress in location independant of statusbar visibility
2008-10-21 22:26:20 +00:00
midori_location_action_set_progress (action, progress);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
else
{
Revamp the loading signals of MidoriWebView
2008-07-23 15:54:24 +00:00
gtk_progress_bar_pulse (GTK_PROGRESS_BAR (browser->progressbar));
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (browser->progressbar),
NULL);
Show progress in location entry if statusbar is hidden
2008-08-31 00:45:13 +00:00
midori_location_action_set_progress (action, 0.0);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
}
Initial addon panel feature, only userscripts for now.
2008-04-28 20:38:57 +00:00
static void
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
_midori_browser_activate_action (MidoriBrowser* browser,
const gchar* name)
{
GtkAction* action = _action_by_name (browser, name);
if (action)
gtk_action_activate (action);
else
g_warning (_("Unexpected action '%s'."), name);
}
static void
midori_view_notify_icon_cb (MidoriView* view,
GParamSpec* pspec,
MidoriBrowser* browser)
Initial addon panel feature, only userscripts for now.
2008-04-28 20:38:57 +00:00
{
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
const gchar* uri;
GtkAction* action;
uri = midori_view_get_display_uri (MIDORI_VIEW (view));
action = _action_by_name (browser, "Location");
Implement the Remeber last visited pages preference
2008-10-13 16:29:46 +00:00
if (sokoke_object_get_boolean (browser->settings, "remember-last-visited-pages"))
midori_location_action_set_icon_for_uri (
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
MIDORI_LOCATION_ACTION (action), midori_view_get_icon (view), uri);
Initial addon panel feature, only userscripts for now.
2008-04-28 20:38:57 +00:00
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static void
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
midori_view_notify_load_status_cb (GtkWidget* view,
GParamSpec* pspec,
MidoriBrowser* browser)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Revamp the loading signals of MidoriWebView
2008-07-23 15:54:24 +00:00
const gchar* uri;
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
GtkAction* action;
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
uri = midori_view_get_display_uri (MIDORI_VIEW (view));
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
action = _action_by_name (browser, "Location");
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
if (midori_view_get_load_status (MIDORI_VIEW (view))
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
== MIDORI_LOAD_COMMITTED)
Implement the Remeber last visited pages preference
2008-10-13 16:29:46 +00:00
{
if (sokoke_object_get_boolean (browser->settings,
"remember-last-visited-pages"))
midori_location_action_add_uri (MIDORI_LOCATION_ACTION (action), uri);
}
Revamp the loading signals of MidoriWebView
2008-07-23 15:54:24 +00:00
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
if (view == midori_browser_get_current_tab (browser))
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
if (midori_view_get_load_status (MIDORI_VIEW (view))
Revamp the loading signals of MidoriWebView
2008-07-23 15:54:24 +00:00
== MIDORI_LOAD_COMMITTED)
{
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
midori_location_action_set_uri (
MIDORI_LOCATION_ACTION (action), uri);
midori_location_action_set_secondary_icon (
MIDORI_LOCATION_ACTION (action), NULL);
Save the session whenever it changes, instead of on quit.
2008-07-23 18:17:13 +00:00
g_object_notify (G_OBJECT (browser), "uri");
Revamp the loading signals of MidoriWebView
2008-07-23 15:54:24 +00:00
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
_midori_browser_update_interface (browser);
_midori_browser_set_statusbar_text (browser, NULL);
}
}
static void
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
midori_view_notify_progress_cb (GtkWidget* view,
GParamSpec* pspec,
MidoriBrowser* browser)
{
if (view == midori_browser_get_current_tab (browser))
_midori_browser_update_progress (browser, MIDORI_VIEW (view));
}
Undo tabs-in-processes, it didn't work out We are not literally undoing in the sense of reverting, this is actually about undoing the individual parts of the last refactoring that implemented the socket/ plug logic. As turned out, the idea was nice but the implementation was absolutely not, embedding of processes in a graphical way is not at all reliable enough for complex use cases. Naturally this change should solve all sorts of peculiar issues, including actual regressions in functionality. Relieving.
2008-10-15 01:07:38 +00:00
static void
midori_view_window_object_cleared_cb (GtkWidget* view,
WebKitWebFrame* web_frame,
JSContextRef js_context,
JSObjectRef js_window,
MidoriBrowser* browser)
{
g_signal_emit (browser, signals[WINDOW_OBJECT_CLEARED], 0,
web_frame, js_context, js_window);
}
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
/*
static void
midori_web_view_news_feed_ready_cb (MidoriWebView* web_view,
const gchar* href,
const gchar* type,
const gchar* title,
Revamp the loading signals of MidoriWebView
2008-07-23 15:54:24 +00:00
MidoriBrowser* browser)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
if (web_view == (MidoriWebView*)midori_browser_get_current_web_view (browser))
midori_location_action_set_secondary_icon (MIDORI_LOCATION_ACTION (
_action_by_name (browser, "Location")), STOCK_NEWS_FEED);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
*/
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static void
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
midori_view_notify_title_cb (GtkWidget* view,
GParamSpec* pspec,
MidoriBrowser* browser)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
const gchar* uri;
const gchar* title;
GtkAction* action;
gchar* window_title;
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
KatzeItem* item;
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
uri = midori_view_get_display_uri (MIDORI_VIEW (view));
title = midori_view_get_display_title (MIDORI_VIEW (view));
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
action = _action_by_name (browser, "Location");
Implement the Remeber last visited pages preference
2008-10-13 16:29:46 +00:00
if (sokoke_object_get_boolean (browser->settings, "remember-last-visited-pages"))
midori_location_action_set_title_for_uri (
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
MIDORI_LOCATION_ACTION (action), title, uri);
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
if (midori_view_get_load_status (MIDORI_VIEW (view)) == MIDORI_LOAD_COMMITTED)
{
if (!browser->history)
return;
item = katze_item_new ();
katze_item_set_uri (item, uri);
katze_item_set_name (item, title);
midori_browser_new_history_item (browser, item);
}
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
if (view == midori_browser_get_current_tab (browser))
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
window_title = g_strconcat (title, " - ",
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
g_get_application_name (), NULL);
gtk_window_set_title (GTK_WINDOW (browser), window_title);
g_free (window_title);
}
}
Toggle ZoomReset as the zoom level changes
2008-07-21 23:51:08 +00:00
static void
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
midori_view_notify_zoom_level_cb (GtkWidget* view,
GParamSpec* pspec,
MidoriBrowser* browser)
Toggle ZoomReset as the zoom level changes
2008-07-21 23:51:08 +00:00
{
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
if (view == midori_browser_get_current_tab (browser))
Toggle ZoomReset as the zoom level changes
2008-07-21 23:51:08 +00:00
_action_set_sensitive (browser, "ZoomNormal",
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
midori_view_get_zoom_level (MIDORI_VIEW (view)) != 1.0);
Load favicons asynchronously
2008-07-19 02:06:10 +00:00
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static void
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
midori_view_notify_statusbar_text_cb (MidoriView* view,
GParamSpec* pspec,
MidoriBrowser* browser)
Reverse Open tabs in the background with Ctrl
2008-07-16 16:08:47 +00:00
{
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
gchar* text;
Reverse Open tabs in the background with Ctrl
2008-07-16 16:08:47 +00:00
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
g_object_get (view, "statusbar-text", &text, NULL);
_midori_browser_set_statusbar_text (browser, text);
g_free (text);
Reverse Open tabs in the background with Ctrl
2008-07-16 16:08:47 +00:00
}
Add a Bookmark Add item to the link context menu.
2008-06-15 11:29:30 +00:00
static void
midori_browser_edit_bookmark_dialog_new (MidoriBrowser* browser,
Allow adding bookmarks from history items
2008-10-29 02:43:08 +00:00
KatzeItem* bookmark,
gboolean new_bookmark)
Add a Bookmark Add item to the link context menu.
2008-06-15 11:29:30 +00:00
{
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
GtkWidget* dialog;
GtkSizeGroup* sizegroup;
GtkWidget* view;
GtkWidget* hbox;
GtkWidget* label;
const gchar* value;
GtkWidget* entry_title;
GtkWidget* entry_desc;
GtkWidget* entry_uri;
GtkWidget* combo_folder;
GtkTreeView* treeview;
GtkTreeModel* treemodel;
GtkTreeIter iter;
dialog = gtk_dialog_new_with_buttons (
Add a Bookmark Add item to the link context menu.
2008-06-15 11:29:30 +00:00
new_bookmark ? _("New bookmark") : _("Edit bookmark"),
GTK_WINDOW (browser),
GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_NO_SEPARATOR,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
new_bookmark ? GTK_STOCK_ADD : GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
gtk_window_set_icon_name (GTK_WINDOW (dialog),
new_bookmark ? GTK_STOCK_ADD : GTK_STOCK_REMOVE);
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), 5);
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
sizegroup = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
Add a Bookmark Add item to the link context menu.
2008-06-15 11:29:30 +00:00
Allow adding bookmarks from history items
2008-10-29 02:43:08 +00:00
if (!bookmark)
Add a Bookmark Add item to the link context menu.
2008-06-15 11:29:30 +00:00
{
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
view = midori_browser_get_current_tab (browser);
bookmark = g_object_new (KATZE_TYPE_ITEM,
"uri", midori_view_get_display_uri (MIDORI_VIEW (view)),
"name", midori_view_get_display_title (MIDORI_VIEW (view)), NULL);
Add a Bookmark Add item to the link context menu.
2008-06-15 11:29:30 +00:00
}
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
hbox = gtk_hbox_new (FALSE, 8);
Add a Bookmark Add item to the link context menu.
2008-06-15 11:29:30 +00:00
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
label = gtk_label_new_with_mnemonic (_("_Title:"));
Add a Bookmark Add item to the link context menu.
2008-06-15 11:29:30 +00:00
gtk_size_group_add_widget (sizegroup, label);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
entry_title = gtk_entry_new ();
Add a Bookmark Add item to the link context menu.
2008-06-15 11:29:30 +00:00
gtk_entry_set_activates_default (GTK_ENTRY (entry_title), TRUE);
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
value = katze_item_get_name (bookmark);
gtk_entry_set_text (GTK_ENTRY (entry_title), value ? value : "");
Add a Bookmark Add item to the link context menu.
2008-06-15 11:29:30 +00:00
gtk_box_pack_start (GTK_BOX (hbox), entry_title, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), hbox);
gtk_widget_show_all (hbox);
hbox = gtk_hbox_new (FALSE, 8);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
label = gtk_label_new_with_mnemonic (_("_Description:"));
gtk_size_group_add_widget (sizegroup, label);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
entry_desc = gtk_entry_new ();
Add a Bookmark Add item to the link context menu.
2008-06-15 11:29:30 +00:00
gtk_entry_set_activates_default (GTK_ENTRY (entry_desc), TRUE);
Allow adding bookmarks from history items
2008-10-29 02:43:08 +00:00
if (bookmark)
Add a Bookmark Add item to the link context menu.
2008-06-15 11:29:30 +00:00
{
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
value = katze_item_get_text (bookmark);
gtk_entry_set_text (GTK_ENTRY (entry_desc), value ? value : "");
Add a Bookmark Add item to the link context menu.
2008-06-15 11:29:30 +00:00
}
gtk_box_pack_start (GTK_BOX (hbox), entry_desc, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), hbox);
gtk_widget_show_all (hbox);
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
entry_uri = NULL;
if (!KATZE_IS_ARRAY (bookmark))
Add a Bookmark Add item to the link context menu.
2008-06-15 11:29:30 +00:00
{
hbox = gtk_hbox_new (FALSE, 8);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
label = gtk_label_new_with_mnemonic (_("_URL:"));
gtk_size_group_add_widget (sizegroup, label);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
entry_uri = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (entry_uri), TRUE);
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
gtk_entry_set_text (GTK_ENTRY (entry_uri), katze_item_get_uri (bookmark));
Show progress in location entry if statusbar is hidden
2008-08-31 00:45:13 +00:00
gtk_box_pack_start (GTK_BOX (hbox), entry_uri, TRUE, TRUE, 0);
Add a Bookmark Add item to the link context menu.
2008-06-15 11:29:30 +00:00
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), hbox);
gtk_widget_show_all (hbox);
}
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
combo_folder = NULL;
Add a Bookmark Add item to the link context menu.
2008-06-15 11:29:30 +00:00
if (new_bookmark)
{
hbox = gtk_hbox_new (FALSE, 8);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
label = gtk_label_new_with_mnemonic (_("_Folder:"));
gtk_size_group_add_widget (sizegroup, label);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
combo_folder = gtk_combo_box_new_text ();
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_folder), _("Root"));
gtk_widget_set_sensitive (combo_folder, FALSE);
gtk_box_pack_start (GTK_BOX (hbox), combo_folder, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), hbox);
gtk_widget_show_all (hbox);
}
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_ACCEPT);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
katze_item_set_name (bookmark,
Add a Bookmark Add item to the link context menu.
2008-06-15 11:29:30 +00:00
gtk_entry_get_text (GTK_ENTRY (entry_title)));
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
katze_item_set_text (bookmark,
Show progress in location entry if statusbar is hidden
2008-08-31 00:45:13 +00:00
gtk_entry_get_text (GTK_ENTRY (entry_desc)));
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
if (!KATZE_IS_ARRAY (bookmark))
katze_item_set_uri (bookmark,
Add a Bookmark Add item to the link context menu.
2008-06-15 11:29:30 +00:00
gtk_entry_get_text (GTK_ENTRY (entry_uri)));
/* FIXME: We want to choose a folder */
if (new_bookmark)
{
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
katze_array_add_item (browser->bookmarks, bookmark);
treeview = GTK_TREE_VIEW (browser->panel_bookmarks);
treemodel = gtk_tree_view_get_model (treeview);
Add a Bookmark Add item to the link context menu.
2008-06-15 11:29:30 +00:00
gtk_tree_store_insert_with_values (GTK_TREE_STORE (treemodel),
&iter, NULL, G_MAXINT, 0, bookmark, -1);
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
g_object_ref (bookmark);
Add a Bookmark Add item to the link context menu.
2008-06-15 11:29:30 +00:00
}
/* FIXME: Update panel in other windows */
}
gtk_widget_destroy (dialog);
}
static void
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
midori_view_add_bookmark_cb (GtkWidget* menuitem,
const gchar* uri,
GtkWidget* view)
Add a Bookmark Add item to the link context menu.
2008-06-15 11:29:30 +00:00
{
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
KatzeItem* item;
Add a Bookmark Add item to the link context menu.
2008-06-15 11:29:30 +00:00
MidoriBrowser* browser;
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
item = katze_item_new ();
katze_item_set_uri (item, uri);
Add a Bookmark Add item to the link context menu.
2008-06-15 11:29:30 +00:00
browser = (MidoriBrowser*)gtk_widget_get_toplevel (menuitem);
Allow adding bookmarks from history items
2008-10-29 02:43:08 +00:00
midori_browser_edit_bookmark_dialog_new (browser, item, FALSE);
Add a Bookmark Add item to the link context menu.
2008-06-15 11:29:30 +00:00
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static gboolean
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
midori_browser_tab_leave_notify_event_cb (GtkWidget* widget,
GdkEventCrossing* event,
MidoriBrowser* browser)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
_midori_browser_set_statusbar_text (browser, NULL);
return TRUE;
}
static void
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
midori_view_activate_action_cb (GtkWidget* view,
const gchar* action,
MidoriBrowser* browser)
{
_midori_browser_activate_action (browser, action);
}
static void
midori_view_console_message_cb (GtkWidget* view,
const gchar* message,
gint line,
const gchar* source_id,
MidoriBrowser* browser)
{
midori_console_add (MIDORI_CONSOLE (browser->panel_console),
message, line, source_id);
}
Initial support for the Web Inspector
2008-11-01 18:15:58 +00:00
static void
midori_view_attach_inspector_cb (GtkWidget* view,
GtkWidget* inspector_view,
MidoriBrowser* browser)
{
GtkWidget* scrolled = gtk_widget_get_parent (browser->inspector_view);
gtk_container_remove (GTK_CONTAINER (scrolled), browser->inspector_view);
gtk_container_add (GTK_CONTAINER (scrolled), inspector_view);
browser->inspector_view = inspector_view;
}
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
static void
midori_view_new_tab_cb (GtkWidget* view,
const gchar* uri,
Reimplement missing preferences Implement font properties, web features, Middle click opens selection, Open tabs in the background and proxy. While we are at it, remove Tab label size.
2008-10-02 22:49:16 +00:00
gboolean background,
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
MidoriBrowser* browser)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Provide action signals as javascript functions From javscript C functions cannot be called, but signals are available through the GObject type system. So we allow javascript to call action signals like functions. At the same time we modify a few browser functions, so that they are functions that are available as signals.
2008-05-31 22:21:08 +00:00
gint n = midori_browser_add_uri (browser, uri);
Reimplement missing preferences Implement font properties, web features, Middle click opens selection, Open tabs in the background and proxy. While we are at it, remove Tab label size.
2008-10-02 22:49:16 +00:00
if (!background)
midori_browser_set_current_page (browser, n);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
static void
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
midori_view_new_window_cb (GtkWidget* view,
const gchar* uri,
MidoriBrowser* browser)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
g_signal_emit (browser, signals[NEW_WINDOW], 0, uri);
}
Make Find work again, and disable it for source tabs
2008-09-28 14:29:41 +00:00
static void
midori_view_search_text_cb (GtkWidget* view,
gboolean found,
MidoriBrowser* browser)
{
const gchar* text;
gboolean case_sensitive;
gboolean highlight;
if (GTK_WIDGET_VISIBLE (browser->find))
{
gtk_icon_entry_set_icon_from_stock (GTK_ICON_ENTRY (browser->find_text),
GTK_ICON_ENTRY_PRIMARY, (found) ? GTK_STOCK_FIND : GTK_STOCK_STOP);
text = gtk_entry_get_text (GTK_ENTRY (browser->find_text));
case_sensitive = gtk_toggle_tool_button_get_active (
GTK_TOGGLE_TOOL_BUTTON (browser->find_case));
midori_view_mark_text_matches (MIDORI_VIEW (view), text, case_sensitive);
highlight = gtk_toggle_tool_button_get_active (
GTK_TOGGLE_TOOL_BUTTON (browser->find_highlight));
midori_view_set_highlight_text_matches (MIDORI_VIEW (view), highlight);
}
}
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
static gboolean
midori_browser_tab_destroy_cb (GtkWidget* widget,
MidoriBrowser* browser)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
KatzeItem* item;
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
const gchar* uri;
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
if (browser->proxy_array && MIDORI_IS_VIEW (widget))
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
item = midori_view_get_proxy_item (MIDORI_VIEW (widget));
uri = katze_item_get_uri (item);
Prevent blank pages from landing in the trash This actually used to work but meanwhile the definition of a blank view changed.
2008-10-10 20:50:56 +00:00
if (browser->trash && !midori_view_is_blank (MIDORI_VIEW (widget)))
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
katze_array_add_item (browser->trash, item);
katze_array_remove_item (browser->proxy_array, item);
g_object_unref (item);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
_midori_browser_update_actions (browser);
Ensure REMOVE_TAB emission, don't alter session when destroying
2008-07-25 10:45:50 +00:00
/* This callback must only be called once, but we need to ensure
that "remove-tab" is emitted in any case */
g_signal_handlers_disconnect_by_func (widget,
midori_browser_tab_destroy_cb, browser);
g_signal_emit (browser, signals[REMOVE_TAB], 0, widget);
Add Always Show Tabbar preference
2008-10-03 23:45:17 +00:00
/* We don't ever want to be in a situation with no tabs,
Finish refactoring the toolbar to use only actions Finally the trash, which was the last item that needed to be implemented as an action, is an action, a KatzeArrayAction to be exact. This simplifies more code and also makes Window and RecentlyVisited generically implementable. Incidentally this change also fixes a bug where the browser tried to add a new tab when the last one was closed, even while destroying itself. Furthermore sokoke_image_menu_item_ellipsized and sokoke_widget_popup were promoted to Katze. We're still keeping the old functions for now.
2008-10-10 20:31:37 +00:00
so just create an empty one if the last one is closed.
The only exception is when we are closing the window,
which is indicated by the proxy array having been unset. */
if (browser->proxy_array && !midori_browser_get_current_tab (browser))
Add Always Show Tabbar preference
2008-10-03 23:45:17 +00:00
midori_browser_add_uri (browser, "");
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
return FALSE;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
Save the session whenever it changes, instead of on quit.
2008-07-23 18:17:13 +00:00
static void
Complete move of webSearch, third step of refactoring web search
2008-06-15 02:02:56 +00:00
_midori_browser_add_tab (MidoriBrowser* browser,
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
GtkWidget* view)
Complete move of webSearch, third step of refactoring web search
2008-06-15 02:02:56 +00:00
{
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
GtkWidget* tab_label;
KatzeItem* item;
Complete move of webSearch, third step of refactoring web search
2008-06-15 02:02:56 +00:00
guint n;
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (view),
Complete move of webSearch, third step of refactoring web search
2008-06-15 02:02:56 +00:00
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
GTK_WIDGET_SET_FLAGS (view, GTK_CAN_FOCUS);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (view),
Remove inner border between scrollbars and window border
2008-07-23 12:42:27 +00:00
GTK_SHADOW_ETCHED_IN);
Complete move of webSearch, third step of refactoring web search
2008-06-15 02:02:56 +00:00
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
tab_label = midori_view_get_proxy_tab_label (MIDORI_VIEW (view));
Finish refactoring the toolbar to use only actions Finally the trash, which was the last item that needed to be implemented as an action, is an action, a KatzeArrayAction to be exact. This simplifies more code and also makes Window and RecentlyVisited generically implementable. Incidentally this change also fixes a bug where the browser tried to add a new tab when the last one was closed, even while destroying itself. Furthermore sokoke_image_menu_item_ellipsized and sokoke_widget_popup were promoted to Katze. We're still keeping the old functions for now.
2008-10-10 20:31:37 +00:00
item = midori_view_get_proxy_item (MIDORI_VIEW (view));
g_object_ref (item);
katze_array_add_item (browser->proxy_array, item);
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
g_object_connect (view,
"signal::notify::icon",
midori_view_notify_icon_cb, browser,
"signal::notify::load-status",
midori_view_notify_load_status_cb, browser,
"signal::notify::progress",
midori_view_notify_progress_cb, browser,
Undo tabs-in-processes, it didn't work out We are not literally undoing in the sense of reverting, this is actually about undoing the individual parts of the last refactoring that implemented the socket/ plug logic. As turned out, the idea was nice but the implementation was absolutely not, embedding of processes in a graphical way is not at all reliable enough for complex use cases. Naturally this change should solve all sorts of peculiar issues, including actual regressions in functionality. Relieving.
2008-10-15 01:07:38 +00:00
"signal::window-object-cleared",
midori_view_window_object_cleared_cb, browser,
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
/* "signal::news-feed-ready",
midori_view_news_feed_ready_cb, browser, */
"signal::notify::title",
midori_view_notify_title_cb, browser,
"signal::notify::zoom-level",
midori_view_notify_zoom_level_cb, browser,
"signal::notify::statusbar-text",
midori_view_notify_statusbar_text_cb, browser,
"signal::activate-action",
midori_view_activate_action_cb, browser,
"signal::console-message",
midori_view_console_message_cb, browser,
Initial support for the Web Inspector
2008-11-01 18:15:58 +00:00
"signal::attach-inspector",
midori_view_attach_inspector_cb, browser,
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
"signal::new-tab",
midori_view_new_tab_cb, browser,
"signal::new-window",
midori_view_new_window_cb, browser,
Make Find work again, and disable it for source tabs
2008-09-28 14:29:41 +00:00
"signal::search-text",
midori_view_search_text_cb, browser,
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
"signal::add-bookmark",
midori_view_add_bookmark_cb, browser,
NULL);
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
g_signal_connect (view, "leave-notify-event",
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
G_CALLBACK (midori_browser_tab_leave_notify_event_cb), browser);
Introduce Open Tabs next to Current At the same time make Open popups in tabs readonly and hide it in the Preferences, as well as Open new pages in and the whole Privacy page.
2008-08-15 18:38:27 +00:00
if (sokoke_object_get_boolean (browser->settings, "open-tabs-next-to-current"))
{
n = gtk_notebook_get_current_page (GTK_NOTEBOOK (browser->notebook));
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
gtk_notebook_insert_page (GTK_NOTEBOOK (browser->notebook), view,
tab_label, n + 1);
Introduce Open Tabs next to Current At the same time make Open popups in tabs readonly and hide it in the Preferences, as well as Open new pages in and the whole Privacy page.
2008-08-15 18:38:27 +00:00
}
else
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
gtk_notebook_append_page (GTK_NOTEBOOK (browser->notebook), view,
tab_label);
Introduce Open Tabs next to Current At the same time make Open popups in tabs readonly and hide it in the Preferences, as well as Open new pages in and the whole Privacy page.
2008-08-15 18:38:27 +00:00
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_notebook_set_tab_reorderable (GTK_NOTEBOOK (browser->notebook),
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
view, TRUE);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_notebook_set_tab_detachable (GTK_NOTEBOOK (browser->notebook),
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
view, TRUE);
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
/* We want the tab to be removed if the widget is destroyed */
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
g_signal_connect (view, "destroy",
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
G_CALLBACK (midori_browser_tab_destroy_cb), browser);
Complete move of webSearch, third step of refactoring web search
2008-06-15 02:02:56 +00:00
_midori_browser_update_actions (browser);
}
Save the session whenever it changes, instead of on quit.
2008-07-23 18:17:13 +00:00
static void
_midori_browser_remove_tab (MidoriBrowser* browser,
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
GtkWidget* view)
Complete move of webSearch, third step of refactoring web search
2008-06-15 02:02:56 +00:00
{
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
gtk_widget_destroy (view);
Complete move of webSearch, third step of refactoring web search
2008-06-15 02:02:56 +00:00
}
static void
_midori_browser_quit (MidoriBrowser* browser)
Fix segfault on quit, improve app and browser interface
2008-06-07 23:25:57 +00:00
{
Introduce MidoriWebList, second step of refactoring web search
2008-06-14 00:23:33 +00:00
/* Nothing to do */
Fix segfault on quit, improve app and browser interface
2008-06-07 23:25:57 +00:00
}
Initial addon panel feature, only userscripts for now.
2008-04-28 20:38:57 +00:00
static void
midori_cclosure_marshal_VOID__OBJECT_POINTER_POINTER (GClosure* closure,
GValue* return_value,
guint n_param_values,
const GValue* param_values,
gpointer invocation_hint,
gpointer marshal_data)
{
typedef gboolean(*GMarshalFunc_VOID__OBJECT_POINTER_POINTER) (gpointer data1,
gpointer arg_1,
gpointer arg_2,
gpointer arg_3,
gpointer data2);
register GMarshalFunc_VOID__OBJECT_POINTER_POINTER callback;
register GCClosure* cc = (GCClosure*) closure;
register gpointer data1, data2;
g_return_if_fail (n_param_values == 4);
if (G_CCLOSURE_SWAP_DATA (closure))
{
data1 = closure->data;
data2 = g_value_peek_pointer (param_values + 0);
}
else
{
data1 = g_value_peek_pointer (param_values + 0);
data2 = closure->data;
}
callback = (GMarshalFunc_VOID__OBJECT_POINTER_POINTER) (marshal_data
? marshal_data : cc->callback);
callback (data1,
g_value_get_object (param_values + 1),
g_value_get_pointer (param_values + 2),
g_value_get_pointer (param_values + 3),
data2);
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static void
midori_browser_class_init (MidoriBrowserClass* class)
{
Improve OSX adjustments in various places
2008-10-25 22:54:57 +00:00
GObjectClass* gobject_class;
GParamFlags flags;
Initial addon panel feature, only userscripts for now.
2008-04-28 20:38:57 +00:00
signals[WINDOW_OBJECT_CLEARED] = g_signal_new (
"window-object-cleared",
G_TYPE_FROM_CLASS (class),
Implement MidoriApp singleton and improve multiple window support The new singleton holds the shared settings and trash. It is further more used to keep track of all open windows and quits when the last window was closed. It also watches the focus in case you need something like a "current" browser.
2008-05-22 22:17:10 +00:00
(GSignalFlags)(G_SIGNAL_RUN_LAST),
Initial addon panel feature, only userscripts for now.
2008-04-28 20:38:57 +00:00
G_STRUCT_OFFSET (MidoriBrowserClass, window_object_cleared),
0,
NULL,
midori_cclosure_marshal_VOID__OBJECT_POINTER_POINTER,
G_TYPE_NONE, 3,
WEBKIT_TYPE_WEB_FRAME,
G_TYPE_POINTER,
G_TYPE_POINTER);
Provide action signals as javascript functions From javscript C functions cannot be called, but signals are available through the GObject type system. So we allow javascript to call action signals like functions. At the same time we modify a few browser functions, so that they are functions that are available as signals.
2008-05-31 22:21:08 +00:00
signals[NEW_WINDOW] = g_signal_new (
"new-window",
G_TYPE_FROM_CLASS (class),
(GSignalFlags)(G_SIGNAL_RUN_LAST),
G_STRUCT_OFFSET (MidoriBrowserClass, new_window),
0,
NULL,
g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE, 1,
G_TYPE_STRING);
signals[ADD_TAB] = g_signal_new (
"add-tab",
Fix panel close button.
2008-03-24 13:15:23 +00:00
G_TYPE_FROM_CLASS (class),
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
(GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
Provide action signals as javascript functions From javscript C functions cannot be called, but signals are available through the GObject type system. So we allow javascript to call action signals like functions. At the same time we modify a few browser functions, so that they are functions that are available as signals.
2008-05-31 22:21:08 +00:00
G_STRUCT_OFFSET (MidoriBrowserClass, add_tab),
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
0,
Provide action signals as javascript functions From javscript C functions cannot be called, but signals are available through the GObject type system. So we allow javascript to call action signals like functions. At the same time we modify a few browser functions, so that they are functions that are available as signals.
2008-05-31 22:21:08 +00:00
NULL,
Save the session whenever it changes, instead of on quit.
2008-07-23 18:17:13 +00:00
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
Provide action signals as javascript functions From javscript C functions cannot be called, but signals are available through the GObject type system. So we allow javascript to call action signals like functions. At the same time we modify a few browser functions, so that they are functions that are available as signals.
2008-05-31 22:21:08 +00:00
GTK_TYPE_WIDGET);
Save the session whenever it changes, instead of on quit.
2008-07-23 18:17:13 +00:00
signals[REMOVE_TAB] = g_signal_new (
"remove-tab",
Provide action signals as javascript functions From javscript C functions cannot be called, but signals are available through the GObject type system. So we allow javascript to call action signals like functions. At the same time we modify a few browser functions, so that they are functions that are available as signals.
2008-05-31 22:21:08 +00:00
G_TYPE_FROM_CLASS (class),
(GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
Save the session whenever it changes, instead of on quit.
2008-07-23 18:17:13 +00:00
G_STRUCT_OFFSET (MidoriBrowserClass, remove_tab),
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
0,
NULL,
Save the session whenever it changes, instead of on quit.
2008-07-23 18:17:13 +00:00
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
GTK_TYPE_WIDGET);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Provide action signals as javascript functions From javscript C functions cannot be called, but signals are available through the GObject type system. So we allow javascript to call action signals like functions. At the same time we modify a few browser functions, so that they are functions that are available as signals.
2008-05-31 22:21:08 +00:00
signals[ACTIVATE_ACTION] = g_signal_new (
"activate-action",
Fix panel close button.
2008-03-24 13:15:23 +00:00
G_TYPE_FROM_CLASS (class),
Provide action signals as javascript functions From javscript C functions cannot be called, but signals are available through the GObject type system. So we allow javascript to call action signals like functions. At the same time we modify a few browser functions, so that they are functions that are available as signals.
2008-05-31 22:21:08 +00:00
(GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
G_STRUCT_OFFSET (MidoriBrowserClass, activate_action),
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
0,
NULL,
g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE, 1,
G_TYPE_STRING);
Provide action signals as javascript functions From javscript C functions cannot be called, but signals are available through the GObject type system. So we allow javascript to call action signals like functions. At the same time we modify a few browser functions, so that they are functions that are available as signals.
2008-05-31 22:21:08 +00:00
signals[QUIT] = g_signal_new (
"quit",
G_TYPE_FROM_CLASS (class),
(GSignalFlags)(G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION),
G_STRUCT_OFFSET (MidoriBrowserClass, quit),
0,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
Complete move of webSearch, third step of refactoring web search
2008-06-15 02:02:56 +00:00
class->add_tab = _midori_browser_add_tab;
Save the session whenever it changes, instead of on quit.
2008-07-23 18:17:13 +00:00
class->remove_tab = _midori_browser_remove_tab;
Complete move of webSearch, third step of refactoring web search
2008-06-15 02:02:56 +00:00
class->activate_action = _midori_browser_activate_action;
class->quit = _midori_browser_quit;
Provide action signals as javascript functions From javscript C functions cannot be called, but signals are available through the GObject type system. So we allow javascript to call action signals like functions. At the same time we modify a few browser functions, so that they are functions that are available as signals.
2008-05-31 22:21:08 +00:00
Improve OSX adjustments in various places
2008-10-25 22:54:57 +00:00
gobject_class = G_OBJECT_CLASS (class);
Ensure REMOVE_TAB emission, don't alter session when destroying
2008-07-25 10:45:50 +00:00
gobject_class->dispose = midori_browser_dispose;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
gobject_class->finalize = midori_browser_finalize;
gobject_class->set_property = midori_browser_set_property;
gobject_class->get_property = midori_browser_get_property;
Improve OSX adjustments in various places
2008-10-25 22:54:57 +00:00
flags = G_PARAM_READWRITE | G_PARAM_CONSTRUCT;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
g_object_class_install_property (gobject_class,
PROP_MENUBAR,
g_param_spec_object (
"menubar",
Do not localize object properties, except WebSettings Property name localization is only useful if the strings are meant to be used in a user interface, such as is the case with WebSettings, or for graphical interface builders, which are not of our concern, since we don't use Glade and friends and nobody else is going to use our widgets. In short, make translation work much easier.
2008-10-15 01:32:11 +00:00
"Menubar",
"The menubar",
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
GTK_TYPE_MENU_BAR,
G_PARAM_READABLE));
g_object_class_install_property (gobject_class,
PROP_NAVIGATIONBAR,
g_param_spec_object (
"navigationbar",
Do not localize object properties, except WebSettings Property name localization is only useful if the strings are meant to be used in a user interface, such as is the case with WebSettings, or for graphical interface builders, which are not of our concern, since we don't use Glade and friends and nobody else is going to use our widgets. In short, make translation work much easier.
2008-10-15 01:32:11 +00:00
"Navigationbar",
"The navigationbar",
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
GTK_TYPE_TOOLBAR,
G_PARAM_READABLE));
Save the session whenever it changes, instead of on quit.
2008-07-23 18:17:13 +00:00
g_object_class_install_property (gobject_class,
PROP_URI,
g_param_spec_string (
"uri",
Do not localize object properties, except WebSettings Property name localization is only useful if the strings are meant to be used in a user interface, such as is the case with WebSettings, or for graphical interface builders, which are not of our concern, since we don't use Glade and friends and nobody else is going to use our widgets. In short, make translation work much easier.
2008-10-15 01:32:11 +00:00
"URI",
"The current URI",
Save the session whenever it changes, instead of on quit.
2008-07-23 18:17:13 +00:00
"about:blank",
G_PARAM_READWRITE));
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
g_object_class_install_property (gobject_class,
PROP_TAB,
g_param_spec_object (
"tab",
Do not localize object properties, except WebSettings Property name localization is only useful if the strings are meant to be used in a user interface, such as is the case with WebSettings, or for graphical interface builders, which are not of our concern, since we don't use Glade and friends and nobody else is going to use our widgets. In short, make translation work much easier.
2008-10-15 01:32:11 +00:00
"Tab",
"The current tab",
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
GTK_TYPE_WIDGET,
G_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_STATUSBAR,
g_param_spec_object (
"statusbar",
Do not localize object properties, except WebSettings Property name localization is only useful if the strings are meant to be used in a user interface, such as is the case with WebSettings, or for graphical interface builders, which are not of our concern, since we don't use Glade and friends and nobody else is going to use our widgets. In short, make translation work much easier.
2008-10-15 01:32:11 +00:00
"Statusbar",
"The statusbar",
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
GTK_TYPE_STATUSBAR,
G_PARAM_READABLE));
Make bookmarks a property of browser and app This means we have removed the last remaining global variable.
2008-09-03 00:28:54 +00:00
/**
* MidoriBrowser:statusbar-text:
*
* The text that is displayed in the statusbar.
*
* This value reflects changes to the text visible in the statusbar, such
* as the uri of a hyperlink the mouse hovers over or the description of
* a menuitem.
*
* Setting this value changes the displayed text until the next change.
*/
g_object_class_install_property (gobject_class,
PROP_STATUSBAR_TEXT,
g_param_spec_string (
"statusbar-text",
Do not localize object properties, except WebSettings Property name localization is only useful if the strings are meant to be used in a user interface, such as is the case with WebSettings, or for graphical interface builders, which are not of our concern, since we don't use Glade and friends and nobody else is going to use our widgets. In short, make translation work much easier.
2008-10-15 01:32:11 +00:00
"Statusbar Text",
"The text that is displayed in the statusbar",
Make bookmarks a property of browser and app This means we have removed the last remaining global variable.
2008-09-03 00:28:54 +00:00
"",
flags));
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
/**
Provide action signals as javascript functions From javscript C functions cannot be called, but signals are available through the GObject type system. So we allow javascript to call action signals like functions. At the same time we modify a few browser functions, so that they are functions that are available as signals.
2008-05-31 22:21:08 +00:00
* MidoriBrowser:settings:
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
*
* An associated settings instance that is shared among all web views.
*
* Setting this value is propagated to every present web view. Also
* every newly created web view will use this instance automatically.
Make bookmarks a property of browser and app This means we have removed the last remaining global variable.
2008-09-03 00:28:54 +00:00
*
* If no settings are specified a default will be used.
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
*/
g_object_class_install_property (gobject_class,
PROP_SETTINGS,
g_param_spec_object (
"settings",
Do not localize object properties, except WebSettings Property name localization is only useful if the strings are meant to be used in a user interface, such as is the case with WebSettings, or for graphical interface builders, which are not of our concern, since we don't use Glade and friends and nobody else is going to use our widgets. In short, make translation work much easier.
2008-10-15 01:32:11 +00:00
"Settings",
"The associated settings",
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
MIDORI_TYPE_WEB_SETTINGS,
G_PARAM_READWRITE));
/**
Make bookmarks a property of browser and app This means we have removed the last remaining global variable.
2008-09-03 00:28:54 +00:00
* MidoriBrowser:bookmarks:
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
*
Make bookmarks a property of browser and app This means we have removed the last remaining global variable.
2008-09-03 00:28:54 +00:00
* The bookmarks folder, containing all bookmarks.
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
*
Make bookmarks a property of browser and app This means we have removed the last remaining global variable.
2008-09-03 00:28:54 +00:00
* This is actually a reference to a bookmarks instance,
* so if bookmarks should be used it must be initially set.
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
*/
g_object_class_install_property (gobject_class,
Make bookmarks a property of browser and app This means we have removed the last remaining global variable.
2008-09-03 00:28:54 +00:00
PROP_BOOKMARKS,
g_param_spec_object (
"bookmarks",
Do not localize object properties, except WebSettings Property name localization is only useful if the strings are meant to be used in a user interface, such as is the case with WebSettings, or for graphical interface builders, which are not of our concern, since we don't use Glade and friends and nobody else is going to use our widgets. In short, make translation work much easier.
2008-10-15 01:32:11 +00:00
"Bookmarks",
"The bookmarks folder, containing all bookmarks",
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
KATZE_TYPE_ARRAY,
Make bookmarks a property of browser and app This means we have removed the last remaining global variable.
2008-09-03 00:28:54 +00:00
G_PARAM_READWRITE));
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
/**
Provide action signals as javascript functions From javscript C functions cannot be called, but signals are available through the GObject type system. So we allow javascript to call action signals like functions. At the same time we modify a few browser functions, so that they are functions that are available as signals.
2008-05-31 22:21:08 +00:00
* MidoriBrowser:trash:
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
*
* The trash, that collects all closed tabs and windows.
*
* This is actually a reference to a trash instance, so if a trash should
* be used it must be initially set.
*
* Note: In the future the trash might collect other types of items.
*/
g_object_class_install_property (gobject_class,
PROP_TRASH,
g_param_spec_object (
"trash",
Do not localize object properties, except WebSettings Property name localization is only useful if the strings are meant to be used in a user interface, such as is the case with WebSettings, or for graphical interface builders, which are not of our concern, since we don't use Glade and friends and nobody else is going to use our widgets. In short, make translation work much easier.
2008-10-15 01:32:11 +00:00
"Trash",
"The trash, collecting recently closed tabs and windows",
Rework MidoriWebList into KatzeList and KatzeArray
2008-08-25 23:19:38 +00:00
KATZE_TYPE_ARRAY,
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
G_PARAM_READWRITE));
Complete move of webSearch, third step of refactoring web search
2008-06-15 02:02:56 +00:00
/**
* MidoriBrowser:search-engines:
*
* The list of search engines to be used for web search.
Make bookmarks a property of browser and app This means we have removed the last remaining global variable.
2008-09-03 00:28:54 +00:00
*
* This is actually a reference to a search engines instance,
* so if search engines should be used it must be initially set.
Complete move of webSearch, third step of refactoring web search
2008-06-15 02:02:56 +00:00
*/
g_object_class_install_property (gobject_class,
PROP_SEARCH_ENGINES,
g_param_spec_object (
"search-engines",
Do not localize object properties, except WebSettings Property name localization is only useful if the strings are meant to be used in a user interface, such as is the case with WebSettings, or for graphical interface builders, which are not of our concern, since we don't use Glade and friends and nobody else is going to use our widgets. In short, make translation work much easier.
2008-10-15 01:32:11 +00:00
"Search Engines",
"The list of search engines to be used for web search",
Rework MidoriWebList into KatzeList and KatzeArray
2008-08-25 23:19:38 +00:00
KATZE_TYPE_ARRAY,
Complete move of webSearch, third step of refactoring web search
2008-06-15 02:02:56 +00:00
G_PARAM_READWRITE));
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
/**
* MidoriBrowser:history:
*
* The list of history items.
*
* This is actually a reference to a history instance,
* so if history should be used it must be initially set.
*/
g_object_class_install_property (gobject_class,
PROP_HISTORY,
g_param_spec_object (
"history",
Do not localize object properties, except WebSettings Property name localization is only useful if the strings are meant to be used in a user interface, such as is the case with WebSettings, or for graphical interface builders, which are not of our concern, since we don't use Glade and friends and nobody else is going to use our widgets. In short, make translation work much easier.
2008-10-15 01:32:11 +00:00
"History",
"The list of history items",
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
KATZE_TYPE_ARRAY,
G_PARAM_READWRITE));
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
static void
_action_window_new_activate (GtkAction* action,
MidoriBrowser* browser)
{
The location is empty and focused by default When a new tab is opened it won't default to about:blank but be empty and also gain focus automatically.
2008-03-30 14:55:46 +00:00
g_signal_emit (browser, signals[NEW_WINDOW], 0, "");
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
static void
_action_tab_new_activate (GtkAction* action,
MidoriBrowser* browser)
{
Provide action signals as javascript functions From javscript C functions cannot be called, but signals are available through the GObject type system. So we allow javascript to call action signals like functions. At the same time we modify a few browser functions, so that they are functions that are available as signals.
2008-05-31 22:21:08 +00:00
gint n = midori_browser_add_uri (browser, "");
Attempt to fix handling of background and foreground tabs.
2008-04-24 22:20:43 +00:00
midori_browser_set_current_page (browser, n);
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
gtk_action_activate (_action_by_name (browser, "Location"));
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
static void
_action_open_activate (GtkAction* action,
MidoriBrowser* browser)
{
Remember the last opened folder for File Open The File Open dialog should remember the last opened folder or try to obtain it from the currently opened web view. Besides the dialog ought to be transient.
2008-05-20 01:01:54 +00:00
static gchar* last_dir = NULL;
gchar* uri = NULL;
gboolean folder_set = FALSE;
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
GtkWidget* dialog;
dialog = gtk_file_chooser_dialog_new (
Improve strings for the sake of better localization
2008-11-02 23:17:43 +00:00
_("Open file"), GTK_WINDOW (browser),
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
gtk_window_set_icon_name (GTK_WINDOW (dialog), GTK_STOCK_OPEN);
Remember the last opened folder for File Open The File Open dialog should remember the last opened folder or try to obtain it from the currently opened web view. Besides the dialog ought to be transient.
2008-05-20 01:01:54 +00:00
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (browser));
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
/* base the start folder on the current view's uri if it is local */
GtkWidget* view = midori_browser_get_current_tab (browser);
if ((uri = (gchar*)midori_view_get_display_uri (MIDORI_VIEW (view))))
Remember the last opened folder for File Open The File Open dialog should remember the last opened folder or try to obtain it from the currently opened web view. Besides the dialog ought to be transient.
2008-05-20 01:01:54 +00:00
{
gchar* filename = g_filename_from_uri (uri, NULL, NULL);
if (filename)
{
gchar* dirname = g_path_get_dirname (filename);
if (dirname && g_file_test (dirname, G_FILE_TEST_IS_DIR))
{
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), dirname);
folder_set = TRUE;
}
g_free (dirname);
g_free (filename);
}
}
if (!folder_set && last_dir && *last_dir)
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), last_dir);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
Remember the last opened folder for File Open The File Open dialog should remember the last opened folder or try to obtain it from the currently opened web view. Besides the dialog ought to be transient.
2008-05-20 01:01:54 +00:00
uri = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (dialog));
gchar* folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
Add an Open external pages in Preference
2008-10-20 06:50:16 +00:00
midori_browser_set_current_uri (browser, uri);
Remember the last opened folder for File Open The File Open dialog should remember the last opened folder or try to obtain it from the currently opened web view. Besides the dialog ought to be transient.
2008-05-20 01:01:54 +00:00
g_free (last_dir);
last_dir = folder;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
g_free (uri);
}
gtk_widget_destroy (dialog);
}
Implement Save As functionality
2008-10-26 16:07:59 +00:00
static void
midori_browser_save_transfer_cb (KatzeNetRequest* request,
gchar* filename)
{
FILE* fp;
if (request->data)
{
/* FIXME: Show an error message if the file cannot be saved */
if ((fp = fopen (filename, "wb")))
{
fwrite (request->data, 1, request->length, fp);
fclose (fp);
}
}
g_free (filename);
}
static void
_action_save_as_activate (GtkAction* action,
MidoriBrowser* browser)
{
static gchar* last_dir = NULL;
gchar* uri = NULL;
gboolean folder_set = FALSE;
GtkWidget* dialog;
GtkWidget* view;
gchar* filename;
gchar* dirname;
gchar* last_slash;
gchar* folder;
dialog = gtk_file_chooser_dialog_new (
Improve strings for the sake of better localization
2008-11-02 23:17:43 +00:00
_("Save file as"), GTK_WINDOW (browser),
Implement Save As functionality
2008-10-26 16:07:59 +00:00
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
gtk_window_set_icon_name (GTK_WINDOW (dialog), GTK_STOCK_SAVE);
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (browser));
view = midori_browser_get_current_tab (browser);
if ((uri = (gchar*)midori_view_get_display_uri (MIDORI_VIEW (view))))
{
/* Base the start folder on the current view's uri if it is local */
filename = g_filename_from_uri (uri, NULL, NULL);
if (filename)
{
dirname = g_path_get_dirname (filename);
if (dirname && g_file_test (dirname, G_FILE_TEST_IS_DIR))
{
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), dirname);
folder_set = TRUE;
}
g_free (dirname);
g_free (filename);
}
/* Try to provide a good default filename */
filename = g_filename_from_uri (uri, NULL, NULL);
if (!filename && (last_slash = g_strrstr (uri, "/")))
{
if (last_slash[0] == '/')
last_slash++;
filename = g_strdup (last_slash);
}
else
filename = g_strdup (uri);
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), filename);
g_free (filename);
}
if (!folder_set && last_dir && *last_dir)
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), last_dir);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
katze_net_load_uri (browser->net, uri, NULL,
(KatzeNetTransferCb)midori_browser_save_transfer_cb, filename);
g_free (last_dir);
last_dir = folder;
g_free (uri);
}
gtk_widget_destroy (dialog);
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static void
_action_tab_close_activate (GtkAction* action,
MidoriBrowser* browser)
{
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
GtkWidget* widget = midori_browser_get_current_tab (browser);
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
gtk_widget_destroy (widget);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
static void
_action_window_close_activate (GtkAction* action,
MidoriBrowser* browser)
{
gtk_widget_destroy (GTK_WIDGET (browser));
}
Add print support via javascript
2008-06-01 09:43:55 +00:00
static void
_action_print_activate (GtkAction* action,
MidoriBrowser* browser)
{
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
GtkWidget* view = midori_browser_get_current_tab (browser);
if (view)
midori_view_print (MIDORI_VIEW (view));
Add print support via javascript
2008-06-01 09:43:55 +00:00
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static void
_action_quit_activate (GtkAction* action,
MidoriBrowser* browser)
{
Implement MidoriApp singleton and improve multiple window support The new singleton holds the shared settings and trash. It is further more used to keep track of all open windows and quits when the last window was closed. It also watches the focus in case you need something like a "current" browser.
2008-05-22 22:17:10 +00:00
g_signal_emit (browser, signals[QUIT], 0);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
static void
Implement the Console panel for script messages.
2008-03-27 00:21:29 +00:00
_action_edit_activate (GtkAction* action,
MidoriBrowser* browser)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
GtkWidget* widget = gtk_window_get_focus (GTK_WINDOW (browser));
gboolean can_cut = FALSE, can_copy = FALSE, can_paste = FALSE;
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
gboolean has_selection, can_select_all = FALSE;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
if (MIDORI_IS_VIEW (widget))
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
MidoriView* view = MIDORI_VIEW (widget);
can_cut = midori_view_can_cut_clipboard (view);
can_copy = midori_view_can_copy_clipboard (view);
can_paste = midori_view_can_paste_clipboard (view);
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
can_select_all = TRUE;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
else if (GTK_IS_EDITABLE (widget))
{
GtkEditable* editable = GTK_EDITABLE (widget);
has_selection = gtk_editable_get_selection_bounds (editable, NULL, NULL);
can_cut = has_selection && gtk_editable_get_editable (editable);
can_copy = has_selection;
can_paste = gtk_editable_get_editable (editable);
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
can_select_all = TRUE;
}
else if (GTK_IS_TEXT_VIEW (widget))
{
GtkTextView* text_view = GTK_TEXT_VIEW (widget);
GtkTextBuffer* buffer = gtk_text_view_get_buffer (text_view);
has_selection = gtk_text_buffer_get_has_selection (buffer);
can_cut = gtk_text_view_get_editable (text_view);
can_copy = has_selection;
can_paste = gtk_text_view_get_editable (text_view) && has_selection;
can_select_all = TRUE;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
_action_set_sensitive (browser, "Cut", can_cut);
_action_set_sensitive (browser, "Copy", can_copy);
_action_set_sensitive (browser, "Paste", can_paste);
_action_set_sensitive (browser, "Delete", can_cut);
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
_action_set_sensitive (browser, "SelectAll", can_select_all);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
static void
Implement the Console panel for script messages.
2008-03-27 00:21:29 +00:00
_action_cut_activate (GtkAction* action,
MidoriBrowser* browser)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
GtkWidget* widget = gtk_window_get_focus (GTK_WINDOW (browser));
if (G_LIKELY (widget))
g_signal_emit_by_name (widget, "cut-clipboard");
}
static void
Implement the Console panel for script messages.
2008-03-27 00:21:29 +00:00
_action_copy_activate (GtkAction* action,
MidoriBrowser* browser)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
GtkWidget* widget = gtk_window_get_focus (GTK_WINDOW (browser));
if (G_LIKELY (widget))
g_signal_emit_by_name (widget, "copy-clipboard");
}
static void
Implement the Console panel for script messages.
2008-03-27 00:21:29 +00:00
_action_paste_activate (GtkAction* action,
MidoriBrowser* browser)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
GtkWidget* widget = gtk_window_get_focus (GTK_WINDOW (browser));
if (G_LIKELY (widget))
g_signal_emit_by_name (widget, "paste-clipboard");
}
static void
Implement the Console panel for script messages.
2008-03-27 00:21:29 +00:00
_action_delete_activate (GtkAction* action,
MidoriBrowser* browser)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
GtkWidget* widget = gtk_window_get_focus (GTK_WINDOW (browser));
if (G_LIKELY (widget))
{
if (WEBKIT_IS_WEB_VIEW (widget))
webkit_web_view_delete_selection (WEBKIT_WEB_VIEW (widget));
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
else if (GTK_IS_EDITABLE (widget))
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
gtk_editable_delete_selection (GTK_EDITABLE (widget));
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
else if (GTK_IS_TEXT_VIEW (widget))
gtk_text_buffer_delete_selection (
gtk_text_view_get_buffer (GTK_TEXT_VIEW (widget)), TRUE, FALSE);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
}
static void
Implement the Console panel for script messages.
2008-03-27 00:21:29 +00:00
_action_select_all_activate (GtkAction* action,
MidoriBrowser* browser)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
GtkWidget* widget = gtk_window_get_focus (GTK_WINDOW (browser));
if (G_LIKELY (widget))
{
Implement the Console panel for script messages.
2008-03-27 00:21:29 +00:00
if (GTK_IS_EDITABLE (widget))
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
gtk_editable_select_region (GTK_EDITABLE (widget), 0, -1);
else
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
g_signal_emit_by_name (widget, "select-all", TRUE);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
}
static void
Show progress in location entry if statusbar is hidden
2008-08-31 00:45:13 +00:00
_action_find_activate (GtkAction* action,
MidoriBrowser* browser)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Make Find work again, and disable it for source tabs
2008-09-28 14:29:41 +00:00
GtkWidget* view;
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
if (GTK_WIDGET_VISIBLE (browser->find))
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Make Find work again, and disable it for source tabs
2008-09-28 14:29:41 +00:00
view = midori_browser_get_current_tab (browser);
midori_view_unmark_text_matches (MIDORI_VIEW (view));
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
gtk_toggle_tool_button_set_active (
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
GTK_TOGGLE_TOOL_BUTTON (browser->find_highlight), FALSE);
gtk_widget_hide (browser->find);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
else
{
Introduce MidoriLocationEntry and GtkIconEntry
2008-07-17 19:02:14 +00:00
gtk_icon_entry_set_icon_from_stock (GTK_ICON_ENTRY (browser->find_text),
GTK_ICON_ENTRY_PRIMARY, GTK_STOCK_FIND);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_entry_set_text (GTK_ENTRY (browser->find_text), "");
gtk_widget_show (browser->find);
gtk_widget_grab_focus (GTK_WIDGET (browser->find_text));
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
}
static void
_midori_browser_find (MidoriBrowser* browser,
gboolean forward)
{
Make Find work again, and disable it for source tabs
2008-09-28 14:29:41 +00:00
const gchar* text;
gboolean case_sensitive;
GtkWidget* view;
text = gtk_entry_get_text (GTK_ENTRY (browser->find_text));
case_sensitive = gtk_toggle_tool_button_get_active (
Show progress in location entry if statusbar is hidden
2008-08-31 00:45:13 +00:00
GTK_TOGGLE_TOOL_BUTTON (browser->find_case));
Make Find work again, and disable it for source tabs
2008-09-28 14:29:41 +00:00
view = midori_browser_get_current_tab (browser);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
if (GTK_WIDGET_VISIBLE (browser->find))
Make Find work again, and disable it for source tabs
2008-09-28 14:29:41 +00:00
midori_view_unmark_text_matches (MIDORI_VIEW (view));
midori_view_search_text (MIDORI_VIEW (view), text, case_sensitive, forward);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
static void
_action_find_next_activate (GtkAction* action,
MidoriBrowser* browser)
{
_midori_browser_find (browser, TRUE);
}
static void
_action_find_previous_activate (GtkAction* action,
MidoriBrowser* browser)
{
_midori_browser_find (browser, FALSE);
}
static void
_find_highlight_toggled (GtkToggleToolButton* toolitem,
MidoriBrowser* browser)
{
Make Find work again, and disable it for source tabs
2008-09-28 14:29:41 +00:00
GtkWidget* view;
gboolean highlight;
view = midori_browser_get_current_tab (browser);
highlight = gtk_toggle_tool_button_get_active (toolitem);
midori_view_set_highlight_text_matches (MIDORI_VIEW (view), highlight);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
static void
midori_browser_find_button_close_clicked_cb (GtkWidget* widget,
MidoriBrowser* browser)
{
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_widget_hide (browser->find);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
static void
midori_browser_navigationbar_notify_style_cb (GObject* object,
GParamSpec* arg1,
MidoriBrowser* browser)
{
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
MidoriToolbarStyle toolbar_style;
GtkToolbarStyle gtk_toolbar_style;
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
g_object_get (browser->settings, "toolbar-style", &toolbar_style, NULL);
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
if (toolbar_style == MIDORI_TOOLBAR_DEFAULT)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
g_object_get (browser->settings,
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
"gtk-toolbar-style", &gtk_toolbar_style, NULL);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_toolbar_set_style (GTK_TOOLBAR (browser->navigationbar),
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
gtk_toolbar_style);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
}
Create navigationbar from a string of actions
2008-10-12 16:14:57 +00:00
static gboolean
midori_browser_toolbar_popup_context_menu_cb (GtkWidget* toolbar,
gint x,
gint y,
gint button,
MidoriBrowser* browser)
{
GtkWidget* menu;
GtkWidget* menuitem;
menu = gtk_menu_new ();
Allow hiding the menubar and showing it again
2008-10-12 20:09:49 +00:00
menuitem = sokoke_action_create_popup_menu_item (
_action_by_name (browser, "Menubar"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
Create navigationbar from a string of actions
2008-10-12 16:14:57 +00:00
menuitem = sokoke_action_create_popup_menu_item (
_action_by_name (browser, "Navigationbar"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
menuitem = sokoke_action_create_popup_menu_item (
_action_by_name (browser, "Bookmarkbar"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
Show all of Toolsbars in the toolbar context menu
2008-10-21 22:28:49 +00:00
gtk_widget_show (menuitem);
menuitem = sokoke_action_create_popup_menu_item (
_action_by_name (browser, "Transferbar"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
menuitem = sokoke_action_create_popup_menu_item (
_action_by_name (browser, "Statusbar"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
Create navigationbar from a string of actions
2008-10-12 16:14:57 +00:00
gtk_widget_show (menuitem);
katze_widget_popup (toolbar, GTK_MENU (menu), NULL,
button == -1 ? KATZE_MENU_POSITION_LEFT : KATZE_MENU_POSITION_CURSOR);
return TRUE;
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static void
Finish refactoring the toolbar to use only actions Finally the trash, which was the last item that needed to be implemented as an action, is an action, a KatzeArrayAction to be exact. This simplifies more code and also makes Window and RecentlyVisited generically implementable. Incidentally this change also fixes a bug where the browser tried to add a new tab when the last one was closed, even while destroying itself. Furthermore sokoke_image_menu_item_ellipsized and sokoke_widget_popup were promoted to Katze. We're still keeping the old functions for now.
2008-10-10 20:31:37 +00:00
_action_trash_populate_popup (GtkAction* action,
GtkMenu* menu,
MidoriBrowser* browser)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Finish refactoring the toolbar to use only actions Finally the trash, which was the last item that needed to be implemented as an action, is an action, a KatzeArrayAction to be exact. This simplifies more code and also makes Window and RecentlyVisited generically implementable. Incidentally this change also fixes a bug where the browser tried to add a new tab when the last one was closed, even while destroying itself. Furthermore sokoke_image_menu_item_ellipsized and sokoke_widget_popup were promoted to Katze. We're still keeping the old functions for now.
2008-10-10 20:31:37 +00:00
GtkWidget* menuitem;
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
Finish refactoring the toolbar to use only actions Finally the trash, which was the last item that needed to be implemented as an action, is an action, a KatzeArrayAction to be exact. This simplifies more code and also makes Window and RecentlyVisited generically implementable. Incidentally this change also fixes a bug where the browser tried to add a new tab when the last one was closed, even while destroying itself. Furthermore sokoke_image_menu_item_ellipsized and sokoke_widget_popup were promoted to Katze. We're still keeping the old functions for now.
2008-10-10 20:31:37 +00:00
menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
Keep otherwise unused actions in a Dummy This is needed for accelerators to work even if the according actions are not part of the permanent UI description.
2008-10-12 19:44:00 +00:00
menuitem = gtk_action_create_menu_item (
Finish refactoring the toolbar to use only actions Finally the trash, which was the last item that needed to be implemented as an action, is an action, a KatzeArrayAction to be exact. This simplifies more code and also makes Window and RecentlyVisited generically implementable. Incidentally this change also fixes a bug where the browser tried to add a new tab when the last one was closed, even while destroying itself. Furthermore sokoke_image_menu_item_ellipsized and sokoke_widget_popup were promoted to Katze. We're still keeping the old functions for now.
2008-10-10 20:31:37 +00:00
_action_by_name (browser, "TrashEmpty"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
}
static void
_action_trash_activate_item (GtkAction* action,
KatzeItem* item,
MidoriBrowser* browser)
{
gint n = midori_browser_add_item (browser, item);
Attempt to fix handling of background and foreground tabs.
2008-04-24 22:20:43 +00:00
midori_browser_set_current_page (browser, n);
Rework MidoriWebList into KatzeList and KatzeArray
2008-08-25 23:19:38 +00:00
katze_array_remove_item (browser->trash, item);
Reuse the trashed item and remove it from the trash properly
2008-08-02 03:29:38 +00:00
_midori_browser_update_actions (browser);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
static void
Finish refactoring the toolbar to use only actions Finally the trash, which was the last item that needed to be implemented as an action, is an action, a KatzeArrayAction to be exact. This simplifies more code and also makes Window and RecentlyVisited generically implementable. Incidentally this change also fixes a bug where the browser tried to add a new tab when the last one was closed, even while destroying itself. Furthermore sokoke_image_menu_item_ellipsized and sokoke_widget_popup were promoted to Katze. We're still keeping the old functions for now.
2008-10-10 20:31:37 +00:00
_action_history_populate_popup (GtkAction* action,
GtkMenu* menu,
MidoriBrowser* browser)
{
/* Nothing to do */
}
static void
_action_history_activate_item (GtkAction* action,
KatzeItem* item,
MidoriBrowser* browser)
{
Add an Open external pages in Preference
2008-10-20 06:50:16 +00:00
midori_browser_set_current_uri (browser, katze_item_get_uri (item));
Finish refactoring the toolbar to use only actions Finally the trash, which was the last item that needed to be implemented as an action, is an action, a KatzeArrayAction to be exact. This simplifies more code and also makes Window and RecentlyVisited generically implementable. Incidentally this change also fixes a bug where the browser tried to add a new tab when the last one was closed, even while destroying itself. Furthermore sokoke_image_menu_item_ellipsized and sokoke_widget_popup were promoted to Katze. We're still keeping the old functions for now.
2008-10-10 20:31:37 +00:00
}
static void
_action_bookmarks_populate_popup (GtkAction* action,
GtkMenu* menu,
MidoriBrowser* browser)
{
GtkWidget* menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
Keep otherwise unused actions in a Dummy This is needed for accelerators to work even if the according actions are not part of the permanent UI description.
2008-10-12 19:44:00 +00:00
menuitem = gtk_action_create_menu_item (
Finish refactoring the toolbar to use only actions Finally the trash, which was the last item that needed to be implemented as an action, is an action, a KatzeArrayAction to be exact. This simplifies more code and also makes Window and RecentlyVisited generically implementable. Incidentally this change also fixes a bug where the browser tried to add a new tab when the last one was closed, even while destroying itself. Furthermore sokoke_image_menu_item_ellipsized and sokoke_widget_popup were promoted to Katze. We're still keeping the old functions for now.
2008-10-10 20:31:37 +00:00
_action_by_name (browser, "BookmarkAdd"));
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
}
static void
_action_bookmarks_activate_item (GtkAction* action,
KatzeItem* item,
MidoriBrowser* browser)
{
Add an Open external pages in Preference
2008-10-20 06:50:16 +00:00
midori_browser_set_current_uri (browser, katze_item_get_uri (item));
Open all bookmarks in the current tab
2008-10-17 21:15:37 +00:00
gtk_widget_grab_focus (midori_browser_get_current_tab (browser));
Finish refactoring the toolbar to use only actions Finally the trash, which was the last item that needed to be implemented as an action, is an action, a KatzeArrayAction to be exact. This simplifies more code and also makes Window and RecentlyVisited generically implementable. Incidentally this change also fixes a bug where the browser tried to add a new tab when the last one was closed, even while destroying itself. Furthermore sokoke_image_menu_item_ellipsized and sokoke_widget_popup were promoted to Katze. We're still keeping the old functions for now.
2008-10-10 20:31:37 +00:00
}
static void
_action_window_populate_popup (GtkAction* action,
GtkMenu* menu,
MidoriBrowser* browser)
{
GtkWidget* menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
Keep otherwise unused actions in a Dummy This is needed for accelerators to work even if the according actions are not part of the permanent UI description.
2008-10-12 19:44:00 +00:00
menuitem = gtk_action_create_menu_item (
Finish refactoring the toolbar to use only actions Finally the trash, which was the last item that needed to be implemented as an action, is an action, a KatzeArrayAction to be exact. This simplifies more code and also makes Window and RecentlyVisited generically implementable. Incidentally this change also fixes a bug where the browser tried to add a new tab when the last one was closed, even while destroying itself. Furthermore sokoke_image_menu_item_ellipsized and sokoke_widget_popup were promoted to Katze. We're still keeping the old functions for now.
2008-10-10 20:31:37 +00:00
_action_by_name (browser, "TabPrevious"));
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
Keep otherwise unused actions in a Dummy This is needed for accelerators to work even if the according actions are not part of the permanent UI description.
2008-10-12 19:44:00 +00:00
menuitem = gtk_action_create_menu_item (
Finish refactoring the toolbar to use only actions Finally the trash, which was the last item that needed to be implemented as an action, is an action, a KatzeArrayAction to be exact. This simplifies more code and also makes Window and RecentlyVisited generically implementable. Incidentally this change also fixes a bug where the browser tried to add a new tab when the last one was closed, even while destroying itself. Furthermore sokoke_image_menu_item_ellipsized and sokoke_widget_popup were promoted to Katze. We're still keeping the old functions for now.
2008-10-10 20:31:37 +00:00
_action_by_name (browser, "TabNext"));
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
}
static void
_action_window_activate_item (GtkAction* action,
KatzeItem* item,
MidoriBrowser* browser)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Ellipsize menu items referring to websites or bookmarks. Originally menu items could in some cases become as wide as the whole screen, making working with menus rather hard. Now we ellipsize at 50 characters in the middle of the string.
2008-09-07 01:39:25 +00:00
guint i, n;
Finish refactoring the toolbar to use only actions Finally the trash, which was the last item that needed to be implemented as an action, is an action, a KatzeArrayAction to be exact. This simplifies more code and also makes Window and RecentlyVisited generically implementable. Incidentally this change also fixes a bug where the browser tried to add a new tab when the last one was closed, even while destroying itself. Furthermore sokoke_image_menu_item_ellipsized and sokoke_widget_popup were promoted to Katze. We're still keeping the old functions for now.
2008-10-10 20:31:37 +00:00
GtkWidget* view;
Ellipsize menu items referring to websites or bookmarks. Originally menu items could in some cases become as wide as the whole screen, making working with menus rather hard. Now we ellipsize at 50 characters in the middle of the string.
2008-09-07 01:39:25 +00:00
Finish refactoring the toolbar to use only actions Finally the trash, which was the last item that needed to be implemented as an action, is an action, a KatzeArrayAction to be exact. This simplifies more code and also makes Window and RecentlyVisited generically implementable. Incidentally this change also fixes a bug where the browser tried to add a new tab when the last one was closed, even while destroying itself. Furthermore sokoke_image_menu_item_ellipsized and sokoke_widget_popup were promoted to Katze. We're still keeping the old functions for now.
2008-10-10 20:31:37 +00:00
n = katze_array_get_length (browser->proxy_array);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
for (i = 0; i < n; i++)
{
Finish refactoring the toolbar to use only actions Finally the trash, which was the last item that needed to be implemented as an action, is an action, a KatzeArrayAction to be exact. This simplifies more code and also makes Window and RecentlyVisited generically implementable. Incidentally this change also fixes a bug where the browser tried to add a new tab when the last one was closed, even while destroying itself. Furthermore sokoke_image_menu_item_ellipsized and sokoke_widget_popup were promoted to Katze. We're still keeping the old functions for now.
2008-10-10 20:31:37 +00:00
view = gtk_notebook_get_nth_page (GTK_NOTEBOOK (browser->notebook), i);
if (midori_view_get_proxy_item (MIDORI_VIEW (view)) == item)
gtk_notebook_set_current_page (GTK_NOTEBOOK (browser->notebook), i);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
}
Connect Help in Preferences to HelpContents
2008-10-03 22:46:54 +00:00
static void
midori_preferences_response_help_cb (GtkWidget* preferences,
gint response,
MidoriBrowser* browser)
{
if (response == GTK_RESPONSE_HELP)
gtk_action_activate (_action_by_name (browser, "HelpContents"));
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static void
_action_preferences_activate (GtkAction* action,
MidoriBrowser* browser)
{
Introduce MidoriWebList, second step of refactoring web search
2008-06-14 00:23:33 +00:00
/* Show the preferences dialog. Create it if necessary. */
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static GtkWidget* dialog = NULL;
if (GTK_IS_DIALOG (dialog))
gtk_window_present (GTK_WINDOW (dialog));
else
{
Turn prefs into MidoriPreferences
2008-04-20 01:30:24 +00:00
dialog = midori_preferences_new (GTK_WINDOW (browser),
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
browser->settings);
Connect Help in Preferences to HelpContents
2008-10-03 22:46:54 +00:00
g_signal_connect (dialog, "response",
G_CALLBACK (midori_preferences_response_help_cb), browser);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
gtk_widget_show (dialog);
}
}
Allow hiding the menubar and showing it again
2008-10-12 20:09:49 +00:00
static void
_action_menubar_activate (GtkToggleAction* action,
MidoriBrowser* browser)
{
gboolean active = gtk_toggle_action_get_active (action);
g_object_set (browser->settings, "show-menubar", active, NULL);
sokoke_widget_set_visible (browser->menubar, active);
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static void
_action_navigationbar_activate (GtkToggleAction* action,
MidoriBrowser* browser)
{
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
gboolean active = gtk_toggle_action_get_active (action);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
g_object_set (browser->settings, "show-navigationbar", active, NULL);
sokoke_widget_set_visible (browser->navigationbar, active);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
static void
_action_bookmarkbar_activate (GtkToggleAction* action,
MidoriBrowser* browser)
{
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
gboolean active = gtk_toggle_action_get_active (action);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
g_object_set (browser->settings, "show-bookmarkbar", active, NULL);
sokoke_widget_set_visible (browser->bookmarkbar, active);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
static void
_action_statusbar_activate (GtkToggleAction* action,
MidoriBrowser* browser)
{
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
gboolean active = gtk_toggle_action_get_active (action);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
g_object_set (browser->settings, "show-statusbar", active, NULL);
sokoke_widget_set_visible (browser->statusbar, active);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
static void
_action_reload_stop_activate (GtkAction* action,
MidoriBrowser* browser)
{
gchar* stock_id;
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
GtkWidget* view;
GdkModifierType state = (GdkModifierType)0;
gint x, y;
gboolean from_cache;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
g_object_get (action, "stock-id", &stock_id, NULL);
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
view = midori_browser_get_current_tab (browser);
Introduce MidoriWebList, second step of refactoring web search
2008-06-14 00:23:33 +00:00
/* Refresh or stop, depending on the stock id */
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
if (!strcmp (stock_id, GTK_STOCK_REFRESH))
{
gdk_window_get_pointer (NULL, &x, &y, &state);
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
from_cache = state & GDK_SHIFT_MASK;
midori_view_reload (MIDORI_VIEW (view), !from_cache);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
else
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
midori_view_stop_loading (MIDORI_VIEW (view));
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
g_free (stock_id);
}
Add zoom functionality, if webkit supports it
2008-06-01 09:26:10 +00:00
static void
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
_action_zoom_in_activate (GtkAction* action,
MidoriBrowser* browser)
{
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
GtkWidget* view = midori_browser_get_current_tab (browser);
if (view)
midori_view_set_zoom_level (MIDORI_VIEW (view),
midori_view_get_zoom_level (MIDORI_VIEW (view)) + 0.25f);
Add zoom functionality, if webkit supports it
2008-06-01 09:26:10 +00:00
}
static void
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
_action_zoom_out_activate (GtkAction* action,
MidoriBrowser* browser)
{
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
GtkWidget* view = midori_browser_get_current_tab (browser);
if (view)
midori_view_set_zoom_level (MIDORI_VIEW (view),
midori_view_get_zoom_level (MIDORI_VIEW (view)) - 0.25f);
Add zoom functionality, if webkit supports it
2008-06-01 09:26:10 +00:00
}
static void
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
_action_zoom_normal_activate (GtkAction* action,
MidoriBrowser* browser)
{
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
GtkWidget* view = midori_browser_get_current_tab (browser);
if (view)
midori_view_set_zoom_level (MIDORI_VIEW (view), 1.0f);
Add zoom functionality, if webkit supports it
2008-06-01 09:26:10 +00:00
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Preserve extensions for viewing source files
2008-10-23 23:15:43 +00:00
static gchar*
midori_browser_get_uri_extension (const gchar* uri)
{
gchar* extension;
gchar* slash;
gchar* period;
gchar* ext_end;
gchar* tmp = g_strdup (uri);
/* Find the last slash in the URI and search for the last period
*after* the last slash. This is not completely accurate
but should cover most (simple) URIs */
slash = strrchr (tmp, '/');
/* Huh, URI without slashes? */
if (!slash)
return g_strdup ("");
ext_end = period = strrchr (slash, '.');
if (!period)
return g_strdup ("");
/* Skip the period */
ext_end++;
/* If *ext_end is 0 here, the URI ended with a period, so skip */
if (!*ext_end)
return g_strdup ("");
/* Find the end of the extension */
while (*ext_end && g_ascii_isalnum (*ext_end))
ext_end++;
*ext_end = 0;
extension = g_strdup (period);
g_free (tmp);
return extension;
}
Implement View source with external Text editor
2008-10-20 19:32:25 +00:00
static void
Implement Save As functionality
2008-10-26 16:07:59 +00:00
midori_browser_source_transfer_cb (KatzeNetRequest* request,
MidoriBrowser* browser)
Implement View source with external Text editor
2008-10-20 19:32:25 +00:00
{
gchar* filename;
Preserve extensions for viewing source files
2008-10-23 23:15:43 +00:00
gchar* extension;
Implement View source with external Text editor
2008-10-20 19:32:25 +00:00
gchar* unique_filename;
gchar* text_editor;
gint fd;
FILE* fp;
Implement KatzeNet as a generic URI loader KatzeNet can from now on be used where URIs are handled and one would have used libSoup and/ or local file handling as appropriate, whereas KatzeNet does both. Since we are displaying icons in several places KatzeNet also provides an icon loader that saves us from doublicating even more code. All bookmarks and also history items have icons now, since KatzeNet makes that incredibly easy. Search engines are also using favicons now, and right now custom icons don't work, we still need to fix that. Note that only icons are cached, nothing else and the code is known to have a hidden, hard to reproduce crasher which may appear when an icon is newly loaded.
2008-10-23 22:09:12 +00:00
if (request->data)
Implement View source with external Text editor
2008-10-20 19:32:25 +00:00
{
Preserve extensions for viewing source files
2008-10-23 23:15:43 +00:00
extension = midori_browser_get_uri_extension (request->uri);
filename = g_strdup_printf ("%uXXXXXX%s",
g_str_hash (request->uri), extension);
g_free (extension);
Implement View source with external Text editor
2008-10-20 19:32:25 +00:00
if (((fd = g_file_open_tmp (filename, &unique_filename, NULL)) != -1))
{
if ((fp = fdopen (fd, "w")))
{
Implement KatzeNet as a generic URI loader KatzeNet can from now on be used where URIs are handled and one would have used libSoup and/ or local file handling as appropriate, whereas KatzeNet does both. Since we are displaying icons in several places KatzeNet also provides an icon loader that saves us from doublicating even more code. All bookmarks and also history items have icons now, since KatzeNet makes that incredibly easy. Search engines are also using favicons now, and right now custom icons don't work, we still need to fix that. Note that only icons are cached, nothing else and the code is known to have a hidden, hard to reproduce crasher which may appear when an icon is newly loaded.
2008-10-23 22:09:12 +00:00
fwrite (request->data, 1, request->length, fp);
Implement View source with external Text editor
2008-10-20 19:32:25 +00:00
fclose (fp);
g_object_get (browser->settings,
"text-editor", &text_editor, NULL);
sokoke_spawn_program (text_editor, unique_filename);
g_free (unique_filename);
g_free (text_editor);
}
close (fd);
}
g_free (filename);
}
}
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
static void
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
_action_source_view_activate (GtkAction* action,
MidoriBrowser* browser)
{
Implement View source with external Text editor
2008-10-20 19:32:25 +00:00
gchar* text_editor;
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
GtkWidget* view;
GtkWidget* source_view;
gchar* uri;
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
gint n;
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
if (!(view = midori_browser_get_current_tab (browser)))
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
return;
Implement View source with external Text editor
2008-10-20 19:32:25 +00:00
g_object_get (browser->settings, "text-editor", &text_editor, NULL);
if (text_editor && *text_editor)
{
Implement KatzeNet as a generic URI loader KatzeNet can from now on be used where URIs are handled and one would have used libSoup and/ or local file handling as appropriate, whereas KatzeNet does both. Since we are displaying icons in several places KatzeNet also provides an icon loader that saves us from doublicating even more code. All bookmarks and also history items have icons now, since KatzeNet makes that incredibly easy. Search engines are also using favicons now, and right now custom icons don't work, we still need to fix that. Note that only icons are cached, nothing else and the code is known to have a hidden, hard to reproduce crasher which may appear when an icon is newly loaded.
2008-10-23 22:09:12 +00:00
katze_net_load_uri (browser->net,
Implement Save As functionality
2008-10-26 16:07:59 +00:00
midori_view_get_display_uri (MIDORI_VIEW (view)), NULL,
(KatzeNetTransferCb)midori_browser_source_transfer_cb, browser);
Implement KatzeNet as a generic URI loader KatzeNet can from now on be used where URIs are handled and one would have used libSoup and/ or local file handling as appropriate, whereas KatzeNet does both. Since we are displaying icons in several places KatzeNet also provides an icon loader that saves us from doublicating even more code. All bookmarks and also history items have icons now, since KatzeNet makes that incredibly easy. Search engines are also using favicons now, and right now custom icons don't work, we still need to fix that. Note that only icons are cached, nothing else and the code is known to have a hidden, hard to reproduce crasher which may appear when an icon is newly loaded.
2008-10-23 22:09:12 +00:00
g_free (text_editor);
return;
Implement View source with external Text editor
2008-10-20 19:32:25 +00:00
}
else
{
uri = g_strdup_printf ("view-source:%s",
midori_view_get_display_uri (MIDORI_VIEW (view)));
Share net between browser and views
2008-10-27 03:23:41 +00:00
source_view = midori_view_new (browser->net);
Implement View source with external Text editor
2008-10-20 19:32:25 +00:00
midori_view_set_settings (MIDORI_VIEW (source_view), browser->settings);
midori_view_set_uri (MIDORI_VIEW (source_view), uri);
Add Compact sidepanel Preference
2008-10-21 22:01:01 +00:00
midori_view_notify_icon_cb (MIDORI_VIEW (source_view), NULL, browser);
Implement View source with external Text editor
2008-10-20 19:32:25 +00:00
g_free (uri);
gtk_widget_show (source_view);
n = midori_browser_add_tab (browser, source_view);
midori_browser_set_current_page (browser, n);
}
g_free (text_editor);
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static void
_action_fullscreen_activate (GtkAction* action,
MidoriBrowser* browser)
{
GdkWindowState state = gdk_window_get_state (GTK_WIDGET (browser)->window);
if (state & GDK_WINDOW_STATE_FULLSCREEN)
gtk_window_unfullscreen (GTK_WINDOW (browser));
else
gtk_window_fullscreen (GTK_WINDOW (browser));
}
static void
_action_back_activate (GtkAction* action,
MidoriBrowser* browser)
{
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
GtkWidget* view = midori_browser_get_current_tab (browser);
if (view)
midori_view_go_back (MIDORI_VIEW (view));
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
static void
_action_forward_activate (GtkAction* action,
MidoriBrowser* browser)
{
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
GtkWidget* view = midori_browser_get_current_tab (browser);
if (view)
midori_view_go_forward (MIDORI_VIEW (view));
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
static void
Add Show Homepage option, remove Form Fill and Small Toolbar
2008-05-20 01:21:11 +00:00
_action_homepage_activate (GtkAction* action,
MidoriBrowser* browser)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
gchar* homepage;
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
g_object_get (browser->settings, "homepage", &homepage, NULL);
Add an Open external pages in Preference
2008-10-20 06:50:16 +00:00
midori_browser_set_current_uri (browser, homepage);
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
g_free (homepage);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
Introduce MidoriLocationEntry and GtkIconEntry
2008-07-17 19:02:14 +00:00
static void
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
_action_location_activate (GtkAction* action,
MidoriBrowser* browser)
{
Show progress in location independant of statusbar visibility
2008-10-21 22:26:20 +00:00
if (!sokoke_object_get_boolean (browser->settings, "show-navigationbar"))
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
gtk_widget_show (browser->navigationbar);
}
static void
_action_location_active_changed (GtkAction* action,
gint index,
MidoriBrowser* browser)
Introduce MidoriLocationEntry and GtkIconEntry
2008-07-17 19:02:14 +00:00
{
const gchar* uri;
if (index > -1)
{
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
uri = midori_location_action_get_uri (MIDORI_LOCATION_ACTION (action));
Add an Open external pages in Preference
2008-10-20 06:50:16 +00:00
midori_browser_set_current_uri (browser, uri);
Introduce MidoriLocationEntry and GtkIconEntry
2008-07-17 19:02:14 +00:00
}
}
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
static void
_action_location_focus_out (GtkAction* action,
MidoriBrowser* browser)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Show progress in location independant of statusbar visibility
2008-10-21 22:26:20 +00:00
if (!sokoke_object_get_boolean (browser->settings, "show-navigationbar"))
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
gtk_widget_hide (browser->navigationbar);
}
Resolve helpers and globals into sokoke.
2008-04-20 19:44:56 +00:00
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
static void
_action_location_reset_uri (GtkAction* action,
MidoriBrowser* browser)
{
const gchar* uri;
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
uri = midori_browser_get_current_uri (browser);
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
midori_location_action_set_uri (MIDORI_LOCATION_ACTION (action), uri);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
static void
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
_action_location_submit_uri (GtkAction* action,
const gchar* uri,
Alt + Enter in the location should issue a new tab
2008-08-31 01:21:29 +00:00
gboolean new_tab,
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
MidoriBrowser* browser)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
gchar* location_entry_search;
gchar* new_uri;
Alt + Enter in the location should issue a new tab
2008-08-31 01:21:29 +00:00
gint n;
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
g_object_get (browser->settings, "location-entry-search",
&location_entry_search, NULL);
new_uri = sokoke_magic_uri (uri, browser->search_engines);
if (!new_uri && strstr (location_entry_search, "%s"))
new_uri = g_strdup_printf (location_entry_search, uri);
else if (!new_uri)
new_uri = g_strdup (location_entry_search);
g_free (location_entry_search);
Alt + Enter in the location should issue a new tab
2008-08-31 01:21:29 +00:00
if (new_tab)
{
n = midori_browser_add_uri (browser, new_uri);
midori_browser_set_current_page (browser, n);
}
else
Add an Open external pages in Preference
2008-10-20 06:50:16 +00:00
midori_browser_set_current_uri (browser, new_uri);
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
g_free (new_uri);
gtk_widget_grab_focus (midori_browser_get_current_tab (browser));
Show hidden location/ web search temporarily when needed. If the location or web search was hidden, and one attempted to use the menus or shortcuts for Location or Web search, an appropriate dialog with an entry was shown. Now we show the according widget temporarily and hide it again once it loses focus.
2008-04-22 21:36:37 +00:00
}
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
static void
midori_browser_menu_feed_item_activate_cb (GtkWidget* widget,
MidoriBrowser* browser)
Show hidden location/ web search temporarily when needed. If the location or web search was hidden, and one attempted to use the menus or shortcuts for Location or Web search, an appropriate dialog with an entry was shown. Now we show the according widget temporarily and hide it again once it loses focus.
2008-04-22 21:36:37 +00:00
{
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
const gchar* uri;
uri = g_object_get_data (G_OBJECT (widget), "uri");
Add an Open external pages in Preference
2008-10-20 06:50:16 +00:00
midori_browser_set_current_uri (browser, uri);
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
}
static void
_action_location_secondary_icon_released (GtkAction* action,
GtkWidget* widget,
MidoriBrowser* browser)
{
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
MidoriView* view;
Rework MidoriWebList into KatzeList and KatzeArray
2008-08-25 23:19:38 +00:00
KatzeArray* news_feeds;
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
GtkWidget* menu;
guint n, i;
GjsValue* feed;
const gchar* uri;
const gchar* title;
GtkWidget* menuitem;
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
view = (MidoriView*)midori_browser_get_current_tab (browser);
if (view)
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
{
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
news_feeds = NULL /* midori_view_get_news_feeds (view) */;
Rework MidoriWebList into KatzeList and KatzeArray
2008-08-25 23:19:38 +00:00
n = news_feeds ? katze_array_get_length (news_feeds) : 0;
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
if (n)
{
menu = gtk_menu_new ();
for (i = 0; i < n; i++)
{
Rework MidoriWebList into KatzeList and KatzeArray
2008-08-25 23:19:38 +00:00
if (!(feed = katze_array_get_nth_item (news_feeds, i)))
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
continue;
uri = gjs_value_get_attribute_string (feed, "href");
if (gjs_value_has_attribute (feed, "title"))
title = gjs_value_get_attribute_string (feed, "title");
else
title = uri;
if (!*title)
title = uri;
Ellipsize menu items referring to websites or bookmarks. Originally menu items could in some cases become as wide as the whole screen, making working with menus rather hard. Now we ellipsize at 50 characters in the middle of the string.
2008-09-07 01:39:25 +00:00
menuitem = sokoke_image_menu_item_new_ellipsized (title);
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
/* FIXME: Get the real icon */
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (
Use fallbacks for all icons, we don't want "broken" icons
2008-08-17 14:14:15 +00:00
menuitem), gtk_image_new_from_stock (STOCK_NEWS_FEED,
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
GTK_ICON_SIZE_MENU));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
g_object_set_data (G_OBJECT (menuitem), "uri", (gchar*)uri);
g_signal_connect (menuitem, "activate",
G_CALLBACK (midori_browser_menu_feed_item_activate_cb),
browser);
gtk_widget_show (menuitem);
}
sokoke_widget_popup (widget, GTK_MENU (menu), NULL,
SOKOKE_MENU_POSITION_CURSOR);
}
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
static void
_action_search_activate (GtkAction* action,
MidoriBrowser* browser)
{
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
if (!GTK_WIDGET_VISIBLE (browser->navigationbar))
gtk_widget_show (browser->navigationbar);
Show hidden location/ web search temporarily when needed. If the location or web search was hidden, and one attempted to use the menus or shortcuts for Location or Web search, an appropriate dialog with an entry was shown. Now we show the according widget temporarily and hide it again once it loses focus.
2008-04-22 21:36:37 +00:00
}
Implement the search widget as an action The most part of the search entry code is merely moved to the new action. We remove the original entry now, the action is all we need.
2008-10-05 21:25:02 +00:00
static void
_action_search_submit (GtkAction* action,
const gchar* keywords,
gboolean new_tab,
MidoriBrowser* browser)
Show hidden location/ web search temporarily when needed. If the location or web search was hidden, and one attempted to use the menus or shortcuts for Location or Web search, an appropriate dialog with an entry was shown. Now we show the according widget temporarily and hide it again once it loses focus.
2008-04-22 21:36:37 +00:00
{
Implement the search widget as an action The most part of the search entry code is merely moved to the new action. We remove the original entry now, the action is all we need.
2008-10-05 21:25:02 +00:00
guint last_web_search;
KatzeItem* item;
const gchar* url;
gchar* location_entry_search;
gchar* search;
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
Implement the search widget as an action The most part of the search entry code is merely moved to the new action. We remove the original entry now, the action is all we need.
2008-10-05 21:25:02 +00:00
g_object_get (browser->settings, "last-web-search", &last_web_search, NULL);
item = katze_array_get_nth_item (browser->search_engines, last_web_search);
if (item)
{
location_entry_search = NULL;
url = katze_item_get_uri (item);
}
else /* The location entry search is our fallback */
{
g_object_get (browser->settings, "location-entry-search",
&location_entry_search, NULL);
url = location_entry_search;
}
if (strstr (url, "%s"))
search = g_strdup_printf (url, keywords);
else
search = g_strconcat (url, " ", keywords, NULL);
if (new_tab)
midori_browser_add_uri (browser, search);
else
Add an Open external pages in Preference
2008-10-20 06:50:16 +00:00
midori_browser_set_current_uri (browser, search);
Implement the search widget as an action The most part of the search entry code is merely moved to the new action. We remove the original entry now, the action is all we need.
2008-10-05 21:25:02 +00:00
g_free (search);
g_free (location_entry_search);
}
static void
_action_search_notify_current_item (GtkAction* action,
GParamSpec* pspec,
MidoriBrowser* browser)
{
MidoriSearchAction* search_action;
KatzeItem* item;
guint index;
search_action = MIDORI_SEARCH_ACTION (action);
item = midori_search_action_get_current_item (search_action);
if (item)
index = katze_array_get_item_index (browser->search_engines, item);
else
index = 0;
g_object_set (browser->settings, "last-web-search", index, NULL);
}
static void
_action_search_focus_out (GtkAction* action,
MidoriBrowser* browser)
{
if (GTK_WIDGET_VISIBLE (browser->statusbar) &&
!sokoke_object_get_boolean (browser->settings, "show-navigationbar"))
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_widget_hide (browser->navigationbar);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
static void
midori_panel_bookmarks_row_activated_cb (GtkTreeView* treeview,
GtkTreePath* path,
GtkTreeViewColumn* column,
MidoriBrowser* browser)
{
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
GtkTreeModel* model;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
GtkTreeIter iter;
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
KatzeItem* item;
const gchar* uri;
model = gtk_tree_view_get_model (treeview);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
if (gtk_tree_model_get_iter (model, &iter, path))
{
gtk_tree_model_get (model, &iter, 0, &item, -1);
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
uri = katze_item_get_uri (item);
if (uri && *uri)
Add an Open external pages in Preference
2008-10-20 06:50:16 +00:00
midori_browser_set_current_uri (browser, uri);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
}
static void
Refactor a lot of tree view selection code into convenience
2008-08-29 01:20:31 +00:00
midori_panel_bookmarks_cursor_or_row_changed_cb (GtkTreeView* tree_view,
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
MidoriBrowser* browser)
{
Refactor a lot of tree view selection code into convenience
2008-08-29 01:20:31 +00:00
GtkTreeModel* model;
GtkTreeIter iter;
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
KatzeItem* item;
Refactor a lot of tree view selection code into convenience
2008-08-29 01:20:31 +00:00
gboolean is_separator;
if (sokoke_tree_view_get_selected_iter (tree_view, &model, &iter))
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Refactor a lot of tree view selection code into convenience
2008-08-29 01:20:31 +00:00
gtk_tree_model_get (model, &iter, 0, &item, -1);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
is_separator = !KATZE_IS_ARRAY (item) && !katze_item_get_uri (item);
Refactor a lot of tree view selection code into convenience
2008-08-29 01:20:31 +00:00
_action_set_sensitive (browser, "BookmarkEdit", !is_separator);
_action_set_sensitive (browser, "BookmarkDelete", TRUE);
}
else
{
_action_set_sensitive (browser, "BookmarkEdit", FALSE);
_action_set_sensitive (browser, "BookmarkDelete", FALSE);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
}
static void
Refactor bookmark context menu, apply it on the bookmarkbar
2008-10-30 01:19:52 +00:00
midori_browser_bookmark_popup_item (GtkWidget* menu,
const gchar* stock_id,
Improve strings for the sake of better localization
2008-11-02 23:17:43 +00:00
const gchar* label,
Refactor bookmark context menu, apply it on the bookmarkbar
2008-10-30 01:19:52 +00:00
KatzeItem* item,
gpointer callback,
MidoriBrowser* browser)
{
const gchar* uri;
GtkWidget* menuitem;
uri = katze_item_get_uri (item);
menuitem = gtk_image_menu_item_new_from_stock (stock_id, NULL);
Improve strings for the sake of better localization
2008-11-02 23:17:43 +00:00
if (label)
gtk_label_set_text_with_mnemonic (GTK_LABEL (gtk_bin_get_child (
GTK_BIN (menuitem))), label);
Refactor bookmark context menu, apply it on the bookmarkbar
2008-10-30 01:19:52 +00:00
if (!strcmp (stock_id, GTK_STOCK_EDIT))
gtk_widget_set_sensitive (menuitem,
KATZE_IS_ARRAY (item) || uri != NULL);
else if (strcmp (stock_id, GTK_STOCK_DELETE))
gtk_widget_set_sensitive (menuitem, uri != NULL);
g_object_set_data (G_OBJECT (menuitem), "KatzeItem", item);
g_signal_connect (menuitem, "activate", G_CALLBACK (callback), browser);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
}
static void
midori_browser_bookmark_open_activate_cb (GtkWidget* menuitem,
MidoriBrowser* browser)
{
KatzeItem* item;
const gchar* uri;
item = (KatzeItem*)g_object_get_data (G_OBJECT (menuitem), "KatzeItem");
uri = katze_item_get_uri (item);
if (uri && *uri)
midori_browser_set_current_uri (browser, uri);
}
static void
midori_browser_bookmark_open_in_tab_activate_cb (GtkWidget* menuitem,
MidoriBrowser* browser)
{
KatzeItem* item;
const gchar* uri;
guint n;
item = (KatzeItem*)g_object_get_data (G_OBJECT (menuitem), "KatzeItem");
uri = katze_item_get_uri (item);
if (uri && *uri)
{
n = midori_browser_add_item (browser, item);
_midori_browser_set_current_page_smartly (browser, n);
}
}
static void
midori_browser_bookmark_open_in_window_activate_cb (GtkWidget* menuitem,
MidoriBrowser* browser)
{
KatzeItem* item;
const gchar* uri;
item = (KatzeItem*)g_object_get_data (G_OBJECT (menuitem), "KatzeItem");
uri = katze_item_get_uri (item);
if (uri && *uri)
g_signal_emit (browser, signals[NEW_WINDOW], 0, uri);
}
static void
midori_browser_bookmark_bookmark_activate_cb (GtkWidget* menuitem,
MidoriBrowser* browser)
{
KatzeItem* item;
const gchar* uri;
item = (KatzeItem*)g_object_get_data (G_OBJECT (menuitem), "KatzeItem");
uri = katze_item_get_uri (item);
if (uri && *uri)
midori_browser_edit_bookmark_dialog_new (browser, item, TRUE);
}
static void
midori_browser_bookmark_edit_activate_cb (GtkWidget* menuitem,
MidoriBrowser* browser)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Refactor bookmark context menu, apply it on the bookmarkbar
2008-10-30 01:19:52 +00:00
KatzeItem* item;
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
const gchar* uri;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Refactor bookmark context menu, apply it on the bookmarkbar
2008-10-30 01:19:52 +00:00
item = (KatzeItem*)g_object_get_data (G_OBJECT (menuitem), "KatzeItem");
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
uri = katze_item_get_uri (item);
Refactor bookmark context menu, apply it on the bookmarkbar
2008-10-30 01:19:52 +00:00
if (KATZE_IS_ARRAY (item) || (uri && *uri))
midori_browser_edit_bookmark_dialog_new (browser, item, FALSE);
}
static void
midori_browser_bookmark_delete_activate_cb (GtkWidget* menuitem,
MidoriBrowser* browser)
{
KatzeItem* item;
const gchar* uri;
KatzeItem* parent;
item = (KatzeItem*)g_object_get_data (G_OBJECT (menuitem), "KatzeItem");
uri = katze_item_get_uri (item);
Marge some more of history and bookmark handling
2008-10-31 00:38:18 +00:00
/* FIXME: Even toplevel items should technically have a parent */
g_return_if_fail (katze_item_get_parent (item));
Refactor bookmark context menu, apply it on the bookmarkbar
2008-10-30 01:19:52 +00:00
if (KATZE_IS_ARRAY (item) || (uri && *uri))
{
parent = katze_item_get_parent (item);
katze_array_remove_item (KATZE_ARRAY (parent), item);
}
}
static void
midori_browser_bookmark_popup (GtkWidget* widget,
GdkEventButton* event,
KatzeItem* item,
gboolean history_item,
MidoriBrowser* browser)
{
GtkWidget* menu;
GtkWidget* menuitem;
menu = gtk_menu_new ();
Improve strings for the sake of better localization
2008-11-02 23:17:43 +00:00
midori_browser_bookmark_popup_item (menu, GTK_STOCK_OPEN, NULL,
Refactor bookmark context menu, apply it on the bookmarkbar
2008-10-30 01:19:52 +00:00
item, midori_browser_bookmark_open_activate_cb, browser);
Improve strings for the sake of better localization
2008-11-02 23:17:43 +00:00
midori_browser_bookmark_popup_item (menu, STOCK_TAB_NEW, _("Open in New _Tab"),
Refactor bookmark context menu, apply it on the bookmarkbar
2008-10-30 01:19:52 +00:00
item, midori_browser_bookmark_open_in_tab_activate_cb, browser);
Improve strings for the sake of better localization
2008-11-02 23:17:43 +00:00
midori_browser_bookmark_popup_item (menu, STOCK_WINDOW_NEW, _("Open in New _Window"),
Refactor bookmark context menu, apply it on the bookmarkbar
2008-10-30 01:19:52 +00:00
item, midori_browser_bookmark_open_in_window_activate_cb, browser);
if (history_item && !KATZE_IS_ARRAY (item))
Improve strings for the sake of better localization
2008-11-02 23:17:43 +00:00
midori_browser_bookmark_popup_item (menu, STOCK_BOOKMARK_ADD, NULL,
Refactor bookmark context menu, apply it on the bookmarkbar
2008-10-30 01:19:52 +00:00
item, midori_browser_bookmark_bookmark_activate_cb, browser);
menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
if (!history_item)
Improve strings for the sake of better localization
2008-11-02 23:17:43 +00:00
midori_browser_bookmark_popup_item (menu, GTK_STOCK_EDIT, NULL,
Refactor bookmark context menu, apply it on the bookmarkbar
2008-10-30 01:19:52 +00:00
item, midori_browser_bookmark_edit_activate_cb, browser);
Improve strings for the sake of better localization
2008-11-02 23:17:43 +00:00
midori_browser_bookmark_popup_item (menu, GTK_STOCK_DELETE, NULL,
Refactor bookmark context menu, apply it on the bookmarkbar
2008-10-30 01:19:52 +00:00
item, midori_browser_bookmark_delete_activate_cb, browser);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Refactor bookmark context menu, apply it on the bookmarkbar
2008-10-30 01:19:52 +00:00
sokoke_widget_popup (widget, GTK_MENU (menu),
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
event, SOKOKE_MENU_POSITION_CURSOR);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
static gboolean
midori_panel_bookmarks_button_release_event_cb (GtkWidget* widget,
GdkEventButton* event,
MidoriBrowser* browser)
{
Refactor a lot of tree view selection code into convenience
2008-08-29 01:20:31 +00:00
GtkTreeModel* model;
GtkTreeIter iter;
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
KatzeItem* item;
const gchar* uri;
gint n;
Refactor a lot of tree view selection code into convenience
2008-08-29 01:20:31 +00:00
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
if (event->button != 2 && event->button != 3)
return FALSE;
Refactor a lot of tree view selection code into convenience
2008-08-29 01:20:31 +00:00
if (sokoke_tree_view_get_selected_iter (GTK_TREE_VIEW (widget), &model, &iter))
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Refactor a lot of tree view selection code into convenience
2008-08-29 01:20:31 +00:00
gtk_tree_model_get (model, &iter, 0, &item, -1);
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
uri = katze_item_get_uri (item);
if (event->button == 2)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
if (uri && *uri)
{
n = midori_browser_add_uri (browser, uri);
midori_browser_set_current_page (browser, n);
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
Refactor a lot of tree view selection code into convenience
2008-08-29 01:20:31 +00:00
else
Refactor bookmark context menu, apply it on the bookmarkbar
2008-10-30 01:19:52 +00:00
midori_browser_bookmark_popup (widget, event, item, FALSE, browser);
Refactor a lot of tree view selection code into convenience
2008-08-29 01:20:31 +00:00
return TRUE;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
return FALSE;
}
static void
midori_panel_bookmarks_popup_menu_cb (GtkWidget* widget,
MidoriBrowser* browser)
{
Refactor a lot of tree view selection code into convenience
2008-08-29 01:20:31 +00:00
GtkTreeModel* model;
GtkTreeIter iter;
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
KatzeItem* item;
Refactor a lot of tree view selection code into convenience
2008-08-29 01:20:31 +00:00
if (sokoke_tree_view_get_selected_iter (GTK_TREE_VIEW (widget), &model, &iter))
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Refactor a lot of tree view selection code into convenience
2008-08-29 01:20:31 +00:00
gtk_tree_model_get (model, &iter, 0, &item, -1);
Refactor bookmark context menu, apply it on the bookmarkbar
2008-10-30 01:19:52 +00:00
midori_browser_bookmark_popup (widget, NULL, item, FALSE, browser);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
}
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
static void
midori_panel_history_row_activated_cb (GtkTreeView* treeview,
GtkTreePath* path,
GtkTreeViewColumn* column,
MidoriBrowser* browser)
{
KatzeItem* item;
GtkTreeModel* model;
GtkTreeIter iter;
const gchar* uri;
model = gtk_tree_view_get_model (treeview);
if (gtk_tree_model_get_iter (model, &iter, path))
{
gtk_tree_model_get (model, &iter, 0, &item, -1);
if (KATZE_IS_ITEM (item))
{
uri = katze_item_get_uri (item);
Add an Open external pages in Preference
2008-10-20 06:50:16 +00:00
midori_browser_set_current_uri (browser, uri);
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
}
g_object_unref (item);
}
}
Small adjustments to the History panel Based on suggestions by Dale
2008-11-06 00:32:42 +00:00
static void
midori_panel_history_cursor_or_row_changed_cb (GtkTreeView* tree_view,
MidoriBrowser* browser)
{
GtkTreeModel* model;
GtkTreeIter iter;
KatzeItem* item;
gboolean is_page;
if (sokoke_tree_view_get_selected_iter (tree_view, &model, &iter))
{
gtk_tree_model_get (model, &iter, 0, &item, -1);
is_page = !KATZE_IS_ARRAY (item) && katze_item_get_uri (item);
_action_set_sensitive (browser, "HistoryAddBookmark", is_page);
}
else
{
_action_set_sensitive (browser, "HistoryAddBookmark", FALSE);
}
}
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
static void
_midori_panel_history_popup (GtkWidget* widget,
GdkEventButton* event,
KatzeItem* item,
MidoriBrowser* browser)
{
Refactor bookmark context menu, apply it on the bookmarkbar
2008-10-30 01:19:52 +00:00
midori_browser_bookmark_popup (widget, event, item, TRUE, browser);
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
}
static gboolean
midori_panel_history_button_release_event_cb (GtkWidget* widget,
GdkEventButton* event,
MidoriBrowser* browser)
{
GtkTreeModel* model;
GtkTreeIter iter;
KatzeItem* item;
const gchar* uri;
gint n;
if (event->button != 2 && event->button != 3)
return FALSE;
if (sokoke_tree_view_get_selected_iter (GTK_TREE_VIEW (widget),
&model, &iter))
{
gtk_tree_model_get (model, &iter, 0, &item, -1);
uri = katze_item_get_uri (item);
if (event->button == 2)
{
if (uri && *uri)
{
n = midori_browser_add_uri (browser, uri);
midori_browser_set_current_page (browser, n);
}
}
else
_midori_panel_history_popup (widget, event, item, browser);
g_object_unref (item);
return TRUE;
}
return FALSE;
}
Show a dialog before clearing the history Plus you can now remove history items with Del.
2008-10-10 21:19:37 +00:00
static void
Marge some more of history and bookmark handling
2008-10-31 00:38:18 +00:00
midori_browser_model_remove_item (GtkTreeModel* model,
KatzeItem* item,
GtkTreeIter* iter)
Show a dialog before clearing the history Plus you can now remove history items with Del.
2008-10-10 21:19:37 +00:00
{
GtkTreeIter child_iter;
KatzeItem* child;
gint i, n;
Marge some more of history and bookmark handling
2008-10-31 00:38:18 +00:00
if (KATZE_IS_ARRAY (item))
Show a dialog before clearing the history Plus you can now remove history items with Del.
2008-10-10 21:19:37 +00:00
{
Marge some more of history and bookmark handling
2008-10-31 00:38:18 +00:00
n = katze_array_get_length (KATZE_ARRAY (item));
for (i = 0; i < n; i++)
Show a dialog before clearing the history Plus you can now remove history items with Del.
2008-10-10 21:19:37 +00:00
{
Marge some more of history and bookmark handling
2008-10-31 00:38:18 +00:00
child = katze_array_get_nth_item (KATZE_ARRAY (item), 0);
katze_array_remove_item (KATZE_ARRAY (item), child);
Show a dialog before clearing the history Plus you can now remove history items with Del.
2008-10-10 21:19:37 +00:00
}
Marge some more of history and bookmark handling
2008-10-31 00:38:18 +00:00
while (gtk_tree_model_iter_nth_child (model, &child_iter, iter, 0))
gtk_tree_store_remove (GTK_TREE_STORE (model), &child_iter);
Show a dialog before clearing the history Plus you can now remove history items with Del.
2008-10-10 21:19:37 +00:00
}
Marge some more of history and bookmark handling
2008-10-31 00:38:18 +00:00
gtk_tree_store_remove (GTK_TREE_STORE (model), iter);
g_object_unref (item);
Show a dialog before clearing the history Plus you can now remove history items with Del.
2008-10-10 21:19:37 +00:00
}
static gboolean
midori_panel_history_key_release_event_cb (GtkWidget* widget,
GdkEventKey* event,
MidoriBrowser* browser)
{
Marge some more of history and bookmark handling
2008-10-31 00:38:18 +00:00
GtkTreeView* treeview;
GtkTreeModel* model;
GtkTreeIter iter;
KatzeItem* item;
Implement sorting location items by the number of visits For the moment, a define in the code decides whether items are sorted based on when they were added or how often a page was visited. The 'visits' property and respective database column is unused (we keep it for compatibility). It turns out it's enough to store that information in the tree model. The visit based sorting is not enabled because it is simply delaying startup incredibly. It will have to be decided whether to introduce a preference, or always use a visited based sorting once the startup delay is fixed. History items are also deleted from the tree model now if they are too old, according to the preference.
2008-11-08 01:23:08 +00:00
GtkAction* location_action;
Marge some more of history and bookmark handling
2008-10-31 00:38:18 +00:00
Implement sorting location items by the number of visits For the moment, a define in the code decides whether items are sorted based on when they were added or how often a page was visited. The 'visits' property and respective database column is unused (we keep it for compatibility). It turns out it's enough to store that information in the tree model. The visit based sorting is not enabled because it is simply delaying startup incredibly. It will have to be decided whether to introduce a preference, or always use a visited based sorting once the startup delay is fixed. History items are also deleted from the tree model now if they are too old, according to the preference.
2008-11-08 01:23:08 +00:00
if (event->keyval != GDK_Delete)
return FALSE;
treeview = GTK_TREE_VIEW (widget);
if (sokoke_tree_view_get_selected_iter (treeview, &model, &iter))
Marge some more of history and bookmark handling
2008-10-31 00:38:18 +00:00
{
Implement sorting location items by the number of visits For the moment, a define in the code decides whether items are sorted based on when they were added or how often a page was visited. The 'visits' property and respective database column is unused (we keep it for compatibility). It turns out it's enough to store that information in the tree model. The visit based sorting is not enabled because it is simply delaying startup incredibly. It will have to be decided whether to introduce a preference, or always use a visited based sorting once the startup delay is fixed. History items are also deleted from the tree model now if they are too old, according to the preference.
2008-11-08 01:23:08 +00:00
location_action = _action_by_name (browser, "Location");
gtk_tree_model_get (model, &iter, 0, &item, -1);
midori_browser_model_remove_item (model, item, &iter);
midori_location_action_delete_item_from_uri (
MIDORI_LOCATION_ACTION (location_action), katze_item_get_uri (item));
Marge some more of history and bookmark handling
2008-10-31 00:38:18 +00:00
}
Show a dialog before clearing the history Plus you can now remove history items with Del.
2008-10-10 21:19:37 +00:00
return FALSE;
}
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
static void
midori_panel_history_popup_menu_cb (GtkWidget* widget,
MidoriBrowser* browser)
{
GtkTreeModel* model;
GtkTreeIter iter;
KatzeItem* item;
if (sokoke_tree_view_get_selected_iter (GTK_TREE_VIEW (widget),
&model, &iter))
{
gtk_tree_model_get (model, &iter, 0, &item, -1);
_midori_panel_history_popup (widget, NULL, item, browser);
g_object_unref (item);
}
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static void
midori_browser_bookmarks_item_render_icon_cb (GtkTreeViewColumn* column,
GtkCellRenderer* renderer,
GtkTreeModel* model,
GtkTreeIter* iter,
GtkWidget* treeview)
{
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
KatzeItem* item;
GdkPixbuf* pixbuf;
Fix tab closing for good
2008-07-14 19:14:57 +00:00
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
gtk_tree_model_get (model, iter, 0, &item, -1);
Marge some more of history and bookmark handling
2008-10-31 00:38:18 +00:00
g_assert (KATZE_IS_ITEM (item));
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Introduce MidoriWebList, second step of refactoring web search
2008-06-14 00:23:33 +00:00
/* TODO: Would it be better to not do this on every redraw? */
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
pixbuf = NULL;
if (KATZE_IS_ARRAY (item))
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
pixbuf = gtk_widget_render_icon (treeview, GTK_STOCK_DIRECTORY,
GTK_ICON_SIZE_MENU, NULL);
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
else if (katze_item_get_uri (item))
Implement KatzeNet as a generic URI loader KatzeNet can from now on be used where URIs are handled and one would have used libSoup and/ or local file handling as appropriate, whereas KatzeNet does both. Since we are displaying icons in several places KatzeNet also provides an icon loader that saves us from doublicating even more code. All bookmarks and also history items have icons now, since KatzeNet makes that incredibly easy. Search engines are also using favicons now, and right now custom icons don't work, we still need to fix that. Note that only icons are cached, nothing else and the code is known to have a hidden, hard to reproduce crasher which may appear when an icon is newly loaded.
2008-10-23 22:09:12 +00:00
/* FIXME: Implement icon_cb */
pixbuf = katze_net_load_icon (
MIDORI_BROWSER (gtk_widget_get_toplevel (treeview))->net,
katze_item_get_uri (item), NULL, treeview, treeview);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
g_object_set (renderer, "pixbuf", pixbuf, NULL);
if (pixbuf)
g_object_unref (pixbuf);
}
static void
midori_browser_bookmarks_item_render_text_cb (GtkTreeViewColumn* column,
GtkCellRenderer* renderer,
GtkTreeModel* model,
GtkTreeIter* iter,
GtkWidget* treeview)
{
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
KatzeItem* item;
Fix tab closing for good
2008-07-14 19:14:57 +00:00
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
gtk_tree_model_get (model, iter, 0, &item, -1);
Marge some more of history and bookmark handling
2008-10-31 00:38:18 +00:00
g_assert (KATZE_IS_ITEM (item));
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
if (KATZE_IS_ARRAY (item) || katze_item_get_uri (item))
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
g_object_set (renderer, "markup", NULL,
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
"text", katze_item_get_name (item), NULL);
else
g_object_set (renderer, "markup", _("<i>Separator</i>"), NULL);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
static void
midori_browser_menu_bookmarks_item_activate_cb (GtkWidget* widget,
MidoriBrowser* browser)
{
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
KatzeItem* item;
item = (KatzeItem*)g_object_get_data (G_OBJECT (widget), "KatzeItem");
Add an Open external pages in Preference
2008-10-20 06:50:16 +00:00
midori_browser_set_current_uri (browser, katze_item_get_uri (item));
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
gtk_widget_grab_focus (midori_browser_get_current_tab (browser));
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
Implement middle click on bookmarkbar items
2008-10-26 17:39:06 +00:00
static gboolean
midori_browser_bookmarkbar_item_button_press_event_cb (GtkWidget* toolitem,
GdkEventButton* event,
MidoriBrowser* browser)
{
KatzeItem* item;
gint n;
gboolean open_in_background;
if (event->button == 2)
{
item = (KatzeItem*)g_object_get_data (G_OBJECT (toolitem), "KatzeItem");
Revamp bookmarkbar items based on KatzeArrayAction Some refactoring in KatzeArrayAction and the addition of a function to create arbitrary bookmark tool items allows us to easily revamp the bookmarkbar so that it finally reflectls changes to the bookmarks, including adding and removing items.
2008-10-26 21:22:26 +00:00
if (katze_item_get_uri (item))
{
g_object_get (browser->settings, "open-tabs-in-the-background",
&open_in_background, NULL);
n = midori_browser_add_uri (browser, katze_item_get_uri (item));
if (!open_in_background)
midori_browser_set_current_page (browser, n);
return TRUE;
}
Implement middle click on bookmarkbar items
2008-10-26 17:39:06 +00:00
}
else if (event->button == 3)
{
Refactor bookmark context menu, apply it on the bookmarkbar
2008-10-30 01:19:52 +00:00
item = (KatzeItem*)g_object_get_data (G_OBJECT (toolitem), "KatzeItem");
midori_browser_bookmark_popup (toolitem, NULL, item, FALSE, browser);
Implement middle click on bookmarkbar items
2008-10-26 17:39:06 +00:00
return TRUE;
}
return FALSE;
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static void
Change a few strings, particularly New Bookmark => Add Bookmark
2008-06-01 14:40:44 +00:00
_action_bookmark_add_activate (GtkAction* action,
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
MidoriBrowser* browser)
{
Allow adding bookmarks from history items
2008-10-29 02:43:08 +00:00
midori_browser_edit_bookmark_dialog_new (browser, NULL, TRUE);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
static void
midori_browser_history_render_icon_cb (GtkTreeViewColumn* column,
GtkCellRenderer* renderer,
GtkTreeModel* model,
GtkTreeIter* iter,
GtkWidget* treeview)
{
KatzeItem* item;
GdkPixbuf* pixbuf = NULL;
gtk_tree_model_get (model, iter, 0, &item, -1);
Marge some more of history and bookmark handling
2008-10-31 00:38:18 +00:00
g_assert (KATZE_IS_ITEM (item));
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
if (KATZE_IS_ARRAY (item))
pixbuf = gtk_widget_render_icon (treeview, GTK_STOCK_DIRECTORY,
GTK_ICON_SIZE_MENU, NULL);
else
Implement KatzeNet as a generic URI loader KatzeNet can from now on be used where URIs are handled and one would have used libSoup and/ or local file handling as appropriate, whereas KatzeNet does both. Since we are displaying icons in several places KatzeNet also provides an icon loader that saves us from doublicating even more code. All bookmarks and also history items have icons now, since KatzeNet makes that incredibly easy. Search engines are also using favicons now, and right now custom icons don't work, we still need to fix that. Note that only icons are cached, nothing else and the code is known to have a hidden, hard to reproduce crasher which may appear when an icon is newly loaded.
2008-10-23 22:09:12 +00:00
/* FIXME: Implement icon_cb */
pixbuf = katze_net_load_icon (
MIDORI_BROWSER (gtk_widget_get_toplevel (treeview))->net,
katze_item_get_uri (item), NULL, treeview, treeview);
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
g_object_set (renderer, "pixbuf", pixbuf, NULL);
if (pixbuf)
g_object_unref (pixbuf);
g_object_unref (item);
}
static void
midori_browser_history_render_text_cb (GtkTreeViewColumn* column,
GtkCellRenderer* renderer,
GtkTreeModel* model,
GtkTreeIter* iter,
GtkWidget* treeview)
{
KatzeItem* item;
Small adjustments to the History panel Based on suggestions by Dale
2008-11-06 00:32:42 +00:00
time_t date;
gchar datebuf[50];
Display relative dates in History panel
2008-10-23 23:35:34 +00:00
char* sdate;
gint age;
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
Display relative dates in History panel
2008-10-23 23:35:34 +00:00
gtk_tree_model_get (model, iter, 0, &item, 1, &age, -1);
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
Small adjustments to the History panel Based on suggestions by Dale
2008-11-06 00:32:42 +00:00
g_assert (KATZE_IS_ITEM (item));
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
if (KATZE_IS_ARRAY (item))
Implement number of days history is saved Note that this will 'break' any existing history and all dates will suddenly jump the beginning of the unix epoch.
2008-10-15 23:31:47 +00:00
{
Small adjustments to the History panel Based on suggestions by Dale
2008-11-06 00:32:42 +00:00
g_assert (age >= 0);
Display relative dates in History panel
2008-10-23 23:35:34 +00:00
Small adjustments to the History panel Based on suggestions by Dale
2008-11-06 00:32:42 +00:00
if (age > 7)
{
date = (time_t)katze_item_get_added (item);
strftime (datebuf, sizeof (datebuf), "%Y-%m-%d", localtime (&date));
g_object_set (renderer, "text", datebuf, NULL);
}
else if (age > 6)
{
sdate = g_strdup_printf (_("A week ago"));
g_object_set (renderer, "text", sdate, NULL);
g_free (sdate);
}
else if (age > 1)
Display relative dates in History panel
2008-10-23 23:35:34 +00:00
{
sdate = g_strdup_printf (_("%d days ago"), age);
g_object_set (renderer, "text", sdate, NULL);
g_free (sdate);
}
else
{
if (age == 0)
sdate = _("Today");
else
sdate = _("Yesterday");
g_object_set (renderer, "text", sdate, NULL);
}
Implement number of days history is saved Note that this will 'break' any existing history and all dates will suddenly jump the beginning of the unix epoch.
2008-10-15 23:31:47 +00:00
}
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
else
g_object_set (renderer, "text", katze_item_get_name (item), NULL);
g_object_unref (item);
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static void
_action_manage_search_engines_activate (GtkAction* action,
MidoriBrowser* browser)
{
Improve SearchEntry and add Manage Search Engines to popup
2008-06-21 21:57:20 +00:00
GtkWidget* dialog;
Complete move of webSearch, third step of refactoring web search
2008-06-15 02:02:56 +00:00
Implement the search widget as an action The most part of the search entry code is merely moved to the new action. We remove the original entry now, the action is all we need.
2008-10-05 21:25:02 +00:00
dialog = midori_search_action_get_dialog (
MIDORI_SEARCH_ACTION (_action_by_name (browser, "Search")));
Improve SearchEntry and add Manage Search Engines to popup
2008-06-21 21:57:20 +00:00
if (GTK_WIDGET_VISIBLE (dialog))
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
gtk_window_present (GTK_WINDOW (dialog));
else
gtk_widget_show (dialog);
}
static void
_action_tab_previous_activate (GtkAction* action,
MidoriBrowser* browser)
{
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gint n = gtk_notebook_get_current_page (GTK_NOTEBOOK (browser->notebook));
gtk_notebook_set_current_page (GTK_NOTEBOOK (browser->notebook), n - 1);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
static void
_action_tab_next_activate (GtkAction* action,
MidoriBrowser* browser)
{
Introduce MidoriWebList, second step of refactoring web search
2008-06-14 00:23:33 +00:00
/* Advance one tab or jump to the first one if we are at the last one */
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gint n = gtk_notebook_get_current_page (GTK_NOTEBOOK (browser->notebook));
if (n == gtk_notebook_get_n_pages (GTK_NOTEBOOK (browser->notebook)) - 1)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
n = -1;
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_notebook_set_current_page (GTK_NOTEBOOK (browser->notebook), n + 1);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
static const gchar* credits_authors[] = {
"Christian Dywan <christian@twotoasts.de>", NULL };
Integrate documentation, bug tracker and website
2008-10-03 20:23:00 +00:00
static const gchar* credits_documenters[] = {
Improve OSX adjustments in various places
2008-10-25 22:54:57 +00:00
"Christian Dywan <christian@twotoasts.de>", NULL };
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static const gchar* credits_artists[] = {
"Nancy Runge <nancy@twotoasts.de>", NULL };
static const gchar* license =
"This library is free software; you can redistribute it and/or\n"
"modify it under the terms of the GNU Lesser General Public\n"
"License as published by the Free Software Foundation; either\n"
"version 2.1 of the License, or (at your option) any later version.\n";
Integrate documentation, bug tracker and website
2008-10-03 20:23:00 +00:00
static void
_action_about_activate_link (GtkAboutDialog* about,
const gchar* link,
gpointer user_data)
{
MidoriBrowser* browser;
gint n;
browser = MIDORI_BROWSER (user_data);
n = midori_browser_add_uri (browser, link);
midori_browser_set_current_page (browser, n);
}
static void
_action_about_activate_email (GtkAboutDialog* about,
const gchar* link,
gpointer user_data)
{
gchar* command = g_strconcat ("xdg-open ", link, NULL);
g_spawn_command_line_async (command, NULL);
g_free (command);
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static void
_action_about_activate (GtkAction* action,
MidoriBrowser* browser)
{
Integrate documentation, bug tracker and website
2008-10-03 20:23:00 +00:00
gtk_about_dialog_set_email_hook (_action_about_activate_email, NULL, NULL);
gtk_about_dialog_set_url_hook (_action_about_activate_link, browser, NULL);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
gtk_show_about_dialog (GTK_WINDOW (browser),
"logo-icon-name", gtk_window_get_icon_name (GTK_WINDOW (browser)),
"name", PACKAGE_NAME,
"version", PACKAGE_VERSION,
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
"comments", _("A lightweight web browser."),
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
"copyright", "Copyright © 2007-2008 Christian Dywan",
Show news feeds in a menu if the icon is clicked
2008-08-02 02:25:05 +00:00
"website", "http://www.twotoasts.de",
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
"authors", credits_authors,
"documenters", credits_documenters,
"artists", credits_artists,
"license", license,
"wrap-license", TRUE,
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
"translator-credits", _("translator-credits"),
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
NULL);
}
Enable Help > Contents to open the FAQ on the web.
2008-09-07 20:41:03 +00:00
static void
Integrate documentation, bug tracker and website
2008-10-03 20:23:00 +00:00
_action_help_link_activate (GtkAction* action,
MidoriBrowser* browser)
Enable Help > Contents to open the FAQ on the web.
2008-09-07 20:41:03 +00:00
{
Integrate documentation, bug tracker and website
2008-10-03 20:23:00 +00:00
const gchar* action_name;
const gchar* uri;
Enable Help > Contents to open the FAQ on the web.
2008-09-07 20:41:03 +00:00
gint n;
Integrate documentation, bug tracker and website
2008-10-03 20:23:00 +00:00
action_name = gtk_action_get_name (action);
if (!strncmp ("HelpContents", action_name, 12))
{
#ifdef DOCDIR
uri = DOCDIR "/midori/user/midori.html";
if (!g_file_test (uri, G_FILE_TEST_EXISTS))
uri = "error:nodocs " DOCDIR "/midori/user/midori.html";
#else
uri = "error:nodocs " DATADIR "/doc/midori/user/midori.html";
#endif
}
else if (!strncmp ("HelpFAQ", action_name, 7))
uri = "http://wiki.xfce.org/_export/xhtml/midori_faq";
else if (!strncmp ("HelpBugs", action_name, 8))
uri = "http://www.twotoasts.de/bugs/";
else
uri = NULL;
if (uri)
{
n = midori_browser_add_uri (browser, uri);
midori_browser_set_current_page (browser, n);
}
Enable Help > Contents to open the FAQ on the web.
2008-09-07 20:41:03 +00:00
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static void
_action_panel_activate (GtkToggleAction* action,
MidoriBrowser* browser)
{
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
gboolean active = gtk_toggle_action_get_active (action);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
g_object_set (browser->settings, "show-panel", active, NULL);
sokoke_widget_set_visible (browser->panel, active);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
static void
_action_open_in_panel_activate (GtkAction* action,
MidoriBrowser* browser)
{
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
GtkWidget* view;
const gchar* uri;
gint n;
view = midori_browser_get_current_tab (browser);
uri = midori_view_get_display_uri (MIDORI_VIEW (view));
Introduce MidoriWebList, second step of refactoring web search
2008-06-14 00:23:33 +00:00
/* FIXME: Don't assign the uri here, update it properly while navigating */
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
g_object_set (browser->settings, "last-pageholder-uri", uri, NULL);
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
n = midori_panel_page_num (MIDORI_PANEL (browser->panel),
browser->panel_pageholder);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
midori_panel_set_current_page (MIDORI_PANEL (browser->panel), n);
gtk_widget_show (browser->panel);
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
midori_view_set_uri (MIDORI_VIEW (browser->panel_pageholder), uri);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
static void
midori_panel_notify_position_cb (GObject* object,
GParamSpec* arg1,
MidoriBrowser* browser)
{
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
gboolean position = gtk_paned_get_position (GTK_PANED (object));
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
g_object_set (browser->settings, "last-panel-position", position, NULL);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
static gboolean
midori_panel_close_cb (MidoriPanel* panel,
MidoriBrowser* browser)
{
Append the closed tabs items as a proper submenu.
2008-04-06 23:15:09 +00:00
_action_set_active (browser, "Panel", FALSE);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
return FALSE;
}
static void
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
gtk_notebook_switch_page_cb (GtkWidget* notebook,
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
GtkNotebookPage* page,
guint page_num,
MidoriBrowser* browser)
{
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
GtkWidget* view;
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
const gchar* uri;
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
GtkAction* action;
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
const gchar* title;
gchar* window_title;
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
view = midori_browser_get_current_tab (browser);
uri = midori_view_get_display_uri (MIDORI_VIEW (view));
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
action = _action_by_name (browser, "Location");
midori_location_action_set_uri (MIDORI_LOCATION_ACTION (action), uri);
Introduce MidoriLocationEntry and GtkIconEntry
2008-07-17 19:02:14 +00:00
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
title = midori_view_get_display_title (MIDORI_VIEW (view));
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
window_title = g_strconcat (title, " - ",
g_get_application_name (), NULL);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
gtk_window_set_title (GTK_WINDOW (browser), window_title);
g_free (window_title);
Save the session whenever it changes, instead of on quit.
2008-07-23 18:17:13 +00:00
g_object_notify (G_OBJECT (browser), "uri");
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
_midori_browser_set_statusbar_text (browser, NULL);
_midori_browser_update_interface (browser);
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
_midori_browser_update_progress (browser, MIDORI_VIEW (view));
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
static void
_action_history_delete_activate (GtkAction* action,
MidoriBrowser* browser)
{
Marge some more of history and bookmark handling
2008-10-31 00:38:18 +00:00
GtkTreeView* treeview;
GtkTreeModel* model;
GtkTreeIter iter;
KatzeItem* item;
Implement sorting location items by the number of visits For the moment, a define in the code decides whether items are sorted based on when they were added or how often a page was visited. The 'visits' property and respective database column is unused (we keep it for compatibility). It turns out it's enough to store that information in the tree model. The visit based sorting is not enabled because it is simply delaying startup incredibly. It will have to be decided whether to introduce a preference, or always use a visited based sorting once the startup delay is fixed. History items are also deleted from the tree model now if they are too old, according to the preference.
2008-11-08 01:23:08 +00:00
GtkAction* location_action;
Marge some more of history and bookmark handling
2008-10-31 00:38:18 +00:00
treeview = GTK_TREE_VIEW (browser->panel_history);
if (sokoke_tree_view_get_selected_iter (treeview, &model, &iter))
{
Implement sorting location items by the number of visits For the moment, a define in the code decides whether items are sorted based on when they were added or how often a page was visited. The 'visits' property and respective database column is unused (we keep it for compatibility). It turns out it's enough to store that information in the tree model. The visit based sorting is not enabled because it is simply delaying startup incredibly. It will have to be decided whether to introduce a preference, or always use a visited based sorting once the startup delay is fixed. History items are also deleted from the tree model now if they are too old, according to the preference.
2008-11-08 01:23:08 +00:00
location_action = _action_by_name (browser, "Location");
Marge some more of history and bookmark handling
2008-10-31 00:38:18 +00:00
gtk_tree_model_get (model, &iter, 0, &item, -1);
midori_browser_model_remove_item (model, item, &iter);
Implement sorting location items by the number of visits For the moment, a define in the code decides whether items are sorted based on when they were added or how often a page was visited. The 'visits' property and respective database column is unused (we keep it for compatibility). It turns out it's enough to store that information in the tree model. The visit based sorting is not enabled because it is simply delaying startup incredibly. It will have to be decided whether to introduce a preference, or always use a visited based sorting once the startup delay is fixed. History items are also deleted from the tree model now if they are too old, according to the preference.
2008-11-08 01:23:08 +00:00
midori_location_action_delete_item_from_uri (
MIDORI_LOCATION_ACTION (location_action), katze_item_get_uri (item));
Marge some more of history and bookmark handling
2008-10-31 00:38:18 +00:00
}
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
}
static void
_action_history_clear_activate (GtkAction* action,
MidoriBrowser* browser)
{
Show a dialog before clearing the history Plus you can now remove history items with Del.
2008-10-10 21:19:37 +00:00
GtkWidget* dialog;
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
GtkTreeView* tree_view;
GtkTreeStore* store;
KatzeItem* item;
Implement sorting location items by the number of visits For the moment, a define in the code decides whether items are sorted based on when they were added or how often a page was visited. The 'visits' property and respective database column is unused (we keep it for compatibility). It turns out it's enough to store that information in the tree model. The visit based sorting is not enabled because it is simply delaying startup incredibly. It will have to be decided whether to introduce a preference, or always use a visited based sorting once the startup delay is fixed. History items are also deleted from the tree model now if they are too old, according to the preference.
2008-11-08 01:23:08 +00:00
GtkAction* location_action;
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
gint i, n;
Show a dialog before clearing the history Plus you can now remove history items with Del.
2008-10-10 21:19:37 +00:00
gint result;
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
if (!browser->history)
return;
Show a dialog before clearing the history Plus you can now remove history items with Del.
2008-10-10 21:19:37 +00:00
dialog = gtk_message_dialog_new (GTK_WINDOW (browser),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
_("Are you sure you want to remove all history items?"));
result = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
if (result != GTK_RESPONSE_YES)
return;
Implement sorting location items by the number of visits For the moment, a define in the code decides whether items are sorted based on when they were added or how often a page was visited. The 'visits' property and respective database column is unused (we keep it for compatibility). It turns out it's enough to store that information in the tree model. The visit based sorting is not enabled because it is simply delaying startup incredibly. It will have to be decided whether to introduce a preference, or always use a visited based sorting once the startup delay is fixed. History items are also deleted from the tree model now if they are too old, according to the preference.
2008-11-08 01:23:08 +00:00
location_action = _action_by_name (browser, "Location");
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
tree_view = GTK_TREE_VIEW (browser->panel_history);
store = GTK_TREE_STORE (gtk_tree_view_get_model (tree_view));
gtk_tree_store_clear (store);
n = katze_array_get_length (browser->history);
for (i = 0; i < n; i++)
{
item = katze_array_get_nth_item (browser->history, i);
katze_array_clear (KATZE_ARRAY (item));
}
katze_array_clear (browser->history);
Implement sorting location items by the number of visits For the moment, a define in the code decides whether items are sorted based on when they were added or how often a page was visited. The 'visits' property and respective database column is unused (we keep it for compatibility). It turns out it's enough to store that information in the tree model. The visit based sorting is not enabled because it is simply delaying startup incredibly. It will have to be decided whether to introduce a preference, or always use a visited based sorting once the startup delay is fixed. History items are also deleted from the tree model now if they are too old, according to the preference.
2008-11-08 01:23:08 +00:00
midori_location_action_clear (MIDORI_LOCATION_ACTION (location_action));
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
}
Allow adding bookmarks from history items
2008-10-29 02:43:08 +00:00
static void
_action_history_add_bookmark_activate (GtkAction* action,
MidoriBrowser* browser)
{
GtkTreeView* tree_view;
GtkTreeModel* model;
GtkTreeIter iter;
KatzeItem* item;
tree_view = GTK_TREE_VIEW (browser->panel_history);
if (sokoke_tree_view_get_selected_iter (tree_view, &model, &iter))
{
gtk_tree_model_get (model, &iter, 0, &item, -1);
Small adjustments to the History panel Based on suggestions by Dale
2008-11-06 00:32:42 +00:00
if (!KATZE_IS_ARRAY (item))
midori_browser_edit_bookmark_dialog_new (browser, item, TRUE);
Allow adding bookmarks from history items
2008-10-29 02:43:08 +00:00
g_object_unref (item);
}
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static void
Build fix: Accidentally removed the wrong action.
2008-03-10 21:48:12 +00:00
_action_undo_tab_close_activate (GtkAction* action,
MidoriBrowser* browser)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Use the right index for Undo Close Tab.
2008-08-24 01:05:00 +00:00
guint last;
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
KatzeItem* item;
Use the right index for Undo Close Tab.
2008-08-24 01:05:00 +00:00
guint n;
Introduce MidoriWebList, second step of refactoring web search
2008-06-14 00:23:33 +00:00
/* Reopen the most recent trash item */
Rework MidoriWebList into KatzeList and KatzeArray
2008-08-25 23:19:38 +00:00
last = katze_array_get_length (browser->trash) - 1;
item = katze_array_get_nth_item (browser->trash, last);
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
n = midori_browser_add_item (browser, item);
Attempt to fix handling of background and foreground tabs.
2008-04-24 22:20:43 +00:00
midori_browser_set_current_page (browser, n);
Rework MidoriWebList into KatzeList and KatzeArray
2008-08-25 23:19:38 +00:00
katze_array_remove_item (browser->trash, item);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
_midori_browser_update_actions (browser);
}
static void
_action_trash_empty_activate (GtkAction* action,
MidoriBrowser* browser)
{
Rework MidoriWebList into KatzeList and KatzeArray
2008-08-25 23:19:38 +00:00
katze_array_clear (browser->trash);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
_midori_browser_update_actions (browser);
}
Refactor bookmark context menu, apply it on the bookmarkbar
2008-10-30 01:19:52 +00:00
static void
_action_bookmark_edit_activate (GtkAction* action,
MidoriBrowser* browser)
{
GtkTreeView* tree_view;
GtkTreeModel* model;
GtkTreeIter iter;
KatzeItem* item;
tree_view = GTK_TREE_VIEW (browser->panel_bookmarks);
if (sokoke_tree_view_get_selected_iter (tree_view, &model, &iter))
{
gtk_tree_model_get (model, &iter, 0, &item, -1);
if (KATZE_IS_ARRAY (item) || katze_item_get_uri (item))
midori_browser_edit_bookmark_dialog_new (browser, item, FALSE);
}
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static void
Make WebList more flexible so it can replace Trash
2008-06-24 19:54:01 +00:00
_action_bookmark_delete_activate (GtkAction* action,
Implement the Console panel for script messages.
2008-03-27 00:21:29 +00:00
MidoriBrowser* browser)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Refactor a lot of tree view selection code into convenience
2008-08-29 01:20:31 +00:00
GtkTreeView* tree_view;
GtkTreeModel* model;
GtkTreeIter iter;
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
KatzeItem* item;
KatzeArray* parent;
Refactor a lot of tree view selection code into convenience
2008-08-29 01:20:31 +00:00
tree_view = GTK_TREE_VIEW (browser->panel_bookmarks);
if (sokoke_tree_view_get_selected_iter (tree_view, &model, &iter))
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Refactor a lot of tree view selection code into convenience
2008-08-29 01:20:31 +00:00
gtk_tree_model_get (model, &iter, 0, &item, -1);
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
parent = katze_item_get_parent (item);
katze_array_remove_item (parent, item);
/* FIXME: This is a preliminary hack, until we fix it properly again */
Refactor a lot of tree view selection code into convenience
2008-08-29 01:20:31 +00:00
gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
g_object_unref (item);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
}
static const GtkActionEntry entries[] = {
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
{ "File", NULL, N_("_File") },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "WindowNew", STOCK_WINDOW_NEW,
NULL, "<Ctrl>n",
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
N_("Open a new window"), G_CALLBACK (_action_window_new_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "TabNew", STOCK_TAB_NEW,
NULL, "<Ctrl>t",
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
N_("Open a new tab"), G_CALLBACK (_action_tab_new_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "Open", GTK_STOCK_OPEN,
NULL, "<Ctrl>o",
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
N_("Open a file"), G_CALLBACK (_action_open_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "SaveAs", GTK_STOCK_SAVE_AS,
NULL, "<Ctrl>s",
Implement Save As functionality
2008-10-26 16:07:59 +00:00
N_("Save to a file"), G_CALLBACK (_action_save_as_activate) },
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
{ "TabClose", NULL,
N_("_Close Tab"), "<Ctrl>w",
N_("Close the current tab"), G_CALLBACK (_action_tab_close_activate) },
{ "WindowClose", NULL,
N_("C_lose Window"), "<Ctrl><Shift>w",
N_("Close this window"), G_CALLBACK (_action_window_close_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "Print", GTK_STOCK_PRINT,
NULL, "<Ctrl>p",
Fill in discriptions for tooltips
2008-06-01 12:08:48 +00:00
N_("Print the current page"), G_CALLBACK (_action_print_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "Quit", GTK_STOCK_QUIT,
NULL, "<Ctrl>q",
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
N_("Quit the application"), G_CALLBACK (_action_quit_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
{ "Edit", NULL, N_("_Edit"), NULL, NULL, G_CALLBACK (_action_edit_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "Cut", GTK_STOCK_CUT,
NULL, "<Ctrl>x",
Fill in discriptions for tooltips
2008-06-01 12:08:48 +00:00
N_("Cut the selected text"), G_CALLBACK (_action_cut_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "Copy", GTK_STOCK_COPY,
NULL, "<Ctrl>c",
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
N_("Copy the selected text"), G_CALLBACK (_action_copy_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "Copy_", GTK_STOCK_COPY,
NULL, "<Ctrl>c",
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
N_("Copy the selected text"), G_CALLBACK (_action_copy_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "Paste", GTK_STOCK_PASTE,
NULL, "<Ctrl>v",
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
N_("Paste text from the clipboard"), G_CALLBACK (_action_paste_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "Delete", GTK_STOCK_DELETE,
NULL, NULL,
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
N_("Delete the selected text"), G_CALLBACK (_action_delete_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "SelectAll", GTK_STOCK_SELECT_ALL,
NULL, "<Ctrl>a",
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
N_("Select all text"), G_CALLBACK (_action_select_all_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "Find", GTK_STOCK_FIND,
NULL, "<Ctrl>f",
Fill in discriptions for tooltips
2008-06-01 12:08:48 +00:00
N_("Find a word or phrase in the page"), G_CALLBACK (_action_find_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "FindNext", GTK_STOCK_GO_FORWARD,
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
N_("Find _Next"), "<Ctrl>g",
Fill in discriptions for tooltips
2008-06-01 12:08:48 +00:00
N_("Find the next occurrence of a word or phrase"), G_CALLBACK (_action_find_next_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "FindPrevious", GTK_STOCK_GO_BACK,
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
N_("Find _Previous"), "<Ctrl><Shift>g",
Initial support for the Web Inspector
2008-11-01 18:15:58 +00:00
N_("Find the previous occurrence of a word or phrase"),
G_CALLBACK (_action_find_previous_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "FindQuick", GTK_STOCK_FIND,
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
N_("_Quick Find"), "period",
Fill in discriptions for tooltips
2008-06-01 12:08:48 +00:00
N_("Quickly jump to a word or phrase"), NULL/*G_CALLBACK (_action_find_quick_activate)*/ },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "Preferences", GTK_STOCK_PREFERENCES,
NULL, "<Ctrl><Alt>p",
Fill in discriptions for tooltips
2008-06-01 12:08:48 +00:00
N_("Configure the application preferences"), G_CALLBACK (_action_preferences_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
{ "View", NULL, N_("_View") },
{ "Toolbars", NULL, N_("_Toolbars") },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "Reload", GTK_STOCK_REFRESH,
NULL, "<Ctrl>r",
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
N_("Reload the current page"), G_CALLBACK (_action_reload_stop_activate) },
Fix Reload/ Stop menu items. The menu items were sensitive in reversed logic and the Stop item had the icon and accelerator of the Reload item. Now the sensitivity is fixed and the Stop item is Stop again.
2008-04-03 21:33:32 +00:00
{ "Stop", GTK_STOCK_STOP,
NULL, "Escape",
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
N_("Stop loading the current page"), G_CALLBACK (_action_reload_stop_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "ReloadStop", GTK_STOCK_STOP,
NULL, "<Ctrl>r",
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
N_("Reload the current page"), G_CALLBACK (_action_reload_stop_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "ZoomIn", GTK_STOCK_ZOOM_IN,
NULL, "<Ctrl>plus",
Fill in discriptions for tooltips
2008-06-01 12:08:48 +00:00
N_("Increase the zoom level"), G_CALLBACK (_action_zoom_in_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "ZoomOut", GTK_STOCK_ZOOM_OUT,
NULL, "<Ctrl>minus",
Fill in discriptions for tooltips
2008-06-01 12:08:48 +00:00
N_("Decrease the zoom level"), G_CALLBACK (_action_zoom_out_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "ZoomNormal", GTK_STOCK_ZOOM_100,
NULL, "<Ctrl>0",
Fill in discriptions for tooltips
2008-06-01 12:08:48 +00:00
N_("Reset the zoom level"), G_CALLBACK (_action_zoom_normal_activate) },
Add common context menu items and cleanup. Add the actions UndoTabClose, BookmarkNew, SaveAs, SourceView and Print to the context menu. Also add UndoTabClose to the Go menu, remove STOCK_SOURCE_VIEW and remove ui.h which is obsolete.
2008-03-19 13:46:08 +00:00
{ "SourceView", NULL,
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
N_("View _Source"), "",
N_("View the source code of the page"), G_CALLBACK (_action_source_view_activate) },
Add common context menu items and cleanup. Add the actions UndoTabClose, BookmarkNew, SaveAs, SourceView and Print to the context menu. Also add UndoTabClose to the Go menu, remove STOCK_SOURCE_VIEW and remove ui.h which is obsolete.
2008-03-19 13:46:08 +00:00
{ "SelectionSourceView", NULL,
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
N_("View Selection Source"), "",
Initial support for the Web Inspector
2008-11-01 18:15:58 +00:00
N_("View the source code of the selection"),
NULL/*G_CALLBACK (_action_selection_source_view_activate)*/ },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "Fullscreen", GTK_STOCK_FULLSCREEN,
NULL, "F11",
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
N_("Toggle fullscreen view"), G_CALLBACK (_action_fullscreen_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
{ "Go", NULL, N_("_Go") },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "Back", GTK_STOCK_GO_BACK,
NULL, "<Alt>Left",
Fill in discriptions for tooltips
2008-06-01 12:08:48 +00:00
N_("Go back to the previous page"), G_CALLBACK (_action_back_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "Forward", GTK_STOCK_GO_FORWARD,
NULL, "<Alt>Right",
Fill in discriptions for tooltips
2008-06-01 12:08:48 +00:00
N_("Go forward to the next page"), G_CALLBACK (_action_forward_activate) },
Add Show Homepage option, remove Form Fill and Small Toolbar
2008-05-20 01:21:11 +00:00
{ "Homepage", STOCK_HOMEPAGE,
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
NULL, "<Alt>Home",
Fill in discriptions for tooltips
2008-06-01 12:08:48 +00:00
N_("Go to your homepage"), G_CALLBACK (_action_homepage_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "OpenInPageholder", GTK_STOCK_JUMP_TO,
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
N_("Open in Page_holder..."), "",
Fill in discriptions for tooltips
2008-06-01 12:08:48 +00:00
N_("Open the current page in the pageholder"), G_CALLBACK (_action_open_in_panel_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "TrashEmpty", GTK_STOCK_CLEAR,
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
N_("Empty Trash"), "",
Fill in discriptions for tooltips
2008-06-01 12:08:48 +00:00
N_("Delete the contents of the trash"), G_CALLBACK (_action_trash_empty_activate) },
Build fix: Accidentally removed the wrong action.
2008-03-10 21:48:12 +00:00
{ "UndoTabClose", GTK_STOCK_UNDELETE,
Use Ctrl+Shift+T for Undo Close Tab
2008-08-15 18:48:30 +00:00
N_("Undo Close Tab"), "<Ctrl><Shift>t",
Fill in discriptions for tooltips
2008-06-01 12:08:48 +00:00
N_("Open the last closed tab"), G_CALLBACK (_action_undo_tab_close_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Change a few strings, particularly New Bookmark => Add Bookmark
2008-06-01 14:40:44 +00:00
{ "BookmarkAdd", STOCK_BOOKMARK_ADD,
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
NULL, "<Ctrl>d",
Change a few strings, particularly New Bookmark => Add Bookmark
2008-06-01 14:40:44 +00:00
N_("Add a new bookmark"), G_CALLBACK (_action_bookmark_add_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "BookmarkEdit", GTK_STOCK_EDIT,
NULL, "",
Fill in discriptions for tooltips
2008-06-01 12:08:48 +00:00
N_("Edit the selected bookmark"), G_CALLBACK (_action_bookmark_edit_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "BookmarkDelete", GTK_STOCK_DELETE,
NULL, "",
Fill in discriptions for tooltips
2008-06-01 12:08:48 +00:00
N_("Delete the selected bookmark"), G_CALLBACK (_action_bookmark_delete_activate) },
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
{ "HistoryDelete", GTK_STOCK_DELETE,
NULL, "",
N_("Delete the selected history item"), G_CALLBACK (_action_history_delete_activate) },
{ "HistoryClear", GTK_STOCK_CLEAR,
NULL, "",
Implement Save As functionality
2008-10-26 16:07:59 +00:00
N_("Clear the entire history"), G_CALLBACK (_action_history_clear_activate) },
Allow adding bookmarks from history items
2008-10-29 02:43:08 +00:00
{ "HistoryAddBookmark", STOCK_BOOKMARK_ADD,
NULL, "",
Improve strings for the sake of better localization
2008-11-02 23:17:43 +00:00
N_("Bookmark the selected history item"),
Initial support for the Web Inspector
2008-11-01 18:15:58 +00:00
G_CALLBACK (_action_history_add_bookmark_activate) },
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
{ "Tools", NULL, N_("_Tools") },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "ManageSearchEngines", GTK_STOCK_PROPERTIES,
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
N_("_Manage Search Engines"), "<Ctrl><Alt>s",
N_("Add, edit and remove search engines..."),
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
G_CALLBACK (_action_manage_search_engines_activate) },
{ "TabPrevious", GTK_STOCK_GO_BACK,
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
N_("_Previous Tab"), "<Ctrl>Page_Up",
Fill in discriptions for tooltips
2008-06-01 12:08:48 +00:00
N_("Switch to the previous tab"), G_CALLBACK (_action_tab_previous_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "TabNext", GTK_STOCK_GO_FORWARD,
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
N_("_Next Tab"), "<Ctrl>Page_Down",
Fill in discriptions for tooltips
2008-06-01 12:08:48 +00:00
N_("Switch to the next tab"), G_CALLBACK (_action_tab_next_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
{ "Help", NULL, N_("_Help") },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "HelpContents", GTK_STOCK_HELP,
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
N_("_Contents"), "F1",
Integrate documentation, bug tracker and website
2008-10-03 20:23:00 +00:00
N_("Show the documentation"), G_CALLBACK (_action_help_link_activate) },
{ "HelpFAQ", NULL,
N_("_Frequent questions"), NULL,
N_("Show the Frequently Asked Questions"), G_CALLBACK (_action_help_link_activate) },
{ "HelpBugs", NULL,
N_("_Report a bug"), NULL,
N_("Open Midori's bug tracker"), G_CALLBACK (_action_help_link_activate) },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "About", GTK_STOCK_ABOUT,
NULL, "",
Fill in discriptions for tooltips
2008-06-01 12:08:48 +00:00
N_("Show information about the program"), G_CALLBACK (_action_about_activate) },
Keep otherwise unused actions in a Dummy This is needed for accelerators to work even if the according actions are not part of the permanent UI description.
2008-10-12 19:44:00 +00:00
{ "Dummy", NULL, "Dummy" },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
};
Fix panel close button.
2008-03-24 13:15:23 +00:00
static const guint entries_n = G_N_ELEMENTS (entries);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static const GtkToggleActionEntry toggle_entries[] = {
{ "PrivateBrowsing", NULL,
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
N_("P_rivate Browsing"), "",
Initial support for the Web Inspector
2008-11-01 18:15:58 +00:00
N_("Don't save any private data while browsing"),
NULL/*G_CALLBACK (_action_private_browsing_activate)*/,
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
FALSE },
Allow hiding the menubar and showing it again
2008-10-12 20:09:49 +00:00
{ "Menubar", NULL,
N_("_Menubar"), "",
N_("Show menubar"), G_CALLBACK (_action_menubar_activate),
FALSE },
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{ "Navigationbar", NULL,
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
N_("_Navigationbar"), "",
Fill in discriptions for tooltips
2008-06-01 12:08:48 +00:00
N_("Show navigationbar"), G_CALLBACK (_action_navigationbar_activate),
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
FALSE },
Do not localize object properties, except WebSettings Property name localization is only useful if the strings are meant to be used in a user interface, such as is the case with WebSettings, or for graphical interface builders, which are not of our concern, since we don't use Glade and friends and nobody else is going to use our widgets. In short, make translation work much easier.
2008-10-15 01:32:11 +00:00
{ "Panel", GTK_STOCK_INDENT,
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
N_("Side_panel"), "F9",
Fill in discriptions for tooltips
2008-06-01 12:08:48 +00:00
N_("Show sidepanel"), G_CALLBACK (_action_panel_activate),
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
FALSE },
{ "Bookmarkbar", NULL,
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
N_("_Bookmarkbar"), "",
Fill in discriptions for tooltips
2008-06-01 12:08:48 +00:00
N_("Show bookmarkbar"), G_CALLBACK (_action_bookmarkbar_activate),
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
FALSE },
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
{ "Transferbar", NULL,
N_("_Transferbar"), "",
Fill in discriptions for tooltips
2008-06-01 12:08:48 +00:00
N_("Show transferbar"), NULL/*G_CALLBACK (_action_transferbar_activate)*/,
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
FALSE },
{ "Statusbar", NULL,
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
N_("_Statusbar"), "",
Fill in discriptions for tooltips
2008-06-01 12:08:48 +00:00
N_("Show statusbar"), G_CALLBACK (_action_statusbar_activate),
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
FALSE },
};
Fix panel close button.
2008-03-24 13:15:23 +00:00
static const guint toggle_entries_n = G_N_ELEMENTS (toggle_entries);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static void
midori_browser_window_state_event_cb (MidoriBrowser* browser,
GdkEventWindowState* event)
{
if (event->changed_mask & GDK_WINDOW_STATE_FULLSCREEN)
{
if (event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN)
{
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_widget_hide (browser->menubar);
g_object_set (browser->button_fullscreen,
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
"stock-id", GTK_STOCK_LEAVE_FULLSCREEN, NULL);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_widget_show (browser->button_fullscreen);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
else
{
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_widget_show (browser->menubar);
gtk_widget_hide (browser->button_fullscreen);
g_object_set (browser->button_fullscreen,
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
"stock-id", GTK_STOCK_FULLSCREEN, NULL);
}
}
}
static void
midori_browser_size_allocate_cb (MidoriBrowser* browser,
GtkAllocation* allocation)
{
GtkWidget* widget = GTK_WIDGET (browser);
if (GTK_WIDGET_REALIZED (widget))
{
GdkWindowState state = gdk_window_get_state (widget->window);
if (!(state & (GDK_WINDOW_STATE_MAXIMIZED | GDK_WINDOW_STATE_FULLSCREEN)))
{
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
g_object_set (browser->settings,
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
"last-window-width", allocation->width,
"last-window-height", allocation->height, NULL);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
}
}
Implement MidoriApp singleton and improve multiple window support The new singleton holds the shared settings and trash. It is further more used to keep track of all open windows and quits when the last window was closed. It also watches the focus in case you need something like a "current" browser.
2008-05-22 22:17:10 +00:00
static void
midori_browser_destroy_cb (MidoriBrowser* browser)
{
Ensure REMOVE_TAB emission, don't alter session when destroying
2008-07-25 10:45:50 +00:00
/* Destroy tabs first, so child widgets don't need special care */
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_container_foreach (GTK_CONTAINER (browser->notebook),
Use 'midori' icon and update icon cache in waf
2008-05-31 12:20:36 +00:00
(GtkCallback) gtk_widget_destroy, NULL);
Implement MidoriApp singleton and improve multiple window support The new singleton holds the shared settings and trash. It is further more used to keep track of all open windows and quits when the last window was closed. It also watches the focus in case you need something like a "current" browser.
2008-05-22 22:17:10 +00:00
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static const gchar* ui_markup =
"<ui>"
"<menubar>"
"<menu action='File'>"
"<menuitem action='WindowNew'/>"
"<menuitem action='TabNew'/>"
"<separator/>"
"<menuitem action='Open'/>"
"<separator/>"
"<menuitem action='SaveAs'/>"
"<separator/>"
"<menuitem action='TabClose'/>"
"<menuitem action='WindowClose'/>"
"<separator/>"
"<menuitem action='Print'/>"
"<menuitem action='PrivateBrowsing'/>"
"<separator/>"
"<menuitem action='Quit'/>"
"</menu>"
"<menu action='Edit'>"
"<menuitem action='Cut'/>"
"<menuitem action='Copy'/>"
"<menuitem action='Paste'/>"
"<menuitem action='Delete'/>"
"<separator/>"
"<menuitem action='SelectAll'/>"
"<separator/>"
Move Find items to Edit again
2008-10-03 23:00:34 +00:00
"<menuitem action='Find'/>"
"<menuitem action='FindNext'/>"
"<separator/>"
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
"<menuitem action='Preferences'/>"
"</menu>"
"<menu action='View'>"
"<menu action='Toolbars'>"
Allow hiding the menubar and showing it again
2008-10-12 20:09:49 +00:00
"<menuitem action='Menubar'/>"
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
"<menuitem action='Navigationbar'/>"
"<menuitem action='Bookmarkbar'/>"
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
"<menuitem action='Transferbar'/>"
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
"<menuitem action='Statusbar'/>"
"</menu>"
"<menuitem action='Panel'/>"
"<separator/>"
"<menuitem action='Reload'/>"
"<menuitem action='Stop'/>"
"<separator/>"
"<menuitem action='ZoomIn'/>"
"<menuitem action='ZoomOut'/>"
"<menuitem action='ZoomNormal'/>"
"<separator/>"
"<menuitem action='SourceView'/>"
"<menuitem action='Fullscreen'/>"
"</menu>"
"<menu action='Go'>"
"<menuitem action='Back'/>"
"<menuitem action='Forward'/>"
Add Show Homepage option, remove Form Fill and Small Toolbar
2008-05-20 01:21:11 +00:00
"<menuitem action='Homepage'/>"
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
"<menuitem action='Location'/>"
"<menuitem action='Search'/>"
"<menuitem action='OpenInPageholder'/>"
Finish refactoring the toolbar to use only actions Finally the trash, which was the last item that needed to be implemented as an action, is an action, a KatzeArrayAction to be exact. This simplifies more code and also makes Window and RecentlyVisited generically implementable. Incidentally this change also fixes a bug where the browser tried to add a new tab when the last one was closed, even while destroying itself. Furthermore sokoke_image_menu_item_ellipsized and sokoke_widget_popup were promoted to Katze. We're still keeping the old functions for now.
2008-10-10 20:31:37 +00:00
"<menuitem action='Trash'/>"
/* "<menuitem action='RecentlyVisited'/>" */
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
"</menu>"
Finish refactoring the toolbar to use only actions Finally the trash, which was the last item that needed to be implemented as an action, is an action, a KatzeArrayAction to be exact. This simplifies more code and also makes Window and RecentlyVisited generically implementable. Incidentally this change also fixes a bug where the browser tried to add a new tab when the last one was closed, even while destroying itself. Furthermore sokoke_image_menu_item_ellipsized and sokoke_widget_popup were promoted to Katze. We're still keeping the old functions for now.
2008-10-10 20:31:37 +00:00
"<menuitem action='Bookmarks'/>"
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
"<menu action='Tools'>"
"<menuitem action='ManageSearchEngines'/>"
Introduce MidoriWebList, second step of refactoring web search
2008-06-14 00:23:33 +00:00
/* Panel items shall be appended here */
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
"</menu>"
Finish refactoring the toolbar to use only actions Finally the trash, which was the last item that needed to be implemented as an action, is an action, a KatzeArrayAction to be exact. This simplifies more code and also makes Window and RecentlyVisited generically implementable. Incidentally this change also fixes a bug where the browser tried to add a new tab when the last one was closed, even while destroying itself. Furthermore sokoke_image_menu_item_ellipsized and sokoke_widget_popup were promoted to Katze. We're still keeping the old functions for now.
2008-10-10 20:31:37 +00:00
"<menuitem action='Window'/>"
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
"<menu action='Help'>"
"<menuitem action='HelpContents'/>"
Integrate documentation, bug tracker and website
2008-10-03 20:23:00 +00:00
"<menuitem action='HelpFAQ'/>"
"<menuitem action='HelpBugs'/>"
"<separator/>"
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
"<menuitem action='About'/>"
"</menu>"
Keep otherwise unused actions in a Dummy This is needed for accelerators to work even if the according actions are not part of the permanent UI description.
2008-10-12 19:44:00 +00:00
/* For accelerators to work all actions need to be used
*somewhere* in the UI definition */
"<menu action='Dummy'>"
"<menuitem action='FindPrevious'/>"
"<menuitem action='TabPrevious'/>"
"<menuitem action='TabNext'/>"
Add UndoTabClose to the Dummy menu
2008-10-17 21:53:20 +00:00
"<menuitem action='UndoTabClose'/>"
Keep otherwise unused actions in a Dummy This is needed for accelerators to work even if the according actions are not part of the permanent UI description.
2008-10-12 19:44:00 +00:00
"<menuitem action='TrashEmpty'/>"
"</menu>"
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
"</menubar>"
"<toolbar name='toolbar_navigation'>"
"</toolbar>"
"<toolbar name='toolbar_bookmarks'>"
Change a few strings, particularly New Bookmark => Add Bookmark
2008-06-01 14:40:44 +00:00
"<toolitem action='BookmarkAdd'/>"
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
"<toolitem action='BookmarkEdit'/>"
"<toolitem action='BookmarkDelete'/>"
"</toolbar>"
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
"<toolbar name='toolbar_history'>"
Small adjustments to the History panel Based on suggestions by Dale
2008-11-06 00:32:42 +00:00
"<toolitem action='HistoryAddBookmark'/>"
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
"<toolitem action='HistoryDelete'/>"
Small adjustments to the History panel Based on suggestions by Dale
2008-11-06 00:32:42 +00:00
"<separator expand='true' />"
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
"<toolitem action='HistoryClear' position='bottom' />"
"</toolbar>"
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
"</ui>";
Use 'midori' icon and update icon cache in waf
2008-05-31 12:20:36 +00:00
static void
Add Midori and news-feed icons, improve waf scripts Add small, optimized application icons and an all new news-feed icon including optimized versions. The build scripts are updated, and the data folder renamed to icons. Plus the wscript_build is improved. Of course, Midori now tests the icon theme for news-feed and uses it.
2008-07-27 05:39:39 +00:00
midori_browser_realize_cb (GtkStyle* style,
MidoriBrowser* browser)
Use 'midori' icon and update icon cache in waf
2008-05-31 12:20:36 +00:00
{
Add Midori and news-feed icons, improve waf scripts Add small, optimized application icons and an all new news-feed icon including optimized versions. The build scripts are updated, and the data folder renamed to icons. Plus the wscript_build is improved. Of course, Midori now tests the icon theme for news-feed and uses it.
2008-07-27 05:39:39 +00:00
GdkScreen* screen;
GtkIconTheme* icon_theme;
screen = gtk_widget_get_screen (GTK_WIDGET (browser));
Use 'midori' icon and update icon cache in waf
2008-05-31 12:20:36 +00:00
if (screen)
{
Add Midori and news-feed icons, improve waf scripts Add small, optimized application icons and an all new news-feed icon including optimized versions. The build scripts are updated, and the data folder renamed to icons. Plus the wscript_build is improved. Of course, Midori now tests the icon theme for news-feed and uses it.
2008-07-27 05:39:39 +00:00
icon_theme = gtk_icon_theme_get_for_screen (screen);
Use 'midori' icon and update icon cache in waf
2008-05-31 12:20:36 +00:00
if (gtk_icon_theme_has_icon (icon_theme, "midori"))
gtk_window_set_icon_name (GTK_WINDOW (browser), "midori");
else
gtk_window_set_icon_name (GTK_WINDOW (browser), "web-browser");
}
}
Introduce MidoriLocationEntry and GtkIconEntry
2008-07-17 19:02:14 +00:00
static void
midori_browser_entry_clear_icon_released_cb (GtkIconEntry* entry,
gint icon_pos,
gint button,
gpointer user_data)
{
if (icon_pos == GTK_ICON_ENTRY_SECONDARY)
gtk_entry_set_text (GTK_ENTRY (entry), "");
}
Show toolbar menu when right-clicking the menubar
2008-10-17 21:30:31 +00:00
static gboolean
midori_browser_toolbar_item_button_press_event_cb (GtkWidget* toolitem,
GdkEventButton* event,
MidoriBrowser* browser);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static void
midori_browser_init (MidoriBrowser* browser)
{
Initial support for the Web Inspector
2008-11-01 18:15:58 +00:00
GtkWidget* vbox;
GtkUIManager* ui_manager;
GError* error;
GtkAction* action;
GtkWidget* menuitem;
GtkSettings* gtk_settings;
GtkWidget* hbox;
GtkWidget* hpaned;
GtkWidget* vpaned;
GtkWidget* box;
GtkTreeViewColumn* column;
GtkCellRenderer* renderer_text;
GtkCellRenderer* renderer_pixbuf;
GtkTreeStore* treestore;
GtkWidget* treeview;
GtkWidget* toolbar;
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
GtkToolItem* toolitem;
Initial support for the Web Inspector
2008-11-01 18:15:58 +00:00
GtkWidget* panel;
Remove inner border between scrollbars and window border
2008-07-23 12:42:27 +00:00
GtkRcStyle* rcstyle;
Initial support for the Web Inspector
2008-11-01 18:15:58 +00:00
GtkWidget* scrolled;
Remove inner border between scrollbars and window border
2008-07-23 12:42:27 +00:00
Implement KatzeNet as a generic URI loader KatzeNet can from now on be used where URIs are handled and one would have used libSoup and/ or local file handling as appropriate, whereas KatzeNet does both. Since we are displaying icons in several places KatzeNet also provides an icon loader that saves us from doublicating even more code. All bookmarks and also history items have icons now, since KatzeNet makes that incredibly easy. Search engines are also using favicons now, and right now custom icons don't work, we still need to fix that. Note that only icons are cached, nothing else and the code is known to have a hidden, hard to reproduce crasher which may appear when an icon is newly loaded.
2008-10-23 22:09:12 +00:00
browser->net = katze_net_new ();
Implement View source with external Text editor
2008-10-20 19:32:25 +00:00
Make bookmarks a property of browser and app This means we have removed the last remaining global variable.
2008-09-03 00:28:54 +00:00
browser->settings = midori_web_settings_new ();
Finish refactoring the toolbar to use only actions Finally the trash, which was the last item that needed to be implemented as an action, is an action, a KatzeArrayAction to be exact. This simplifies more code and also makes Window and RecentlyVisited generically implementable. Incidentally this change also fixes a bug where the browser tried to add a new tab when the last one was closed, even while destroying itself. Furthermore sokoke_image_menu_item_ellipsized and sokoke_widget_popup were promoted to Katze. We're still keeping the old functions for now.
2008-10-10 20:31:37 +00:00
browser->proxy_array = katze_array_new (KATZE_TYPE_ARRAY);
Make bookmarks a property of browser and app This means we have removed the last remaining global variable.
2008-09-03 00:28:54 +00:00
browser->bookmarks = NULL;
browser->trash = NULL;
browser->search_engines = NULL;
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
browser->history = NULL;
Make bookmarks a property of browser and app This means we have removed the last remaining global variable.
2008-09-03 00:28:54 +00:00
Introduce MidoriWebList, second step of refactoring web search
2008-06-14 00:23:33 +00:00
/* Setup the window metrics */
Use 'midori' icon and update icon cache in waf
2008-05-31 12:20:36 +00:00
g_signal_connect (browser, "realize",
G_CALLBACK (midori_browser_realize_cb), browser);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
g_signal_connect (browser, "window-state-event",
G_CALLBACK (midori_browser_window_state_event_cb), NULL);
g_signal_connect (browser, "size-allocate",
G_CALLBACK (midori_browser_size_allocate_cb), NULL);
Implement MidoriApp singleton and improve multiple window support The new singleton holds the shared settings and trash. It is further more used to keep track of all open windows and quits when the last window was closed. It also watches the focus in case you need something like a "current" browser.
2008-05-22 22:17:10 +00:00
g_signal_connect (browser, "destroy",
G_CALLBACK (midori_browser_destroy_cb), NULL);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
gtk_window_set_icon_name (GTK_WINDOW (browser), "web-browser");
gtk_window_set_title (GTK_WINDOW (browser), g_get_application_name ());
Initial support for the Web Inspector
2008-11-01 18:15:58 +00:00
vbox = gtk_vbox_new (FALSE, 0);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
gtk_container_add (GTK_CONTAINER (browser), vbox);
gtk_widget_show (vbox);
Introduce MidoriWebList, second step of refactoring web search
2008-06-14 00:23:33 +00:00
/* Let us see some ui manager magic */
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
browser->action_group = gtk_action_group_new ("Browser");
gtk_action_group_set_translation_domain (browser->action_group, GETTEXT_PACKAGE);
gtk_action_group_add_actions (browser->action_group,
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
entries, entries_n, browser);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_action_group_add_toggle_actions (browser->action_group,
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
toggle_entries, toggle_entries_n, browser);
Initial support for the Web Inspector
2008-11-01 18:15:58 +00:00
ui_manager = gtk_ui_manager_new ();
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_ui_manager_insert_action_group (ui_manager, browser->action_group, 0);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
gtk_window_add_accel_group (GTK_WINDOW (browser),
gtk_ui_manager_get_accel_group (ui_manager));
Initial support for the Web Inspector
2008-11-01 18:15:58 +00:00
error = NULL;
Show news feeds in a menu if the icon is clicked
2008-08-02 02:25:05 +00:00
if (!gtk_ui_manager_add_ui_from_string (ui_manager, ui_markup, -1, &error))
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Introduce MidoriWebList, second step of refactoring web search
2008-06-14 00:23:33 +00:00
/* TODO: Should this be a message dialog? When does this happen? */
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
g_message ("User interface couldn't be created: %s", error->message);
g_error_free (error);
}
Introduce MidoriWebList, second step of refactoring web search
2008-06-14 00:23:33 +00:00
/* _action_set_active(browser, "Transferbar", config->toolbarTransfers); */
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Keep otherwise unused actions in a Dummy This is needed for accelerators to work even if the according actions are not part of the permanent UI description.
2008-10-12 19:44:00 +00:00
/* Hide the 'Dummy' which only holds otherwise unused actions */
g_object_set (_action_by_name (browser, "Dummy"), "visible", FALSE, NULL);
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
action = g_object_new (MIDORI_TYPE_LOCATION_ACTION,
"name", "Location",
"label", _("_Location..."),
"stock-id", GTK_STOCK_JUMP_TO,
"tooltip", _("Open a particular location"),
/* FIXME: Due to a bug in GtkIconEntry we need to set an initial icon */
Use fallbacks for all icons, we don't want "broken" icons
2008-08-17 14:14:15 +00:00
"secondary-icon", STOCK_NEWS_FEED,
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
NULL);
g_object_connect (action,
"signal::activate",
_action_location_activate, browser,
"signal::active-changed",
_action_location_active_changed, browser,
"signal::focus-out",
_action_location_focus_out, browser,
"signal::reset-uri",
_action_location_reset_uri, browser,
"signal::submit-uri",
_action_location_submit_uri, browser,
"signal::secondary-icon-released",
_action_location_secondary_icon_released, browser,
NULL);
gtk_action_group_add_action_with_accel (browser->action_group,
action, "<Ctrl>L");
g_object_unref (action);
Implement the search widget as an action The most part of the search entry code is merely moved to the new action. We remove the original entry now, the action is all we need.
2008-10-05 21:25:02 +00:00
action = g_object_new (MIDORI_TYPE_SEARCH_ACTION,
"name", "Search",
"label", _("_Web Search..."),
"stock-id", GTK_STOCK_FIND,
"tooltip", _("Run a web search"),
NULL);
g_object_connect (action,
"signal::activate",
_action_search_activate, browser,
"signal::submit",
_action_search_submit, browser,
"signal::focus-out",
_action_search_focus_out, browser,
"signal::notify::current-item",
_action_search_notify_current_item, browser,
NULL);
gtk_action_group_add_action_with_accel (browser->action_group,
action, "<Ctrl>K");
g_object_unref (action);
Finish refactoring the toolbar to use only actions Finally the trash, which was the last item that needed to be implemented as an action, is an action, a KatzeArrayAction to be exact. This simplifies more code and also makes Window and RecentlyVisited generically implementable. Incidentally this change also fixes a bug where the browser tried to add a new tab when the last one was closed, even while destroying itself. Furthermore sokoke_image_menu_item_ellipsized and sokoke_widget_popup were promoted to Katze. We're still keeping the old functions for now.
2008-10-10 20:31:37 +00:00
action = g_object_new (KATZE_TYPE_ARRAY_ACTION,
"name", "Trash",
"stock-id", STOCK_USER_TRASH,
"tooltip", _("Reopen a previously closed tab or window"),
NULL);
g_object_connect (action,
"signal::populate-popup",
_action_trash_populate_popup, browser,
"signal::activate-item",
_action_trash_activate_item, browser,
NULL);
gtk_action_group_add_action_with_accel (browser->action_group,
action, "");
g_object_unref (action);
action = g_object_new (KATZE_TYPE_ARRAY_ACTION,
"name", "RecentlyVisited",
"label", _("_Recently visited pages"),
"stock-id", STOCK_HISTORY,
Improve strings for the sake of better localization
2008-11-02 23:17:43 +00:00
"tooltip", _("Reopen pages that you visited earlier"),
Finish refactoring the toolbar to use only actions Finally the trash, which was the last item that needed to be implemented as an action, is an action, a KatzeArrayAction to be exact. This simplifies more code and also makes Window and RecentlyVisited generically implementable. Incidentally this change also fixes a bug where the browser tried to add a new tab when the last one was closed, even while destroying itself. Furthermore sokoke_image_menu_item_ellipsized and sokoke_widget_popup were promoted to Katze. We're still keeping the old functions for now.
2008-10-10 20:31:37 +00:00
NULL);
g_object_connect (action,
"signal::populate-popup",
_action_history_populate_popup, browser,
"signal::activate-item",
_action_history_activate_item, browser,
NULL);
gtk_action_group_add_action_with_accel (browser->action_group,
action, "");
g_object_unref (action);
action = g_object_new (KATZE_TYPE_ARRAY_ACTION,
"name", "Bookmarks",
"label", _("_Bookmarks"),
"stock-id", STOCK_BOOKMARKS,
Improve strings for the sake of better localization
2008-11-02 23:17:43 +00:00
"tooltip", _("Show the saved bookmarks"),
Finish refactoring the toolbar to use only actions Finally the trash, which was the last item that needed to be implemented as an action, is an action, a KatzeArrayAction to be exact. This simplifies more code and also makes Window and RecentlyVisited generically implementable. Incidentally this change also fixes a bug where the browser tried to add a new tab when the last one was closed, even while destroying itself. Furthermore sokoke_image_menu_item_ellipsized and sokoke_widget_popup were promoted to Katze. We're still keeping the old functions for now.
2008-10-10 20:31:37 +00:00
NULL);
g_object_connect (action,
"signal::populate-popup",
_action_bookmarks_populate_popup, browser,
"signal::activate-item",
_action_bookmarks_activate_item, browser,
NULL);
gtk_action_group_add_action_with_accel (browser->action_group,
action, "");
g_object_unref (action);
action = g_object_new (KATZE_TYPE_ARRAY_ACTION,
"name", "Window",
Improve strings for the sake of better localization
2008-11-02 23:17:43 +00:00
"label", _("_Window"),
Finish refactoring the toolbar to use only actions Finally the trash, which was the last item that needed to be implemented as an action, is an action, a KatzeArrayAction to be exact. This simplifies more code and also makes Window and RecentlyVisited generically implementable. Incidentally this change also fixes a bug where the browser tried to add a new tab when the last one was closed, even while destroying itself. Furthermore sokoke_image_menu_item_ellipsized and sokoke_widget_popup were promoted to Katze. We're still keeping the old functions for now.
2008-10-10 20:31:37 +00:00
"stock-id", GTK_STOCK_INDEX,
"tooltip", _("Show a list of all open tabs"),
"array", browser->proxy_array,
NULL);
g_object_connect (action,
"signal::populate-popup",
_action_window_populate_popup, browser,
"signal::activate-item",
_action_window_activate_item, browser,
NULL);
gtk_action_group_add_action_with_accel (browser->action_group,
action, "");
g_object_unref (action);
Introduce MidoriWebList, second step of refactoring web search
2008-06-14 00:23:33 +00:00
/* Create the menubar */
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
browser->menubar = gtk_ui_manager_get_widget (ui_manager, "/menubar");
Initial support for the Web Inspector
2008-11-01 18:15:58 +00:00
menuitem = gtk_menu_item_new ();
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
gtk_widget_show (menuitem);
Show progress in location entry if statusbar is hidden
2008-08-31 00:45:13 +00:00
browser->throbber = katze_throbber_new ();
gtk_widget_show (browser->throbber);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_container_add (GTK_CONTAINER (menuitem), browser->throbber);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
gtk_widget_set_sensitive (menuitem, FALSE);
gtk_menu_item_set_right_justified (GTK_MENU_ITEM (menuitem), TRUE);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_menu_shell_append (GTK_MENU_SHELL (browser->menubar), menuitem);
gtk_box_pack_start (GTK_BOX (vbox), browser->menubar, FALSE, FALSE, 0);
browser->menu_tools = gtk_menu_item_get_submenu (GTK_MENU_ITEM (
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
gtk_ui_manager_get_widget (ui_manager, "/menubar/Tools")));
Rework MidoriWebList into KatzeList and KatzeArray
2008-08-25 23:19:38 +00:00
menuitem = gtk_separator_menu_item_new ();
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
gtk_widget_show (menuitem);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_menu_shell_append (GTK_MENU_SHELL (browser->menu_tools), menuitem);
Allow hiding the menubar and showing it again
2008-10-12 20:09:49 +00:00
gtk_widget_hide (browser->menubar);
Show toolbar menu when right-clicking the menubar
2008-10-17 21:30:31 +00:00
g_signal_connect (browser->menubar, "button-press-event",
G_CALLBACK (midori_browser_toolbar_item_button_press_event_cb), browser);
Allow hiding the menubar and showing it again
2008-10-12 20:09:49 +00:00
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
_action_set_sensitive (browser, "PrivateBrowsing", FALSE);
Keep otherwise unused actions in a Dummy This is needed for accelerators to work even if the according actions are not part of the permanent UI description.
2008-10-12 19:44:00 +00:00
_action_set_sensitive (browser, "FindQuick", FALSE);
_action_set_sensitive (browser, "Transferbar", FALSE);
_action_set_sensitive (browser, "SelectionSourceView", FALSE);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Introduce MidoriWebList, second step of refactoring web search
2008-06-14 00:23:33 +00:00
/* Create the navigationbar */
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
browser->navigationbar = gtk_ui_manager_get_widget (
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
ui_manager, "/toolbar_navigation");
Introduce MidoriWebList, second step of refactoring web search
2008-06-14 00:23:33 +00:00
/* FIXME: settings should be connected with screen changes */
Initial support for the Web Inspector
2008-11-01 18:15:58 +00:00
gtk_settings = gtk_widget_get_settings (GTK_WIDGET (browser));
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
if (gtk_settings)
g_signal_connect (gtk_settings, "notify::gtk-toolbar-style",
G_CALLBACK (midori_browser_navigationbar_notify_style_cb), browser);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_toolbar_set_show_arrow (GTK_TOOLBAR (browser->navigationbar), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), browser->navigationbar, FALSE, FALSE, 0);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
g_object_set (_action_by_name (browser, "Back"), "is-important", TRUE, NULL);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
sokoke_container_show_children (GTK_CONTAINER (browser->navigationbar));
Hide the navigationbar initially We need to make sure that the navigationbar is initially invisible, so we hide it expressly. Otherwise it shows up regardless of the show-navigationbar setting.
2008-08-10 16:28:08 +00:00
gtk_widget_hide (browser->navigationbar);
Create navigationbar from a string of actions
2008-10-12 16:14:57 +00:00
g_signal_connect (browser->navigationbar, "popup-context-menu",
G_CALLBACK (midori_browser_toolbar_popup_context_menu_cb), browser);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Introduce MidoriWebList, second step of refactoring web search
2008-06-14 00:23:33 +00:00
/* Bookmarkbar */
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
browser->bookmarkbar = gtk_toolbar_new ();
gtk_toolbar_set_icon_size (GTK_TOOLBAR (browser->bookmarkbar),
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
GTK_ICON_SIZE_MENU);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_toolbar_set_style (GTK_TOOLBAR (browser->bookmarkbar),
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
GTK_TOOLBAR_BOTH_HORIZ);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_box_pack_start (GTK_BOX (vbox), browser->bookmarkbar, FALSE, FALSE, 0);
Create navigationbar from a string of actions
2008-10-12 16:14:57 +00:00
g_signal_connect (browser->bookmarkbar, "popup-context-menu",
G_CALLBACK (midori_browser_toolbar_popup_context_menu_cb), browser);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Introduce MidoriWebList, second step of refactoring web search
2008-06-14 00:23:33 +00:00
/* Superuser warning */
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
if ((hbox = sokoke_superuser_warning_new ()))
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
Introduce MidoriWebList, second step of refactoring web search
2008-06-14 00:23:33 +00:00
/* Create the panel */
Initial support for the Web Inspector
2008-11-01 18:15:58 +00:00
hpaned = gtk_hpaned_new ();
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
g_signal_connect (hpaned, "notify::position",
G_CALLBACK (midori_panel_notify_position_cb),
browser);
gtk_box_pack_start (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0);
gtk_widget_show (hpaned);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
browser->panel = g_object_new (MIDORI_TYPE_PANEL,
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
"shadow-type", GTK_SHADOW_IN,
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
"menu", browser->menu_tools,
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
NULL);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
g_signal_connect (browser->panel, "close",
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
G_CALLBACK (midori_panel_close_cb), browser);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_paned_pack1 (GTK_PANED (hpaned), browser->panel, FALSE, FALSE);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Introduce MidoriWebList, second step of refactoring web search
2008-06-14 00:23:33 +00:00
/* Bookmarks */
Initial support for the Web Inspector
2008-11-01 18:15:58 +00:00
box = gtk_vbox_new (FALSE, 0);
treestore = gtk_tree_store_new (1, KATZE_TYPE_ITEM);
treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (treestore));
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
column = gtk_tree_view_column_new ();
renderer_pixbuf = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, renderer_pixbuf, FALSE);
gtk_tree_view_column_set_cell_data_func (column, renderer_pixbuf,
(GtkTreeCellDataFunc)midori_browser_bookmarks_item_render_icon_cb,
treeview, NULL);
renderer_text = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer_text, FALSE);
gtk_tree_view_column_set_cell_data_func (column, renderer_text,
(GtkTreeCellDataFunc)midori_browser_bookmarks_item_render_text_cb,
treeview, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
g_object_unref (treestore);
g_object_connect (treeview,
"signal::row-activated",
midori_panel_bookmarks_row_activated_cb, browser,
"signal::cursor-changed",
midori_panel_bookmarks_cursor_or_row_changed_cb, browser,
"signal::columns-changed",
midori_panel_bookmarks_cursor_or_row_changed_cb, browser,
"signal::button-release-event",
midori_panel_bookmarks_button_release_event_cb, browser,
"signal::popup-menu",
midori_panel_bookmarks_popup_menu_cb, browser,
NULL);
midori_panel_bookmarks_cursor_or_row_changed_cb (GTK_TREE_VIEW (treeview),
browser);
Implement the Console panel for script messages.
2008-03-27 00:21:29 +00:00
gtk_box_pack_start (GTK_BOX (box), treeview, TRUE, TRUE, 0);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
browser->panel_bookmarks = treeview;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
gtk_widget_show_all (box);
Initial support for the Web Inspector
2008-11-01 18:15:58 +00:00
toolbar = gtk_ui_manager_get_widget (ui_manager, "/toolbar_bookmarks");
Make bookmarks a property of browser and app This means we have removed the last remaining global variable.
2008-09-03 00:28:54 +00:00
_action_set_sensitive (browser, "BookmarkAdd", FALSE);
Integrate panel toolbars properly outside scrolled areas.
2008-04-26 00:43:32 +00:00
gtk_toolbar_set_icon_size (GTK_TOOLBAR (toolbar), GTK_ICON_SIZE_MENU);
gtk_widget_show_all (toolbar);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
midori_panel_append_page (MIDORI_PANEL (browser->panel),
Integrate panel toolbars properly outside scrolled areas.
2008-04-26 00:43:32 +00:00
box, toolbar,
Use fallbacks for all icons, we don't want "broken" icons
2008-08-17 14:14:15 +00:00
STOCK_BOOKMARKS, _("Bookmarks"));
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Introduce MidoriWebList, second step of refactoring web search
2008-06-14 00:23:33 +00:00
/* Transfers */
Initial support for the Web Inspector
2008-11-01 18:15:58 +00:00
panel = midori_view_new (browser->net);
Initial addon panel feature, only userscripts for now.
2008-04-28 20:38:57 +00:00
gtk_widget_show (panel);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
midori_panel_append_page (MIDORI_PANEL (browser->panel),
Initial addon panel feature, only userscripts for now.
2008-04-28 20:38:57 +00:00
panel, NULL,
Use fallbacks for all icons, we don't want "broken" icons
2008-08-17 14:14:15 +00:00
STOCK_TRANSFERS, _("Transfers"));
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Introduce MidoriWebList, second step of refactoring web search
2008-06-14 00:23:33 +00:00
/* Console */
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
browser->panel_console = midori_console_new ();
gtk_widget_show (browser->panel_console);
toolbar = midori_console_get_toolbar (MIDORI_CONSOLE (browser->panel_console));
Integrate panel toolbars properly outside scrolled areas.
2008-04-26 00:43:32 +00:00
gtk_widget_show (toolbar);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
midori_panel_append_page (MIDORI_PANEL (browser->panel),
browser->panel_console, toolbar,
Use fallbacks for all icons, we don't want "broken" icons
2008-08-17 14:14:15 +00:00
STOCK_CONSOLE, _("Console"));
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Introduce MidoriWebList, second step of refactoring web search
2008-06-14 00:23:33 +00:00
/* History */
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
box = gtk_vbox_new (FALSE, 0);
Display relative dates in History panel
2008-10-23 23:35:34 +00:00
treestore = gtk_tree_store_new (2, KATZE_TYPE_ITEM, G_TYPE_INT);
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (treestore));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
column = gtk_tree_view_column_new ();
renderer_pixbuf = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, renderer_pixbuf, FALSE);
gtk_tree_view_column_set_cell_data_func (column, renderer_pixbuf,
(GtkTreeCellDataFunc)midori_browser_history_render_icon_cb,
treeview, NULL);
renderer_text = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer_text, FALSE);
gtk_tree_view_column_set_cell_data_func (column, renderer_text,
(GtkTreeCellDataFunc)midori_browser_history_render_text_cb,
treeview, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
g_object_unref (treestore);
g_object_connect (treeview,
"signal::row-activated",
midori_panel_history_row_activated_cb, browser,
Small adjustments to the History panel Based on suggestions by Dale
2008-11-06 00:32:42 +00:00
"signal::cursor-changed",
midori_panel_history_cursor_or_row_changed_cb, browser,
"signal::columns-changed",
midori_panel_history_cursor_or_row_changed_cb, browser,
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
"signal::button-release-event",
midori_panel_history_button_release_event_cb, browser,
Show a dialog before clearing the history Plus you can now remove history items with Del.
2008-10-10 21:19:37 +00:00
"signal::key-release-event",
midori_panel_history_key_release_event_cb, browser,
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
"signal::popup-menu",
midori_panel_history_popup_menu_cb, browser,
NULL);
Small adjustments to the History panel Based on suggestions by Dale
2008-11-06 00:32:42 +00:00
midori_panel_history_cursor_or_row_changed_cb (GTK_TREE_VIEW (treeview),
browser);
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
gtk_box_pack_start (GTK_BOX (box), treeview, TRUE, TRUE, 0);
browser->panel_history = treeview;
gtk_widget_show_all (box);
toolbar = gtk_ui_manager_get_widget (ui_manager, "/toolbar_history");
gtk_toolbar_set_icon_size (GTK_TOOLBAR (toolbar), GTK_ICON_SIZE_MENU);
gtk_widget_show (toolbar);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
midori_panel_append_page (MIDORI_PANEL (browser->panel),
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
box, toolbar,
Use fallbacks for all icons, we don't want "broken" icons
2008-08-17 14:14:15 +00:00
STOCK_HISTORY, _("History"));
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Introduce MidoriWebList, second step of refactoring web search
2008-06-14 00:23:33 +00:00
/* Pageholder */
Share net between browser and views
2008-10-27 03:23:41 +00:00
browser->panel_pageholder = midori_view_new (browser->net);
Make the pageholder work again
2008-10-18 22:15:02 +00:00
midori_view_set_settings (MIDORI_VIEW (browser->panel_pageholder),
browser->settings);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_widget_show (browser->panel_pageholder);
midori_panel_append_page (MIDORI_PANEL (browser->panel),
browser->panel_pageholder, NULL,
Use fallbacks for all icons, we don't want "broken" icons
2008-08-17 14:14:15 +00:00
STOCK_PAGE_HOLDER, _("Pageholder"));
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Introduce MidoriWebList, second step of refactoring web search
2008-06-14 00:23:33 +00:00
/* Userscripts */
Initial addon panel feature, only userscripts for now.
2008-04-28 20:38:57 +00:00
panel = midori_addons_new (GTK_WIDGET (browser), MIDORI_ADDON_USER_SCRIPTS);
gtk_widget_show (panel);
toolbar = midori_addons_get_toolbar (MIDORI_ADDONS (panel));
gtk_widget_show (toolbar);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
midori_panel_append_page (MIDORI_PANEL (browser->panel),
Initial addon panel feature, only userscripts for now.
2008-04-28 20:38:57 +00:00
panel, toolbar,
Use fallbacks for all icons, we don't want "broken" icons
2008-08-17 14:14:15 +00:00
STOCK_SCRIPTS, _("Userscripts"));
Introduce MidoriWebList, second step of refactoring web search
2008-06-14 00:23:33 +00:00
/* Userstyles */
Implement the Userstyles Addon panel
2008-08-17 23:24:26 +00:00
panel = midori_addons_new (GTK_WIDGET (browser), MIDORI_ADDON_USER_STYLES);
Initial addon panel feature, only userscripts for now.
2008-04-28 20:38:57 +00:00
gtk_widget_show (panel);
toolbar = midori_addons_get_toolbar (MIDORI_ADDONS (panel));
gtk_widget_show (toolbar);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
midori_panel_append_page (MIDORI_PANEL (browser->panel),
Initial addon panel feature, only userscripts for now.
2008-04-28 20:38:57 +00:00
panel, toolbar,
Implement the Userstyles Addon panel
2008-08-17 23:24:26 +00:00
STOCK_STYLES, _("Userstyles"));
Initial addon panel feature, only userscripts for now.
2008-04-28 20:38:57 +00:00
Use icons for Script and Extension
2008-08-01 13:49:47 +00:00
/* Extensions */
panel = midori_addons_new (GTK_WIDGET (browser), MIDORI_ADDON_EXTENSIONS);
gtk_widget_show (panel);
toolbar = midori_addons_get_toolbar (MIDORI_ADDONS (panel));
gtk_widget_show (toolbar);
midori_panel_append_page (MIDORI_PANEL (browser->panel),
panel, toolbar,
Use fallbacks for all icons, we don't want "broken" icons
2008-08-17 14:14:15 +00:00
STOCK_EXTENSIONS, _("Extensions"));
Use icons for Script and Extension
2008-08-01 13:49:47 +00:00
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
/* Notebook, containing all views */
Initial support for the Web Inspector
2008-11-01 18:15:58 +00:00
vpaned = gtk_vpaned_new ();
gtk_paned_pack2 (GTK_PANED (hpaned), vpaned, FALSE, FALSE);
gtk_widget_show (vpaned);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
browser->notebook = gtk_notebook_new ();
Remove inner border between scrollbars and window border
2008-07-23 12:42:27 +00:00
/* Remove the inner border between scrollbars and the window border */
rcstyle = gtk_rc_style_new ();
rcstyle->xthickness = rcstyle->ythickness = 0;
gtk_widget_modify_style (browser->notebook, rcstyle);
g_object_unref (rcstyle);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_notebook_set_scrollable (GTK_NOTEBOOK (browser->notebook), TRUE);
Initial support for the Web Inspector
2008-11-01 18:15:58 +00:00
gtk_paned_pack2 (GTK_PANED (vpaned), browser->notebook, FALSE, FALSE);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
g_signal_connect_after (browser->notebook, "switch-page",
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
G_CALLBACK (gtk_notebook_switch_page_cb),
browser);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_widget_show (browser->notebook);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Initial support for the Web Inspector
2008-11-01 18:15:58 +00:00
/* Inspector container */
browser->inspector = gtk_vbox_new (FALSE, 0);
gtk_paned_pack2 (GTK_PANED (vpaned), browser->inspector, TRUE, TRUE);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
GTK_WIDGET_SET_FLAGS (scrolled, GTK_CAN_FOCUS);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled),
GTK_SHADOW_ETCHED_IN);
gtk_box_pack_start (GTK_BOX (browser->inspector),
scrolled, TRUE, TRUE, 0);
browser->inspector_view = webkit_web_view_new ();
gtk_container_add (GTK_CONTAINER (scrolled), browser->inspector_view);
gtk_widget_show_all (browser->inspector);
Introduce MidoriWebList, second step of refactoring web search
2008-06-14 00:23:33 +00:00
/* Incremental findbar */
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
browser->find = gtk_toolbar_new ();
gtk_toolbar_set_icon_size (GTK_TOOLBAR (browser->find), GTK_ICON_SIZE_MENU);
gtk_toolbar_set_style (GTK_TOOLBAR (browser->find), GTK_TOOLBAR_BOTH_HORIZ);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
toolitem = gtk_tool_item_new ();
gtk_container_set_border_width (GTK_CONTAINER (toolitem), 6);
gtk_container_add (GTK_CONTAINER (toolitem),
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
gtk_label_new_with_mnemonic (_("_Inline find:")));
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_toolbar_insert (GTK_TOOLBAR (browser->find), toolitem, -1);
Introduce MidoriLocationEntry and GtkIconEntry
2008-07-17 19:02:14 +00:00
browser->find_text = gtk_icon_entry_new ();
Always show the icon in the Web Search entry
2008-08-25 23:59:02 +00:00
gtk_icon_entry_set_icon_from_stock (GTK_ICON_ENTRY (browser->find_text),
Introduce MidoriLocationEntry and GtkIconEntry
2008-07-17 19:02:14 +00:00
GTK_ICON_ENTRY_PRIMARY,
GTK_STOCK_FIND);
gtk_icon_entry_set_icon_from_stock (GTK_ICON_ENTRY (browser->find_text),
GTK_ICON_ENTRY_SECONDARY,
GTK_STOCK_CLEAR);
Highlight the Clear icon in the findbar
2008-07-22 12:53:25 +00:00
gtk_icon_entry_set_icon_highlight (GTK_ICON_ENTRY (browser->find_text),
GTK_ICON_ENTRY_SECONDARY, TRUE);
Introduce MidoriLocationEntry and GtkIconEntry
2008-07-17 19:02:14 +00:00
g_signal_connect (browser->find_text, "icon_released",
G_CALLBACK (midori_browser_entry_clear_icon_released_cb), NULL);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
g_signal_connect (browser->find_text, "activate",
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
G_CALLBACK (_action_find_next_activate), browser);
toolitem = gtk_tool_item_new ();
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_container_add (GTK_CONTAINER (toolitem), browser->find_text);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
gtk_tool_item_set_expand (GTK_TOOL_ITEM (toolitem), TRUE);
Always show the icon in the Web Search entry
2008-08-25 23:59:02 +00:00
gtk_toolbar_insert (GTK_TOOLBAR (browser->find), toolitem, -1);
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
toolitem = (GtkToolItem*)gtk_action_create_tool_item
(_action_by_name (browser, "FindPrevious"));
gtk_tool_button_set_label (GTK_TOOL_BUTTON (toolitem), NULL);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
gtk_tool_item_set_is_important (toolitem, TRUE);
g_signal_connect (toolitem, "clicked",
G_CALLBACK (_action_find_previous_activate), browser);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_toolbar_insert (GTK_TOOLBAR (browser->find), toolitem, -1);
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
toolitem = (GtkToolItem*)gtk_action_create_tool_item
(_action_by_name (browser, "FindNext"));
gtk_tool_button_set_label (GTK_TOOL_BUTTON (toolitem), NULL);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
gtk_tool_item_set_is_important (toolitem, TRUE);
g_signal_connect (toolitem, "clicked",
G_CALLBACK (_action_find_next_activate), browser);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_toolbar_insert (GTK_TOOLBAR (browser->find), toolitem, -1);
browser->find_case = gtk_toggle_tool_button_new_from_stock (
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
GTK_STOCK_SPELL_CHECK);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_tool_button_set_label (GTK_TOOL_BUTTON (browser->find_case), _("Match Case"));
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (browser->find_case), TRUE);
gtk_toolbar_insert (GTK_TOOLBAR (browser->find), browser->find_case, -1);
browser->find_highlight = gtk_toggle_tool_button_new_from_stock (
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
GTK_STOCK_SELECT_ALL);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
g_signal_connect (browser->find_highlight, "toggled",
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
G_CALLBACK (_find_highlight_toggled), browser);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_tool_button_set_label (GTK_TOOL_BUTTON (browser->find_highlight),
Ellipsize menu items referring to websites or bookmarks. Originally menu items could in some cases become as wide as the whole screen, making working with menus rather hard. Now we ellipsize at 50 characters in the middle of the string.
2008-09-07 01:39:25 +00:00
_("Highlight Matches"));
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (browser->find_highlight), TRUE);
gtk_toolbar_insert (GTK_TOOLBAR (browser->find), browser->find_highlight, -1);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
toolitem = gtk_separator_tool_item_new ();
gtk_separator_tool_item_set_draw (
GTK_SEPARATOR_TOOL_ITEM (toolitem), FALSE);
gtk_tool_item_set_expand (GTK_TOOL_ITEM (toolitem), TRUE);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_toolbar_insert (GTK_TOOLBAR (browser->find), toolitem, -1);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
toolitem = gtk_tool_button_new_from_stock (GTK_STOCK_CLOSE);
Implement localization via Gettext. Based on the implementation of localization via Gettext contributed by Enrico Tröger, a few adjustments were made to allow Midori to be properly localized. Initially German is fully supported.
2008-03-22 02:38:23 +00:00
gtk_tool_button_set_label (GTK_TOOL_BUTTON (toolitem), _("Close Findbar"));
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
g_signal_connect (toolitem, "clicked",
G_CALLBACK (midori_browser_find_button_close_clicked_cb), browser);
Improve OSX adjustments in various places
2008-10-25 22:54:57 +00:00
#ifdef HAVE_OSX
gtk_toolbar_insert (GTK_TOOLBAR (browser->find), toolitem, 0);
#else
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_toolbar_insert (GTK_TOOLBAR (browser->find), toolitem, -1);
Improve OSX adjustments in various places
2008-10-25 22:54:57 +00:00
#endif
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
sokoke_container_show_children (GTK_CONTAINER (browser->find));
gtk_box_pack_start (GTK_BOX (vbox), browser->find, FALSE, FALSE, 0);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Introduce MidoriWebList, second step of refactoring web search
2008-06-14 00:23:33 +00:00
/* Statusbar */
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
browser->statusbar = gtk_statusbar_new ();
Make statusbar children fit in better
2008-07-23 16:23:21 +00:00
/* Adjust the statusbar's padding to avoid child overlapping */
rcstyle = gtk_rc_style_new ();
rcstyle->xthickness = rcstyle->ythickness = -4;
gtk_widget_modify_style (browser->statusbar, rcstyle);
g_object_unref (rcstyle);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_box_pack_start (GTK_BOX (vbox), browser->statusbar, FALSE, FALSE, 0);
browser->progressbar = gtk_progress_bar_new ();
Make statusbar children fit in better
2008-07-23 16:23:21 +00:00
/* Set the progressbar's height to 1 to fit it in the statusbar */
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_widget_set_size_request (browser->progressbar, -1, 1);
gtk_box_pack_start (GTK_BOX (browser->statusbar), browser->progressbar,
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
FALSE, FALSE, 3);
g_object_unref (ui_manager);
}
Ensure REMOVE_TAB emission, don't alter session when destroying
2008-07-25 10:45:50 +00:00
static void
midori_browser_dispose (GObject* object)
{
MidoriBrowser* browser = MIDORI_BROWSER (object);
/* We are done, the session mustn't change anymore */
Finish refactoring the toolbar to use only actions Finally the trash, which was the last item that needed to be implemented as an action, is an action, a KatzeArrayAction to be exact. This simplifies more code and also makes Window and RecentlyVisited generically implementable. Incidentally this change also fixes a bug where the browser tried to add a new tab when the last one was closed, even while destroying itself. Furthermore sokoke_image_menu_item_ellipsized and sokoke_widget_popup were promoted to Katze. We're still keeping the old functions for now.
2008-10-10 20:31:37 +00:00
katze_object_assign (browser->proxy_array, NULL);
Ensure REMOVE_TAB emission, don't alter session when destroying
2008-07-25 10:45:50 +00:00
G_OBJECT_CLASS (midori_browser_parent_class)->dispose (object);
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static void
midori_browser_finalize (GObject* object)
{
MidoriBrowser* browser = MIDORI_BROWSER (object);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
g_free (browser->statusbar_text);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Implement KatzeNet as a generic URI loader KatzeNet can from now on be used where URIs are handled and one would have used libSoup and/ or local file handling as appropriate, whereas KatzeNet does both. Since we are displaying icons in several places KatzeNet also provides an icon loader that saves us from doublicating even more code. All bookmarks and also history items have icons now, since KatzeNet makes that incredibly easy. Search engines are also using favicons now, and right now custom icons don't work, we still need to fix that. Note that only icons are cached, nothing else and the code is known to have a hidden, hard to reproduce crasher which may appear when an icon is newly loaded.
2008-10-23 22:09:12 +00:00
katze_object_assign (browser->settings, NULL);
katze_object_assign (browser->bookmarks, NULL);
katze_object_assign (browser->trash, NULL);
katze_object_assign (browser->search_engines, NULL);
katze_object_assign (browser->history, NULL);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Implement KatzeNet as a generic URI loader KatzeNet can from now on be used where URIs are handled and one would have used libSoup and/ or local file handling as appropriate, whereas KatzeNet does both. Since we are displaying icons in several places KatzeNet also provides an icon loader that saves us from doublicating even more code. All bookmarks and also history items have icons now, since KatzeNet makes that incredibly easy. Search engines are also using favicons now, and right now custom icons don't work, we still need to fix that. Note that only icons are cached, nothing else and the code is known to have a hidden, hard to reproduce crasher which may appear when an icon is newly loaded.
2008-10-23 22:09:12 +00:00
katze_object_assign (browser->net, NULL);
Implement View source with external Text editor
2008-10-20 19:32:25 +00:00
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
G_OBJECT_CLASS (midori_browser_parent_class)->finalize (object);
}
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
static void
Update interface and web featureswith preference changes. The toolbar style, small toolbar, New Tab, Web Search and Trash buttons are shown or hidden respectively as the preference values change. This is also an attempt at updating the web view's settings immediately. Although it seems to work, an ugly warning is emitted to the console on every change.
2008-04-22 20:19:24 +00:00
_midori_browser_set_toolbar_style (MidoriBrowser* browser,
MidoriToolbarStyle toolbar_style)
{
GtkToolbarStyle gtk_toolbar_style;
GtkSettings* gtk_settings = gtk_widget_get_settings (GTK_WIDGET (browser));
if (toolbar_style == MIDORI_TOOLBAR_DEFAULT && gtk_settings)
g_object_get (gtk_settings, "gtk-toolbar-style", &gtk_toolbar_style, NULL);
else
{
switch (toolbar_style)
{
case MIDORI_TOOLBAR_ICONS:
gtk_toolbar_style = GTK_TOOLBAR_ICONS;
break;
case MIDORI_TOOLBAR_TEXT:
gtk_toolbar_style = GTK_TOOLBAR_TEXT;
break;
case MIDORI_TOOLBAR_BOTH:
gtk_toolbar_style = GTK_TOOLBAR_BOTH;
break;
case MIDORI_TOOLBAR_BOTH_HORIZ:
case MIDORI_TOOLBAR_DEFAULT:
gtk_toolbar_style = GTK_TOOLBAR_BOTH_HORIZ;
}
}
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_toolbar_set_style (GTK_TOOLBAR (browser->navigationbar),
Update interface and web featureswith preference changes. The toolbar style, small toolbar, New Tab, Web Search and Trash buttons are shown or hidden respectively as the preference values change. This is also an attempt at updating the web view's settings immediately. Although it seems to work, an ugly warning is emitted to the console on every change.
2008-04-22 20:19:24 +00:00
gtk_toolbar_style);
}
Create navigationbar from a string of actions
2008-10-12 16:14:57 +00:00
static gboolean
midori_browser_toolbar_item_button_press_event_cb (GtkWidget* toolitem,
GdkEventButton* event,
MidoriBrowser* browser)
{
if (event->button == 3)
{
midori_browser_toolbar_popup_context_menu_cb (browser->navigationbar,
event->x, event->y, event->button, browser);
return TRUE;
}
return FALSE;
}
Update interface and web featureswith preference changes. The toolbar style, small toolbar, New Tab, Web Search and Trash buttons are shown or hidden respectively as the preference values change. This is also an attempt at updating the web view's settings immediately. Although it seems to work, an ugly warning is emitted to the console on every change.
2008-04-22 20:19:24 +00:00
static void
Create navigationbar from a string of actions
2008-10-12 16:14:57 +00:00
_midori_browser_set_toolbar_items (MidoriBrowser* browser,
const gchar* items)
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
{
Create navigationbar from a string of actions
2008-10-12 16:14:57 +00:00
gchar** names;
gchar** name;
GtkAction* action;
GtkWidget* toolitem;
gtk_container_foreach (GTK_CONTAINER (browser->navigationbar),
(GtkCallback)gtk_widget_destroy, NULL);
names = g_strsplit (items ? items : "", ",", 0);
name = names;
while (*name)
{
action = _action_by_name (browser, *name);
if (action)
{
toolitem = gtk_action_create_tool_item (action);
g_signal_connect (gtk_bin_get_child (GTK_BIN (toolitem)),
"button-press-event",
G_CALLBACK (midori_browser_toolbar_item_button_press_event_cb),
browser);
gtk_toolbar_insert (GTK_TOOLBAR (browser->navigationbar),
GTK_TOOL_ITEM (toolitem), -1);
}
name++;
}
g_strfreev (names);
Properly create unfullscreen button with the toolbar
2008-10-17 21:18:56 +00:00
action = gtk_action_group_get_action (browser->action_group, "Fullscreen");
browser->button_fullscreen = gtk_action_create_tool_item (action);
gtk_widget_hide (browser->button_fullscreen);
g_signal_connect (browser->button_fullscreen, "clicked",
G_CALLBACK (_action_fullscreen_activate), browser);
gtk_toolbar_insert (GTK_TOOLBAR (browser->navigationbar),
GTK_TOOL_ITEM (browser->button_fullscreen), -1);
Create navigationbar from a string of actions
2008-10-12 16:14:57 +00:00
}
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
Create navigationbar from a string of actions
2008-10-12 16:14:57 +00:00
static void
_midori_browser_update_settings (MidoriBrowser* browser)
{
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
gboolean remember_last_window_size;
gint last_window_width, last_window_height;
Add Compact sidepanel Preference
2008-10-21 22:01:01 +00:00
gboolean compact_sidepanel;
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
gint last_panel_position, last_panel_page;
Allow hiding the menubar and showing it again
2008-10-12 20:09:49 +00:00
gboolean show_menubar, show_navigationbar, show_bookmarkbar;
gboolean show_panel, show_statusbar;
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
MidoriToolbarStyle toolbar_style;
Create navigationbar from a string of actions
2008-10-12 16:14:57 +00:00
gchar* toolbar_items;
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
gint last_web_search;
gchar* last_pageholder_uri;
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
gboolean close_buttons_on_tabs;
Create navigationbar from a string of actions
2008-10-12 16:14:57 +00:00
GdkScreen* screen;
gint default_width, default_height;
KatzeItem* item;
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
g_object_get (browser->settings,
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
"remember-last-window-size", &remember_last_window_size,
"last-window-width", &last_window_width,
"last-window-height", &last_window_height,
Add Compact sidepanel Preference
2008-10-21 22:01:01 +00:00
"compact-sidepanel", &compact_sidepanel,
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
"last-panel-position", &last_panel_position,
"last-panel-page", &last_panel_page,
Allow hiding the menubar and showing it again
2008-10-12 20:09:49 +00:00
"show-menubar", &show_menubar,
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
"show-navigationbar", &show_navigationbar,
"show-bookmarkbar", &show_bookmarkbar,
"show-panel", &show_panel,
"show-statusbar", &show_statusbar,
"toolbar-style", &toolbar_style,
Create navigationbar from a string of actions
2008-10-12 16:14:57 +00:00
"toolbar-items", &toolbar_items,
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
"last-web-search", &last_web_search,
"last-pageholder-uri", &last_pageholder_uri,
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
"close-buttons-on-tabs", &close_buttons_on_tabs,
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
NULL);
Create navigationbar from a string of actions
2008-10-12 16:14:57 +00:00
screen = gtk_window_get_screen (GTK_WINDOW (browser));
default_width = gdk_screen_get_width (screen) / 1.7;
default_height = gdk_screen_get_height (screen) / 1.7;
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
if (remember_last_window_size)
{
if (last_window_width && last_window_height)
gtk_window_set_default_size (GTK_WINDOW (browser),
last_window_width, last_window_height);
else
gtk_window_set_default_size (GTK_WINDOW (browser),
default_width, default_height);
}
Update interface and web featureswith preference changes. The toolbar style, small toolbar, New Tab, Web Search and Trash buttons are shown or hidden respectively as the preference values change. This is also an attempt at updating the web view's settings immediately. Although it seems to work, an ugly warning is emitted to the console on every change.
2008-04-22 20:19:24 +00:00
_midori_browser_set_toolbar_style (browser, toolbar_style);
Add Always Show Tabbar preference
2008-10-03 23:45:17 +00:00
_toggle_tabbar_smartly (browser);
Create navigationbar from a string of actions
2008-10-12 16:14:57 +00:00
_midori_browser_set_toolbar_items (browser, toolbar_items);
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
if (browser->search_engines)
Complete move of webSearch, third step of refactoring web search
2008-06-15 02:02:56 +00:00
{
Rework MidoriWebList into KatzeList and KatzeArray
2008-08-25 23:19:38 +00:00
item = katze_array_get_nth_item (browser->search_engines,
last_web_search);
Rename MidoriWebItem to KatzeItem
2008-08-23 16:32:53 +00:00
if (item)
Implement the search widget as an action The most part of the search entry code is merely moved to the new action. We remove the original entry now, the action is all we need.
2008-10-05 21:25:02 +00:00
midori_search_action_set_current_item (MIDORI_SEARCH_ACTION (
_action_by_name (browser, "Search")), item);
Complete move of webSearch, third step of refactoring web search
2008-06-15 02:02:56 +00:00
}
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
Add Compact sidepanel Preference
2008-10-21 22:01:01 +00:00
midori_panel_set_compact (MIDORI_PANEL (browser->panel), compact_sidepanel);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_paned_set_position (GTK_PANED (gtk_widget_get_parent (browser->panel)),
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
last_panel_position);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
midori_panel_set_current_page (MIDORI_PANEL (browser->panel), last_panel_page);
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
midori_view_set_uri (MIDORI_VIEW (browser->panel_pageholder),
last_pageholder_uri);
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
Allow hiding the menubar and showing it again
2008-10-12 20:09:49 +00:00
_action_set_active (browser, "Menubar", show_menubar);
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
_action_set_active (browser, "Navigationbar", show_navigationbar);
_action_set_active (browser, "Bookmarkbar", show_bookmarkbar);
_action_set_active (browser, "Panel", show_panel);
_action_set_active (browser, "Statusbar", show_statusbar);
Create navigationbar from a string of actions
2008-10-12 16:14:57 +00:00
g_free (toolbar_items);
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
g_free (last_pageholder_uri);
}
Update interface and web featureswith preference changes. The toolbar style, small toolbar, New Tab, Web Search and Trash buttons are shown or hidden respectively as the preference values change. This is also an attempt at updating the web view's settings immediately. Although it seems to work, an ugly warning is emitted to the console on every change.
2008-04-22 20:19:24 +00:00
static void
midori_browser_settings_notify (MidoriWebSettings* web_settings,
GParamSpec* pspec,
MidoriBrowser* browser)
{
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
const gchar* name;
Update interface and web featureswith preference changes. The toolbar style, small toolbar, New Tab, Web Search and Trash buttons are shown or hidden respectively as the preference values change. This is also an attempt at updating the web view's settings immediately. Although it seems to work, an ugly warning is emitted to the console on every change.
2008-04-22 20:19:24 +00:00
GValue value = {0, };
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
name = g_intern_string (pspec->name);
Update interface and web featureswith preference changes. The toolbar style, small toolbar, New Tab, Web Search and Trash buttons are shown or hidden respectively as the preference values change. This is also an attempt at updating the web view's settings immediately. Although it seems to work, an ugly warning is emitted to the console on every change.
2008-04-22 20:19:24 +00:00
g_value_init (&value, pspec->value_type);
Open all bookmarks in the current tab
2008-10-17 21:15:37 +00:00
g_object_get_property (G_OBJECT (web_settings), name, &value);
Update interface and web featureswith preference changes. The toolbar style, small toolbar, New Tab, Web Search and Trash buttons are shown or hidden respectively as the preference values change. This is also an attempt at updating the web view's settings immediately. Although it seems to work, an ugly warning is emitted to the console on every change.
2008-04-22 20:19:24 +00:00
if (name == g_intern_string ("toolbar-style"))
_midori_browser_set_toolbar_style (browser, g_value_get_enum (&value));
Create navigationbar from a string of actions
2008-10-12 16:14:57 +00:00
else if (name == g_intern_string ("toolbar-items"))
_midori_browser_set_toolbar_items (browser, g_value_get_string (&value));
Add Compact sidepanel Preference
2008-10-21 22:01:01 +00:00
else if (name == g_intern_string ("compact-sidepanel"))
midori_panel_set_compact (MIDORI_PANEL (browser->panel),
g_value_get_boolean (&value));
Add Always Show Tabbar preference
2008-10-03 23:45:17 +00:00
else if (name == g_intern_string ("always-show-tabbar"))
_toggle_tabbar_smartly (browser);
Update interface and web featureswith preference changes. The toolbar style, small toolbar, New Tab, Web Search and Trash buttons are shown or hidden respectively as the preference values change. This is also an attempt at updating the web view's settings immediately. Although it seems to work, an ugly warning is emitted to the console on every change.
2008-04-22 20:19:24 +00:00
else if (!g_object_class_find_property (G_OBJECT_GET_CLASS (web_settings),
name))
Fix focus in location if starting up with a Blank page At the point of loading the first page the web view hasn't loaded anything, so we need to manually focus the Location if the page is blank. Incidentally midori_browser_activate_action can activate any action, so it will probably be much more useful in the future.
2008-04-25 19:31:57 +00:00
g_warning (_("Unexpected setting '%s'"), name);
Update interface and web featureswith preference changes. The toolbar style, small toolbar, New Tab, Web Search and Trash buttons are shown or hidden respectively as the preference values change. This is also an attempt at updating the web view's settings immediately. Although it seems to work, an ugly warning is emitted to the console on every change.
2008-04-22 20:19:24 +00:00
g_value_unset (&value);
}
Revamp bookmarkbar items based on KatzeArrayAction Some refactoring in KatzeArrayAction and the addition of a function to create arbitrary bookmark tool items allows us to easily revamp the bookmarkbar so that it finally reflectls changes to the bookmarks, including adding and removing items.
2008-10-26 21:22:26 +00:00
static void
browser_bookmarks_add_item_cb (KatzeArray* array,
KatzeItem* item,
MidoriBrowser* browser)
{
GtkToolItem* toolitem;
toolitem = katze_array_action_create_tool_item_for (
KATZE_ARRAY_ACTION (_action_by_name (browser, "Bookmarks")), item);
g_object_set_data (G_OBJECT (toolitem), "KatzeItem", item);
if (!KATZE_IS_ARRAY (item) && katze_item_get_uri (item))
g_signal_connect (toolitem, "clicked",
G_CALLBACK (midori_browser_menu_bookmarks_item_activate_cb),
browser);
if (KATZE_IS_ARRAY (item) || katze_item_get_uri (item))
{
g_signal_connect (gtk_bin_get_child (GTK_BIN (toolitem)),
"button-press-event",
G_CALLBACK (midori_browser_bookmarkbar_item_button_press_event_cb),
browser);
g_object_set_data (G_OBJECT (gtk_bin_get_child (GTK_BIN (toolitem))),
"KatzeItem", item);
}
Refactor bookmark context menu, apply it on the bookmarkbar
2008-10-30 01:19:52 +00:00
/* FIXME: Work around the inability to apply button events
to separator tool items */
Revamp bookmarkbar items based on KatzeArrayAction Some refactoring in KatzeArrayAction and the addition of a function to create arbitrary bookmark tool items allows us to easily revamp the bookmarkbar so that it finally reflectls changes to the bookmarks, including adding and removing items.
2008-10-26 21:22:26 +00:00
gtk_widget_show (GTK_WIDGET (toolitem));
gtk_toolbar_insert (GTK_TOOLBAR (browser->bookmarkbar), toolitem, -1);
}
static void
browser_bookmarks_remove_item_cb (KatzeArray* array,
KatzeItem* removed_item,
MidoriBrowser* browser)
{
GList* children;
GtkWidget* toolitem;
KatzeItem* item;
Marge some more of history and bookmark handling
2008-10-31 00:38:18 +00:00
GtkTreeModel* model;
GtkTreeIter iter;
gsize i = 0;
Revamp bookmarkbar items based on KatzeArrayAction Some refactoring in KatzeArrayAction and the addition of a function to create arbitrary bookmark tool items allows us to easily revamp the bookmarkbar so that it finally reflectls changes to the bookmarks, including adding and removing items.
2008-10-26 21:22:26 +00:00
children = gtk_container_get_children (GTK_CONTAINER (browser->bookmarkbar));
while (children != NULL)
{
toolitem = GTK_WIDGET (children->data);
item = (KatzeItem*)g_object_get_data (G_OBJECT (toolitem), "KatzeItem");
if (item == removed_item)
gtk_widget_destroy (toolitem);
children = g_list_next (children);
}
Marge some more of history and bookmark handling
2008-10-31 00:38:18 +00:00
model = gtk_tree_view_get_model (GTK_TREE_VIEW (browser->panel_bookmarks));
i = 0;
item = NULL;
while (item != removed_item &&
gtk_tree_model_iter_nth_child (model, &iter, NULL, i))
{
gtk_tree_model_get (model, &iter, 0, &item, -1);
if (item == removed_item)
midori_browser_model_remove_item (model, item, &iter);
i++;
}
}
static void
bookmarks_model_insert_folder (GtkTreeStore* treestore,
GtkTreeIter* parent,
KatzeArray* array)
{
guint n, i;
KatzeItem* item;
GtkTreeIter iter;
n = katze_array_get_length (array);
for (i = 0; i < n; i++)
{
item = katze_array_get_nth_item (array, i);
g_object_ref (item);
gtk_tree_store_insert_with_values (treestore, &iter, parent, n,
0, item, -1);
g_object_ref (item);
if (KATZE_IS_ARRAY (item))
bookmarks_model_insert_folder (treestore, &iter, KATZE_ARRAY (item));
}
Revamp bookmarkbar items based on KatzeArrayAction Some refactoring in KatzeArrayAction and the addition of a function to create arbitrary bookmark tool items allows us to easily revamp the bookmarkbar so that it finally reflectls changes to the bookmarks, including adding and removing items.
2008-10-26 21:22:26 +00:00
}
Make bookmarks a property of browser and app This means we have removed the last remaining global variable.
2008-09-03 00:28:54 +00:00
static void
midori_browser_load_bookmarks (MidoriBrowser* browser)
{
guint i, n;
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
KatzeItem* item;
Make bookmarks a property of browser and app This means we have removed the last remaining global variable.
2008-09-03 00:28:54 +00:00
GtkTreeModel* treestore;
// FIXME: Clear bookmark panel
_action_set_sensitive (browser, "BookmarkAdd", FALSE);
if (!browser->bookmarks)
return;
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
n = katze_array_get_length (browser->bookmarks);
Make bookmarks a property of browser and app This means we have removed the last remaining global variable.
2008-09-03 00:28:54 +00:00
for (i = 0; i < n; i++)
{
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
item = katze_array_get_nth_item (browser->bookmarks, i);
Revamp bookmarkbar items based on KatzeArrayAction Some refactoring in KatzeArrayAction and the addition of a function to create arbitrary bookmark tool items allows us to easily revamp the bookmarkbar so that it finally reflectls changes to the bookmarks, including adding and removing items.
2008-10-26 21:22:26 +00:00
browser_bookmarks_add_item_cb (browser->bookmarks, item, browser);
Make bookmarks a property of browser and app This means we have removed the last remaining global variable.
2008-09-03 00:28:54 +00:00
}
Revamp bookmarkbar items based on KatzeArrayAction Some refactoring in KatzeArrayAction and the addition of a function to create arbitrary bookmark tool items allows us to easily revamp the bookmarkbar so that it finally reflectls changes to the bookmarks, including adding and removing items.
2008-10-26 21:22:26 +00:00
g_signal_connect (browser->bookmarks, "add-item",
G_CALLBACK (browser_bookmarks_add_item_cb), browser);
g_signal_connect (browser->bookmarks, "remove-item",
G_CALLBACK (browser_bookmarks_remove_item_cb), browser);
Make bookmarks a property of browser and app This means we have removed the last remaining global variable.
2008-09-03 00:28:54 +00:00
treestore = gtk_tree_view_get_model (GTK_TREE_VIEW (browser->panel_bookmarks));
Marge some more of history and bookmark handling
2008-10-31 00:38:18 +00:00
bookmarks_model_insert_folder (GTK_TREE_STORE (treestore),
NULL, browser->bookmarks);
Make bookmarks a property of browser and app This means we have removed the last remaining global variable.
2008-09-03 00:28:54 +00:00
midori_panel_bookmarks_cursor_or_row_changed_cb (
GTK_TREE_VIEW (browser->panel_bookmarks), browser);
_action_set_sensitive (browser, "BookmarkAdd", TRUE);
}
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
static void
_tree_store_insert_history_item (GtkTreeStore* treestore,
GtkTreeIter* parent,
KatzeItem* item)
{
GtkTreeIter iter;
KatzeItem* child;
guint i, n;
GtkTreeIter* piter;
Display relative dates in History panel
2008-10-23 23:35:34 +00:00
time_t now;
gint64 date;
gint age = -1;
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
g_return_if_fail (KATZE_IS_ITEM (item));
if (KATZE_IS_ARRAY (item))
{
piter = parent;
Display relative dates in History panel
2008-10-23 23:35:34 +00:00
if ((date = katze_item_get_added (item)))
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
{
Display relative dates in History panel
2008-10-23 23:35:34 +00:00
now = time (NULL);
age = sokoke_days_between (&date, &now);
gtk_tree_store_insert_with_values (treestore, &iter, parent,
0, 0, item, 1, age, -1);
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
g_object_unref (item);
piter = &iter;
}
n = katze_array_get_length (KATZE_ARRAY (item));
for (i = 0; i < n; i++)
{
child = katze_array_get_nth_item (KATZE_ARRAY (item), i);
_tree_store_insert_history_item (treestore, piter, child);
}
}
else
{
Display relative dates in History panel
2008-10-23 23:35:34 +00:00
gtk_tree_store_insert_with_values (treestore, &iter, parent,
0, 0, item, 1, age, -1);
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
g_object_unref (item);
}
}
static void
midori_browser_new_history_item (MidoriBrowser* browser,
KatzeItem* item)
{
GtkTreeView* treeview;
GtkTreeModel* treemodel;
GtkTreeIter iter;
KatzeArray* parent;
gint i;
gboolean found;
time_t now;
Implement number of days history is saved Note that this will 'break' any existing history and all dates will suddenly jump the beginning of the unix epoch.
2008-10-15 23:31:47 +00:00
gint64 date;
Implement KatzeNet as a generic URI loader KatzeNet can from now on be used where URIs are handled and one would have used libSoup and/ or local file handling as appropriate, whereas KatzeNet does both. Since we are displaying icons in several places KatzeNet also provides an icon loader that saves us from doublicating even more code. All bookmarks and also history items have icons now, since KatzeNet makes that incredibly easy. Search engines are also using favicons now, and right now custom icons don't work, we still need to fix that. Note that only icons are cached, nothing else and the code is known to have a hidden, hard to reproduce crasher which may appear when an icon is newly loaded.
2008-10-23 22:09:12 +00:00
time_t date_;
Display relative dates in History panel
2008-10-23 23:35:34 +00:00
gint age;
gint newage;
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
Implement the Remeber last visited pages preference
2008-10-13 16:29:46 +00:00
if (!sokoke_object_get_boolean (browser->settings, "remember-last-visited-pages"))
return;
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
treeview = GTK_TREE_VIEW (browser->panel_history);
treemodel = gtk_tree_view_get_model (treeview);
now = time (NULL);
Implement number of days history is saved Note that this will 'break' any existing history and all dates will suddenly jump the beginning of the unix epoch.
2008-10-15 23:31:47 +00:00
katze_item_set_added (item, now);
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
found = FALSE;
i = 0;
while (gtk_tree_model_iter_nth_child (treemodel, &iter, NULL, i++))
{
Display relative dates in History panel
2008-10-23 23:35:34 +00:00
gtk_tree_model_get (treemodel, &iter, 0, &parent, 1, &age, -1);
Implement number of days history is saved Note that this will 'break' any existing history and all dates will suddenly jump the beginning of the unix epoch.
2008-10-15 23:31:47 +00:00
date = katze_item_get_added (KATZE_ITEM (parent));
Implement KatzeNet as a generic URI loader KatzeNet can from now on be used where URIs are handled and one would have used libSoup and/ or local file handling as appropriate, whereas KatzeNet does both. Since we are displaying icons in several places KatzeNet also provides an icon loader that saves us from doublicating even more code. All bookmarks and also history items have icons now, since KatzeNet makes that incredibly easy. Search engines are also using favicons now, and right now custom icons don't work, we still need to fix that. Note that only icons are cached, nothing else and the code is known to have a hidden, hard to reproduce crasher which may appear when an icon is newly loaded.
2008-10-23 22:09:12 +00:00
date_ = (time_t)date;
Display relative dates in History panel
2008-10-23 23:35:34 +00:00
newage = sokoke_days_between (&date, &now);
if (newage == 0)
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
{
found = TRUE;
Display relative dates in History panel
2008-10-23 23:35:34 +00:00
_tree_store_insert_history_item (GTK_TREE_STORE (treemodel),
&iter, item);
katze_array_add_item (parent, item);
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
}
Display relative dates in History panel
2008-10-23 23:35:34 +00:00
if (age != newage)
gtk_tree_store_set (GTK_TREE_STORE (treemodel),
&iter, 1, newage, -1);
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
g_object_unref (parent);
}
if (!found)
{
parent = katze_array_new (KATZE_TYPE_ARRAY);
Implement number of days history is saved Note that this will 'break' any existing history and all dates will suddenly jump the beginning of the unix epoch.
2008-10-15 23:31:47 +00:00
katze_item_set_added (KATZE_ITEM (parent), now);
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
katze_array_add_item (browser->history, parent);
katze_array_add_item (parent, item);
_tree_store_insert_history_item (GTK_TREE_STORE (treemodel), NULL,
KATZE_ITEM (parent));
}
}
First stab at integration history with the location For starters, the location contains items from the history and not only from the current session.
2008-10-27 02:12:09 +00:00
static void
_location_action_insert_history_item (MidoriLocationAction* action,
MidoriBrowser* browser,
KatzeItem* item)
{
KatzeItem* child;
guint i, n;
const gchar* uri;
GdkPixbuf* pixbuf = NULL;
g_return_if_fail (MIDORI_IS_LOCATION_ACTION (action));
g_return_if_fail (KATZE_IS_ITEM (item));
if (KATZE_IS_ARRAY (item))
{
n = katze_array_get_length (KATZE_ARRAY (item));
for (i = n; i > 0; i--)
{
child = katze_array_get_nth_item (KATZE_ARRAY (item), i - 1);
_location_action_insert_history_item (action, browser, child);
}
}
else
{
uri = katze_item_get_uri (item);
pixbuf = katze_net_load_icon (browser->net, katze_item_get_uri (item),
NULL, GTK_WIDGET (browser), NULL);
midori_location_action_add_item (action, uri, pixbuf, katze_item_get_name (item));
}
}
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
static void
midori_browser_load_history (MidoriBrowser* browser)
{
GtkTreeView* treeview;
GtkTreeModel* treemodel;
First stab at integration history with the location For starters, the location contains items from the history and not only from the current session.
2008-10-27 02:12:09 +00:00
GtkAction* action;
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
if (!browser->history)
return;
treeview = GTK_TREE_VIEW (browser->panel_history);
treemodel = gtk_tree_view_get_model (treeview);
_tree_store_insert_history_item (GTK_TREE_STORE (treemodel),
NULL, KATZE_ITEM (browser->history));
First stab at integration history with the location For starters, the location contains items from the history and not only from the current session.
2008-10-27 02:12:09 +00:00
action = _action_by_name (browser, "Location");
_location_action_insert_history_item (MIDORI_LOCATION_ACTION (action),
browser,
KATZE_ITEM (browser->history));
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
static void
midori_browser_set_property (GObject* object,
guint prop_id,
const GValue* value,
GParamSpec* pspec)
{
MidoriBrowser* browser = MIDORI_BROWSER (object);
Finish missing web search functionality
2008-06-15 23:13:27 +00:00
guint last_web_search;
Rename MidoriWebItem to KatzeItem
2008-08-23 16:32:53 +00:00
KatzeItem* item;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
switch (prop_id)
{
Save the session whenever it changes, instead of on quit.
2008-07-23 18:17:13 +00:00
case PROP_URI:
Add an Open external pages in Preference
2008-10-20 06:50:16 +00:00
midori_browser_set_current_uri (browser, g_value_get_string (value));
Save the session whenever it changes, instead of on quit.
2008-07-23 18:17:13 +00:00
break;
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
case PROP_TAB:
midori_browser_set_current_tab (browser, g_value_get_object (value));
break;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
case PROP_STATUSBAR_TEXT:
_midori_browser_set_statusbar_text (browser, g_value_get_string (value));
break;
case PROP_SETTINGS:
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
if (browser->settings)
g_signal_handlers_disconnect_by_func (browser->settings,
Update interface and web featureswith preference changes. The toolbar style, small toolbar, New Tab, Web Search and Trash buttons are shown or hidden respectively as the preference values change. This is also an attempt at updating the web view's settings immediately. Although it seems to work, an ugly warning is emitted to the console on every change.
2008-04-22 20:19:24 +00:00
midori_browser_settings_notify,
browser);
Share net between browser and views
2008-10-27 03:23:41 +00:00
katze_object_assign (browser->settings, g_value_dup_object (value));
Remove old configuration logic entirely Almost all uses of the old system were superseded by the use of MidoriWebSettings now, the migration is almost finished.
2008-04-16 23:38:22 +00:00
_midori_browser_update_settings (browser);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
g_signal_connect (browser->settings, "notify",
Update interface and web featureswith preference changes. The toolbar style, small toolbar, New Tab, Web Search and Trash buttons are shown or hidden respectively as the preference values change. This is also an attempt at updating the web view's settings immediately. Although it seems to work, an ugly warning is emitted to the console on every change.
2008-04-22 20:19:24 +00:00
G_CALLBACK (midori_browser_settings_notify), browser);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_container_foreach (GTK_CONTAINER (browser->notebook),
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
(GtkCallback) midori_view_set_settings, browser->settings);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
break;
Make bookmarks a property of browser and app This means we have removed the last remaining global variable.
2008-09-03 00:28:54 +00:00
case PROP_BOOKMARKS:
; /* FIXME: Disconnect handlers */
Share net between browser and views
2008-10-27 03:23:41 +00:00
katze_object_assign (browser->bookmarks, g_value_dup_object (value));
Finish refactoring the toolbar to use only actions Finally the trash, which was the last item that needed to be implemented as an action, is an action, a KatzeArrayAction to be exact. This simplifies more code and also makes Window and RecentlyVisited generically implementable. Incidentally this change also fixes a bug where the browser tried to add a new tab when the last one was closed, even while destroying itself. Furthermore sokoke_image_menu_item_ellipsized and sokoke_widget_popup were promoted to Katze. We're still keeping the old functions for now.
2008-10-10 20:31:37 +00:00
g_object_set (_action_by_name (browser, "Bookmarks"), "array",
browser->bookmarks, NULL);
Make bookmarks a property of browser and app This means we have removed the last remaining global variable.
2008-09-03 00:28:54 +00:00
midori_browser_load_bookmarks (browser);
/* FIXME: Connect to updates */
break;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
case PROP_TRASH:
Introduce MidoriWebList, second step of refactoring web search
2008-06-14 00:23:33 +00:00
; /* FIXME: Disconnect handlers */
Share net between browser and views
2008-10-27 03:23:41 +00:00
katze_object_assign (browser->trash, g_value_dup_object (value));
Finish refactoring the toolbar to use only actions Finally the trash, which was the last item that needed to be implemented as an action, is an action, a KatzeArrayAction to be exact. This simplifies more code and also makes Window and RecentlyVisited generically implementable. Incidentally this change also fixes a bug where the browser tried to add a new tab when the last one was closed, even while destroying itself. Furthermore sokoke_image_menu_item_ellipsized and sokoke_widget_popup were promoted to Katze. We're still keeping the old functions for now.
2008-10-10 20:31:37 +00:00
g_object_set (_action_by_name (browser, "Trash"), "array",
browser->trash, NULL);
Introduce MidoriWebList, second step of refactoring web search
2008-06-14 00:23:33 +00:00
/* FIXME: Connect to updates */
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
_midori_browser_update_actions (browser);
break;
Complete move of webSearch, third step of refactoring web search
2008-06-15 02:02:56 +00:00
case PROP_SEARCH_ENGINES:
; /* FIXME: Disconnect handlers */
Share net between browser and views
2008-10-27 03:23:41 +00:00
katze_object_assign (browser->search_engines, g_value_dup_object (value));
Implement the search widget as an action The most part of the search entry code is merely moved to the new action. We remove the original entry now, the action is all we need.
2008-10-05 21:25:02 +00:00
midori_search_action_set_search_engines (MIDORI_SEARCH_ACTION (
_action_by_name (browser, "Search")), browser->search_engines);
Complete move of webSearch, third step of refactoring web search
2008-06-15 02:02:56 +00:00
/* FIXME: Connect to updates */
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
if (browser->settings)
Finish missing web search functionality
2008-06-15 23:13:27 +00:00
{
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
g_object_get (browser->settings, "last-web-search",
Finish missing web search functionality
2008-06-15 23:13:27 +00:00
&last_web_search, NULL);
Rework MidoriWebList into KatzeList and KatzeArray
2008-08-25 23:19:38 +00:00
item = katze_array_get_nth_item (browser->search_engines,
last_web_search);
Implement the search widget as an action The most part of the search entry code is merely moved to the new action. We remove the original entry now, the action is all we need.
2008-10-05 21:25:02 +00:00
midori_search_action_set_current_item (MIDORI_SEARCH_ACTION (
_action_by_name (browser, "Search")), item);
Finish missing web search functionality
2008-06-15 23:13:27 +00:00
}
Complete move of webSearch, third step of refactoring web search
2008-06-15 02:02:56 +00:00
break;
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
case PROP_HISTORY:
; /* FIXME: Disconnect handlers */
Share net between browser and views
2008-10-27 03:23:41 +00:00
katze_object_assign (browser->history, g_value_dup_object (value));
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
midori_browser_load_history (browser);
Finish refactoring the toolbar to use only actions Finally the trash, which was the last item that needed to be implemented as an action, is an action, a KatzeArrayAction to be exact. This simplifies more code and also makes Window and RecentlyVisited generically implementable. Incidentally this change also fixes a bug where the browser tried to add a new tab when the last one was closed, even while destroying itself. Furthermore sokoke_image_menu_item_ellipsized and sokoke_widget_popup were promoted to Katze. We're still keeping the old functions for now.
2008-10-10 20:31:37 +00:00
g_object_set (_action_by_name (browser, "RecentlyVisited"), "array",
browser->history, NULL);
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
/* FIXME: Connect to updates */
break;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
midori_browser_get_property (GObject* object,
guint prop_id,
GValue* value,
GParamSpec* pspec)
{
MidoriBrowser* browser = MIDORI_BROWSER (object);
switch (prop_id)
{
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
case PROP_MENUBAR:
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
g_value_set_object (value, browser->menubar);
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
break;
case PROP_NAVIGATIONBAR:
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
g_value_set_object (value, browser->navigationbar);
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
break;
Save the session whenever it changes, instead of on quit.
2008-07-23 18:17:13 +00:00
case PROP_URI:
g_value_set_string (value, midori_browser_get_current_uri (browser));
break;
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
case PROP_TAB:
g_value_set_object (value, midori_browser_get_current_tab (browser));
break;
case PROP_STATUSBAR:
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
g_value_set_object (value, browser->statusbar);
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
break;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
case PROP_STATUSBAR_TEXT:
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
g_value_set_string (value, browser->statusbar_text);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
break;
case PROP_SETTINGS:
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
g_value_set_object (value, browser->settings);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
break;
Make bookmarks a property of browser and app This means we have removed the last remaining global variable.
2008-09-03 00:28:54 +00:00
case PROP_BOOKMARKS:
g_value_set_object (value, browser->bookmarks);
break;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
case PROP_TRASH:
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
g_value_set_object (value, browser->trash);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
break;
Complete move of webSearch, third step of refactoring web search
2008-06-15 02:02:56 +00:00
case PROP_SEARCH_ENGINES:
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
g_value_set_object (value, browser->search_engines);
Complete move of webSearch, third step of refactoring web search
2008-06-15 02:02:56 +00:00
break;
Implement navigation history backed by sqlite The implementation relies on KatzeArray for the most part and only does the storage with sqlite behind the scenes. The change includes a working History panel. Changes to the database are committed in realtime.
2008-10-07 00:19:33 +00:00
case PROP_HISTORY:
g_value_set_object (value, browser->history);
break;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
/**
* midori_browser_new:
*
* Creates a new browser widget.
*
Implement MidoriApp singleton and improve multiple window support The new singleton holds the shared settings and trash. It is further more used to keep track of all open windows and quits when the last window was closed. It also watches the focus in case you need something like a "current" browser.
2008-05-22 22:17:10 +00:00
* A browser is a window with a menubar, toolbars, a notebook, panels
* and a statusbar. You should mostly treat it as an opaque widget.
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
*
* Return value: a new #MidoriBrowser
**/
Implement MidoriApp singleton and improve multiple window support The new singleton holds the shared settings and trash. It is further more used to keep track of all open windows and quits when the last window was closed. It also watches the focus in case you need something like a "current" browser.
2008-05-22 22:17:10 +00:00
MidoriBrowser*
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
midori_browser_new (void)
{
MidoriBrowser* browser = g_object_new (MIDORI_TYPE_BROWSER,
NULL);
Implement MidoriApp singleton and improve multiple window support The new singleton holds the shared settings and trash. It is further more used to keep track of all open windows and quits when the last window was closed. It also watches the focus in case you need something like a "current" browser.
2008-05-22 22:17:10 +00:00
return browser;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
/**
Provide action signals as javascript functions From javscript C functions cannot be called, but signals are available through the GObject type system. So we allow javascript to call action signals like functions. At the same time we modify a few browser functions, so that they are functions that are available as signals.
2008-05-31 22:21:08 +00:00
* midori_browser_add_tab:
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
* @browser: a #MidoriBrowser
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
* @widget: a view
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
*
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
* Appends a view in the form of a new tab and creates an
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
* according item in the Window menu.
*
* Return value: the index of the new tab, or -1 in case of an error
**/
gint
Provide action signals as javascript functions From javscript C functions cannot be called, but signals are available through the GObject type system. So we allow javascript to call action signals like functions. At the same time we modify a few browser functions, so that they are functions that are available as signals.
2008-05-31 22:21:08 +00:00
midori_browser_add_tab (MidoriBrowser* browser,
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
GtkWidget* view)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
g_signal_emit (browser, signals[ADD_TAB], 0, view);
return gtk_notebook_page_num (GTK_NOTEBOOK (browser->notebook), view);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
/**
* midori_browser_remove_tab:
* @browser: a #MidoriBrowser
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
* @widget: a view
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
*
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
* Removes an existing view from the browser,
* including an associated menu item.
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
**/
void
midori_browser_remove_tab (MidoriBrowser* browser,
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
GtkWidget* view)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
g_signal_emit (browser, signals[REMOVE_TAB], 0, view);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
/**
* midori_browser_add_item:
* @browser: a #MidoriBrowser
* @item: an item
*
* Appends a new view as described by @item.
*
* Note: Currently this will always be a #MidoriWebView.
*
* Return value: the index of the new tab, or -1 in case of an error
**/
gint
midori_browser_add_item (MidoriBrowser* browser,
KatzeItem* item)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
const gchar* uri;
const gchar* title;
GtkWidget* view;
g_return_val_if_fail (KATZE_IS_ITEM (item), -1);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
uri = katze_item_get_uri (item);
title = katze_item_get_name (item);
view = g_object_new (MIDORI_TYPE_VIEW,
"title", title,
"settings", browser->settings,
NULL);
midori_view_set_uri (MIDORI_VIEW (view), uri);
gtk_widget_show (view);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
return midori_browser_add_tab (browser, view);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
/**
Provide action signals as javascript functions From javscript C functions cannot be called, but signals are available through the GObject type system. So we allow javascript to call action signals like functions. At the same time we modify a few browser functions, so that they are functions that are available as signals.
2008-05-31 22:21:08 +00:00
* midori_browser_add_uri:
Fix background tabs, strings and new tab focus.
2008-04-18 00:40:53 +00:00
* @browser: a #MidoriBrowser
* @uri: an URI
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
*
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
* Appends an uri in the form of a new view.
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
*
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
* Note: Currently this will always be a #MidoriView.
*
* Return value: the index of the new view, or -1
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
**/
gint
Provide action signals as javascript functions From javscript C functions cannot be called, but signals are available through the GObject type system. So we allow javascript to call action signals like functions. At the same time we modify a few browser functions, so that they are functions that are available as signals.
2008-05-31 22:21:08 +00:00
midori_browser_add_uri (MidoriBrowser* browser,
const gchar* uri)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
GtkWidget* view;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
view = g_object_new (MIDORI_TYPE_VIEW,
"settings", browser->settings,
NULL);
midori_view_set_uri (MIDORI_VIEW (view), uri);
gtk_widget_show (view);
Save the session whenever it changes, instead of on quit.
2008-07-23 18:17:13 +00:00
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
return midori_browser_add_tab (browser, view);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
Fix focus in location if starting up with a Blank page At the point of loading the first page the web view hasn't loaded anything, so we need to manually focus the Location if the page is blank. Incidentally midori_browser_activate_action can activate any action, so it will probably be much more useful in the future.
2008-04-25 19:31:57 +00:00
/**
* midori_browser_activate_action:
* @browser: a #MidoriBrowser
* @name: name of the action
*
* Activates the specified action.
**/
void
midori_browser_activate_action (MidoriBrowser* browser,
const gchar* name)
{
Complete move of webSearch, third step of refactoring web search
2008-06-15 02:02:56 +00:00
g_signal_emit (browser, signals[ACTIVATE_ACTION], 0, name);
Fix focus in location if starting up with a Blank page At the point of loading the first page the web view hasn't loaded anything, so we need to manually focus the Location if the page is blank. Incidentally midori_browser_activate_action can activate any action, so it will probably be much more useful in the future.
2008-04-25 19:31:57 +00:00
}
Add an Open external pages in Preference
2008-10-20 06:50:16 +00:00
/**
* midori_browser_set_current_uri:
* @browser: a #MidoriBrowser
* @uri: an URI
*
* Loads the specified URI in the current view.
*
* If the current view is opaque, and cannot load
* new pages, it will automatically open a new tab.
**/
void
midori_browser_set_current_uri (MidoriBrowser* browser,
const gchar* uri)
{
GtkWidget* view;
g_return_if_fail (MIDORI_IS_BROWSER (browser));
g_return_if_fail (uri);
view = midori_browser_get_current_tab (browser);
midori_view_set_uri (MIDORI_VIEW (view), uri);
}
Save the session whenever it changes, instead of on quit.
2008-07-23 18:17:13 +00:00
/**
* midori_browser_get_current_uri:
* @browser: a #MidoriBrowser
*
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
* Determines the URI loaded in the current view.
Save the session whenever it changes, instead of on quit.
2008-07-23 18:17:13 +00:00
*
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
* If there is no view present at all, %NULL is returned.
Save the session whenever it changes, instead of on quit.
2008-07-23 18:17:13 +00:00
*
* Return value: the current URI, or %NULL
**/
const gchar*
midori_browser_get_current_uri (MidoriBrowser* browser)
{
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
GtkWidget* view;
Save the session whenever it changes, instead of on quit.
2008-07-23 18:17:13 +00:00
g_return_val_if_fail (MIDORI_IS_BROWSER (browser), NULL);
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
view = midori_browser_get_current_tab (browser);
return midori_view_get_display_uri (MIDORI_VIEW (view));
Save the session whenever it changes, instead of on quit.
2008-07-23 18:17:13 +00:00
}
Attempt to fix handling of background and foreground tabs.
2008-04-24 22:20:43 +00:00
/**
* midori_browser_set_current_page:
* @browser: a #MidoriBrowser
* @n: the index of a page
*
* Switches to the page with the index @n.
*
* The widget will also grab the focus automatically.
**/
void
midori_browser_set_current_page (MidoriBrowser* browser,
gint n)
{
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
GtkWidget* view;
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_notebook_set_current_page (GTK_NOTEBOOK (browser->notebook), n);
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
view = gtk_notebook_get_nth_page (GTK_NOTEBOOK (browser->notebook), n);
if (view && midori_view_is_blank (MIDORI_VIEW (view)))
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
gtk_action_activate (_action_by_name (browser, "Location"));
Fix focus in location if starting up with a Blank page At the point of loading the first page the web view hasn't loaded anything, so we need to manually focus the Location if the page is blank. Incidentally midori_browser_activate_action can activate any action, so it will probably be much more useful in the future.
2008-04-25 19:31:57 +00:00
else
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
gtk_widget_grab_focus (view);
Attempt to fix handling of background and foreground tabs.
2008-04-24 22:20:43 +00:00
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
/**
* midori_browser_get_current_page:
* @browser: a #MidoriBrowser
*
* Determines the currently selected page.
*
* If there is no page present at all, %NULL is returned.
*
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
* Return value: the selected page, or -1
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
**/
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
gint
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
midori_browser_get_current_page (MidoriBrowser* browser)
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
{
g_return_val_if_fail (MIDORI_IS_BROWSER (browser), -1);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
return gtk_notebook_get_current_page (GTK_NOTEBOOK (browser->notebook));
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
}
/**
* midori_browser_set_current_tab:
* @browser: a #MidoriBrowser
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
* @view: a #GtkWidget
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
*
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
* Switches to the page containing @view.
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
*
* The widget will also grab the focus automatically.
**/
void
midori_browser_set_current_tab (MidoriBrowser* browser,
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
GtkWidget* view)
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
{
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
gint n;
g_return_if_fail (MIDORI_IS_BROWSER (browser));
g_return_if_fail (GTK_IS_WIDGET (view));
n = gtk_notebook_page_num (GTK_NOTEBOOK (browser->notebook), view);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_notebook_set_current_page (GTK_NOTEBOOK (browser->notebook), n);
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
if (view && midori_view_is_blank (MIDORI_VIEW (view)))
Implement MidoriLocationAction This is a step towards customziable toolbars. The new action actually provides a nicer API than MidoriLocationEntry does right now. Later we should improve the widget itself as well. There are still to resolve regressions: - The location icon tends to be initially empty - The news feed icon doesn't show up - Tab icons sometimes load and reset again afterwards
2008-08-14 23:57:48 +00:00
gtk_action_activate (_action_by_name (browser, "Location"));
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
else
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
gtk_widget_grab_focus (view);
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
}
/**
* midori_browser_get_current_tab:
* @browser: a #MidoriBrowser
*
* Retrieves the currently selected tab.
*
* If there is no tab present at all, %NULL is returned.
*
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
* See also midori_browser_get_current_page().
*
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
* Return value: the selected tab, or %NULL
**/
GtkWidget*
midori_browser_get_current_tab (MidoriBrowser* browser)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
gint n;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
g_return_val_if_fail (MIDORI_IS_BROWSER (browser), NULL);
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
n = gtk_notebook_get_current_page (GTK_NOTEBOOK (browser->notebook));
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
if (n >= 0)
{
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
return gtk_notebook_get_nth_page (GTK_NOTEBOOK (browser->notebook), n);
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
}
else
return NULL;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
/**
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
* midori_browser_get_proxy_array:
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
* @browser: a #MidoriBrowser
*
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
* Retrieves a proxy array representing the respective proxy items
* of the present views that can be used for session management.
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
*
Finish refactoring the toolbar to use only actions Finally the trash, which was the last item that needed to be implemented as an action, is an action, a KatzeArrayAction to be exact. This simplifies more code and also makes Window and RecentlyVisited generically implementable. Incidentally this change also fixes a bug where the browser tried to add a new tab when the last one was closed, even while destroying itself. Furthermore sokoke_image_menu_item_ellipsized and sokoke_widget_popup were promoted to Katze. We're still keeping the old functions for now.
2008-10-10 20:31:37 +00:00
* The array is updated automatically.
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
*
Ensure REMOVE_TAB emission, don't alter session when destroying
2008-07-25 10:45:50 +00:00
* Note: Calling this function doesn't add a reference and the browser
* may release its reference at some point.
*
Factor out katze_xbel_folder_from_data_dirs and _to_data
2008-09-03 22:35:15 +00:00
* Return value: the proxy #KatzeArray
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
**/
Factor out katze_xbel_folder_from_data_dirs and _to_data
2008-09-03 22:35:15 +00:00
KatzeArray*
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
midori_browser_get_proxy_array (MidoriBrowser* browser)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
{
g_return_val_if_fail (MIDORI_IS_BROWSER (browser), NULL);
Implement tabs in individual processes The approach is rather plump, Midori can be run in a plug mode that creates a GtkPlug, while the normal instance knows how to embed it. Communication between browser and tabs is done via named pipes which are portable. The feature is not complete right now, there are expected regressions, but it works. As a bonus, we implement Not found pages.
2008-09-26 21:13:46 +00:00
return browser->proxy_array;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
}
Provide action signals as javascript functions From javscript C functions cannot be called, but signals are available through the GObject type system. So we allow javascript to call action signals like functions. At the same time we modify a few browser functions, so that they are functions that are available as signals.
2008-05-31 22:21:08 +00:00
/**
* midori_browser_quit:
* @browser: a #MidoriBrowser
*
* Quits the browser, including any other browser windows.
Complete move of webSearch, third step of refactoring web search
2008-06-15 02:02:56 +00:00
*
* This function relys on the application implementing
* the MidoriBrowser::quit signal. If the browser was added
* to the MidoriApp, this is handled automatically.
Provide action signals as javascript functions From javscript C functions cannot be called, but signals are available through the GObject type system. So we allow javascript to call action signals like functions. At the same time we modify a few browser functions, so that they are functions that are available as signals.
2008-05-31 22:21:08 +00:00
**/
void
midori_browser_quit (MidoriBrowser* browser)
{
g_return_if_fail (MIDORI_IS_BROWSER (browser));
g_signal_emit (browser, signals[QUIT], 0);
}
Reference in a new issue Copy permalink