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

5279 lines
184 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
/*
Refactor bookmarks panel into a separate panel widget
2009-01-31 03:09:35 +00:00
Copyright (C) 2007-2009 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"
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"
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"
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified 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
{
Integrate Midori with Maemo, use a Hildon window and adjust the interface To make Midori play nicely with Maemo the menubar is now integrated, we have a service file, a specific toolbar layout, no statusbar and icon styles. The changes are applied if hildon is available, and can of course be manually enabled or disabled.
2009-01-27 01:57:40 +00:00
#if HAVE_HILDON
HildonWindow parent_instance;
#else
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
GtkWindow parent_instance;
Integrate Midori with Maemo, use a Hildon window and adjust the interface To make Midori play nicely with Maemo the menubar is now integrated, we have a service file, a specific toolbar layout, no statusbar and icon styles. The changes are applied if hildon is available, and can of course be manually enabled or disabled.
2009-01-27 01:57:40 +00:00
#endif
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +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
GtkActionGroup* action_group;
GtkWidget* menubar;
GtkWidget* menu_tools;
GtkWidget* throbber;
GtkWidget* navigationbar;
GtkWidget* button_fullscreen;
GtkWidget* bookmarkbar;
GtkWidget* panel;
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;
Hide find options and close button in 'typing' search
2009-02-22 01:34:21 +00:00
GtkToolItem* find_close;
Actually search after every character in 'typing' search
2009-02-22 01:17:58 +00:00
gboolean find_typing;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified 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* statusbar;
Initial support for WebKitDownload At this point all downloads run automatically and appear in the statusbar. The destination folder can be chosen in the preferences. Download can be cancelled. The context menu works as well.
2009-03-19 17:28:50 +00:00
GtkWidget* transferbar;
Show a 'Delete all' button in the transferbar as needed The button shows up as a new download starts and vanishes again if no downloads are there.
2009-04-19 17:05:05 +00:00
GtkWidget* transferbar_clear;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified 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* progressbar;
gchar* statusbar_text;
Save size and panel position with a delay of 5 seconds
2009-01-25 23:54:12 +00:00
guint alloc_timeout;
guint panel_timeout;
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;
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
gboolean show_navigationbar;
gboolean show_statusbar;
gboolean progress_in_location;
gboolean remember_last_visited_pages;
Allow marking a search engine as Default engine The default engine is used when search terms are typed in the address entry without tokens and for the 'Search the Web' item in the selection context menu. The 'Location entry search' is removed from the preferences. The setting 'location-entry-search' remains functional however.
2009-04-18 20:41:37 +00:00
gchar* location_entry_search;
Add News Aggregator preference The program set here is called if the user clicks on the news feed icon, with the address of the current website as argument. For example liferea-add-feed works like that.
2009-04-14 17:44:48 +00:00
gchar* news_aggregator;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified 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 Midori with Maemo, use a Hildon window and adjust the interface To make Midori play nicely with Maemo the menubar is now integrated, we have a service file, a specific toolbar layout, no statusbar and icon styles. The changes are applied if hildon is available, and can of course be manually enabled or disabled.
2009-01-27 01:57:40 +00:00
#if HAVE_HILDON
G_DEFINE_TYPE (MidoriBrowser, midori_browser, HILDON_TYPE_WINDOW)
#else
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
G_DEFINE_TYPE (MidoriBrowser, midori_browser, GTK_TYPE_WINDOW)
Integrate Midori with Maemo, use a Hildon window and adjust the interface To make Midori play nicely with Maemo the menubar is now integrated, we have a service file, a specific toolbar layout, no statusbar and icon styles. The changes are applied if hildon is available, and can of course be manually enabled or disabled.
2009-01-27 01:57:40 +00:00
#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
enum
{
PROP_0,
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
PROP_MENUBAR,
PROP_NAVIGATIONBAR,
Expose browser notebook and panel as properties
2008-11-18 01:02:59 +00:00
PROP_NOTEBOOK,
PROP_PANEL,
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,
Replace window-object-cleared with context-ready Introduce MidoriBrowser::load-status and also midori_view_execute_script while we are at it.
2008-11-23 04:19:43 +00:00
PROP_LOAD_STATUS,
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
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
NEW_WINDOW,
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,
Replace window-object-cleared with context-ready Introduce MidoriBrowser::load-status and also midori_view_execute_script while we are at it.
2008-11-23 04:19:43 +00:00
CONTEXT_READY,
Add add-download signal to MidoriBrowser
2009-03-22 14:24:40 +00:00
ADD_DOWNLOAD,
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
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));
Add a missing check whether 'settings' are set
2009-02-21 23:12:18 +00:00
if (n < 2 && browser->settings)
Add Always Show Tabbar preference
2008-10-03 23:45:17 +00:00
{
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);
}
}
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
static gboolean
midori_browser_view_can_set_encoding (MidoriView* view)
{
static GParamSpec* pspec = NULL;
if (G_UNLIKELY (!pspec))
pspec = g_object_class_find_property (
g_type_class_peek (WEBKIT_TYPE_WEB_VIEW), "custom-encoding");
/* Web views and zoom, source views can't, so zoom means encoding */
return pspec && midori_view_can_zoom_in (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
_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
Implement Save As for arbitrary links
2008-11-09 21:07:42 +00:00
saving either. If that changes, we need to think of something. */
Implement Save As functionality
2008-10-26 16:07:59 +00:00
_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",
Fix zooming, and make Zoom Normal work again
2009-03-05 21:45:34 +00:00
midori_view_get_zoom_level (MIDORI_VIEW (view)) != 1.0f);
Implement Encoding menu
2009-02-27 22:09:36 +00:00
_action_set_sensitive (browser, "Encoding",
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
midori_browser_view_can_set_encoding (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, "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);
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (!browser->show_navigationbar && !browser->show_statusbar)
Show progress in location independant of statusbar visibility
2008-10-21 22:26:20 +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
}
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);
Don't show the progressbar if the location shows progress
2009-04-12 12:09:06 +00:00
if (!browser->progress_in_location || !GTK_WIDGET_VISIBLE (browser->navigationbar))
gtk_widget_show (browser->progressbar);
Add a Preference Show progress in location entry Disabling the preference will suppress the progress bar inside the location entry and also prevent the navigationbar from showing up during loads if it was otherwise hidden.
2009-02-11 22:41:09 +00:00
if (!GTK_WIDGET_VISIBLE (browser->statusbar) &&
!GTK_WIDGET_VISIBLE (browser->navigationbar) &&
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
browser->progress_in_location)
Show progress in location independant of statusbar visibility
2008-10-21 22:26:20 +00:00
gtk_widget_show (browser->navigationbar);
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (browser->progress_in_location)
Add a Preference Show progress in location entry Disabling the preference will suppress the progress bar inside the location entry and also prevent the navigationbar from showing up during loads if it was otherwise hidden.
2009-02-11 22:41:09 +00:00
{
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
Display the news feed icon again The code for looking up news feeds on websites was disabled and is now back in simplified form. 'liferea-add-feed' is hardcoded for the moment.
2009-04-13 20:40:57 +00:00
action = _action_by_name (browser, "Location");
Add News Aggregator preference The program set here is called if the user clicks on the news feed icon, with the address of the current website as argument. For example liferea-add-feed works like that.
2009-04-14 17:44:48 +00:00
if (browser->news_aggregator && *browser->news_aggregator
&& g_object_get_data (G_OBJECT (view), "news-feeds"))
Display the news feed icon again The code for looking up news feeds on websites was disabled and is now back in simplified form. 'liferea-add-feed' is hardcoded for the moment.
2009-04-13 20:40:57 +00:00
midori_location_action_set_secondary_icon (
MIDORI_LOCATION_ACTION (action), STOCK_NEWS_FEED);
Show news feeds in a menu if the icon is clicked
2008-08-02 02:25:05 +00:00
else
Display the news feed icon again The code for looking up news feeds on websites was disabled and is now back in simplified form. 'liferea-add-feed' is hardcoded for the moment.
2009-04-13 20:40:57 +00:00
midori_location_action_set_secondary_icon (
Do not display any icon if there's no news feed available Work around a bug that made unsetting the secondary icon in the location entry impossible and do not set an icon if there is no news feed instead of an 'information' icon.
2009-04-26 23:11:58 +00:00
MIDORI_LOCATION_ACTION (action), 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)
{
Use katze_object_get_foo instead of sokoke_object_get_foo
2008-11-18 22:10:21 +00:00
if (!katze_object_get_boolean (browser->settings,
Reverse Open tabs in the background with Ctrl
2008-07-16 16:08:47 +00:00
"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);
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (!browser->progress_in_location)
Add a Preference Show progress in location entry Disabling the preference will suppress the progress bar inside the location entry and also prevent the navigationbar from showing up during loads if it was otherwise hidden.
2009-02-11 22:41:09 +00:00
progress = 0.0;
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");
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (browser->remember_last_visited_pages)
Implement the Remeber last visited pages preference
2008-10-13 16:29:46 +00:00
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
{
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (browser->remember_last_visited_pages)
Implement the Remeber last visited pages preference
2008-10-13 16:29:46 +00:00
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 (
Do not display any icon if there's no news feed available Work around a bug that made unsetting the secondary icon in the location entry impossible and do not set an icon if there is no news feed instead of an 'information' icon.
2009-04-26 23:11:58 +00:00
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);
}
Replace window-object-cleared with context-ready Introduce MidoriBrowser::load-status and also midori_view_execute_script while we are at it.
2008-11-23 04:19:43 +00:00
g_object_notify (G_OBJECT (browser), "load-status");
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified 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_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
Replace window-object-cleared with context-ready Introduce MidoriBrowser::load-status and also midori_view_execute_script while we are at it.
2008-11-23 04:19:43 +00:00
midori_view_context_ready_cb (GtkWidget* view,
JSContextRef js_context,
MidoriBrowser* 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
{
Replace window-object-cleared with context-ready Introduce MidoriBrowser::load-status and also midori_view_execute_script while we are at it.
2008-11-23 04:19:43 +00:00
g_signal_emit (browser, signals[CONTEXT_READY], 0, js_context);
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
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified 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 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");
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (browser->remember_last_visited_pages)
Implement the Remeber last visited pages preference
2008-10-13 16:29:46 +00:00
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)
{
Instead of adding multiple same history items, update the original item
2009-01-26 02:43:59 +00:00
KatzeItem* item;
KatzeItem* proxy;
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (browser->history && browser->remember_last_visited_pages)
Instead of adding multiple same history items, update the original item
2009-01-26 02:43:59 +00:00
{
Refactor History panel into a separate class This brings back the problem of address and title of items showing up in the history unfortunately. Now the history items are appended rather than prepended, we probably want to fix that in the future.
2009-02-21 22:59:02 +00:00
item = g_object_get_data (G_OBJECT (view), "history-item-added");
proxy = midori_view_get_proxy_item (MIDORI_VIEW (view));
if (item && katze_item_get_added (item) == katze_item_get_added (proxy))
katze_item_set_name (item, katze_item_get_name (proxy));
else
{
katze_object_assign (item, katze_item_copy (proxy));
midori_browser_new_history_item (browser, g_object_ref (item));
g_object_set_data_full (G_OBJECT (view), "history-item-added",
item, (GDestroyNotify)g_object_unref);
}
Instead of adding multiple same history items, update the original item
2009-01-26 02:43:59 +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
}
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",
Fix zooming, and make Zoom Normal work again
2009-03-05 21:45:34 +00:00
midori_view_get_zoom_level (MIDORI_VIEW (view)) != 1.0f);
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 "New folder" button to the bookmark panel
2009-02-22 02:11:40 +00:00
/* Private function, used by MidoriBookmarks and MidoriHistory */
Refactor bookmarks panel into a separate panel widget
2009-01-31 03:09:35 +00:00
/* static */ void
Add a Bookmark Add item to the link context menu.
2008-06-15 11:29:30 +00:00
midori_browser_edit_bookmark_dialog_new (MidoriBrowser* browser,
Allow adding bookmarks from history items
2008-10-29 02:43:08 +00:00
KatzeItem* bookmark,
Add a "New folder" button to the bookmark panel
2009-02-22 02:11:40 +00:00
gboolean new_bookmark,
gboolean is_folder)
Add a Bookmark Add item to the link context menu.
2008-06-15 11:29:30 +00:00
{
Add a "New folder" button to the bookmark panel
2009-02-22 02:11:40 +00:00
const gchar* title;
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;
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (!browser->bookmarks || !GTK_WIDGET_VISIBLE (browser))
return;
Add a "New folder" button to the bookmark panel
2009-02-22 02:11:40 +00:00
if (is_folder)
title = new_bookmark ? _("New folder") : _("Edit folder");
else
title = new_bookmark ? _("New bookmark") : _("Edit bookmark");
Finally obsolete KatzeXbelItem
2008-10-01 02:00:16 +00:00
dialog = gtk_dialog_new_with_buttons (
Add a "New folder" button to the bookmark panel
2009-02-22 02:11:40 +00:00
title, GTK_WINDOW (browser),
Add a Bookmark Add item to the link context menu.
2008-06-15 11:29:30 +00:00
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);
Add a "New folder" button to the bookmark panel
2009-02-22 02:11:40 +00:00
if (is_folder)
{
Fix browser properties along with enabling the property test
2009-02-22 12:52:04 +00:00
bookmark = (KatzeItem*)katze_array_new (KATZE_TYPE_ARRAY);
Add a "New folder" button to the bookmark panel
2009-02-22 02:11:40 +00:00
katze_item_set_name (bookmark,
midori_view_get_display_title (MIDORI_VIEW (view)));
}
else
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);
Various string changes and additions
2009-01-04 18:21:25 +00:00
label = gtk_label_new_with_mnemonic (_("_Address:"));
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);
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;
Enable changing the containing folder of bookmarks
2009-02-23 23:17:21 +00:00
if (1)
Add a Bookmark Add item to the link context menu.
2008-06-15 11:29:30 +00:00
{
Enable changing the containing folder of bookmarks
2009-02-23 23:17:21 +00:00
KatzeItem* item;
Allow choosing a folder when adding a bookmark
2009-01-01 02:52:43 +00:00
guint i, n;
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 (_("_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 ();
Various string changes and additions
2009-01-04 18:21:25 +00:00
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_folder),
_("Toplevel folder"));
Allow choosing a folder when adding a bookmark
2009-01-01 02:52:43 +00:00
gtk_combo_box_set_active (GTK_COMBO_BOX (combo_folder), 0);
Enable changing the containing folder of bookmarks
2009-02-23 23:17:21 +00:00
i = 0;
n = 1;
while ((item = katze_array_get_nth_item (browser->bookmarks, i++)))
Allow choosing a folder when adding a bookmark
2009-01-01 02:52:43 +00:00
{
if (KATZE_IS_ARRAY (item))
{
const gchar* name = katze_item_get_name (item);
gtk_combo_box_append_text (GTK_COMBO_BOX (combo_folder), name);
Enable changing the containing folder of bookmarks
2009-02-23 23:17:21 +00:00
if (katze_item_get_parent (bookmark) == item)
gtk_combo_box_set_active (GTK_COMBO_BOX (combo_folder), n);
n++;
Allow choosing a folder when adding a bookmark
2009-01-01 02:52:43 +00:00
}
}
Enable changing the containing folder of bookmarks
2009-02-23 23:17:21 +00:00
if (!i)
Allow choosing a folder when adding a bookmark
2009-01-01 02:52:43 +00:00
gtk_widget_set_sensitive (combo_folder, FALSE);
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), 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)
{
Allow choosing a folder when adding a bookmark
2009-01-01 02:52:43 +00:00
gchar* selected;
KatzeArray* folder;
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)));
Refactor bookmarks panel into a separate panel widget
2009-01-31 03:09:35 +00:00
folder = browser->bookmarks;
Enable changing the containing folder of bookmarks
2009-02-23 23:17:21 +00:00
if (1)
Allow choosing a folder when adding a bookmark
2009-01-01 02:52:43 +00:00
{
Refactor bookmarks panel into a separate panel widget
2009-01-31 03:09:35 +00:00
selected = gtk_combo_box_get_active_text (GTK_COMBO_BOX (combo_folder));
if (g_strcmp0 (selected, _("Toplevel folder")))
Allow choosing a folder when adding a bookmark
2009-01-01 02:52:43 +00:00
{
Optimize array iterations in the browser
2009-03-31 19:19:18 +00:00
guint i = 0;
KatzeItem* item;
while ((item = katze_array_get_nth_item (browser->bookmarks, i++)))
Refactor bookmarks panel into a separate panel widget
2009-01-31 03:09:35 +00:00
if (KATZE_IS_ARRAY (item))
if (!g_strcmp0 (katze_item_get_name (item), selected))
{
folder = KATZE_ARRAY (item);
break;
}
Allow choosing a folder when adding a bookmark
2009-01-01 02:52:43 +00:00
}
Refactor bookmarks panel into a separate panel widget
2009-01-31 03:09:35 +00:00
g_free (selected);
Enable changing the containing folder of bookmarks
2009-02-23 23:17:21 +00:00
if (!new_bookmark)
katze_array_remove_item (katze_item_get_parent (bookmark), bookmark);
Allow choosing a folder when adding a bookmark
2009-01-01 02:52:43 +00:00
katze_array_add_item (folder, bookmark);
Add a Bookmark Add item to the link context menu.
2008-06-15 11:29:30 +00:00
}
}
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 midori_browser_get_for_widget_utility function This function will look for a MidoriBrowser according to a particular widget - even if it's inside a detached panel window or any other window transient for the browser.
2009-04-23 02:10:38 +00:00
browser = midori_browser_get_for_widget (menuitem);
Add a "New folder" button to the bookmark panel
2009-02-22 02:11:40 +00:00
midori_browser_edit_bookmark_dialog_new (browser, item, FALSE, FALSE);
Add a Bookmark Add item to the link context menu.
2008-06-15 11:29:30 +00:00
}
Implement Save As for arbitrary links
2008-11-09 21:07:42 +00:00
static void
midori_browser_save_transfer_cb (KatzeNetRequest* request,
gchar* filename)
{
FILE* fp;
Arrange file saving for error handling to fix warnings
2008-11-15 23:10:39 +00:00
size_t ret;
Implement Save As for arbitrary links
2008-11-09 21:07:42 +00:00
if (request->data)
{
if ((fp = fopen (filename, "wb")))
{
Arrange file saving for error handling to fix warnings
2008-11-15 23:10:39 +00:00
ret = fwrite (request->data, 1, request->length, fp);
Implement Save As for arbitrary links
2008-11-09 21:07:42 +00:00
fclose (fp);
Arrange file saving for error handling to fix warnings
2008-11-15 23:10:39 +00:00
if ((ret - request->length) != 0)
{
Print file saving errors to the standard output
2008-11-18 22:18:53 +00:00
/* Once we have a download interface this should be
indicated graphically. */
g_warning ("Error writing to file %s "
"in midori_browser_save_transfer_cb", filename);
Arrange file saving for error handling to fix warnings
2008-11-15 23:10:39 +00:00
}
Implement Save As for arbitrary links
2008-11-09 21:07:42 +00:00
}
}
g_free (filename);
}
static void
midori_browser_save_uri (MidoriBrowser* browser,
const gchar* uri)
{
static gchar* last_dir = NULL;
gboolean folder_set = FALSE;
GtkWidget* dialog;
gchar* filename;
gchar* dirname;
gchar* last_slash;
gchar* folder;
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (!GTK_WIDGET_VISIBLE (browser))
return;
Implement Save As for arbitrary links
2008-11-09 21:07:42 +00:00
dialog = gtk_file_chooser_dialog_new (
_("Save file as"), GTK_WINDOW (browser),
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));
if (uri)
{
/* 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;
}
gtk_widget_destroy (dialog);
}
static void
midori_view_save_as_cb (GtkWidget* menuitem,
const gchar* uri,
GtkWidget* view)
{
MidoriBrowser* browser;
Add midori_browser_get_for_widget_utility function This function will look for a MidoriBrowser according to a particular widget - even if it's inside a detached panel window or any other window transient for the browser.
2009-04-23 02:10:38 +00:00
browser = midori_browser_get_for_widget (menuitem);
Implement Save As for arbitrary links
2008-11-09 21:07:42 +00:00
midori_browser_save_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 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);
}
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);
}
Support opening of new windows The preference determining where to open those windows is not currently honored, so everything goes in a new tab. Incidentally compile time checks guarding the web inspector are replaced with runtime checks here, and the same approach is used for the create-web-view signal. The features are used if available.
2008-12-03 03:16:19 +00:00
static void
midori_view_new_view_cb (GtkWidget* view,
GtkWidget* new_view,
MidoriNewView where,
MidoriBrowser* browser)
{
if (where == MIDORI_NEW_VIEW_WINDOW)
{
/* MidoriBrowser* new_browser = g_object_new (MIDORI_TYPE_BROWSER,
NULL);
g_signal_emit (browser, signals[NEW_BROWSER], 0, new_browser); */
g_debug ("Opening all pages in new windows not implemented");
midori_browser_set_current_page (browser,
midori_browser_add_tab (browser, new_view));
}
else
{
gint n = midori_browser_add_tab (browser, new_view);
if (where != MIDORI_NEW_VIEW_BACKGROUND)
midori_browser_set_current_page (browser, n);
}
}
Initial support for WebKitDownload At this point all downloads run automatically and appear in the statusbar. The destination folder can be chosen in the preferences. Download can be cancelled. The context menu works as well.
2009-03-19 17:28:50 +00:00
#if WEBKIT_CHECK_VERSION (1, 1, 3)
static void
midori_browser_download_notify_progress_cb (WebKitDownload* download,
GParamSpec* pspec,
GtkWidget* progress)
{
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress),
webkit_download_get_progress (download));
}
static void
midori_browser_download_notify_status_cb (WebKitDownload* download,
GParamSpec* pspec,
GtkWidget* button)
{
Provide a Clear button for cancelled downloads
2009-03-21 19:08:37 +00:00
GtkWidget* icon;
Initial support for WebKitDownload At this point all downloads run automatically and appear in the statusbar. The destination folder can be chosen in the preferences. Download can be cancelled. The context menu works as well.
2009-03-19 17:28:50 +00:00
switch (webkit_download_get_status (download))
{
case WEBKIT_DOWNLOAD_STATUS_FINISHED:
Implement transfer completion notification via libnotify
2009-04-26 22:22:16 +00:00
{
MidoriBrowser* browser = midori_browser_get_for_widget (button);
Initial support for WebKitDownload At this point all downloads run automatically and appear in the statusbar. The destination folder can be chosen in the preferences. Download can be cancelled. The context menu works as well.
2009-03-19 17:28:50 +00:00
icon = gtk_image_new_from_stock (GTK_STOCK_OPEN, GTK_ICON_SIZE_MENU);
gtk_button_set_image (GTK_BUTTON (button), icon);
Move download dialog to the view and don't show an error page We have to handle the dialog when the MIME type is requested, otherwise we don't know the type. Plus we stop the loading now to avoid seeing an error page.
2009-03-21 14:06:57 +00:00
if (g_object_get_data (G_OBJECT (download), "open-download"))
Implement the 'open' button in the download dialog
2009-03-21 09:46:25 +00:00
gtk_button_clicked (GTK_BUTTON (button));
Show a 'Delete all' button in the transferbar as needed The button shows up as a new download starts and vanishes again if no downloads are there.
2009-04-19 17:05:05 +00:00
else
g_object_set_data (G_OBJECT (gtk_widget_get_parent (button)),
"done", (void*)1);
Implement transfer completion notification via libnotify
2009-04-26 22:22:16 +00:00
if (browser->settings && katze_object_get_boolean (
browser->settings, "notify-transfer-completed"))
{
gchar* program = g_find_program_in_path ("notify-send");
if (program != NULL)
{
gchar* msg = g_strdup_printf (
_("The file <b>%s</b> has been downloaded."),
webkit_download_get_suggested_filename (download));
gchar* msgq = g_shell_quote (msg);
gchar* titleq = g_shell_quote (_("Transfer completed"));
gchar* command = g_strconcat (titleq, " ", msgq, NULL);
g_free (msg);
g_free (titleq);
g_free (msgq);
sokoke_spawn_program ("notify-send -i midori %s", command, FALSE);
g_free (command);
g_free (program);
}
}
}
Initial support for WebKitDownload At this point all downloads run automatically and appear in the statusbar. The destination folder can be chosen in the preferences. Download can be cancelled. The context menu works as well.
2009-03-19 17:28:50 +00:00
break;
case WEBKIT_DOWNLOAD_STATUS_CANCELLED:
case WEBKIT_DOWNLOAD_STATUS_ERROR:
Provide a Clear button for cancelled downloads
2009-03-21 19:08:37 +00:00
icon = gtk_image_new_from_stock (GTK_STOCK_CLEAR, GTK_ICON_SIZE_MENU);
gtk_button_set_image (GTK_BUTTON (button), icon);
Show a 'Delete all' button in the transferbar as needed The button shows up as a new download starts and vanishes again if no downloads are there.
2009-04-19 17:05:05 +00:00
g_object_set_data (G_OBJECT (gtk_widget_get_parent (button)),
"done", (void*)1);
Initial support for WebKitDownload At this point all downloads run automatically and appear in the statusbar. The destination folder can be chosen in the preferences. Download can be cancelled. The context menu works as well.
2009-03-19 17:28:50 +00:00
break;
default:
break;
}
}
static void
midori_browser_download_button_clicked_cb (GtkWidget* button,
WebKitDownload* download)
{
Show a 'Delete all' button in the transferbar as needed The button shows up as a new download starts and vanishes again if no downloads are there.
2009-04-19 17:05:05 +00:00
MidoriBrowser* browser;
GList* buttons;
Add midori_browser_get_for_widget_utility function This function will look for a MidoriBrowser according to a particular widget - even if it's inside a detached panel window or any other window transient for the browser.
2009-04-23 02:10:38 +00:00
browser = midori_browser_get_for_widget (button);
Show a 'Delete all' button in the transferbar as needed The button shows up as a new download starts and vanishes again if no downloads are there.
2009-04-19 17:05:05 +00:00
Initial support for WebKitDownload At this point all downloads run automatically and appear in the statusbar. The destination folder can be chosen in the preferences. Download can be cancelled. The context menu works as well.
2009-03-19 17:28:50 +00:00
switch (webkit_download_get_status (download))
{
case WEBKIT_DOWNLOAD_STATUS_STARTED:
webkit_download_cancel (download);
Show a 'Delete all' button in the transferbar as needed The button shows up as a new download starts and vanishes again if no downloads are there.
2009-04-19 17:05:05 +00:00
g_object_set_data (G_OBJECT (gtk_widget_get_parent (button)),
"done", (void*)1);
Initial support for WebKitDownload At this point all downloads run automatically and appear in the statusbar. The destination folder can be chosen in the preferences. Download can be cancelled. The context menu works as well.
2009-03-19 17:28:50 +00:00
break;
Implement opening of downloaded files
2009-03-20 23:08:22 +00:00
case WEBKIT_DOWNLOAD_STATUS_FINISHED:
{
const gchar* uri = webkit_download_get_destination_uri (download);
Unify opening URIs externally with good fallbacks
2009-04-20 17:10:13 +00:00
if (sokoke_show_uri (gtk_widget_get_screen (button),
uri, gtk_get_current_event_time (), NULL))
Remove items from the transferbar when they are opened
2009-03-20 23:11:29 +00:00
gtk_widget_destroy (gtk_widget_get_parent (button));
Implement opening of downloaded files
2009-03-20 23:08:22 +00:00
break;
}
Provide a Clear button for cancelled downloads
2009-03-21 19:08:37 +00:00
case WEBKIT_DOWNLOAD_STATUS_CANCELLED:
gtk_widget_destroy (gtk_widget_get_parent (button));
Initial support for WebKitDownload At this point all downloads run automatically and appear in the statusbar. The destination folder can be chosen in the preferences. Download can be cancelled. The context menu works as well.
2009-03-19 17:28:50 +00:00
default:
break;
}
Show a 'Delete all' button in the transferbar as needed The button shows up as a new download starts and vanishes again if no downloads are there.
2009-04-19 17:05:05 +00:00
buttons = gtk_container_get_children (GTK_CONTAINER (browser->transferbar));
if (g_list_length (buttons) == 1)
gtk_widget_hide (browser->transferbar_clear);
g_list_free (buttons);
Initial support for WebKitDownload At this point all downloads run automatically and appear in the statusbar. The destination folder can be chosen in the preferences. Download can be cancelled. The context menu works as well.
2009-03-19 17:28:50 +00:00
}
static void
midori_browser_add_download_item (MidoriBrowser* browser,
WebKitDownload* download)
{
GtkWidget* box;
GtkWidget* icon;
GtkWidget* button;
GtkWidget* progress;
Reduce the width of individual download items
2009-03-21 19:17:23 +00:00
gint width;
Initial support for WebKitDownload At this point all downloads run automatically and appear in the statusbar. The destination folder can be chosen in the preferences. Download can be cancelled. The context menu works as well.
2009-03-19 17:28:50 +00:00
box = gtk_hbox_new (FALSE, 0);
/* icon = gtk_image_new_from_stock (STOCK_TRANSFER, GTK_ICON_SIZE_MENU);
gtk_box_pack_start (GTK_BOX (box), icon, FALSE, FALSE, 0); */
progress = gtk_progress_bar_new ();
gtk_progress_bar_set_ellipsize (GTK_PROGRESS_BAR (progress),
PANGO_ELLIPSIZE_MIDDLE);
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (progress),
webkit_download_get_suggested_filename (download));
Reduce the width of individual download items
2009-03-21 19:17:23 +00:00
sokoke_widget_get_text_size (progress, "M", &width, NULL);
gtk_widget_set_size_request (progress, width * 10, -1);
Initial support for WebKitDownload At this point all downloads run automatically and appear in the statusbar. The destination folder can be chosen in the preferences. Download can be cancelled. The context menu works as well.
2009-03-19 17:28:50 +00:00
/* Avoid a bug in WebKit */
if (webkit_download_get_status (download) != WEBKIT_DOWNLOAD_STATUS_CREATED)
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (progress),
webkit_download_get_progress (download));
gtk_box_pack_start (GTK_BOX (box), progress, FALSE, FALSE, 0);
icon = gtk_image_new_from_stock (GTK_STOCK_CANCEL, GTK_ICON_SIZE_MENU);
button = gtk_button_new ();
gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
gtk_button_set_focus_on_click (GTK_BUTTON (button), FALSE);
gtk_container_add (GTK_CONTAINER (button), icon);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
gtk_widget_show_all (box);
Reduce the width of individual download items
2009-03-21 19:17:23 +00:00
gtk_box_pack_start (GTK_BOX (browser->transferbar), box, FALSE, FALSE, 0);
Show a 'Delete all' button in the transferbar as needed The button shows up as a new download starts and vanishes again if no downloads are there.
2009-04-19 17:05:05 +00:00
gtk_widget_show (browser->transferbar_clear);
Initial support for WebKitDownload At this point all downloads run automatically and appear in the statusbar. The destination folder can be chosen in the preferences. Download can be cancelled. The context menu works as well.
2009-03-19 17:28:50 +00:00
g_signal_connect (download, "notify::progress",
G_CALLBACK (midori_browser_download_notify_progress_cb), progress);
g_signal_connect (download, "notify::status",
G_CALLBACK (midori_browser_download_notify_status_cb), button);
g_signal_connect (button, "clicked",
G_CALLBACK (midori_browser_download_button_clicked_cb), download);
}
static gboolean
midori_view_download_requested_cb (GtkWidget* view,
WebKitDownload* download,
MidoriBrowser* browser)
{
Add add-download signal to MidoriBrowser
2009-03-22 14:24:40 +00:00
g_signal_emit (browser, signals[ADD_DOWNLOAD], 0, download);
Move download dialog to the view and don't show an error page We have to handle the dialog when the MIME type is requested, otherwise we don't know the type. Plus we stop the loading now to avoid seeing an error page.
2009-03-21 14:06:57 +00:00
if (!webkit_download_get_destination_uri (download))
Show a dialog before downloading asking what to do
2009-03-20 23:40:03 +00:00
{
Move download dialog to the view and don't show an error page We have to handle the dialog when the MIME type is requested, otherwise we don't know the type. Plus we stop the loading now to avoid seeing an error page.
2009-03-21 14:06:57 +00:00
gchar* folder;
gchar* filename;
gchar* uri;
Save files which are opened immediately to the temporary folder
2009-03-31 19:19:48 +00:00
if (g_object_get_data (G_OBJECT (download), "open-download"))
folder = g_strdup (g_get_tmp_dir ());
else
folder = katze_object_get_string (browser->settings, "download-folder");
Move download dialog to the view and don't show an error page We have to handle the dialog when the MIME type is requested, otherwise we don't know the type. Plus we stop the loading now to avoid seeing an error page.
2009-03-21 14:06:57 +00:00
filename = g_build_filename (folder,
webkit_download_get_suggested_filename (download), NULL);
g_free (folder);
uri = g_filename_to_uri (filename, NULL, NULL);
g_free (filename);
webkit_download_set_destination_uri (download, uri);
g_free (uri);
Show a dialog before downloading asking what to do
2009-03-20 23:40:03 +00:00
}
Move download dialog to the view and don't show an error page We have to handle the dialog when the MIME type is requested, otherwise we don't know the type. Plus we stop the loading now to avoid seeing an error page.
2009-03-21 14:06:57 +00:00
midori_browser_add_download_item (browser, download);
return TRUE;
Initial support for WebKitDownload At this point all downloads run automatically and appear in the statusbar. The destination folder can be chosen in the preferences. Download can be cancelled. The context menu works as well.
2009-03-19 17:28:50 +00:00
}
#endif
Show a 'Delete all' button in the transferbar as needed The button shows up as a new download starts and vanishes again if no downloads are there.
2009-04-19 17:05:05 +00:00
static void
midori_browser_transferbar_clear_clicked_cb (GtkWidget* button,
MidoriBrowser* browser)
{
GList* buttons;
guint i;
GtkWidget* item;
buttons = gtk_container_get_children (GTK_CONTAINER (browser->transferbar));
i = 0;
while ((item = g_list_nth_data (buttons, i++)))
if (g_object_get_data (G_OBJECT (item), "done"))
gtk_widget_destroy (item);
g_list_free (buttons);
buttons = gtk_container_get_children (GTK_CONTAINER (browser->transferbar));
if (g_list_length (buttons) == 1)
gtk_widget_hide (browser->transferbar_clear);
g_list_free (buttons);
}
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,
Implement a primitive find-as-you-type
2009-02-22 00:45:22 +00:00
gchar* typing,
Make Find work again, and disable it for source tabs
2008-09-28 14:29:41 +00:00
MidoriBrowser* browser)
{
const gchar* text;
gboolean case_sensitive;
gboolean highlight;
Implement a primitive find-as-you-type
2009-02-22 00:45:22 +00:00
if (typing)
{
gint position = -1;
Actually search after every character in 'typing' search
2009-02-22 01:17:58 +00:00
browser->find_typing = TRUE;
Hide find options and close button in 'typing' search
2009-02-22 01:34:21 +00:00
gtk_toggle_tool_button_set_active (GTK_TOGGLE_TOOL_BUTTON (
browser->find_highlight), TRUE);
gtk_widget_hide (GTK_WIDGET (browser->find_case));
gtk_widget_hide (GTK_WIDGET (browser->find_highlight));
gtk_widget_hide (GTK_WIDGET (browser->find_close));
if (!GTK_WIDGET_VISIBLE (browser->find))
gtk_entry_set_text (GTK_ENTRY (browser->find_text), "");
Implement a primitive find-as-you-type
2009-02-22 00:45:22 +00:00
gtk_widget_show (browser->find);
gtk_window_set_focus (GTK_WINDOW (browser), browser->find_text);
gtk_editable_insert_text (GTK_EDITABLE (browser->find_text), typing, -1, &position);
gtk_editable_set_position (GTK_EDITABLE (browser->find_text), -1);
}
Do not actually search less than 3 characters in 'typing' search
2009-02-22 15:12:58 +00:00
if (GTK_WIDGET_VISIBLE (browser->find) && !typing)
Make Find work again, and disable it for source tabs
2008-09-28 14:29:41 +00:00
{
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,
Replace window-object-cleared with context-ready Introduce MidoriBrowser::load-status and also midori_view_execute_script while we are at it.
2008-11-23 04:19:43 +00:00
"signal::context-ready",
midori_view_context_ready_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::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,
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,
Support opening of new windows The preference determining where to open those windows is not currently honored, so everything goes in a new tab. Incidentally compile time checks guarding the web inspector are replaced with runtime checks here, and the same approach is used for the create-web-view signal. The features are used if available.
2008-12-03 03:16:19 +00:00
"signal::new-view",
midori_view_new_view_cb, browser,
Initial support for WebKitDownload At this point all downloads run automatically and appear in the statusbar. The destination folder can be chosen in the preferences. Download can be cancelled. The context menu works as well.
2009-03-19 17:28:50 +00:00
#if WEBKIT_CHECK_VERSION (1, 1, 3)
"signal::download-requested",
midori_view_download_requested_cb, browser,
#endif
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,
Implement Save As for arbitrary links
2008-11-09 21:07:42 +00:00
"signal::save-as",
midori_view_save_as_cb, browser,
Support opening of new windows The preference determining where to open those windows is not currently honored, so everything goes in a new tab. Incidentally compile time checks guarding the web inspector are replaced with runtime checks here, and the same approach is used for the create-web-view signal. The features are used if available.
2008-12-03 03:16:19 +00:00
"signal::leave-notify-event",
midori_browser_tab_leave_notify_event_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
NULL);
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (browser->settings &&
katze_object_get_boolean (browser->settings, "open-tabs-next-to-current"))
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
{
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
}
Add midori_browser_foreach to iterate over all present browsers
2009-04-22 19:53:14 +00:00
/**
* midori_browser_foreach:
* @browser: a #MidoriBrowser
* @callback: a #GtkCallback
* @callback_data: custom data
*
* Calls the specified callback for each view contained
* in the browser.
*
* Since: 0.1.7
**/
void
midori_browser_foreach (MidoriBrowser* browser,
GtkCallback callback,
gpointer callback_data)
{
g_return_if_fail (MIDORI_IS_BROWSER (browser));
gtk_container_foreach (GTK_CONTAINER (browser->notebook),
callback, callback_data);
}
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 refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified 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;
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);
Replace window-object-cleared with context-ready Introduce MidoriBrowser::load-status and also midori_view_execute_script while we are at it.
2008-11-23 04:19:43 +00:00
signals[CONTEXT_READY] = g_signal_new (
"context-ready",
G_TYPE_FROM_CLASS (class),
(GSignalFlags)(G_SIGNAL_RUN_LAST),
0,
0,
NULL,
g_cclosure_marshal_VOID__POINTER,
G_TYPE_NONE, 1,
G_TYPE_POINTER);
Add add-download signal to MidoriBrowser
2009-03-22 14:24:40 +00:00
/**
Add midori_browser_foreach to iterate over all present browsers
2009-04-22 19:53:14 +00:00
* MidoriBrowser::add-download:
* @browser: the object on which the signal is emitted
Add add-download signal to MidoriBrowser
2009-03-22 14:24:40 +00:00
* @download: a new download
*
* Emitted when a new download was accepted and is
* about to start, before the browser adds items
* to the transferbar.
*
* Emitting this signal manually is equal to a
* user initiating and confirming a download
*
Add midori_browser_foreach to iterate over all present browsers
2009-04-22 19:53:14 +00:00
* Note: This requires WebKitGTK+ 1.1.3.
Add add-download signal to MidoriBrowser
2009-03-22 14:24:40 +00:00
*
* Since: 0.1.5
*/
signals[ADD_DOWNLOAD] = g_signal_new (
"add-download",
G_TYPE_FROM_CLASS (class),
(GSignalFlags)(G_SIGNAL_RUN_LAST),
0,
0,
NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
G_TYPE_OBJECT);
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;
Make property strings static to save some memory
2009-01-16 04:19:43 +00:00
flags = G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified 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,
Make property strings static to save some memory
2009-01-16 04:19:43 +00:00
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
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,
Make property strings static to save some memory
2009-01-16 04:19:43 +00:00
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
Expose browser notebook and panel as properties
2008-11-18 01:02:59 +00:00
g_object_class_install_property (gobject_class,
PROP_NOTEBOOK,
g_param_spec_object (
"notebook",
"Notebook",
"The notebook containing the views",
GTK_TYPE_NOTEBOOK,
Make property strings static to save some memory
2009-01-16 04:19:43 +00:00
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
Expose browser notebook and panel as properties
2008-11-18 01:02:59 +00:00
g_object_class_install_property (gobject_class,
PROP_PANEL,
g_param_spec_object (
"panel",
"Panel",
"The side panel embedded in the browser",
MIDORI_TYPE_PANEL,
Make property strings static to save some memory
2009-01-16 04:19:43 +00:00
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
Expose browser notebook and panel as properties
2008-11-18 01:02:59 +00:00
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",
Fix browser properties along with enabling the property test
2009-02-22 12:52:04 +00:00
"",
Make property strings static to save some memory
2009-01-16 04:19:43 +00:00
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
Save the session whenever it changes, instead of on quit.
2008-07-23 18:17:13 +00:00
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,
Make property strings static to save some memory
2009-01-16 04:19:43 +00:00
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
Replace window-object-cleared with context-ready Introduce MidoriBrowser::load-status and also midori_view_execute_script while we are at it.
2008-11-23 04:19:43 +00:00
g_object_class_install_property (gobject_class,
PROP_LOAD_STATUS,
g_param_spec_enum (
"load-status",
"Load Status",
"The current load status",
MIDORI_TYPE_LOAD_STATUS,
MIDORI_LOAD_FINISHED,
Make property strings static to save some memory
2009-01-16 04:19:43 +00:00
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
Replace window-object-cleared with context-ready Introduce MidoriBrowser::load-status and also midori_view_execute_script while we are at it.
2008-11-23 04:19:43 +00:00
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
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,
Make property strings static to save some memory
2009-01-16 04:19:43 +00:00
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
First attempt at an extension interface.
2008-05-02 20:30: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
/**
* 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,
Make property strings static to save some memory
2009-01-16 04:19:43 +00:00
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified 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
* 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 property strings static to save some memory
2009-01-16 04:19:43 +00:00
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified 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,
Make property strings static to save some memory
2009-01-16 04:19:43 +00:00
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
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,
Make property strings static to save some memory
2009-01-16 04:19:43 +00:00
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
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,
Move around history loading in MidoriBrowser
2008-11-09 18:26:48 +00:00
flags));
Add 2px space between tool buttons
2009-01-12 20:52:33 +00:00
/* Add 2px space between tool buttons */
gtk_rc_parse_string (
"style \"tool-button-style\"\n {\n"
"GtkToolButton::icon-spacing = 2\n }\n"
"widget \"MidoriBrowser.*.MidoriBookmarkbar.Gtk*ToolButton\" "
"style \"tool-button-style\"\n"
"widget \"MidoriBrowser.*.MidoriFindbar.Gtk*ToolButton\" "
"style \"tool-button-style\"\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
_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;
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (!GTK_WIDGET_VISIBLE (browser))
return;
Actually handle non web view tabs, and a View Source tab
2008-07-13 19:49:57 +00:00
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)
{
Move variable declarations to the beginnings of blocks
2008-11-16 01:00:17 +00:00
gchar* folder;
folder = gtk_file_chooser_get_current_folder (GTK_FILE_CHOOSER (dialog));
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));
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
_action_save_as_activate (GtkAction* action,
MidoriBrowser* browser)
{
Implement Save As for arbitrary links
2008-11-09 21:07:42 +00:00
midori_browser_save_uri (browser, midori_browser_get_current_uri (browser));
Implement Save As functionality
2008-10-26 16:07:59 +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_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)
{
Only print if the browser is visible
2009-04-05 09:28:42 +00:00
GtkWidget* view;
if (!GTK_WIDGET_VISIBLE (browser))
return;
if ((view = midori_browser_get_current_tab (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_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
Fix clipboard menu items and do some tidying
2008-11-23 00:44:40 +00:00
if (WEBKIT_IS_WEB_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
{
Fix clipboard menu items and do some tidying
2008-11-23 00:44:40 +00:00
WebKitWebView* view = WEBKIT_WEB_VIEW (widget);
can_cut = webkit_web_view_can_cut_clipboard (view);
can_copy = webkit_web_view_can_copy_clipboard (view);
can_paste = webkit_web_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));
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (G_LIKELY (widget) && g_signal_lookup ("cut-clipboard", G_OBJECT_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
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));
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (G_LIKELY (widget) && g_signal_lookup ("copy-clipboard", G_OBJECT_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
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));
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (G_LIKELY (widget) && g_signal_lookup ("paste-clipboard", G_OBJECT_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
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);
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
else if (g_signal_lookup ("select-all", G_OBJECT_TYPE (widget)))
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
{
Open or focus Inline Find on activation, close it with Escape
2009-01-24 14:34:31 +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
{
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), "");
Hide find options and close button in 'typing' search
2009-02-22 01:34:21 +00:00
gtk_widget_show (GTK_WIDGET (browser->find_case));
gtk_widget_show (GTK_WIDGET (browser->find_highlight));
gtk_widget_show (GTK_WIDGET (browser->find_close));
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_widget_show (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
}
Open or focus Inline Find on activation, close it with Escape
2009-01-24 14:34:31 +00:00
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;
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (!(view = midori_browser_get_current_tab (browser)))
return;
Make Find work again, and disable it for source tabs
2008-09-28 14:29:41 +00:00
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
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
}
Cancel 'typing' search when the entry loses its focus
2009-02-22 14:36:41 +00:00
static void
_midori_browser_find_done (MidoriBrowser* browser)
{
GtkWidget* view = midori_browser_get_current_tab (browser);
midori_view_unmark_text_matches (MIDORI_VIEW (view));
gtk_widget_hide (browser->find);
browser->find_typing = FALSE;
gtk_window_set_focus (GTK_WINDOW (browser),
gtk_bin_get_child (GTK_BIN (view)) ?
gtk_bin_get_child (GTK_BIN (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_find_next_activate (GtkAction* action,
MidoriBrowser* browser)
{
_midori_browser_find (browser, TRUE);
}
Actually search after every character in 'typing' search
2009-02-22 01:17:58 +00:00
static void
Cancel 'typing' search when the entry loses its focus
2009-02-22 14:36:41 +00:00
midori_browser_find_text_changed_cb (GtkWidget* entry,
MidoriBrowser* browser)
Actually search after every character in 'typing' search
2009-02-22 01:17:58 +00:00
{
if (browser->find_typing)
Do not actually search less than 3 characters in 'typing' search
2009-02-22 15:12:58 +00:00
{
Fix highlighted matches in 'typing' mode
2009-02-22 15:17:32 +00:00
GtkWidget* view = midori_browser_get_current_tab (browser);
Do not actually search less than 3 characters in 'typing' search
2009-02-22 15:12:58 +00:00
const gchar* text = gtk_entry_get_text (GTK_ENTRY (entry));
Fix highlighted matches in 'typing' mode
2009-02-22 15:17:32 +00:00
midori_view_unmark_text_matches (MIDORI_VIEW (view));
Do not actually search less than 3 characters in 'typing' search
2009-02-22 15:12:58 +00:00
if (g_utf8_strlen (text, -1) > 2)
_midori_browser_find (browser, TRUE);
}
Actually search after every character in 'typing' search
2009-02-22 01:17:58 +00:00
}
Cancel 'typing' search when the entry loses its focus
2009-02-22 14:36:41 +00:00
static gboolean
midori_browser_find_text_focus_out_event_cb (GtkWidget* entry,
GdkEventFocus* event,
MidoriBrowser* browser)
{
if (browser->find_typing)
_midori_browser_find_done (browser);
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
_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
}
Open or focus Inline Find on activation, close it with Escape
2009-01-24 14:34:31 +00:00
static gboolean
Unmark the matches when hiding the findbar again
2009-01-24 21:15:37 +00:00
midori_browser_find_key_press_event_cb (GtkWidget* toolbar,
GdkEventKey* event,
MidoriBrowser* browser)
Open or focus Inline Find on activation, close it with Escape
2009-01-24 14:34:31 +00:00
{
if (event->keyval == GDK_Escape)
{
Cancel 'typing' search when the entry loses its focus
2009-02-22 14:36:41 +00:00
_midori_browser_find_done (browser);
Open or focus Inline Find on activation, close it with Escape
2009-01-24 14:34:31 +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
midori_browser_find_button_close_clicked_cb (GtkWidget* widget,
MidoriBrowser* browser)
{
Cancel 'typing' search when the entry loses its focus
2009-02-22 14:36:41 +00:00
_midori_browser_find_done (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_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
}
}
Items can be added via the new toolbar menu now
2009-01-18 02:58:05 +00:00
static gboolean
midori_browser_toolbar_item_button_press_event_cb (GtkWidget* toolitem,
GdkEventButton* event,
MidoriBrowser* browser);
Integrate Midori with Maemo, use a Hildon window and adjust the interface To make Midori play nicely with Maemo the menubar is now integrated, we have a service file, a specific toolbar layout, no statusbar and icon styles. The changes are applied if hildon is available, and can of course be manually enabled or disabled.
2009-01-27 01:57:40 +00:00
#if !HAVE_HILDON
Save toolbar changes via the menu and remove the Toolbar Items entry
2009-01-18 03:38:46 +00:00
static void
_midori_browser_save_toolbar_items (MidoriBrowser* browser)
{
GString* toolbar_items;
GList* children;
gchar* items;
toolbar_items = g_string_new (NULL);
children = gtk_container_get_children (GTK_CONTAINER (browser->navigationbar));
for (; children != NULL; children = g_list_next (children))
{
GtkAction* action = gtk_widget_get_action (GTK_WIDGET (children->data));
Support separators in navigationbar and bookmarkbar
2009-01-28 23:56:07 +00:00
/* If a widget has no action that is actually a bug, so warn about it */
g_warn_if_fail (action != NULL);
if (action && strcmp (gtk_action_get_name (action), "Fullscreen"))
Save toolbar changes via the menu and remove the Toolbar Items entry
2009-01-18 03:38:46 +00:00
{
g_string_append (toolbar_items, gtk_action_get_name (action));
g_string_append (toolbar_items, ",");
}
}
items = g_string_free (toolbar_items, FALSE);
g_object_set (browser->settings, "toolbar-items", items, NULL);
g_free (items);
}
Implement a not yet functional menu for adding and removing tool items
2009-01-17 22:56:23 +00:00
static void
midori_browser_toolbar_add_item_cb (GtkWidget* menuitem,
MidoriBrowser* browser)
{
Items can be added via the new toolbar menu now
2009-01-18 02:58:05 +00:00
GtkWidget* widget = g_object_get_data (G_OBJECT (menuitem), "widget");
Save toolbar changes via the menu and remove the Toolbar Items entry
2009-01-18 03:38:46 +00:00
GtkAction* widget_action = g_object_get_data (G_OBJECT (menuitem), "action");
GtkWidget* toolitem = gtk_action_create_tool_item (widget_action);
Items can be added via the new toolbar menu now
2009-01-18 02:58:05 +00:00
if (widget)
{
gint i = gtk_toolbar_get_item_index (GTK_TOOLBAR (browser->navigationbar),
GTK_TOOL_ITEM (widget));
gtk_toolbar_insert (GTK_TOOLBAR (browser->navigationbar),
GTK_TOOL_ITEM (toolitem), i ? i : 0);
}
else
gtk_toolbar_insert (GTK_TOOLBAR (browser->navigationbar),
GTK_TOOL_ITEM (toolitem), 0);
Support separators in navigationbar and bookmarkbar
2009-01-28 23:56:07 +00:00
if (gtk_bin_get_child (GTK_BIN (toolitem)))
g_signal_connect (gtk_bin_get_child (GTK_BIN (toolitem)),
"button-press-event",
G_CALLBACK (midori_browser_toolbar_item_button_press_event_cb),
browser);
else
{
gtk_tool_item_set_use_drag_window (GTK_TOOL_ITEM (toolitem), TRUE);
g_signal_connect (toolitem,
"button-press-event",
G_CALLBACK (midori_browser_toolbar_item_button_press_event_cb),
browser);
}
Save toolbar changes via the menu and remove the Toolbar Items entry
2009-01-18 03:38:46 +00:00
_midori_browser_save_toolbar_items (browser);
Implement a not yet functional menu for adding and removing tool items
2009-01-17 22:56:23 +00:00
}
static void
midori_browser_toolbar_remove_item_cb (GtkWidget* menuitem,
MidoriBrowser* browser)
{
GtkWidget* widget = g_object_get_data (G_OBJECT (menuitem), "widget");
gtk_container_remove (GTK_CONTAINER (browser->navigationbar), widget);
Save toolbar changes via the menu and remove the Toolbar Items entry
2009-01-18 03:38:46 +00:00
_midori_browser_save_toolbar_items (browser);
Implement a not yet functional menu for adding and removing tool items
2009-01-17 22:56:23 +00:00
}
Integrate Midori with Maemo, use a Hildon window and adjust the interface To make Midori play nicely with Maemo the menubar is now integrated, we have a service file, a specific toolbar layout, no statusbar and icon styles. The changes are applied if hildon is available, and can of course be manually enabled or disabled.
2009-01-27 01:57:40 +00:00
#endif
Implement a not yet functional menu for adding and removing tool items
2009-01-17 22:56:23 +00:00
Create navigationbar from a string of actions
2008-10-12 16:14:57 +00:00
static gboolean
Implement a not yet functional menu for adding and removing tool items
2009-01-17 22:56:23 +00:00
midori_browser_toolbar_popup_context_menu_cb (GtkWidget* widget,
Create navigationbar from a string of actions
2008-10-12 16:14:57 +00:00
gint x,
gint y,
gint button,
MidoriBrowser* browser)
{
GtkWidget* menu;
GtkWidget* menuitem;
Implement "-a" or "--app" to run web apps At the moment this takes an URI and opens a standalone window with a non-editable toolbar and a statusbar.
2009-04-13 02:38:01 +00:00
/* Unsupported trick used for web app mode */
if (g_object_get_data (G_OBJECT (browser), "locked"))
return FALSE;
Create navigationbar from a string of actions
2008-10-12 16:14:57 +00:00
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);
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);
menuitem = sokoke_action_create_popup_menu_item (
_action_by_name (browser, "Bookmarkbar"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
Allow showing/ hiding the transferbar
2009-03-20 22:55:38 +00:00
menuitem = sokoke_action_create_popup_menu_item (
Show all of Toolsbars in the toolbar context menu
2008-10-21 22:28:49 +00:00
_action_by_name (browser, "Transferbar"));
Allow showing/ hiding the transferbar
2009-03-20 22:55:38 +00:00
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
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
Integrate Midori with Maemo, use a Hildon window and adjust the interface To make Midori play nicely with Maemo the menubar is now integrated, we have a service file, a specific toolbar layout, no statusbar and icon styles. The changes are applied if hildon is available, and can of course be manually enabled or disabled.
2009-01-27 01:57:40 +00:00
#if !HAVE_HILDON
Implement a not yet functional menu for adding and removing tool items
2009-01-17 22:56:23 +00:00
if (widget == browser->navigationbar ||
gtk_widget_is_ancestor (widget, browser->navigationbar))
{
GtkAction* widget_action = gtk_widget_get_action (widget);
Save toolbar changes via the menu and remove the Toolbar Items entry
2009-01-18 03:38:46 +00:00
const gchar* actions[] = { "TabNew", "Open", "SaveAs", "Print", "Find",
Implement Last Visited Pages menu and toolbar item We use the name of history folders now to store dates instead of the token. This makes it possible to show history in an action.
2009-03-07 13:00:14 +00:00
"Preferences", "Window", "Bookmarks", "RecentlyVisited",
"ReloadStop", "ZoomIn", "Separator", "ZoomOut", "Back", "Forward",
"Homepage", "Panel", "Trash", "Search" };
Implement a not yet functional menu for adding and removing tool items
2009-01-17 22:56:23 +00:00
GtkWidget* submenu;
gsize i;
menuitem = gtk_separator_menu_item_new ();
Integrate Midori with Maemo, use a Hildon window and adjust the interface To make Midori play nicely with Maemo the menubar is now integrated, we have a service file, a specific toolbar layout, no statusbar and icon styles. The changes are applied if hildon is available, and can of course be manually enabled or disabled.
2009-01-27 01:57:40 +00:00
gtk_widget_show (menuitem);
Implement a not yet functional menu for adding and removing tool items
2009-01-17 22:56:23 +00:00
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
submenu = gtk_menu_new ();
menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_ADD, NULL);
Integrate Midori with Maemo, use a Hildon window and adjust the interface To make Midori play nicely with Maemo the menubar is now integrated, we have a service file, a specific toolbar layout, no statusbar and icon styles. The changes are applied if hildon is available, and can of course be manually enabled or disabled.
2009-01-27 01:57:40 +00:00
gtk_widget_show (menuitem);
Implement a not yet functional menu for adding and removing tool items
2009-01-17 22:56:23 +00:00
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_REMOVE, NULL);
Integrate Midori with Maemo, use a Hildon window and adjust the interface To make Midori play nicely with Maemo the menubar is now integrated, we have a service file, a specific toolbar layout, no statusbar and icon styles. The changes are applied if hildon is available, and can of course be manually enabled or disabled.
2009-01-27 01:57:40 +00:00
gtk_widget_show (menuitem);
Implement a not yet functional menu for adding and removing tool items
2009-01-17 22:56:23 +00:00
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
if (widget_action &&
strcmp (gtk_action_get_name (widget_action), "Location"))
{
g_object_set_data (G_OBJECT (menuitem), "widget", widget);
g_signal_connect (menuitem, "activate",
G_CALLBACK (midori_browser_toolbar_remove_item_cb), browser);
}
else
gtk_widget_set_sensitive (menuitem, FALSE);
for (i = 0; i < G_N_ELEMENTS (actions); i++)
{
GtkAction* action = _action_by_name (browser, actions[i]);
gchar* stock_id = katze_object_get_string (action, "stock-id");
gchar* label = katze_object_get_string (action, "label");
if (stock_id && label)
{
GtkWidget* icon;
menuitem = gtk_image_menu_item_new_with_mnemonic (label);
icon = gtk_image_new_from_stock (stock_id, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), icon);
}
else if (stock_id)
menuitem = gtk_image_menu_item_new_from_stock (stock_id, NULL);
else
menuitem = gtk_image_menu_item_new_with_mnemonic (label);
gtk_menu_shell_append (GTK_MENU_SHELL (submenu), menuitem);
Items can be added via the new toolbar menu now
2009-01-18 02:58:05 +00:00
if (widget_action)
g_object_set_data (G_OBJECT (menuitem), "widget", widget);
g_object_set_data (G_OBJECT (menuitem), "action", action);
Implement a not yet functional menu for adding and removing tool items
2009-01-17 22:56:23 +00:00
g_signal_connect (menuitem, "activate",
G_CALLBACK (midori_browser_toolbar_add_item_cb), browser);
}
Integrate Midori with Maemo, use a Hildon window and adjust the interface To make Midori play nicely with Maemo the menubar is now integrated, we have a service file, a specific toolbar layout, no statusbar and icon styles. The changes are applied if hildon is available, and can of course be manually enabled or disabled.
2009-01-27 01:57:40 +00:00
sokoke_container_show_children (GTK_CONTAINER (submenu));
Implement a not yet functional menu for adding and removing tool items
2009-01-17 22:56:23 +00:00
}
Integrate Midori with Maemo, use a Hildon window and adjust the interface To make Midori play nicely with Maemo the menubar is now integrated, we have a service file, a specific toolbar layout, no statusbar and icon styles. The changes are applied if hildon is available, and can of course be manually enabled or disabled.
2009-01-27 01:57:40 +00:00
#endif
Implement a not yet functional menu for adding and removing tool items
2009-01-17 22:56:23 +00:00
katze_widget_popup (widget, GTK_MENU (menu), NULL,
Create navigationbar from a string of actions
2008-10-12 16:14:57 +00:00
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)
{
Only append separator to bookmarks if the array isn't empty
2009-03-28 19:57:42 +00:00
GtkWidget* menuitem;
if (katze_array_get_nth_item (browser->bookmarks, 0))
{
menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
}
Add an 'Add new folder' menu item to Bookmarks menu
2009-04-10 20:28:36 +00:00
menuitem = gtk_action_create_menu_item (
_action_by_name (browser, "BookmarkFolderAdd"));
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)
{
static GtkWidget* dialog = NULL;
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (!browser->settings || !GTK_WIDGET_VISIBLE (browser))
return;
if (!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
{
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);
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
g_signal_connect (dialog, "destroy",
G_CALLBACK (gtk_widget_destroyed), &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_widget_show (dialog);
}
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
else
gtk_window_present (GTK_WINDOW (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
}
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);
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (browser->settings)
g_object_set (browser->settings, "show-menubar", active, NULL);
Integrate Midori with Maemo, use a Hildon window and adjust the interface To make Midori play nicely with Maemo the menubar is now integrated, we have a service file, a specific toolbar layout, no statusbar and icon styles. The changes are applied if hildon is available, and can of course be manually enabled or disabled.
2009-01-27 01:57:40 +00:00
#if !HAVE_HILDON
Allow hiding the menubar and showing it again
2008-10-12 20:09:49 +00:00
sokoke_widget_set_visible (browser->menubar, active);
Integrate Midori with Maemo, use a Hildon window and adjust the interface To make Midori play nicely with Maemo the menubar is now integrated, we have a service file, a specific toolbar layout, no statusbar and icon styles. The changes are applied if hildon is available, and can of course be manually enabled or disabled.
2009-01-27 01:57:40 +00:00
#endif
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
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);
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (browser->settings)
g_object_set (browser->settings, "show-navigationbar", active, NULL);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
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);
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (browser->settings)
g_object_set (browser->settings, "show-bookmarkbar", active, NULL);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
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
}
Allow showing/ hiding the transferbar
2009-03-20 22:55:38 +00:00
static void
_action_transferbar_activate (GtkToggleAction* action,
MidoriBrowser* browser)
{
gboolean active = gtk_toggle_action_get_active (action);
if (browser->settings)
g_object_set (browser->settings, "show-transferbar", active, NULL);
sokoke_widget_set_visible (browser->transferbar, 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);
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (browser->settings)
g_object_set (browser->settings, "show-statusbar", active, NULL);
Integrate Midori with Maemo, use a Hildon window and adjust the interface To make Midori play nicely with Maemo the menubar is now integrated, we have a service file, a specific toolbar layout, no statusbar and icon styles. The changes are applied if hildon is available, and can of course be manually enabled or disabled.
2009-01-27 01:57:40 +00:00
#if !HAVE_HILDON
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
sokoke_widget_set_visible (browser->statusbar, active);
Integrate Midori with Maemo, use a Hildon window and adjust the interface To make Midori play nicely with Maemo the menubar is now integrated, we have a service file, a specific toolbar layout, no statusbar and icon styles. The changes are applied if hildon is available, and can of course be manually enabled or disabled.
2009-01-27 01:57:40 +00:00
#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
}
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;
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (!(view = midori_browser_get_current_tab (browser)))
return;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified 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
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
Implement Encoding menu
2009-02-27 22:09:36 +00:00
static void
_action_view_encoding_activate (GtkAction* action,
MidoriBrowser* browser)
{
GtkWidget* view = midori_browser_get_current_tab (browser);
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (view && midori_browser_view_can_set_encoding (MIDORI_VIEW (view)))
Implement Encoding menu
2009-02-27 22:09:36 +00:00
{
const gchar* name;
GtkWidget* web_view;
name = gtk_action_get_name (action);
web_view = gtk_bin_get_child (GTK_BIN (view));
if (!strcmp (name, "EncodingAutomatic"))
g_object_set (web_view, "custom-encoding", NULL, NULL);
else
{
const gchar* encoding;
if (!strcmp (name, "EncodingChinese"))
encoding = "BIG5";
else if (!strcmp (name, "EncodingJapanese"))
encoding = "SHIFT_JIS";
else if (!strcmp (name, "EncodingRussian"))
encoding = "KOI8-R";
else if (!strcmp (name, "EncodingUnicode"))
encoding = "UTF-8";
else if (!strcmp (name, "EncodingWestern"))
encoding = "ISO-8859-1";
else
g_assert_not_reached ();
g_object_set (web_view, "custom-encoding", encoding, NULL);
}
}
}
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;
Arrange file saving for error handling to fix warnings
2008-11-15 23:10:39 +00:00
size_t ret;
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
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")))
{
Arrange file saving for error handling to fix warnings
2008-11-15 23:10:39 +00:00
ret = fwrite (request->data, 1, request->length, fp);
Implement View source with external Text editor
2008-10-20 19:32:25 +00:00
fclose (fp);
Arrange file saving for error handling to fix warnings
2008-11-15 23:10:39 +00:00
if ((ret - request->length) != 0)
{
Print file saving errors to the standard output
2008-11-18 22:18:53 +00:00
/* FIXME: Show an error in the graphical interface */
g_warning ("Error writing to file %s "
"in midori_browser_source_transfer_cb()", filename);
Arrange file saving for error handling to fix warnings
2008-11-15 23:10:39 +00:00
}
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);
Implement source view with GIO and drop internal source view We use GIO to choose a text editor unless a text editor was specified in the Preferences. We drop our internal source view now which used to serve as a fallback.
2009-03-17 20:35:05 +00:00
if (text_editor && *text_editor)
Implement transfer completion notification via libnotify
2009-04-26 22:22:16 +00:00
sokoke_spawn_program (text_editor, unique_filename, TRUE);
Implement source view with GIO and drop internal source view We use GIO to choose a text editor unless a text editor was specified in the Preferences. We drop our internal source view now which used to serve as a fallback.
2009-03-17 20:35:05 +00:00
else
Unify opening URIs externally with good fallbacks
2009-04-20 17:10:13 +00:00
sokoke_show_uri (NULL, unique_filename,
gtk_get_current_event_time (), NULL);
Implement source view with GIO and drop internal source view We use GIO to choose a text editor unless a text editor was specified in the Preferences. We drop our internal source view now which used to serve as a fallback.
2009-03-17 20:35:05 +00:00
Implement View source with external Text editor
2008-10-20 19:32:25 +00:00
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 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;
Implement source view with GIO and drop internal source view We use GIO to choose a text editor unless a text editor was specified in the Preferences. We drop our internal source view now which used to serve as a fallback.
2009-03-17 20:35:05 +00:00
gchar* text_editor;
const gchar* uri;
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
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;
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (browser->settings)
g_object_get (browser->settings, "text-editor", &text_editor, NULL);
else
text_editor = NULL;
Implement source view with GIO and drop internal source view We use GIO to choose a text editor unless a text editor was specified in the Preferences. We drop our internal source view now which used to serve as a fallback.
2009-03-17 20:35:05 +00:00
uri = midori_view_get_display_uri (MIDORI_VIEW (view));
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
Implement source view with GIO and drop internal source view We use GIO to choose a text editor unless a text editor was specified in the Preferences. We drop our internal source view now which used to serve as a fallback.
2009-03-17 20:35:05 +00:00
if (!g_strcmp0 (text_editor, ""))
Implement View source with external Text editor
2008-10-20 19:32:25 +00:00
{
Implement source view with GIO and drop internal source view We use GIO to choose a text editor unless a text editor was specified in the Preferences. We drop our internal source view now which used to serve as a fallback.
2009-03-17 20:35:05 +00:00
GFile* file = g_file_new_for_uri (uri);
gchar* content_type;
GAppInfo* app_info;
GList* files;
gpointer context;
#if GLIB_CHECK_VERSION (2, 18, 0)
content_type = g_content_type_from_mime_type ("text/plain");
#else
content_type = g_strdup ("text/plain");
#endif
app_info = g_app_info_get_default_for_type (content_type,
!g_str_has_prefix (uri, "file://"));
g_free (content_type);
files = g_list_prepend (NULL, file);
#if GTK_CHECK_VERSION (2, 14, 0)
context = gdk_app_launch_context_new ();
gdk_app_launch_context_set_screen (context, gtk_widget_get_screen (view));
gdk_app_launch_context_set_timestamp (context, gtk_get_current_event_time ());
#else
context = g_app_launch_context_new ();
#endif
if (g_app_info_launch (app_info, files, context, NULL))
{
g_object_unref (app_info);
g_list_free (files);
g_object_unref (file);
g_free (text_editor);
return;
}
Implement View source with external Text editor
2008-10-20 19:32:25 +00:00
}
Implement source view with GIO and drop internal source view We use GIO to choose a text editor unless a text editor was specified in the Preferences. We drop our internal source view now which used to serve as a fallback.
2009-03-17 20:35:05 +00:00
katze_net_load_uri (browser->net, uri, NULL,
(KatzeNetTransferCb)midori_browser_source_transfer_cb, browser);
Implement View source with external Text editor
2008-10-20 19:32:25 +00:00
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)
{
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (!GTK_WIDGET (browser)->window)
return;
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified files, such as bookmarks or the session. Regressions are expected and not everything is done yet.
2008-03-10 21:26:09 +00:00
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;
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (!browser->settings)
return;
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)
{
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (!browser->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,
Implement 'full' debug-level and fix according warnings
2009-01-09 21:54:40 +00:00
gint idx,
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)
Introduce MidoriLocationEntry and GtkIconEntry
2008-07-17 19:02:14 +00:00
{
const gchar* uri;
Implement 'full' debug-level and fix according warnings
2009-01-09 21:54:40 +00:00
if (idx > -1)
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
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
{
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (!browser->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* 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
new_uri = sokoke_magic_uri (uri, browser->search_engines);
Percent encode search terms, so '+' actually ends up as a '+'
2009-04-18 22:47:02 +00:00
if (!new_uri)
Unify how search URI and keywords are combined This handles the presence of a %1 and encoding the keywords.
2009-04-19 22:39:36 +00:00
new_uri = sokoke_search_uri (browser->location_entry_search, uri);
Allow marking a search engine as Default engine The default engine is used when search terms are typed in the address entry without tokens and for the 'Search the Web' item in the selection context menu. The 'Location entry search' is removed from the preferences. The setting 'location-entry-search' remains functional however.
2009-04-18 20:41:37 +00:00
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
_action_location_secondary_icon_released (GtkAction* action,
GtkWidget* widget,
MidoriBrowser* browser)
{
Display the news feed icon again The code for looking up news feeds on websites was disabled and is now back in simplified form. 'liferea-add-feed' is hardcoded for the moment.
2009-04-13 20:40:57 +00:00
GtkWidget* 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
Display the news feed icon again The code for looking up news feeds on websites was disabled and is now back in simplified form. 'liferea-add-feed' is hardcoded for the moment.
2009-04-13 20:40:57 +00:00
if ((view = midori_browser_get_current_tab (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
{
Display the news feed icon again The code for looking up news feeds on websites was disabled and is now back in simplified form. 'liferea-add-feed' is hardcoded for the moment.
2009-04-13 20:40:57 +00:00
const gchar* uri = midori_view_get_display_uri (MIDORI_VIEW (view));
Add News Aggregator preference The program set here is called if the user clicks on the news feed icon, with the address of the current website as argument. For example liferea-add-feed works like that.
2009-04-14 17:44:48 +00:00
if (browser->news_aggregator && *browser->news_aggregator)
Implement transfer completion notification via libnotify
2009-04-26 22:22:16 +00:00
sokoke_spawn_program (browser->news_aggregator, uri, TRUE);
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
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified 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* 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)
url = katze_item_get_uri (item);
else /* The location entry search is our fallback */
Allow marking a search engine as Default engine The default engine is used when search terms are typed in the address entry without tokens and for the 'Search the Web' item in the selection context menu. The 'Location entry search' is removed from the preferences. The setting 'location-entry-search' remains functional however.
2009-04-18 20:41:37 +00:00
url = browser->location_entry_search;
Unify how search URI and keywords are combined This handles the presence of a %1 and encoding the keywords.
2009-04-19 22:39:36 +00:00
search = sokoke_search_uri (url, keywords);
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
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);
}
static void
_action_search_notify_current_item (GtkAction* action,
GParamSpec* pspec,
MidoriBrowser* browser)
{
MidoriSearchAction* search_action;
KatzeItem* item;
Implement 'full' debug-level and fix according warnings
2009-01-09 21:54:40 +00:00
guint idx;
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
search_action = MIDORI_SEARCH_ACTION (action);
item = midori_search_action_get_current_item (search_action);
if (item)
Implement 'full' debug-level and fix according warnings
2009-01-09 21:54:40 +00:00
idx = katze_array_get_item_index (browser->search_engines, 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
else
Implement 'full' debug-level and fix according warnings
2009-01-09 21:54:40 +00:00
idx = 0;
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
Implement 'full' debug-level and fix according warnings
2009-01-09 21:54:40 +00:00
g_object_set (browser->settings, "last-web-search", idx, NULL);
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
}
Allow marking a search engine as Default engine The default engine is used when search terms are typed in the address entry without tokens and for the 'Search the Web' item in the selection context menu. The 'Location entry search' is removed from the preferences. The setting 'location-entry-search' remains functional however.
2009-04-18 20:41:37 +00:00
static void
_action_search_notify_default_item (GtkAction* action,
GParamSpec* pspec,
MidoriBrowser* browser)
{
MidoriSearchAction* search_action;
KatzeItem* item;
search_action = MIDORI_SEARCH_ACTION (action);
item = midori_search_action_get_default_item (search_action);
if (item)
g_object_set (browser->settings, "location-entry-search",
katze_item_get_uri (item), NULL);
}
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_focus_out (GtkAction* action,
MidoriBrowser* browser)
{
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (GTK_WIDGET_VISIBLE (browser->statusbar) && !browser->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
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);
Implement 'Open all in Tabs' for bookmark folders and history
2009-02-27 20:52:51 +00:00
else if (!KATZE_IS_ARRAY (item) && strcmp (stock_id, GTK_STOCK_DELETE))
Refactor bookmark context menu, apply it on the bookmarkbar
2008-10-30 01:19:52 +00:00
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");
Implement 'Open all in Tabs' for bookmark folders and history
2009-02-27 20:52:51 +00:00
if (KATZE_IS_ARRAY (item))
{
KatzeItem* child;
guint i = 0;
Refactor bookmark context menu, apply it on the bookmarkbar
2008-10-30 01:19:52 +00:00
Implement 'Open all in Tabs' for bookmark folders and history
2009-02-27 20:52:51 +00:00
while ((child = katze_array_get_nth_item (KATZE_ARRAY (item), i)))
{
if ((uri = katze_item_get_uri (child)) && *uri)
{
n = midori_browser_add_item (browser, child);
_midori_browser_set_current_page_smartly (browser, n);
}
i++;
}
}
else
Refactor bookmark context menu, apply it on the bookmarkbar
2008-10-30 01:19:52 +00:00
{
Implement 'Open all in Tabs' for bookmark folders and history
2009-02-27 20:52:51 +00:00
if ((uri = katze_item_get_uri (item)) && *uri)
{
n = midori_browser_add_item (browser, item);
_midori_browser_set_current_page_smartly (browser, n);
}
Refactor bookmark context menu, apply it on the bookmarkbar
2008-10-30 01:19:52 +00:00
}
}
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_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);
Add a "New folder" button to the bookmark panel
2009-02-22 02:11:40 +00:00
if (KATZE_IS_ARRAY (item))
midori_browser_edit_bookmark_dialog_new (browser, item, FALSE, TRUE);
else if (uri && *uri)
midori_browser_edit_bookmark_dialog_new (browser, item, FALSE, FALSE);
Refactor bookmark context menu, apply it on the bookmarkbar
2008-10-30 01:19:52 +00:00
}
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));
Support separators in navigationbar and bookmarkbar
2009-01-28 23:56:07 +00:00
parent = katze_item_get_parent (item);
katze_array_remove_item (KATZE_ARRAY (parent), item);
Refactor bookmark context menu, apply it on the bookmarkbar
2008-10-30 01:19:52 +00:00
}
static void
midori_browser_bookmark_popup (GtkWidget* widget,
GdkEventButton* event,
KatzeItem* item,
MidoriBrowser* browser)
{
GtkWidget* menu;
GtkWidget* menuitem;
menu = gtk_menu_new ();
Implement 'Open all in Tabs' for bookmark folders and history
2009-02-27 20:52:51 +00:00
if (KATZE_IS_ARRAY (item))
midori_browser_bookmark_popup_item (menu,
STOCK_TAB_NEW, _("Open all in _Tabs"),
item, midori_browser_bookmark_open_in_tab_activate_cb, browser);
else
{
midori_browser_bookmark_popup_item (menu, GTK_STOCK_OPEN, NULL,
item, midori_browser_bookmark_open_activate_cb, browser);
midori_browser_bookmark_popup_item (menu,
STOCK_TAB_NEW, _("Open in New _Tab"),
item, midori_browser_bookmark_open_in_tab_activate_cb, browser);
midori_browser_bookmark_popup_item (menu,
STOCK_WINDOW_NEW, _("Open in New _Window"),
item, midori_browser_bookmark_open_in_window_activate_cb, browser);
}
Refactor bookmark context menu, apply it on the bookmarkbar
2008-10-30 01:19:52 +00:00
menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
Refactor History panel into a separate class This brings back the problem of address and title of items showing up in the history unfortunately. Now the history items are appended rather than prepended, we probably want to fix that in the future.
2009-02-21 22:59:02 +00:00
midori_browser_bookmark_popup_item (menu, GTK_STOCK_EDIT, NULL,
item, midori_browser_bookmark_edit_activate_cb, browser);
midori_browser_bookmark_popup_item (menu, GTK_STOCK_DELETE, NULL,
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 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");
Refactor History panel into a separate class This brings back the problem of address and title of items showing up in the history unfortunately. Now the history items are appended rather than prepended, we probably want to fix that in the future.
2009-02-21 22:59:02 +00:00
midori_browser_bookmark_popup (toolitem, NULL, item, 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)
{
Add a "New folder" button to the bookmark panel
2009-02-22 02:11:40 +00:00
midori_browser_edit_bookmark_dialog_new (browser, NULL, 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
}
Add an 'Add new folder' menu item to Bookmarks menu
2009-04-10 20:28:36 +00:00
static void
_action_bookmark_folder_add_activate (GtkAction* action,
MidoriBrowser* browser)
{
midori_browser_edit_bookmark_dialog_new (browser, NULL, TRUE, 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
_action_manage_search_engines_activate (GtkAction* action,
MidoriBrowser* browser)
{
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
static GtkWidget* dialog = NULL;
Complete move of webSearch, third step of refactoring web search
2008-06-15 02:02:56 +00:00
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (!GTK_WIDGET_VISIBLE (browser))
return;
if (!dialog)
{
dialog = midori_search_action_get_dialog (
MIDORI_SEARCH_ACTION (_action_by_name (browser, "Search")));
g_signal_connect (dialog, "destroy",
G_CALLBACK (gtk_widget_destroyed), &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_widget_show (dialog);
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
}
else
gtk_window_present (GTK_WINDOW (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
}
Implement Clear Private Data dialogue
2009-04-11 03:14:53 +00:00
static void
midori_browser_clear_private_data_response_cb (GtkWidget* dialog,
gint response_id,
MidoriBrowser* browser)
{
if (response_id == GTK_RESPONSE_ACCEPT)
{
GtkToggleButton* button;
button = g_object_get_data (G_OBJECT (dialog), "history");
if (gtk_toggle_button_get_active (button))
katze_array_clear (browser->history);
button = g_object_get_data (G_OBJECT (dialog), "cookies");
if (gtk_toggle_button_get_active (button))
{
SoupSession* session = katze_net_get_session (browser->net);
SoupSessionFeature* jar = soup_session_get_feature (session,
SOUP_TYPE_COOKIE_JAR);
GSList* cookies = soup_cookie_jar_all_cookies (SOUP_COOKIE_JAR (jar));
SoupCookie* cookie;
gsize i = 0;
while ((cookie = g_slist_nth_data (cookies, i++)))
{
soup_cookie_jar_delete_cookie (SOUP_COOKIE_JAR (jar), cookie);
soup_cookie_free (cookie);
}
g_slist_free (cookies);
}
button = g_object_get_data (G_OBJECT (dialog), "flash-cookies");
if (gtk_toggle_button_get_active (button))
{
gchar* cache = g_build_filename (g_get_home_dir (), ".macromedia",
"Flash_Player", NULL);
sokoke_remove_path (cache, TRUE);
g_free (cache);
}
button = g_object_get_data (G_OBJECT (dialog), "website-icons");
if (gtk_toggle_button_get_active (button))
{
gchar* cache = g_build_filename (g_get_user_cache_dir (),
PACKAGE_NAME, "icons", NULL);
sokoke_remove_path (cache, TRUE);
g_free (cache);
}
}
if (response_id != GTK_RESPONSE_DELETE_EVENT)
gtk_widget_destroy (dialog);
}
static void
_action_clear_private_data_activate (GtkAction* action,
MidoriBrowser* browser)
{
static GtkWidget* dialog = NULL;
if (!GTK_WIDGET_VISIBLE (browser))
return;
if (!dialog)
{
GdkScreen* screen;
GtkIconTheme* icon_theme;
GtkSizeGroup* sizegroup;
GtkWidget* hbox;
GtkWidget* vbox;
GtkWidget* icon;
GtkWidget* label;
GtkWidget* button;
dialog = gtk_dialog_new_with_buttons (_("Clear Private Data"),
GTK_WINDOW (browser), GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
Use mnemonic in "Clear private data" button
2009-04-13 21:35:31 +00:00
_("_Clear private data"), GTK_RESPONSE_ACCEPT, NULL);
Implement Clear Private Data dialogue
2009-04-11 03:14:53 +00:00
gtk_window_set_skip_taskbar_hint (GTK_WINDOW (dialog), FALSE);
screen = gtk_widget_get_screen (GTK_WIDGET (browser));
if (screen)
{
icon_theme = gtk_icon_theme_get_for_screen (screen);
gtk_window_set_icon_name (GTK_WINDOW (dialog), GTK_STOCK_CLEAR);
}
sizegroup = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
hbox = gtk_hbox_new (FALSE, 4);
icon = gtk_image_new_from_stock (GTK_STOCK_CLEAR, GTK_ICON_SIZE_DIALOG);
gtk_size_group_add_widget (sizegroup, icon);
gtk_box_pack_start (GTK_BOX (hbox), icon, FALSE, FALSE, 0);
label = gtk_label_new (_("Clear the following data:"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, FALSE, FALSE, 8);
hbox = gtk_hbox_new (FALSE, 4);
icon = gtk_image_new ();
gtk_size_group_add_widget (sizegroup, icon);
gtk_box_pack_start (GTK_BOX (hbox), icon, FALSE, FALSE, 0);
vbox = gtk_vbox_new (TRUE, 4);
button = gtk_check_button_new_with_mnemonic (_("History"));
g_object_set_data (G_OBJECT (dialog), "history", button);
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
button = gtk_check_button_new_with_mnemonic (_("Cookies"));
g_object_set_data (G_OBJECT (dialog), "cookies", button);
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
button = gtk_check_button_new_with_mnemonic (_("'Flash' Cookies"));
g_object_set_data (G_OBJECT (dialog), "flash-cookies", button);
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
button = gtk_check_button_new_with_mnemonic (_("Website icons"));
g_object_set_data (G_OBJECT (dialog), "website-icons", button);
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, FALSE, FALSE, 8);
gtk_widget_show_all (GTK_DIALOG (dialog)->vbox);
g_signal_connect (dialog, "response",
G_CALLBACK (midori_browser_clear_private_data_response_cb), browser);
g_signal_connect (dialog, "destroy",
G_CALLBACK (gtk_widget_destroyed), &dialog);
gtk_widget_show (dialog);
}
else
gtk_window_present (GTK_WINDOW (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_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,
Implement 'full' debug-level and fix according warnings
2009-01-09 21:54:40 +00:00
const gchar* uri,
Integrate documentation, bug tracker and website
2008-10-03 20:23:00 +00:00
gpointer user_data)
{
MidoriBrowser* browser;
gint n;
browser = MIDORI_BROWSER (user_data);
Implement 'full' debug-level and fix according warnings
2009-01-09 21:54:40 +00:00
n = midori_browser_add_uri (browser, uri);
Integrate documentation, bug tracker and website
2008-10-03 20:23:00 +00:00
midori_browser_set_current_page (browser, n);
}
static void
_action_about_activate_email (GtkAboutDialog* about,
Implement 'full' debug-level and fix according warnings
2009-01-09 21:54:40 +00:00
const gchar* uri,
Integrate documentation, bug tracker and website
2008-10-03 20:23:00 +00:00
gpointer user_data)
{
Unify opening URIs externally with good fallbacks
2009-04-20 17:10:13 +00:00
sokoke_show_uri (NULL, uri, GDK_CURRENT_TIME, NULL);
Integrate documentation, bug tracker and website
2008-10-03 20:23:00 +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_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."),
Update copyright year in --version and about dialog
2009-03-01 20:00:06 +00:00
"copyright", "Copyright © 2007-2009 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
Load documentation as a proper file:// URI
2009-02-21 23:04:28 +00:00
uri = "file://" DOCDIR "/midori/user/midori.html";
if (!g_file_test (DOCDIR "/midori/user/midori.html", G_FILE_TEST_EXISTS))
Integrate documentation, bug tracker and website
2008-10-03 20:23:00 +00:00
#endif
Load documentation as a proper file:// URI
2009-02-21 23:04:28 +00:00
uri = "error:nodocs " DOCDIR "/midori/user/midori.html";
Integrate documentation, bug tracker and website
2008-10-03 20:23:00 +00:00
}
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);
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (browser->settings)
g_object_set (browser->settings, "show-panel", active, NULL);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
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
}
Save size and panel position with a delay of 5 seconds
2009-01-25 23:54:12 +00:00
static gboolean
midori_browser_panel_timeout (GtkWidget* hpaned)
{
gboolean position = gtk_paned_get_position (GTK_PANED (hpaned));
Add midori_browser_get_for_widget_utility function This function will look for a MidoriBrowser according to a particular widget - even if it's inside a detached panel window or any other window transient for the browser.
2009-04-23 02:10:38 +00:00
MidoriBrowser* browser = midori_browser_get_for_widget (hpaned);
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (browser->settings)
g_object_set (browser->settings, "last-panel-position", position, NULL);
Save size and panel position with a delay of 5 seconds
2009-01-25 23:54:12 +00:00
browser->panel_timeout = 0;
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
Save size and panel position with a delay of 5 seconds
2009-01-25 23:54:12 +00:00
midori_panel_notify_position_cb (GObject* hpaned,
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
MidoriBrowser* browser)
{
Save size and panel position with a delay of 5 seconds
2009-01-25 23:54:12 +00:00
if (!browser->panel_timeout)
browser->panel_timeout = g_timeout_add_full (G_PRIORITY_LOW, 5000,
(GSourceFunc)midori_browser_panel_timeout, hpaned, 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
}
Add a button to change the alignment to the panel
2009-02-22 18:23:45 +00:00
static void
midori_panel_notify_right_aligned_cb (MidoriPanel* panel,
GParamSpec* pspec,
MidoriBrowser* browser)
{
gboolean right_aligned = katze_object_get_boolean (panel, "right-aligned");
GtkWidget* hpaned = gtk_widget_get_parent (browser->panel);
GtkWidget* vpaned = gtk_widget_get_parent (browser->notebook);
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (browser->settings)
g_object_set (browser->settings, "right-align-sidepanel",
right_aligned, NULL);
Add a button to change the alignment to the panel
2009-02-22 18:23:45 +00:00
g_object_ref (browser->panel);
g_object_ref (vpaned);
gtk_container_remove (GTK_CONTAINER (hpaned), browser->panel);
gtk_container_remove (GTK_CONTAINER (hpaned), vpaned);
if (right_aligned)
{
gtk_paned_pack1 (GTK_PANED (hpaned), vpaned, FALSE, FALSE);
gtk_paned_pack2 (GTK_PANED (hpaned), browser->panel, FALSE, FALSE);
}
else
{
gtk_paned_pack1 (GTK_PANED (hpaned), browser->panel, FALSE, FALSE);
gtk_paned_pack2 (GTK_PANED (hpaned), vpaned, FALSE, FALSE);
}
g_object_unref (browser->panel);
g_object_unref (vpaned);
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified 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;
Check if we really have a view, it might be invisible
2009-04-01 21:53:45 +00:00
if (!(view = midori_browser_get_current_tab (browser)))
return;
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");
midori_location_action_set_uri (MIDORI_LOCATION_ACTION (action), uri);
Update location icon even if it's not in the history
2008-11-10 23:51:28 +00:00
midori_location_action_set_icon (MIDORI_LOCATION_ACTION (action),
midori_view_get_icon (MIDORI_VIEW (view)));
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));
Fix some compiler warnings
2008-11-12 01:15:52 +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
}
Save tab reordering to the session
2009-03-24 22:54:37 +00:00
static void
midori_browser_notebook_page_reordered_cb (GtkNotebook* notebook,
MidoriView* view,
guint page_num,
MidoriBrowser* browser)
{
KatzeItem* item = midori_view_get_proxy_item (view);
katze_array_move_item (browser->proxy_array, item, page_num);
g_object_notify (G_OBJECT (browser), "uri");
}
Open new tabs by double or middle clicking on the tabbar
2009-01-13 19:50:17 +00:00
static gboolean
gtk_notebook_button_press_event_cb (GtkNotebook* notebook,
GdkEventButton* event,
MidoriBrowser* browser)
{
/* Open a new tab on double click or middle mouse click */
if (event->window == notebook->event_window
&& ((event->type == GDK_2BUTTON_PRESS && event->button == 1)
|| (event->type == GDK_BUTTON_PRESS && event->button == 2)))
{
gtk_action_activate (_action_by_name (browser, "TabNew"));
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
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;
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (!browser->trash)
return;
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)
{
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (browser->trash)
{
katze_array_clear (browser->trash);
_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 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) },
Implement Encoding menu
2009-02-27 22:09:36 +00:00
{ "Encoding", NULL, N_("_Encoding") },
{ "EncodingAutomatic", NULL,
N_("_Automatic"), "",
NULL, G_CALLBACK (_action_view_encoding_activate) },
{ "EncodingChinese", NULL,
N_("Chinese (BIG5)"), "",
NULL, G_CALLBACK (_action_view_encoding_activate) },
{ "EncodingJapanese", NULL,
N_("Japanese (SHIFT_JIS)"), "",
NULL, G_CALLBACK (_action_view_encoding_activate) },
{ "EncodingRussian", NULL,
N_("Russian (KOI8-R)"), "",
NULL, G_CALLBACK (_action_view_encoding_activate) },
{ "EncodingUnicode", NULL,
N_("Unicode (UTF-8)"), "",
NULL, G_CALLBACK (_action_view_encoding_activate) },
{ "EncodingWestern", NULL,
N_("Western (ISO-8859-1)"), "",
NULL, G_CALLBACK (_action_view_encoding_activate) },
{ "EncodingCustom", NULL,
N_("Custom..."), "",
NULL, G_CALLBACK (_action_view_encoding_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
{ "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) },
Add an 'Add new folder' menu item to Bookmarks menu
2009-04-10 20:28:36 +00:00
{ "BookmarkFolderAdd", GTK_STOCK_DIRECTORY,
N_("Add a new folder"), "",
N_("Add a new bookmark folder"), G_CALLBACK (_action_bookmark_folder_add_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) },
Implement Clear Private Data dialogue
2009-04-11 03:14:53 +00:00
{ "ClearPrivateData", GTK_STOCK_CLEAR,
N_("_Clear Private Data"), "<Ctrl><Shift>Delete",
N_("Clear private data..."),
G_CALLBACK (_action_clear_private_data_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
{ "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,
Correct capitalizations in Help menu and Inline Find
2009-01-16 04:50:01 +00:00
N_("_Frequent Questions"), NULL,
Integrate documentation, bug tracker and website
2008-10-03 20:23:00 +00:00
N_("Show the Frequently Asked Questions"), G_CALLBACK (_action_help_link_activate) },
{ "HelpBugs", NULL,
Correct capitalizations in Help menu and Inline Find
2009-01-16 04:50:01 +00:00
N_("_Report a Bug"), NULL,
Integrate documentation, bug tracker and website
2008-10-03 20:23:00 +00:00
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 },
Allow showing/ hiding the transferbar
2009-03-20 22:55:38 +00:00
{ "Transferbar", 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_("_Transferbar"), "",
Initial support for WebKitDownload At this point all downloads run automatically and appear in the statusbar. The destination folder can be chosen in the preferences. Download can be cancelled. The context menu works as well.
2009-03-19 17:28:50 +00:00
N_("Show transferbar"), G_CALLBACK (_action_transferbar_activate),
Allow showing/ hiding the transferbar
2009-03-20 22:55:38 +00:00
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
{ "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)
{
Remember the last window state, ie. whether Midori was maximized or minimized
2009-01-20 22:27:19 +00:00
MidoriWindowState window_state = MIDORI_WINDOW_NORMAL;
if (event->new_window_state & GDK_WINDOW_STATE_ICONIFIED)
window_state = MIDORI_WINDOW_MINIMIZED;
else if (event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED)
window_state = MIDORI_WINDOW_MAXIMIZED;
else if (event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN)
window_state = MIDORI_WINDOW_FULLSCREEN;
g_object_set (browser->settings, "last-window-state", window_state, 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
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
{
Respect menubar visibility when restoring from fullscreen
2008-12-06 03:53:30 +00:00
if (katze_object_get_boolean (browser->settings, "show-menubar"))
gtk_widget_show (browser->menubar);
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
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);
}
}
}
Save size and panel position with a delay of 5 seconds
2009-01-25 23:54:12 +00:00
static gboolean
midori_browser_alloc_timeout (MidoriBrowser* browser)
{
Save the normal window size, not the maximized size
2009-02-22 13:42:27 +00:00
GtkWidget* widget = GTK_WIDGET (browser);
GdkWindowState state = gdk_window_get_state (widget->window);
if (!(state &
(GDK_WINDOW_STATE_MAXIMIZED | GDK_WINDOW_STATE_FULLSCREEN)))
g_object_set (browser->settings,
"last-window-width", widget->allocation.width,
"last-window-height", widget->allocation.height, NULL);
Save size and panel position with a delay of 5 seconds
2009-01-25 23:54:12 +00:00
browser->alloc_timeout = 0;
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
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);
Save size and panel position with a delay of 5 seconds
2009-01-25 23:54:12 +00:00
if (!(state &
(GDK_WINDOW_STATE_MAXIMIZED | GDK_WINDOW_STATE_FULLSCREEN))
&& !browser->alloc_timeout)
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified 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 size and panel position with a delay of 5 seconds
2009-01-25 23:54:12 +00:00
browser->alloc_timeout = g_timeout_add_full (G_PRIORITY_LOW, 5000,
(GSourceFunc)midori_browser_alloc_timeout, 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
}
}
}
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)
{
Remove any left timeouts if the browser is destroyed
2009-02-24 21:59:18 +00:00
if (G_UNLIKELY (browser->panel_timeout))
g_source_remove (browser->panel_timeout);
if (G_UNLIKELY (browser->alloc_timeout))
g_source_remove (browser->alloc_timeout);
Remove panel pages implicitly as viewables are destroyed For this to work smoothly, from now on the browser destroys the panel eary, as it does with the tabs, and the panel in turn destroys its pages early.
2009-01-20 21:17:04 +00:00
/* Destroy panel first, so panels don't need special care */
gtk_widget_destroy (browser->panel);
/* Destroy tabs second, 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'/>"
Allow showing/ hiding the transferbar
2009-03-20 22:55:38 +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/>"
Implement Encoding menu
2009-02-27 22:09:36 +00:00
"<menu action='Encoding'>"
"<menuitem action='EncodingAutomatic'/>"
"<menuitem action='EncodingChinese'/>"
"<menuitem action='EncodingJapanese'/>"
"<menuitem action='EncodingRussian'/>"
"<menuitem action='EncodingUnicode'/>"
"<menuitem action='EncodingWestern'/>"
"<menuitem action='EncodingCustom'/>"
"</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
"<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'/>"
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'/>"
Implement Last Visited Pages menu and toolbar item We use the name of history folders now to store dates instead of the token. This makes it possible to show history in an action.
2009-03-07 13:00:14 +00:00
"<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'/>"
Implement Clear Private Data dialogue
2009-04-11 03:14:53 +00:00
"<menuitem action='ClearPrivateData'/>"
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'/>"
Add BookmarkAdd to dummy menu items This fixes a warning about an accelerator and in some cases even a crash when opening the bookmarks menu.
2009-03-28 20:00:11 +00:00
"<menuitem action='BookmarkAdd'/>"
Add an 'Add new folder' menu item to Bookmarks menu
2009-04-10 20:28:36 +00:00
"<menuitem action='BookmarkFolderAdd'/>"
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='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>"
"</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), "");
}
Move around history loading in MidoriBrowser
2008-11-09 18:26:48 +00:00
static void
midori_browser_new_history_item (MidoriBrowser* browser,
KatzeItem* item)
{
KatzeArray* parent;
gint i;
gboolean found;
time_t now;
Store the 'day' of history items to reduce even more calls to localtime By storing the timestamp of the day in the database we can significantly reduce the calls to localtime, which should result in a noticible speedup. We are changing the database format. For the convenience of the user the code automatically converts from the old format.
2009-01-23 21:38:39 +00:00
gint64 day;
gint64 pday;
gint64 newage;
Store history dates in 'token' to avoid locatime() and revamp deleting Loading history items used to involve frequent calls to localtime() and g_memdup(). We avoid this by storing the date strings in parent items now, which can even be used to display items in the treeview. Deleting of treeview items was also reworked so it should work from menu items and the panel.
2009-01-11 18:30:43 +00:00
gchar token[50];
Move around history loading in MidoriBrowser
2008-11-09 18:26:48 +00:00
now = time (NULL);
katze_item_set_added (item, now);
Store the 'day' of history items to reduce even more calls to localtime By storing the timestamp of the day in the database we can significantly reduce the calls to localtime, which should result in a noticible speedup. We are changing the database format. For the convenience of the user the code automatically converts from the old format.
2009-01-23 21:38:39 +00:00
day = sokoke_time_t_to_julian (&now);
Move around history loading in MidoriBrowser
2008-11-09 18:26:48 +00:00
found = FALSE;
i = 0;
Refactor History panel into a separate class This brings back the problem of address and title of items showing up in the history unfortunately. Now the history items are appended rather than prepended, we probably want to fix that in the future.
2009-02-21 22:59:02 +00:00
while ((parent = katze_array_get_nth_item (browser->history, i++)))
Move around history loading in MidoriBrowser
2008-11-09 18:26:48 +00:00
{
Store the 'day' of history items to reduce even more calls to localtime By storing the timestamp of the day in the database we can significantly reduce the calls to localtime, which should result in a noticible speedup. We are changing the database format. For the convenience of the user the code automatically converts from the old format.
2009-01-23 21:38:39 +00:00
pday = katze_item_get_added (KATZE_ITEM (parent));
newage = day - pday;
Move around history loading in MidoriBrowser
2008-11-09 18:26:48 +00:00
if (newage == 0)
{
found = TRUE;
katze_array_add_item (parent, item);
}
}
if (!found)
{
Use the date format of the user locale to display history dates
2009-02-28 22:03:23 +00:00
strftime (token, sizeof (token), "%x", localtime (&now));
Move around history loading in MidoriBrowser
2008-11-09 18:26:48 +00:00
parent = katze_array_new (KATZE_TYPE_ARRAY);
Store the 'day' of history items to reduce even more calls to localtime By storing the timestamp of the day in the database we can significantly reduce the calls to localtime, which should result in a noticible speedup. We are changing the database format. For the convenience of the user the code automatically converts from the old format.
2009-01-23 21:38:39 +00:00
katze_item_set_added (KATZE_ITEM (parent), day);
Implement Last Visited Pages menu and toolbar item We use the name of history folders now to store dates instead of the token. This makes it possible to show history in an action.
2009-03-07 13:00:14 +00:00
katze_item_set_name (KATZE_ITEM (parent), token);
Move around history loading in MidoriBrowser
2008-11-09 18:26:48 +00:00
katze_array_add_item (browser->history, parent);
katze_array_add_item (parent, item);
}
}
Refactor History panel into a separate class This brings back the problem of address and title of items showing up in the history unfortunately. Now the history items are appended rather than prepended, we probably want to fix that in the future.
2009-02-21 22:59:02 +00:00
static void
midori_browser_history_remove_item_cb (KatzeArray* folder,
KatzeItem* item,
MidoriBrowser* browser)
{
Implement Last Visited Pages menu and toolbar item We use the name of history folders now to store dates instead of the token. This makes it possible to show history in an action.
2009-03-07 13:00:14 +00:00
GtkAction* action;
action = _action_by_name (browser, "Location");
Refactor History panel into a separate class This brings back the problem of address and title of items showing up in the history unfortunately. Now the history items are appended rather than prepended, we probably want to fix that in the future.
2009-02-21 22:59:02 +00:00
midori_location_action_delete_item_from_uri (
Implement Last Visited Pages menu and toolbar item We use the name of history folders now to store dates instead of the token. This makes it possible to show history in an action.
2009-03-07 13:00:14 +00:00
MIDORI_LOCATION_ACTION (action), katze_item_get_uri (item));
Refactor History panel into a separate class This brings back the problem of address and title of items showing up in the history unfortunately. Now the history items are appended rather than prepended, we probably want to fix that in the future.
2009-02-21 22:59:02 +00:00
g_signal_handlers_disconnect_by_func (folder,
midori_browser_history_remove_item_cb,
browser);
Implement Last Visited Pages menu and toolbar item We use the name of history folders now to store dates instead of the token. This makes it possible to show history in an action.
2009-03-07 13:00:14 +00:00
action = _action_by_name (browser, "RecentlyVisited");
if ((KatzeArray*)item == katze_array_action_get_array (KATZE_ARRAY_ACTION (action)))
g_object_set (action, "array", NULL, NULL);
Refactor History panel into a separate class This brings back the problem of address and title of items showing up in the history unfortunately. Now the history items are appended rather than prepended, we probably want to fix that in the future.
2009-02-21 22:59:02 +00:00
}
Move around history loading in MidoriBrowser
2008-11-09 18:26:48 +00:00
static void
_location_action_insert_history_item (MidoriLocationAction* action,
MidoriBrowser* browser,
KatzeItem* item)
{
KatzeItem* child;
Don't connect to search buttons twice, and fix a pixbuf leak
2008-12-18 20:15:05 +00:00
guint i;
Move around history loading in MidoriBrowser
2008-11-09 18:26:48 +00:00
const gchar* uri;
GdkPixbuf* pixbuf = NULL;
if (KATZE_IS_ARRAY (item))
{
Don't connect to search buttons twice, and fix a pixbuf leak
2008-12-18 20:15:05 +00:00
for (i = katze_array_get_length (KATZE_ARRAY (item)); i > 0; i--)
Move around history loading in MidoriBrowser
2008-11-09 18:26:48 +00:00
{
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);
Do not load icons other than in tabs
2008-11-20 00:41:58 +00:00
midori_location_action_add_item (action, uri,
pixbuf, katze_item_get_name (item));
Don't connect to search buttons twice, and fix a pixbuf leak
2008-12-18 20:15:05 +00:00
g_object_unref (pixbuf);
Refactor History panel into a separate class This brings back the problem of address and title of items showing up in the history unfortunately. Now the history items are appended rather than prepended, we probably want to fix that in the future.
2009-02-21 22:59:02 +00:00
g_signal_connect (katze_item_get_parent (item), "remove-item",
G_CALLBACK (midori_browser_history_remove_item_cb), browser);
Move around history loading in MidoriBrowser
2008-11-09 18:26:48 +00:00
}
}
static void
Revamp clearing of the history
2008-12-21 18:21:04 +00:00
midori_browser_history_clear_cb (KatzeArray* history,
MidoriBrowser* browser)
{
Refactor History panel into a separate class This brings back the problem of address and title of items showing up in the history unfortunately. Now the history items are appended rather than prepended, we probably want to fix that in the future.
2009-02-21 22:59:02 +00:00
GtkAction* location_action = _action_by_name (browser, "Location");
Revamp clearing of the history
2008-12-21 18:21:04 +00:00
midori_location_action_clear (MIDORI_LOCATION_ACTION (location_action));
Implement Last Visited Pages menu and toolbar item We use the name of history folders now to store dates instead of the token. This makes it possible to show history in an action.
2009-03-07 13:00:14 +00:00
g_object_set (_action_by_name (browser, "RecentlyVisited"),
"array", NULL, NULL);
Revamp clearing of the history
2008-12-21 18:21:04 +00:00
}
static void
midori_browser_set_history (MidoriBrowser* browser,
KatzeArray* history)
Move around history loading in MidoriBrowser
2008-11-09 18:26:48 +00:00
{
Implement Last Visited Pages menu and toolbar item We use the name of history folders now to store dates instead of the token. This makes it possible to show history in an action.
2009-03-07 13:00:14 +00:00
KatzeItem* recently_visited;
Move around history loading in MidoriBrowser
2008-11-09 18:26:48 +00:00
GtkAction* action;
Store the 'day' of history items to reduce even more calls to localtime By storing the timestamp of the day in the database we can significantly reduce the calls to localtime, which should result in a noticible speedup. We are changing the database format. For the convenience of the user the code automatically converts from the old format.
2009-01-23 21:38:39 +00:00
time_t now;
gint64 day;
Move around history loading in MidoriBrowser
2008-11-09 18:26:48 +00:00
Revamp clearing of the history
2008-12-21 18:21:04 +00:00
if (browser->history == history)
return;
if (browser->history)
g_signal_handlers_disconnect_by_func (browser->history,
midori_browser_history_clear_cb,
browser);
if (history)
g_object_ref (history);
katze_object_assign (browser->history, history);
Implement Last Visited Pages menu and toolbar item We use the name of history folders now to store dates instead of the token. This makes it possible to show history in an action.
2009-03-07 13:00:14 +00:00
midori_browser_history_clear_cb (history, browser);
Move around history loading in MidoriBrowser
2008-11-09 18:26:48 +00:00
Implement Last Visited Pages menu and toolbar item We use the name of history folders now to store dates instead of the token. This makes it possible to show history in an action.
2009-03-07 13:00:14 +00:00
if (history && ((recently_visited = katze_array_get_nth_item (history,
katze_array_get_length (KATZE_ARRAY (history)) - 1))))
g_object_set (_action_by_name (browser, "RecentlyVisited"),
"array", recently_visited, NULL);
else
g_object_set (_action_by_name (browser, "RecentlyVisited"),
"array", NULL, NULL);
Move around history loading in MidoriBrowser
2008-11-09 18:26:48 +00:00
Implement Last Visited Pages menu and toolbar item We use the name of history folders now to store dates instead of the token. This makes it possible to show history in an action.
2009-03-07 13:00:14 +00:00
if (!history)
Move around history loading in MidoriBrowser
2008-11-09 18:26:48 +00:00
return;
Clean up handling of bookmarks like the history before
2008-12-21 19:44:31 +00:00
g_signal_connect (browser->history, "clear",
G_CALLBACK (midori_browser_history_clear_cb), browser);
Store the 'day' of history items to reduce even more calls to localtime By storing the timestamp of the day in the database we can significantly reduce the calls to localtime, which should result in a noticible speedup. We are changing the database format. For the convenience of the user the code automatically converts from the old format.
2009-01-23 21:38:39 +00:00
now = time (NULL);
day = sokoke_time_t_to_julian (&now);
Move around history loading in MidoriBrowser
2008-11-09 18:26:48 +00:00
action = _action_by_name (browser, "Location");
Optimize location action, so Midori starts up twice as fast
2008-12-12 20:06:33 +00:00
midori_location_action_freeze (MIDORI_LOCATION_ACTION (action));
Move around history loading in MidoriBrowser
2008-11-09 18:26:48 +00:00
_location_action_insert_history_item (MIDORI_LOCATION_ACTION (action),
Optimize location action, so Midori starts up twice as fast
2008-12-12 20:06:33 +00:00
browser, KATZE_ITEM (browser->history));
midori_location_action_thaw (MIDORI_LOCATION_ACTION (action));
Move around history loading in MidoriBrowser
2008-11-09 18:26:48 +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_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;
Integrate Midori with Maemo, use a Hildon window and adjust the interface To make Midori play nicely with Maemo the menubar is now integrated, we have a service file, a specific toolbar layout, no statusbar and icon styles. The changes are applied if hildon is available, and can of course be manually enabled or disabled.
2009-01-27 01:57:40 +00:00
#if HAVE_HILDON
GtkWidget* menu;
GList* children;
#endif
Initial support for the Web Inspector
2008-11-01 18:15:58 +00:00
GtkSettings* gtk_settings;
GtkWidget* hbox;
GtkWidget* hpaned;
GtkWidget* vpaned;
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;
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;
Show a 'Delete all' button in the transferbar as needed The button shows up as a new download starts and vanishes again if no downloads are there.
2009-04-19 17:05:05 +00:00
GtkWidget* icon;
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;
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);
}
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);
Support separators in navigationbar and bookmarkbar
2009-01-28 23:56:07 +00:00
action = g_object_new (KATZE_TYPE_SEPARATOR_ACTION,
"name", "Separator",
"label", _("_Separator"),
NULL);
gtk_action_group_add_action (browser->action_group, action);
g_object_unref (action);
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"),
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,
Allow marking a search engine as Default engine The default engine is used when search terms are typed in the address entry without tokens and for the 'Search the Web' item in the selection context menu. The 'Location entry search' is removed from the preferences. The setting 'location-entry-search' remains functional however.
2009-04-18 20:41:37 +00:00
"signal::notify::default-item",
_action_search_notify_default_item, browser,
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
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);
Fix clipboard menu items and do some tidying
2008-11-23 00:44:40 +00:00
gtk_action_group_add_action_with_accel (browser->action_group, 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
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);
Fix clipboard menu items and do some tidying
2008-11-23 00:44:40 +00:00
gtk_action_group_add_action_with_accel (browser->action_group, 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
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);
Fix clipboard menu items and do some tidying
2008-11-23 00:44:40 +00:00
gtk_action_group_add_action_with_accel (browser->action_group, 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
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);
Fix clipboard menu items and do some tidying
2008-11-23 00:44:40 +00:00
gtk_action_group_add_action_with_accel (browser->action_group, 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
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");
Integrate Midori with Maemo, use a Hildon window and adjust the interface To make Midori play nicely with Maemo the menubar is now integrated, we have a service file, a specific toolbar layout, no statusbar and icon styles. The changes are applied if hildon is available, and can of course be manually enabled or disabled.
2009-01-27 01:57:40 +00:00
#if HAVE_HILDON
menu = gtk_menu_new ();
children = gtk_container_get_children (GTK_CONTAINER (browser->menubar));
while (children)
{
menuitem = GTK_WIDGET (children->data);
gtk_widget_reparent (menuitem, menu);
children = g_list_next (children);
}
browser->menubar = menu;
hildon_window_set_menu (HILDON_WINDOW (browser), GTK_MENU (browser->menubar));
hildon_program_add_window (hildon_program_get_instance (),
HILDON_WINDOW (browser));
#else
gtk_box_pack_start (GTK_BOX (vbox), browser->menubar, FALSE, FALSE, 0);
gtk_widget_hide (browser->menubar);
g_signal_connect (browser->menubar, "button-press-event",
G_CALLBACK (midori_browser_toolbar_item_button_press_event_cb), browser);
#endif
Initial support for the Web Inspector
2008-11-01 18:15:58 +00:00
menuitem = gtk_menu_item_new ();
Integrate Midori with Maemo, use a Hildon window and adjust the interface To make Midori play nicely with Maemo the menubar is now integrated, we have a service file, a specific toolbar layout, no statusbar and icon styles. The changes are applied if hildon is available, and can of course be manually enabled or disabled.
2009-01-27 01:57:40 +00:00
#if !HAVE_HILDON
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified 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);
Integrate Midori with Maemo, use a Hildon window and adjust the interface To make Midori play nicely with Maemo the menubar is now integrated, we have a service file, a specific toolbar layout, no statusbar and icon styles. The changes are applied if hildon is available, and can of course be manually enabled or disabled.
2009-01-27 01:57:40 +00:00
#endif
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);
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
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified 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);
Integrate Midori with Maemo, use a Hildon window and adjust the interface To make Midori play nicely with Maemo the menubar is now integrated, we have a service file, a specific toolbar layout, no statusbar and icon styles. The changes are applied if hildon is available, and can of course be manually enabled or disabled.
2009-01-27 01:57:40 +00:00
#if HAVE_HILDON
g_object_set (_action_by_name (browser, "Menubar"), "visible", FALSE, NULL);
g_object_set (_action_by_name (browser, "Statusbar"), "visible", FALSE, NULL);
#endif
Allow showing/ hiding the transferbar
2009-03-20 22:55:38 +00:00
#if !WEBKIT_CHECK_VERSION (1, 1, 3)
_action_set_sensitive (browser, "Transferbar", FALSE);
#endif
Implement Encoding menu
2009-02-27 22:09:36 +00:00
_action_set_sensitive (browser, "EncodingCustom", 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, "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");
Fix clipboard menu items and do some tidying
2008-11-23 00:44:40 +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);
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified 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);
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);
Integrate Midori with Maemo, use a Hildon window and adjust the interface To make Midori play nicely with Maemo the menubar is now integrated, we have a service file, a specific toolbar layout, no statusbar and icon styles. The changes are applied if hildon is available, and can of course be manually enabled or disabled.
2009-01-27 01:57:40 +00:00
#if HAVE_HILDON
hildon_window_add_toolbar (HILDON_WINDOW (browser),
GTK_TOOLBAR (browser->navigationbar));
#else
gtk_box_pack_start (GTK_BOX (vbox), browser->navigationbar, FALSE, FALSE, 0);
#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
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 ();
Add 2px space between tool buttons
2009-01-12 20:52:33 +00:00
gtk_widget_set_name (browser->bookmarkbar, "MidoriBookmarkbar");
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
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);
Integrate Midori with Maemo, use a Hildon window and adjust the interface To make Midori play nicely with Maemo the menubar is now integrated, we have a service file, a specific toolbar layout, no statusbar and icon styles. The changes are applied if hildon is available, and can of course be manually enabled or disabled.
2009-01-27 01:57:40 +00:00
#if HAVE_HILDON
hildon_window_add_toolbar (HILDON_WINDOW (browser),
GTK_TOOLBAR (browser->bookmarkbar));
#else
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_box_pack_start (GTK_BOX (vbox), browser->bookmarkbar, FALSE, FALSE, 0);
Integrate Midori with Maemo, use a Hildon window and adjust the interface To make Midori play nicely with Maemo the menubar is now integrated, we have a service file, a specific toolbar layout, no statusbar and icon styles. The changes are applied if hildon is available, and can of course be manually enabled or disabled.
2009-01-27 01:57:40 +00:00
#endif
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,
Add a button to change the alignment to the panel
2009-02-22 18:23:45 +00:00
"menu", browser->menu_tools,
NULL);
g_signal_connect (browser->panel, "notify::right-aligned",
G_CALLBACK (midori_panel_notify_right_aligned_cb), browser);
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
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 ();
Don't touch the ythickness of the notebook This allows the active tab to visually move above other tabs. The drawback is that it makes all tabs somewhat larger.
2009-04-12 19:57:20 +00:00
rcstyle->xthickness = 0;
Remove inner border between scrollbars and window border
2008-07-23 12:42:27 +00:00
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);
Save tab reordering to the session
2009-03-24 22:54:37 +00:00
g_signal_connect (browser->notebook, "page-reordered",
G_CALLBACK (midori_browser_notebook_page_reordered_cb),
browser);
Open new tabs by double or middle clicking on the tabbar
2009-01-13 19:50:17 +00:00
g_signal_connect (browser->notebook, "button-press-event",
G_CALLBACK (gtk_notebook_button_press_event_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 ();
Add 2px space between tool buttons
2009-01-12 20:52:33 +00:00
gtk_widget_set_name (browser->find, "MidoriFindbar");
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
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);
Open or focus Inline Find on activation, close it with Escape
2009-01-24 14:34:31 +00:00
g_signal_connect (browser->find, "key-press-event",
Unmark the matches when hiding the findbar again
2009-01-24 21:15:37 +00:00
G_CALLBACK (midori_browser_find_key_press_event_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
toolitem = gtk_tool_item_new ();
gtk_container_set_border_width (GTK_CONTAINER (toolitem), 6);
gtk_container_add (GTK_CONTAINER (toolitem),
Introduce descriptive comments meant to help translators intltool automatically embeds comments in the po template if they are directly before a translatable string. From now on we will try to avoid leaving accidental comments and instead put descriptive comments for translators before strings, starting with 'i18n'.
2008-11-08 02:05:30 +00:00
/* i18n: A panel at the bottom, to search text in pages */
Correct capitalizations in Help menu and Inline Find
2009-01-16 04:50:01 +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);
Use progress and icon GtkEntry features with GTK+ 2.16
2009-04-11 05:05:28 +00:00
g_signal_connect (browser->find_text, "icon-release",
Introduce MidoriLocationEntry and GtkIconEntry
2008-07-17 19:02:14 +00:00
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);
Actually search after every character in 'typing' search
2009-02-22 01:17:58 +00:00
g_signal_connect (browser->find_text, "changed",
Cancel 'typing' search when the entry loses its focus
2009-02-22 14:36:41 +00:00
G_CALLBACK (midori_browser_find_text_changed_cb), browser);
g_signal_connect (browser->find_text, "focus-out-event",
G_CALLBACK (midori_browser_find_text_focus_out_event_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
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"));
Correct capitalizations in Help menu and Inline Find
2009-01-16 04:50:01 +00:00
gtk_tool_button_set_label (GTK_TOOL_BUTTON (toolitem), _("Previous"));
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified 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);
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"));
Correct capitalizations in Help menu and Inline Find
2009-01-16 04:50:01 +00:00
gtk_tool_button_set_label (GTK_TOOL_BUTTON (toolitem), _("Next"));
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified 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);
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);
Hide find options and close button in 'typing' search
2009-02-22 01:34:21 +00:00
browser->find_close = gtk_tool_button_new_from_stock (GTK_STOCK_CLOSE);
gtk_tool_button_set_label (GTK_TOOL_BUTTON (browser->find_close),
_("Close Findbar"));
g_signal_connect (browser->find_close, "clicked",
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified 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_browser_find_button_close_clicked_cb), browser);
Implement 'full' debug-level and fix according warnings
2009-01-09 21:54:40 +00:00
#if HAVE_OSX
Hide find options and close button in 'typing' search
2009-02-22 01:34:21 +00:00
gtk_toolbar_insert (GTK_TOOLBAR (browser->find), browser->find_close, 0);
Improve OSX adjustments in various places
2008-10-25 22:54:57 +00:00
#else
Hide find options and close button in 'typing' search
2009-02-22 01:34:21 +00:00
gtk_toolbar_insert (GTK_TOOLBAR (browser->find), browser->find_close, -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));
Integrate Midori with Maemo, use a Hildon window and adjust the interface To make Midori play nicely with Maemo the menubar is now integrated, we have a service file, a specific toolbar layout, no statusbar and icon styles. The changes are applied if hildon is available, and can of course be manually enabled or disabled.
2009-01-27 01:57:40 +00:00
#if HAVE_HILDON
hildon_window_add_toolbar (HILDON_WINDOW (browser),
GTK_TOOLBAR (browser->find));
#else
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
gtk_box_pack_start (GTK_BOX (vbox), browser->find, FALSE, FALSE, 0);
Integrate Midori with Maemo, use a Hildon window and adjust the interface To make Midori play nicely with Maemo the menubar is now integrated, we have a service file, a specific toolbar layout, no statusbar and icon styles. The changes are applied if hildon is available, and can of course be manually enabled or disabled.
2009-01-27 01:57:40 +00:00
#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
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);
Initial support for WebKitDownload At this point all downloads run automatically and appear in the statusbar. The destination folder can be chosen in the preferences. Download can be cancelled. The context menu works as well.
2009-03-19 17:28:50 +00:00
Simplify MidoriBrowser, remove Private
2008-06-19 18:39:00 +00:00
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);
Initial support for WebKitDownload At this point all downloads run automatically and appear in the statusbar. The destination folder can be chosen in the preferences. Download can be cancelled. The context menu works as well.
2009-03-19 17:28:50 +00:00
browser->transferbar = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (browser->statusbar), browser->transferbar,
FALSE, FALSE, 3);
gtk_widget_show (browser->transferbar);
Show a 'Delete all' button in the transferbar as needed The button shows up as a new download starts and vanishes again if no downloads are there.
2009-04-19 17:05:05 +00:00
browser->transferbar_clear = gtk_button_new_with_label (_("Delete All"));
icon = gtk_image_new_from_stock (GTK_STOCK_CLEAR, GTK_ICON_SIZE_MENU);
gtk_button_set_image (GTK_BUTTON (browser->transferbar_clear), icon);
g_signal_connect (browser->transferbar_clear, "clicked",
G_CALLBACK (midori_browser_transferbar_clear_clicked_cb), browser);
gtk_box_pack_end (GTK_BOX (browser->transferbar), browser->transferbar_clear,
FALSE, FALSE, 0);
Allow showing/ hiding the transferbar
2009-03-20 22:55:38 +00:00
g_signal_connect (browser->statusbar, "button-press-event",
G_CALLBACK (midori_browser_toolbar_item_button_press_event_cb), browser);
Initial support for WebKitDownload At this point all downloads run automatically and appear in the statusbar. The destination folder can be chosen in the preferences. Download can be cancelled. The context menu works as well.
2009-03-19 17:28:50 +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_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);
Fix clipboard menu items and do some tidying
2008-11-23 00:44:40 +00:00
katze_assign (browser->statusbar_text, 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->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
Add News Aggregator preference The program set here is called if the user clicks on the news feed icon, with the address of the current website as argument. For example liferea-add-feed works like that.
2009-04-14 17:44:48 +00:00
katze_assign (browser->news_aggregator, 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
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)
{
Integrate Midori with Maemo, use a Hildon window and adjust the interface To make Midori play nicely with Maemo the menubar is now integrated, we have a service file, a specific toolbar layout, no statusbar and icon styles. The changes are applied if hildon is available, and can of course be manually enabled or disabled.
2009-01-27 01:57:40 +00:00
#if HAVE_HILDON
GtkToolbarStyle gtk_toolbar_style = GTK_TOOLBAR_ICONS;
#else
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
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;
}
}
Integrate Midori with Maemo, use a Hildon window and adjust the interface To make Midori play nicely with Maemo the menubar is now integrated, we have a service file, a specific toolbar layout, no statusbar and icon styles. The changes are applied if hildon is available, and can of course be manually enabled or disabled.
2009-01-27 01:57:40 +00:00
#endif
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)
{
Implement a not yet functional menu for adding and removing tool items
2009-01-17 22:56:23 +00:00
midori_browser_toolbar_popup_context_menu_cb (
Refactor bookmarks panel into a separate panel widget
2009-01-31 03:09:35 +00:00
GTK_IS_BIN (toolitem) && gtk_bin_get_child (GTK_BIN (toolitem)) ?
Support separators in navigationbar and bookmarkbar
2009-01-28 23:56:07 +00:00
gtk_widget_get_parent (toolitem) : toolitem,
Create navigationbar from a string of actions
2008-10-12 16:14:57 +00:00
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;
Integrate Midori with Maemo, use a Hildon window and adjust the interface To make Midori play nicely with Maemo the menubar is now integrated, we have a service file, a specific toolbar layout, no statusbar and icon styles. The changes are applied if hildon is available, and can of course be manually enabled or disabled.
2009-01-27 01:57:40 +00:00
#if HAVE_HILDON
items = "Bookmarks,Window,Back,Forward,ReloadStop,Location,Panel,Trash";
#endif
Create navigationbar from a string of actions
2008-10-12 16:14:57 +00:00
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);
Support separators in navigationbar and bookmarkbar
2009-01-28 23:56:07 +00:00
if (gtk_bin_get_child (GTK_BIN (toolitem)))
g_signal_connect (gtk_bin_get_child (GTK_BIN (toolitem)),
"button-press-event",
G_CALLBACK (midori_browser_toolbar_item_button_press_event_cb),
browser);
else
{
gtk_tool_item_set_use_drag_window (GTK_TOOL_ITEM (toolitem), TRUE);
g_signal_connect (toolitem,
"button-press-event",
G_CALLBACK (midori_browser_toolbar_item_button_press_event_cb),
browser);
}
Allow adding separators to the navigationbar
2008-12-17 21:17:36 +00:00
gtk_toolbar_insert (GTK_TOOLBAR (browser->navigationbar),
GTK_TOOL_ITEM (toolitem), -1);
}
Create navigationbar from a string of actions
2008-10-12 16:14:57 +00:00
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;
Remember the last window state, ie. whether Midori was maximized or minimized
2009-01-20 22:27:19 +00:00
MidoriWindowState last_window_state;
Implement "right-align-sidepanel" to align the panel on the right
2009-02-22 02:51:10 +00:00
gboolean compact_sidepanel, right_align_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;
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
gboolean show_menubar, show_bookmarkbar;
Allow showing/ hiding the transferbar
2009-03-20 22:55:38 +00:00
gboolean show_panel, show_transferbar;
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;
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
Add News Aggregator preference The program set here is called if the user clicks on the news feed icon, with the address of the current website as argument. For example liferea-add-feed works like that.
2009-04-14 17:44:48 +00:00
g_free (browser->news_aggregator);
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,
Remember the last window state, ie. whether Midori was maximized or minimized
2009-01-20 22:27:19 +00:00
"last-window-state", &last_window_state,
Add Compact sidepanel Preference
2008-10-21 22:01:01 +00:00
"compact-sidepanel", &compact_sidepanel,
Implement "right-align-sidepanel" to align the panel on the right
2009-02-22 02:51:10 +00:00
"right-align-sidepanel", &right_align_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,
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
"show-navigationbar", &browser->show_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
"show-bookmarkbar", &show_bookmarkbar,
"show-panel", &show_panel,
Allow showing/ hiding the transferbar
2009-03-20 22:55:38 +00:00
"show-transferbar", &show_transferbar,
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
"show-statusbar", &browser->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
"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,
Allow marking a search engine as Default engine The default engine is used when search terms are typed in the address entry without tokens and for the 'Search the Web' item in the selection context menu. The 'Location entry search' is removed from the preferences. The setting 'location-entry-search' remains functional however.
2009-04-18 20:41:37 +00:00
"location-entry-search", &browser->location_entry_search,
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,
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
"progress-in-location", &browser->progress_in_location,
"remember-last-visited-pages", &browser->remember_last_visited_pages,
Add News Aggregator preference The program set here is called if the user clicks on the news feed icon, with the address of the current website as argument. For example liferea-add-feed works like that.
2009-04-14 17:44:48 +00:00
"news-aggregator", &browser->news_aggregator,
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);
Remember the last window state, ie. whether Midori was maximized or minimized
2009-01-20 22:27:19 +00:00
switch (last_window_state)
{
case MIDORI_WINDOW_MINIMIZED:
gtk_window_iconify (GTK_WINDOW (browser));
break;
case MIDORI_WINDOW_MAXIMIZED:
gtk_window_maximize (GTK_WINDOW (browser));
break;
case MIDORI_WINDOW_FULLSCREEN:
gtk_window_fullscreen (GTK_WINDOW (browser));
break;
default:
;/* Do nothing. */
}
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
}
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
{
Allow marking a search engine as Default engine The default engine is used when search terms are typed in the address entry without tokens and for the 'Search the Web' item in the selection context menu. The 'Location entry search' is removed from the preferences. The setting 'location-entry-search' remains functional however.
2009-04-18 20:41:37 +00:00
guint i;
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);
Allow marking a search engine as Default engine The default engine is used when search terms are typed in the address entry without tokens and for the 'Search the Web' item in the selection context menu. The 'Location entry search' is removed from the preferences. The setting 'location-entry-search' remains functional however.
2009-04-18 20:41:37 +00:00
i = 0;
while ((item = katze_array_get_nth_item (browser->search_engines, i++)))
if (!g_strcmp0 (katze_item_get_uri (item), browser->location_entry_search))
{
midori_search_action_set_default_item (MIDORI_SEARCH_ACTION (
_action_by_name (browser, "Search")), item);
break;
}
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);
Flip the toolbar of the panel as well when aligning it to the right
2009-02-22 15:03:08 +00:00
midori_panel_set_right_aligned (MIDORI_PANEL (browser->panel),
right_align_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);
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);
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
_action_set_active (browser, "Navigationbar", browser->show_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
_action_set_active (browser, "Bookmarkbar", show_bookmarkbar);
_action_set_active (browser, "Panel", show_panel);
Allow showing/ hiding the transferbar
2009-03-20 22:55:38 +00:00
#if WEBKIT_CHECK_VERSION (1, 1, 3)
_action_set_active (browser, "Transferbar", show_transferbar);
#endif
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
_action_set_active (browser, "Statusbar", browser->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
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
}
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);
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
else if (name == g_intern_string ("show-navigationbar"))
browser->show_navigationbar = g_value_get_boolean (&value);
else if (name == g_intern_string ("show-statusbar"))
browser->show_statusbar = g_value_get_boolean (&value);
else if (name == g_intern_string ("progress-in-location"))
browser->progress_in_location = g_value_get_boolean (&value);
Add a preference Search engines in location completion It seems that deletion of completion actions can fail, which means that the actions remain until the next restart. It is not clear how to fix this.
2009-04-18 21:26:54 +00:00
else if (name == g_intern_string ("search-engines-in-completion"))
{
if (g_value_get_boolean (&value))
midori_location_action_set_search_engines (MIDORI_LOCATION_ACTION (
_action_by_name (browser, "Location")), browser->search_engines);
else
midori_location_action_set_search_engines (MIDORI_LOCATION_ACTION (
_action_by_name (browser, "Location")), NULL);
}
Allow marking a search engine as Default engine The default engine is used when search terms are typed in the address entry without tokens and for the 'Search the Web' item in the selection context menu. The 'Location entry search' is removed from the preferences. The setting 'location-entry-search' remains functional however.
2009-04-18 20:41:37 +00:00
else if (name == g_intern_string ("location-entry-search"))
{
katze_assign (browser->location_entry_search, g_value_dup_string (&value));
}
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
else if (name == g_intern_string ("remember-last-visited-pages"))
browser->remember_last_visited_pages = g_value_get_boolean (&value);
Add News Aggregator preference The program set here is called if the user clicks on the news feed icon, with the address of the current website as argument. For example liferea-add-feed works like that.
2009-04-14 17:44:48 +00:00
else if (name == g_intern_string ("news-aggregator"))
{
katze_assign (browser->news_aggregator, g_value_dup_string (&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
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);
}
Support separators in navigationbar and bookmarkbar
2009-01-28 23:56:07 +00:00
else
{
gtk_tool_item_set_use_drag_window (toolitem, TRUE);
g_signal_connect (toolitem,
"button-press-event",
G_CALLBACK (midori_browser_bookmarkbar_item_button_press_event_cb),
browser);
g_object_set_data (G_OBJECT (toolitem), "KatzeItem", 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
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;
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);
}
Clean up handling of bookmarks like the history before
2008-12-21 19:44:31 +00:00
}
static void
midori_browser_set_bookmarks (MidoriBrowser* browser,
KatzeArray* 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
{
Optimize array iterations in the browser
2009-03-31 19:19:18 +00:00
guint i;
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
Clean up handling of bookmarks like the history before
2008-12-21 19:44:31 +00:00
if (browser->bookmarks == bookmarks)
return;
if (bookmarks)
g_object_ref (bookmarks);
katze_object_assign (browser->bookmarks, bookmarks);
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
_action_set_sensitive (browser, "BookmarkAdd", FALSE);
Add an 'Add new folder' menu item to Bookmarks menu
2009-04-10 20:28:36 +00:00
_action_set_sensitive (browser, "BookmarkFolderAdd", FALSE);
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 (!browser->bookmarks)
return;
Optimize array iterations in the browser
2009-03-31 19:19:18 +00:00
i = 0;
while ((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);
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
_action_set_sensitive (browser, "BookmarkAdd", TRUE);
Add an 'Add new folder' menu item to Bookmarks menu
2009-04-10 20:28:36 +00:00
_action_set_sensitive (browser, "BookmarkFolderAdd", TRUE);
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
}
Initial refactoring work, regressions expected The 'browser' struct is superseded by MidoriBrowser, which actually represents a window that holds pages, i.e. tabs. The tabs are currently of the type MidoriWebView, which is a slightly enhanced WebView. Also MidoriWebSettings is introduced to hold additional settings that Midori needs. The other two new classes are MidoriTrash, representing closed tabs and windows and MidoriPanel, representing the side panel. The refactoring allows for several features to be much more easily implemented, such as full support for multiple windows and instant saving of modified 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));
Allow choosing a folder when adding a bookmark
2009-01-01 02:52:43 +00:00
if (browser->settings)
{
_midori_browser_update_settings (browser);
g_signal_connect (browser->settings, "notify",
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:
Clean up handling of bookmarks like the history before
2008-12-21 19:44:31 +00:00
midori_browser_set_bookmarks (browser, g_value_get_object (value));
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
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:
Move around history loading in MidoriBrowser
2008-11-09 18:26:48 +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:
Move around history loading in MidoriBrowser
2008-11-09 18:26:48 +00:00
/* 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));
Add a preference Search engines in location completion It seems that deletion of completion actions can fail, which means that the actions remain until the next restart. It is not clear how to fix this.
2009-04-18 21:26:54 +00:00
if (browser->settings)
{
if (katze_object_get_boolean (browser->settings,
"search-engines-in-completion"))
midori_location_action_set_search_engines (MIDORI_LOCATION_ACTION (
_action_by_name (browser, "Location")), browser->search_engines);
else
midori_location_action_set_search_engines (MIDORI_LOCATION_ACTION (
_action_by_name (browser, "Location")), NULL);
}
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
{
Allow marking a search engine as Default engine The default engine is used when search terms are typed in the address entry without tokens and for the 'Search the Web' item in the selection context menu. The 'Location entry search' is removed from the preferences. The setting 'location-entry-search' remains functional however.
2009-04-18 20:41:37 +00:00
guint i;
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);
Allow marking a search engine as Default engine The default engine is used when search terms are typed in the address entry without tokens and for the 'Search the Web' item in the selection context menu. The 'Location entry search' is removed from the preferences. The setting 'location-entry-search' remains functional however.
2009-04-18 20:41:37 +00:00
i = 0;
while ((item = katze_array_get_nth_item (browser->search_engines, i++)))
if (!g_strcmp0 (katze_item_get_uri (item), browser->location_entry_search))
{
midori_search_action_set_default_item (MIDORI_SEARCH_ACTION (
_action_by_name (browser, "Search")), item);
break;
}
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:
Revamp clearing of the history
2008-12-21 18:21:04 +00:00
midori_browser_set_history (browser, g_value_get_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
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;
Expose browser notebook and panel as properties
2008-11-18 01:02:59 +00:00
case PROP_NOTEBOOK:
g_value_set_object (value, browser->notebook);
break;
case PROP_PANEL:
g_value_set_object (value, browser->panel);
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;
Fix browser properties along with enabling the property test
2009-02-22 12:52:04 +00:00
case PROP_LOAD_STATUS:
{
GtkWidget* view = midori_browser_get_current_tab (browser);
if (view)
g_value_set_enum (value,
midori_view_get_load_status (MIDORI_VIEW (view)));
else
g_value_set_enum (value, MIDORI_LOAD_FINISHED);
break;
}
First attempt at an extension interface.
2008-05-02 20:30:26 +00:00
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
{
Fix clipboard menu items and do some tidying
2008-11-23 00:44:40 +00:00
g_return_val_if_fail (MIDORI_IS_BROWSER (browser), -1);
g_return_val_if_fail (GTK_IS_WIDGET (view), -1);
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
{
Fix clipboard menu items and do some tidying
2008-11-23 00:44:40 +00:00
g_return_if_fail (MIDORI_IS_BROWSER (browser));
g_return_if_fail (GTK_IS_WIDGET (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
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.
*
* 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;
Fix clipboard menu items and do some tidying
2008-11-23 00:44:40 +00:00
g_return_val_if_fail (MIDORI_IS_BROWSER (browser), -1);
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_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,
Implement a not yet functional menu for adding and removing tool items
2009-01-17 22:56:23 +00:00
"net", browser->net,
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
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
* 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
Fix clipboard menu items and do some tidying
2008-11-23 00:44:40 +00:00
g_return_val_if_fail (MIDORI_IS_BROWSER (browser), -1);
g_return_val_if_fail (uri != NULL, -1);
Check for settings and views more properly These improvements were assisted by a test case that is going to follow soon.
2009-02-28 13:05:01 +00:00
if (browser->settings)
view = g_object_new (MIDORI_TYPE_VIEW, "settings", browser->settings,
"net", browser->net, NULL);
else
view = midori_view_new (browser->net);
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 (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)
{
Fix clipboard menu items and do some tidying
2008-11-23 00:44:40 +00:00
g_return_if_fail (MIDORI_IS_BROWSER (browser));
g_return_if_fail (name != NULL);
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 function to obtain the action group of the browser
2009-02-28 03:15:16 +00:00
/**
* midori_browser_get_action_group:
* @browser: a #MidoriBrowser
*
* Retrieves the action group holding all actions used
* by the browser. It allows obtaining individual
* actions and adding new actions.
*
* Return value: the action group of the browser
*
* Since: 0.1.4
**/
GtkActionGroup*
midori_browser_get_action_group (MidoriBrowser* browser)
{
g_return_val_if_fail (MIDORI_IS_BROWSER (browser), NULL);
return browser->action_group;
}
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));
Fix clipboard menu items and do some tidying
2008-11-23 00:44:40 +00:00
g_return_if_fail (uri != NULL);
Add an Open external pages in Preference
2008-10-20 06:50:16 +00:00
Fix browser properties along with enabling the property test
2009-02-22 12:52:04 +00:00
if ((view = midori_browser_get_current_tab (browser)))
midori_view_set_uri (MIDORI_VIEW (view), uri);
else
midori_browser_add_uri (browser, uri);
Add an Open external pages in Preference
2008-10-20 06:50:16 +00:00
}
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);
Fix browser properties along with enabling the property test
2009-02-22 12:52:04 +00:00
if ((view = midori_browser_get_current_tab (browser)))
return midori_view_get_display_uri (MIDORI_VIEW (view));
return NULL;
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
Add midori_browser_get_for_widget_utility function This function will look for a MidoriBrowser according to a particular widget - even if it's inside a detached panel window or any other window transient for the browser.
2009-04-23 02:10:38 +00:00
/**
* midori_browser_get_for_widget:
* @widget: a #GtkWidget
*
* Determines the browser appropriate for the specified widget.
*
* Return value: a #MidoriBrowser
*
* Since 0.1.7
**/
MidoriBrowser*
midori_browser_get_for_widget (GtkWidget* widget)
{
gpointer browser;
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
browser = gtk_widget_get_toplevel (GTK_WIDGET (widget));
if (!MIDORI_IS_BROWSER (browser))
{
if (!GTK_IS_WINDOW (browser))
return NULL;
browser = gtk_window_get_transient_for (GTK_WINDOW (browser));
if (!MIDORI_IS_BROWSER (browser))
return NULL;
}
return MIDORI_BROWSER (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
/**
* 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