KatzeSeparatorAction

KatzeSeparatorAction

Synopsis

#include <midori/midori.h>

#define             MIDORI_AUTOCOMPLETER_TYPE_COLUMNS
struct              KatzeSeparatorAction;
struct              KatzeSeparatorActionClass;
struct              MidoriHSTS;
struct              MidoriHSTSClass;
struct              MidoriHSTSDirective;
struct              MidoriHSTSDirectiveClass;
enum                MidoriRuntimeMode;
struct              MidoriURI;
struct              MidoriURIClass;
struct              MidoriURIIcon;
struct              MidoriURIIconClass;
enum                MidoriDatabaseError;
#define             MIDORI_DATABASE_ERROR
struct              MidoriDatabase;
struct              MidoriDatabaseClass;
struct              MidoriBookmarksDatabase;
struct              MidoriBookmarksDatabaseClass;
struct              MidoriTestJob;
struct              MidoriTestJobClass;
struct              MidoriFileChooserDialog;
struct              MidoriFileChooserDialogClass;
struct              MidoriCompletion;
struct              MidoriCompletionClass;
struct              MidoriSearchCompletion;
struct              MidoriSearchCompletionClass;
struct              MidoriHistoryCompletion;
struct              MidoriHistoryCompletionClass;
enum                MidoriSpeedDialError;
#define             MIDORI_SPEED_DIAL_ERROR
struct              MidoriSpeedDial;
struct              MidoriSpeedDialClass;
struct              MidoriSpeedDialSpec;
struct              MidoriSpeedDialSpecClass;
struct              MidoriContextAction;
struct              MidoriContextActionClass;
void                (*MidoriContextActionActionActivateCallback)
                                                        (GtkAction *action,
                                                         void *user_data);
struct              MidoriSeparatorContextAction;
struct              MidoriSeparatorContextActionClass;
gboolean            (*MidoriDatabaseCallback)           (void *user_data,
                                                         GError **error);
struct              MidoriDatabaseStatement;
struct              MidoriDatabaseStatementClass;
struct              MidoriPanedAction;
struct              MidoriPanedActionClass;
struct              MidoriViewableIface;
struct              MidoriExtensionsColumn;
struct              MidoriExtensionsColumnClass;
struct              MidoriSuggestion;
struct              MidoriSuggestionClass;
struct              MidoriAutocompleter;
struct              MidoriAutocompleterClass;
enum                MidoriAutocompleterColumns;
enum                MidoriWindowState;
struct              MidoriSettings;
struct              MidoriSettingsClass;
struct              MidoriHistoryItem;
struct              MidoriHistoryItemClass;
struct              MidoriHistoryWebsite;
struct              MidoriHistoryWebsiteClass;
struct              MidoriHistorySearch;
struct              MidoriHistorySearchClass;
struct              MidoriHistoryDatabase;
struct              MidoriHistoryDatabaseClass;
enum                MidoriNewView;
enum                MidoriSecurity;
enum                MidoriLoadStatus;
enum                MidoriLoadError;
struct              MidoriTab;
struct              MidoriTabClass;
struct              MidoriTally;
struct              MidoriTallyClass;
struct              MidoriNotebook;
struct              MidoriNotebookClass;
struct              MidoriViewCompletion;
struct              MidoriViewCompletionClass;
KatzeSeparatorAction * katze_separator_action_new       (void);
KatzeSeparatorAction * katze_separator_action_construct (GType object_type);
MidoriHSTS *        midori_hsts_new                     (void);
MidoriHSTS *        midori_hsts_construct               (GType object_type);
gpointer            midori_hsts_directive_ref           (gpointer instance);
void                midori_hsts_directive_unref         (gpointer instance);
GParamSpec *        midori_hsts_param_spec_directive    (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         GType object_type,
                                                         GParamFlags flags);
void                midori_hsts_value_set_directive     (GValue *value,
                                                         gpointer v_object);
void                midori_hsts_value_take_directive    (GValue *value,
                                                         gpointer v_object);
gpointer            midori_hsts_value_get_directive     (const GValue *value);
MidoriHSTSDirective * midori_hsts_directive_new         (gboolean include_sub_domains);
MidoriHSTSDirective * midori_hsts_directive_construct   (GType object_type,
                                                         gboolean include_sub_domains);
MidoriHSTSDirective * midori_hsts_directive_new_from_header
                                                        (const gchar *header);
MidoriHSTSDirective * midori_hsts_directive_construct_from_header
                                                        (GType object_type,
                                                         const gchar *header);
gboolean            midori_hsts_directive_is_valid      (MidoriHSTSDirective *self);
void                midori_paths_test_reset_runtime_mode
                                                        (void);
gchar *             midori_paths_get_config_dir_for_reading
                                                        (void);
gchar *             midori_paths_get_config_filename_for_reading
                                                        (const gchar *filename);
gboolean            midori_paths_is_readonly            (void);
MidoriRuntimeMode   midori_paths_get_runtime_mode       (void);
const gchar *       midori_paths_get_runtime_dir        (void);
void                midori_paths_init                   (MidoriRuntimeMode new_mode,
                                                         const gchar *config);
void                midori_paths_mkdir_with_parents     (const gchar *path,
                                                         gint mode);
void                midori_paths_remove_path            (const gchar *path);
const gchar *       midori_paths_get_config_dir_for_writing
                                                        (void);
gchar *             midori_paths_get_extension_config_dir
                                                        (const gchar *extension);
gchar *             midori_paths_get_extension_preset_filename
                                                        (const gchar *extension,
                                                         const gchar *filename);
gchar *             midori_paths_get_config_filename_for_writing
                                                        (const gchar *filename);
const gchar *       midori_paths_get_cache_dir          (void);
const gchar *       midori_paths_get_user_data_dir      (void);
const gchar *       midori_paths_get_user_data_dir_for_reading
                                                        (void);
const gchar *       midori_paths_get_cache_dir_for_reading
                                                        (void);
const gchar *       midori_paths_get_tmp_dir            (void);
gchar *             midori_paths_make_tmp_dir           (const gchar *tmpl);
void                midori_paths_init_exec_path         (gchar **new_command_line,
                                                         int new_command_line_length1);
gchar **            midori_paths_get_command_line       (int *result_length1);
gchar *             midori_paths_get_command_line_str   (gboolean for_display);
gchar *             midori_paths_get_lib_path           (const gchar *package);
gchar *             midori_paths_get_res_filename       (const gchar *filename);
gchar *             midori_paths_get_data_filename      (const gchar *filename,
                                                         gboolean res);
gchar *             midori_paths_get_preset_filename    (const gchar *folder,
                                                         const gchar *filename);
void                midori_paths_clear_icons            (void);
GdkPixbuf *         midori_paths_get_icon               (const gchar *uri,
                                                         GtkWidget *widget);
gchar *             midori_uri_parse_hostname           (const gchar *uri,
                                                         gchar **path);
gchar *             midori_uri_parse                    (const gchar *uri,
                                                         gchar **path);
gchar *             midori_uri_to_ascii                 (const gchar *uri);
gchar *             midori_uri_get_base_domain          (const gchar *uri);
gchar *             midori_uri_unescape                 (const gchar *uri);
gchar *             midori_uri_strip_prefix_for_display (const gchar *uri);
gchar *             midori_uri_format_for_display       (const gchar *uri);
gchar *             midori_uri_for_search               (const gchar *uri,
                                                         const gchar *keywords);
gboolean            midori_uri_is_blank                 (const gchar *uri);
gboolean            midori_uri_is_http                  (const gchar *uri);
gboolean            midori_uri_is_resource              (const gchar *uri);
gboolean            midori_uri_is_location              (const gchar *uri);
gboolean            midori_uri_is_ip_address            (const gchar *uri);
gboolean            midori_uri_is_valid                 (const gchar *uri);
gchar *             midori_uri_get_folder               (const gchar *uri);
GChecksumType       midori_uri_get_fingerprint          (const gchar *uri,
                                                         gchar **checksum,
                                                         gchar **label);
gboolean            midori_uri_recursive_fork_protection
                                                        (const gchar *uri,
                                                         gboolean set_uri);
void                midori_uri_get_icon                 (const gchar *uri,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);
GIcon *             midori_uri_get_icon_finish          (GAsyncResult *_res_,
                                                         GError **error);
void                midori_uri_get_icon_fallback        (const gchar *uri,
                                                         GIcon *fallback,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);
GIcon *             midori_uri_get_icon_fallback_finish (GAsyncResult *_res_);
MidoriURI *         midori_uri_new                      (void);
MidoriURI *         midori_uri_construct                (GType object_type);
MidoriURIIcon *     midori_uri_icon_new                 (const gchar *website_uri,
                                                         GIcon *fallback);
MidoriURIIcon *     midori_uri_icon_construct           (GType object_type,
                                                         const gchar *website_uri,
                                                         GIcon *fallback);
const gchar *       midori_uri_icon_get_uri             (MidoriURIIcon *self);
GIcon *             midori_uri_icon_get_fallback        (MidoriURIIcon *self);
GQuark              midori_database_error_quark         (void);
MidoriBookmarksDatabase * midori_bookmarks_database_new (GError **error);
MidoriBookmarksDatabase * midori_bookmarks_database_construct
                                                        (GType object_type,
                                                         GError **error);
void                midori_bookmarks_database_preinit   (MidoriBookmarksDatabase *self,
                                                         GError **error);
guint               midori_timeout_add_seconds          (guint interval,
                                                         GSourceFunc function,
                                                         void *function_target,
                                                         GDestroyNotify function_target_destroy_notify);
guint               midori_timeout_add                  (guint interval,
                                                         GSourceFunc function,
                                                         void *function_target,
                                                         GDestroyNotify function_target_destroy_notify);
void                midori_test_init                    (int *args_length1,
                                                         gchar ***args);
void                midori_test_grab_max_timeout        (void);
void                midori_test_release_max_timeout     (void);
void                midori_test_idle_timeouts           (void);
void                midori_test_job_run                 (MidoriTestJob *self,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);
void                midori_test_job_run_finish          (MidoriTestJob *self,
                                                         GAsyncResult *_res_,
                                                         GError **error);
void                midori_test_job_run_sync            (MidoriTestJob *self);
MidoriTestJob *     midori_test_job_construct           (GType object_type);
void                midori_test_log_set_fatal_handler_for_icons
                                                        (void);
void                midori_test_set_dialog_response     (GtkResponseType response);
void                midori_test_set_file_chooser_filename
                                                        (const gchar *filename);
void                midori_show_message_dialog          (GtkMessageType type,
                                                         const gchar *_short_,
                                                         const gchar *detailed,
                                                         gboolean modal);
MidoriFileChooserDialog * midori_file_chooser_dialog_new
                                                        (const gchar *title,
                                                         GtkWindow *window,
                                                         GtkFileChooserAction action);
MidoriFileChooserDialog * midori_file_chooser_dialog_construct
                                                        (GType object_type,
                                                         const gchar *title,
                                                         GtkWindow *window,
                                                         GtkFileChooserAction action);
gint                midori_dialog_run                   (GtkDialog *dialog);
gboolean            midori_download_is_finished         (WebKitDownload *download);
void                midori_download_set_type            (WebKitDownload *download,
                                                         gint type);
gdouble             midori_download_get_progress        (WebKitDownload *download);
gchar *             midori_download_get_tooltip         (WebKitDownload *download);
gchar *             midori_download_get_content_type    (WebKitDownload *download,
                                                         const gchar *mime_type);
gboolean            midori_download_has_wrong_checksum  (WebKitDownload *download);
gboolean            midori_download_action_clear        (WebKitDownload *download,
                                                         GtkWidget *widget,
                                                         GError **error);
gchar *             midori_download_action_stock_id     (WebKitDownload *download);
gboolean            midori_download_open                (WebKitDownload *download,
                                                         GtkWidget *widget,
                                                         GError **error);
const gchar *       midori_download_fallback_extension  (const gchar *extension,
                                                         const gchar *mime_type);
gchar *             midori_download_clean_filename      (const gchar *filename);
gchar *             midori_download_get_suggested_filename
                                                        (WebKitDownload *download);
gchar *             midori_download_get_filename_suggestion_for_uri
                                                        (const gchar *mime_type,
                                                         const gchar *uri);
gchar *             midori_download_get_extension_for_uri
                                                        (const gchar *uri,
                                                         gchar **basename);
gchar *             midori_download_get_unique_filename (const gchar *filename);
gchar *             midori_download_get_basename_for_display
                                                        (const gchar *uri);
gchar *             midori_download_prepare_destination_uri
                                                        (WebKitDownload *download,
                                                         const gchar *folder);
gboolean            midori_download_has_enough_space    (WebKitDownload *download,
                                                         const gchar *destination_uri,
                                                         gboolean quiet);
MidoriSearchCompletion * midori_search_completion_new   (void);
MidoriSearchCompletion * midori_search_completion_construct
                                                        (GType object_type);
MidoriHistoryCompletion * midori_history_completion_new (void);
MidoriHistoryCompletion * midori_history_completion_construct
                                                        (GType object_type);
GQuark              midori_speed_dial_error_quark       (void);
MidoriSpeedDial *   midori_speed_dial_new               (const gchar *new_filename,
                                                         const gchar *fallback);
MidoriSpeedDial *   midori_speed_dial_construct         (GType object_type,
                                                         const gchar *new_filename,
                                                         const gchar *fallback);
gchar *             midori_speed_dial_get_next_free_slot
                                                        (MidoriSpeedDial *self,
                                                         guint *count);
void                midori_speed_dial_add               (MidoriSpeedDial *self,
                                                         const gchar *uri,
                                                         const gchar *title,
                                                         GdkPixbuf *img);
void                midori_speed_dial_add_with_id       (MidoriSpeedDial *self,
                                                         const gchar *id,
                                                         const gchar *uri,
                                                         const gchar *title,
                                                         GdkPixbuf *img);
const gchar *       midori_speed_dial_get_html          (MidoriSpeedDial *self,
                                                         GError **error);
void                midori_speed_dial_save_message      (MidoriSpeedDial *self,
                                                         const gchar *message,
                                                         GError **error);
gboolean            midori_speed_dial_get_close_buttons_left
                                                        (MidoriSpeedDial *self);
void                midori_speed_dial_set_close_buttons_left
                                                        (MidoriSpeedDial *self,
                                                         gboolean value);
gpointer            midori_speed_dial_spec_ref          (gpointer instance);
void                midori_speed_dial_spec_unref        (gpointer instance);
GParamSpec *        midori_speed_dial_param_spec_spec   (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         GType object_type,
                                                         GParamFlags flags);
void                midori_speed_dial_value_set_spec    (GValue *value,
                                                         gpointer v_object);
void                midori_speed_dial_value_take_spec   (GValue *value,
                                                         gpointer v_object);
gpointer            midori_speed_dial_value_get_spec    (const GValue *value);
MidoriSpeedDialSpec * midori_speed_dial_spec_new        (const gchar *dial_id,
                                                         const gchar *uri);
MidoriSpeedDialSpec * midori_speed_dial_spec_construct  (GType object_type,
                                                         const gchar *dial_id,
                                                         const gchar *uri);
MidoriContextAction * midori_context_action_new         (const gchar *name,
                                                         const gchar *label,
                                                         const gchar *tooltip,
                                                         const gchar *stock_id);
MidoriContextAction * midori_context_action_construct   (GType object_type,
                                                         const gchar *name,
                                                         const gchar *label,
                                                         const gchar *tooltip,
                                                         const gchar *stock_id);
MidoriContextAction * midori_context_action_new_escaped (const gchar *name,
                                                         const gchar *label,
                                                         const gchar *tooltip,
                                                         const gchar *stock_id);
MidoriContextAction * midori_context_action_construct_escaped
                                                        (GType object_type,
                                                         const gchar *name,
                                                         const gchar *label,
                                                         const gchar *tooltip,
                                                         const gchar *stock_id);
void                midori_context_action_add_simple    (MidoriContextAction *self,
                                                         const gchar *name,
                                                         const gchar *label,
                                                         const gchar *tooltip,
                                                         const gchar *stock_id,
                                                         MidoriContextActionActionActivateCallback callback,
                                                         void *callback_target);
void                midori_context_action_add           (MidoriContextAction *self,
                                                         GtkAction *action);
void                midori_context_action_add_action_group
                                                        (MidoriContextAction *self,
                                                         GtkActionGroup *action_group);
void                midori_context_action_add_by_name   (MidoriContextAction *self,
                                                         const gchar *name);
GtkMenu *           midori_context_action_create_menu   (MidoriContextAction *self,
                                                         GtkMenu *default_menu,
                                                         gboolean accels);
GtkAction *         midori_context_action_get_by_name   (MidoriContextAction *self,
                                                         const gchar *name);
MidoriSeparatorContextAction * midori_separator_context_action_new
                                                        (void);
MidoriSeparatorContextAction * midori_separator_context_action_construct
                                                        (GType object_type);
MidoriDatabaseStatement * midori_database_statement_new (MidoriDatabase *database,
                                                         const gchar *query,
                                                         GError **error);
MidoriDatabaseStatement * midori_database_statement_construct
                                                        (GType object_type,
                                                         MidoriDatabase *database,
                                                         const gchar *query,
                                                         GError **error);
gboolean            midori_database_statement_init      (MidoriDatabaseStatement *self,
                                                         GCancellable *cancellable,
                                                         GError **error);
void                midori_database_statement_bind      (MidoriDatabaseStatement *self,
                                                         const gchar *pname,
                                                         GError **error,
                                                         ...);
gboolean            midori_database_statement_exec      (MidoriDatabaseStatement *self,
                                                         GError **error);
gboolean            midori_database_statement_step      (MidoriDatabaseStatement *self,
                                                         GError **error);
gint64              midori_database_statement_row_id    (MidoriDatabaseStatement *self,
                                                         GError **error);
gchar *             midori_database_statement_get_string
                                                        (MidoriDatabaseStatement *self,
                                                         const gchar *name,
                                                         GError **error);
gint64              midori_database_statement_get_int64 (MidoriDatabaseStatement *self,
                                                         const gchar *name,
                                                         GError **error);
gdouble             midori_database_statement_get_double
                                                        (MidoriDatabaseStatement *self,
                                                         const gchar *name,
                                                         GError **error);
sqlite3_stmt *      midori_database_statement_get_stmt  (MidoriDatabaseStatement *self);
MidoriDatabase *    midori_database_statement_get_database
                                                        (MidoriDatabaseStatement *self);
void                midori_database_statement_set_database
                                                        (MidoriDatabaseStatement *self,
                                                         MidoriDatabase *value);
const gchar *       midori_database_statement_get_query (MidoriDatabaseStatement *self);
void                midori_database_statement_set_query (MidoriDatabaseStatement *self,
                                                         const gchar *value);
MidoriDatabase *    midori_database_new                 (const gchar *path,
                                                         GError **error);
MidoriDatabase *    midori_database_construct           (GType object_type,
                                                         const gchar *path,
                                                         GError **error);
gboolean            midori_database_init                (MidoriDatabase *self,
                                                         GCancellable *cancellable,
                                                         GError **error);
gboolean            midori_database_attach              (MidoriDatabase *self,
                                                         const gchar *path,
                                                         const gchar *alias,
                                                         GError **error);
gboolean            midori_database_exec_script         (MidoriDatabase *self,
                                                         const gchar *filename,
                                                         GError **error);
gboolean            midori_database_transaction         (MidoriDatabase *self,
                                                         MidoriDatabaseCallback callback,
                                                         void *callback_target,
                                                         GError **error);
gboolean            midori_database_exec                (MidoriDatabase *self,
                                                         const gchar *query,
                                                         GError **error);
MidoriDatabaseStatement * midori_database_prepare       (MidoriDatabase *self,
                                                         const gchar *query,
                                                         GError **error,
                                                         ...);
sqlite3 *           midori_database_get_db              (MidoriDatabase *self);
const gchar *       midori_database_get_path            (MidoriDatabase *self);
void                midori_database_set_path            (MidoriDatabase *self,
                                                         const gchar *value);
gboolean            midori_database_get_first_use       (MidoriDatabase *self);
void                midori_database_set_first_use       (MidoriDatabase *self,
                                                         gboolean value);
void                midori_paned_action_set_child1      (MidoriPanedAction *self,
                                                         GtkWidget *widget,
                                                         const gchar *name,
                                                         gboolean resize,
                                                         gboolean shrink);
void                midori_paned_action_set_child2      (MidoriPanedAction *self,
                                                         GtkWidget *widget,
                                                         const gchar *name,
                                                         gboolean resize,
                                                         gboolean shrink);
GtkWidget *         midori_paned_action_get_child1      (MidoriPanedAction *self);
GtkWidget *         midori_paned_action_get_child2      (MidoriPanedAction *self);
GtkWidget *         midori_paned_action_get_child_by_name
                                                        (MidoriPanedAction *self,
                                                         const gchar *name);
gchar *             midori_paned_action_get_child1_name (MidoriPanedAction *self);
gchar *             midori_paned_action_get_child2_name (MidoriPanedAction *self);
MidoriPanedAction * midori_paned_action_new             (void);
MidoriPanedAction * midori_paned_action_construct       (GType object_type);
const gchar *       midori_viewable_get_stock_id        (MidoriViewable *self);
const gchar *       midori_viewable_get_label           (MidoriViewable *self);
GtkWidget *         midori_viewable_get_toolbar         (MidoriViewable *self);
MidoriExtensionsColumn * midori_extensions_column_new   (void);
MidoriExtensionsColumn * midori_extensions_column_construct
                                                        (GType object_type);
MidoriSuggestion *  midori_suggestion_new               (const gchar *uri,
                                                         const gchar *markup,
                                                         gboolean use_markup,
                                                         const gchar *background,
                                                         GIcon *icon,
                                                         gint *priority);
MidoriSuggestion *  midori_suggestion_construct         (GType object_type,
                                                         const gchar *uri,
                                                         const gchar *markup,
                                                         gboolean use_markup,
                                                         const gchar *background,
                                                         GIcon *icon,
                                                         gint *priority);
const gchar *       midori_suggestion_get_uri           (MidoriSuggestion *self);
void                midori_suggestion_set_uri           (MidoriSuggestion *self,
                                                         const gchar *value);
const gchar *       midori_suggestion_get_markup        (MidoriSuggestion *self);
void                midori_suggestion_set_markup        (MidoriSuggestion *self,
                                                         const gchar *value);
gboolean            midori_suggestion_get_use_markup    (MidoriSuggestion *self);
void                midori_suggestion_set_use_markup    (MidoriSuggestion *self,
                                                         gboolean value);
const gchar *       midori_suggestion_get_background    (MidoriSuggestion *self);
void                midori_suggestion_set_background    (MidoriSuggestion *self,
                                                         const gchar *value);
GIcon *             midori_suggestion_get_icon          (MidoriSuggestion *self);
void                midori_suggestion_set_icon          (MidoriSuggestion *self,
                                                         GIcon *value);
gboolean            midori_suggestion_get_action        (MidoriSuggestion *self);
void                midori_suggestion_set_action        (MidoriSuggestion *self,
                                                         gboolean value);
gint                midori_suggestion_get_priority      (MidoriSuggestion *self);
void                midori_suggestion_set_priority      (MidoriSuggestion *self,
                                                         gint value);
void                midori_completion_prepare           (MidoriCompletion *self,
                                                         GObject *app);
gboolean            midori_completion_can_complete      (MidoriCompletion *self,
                                                         const gchar *prefix);
gboolean            midori_completion_can_action        (MidoriCompletion *self,
                                                         const gchar *action);
void                midori_completion_complete          (MidoriCompletion *self,
                                                         const gchar *text,
                                                         const gchar *action,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);
GList *             midori_completion_complete_finish   (MidoriCompletion *self,
                                                         GAsyncResult *_res_);
MidoriCompletion *  midori_completion_construct         (GType object_type);
const gchar *       midori_completion_get_description   (MidoriCompletion *self);
void                midori_completion_set_description   (MidoriCompletion *self,
                                                         const gchar *value);
gint                midori_completion_get_max_items     (MidoriCompletion *self);
MidoriAutocompleter * midori_autocompleter_new          (GObject *app);
MidoriAutocompleter * midori_autocompleter_construct    (GType object_type,
                                                         GObject *app);
void                midori_autocompleter_add            (MidoriAutocompleter *self,
                                                         MidoriCompletion *completion);
gboolean            midori_autocompleter_can_complete   (MidoriAutocompleter *self,
                                                         const gchar *text);
void                midori_autocompleter_complete       (MidoriAutocompleter *self,
                                                         const gchar *text,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);
void                midori_autocompleter_complete_finish
                                                        (MidoriAutocompleter *self,
                                                         GAsyncResult *_res_);
gboolean            midori_autocompleter_can_action     (MidoriAutocompleter *self,
                                                         const gchar *action);
void                midori_autocompleter_action         (MidoriAutocompleter *self,
                                                         const gchar *action,
                                                         const gchar *text,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);
void                midori_autocompleter_action_finish  (MidoriAutocompleter *self,
                                                         GAsyncResult *_res_);
GtkListStore *      midori_autocompleter_get_model      (MidoriAutocompleter *self);
gboolean            midori_settings_delay_saving        (MidoriSettings *self,
                                                         const gchar *property);
MidoriSettings *    midori_settings_new                 (void);
MidoriSettings *    midori_settings_construct           (GType object_type);
gboolean            midori_settings_get_enable_javascript
                                                        (MidoriSettings *self);
void                midori_settings_set_enable_javascript
                                                        (MidoriSettings *self,
                                                         gboolean value);
gchar *             midori_settings_get_default_charset (MidoriSettings *self);
void                midori_settings_set_default_charset (MidoriSettings *self,
                                                         const gchar *value);
gboolean            midori_settings_get_zoom_text_and_images
                                                        (MidoriSettings *self);
void                midori_settings_set_zoom_text_and_images
                                                        (MidoriSettings *self,
                                                         gboolean value);
gboolean            midori_settings_get_remember_last_window_size
                                                        (MidoriSettings *self);
void                midori_settings_set_remember_last_window_size
                                                        (MidoriSettings *self,
                                                         gboolean value);
gint                midori_settings_get_last_window_width
                                                        (MidoriSettings *self);
void                midori_settings_set_last_window_width
                                                        (MidoriSettings *self,
                                                         gint value);
gint                midori_settings_get_last_window_height
                                                        (MidoriSettings *self);
void                midori_settings_set_last_window_height
                                                        (MidoriSettings *self,
                                                         gint value);
gint                midori_settings_get_last_panel_position
                                                        (MidoriSettings *self);
void                midori_settings_set_last_panel_position
                                                        (MidoriSettings *self,
                                                         gint value);
gint                midori_settings_get_last_panel_page (MidoriSettings *self);
void                midori_settings_set_last_panel_page (MidoriSettings *self,
                                                         gint value);
gint                midori_settings_get_last_web_search (MidoriSettings *self);
void                midori_settings_set_last_web_search (MidoriSettings *self,
                                                         gint value);
gint                midori_settings_get_search_width    (MidoriSettings *self);
void                midori_settings_set_search_width    (MidoriSettings *self,
                                                         gint value);
gboolean            midori_settings_get_last_inspector_attached
                                                        (MidoriSettings *self);
void                midori_settings_set_last_inspector_attached
                                                        (MidoriSettings *self,
                                                         gboolean value);
MidoriWindowState   midori_settings_get_last_window_state
                                                        (MidoriSettings *self);
void                midori_settings_set_last_window_state
                                                        (MidoriSettings *self,
                                                         MidoriWindowState value);
guint               midori_settings_get_inactivity_reset
                                                        (MidoriSettings *self);
void                midori_settings_set_inactivity_reset
                                                        (MidoriSettings *self,
                                                         guint value);
const gchar *       midori_settings_get_default_theme_name
                                                        (MidoriSettings *self);
const gchar *       midori_settings_get_theme_name      (MidoriSettings *self);
void                midori_settings_set_theme_name      (MidoriSettings *self,
                                                         const gchar *value);
const gchar *       midori_settings_get_block_uris      (MidoriSettings *self);
void                midori_settings_set_block_uris      (MidoriSettings *self,
                                                         const gchar *value);
const gchar *       midori_settings_get_custom_title    (MidoriSettings *self);
void                midori_settings_set_custom_title    (MidoriSettings *self,
                                                         const gchar *value);
const gchar *       midori_settings_get_location_entry_search
                                                        (MidoriSettings *self);
void                midori_settings_set_location_entry_search
                                                        (MidoriSettings *self,
                                                         const gchar *value);
gint                midori_settings_get_clear_private_data
                                                        (MidoriSettings *self);
void                midori_settings_set_clear_private_data
                                                        (MidoriSettings *self,
                                                         gint value);
const gchar *       midori_settings_get_clear_data      (MidoriSettings *self);
void                midori_settings_set_clear_data      (MidoriSettings *self,
                                                         const gchar *value);
gboolean            midori_settings_get_compact_sidepanel
                                                        (MidoriSettings *self);
void                midori_settings_set_compact_sidepanel
                                                        (MidoriSettings *self,
                                                         gboolean value);
gboolean            midori_settings_get_open_panels_in_windows
                                                        (MidoriSettings *self);
void                midori_settings_set_open_panels_in_windows
                                                        (MidoriSettings *self,
                                                         gboolean value);
gboolean            midori_settings_get_right_align_sidepanel
                                                        (MidoriSettings *self);
void                midori_settings_set_right_align_sidepanel
                                                        (MidoriSettings *self,
                                                         gboolean value);
gboolean            midori_settings_get_show_menubar    (MidoriSettings *self);
void                midori_settings_set_show_menubar    (MidoriSettings *self,
                                                         gboolean value);
gboolean            midori_settings_get_show_navigationbar
                                                        (MidoriSettings *self);
void                midori_settings_set_show_navigationbar
                                                        (MidoriSettings *self,
                                                         gboolean value);
gboolean            midori_settings_get_show_bookmarkbar
                                                        (MidoriSettings *self);
void                midori_settings_set_show_bookmarkbar
                                                        (MidoriSettings *self,
                                                         gboolean value);
gboolean            midori_settings_get_show_panel      (MidoriSettings *self);
void                midori_settings_set_show_panel      (MidoriSettings *self,
                                                         gboolean value);
gboolean            midori_settings_get_show_statusbar  (MidoriSettings *self);
void                midori_settings_set_show_statusbar  (MidoriSettings *self,
                                                         gboolean value);
gboolean            midori_settings_get_show_crash_dialog
                                                        (MidoriSettings *self);
void                midori_settings_set_show_crash_dialog
                                                        (MidoriSettings *self,
                                                         gboolean value);
const gchar *       midori_settings_get_toolbar_items   (MidoriSettings *self);
void                midori_settings_set_toolbar_items   (MidoriSettings *self,
                                                         const gchar *value);
gboolean            midori_settings_get_find_while_typing
                                                        (MidoriSettings *self);
void                midori_settings_set_find_while_typing
                                                        (MidoriSettings *self,
                                                         gboolean value);
gdouble             midori_settings_get_zoom_level      (MidoriSettings *self);
void                midori_settings_set_zoom_level      (MidoriSettings *self,
                                                         gdouble value);
gboolean            midori_settings_get_open_popups_in_tabs
                                                        (MidoriSettings *self);
void                midori_settings_set_open_popups_in_tabs
                                                        (MidoriSettings *self,
                                                         gboolean value);
gboolean            midori_settings_get_kinetic_scrolling
                                                        (MidoriSettings *self);
void                midori_settings_set_kinetic_scrolling
                                                        (MidoriSettings *self,
                                                         gboolean value);
gboolean            midori_settings_get_middle_click_opens_selection
                                                        (MidoriSettings *self);
void                midori_settings_set_middle_click_opens_selection
                                                        (MidoriSettings *self,
                                                         gboolean value);
gboolean            midori_settings_get_flash_window_on_new_bg_tabs
                                                        (MidoriSettings *self);
void                midori_settings_set_flash_window_on_new_bg_tabs
                                                        (MidoriSettings *self,
                                                         gboolean value);
gboolean            midori_settings_get_close_buttons_on_tabs
                                                        (MidoriSettings *self);
void                midori_settings_set_close_buttons_on_tabs
                                                        (MidoriSettings *self,
                                                         gboolean value);
gboolean            midori_settings_get_open_tabs_in_the_background
                                                        (MidoriSettings *self);
void                midori_settings_set_open_tabs_in_the_background
                                                        (MidoriSettings *self,
                                                         gboolean value);
gboolean            midori_settings_get_open_tabs_next_to_current
                                                        (MidoriSettings *self);
void                midori_settings_set_open_tabs_next_to_current
                                                        (MidoriSettings *self,
                                                         gboolean value);
gboolean            midori_settings_get_always_show_tabbar
                                                        (MidoriSettings *self);
void                midori_settings_set_always_show_tabbar
                                                        (MidoriSettings *self,
                                                         gboolean value);
const gchar *       midori_settings_get_homepage        (MidoriSettings *self);
void                midori_settings_set_homepage        (MidoriSettings *self,
                                                         const gchar *value);
const gchar *       midori_settings_get_tabhome         (MidoriSettings *self);
void                midori_settings_set_tabhome         (MidoriSettings *self,
                                                         const gchar *value);
const gchar *       midori_settings_get_download_folder (MidoriSettings *self);
void                midori_settings_set_download_folder (MidoriSettings *self,
                                                         const gchar *value);
const gchar *       midori_settings_get_text_editor     (MidoriSettings *self);
void                midori_settings_set_text_editor     (MidoriSettings *self,
                                                         const gchar *value);
const gchar *       midori_settings_get_news_aggregator (MidoriSettings *self);
void                midori_settings_set_news_aggregator (MidoriSettings *self,
                                                         const gchar *value);
const gchar *       midori_settings_get_http_proxy      (MidoriSettings *self);
void                midori_settings_set_http_proxy      (MidoriSettings *self,
                                                         const gchar *value);
gint                midori_settings_get_http_proxy_port (MidoriSettings *self);
void                midori_settings_set_http_proxy_port (MidoriSettings *self,
                                                         gint value);
gint                midori_settings_get_maximum_cache_size
                                                        (MidoriSettings *self);
void                midori_settings_set_maximum_cache_size
                                                        (MidoriSettings *self,
                                                         gint value);
gboolean            midori_settings_get_strip_referer   (MidoriSettings *self);
void                midori_settings_set_strip_referer   (MidoriSettings *self,
                                                         gboolean value);
gboolean            midori_settings_get_first_party_cookies_only
                                                        (MidoriSettings *self);
void                midori_settings_set_first_party_cookies_only
                                                        (MidoriSettings *self,
                                                         gboolean value);
gint                midori_settings_get_maximum_cookie_age
                                                        (MidoriSettings *self);
void                midori_settings_set_maximum_cookie_age
                                                        (MidoriSettings *self,
                                                         gint value);
gint                midori_settings_get_maximum_history_age
                                                        (MidoriSettings *self);
void                midori_settings_set_maximum_history_age
                                                        (MidoriSettings *self,
                                                         gint value);
MidoriHistoryWebsite * midori_history_website_new       (const gchar *uri,
                                                         const gchar *title,
                                                         gint64 date);
MidoriHistoryWebsite * midori_history_website_construct (GType object_type,
                                                         const gchar *uri,
                                                         const gchar *title,
                                                         gint64 date);
const gchar *       midori_history_website_get_uri      (MidoriHistoryWebsite *self);
void                midori_history_website_set_uri      (MidoriHistoryWebsite *self,
                                                         const gchar *value);
MidoriHistorySearch * midori_history_search_new         (const gchar *uri,
                                                         const gchar *keywords,
                                                         gint64 date);
MidoriHistorySearch * midori_history_search_construct   (GType object_type,
                                                         const gchar *uri,
                                                         const gchar *keywords,
                                                         gint64 date);
const gchar *       midori_history_search_get_uri       (MidoriHistorySearch *self);
void                midori_history_search_set_uri       (MidoriHistorySearch *self,
                                                         const gchar *value);
const gchar *       midori_history_search_get_keywords  (MidoriHistorySearch *self);
void                midori_history_search_set_keywords  (MidoriHistorySearch *self,
                                                         const gchar *value);
MidoriHistoryItem * midori_history_item_new             (void);
MidoriHistoryItem * midori_history_item_construct       (GType object_type);
const gchar *       midori_history_item_get_title       (MidoriHistoryItem *self);
void                midori_history_item_set_title       (MidoriHistoryItem *self,
                                                         const gchar *value);
gint64              midori_history_item_get_date        (MidoriHistoryItem *self);
void                midori_history_item_set_date        (MidoriHistoryItem *self,
                                                         gint64 value);
MidoriHistoryDatabase * midori_history_database_new     (GObject *app,
                                                         GError **error);
MidoriHistoryDatabase * midori_history_database_construct
                                                        (GType object_type,
                                                         GObject *app,
                                                         GError **error);
void                midori_history_database_query       (MidoriHistoryDatabase *self,
                                                         const gchar *sqlcmd,
                                                         const gchar *filter,
                                                         gint64 day,
                                                         gint64 max_items,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);
GList *             midori_history_database_query_finish
                                                        (MidoriHistoryDatabase *self,
                                                         GAsyncResult *_res_);
void                midori_history_database_list_by_count_with_bookmarks
                                                        (MidoriHistoryDatabase *self,
                                                         const gchar *filter,
                                                         gint max_items,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);
GList *             midori_history_database_list_by_count_with_bookmarks_finish
                                                        (MidoriHistoryDatabase *self,
                                                         GAsyncResult *_res_);
gboolean            midori_history_database_insert      (MidoriHistoryDatabase *self,
                                                         const gchar *uri,
                                                         const gchar *title,
                                                         gint64 date,
                                                         gint64 day,
                                                         GError **error);
gboolean            midori_history_database_clear       (MidoriHistoryDatabase *self,
                                                         gint64 maximum_age,
                                                         GError **error);
gboolean            midori_tab_is_blank                 (MidoriTab *self);
void                midori_tab_inject_stylesheet        (MidoriTab *self,
                                                         const gchar *stylesheet);
gboolean            midori_tab_can_view_source          (MidoriTab *self);
gchar *             midori_tab_get_display_title        (const gchar *title,
                                                         const gchar *uri);
PangoEllipsizeMode  midori_tab_get_display_ellipsize    (const gchar *title,
                                                         const gchar *uri);
gboolean            midori_tab_can_save                 (MidoriTab *self);
void                midori_tab_stop_loading             (MidoriTab *self);
gboolean            midori_tab_can_go_forward           (MidoriTab *self);
void                midori_tab_go_forward               (MidoriTab *self);
void                midori_tab_unmark_text_matches      (MidoriTab *self);
gboolean            midori_tab_find                     (MidoriTab *self,
                                                         const gchar *text,
                                                         gboolean case_sensitive,
                                                         gboolean forward);
void                midori_tab_update_actions           (MidoriTab *self,
                                                         GtkActionGroup *actions,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);
void                midori_tab_update_actions_finish    (MidoriTab *self,
                                                         GAsyncResult *_res_);
MidoriTab *         midori_tab_new                      (void);
MidoriTab *         midori_tab_construct                (GType object_type);
MidoriTab *         midori_tab_get_related              (MidoriTab *self);
void                midori_tab_set_related              (MidoriTab *self,
                                                         MidoriTab *value);
WebKitWebView *     midori_tab_get_web_view             (MidoriTab *self);
const gchar *       midori_tab_get_uri                  (MidoriTab *self);
void                midori_tab_set_uri                  (MidoriTab *self,
                                                         const gchar *value);
gboolean            midori_tab_get_special              (MidoriTab *self);
void                midori_tab_set_special              (MidoriTab *self,
                                                         gboolean value);
gboolean            midori_tab_get_minimized            (MidoriTab *self);
void                midori_tab_set_minimized            (MidoriTab *self,
                                                         gboolean value);
const gchar *       midori_tab_get_mime_type            (MidoriTab *self);
void                midori_tab_set_mime_type            (MidoriTab *self,
                                                         const gchar *value);
MidoriSecurity      midori_tab_get_security             (MidoriTab *self);
void                midori_tab_set_security             (MidoriTab *self,
                                                         MidoriSecurity value);
MidoriLoadStatus    midori_tab_get_load_status          (MidoriTab *self);
void                midori_tab_set_load_status          (MidoriTab *self,
                                                         MidoriLoadStatus value);
MidoriLoadError     midori_tab_get_load_error           (MidoriTab *self);
void                midori_tab_set_load_error           (MidoriTab *self,
                                                         MidoriLoadError value);
const gchar *       midori_tab_get_statusbar_text       (MidoriTab *self);
void                midori_tab_set_statusbar_text       (MidoriTab *self,
                                                         const gchar *value);
GdkColor *          midori_tab_get_fg_color             (MidoriTab *self);
void                midori_tab_set_fg_color             (MidoriTab *self,
                                                         GdkColor *value);
GdkColor *          midori_tab_get_bg_color             (MidoriTab *self);
void                midori_tab_set_bg_color             (MidoriTab *self,
                                                         GdkColor *value);
gdouble             midori_tab_get_progress             (MidoriTab *self);
void                midori_tab_set_progress             (MidoriTab *self,
                                                         gdouble value);
gboolean            midori_tab_get_is_dialog            (MidoriTab *self);
void                midori_tab_set_is_dialog            (MidoriTab *self,
                                                         gboolean value);
gboolean            midori_tab_get_view_source          (MidoriTab *self);
void                midori_tab_set_view_source          (MidoriTab *self,
                                                         gboolean value);
MidoriTally *       midori_tally_new                    (MidoriTab *tab);
MidoriTally *       midori_tally_construct              (GType object_type,
                                                         MidoriTab *tab);
MidoriTab *         midori_tally_get_tab                (MidoriTally *self);
void                midori_tally_set_tab                (MidoriTally *self,
                                                         MidoriTab *value);
gboolean            midori_tally_get_close_button_left  (MidoriTally *self);
void                midori_tally_set_close_button_left  (MidoriTally *self,
                                                         gboolean value);
gboolean            midori_tally_get_close_button_visible
                                                        (MidoriTally *self);
void                midori_tally_set_close_button_visible
                                                        (MidoriTally *self,
                                                         gboolean value);
GtkWidget *         midori_notebook_new                 (void);
GtkWidget *         midori_notebook_construct           (GType object_type);
MidoriContextAction * midori_notebook_get_context_action
                                                        (MidoriNotebook *self);
void                midori_notebook_insert              (MidoriNotebook *self,
                                                         MidoriTab *tab,
                                                         gint index);
MidoriContextAction * midori_notebook_get_tab_context_action
                                                        (MidoriNotebook *self,
                                                         MidoriTab *tab);
void                midori_notebook_move                (MidoriNotebook *self,
                                                         MidoriTab *tab,
                                                         gint index);
void                midori_notebook_remove              (MidoriNotebook *self,
                                                         MidoriTab *tab);
MidoriTab *         midori_notebook_get_nth_tab         (MidoriNotebook *self,
                                                         gint index);
gint                midori_notebook_get_tab_index       (MidoriNotebook *self,
                                                         MidoriTab *tab);
guint               midori_notebook_get_count           (MidoriNotebook *self);
gint                midori_notebook_get_index           (MidoriNotebook *self);
void                midori_notebook_set_index           (MidoriNotebook *self,
                                                         gint value);
MidoriTab *         midori_notebook_get_tab             (MidoriNotebook *self);
void                midori_notebook_set_tab             (MidoriNotebook *self,
                                                         MidoriTab *value);
gboolean            midori_notebook_get_close_buttons_left
                                                        (MidoriNotebook *self);
void                midori_notebook_set_close_buttons_left
                                                        (MidoriNotebook *self,
                                                         gboolean value);
gboolean            midori_notebook_get_close_buttons_visible
                                                        (MidoriNotebook *self);
void                midori_notebook_set_close_buttons_visible
                                                        (MidoriNotebook *self,
                                                         gboolean value);
gboolean            midori_notebook_get_labels_visible  (MidoriNotebook *self);
void                midori_notebook_set_labels_visible  (MidoriNotebook *self,
                                                         gboolean value);
MidoriViewCompletion * midori_view_completion_new       (void);
MidoriViewCompletion * midori_view_completion_construct (GType object_type);
                    MidoriBookmarksDatabasePrivate;
                    MidoriSearchCompletionPrivate;
                    MidoriCompletionPrivate;
                    MidoriViewCompletionPrivate;
                    MidoriContextActionPrivate;
                    MidoriDatabasePrivate;

Description

Details

MIDORI_AUTOCOMPLETER_TYPE_COLUMNS

#define MIDORI_AUTOCOMPLETER_TYPE_COLUMNS (midori_autocompleter_columns_get_type ())

struct KatzeSeparatorAction

struct KatzeSeparatorAction {
	GtkAction parent_instance;
	KatzeSeparatorActionPrivate * priv;
};

struct KatzeSeparatorActionClass

struct KatzeSeparatorActionClass {
	GtkActionClass parent_class;
};

struct MidoriHSTS

struct MidoriHSTS {
	GObject parent_instance;
	MidoriHSTSPrivate * priv;
};

struct MidoriHSTSClass

struct MidoriHSTSClass {
	GObjectClass parent_class;
};

struct MidoriHSTSDirective

struct MidoriHSTSDirective {
	GTypeInstance parent_instance;
	volatile int ref_count;
	MidoriHSTSDirectivePrivate * priv;
	SoupDate* expires;
	gboolean sub_domains;
};

struct MidoriHSTSDirectiveClass

struct MidoriHSTSDirectiveClass {
	GTypeClass parent_class;
	void (*finalize) (MidoriHSTSDirective *self);
};

enum MidoriRuntimeMode

typedef enum {
	MIDORI_RUNTIME_MODE_UNDEFINED,
	MIDORI_RUNTIME_MODE_NORMAL,
	MIDORI_RUNTIME_MODE_APP,
	MIDORI_RUNTIME_MODE_PRIVATE,
	MIDORI_RUNTIME_MODE_PORTABLE
} MidoriRuntimeMode;

MIDORI_RUNTIME_MODE_UNDEFINED

MIDORI_RUNTIME_MODE_NORMAL

MIDORI_RUNTIME_MODE_APP

MIDORI_RUNTIME_MODE_PRIVATE

MIDORI_RUNTIME_MODE_PORTABLE


struct MidoriURI

struct MidoriURI {
	GObject parent_instance;
	MidoriURIPrivate * priv;
};

struct MidoriURIClass

struct MidoriURIClass {
	GObjectClass parent_class;
};

struct MidoriURIIcon

struct MidoriURIIcon {
	GInitiallyUnowned parent_instance;
	MidoriURIIconPrivate * priv;
};

struct MidoriURIIconClass

struct MidoriURIIconClass {
	GInitiallyUnownedClass parent_class;
};

enum MidoriDatabaseError

typedef enum {
	MIDORI_DATABASE_ERROR_OPEN,
	MIDORI_DATABASE_ERROR_NAMING,
	MIDORI_DATABASE_ERROR_FILENAME,
	MIDORI_DATABASE_ERROR_EXECUTE,
	MIDORI_DATABASE_ERROR_COMPILE,
	MIDORI_DATABASE_ERROR_TYPE
} MidoriDatabaseError;

MIDORI_DATABASE_ERROR_OPEN

MIDORI_DATABASE_ERROR_NAMING

MIDORI_DATABASE_ERROR_FILENAME

MIDORI_DATABASE_ERROR_EXECUTE

MIDORI_DATABASE_ERROR_COMPILE

MIDORI_DATABASE_ERROR_TYPE


MIDORI_DATABASE_ERROR

#define MIDORI_DATABASE_ERROR midori_database_error_quark ()

struct MidoriDatabase

struct MidoriDatabase {
	GObject parent_instance;
	MidoriDatabasePrivate * priv;
	gboolean trace;
	sqlite3* _db;
};

struct MidoriDatabaseClass

struct MidoriDatabaseClass {
	GObjectClass parent_class;
	gboolean (*init) (MidoriDatabase* self, GCancellable* cancellable, GError** error);
};

struct MidoriBookmarksDatabase

struct MidoriBookmarksDatabase {
	MidoriDatabase parent_instance;
	MidoriBookmarksDatabasePrivate * priv;
};

struct MidoriBookmarksDatabaseClass

struct MidoriBookmarksDatabaseClass {
	MidoriDatabaseClass parent_class;
};

struct MidoriTestJob

struct MidoriTestJob {
	GObject parent_instance;
	MidoriTestJobPrivate * priv;
};

struct MidoriTestJobClass

struct MidoriTestJobClass {
	GObjectClass parent_class;
	void (*run) (MidoriTestJob* self, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
	void (*run_finish) (MidoriTestJob* self, GAsyncResult* _res_, GError** error);
};

struct MidoriFileChooserDialog

struct MidoriFileChooserDialog {
	GtkFileChooserDialog parent_instance;
	MidoriFileChooserDialogPrivate * priv;
};

struct MidoriFileChooserDialogClass

struct MidoriFileChooserDialogClass {
	GtkFileChooserDialogClass parent_class;
};

struct MidoriCompletion

struct MidoriCompletion {
	GObject parent_instance;
	MidoriCompletionPrivate * priv;
};

struct MidoriCompletionClass

struct MidoriCompletionClass {
	GObjectClass parent_class;
	void (*prepare) (MidoriCompletion* self, GObject* app);
	gboolean (*can_complete) (MidoriCompletion* self, const gchar* prefix);
	gboolean (*can_action) (MidoriCompletion* self, const gchar* action);
	void (*complete) (MidoriCompletion* self, const gchar* text, const gchar* action, GCancellable* cancellable, GAsyncReadyCallback _callback_, gpointer _user_data_);
	GList* (*complete_finish) (MidoriCompletion* self, GAsyncResult* _res_);
};

struct MidoriSearchCompletion

struct MidoriSearchCompletion {
	MidoriCompletion parent_instance;
	MidoriSearchCompletionPrivate * priv;
};

struct MidoriSearchCompletionClass

struct MidoriSearchCompletionClass {
	MidoriCompletionClass parent_class;
};

struct MidoriHistoryCompletion

struct MidoriHistoryCompletion {
	MidoriCompletion parent_instance;
	MidoriHistoryCompletionPrivate * priv;
};

struct MidoriHistoryCompletionClass

struct MidoriHistoryCompletionClass {
	MidoriCompletionClass parent_class;
};

enum MidoriSpeedDialError

typedef enum {
	MIDORI_SPEED_DIAL_ERROR_INVALID_MESSAGE,
	MIDORI_SPEED_DIAL_ERROR_NO_ACTION,
	MIDORI_SPEED_DIAL_ERROR_NO_ID,
	MIDORI_SPEED_DIAL_ERROR_NO_URL,
	MIDORI_SPEED_DIAL_ERROR_NO_TITLE,
	MIDORI_SPEED_DIAL_ERROR_NO_ID2,
	MIDORI_SPEED_DIAL_ERROR_INVALID_ACTION
} MidoriSpeedDialError;

MIDORI_SPEED_DIAL_ERROR_INVALID_MESSAGE

MIDORI_SPEED_DIAL_ERROR_NO_ACTION

MIDORI_SPEED_DIAL_ERROR_NO_ID

MIDORI_SPEED_DIAL_ERROR_NO_URL

MIDORI_SPEED_DIAL_ERROR_NO_TITLE

MIDORI_SPEED_DIAL_ERROR_NO_ID2

MIDORI_SPEED_DIAL_ERROR_INVALID_ACTION


MIDORI_SPEED_DIAL_ERROR

#define MIDORI_SPEED_DIAL_ERROR midori_speed_dial_error_quark ()

struct MidoriSpeedDial

struct MidoriSpeedDial {
	GObject parent_instance;
	MidoriSpeedDialPrivate * priv;
	GKeyFile* keyfile;
};

struct MidoriSpeedDialClass

struct MidoriSpeedDialClass {
	GObjectClass parent_class;
};

struct MidoriSpeedDialSpec

struct MidoriSpeedDialSpec {
	GTypeInstance parent_instance;
	volatile int ref_count;
	MidoriSpeedDialSpecPrivate * priv;
	gchar* dial_id;
	gchar* uri;
};

struct MidoriSpeedDialSpecClass

struct MidoriSpeedDialSpecClass {
	GTypeClass parent_class;
	void (*finalize) (MidoriSpeedDialSpec *self);
};

struct MidoriContextAction

struct MidoriContextAction {
	GtkAction parent_instance;
	MidoriContextActionPrivate * priv;
};

struct MidoriContextActionClass

struct MidoriContextActionClass {
	GtkActionClass parent_class;
};

MidoriContextActionActionActivateCallback ()

void                (*MidoriContextActionActionActivateCallback)
                                                        (GtkAction *action,
                                                         void *user_data);

struct MidoriSeparatorContextAction

struct MidoriSeparatorContextAction {
	MidoriContextAction parent_instance;
	MidoriSeparatorContextActionPrivate * priv;
};

struct MidoriSeparatorContextActionClass

struct MidoriSeparatorContextActionClass {
	MidoriContextActionClass parent_class;
};

MidoriDatabaseCallback ()

gboolean            (*MidoriDatabaseCallback)           (void *user_data,
                                                         GError **error);

struct MidoriDatabaseStatement

struct MidoriDatabaseStatement {
	GObject parent_instance;
	MidoriDatabaseStatementPrivate * priv;
	sqlite3_stmt* _stmt;
};

struct MidoriDatabaseStatementClass

struct MidoriDatabaseStatementClass {
	GObjectClass parent_class;
	gboolean (*init) (MidoriDatabaseStatement* self, GCancellable* cancellable, GError** error);
};

struct MidoriPanedAction

struct MidoriPanedAction {
	GtkAction parent_instance;
	MidoriPanedActionPrivate * priv;
};

struct MidoriPanedActionClass

struct MidoriPanedActionClass {
	GtkActionClass parent_class;
};

struct MidoriViewableIface

struct MidoriViewableIface {
	GTypeInterface parent_iface;
	const gchar* (*get_stock_id) (MidoriViewable* self);
	const gchar* (*get_label) (MidoriViewable* self);
	GtkWidget* (*get_toolbar) (MidoriViewable* self);
};

struct MidoriExtensionsColumn

struct MidoriExtensionsColumn {
	GtkTreeViewColumn parent_instance;
	MidoriExtensionsColumnPrivate * priv;
};

struct MidoriExtensionsColumnClass

struct MidoriExtensionsColumnClass {
	GtkTreeViewColumnClass parent_class;
};

struct MidoriSuggestion

struct MidoriSuggestion {
	GObject parent_instance;
	MidoriSuggestionPrivate * priv;
};

struct MidoriSuggestionClass

struct MidoriSuggestionClass {
	GObjectClass parent_class;
};

struct MidoriAutocompleter

struct MidoriAutocompleter {
	GObject parent_instance;
	MidoriAutocompleterPrivate * priv;
};

struct MidoriAutocompleterClass

struct MidoriAutocompleterClass {
	GObjectClass parent_class;
};

enum MidoriAutocompleterColumns

typedef enum {
	MIDORI_AUTOCOMPLETER_COLUMNS_ICON,
	MIDORI_AUTOCOMPLETER_COLUMNS_URI,
	MIDORI_AUTOCOMPLETER_COLUMNS_MARKUP,
	MIDORI_AUTOCOMPLETER_COLUMNS_BACKGROUND,
	MIDORI_AUTOCOMPLETER_COLUMNS_YALIGN,
	MIDORI_AUTOCOMPLETER_COLUMNS_SIZE,
	MIDORI_AUTOCOMPLETER_COLUMNS_PRIORITY,
	MIDORI_AUTOCOMPLETER_COLUMNS_N
} MidoriAutocompleterColumns;

MIDORI_AUTOCOMPLETER_COLUMNS_ICON

MIDORI_AUTOCOMPLETER_COLUMNS_URI

MIDORI_AUTOCOMPLETER_COLUMNS_MARKUP

MIDORI_AUTOCOMPLETER_COLUMNS_BACKGROUND

MIDORI_AUTOCOMPLETER_COLUMNS_YALIGN

MIDORI_AUTOCOMPLETER_COLUMNS_SIZE

MIDORI_AUTOCOMPLETER_COLUMNS_PRIORITY

MIDORI_AUTOCOMPLETER_COLUMNS_N


enum MidoriWindowState

typedef enum {
	MIDORI_WINDOW_NORMAL,
	MIDORI_WINDOW_MINIMIZED,
	MIDORI_WINDOW_MAXIMIZED,
	MIDORI_WINDOW_FULLSCREEN
} MidoriWindowState;

MIDORI_WINDOW_NORMAL

MIDORI_WINDOW_MINIMIZED

MIDORI_WINDOW_MAXIMIZED

MIDORI_WINDOW_FULLSCREEN


struct MidoriSettings

struct MidoriSettings {
	WebKitWebSettings parent_instance;
	MidoriSettingsPrivate * priv;
};

struct MidoriSettingsClass

struct MidoriSettingsClass {
	WebKitWebSettingsClass parent_class;
};

struct MidoriHistoryItem

struct MidoriHistoryItem {
	GObject parent_instance;
	MidoriHistoryItemPrivate * priv;
};

struct MidoriHistoryItemClass

struct MidoriHistoryItemClass {
	GObjectClass parent_class;
};

struct MidoriHistoryWebsite

struct MidoriHistoryWebsite {
	MidoriHistoryItem parent_instance;
	MidoriHistoryWebsitePrivate * priv;
};

struct MidoriHistoryWebsiteClass

struct MidoriHistoryWebsiteClass {
	MidoriHistoryItemClass parent_class;
};

struct MidoriHistorySearch

struct MidoriHistorySearch {
	MidoriHistoryItem parent_instance;
	MidoriHistorySearchPrivate * priv;
};

struct MidoriHistorySearchClass

struct MidoriHistorySearchClass {
	MidoriHistoryItemClass parent_class;
};

struct MidoriHistoryDatabase

struct MidoriHistoryDatabase {
	MidoriDatabase parent_instance;
	MidoriHistoryDatabasePrivate * priv;
};

struct MidoriHistoryDatabaseClass

struct MidoriHistoryDatabaseClass {
	MidoriDatabaseClass parent_class;
};

enum MidoriNewView

typedef enum {
	MIDORI_NEW_VIEW_TAB,
	MIDORI_NEW_VIEW_BACKGROUND,
	MIDORI_NEW_VIEW_WINDOW
} MidoriNewView;

MIDORI_NEW_VIEW_TAB

MIDORI_NEW_VIEW_BACKGROUND

MIDORI_NEW_VIEW_WINDOW


enum MidoriSecurity

typedef enum {
	MIDORI_SECURITY_NONE,
	MIDORI_SECURITY_UNKNOWN,
	MIDORI_SECURITY_TRUSTED
} MidoriSecurity;

MIDORI_SECURITY_NONE

MIDORI_SECURITY_UNKNOWN

MIDORI_SECURITY_TRUSTED


enum MidoriLoadStatus

typedef enum {
	MIDORI_LOAD_FINISHED,
	MIDORI_LOAD_COMMITTED,
	MIDORI_LOAD_PROVISIONAL
} MidoriLoadStatus;

MIDORI_LOAD_FINISHED

MIDORI_LOAD_COMMITTED

MIDORI_LOAD_PROVISIONAL


enum MidoriLoadError

typedef enum {
	MIDORI_LOAD_ERROR_NONE,
	MIDORI_LOAD_ERROR_DELAYED,
	MIDORI_LOAD_ERROR_SECURITY,
	MIDORI_LOAD_ERROR_CRASH,
	MIDORI_LOAD_ERROR_NETWORK
} MidoriLoadError;

MIDORI_LOAD_ERROR_NONE

MIDORI_LOAD_ERROR_DELAYED

MIDORI_LOAD_ERROR_SECURITY

MIDORI_LOAD_ERROR_CRASH

MIDORI_LOAD_ERROR_NETWORK


struct MidoriTab

struct MidoriTab {
	GtkVBox parent_instance;
	MidoriTabPrivate * priv;
};

struct MidoriTabClass

struct MidoriTabClass {
	GtkVBoxClass parent_class;
};

struct MidoriTally

struct MidoriTally {
	GtkEventBox parent_instance;
	MidoriTallyPrivate * priv;
	GtkLabel* label;
	GtkImage* icon;
};

struct MidoriTallyClass

struct MidoriTallyClass {
	GtkEventBoxClass parent_class;
};

struct MidoriNotebook

struct MidoriNotebook {
	GtkEventBox parent_instance;
	MidoriNotebookPrivate * priv;
	GtkNotebook* notebook;
};

struct MidoriNotebookClass

struct MidoriNotebookClass {
	GtkEventBoxClass parent_class;
};

struct MidoriViewCompletion

struct MidoriViewCompletion {
	MidoriCompletion parent_instance;
	MidoriViewCompletionPrivate * priv;
};

struct MidoriViewCompletionClass

struct MidoriViewCompletionClass {
	MidoriCompletionClass parent_class;
};

katze_separator_action_new ()

KatzeSeparatorAction * katze_separator_action_new       (void);

katze_separator_action_construct ()

KatzeSeparatorAction * katze_separator_action_construct (GType object_type);

midori_hsts_new ()

MidoriHSTS *        midori_hsts_new                     (void);

midori_hsts_construct ()

MidoriHSTS *        midori_hsts_construct               (GType object_type);

midori_hsts_directive_ref ()

gpointer            midori_hsts_directive_ref           (gpointer instance);

midori_hsts_directive_unref ()

void                midori_hsts_directive_unref         (gpointer instance);

midori_hsts_param_spec_directive ()

GParamSpec *        midori_hsts_param_spec_directive    (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         GType object_type,
                                                         GParamFlags flags);

midori_hsts_value_set_directive ()

void                midori_hsts_value_set_directive     (GValue *value,
                                                         gpointer v_object);

midori_hsts_value_take_directive ()

void                midori_hsts_value_take_directive    (GValue *value,
                                                         gpointer v_object);

midori_hsts_value_get_directive ()

gpointer            midori_hsts_value_get_directive     (const GValue *value);

midori_hsts_directive_new ()

MidoriHSTSDirective * midori_hsts_directive_new         (gboolean include_sub_domains);

midori_hsts_directive_construct ()

MidoriHSTSDirective * midori_hsts_directive_construct   (GType object_type,
                                                         gboolean include_sub_domains);

midori_hsts_directive_new_from_header ()

MidoriHSTSDirective * midori_hsts_directive_new_from_header
                                                        (const gchar *header);

midori_hsts_directive_construct_from_header ()

MidoriHSTSDirective * midori_hsts_directive_construct_from_header
                                                        (GType object_type,
                                                         const gchar *header);

midori_hsts_directive_is_valid ()

gboolean            midori_hsts_directive_is_valid      (MidoriHSTSDirective *self);

midori_paths_test_reset_runtime_mode ()

void                midori_paths_test_reset_runtime_mode
                                                        (void);

midori_paths_get_config_dir_for_reading ()

gchar *             midori_paths_get_config_dir_for_reading
                                                        (void);

midori_paths_get_config_filename_for_reading ()

gchar *             midori_paths_get_config_filename_for_reading
                                                        (const gchar *filename);

midori_paths_is_readonly ()

gboolean            midori_paths_is_readonly            (void);

midori_paths_get_runtime_mode ()

MidoriRuntimeMode   midori_paths_get_runtime_mode       (void);

midori_paths_get_runtime_dir ()

const gchar *       midori_paths_get_runtime_dir        (void);

midori_paths_init ()

void                midori_paths_init                   (MidoriRuntimeMode new_mode,
                                                         const gchar *config);

midori_paths_mkdir_with_parents ()

void                midori_paths_mkdir_with_parents     (const gchar *path,
                                                         gint mode);

midori_paths_remove_path ()

void                midori_paths_remove_path            (const gchar *path);

midori_paths_get_config_dir_for_writing ()

const gchar *       midori_paths_get_config_dir_for_writing
                                                        (void);

midori_paths_get_extension_config_dir ()

gchar *             midori_paths_get_extension_config_dir
                                                        (const gchar *extension);

midori_paths_get_extension_preset_filename ()

gchar *             midori_paths_get_extension_preset_filename
                                                        (const gchar *extension,
                                                         const gchar *filename);

midori_paths_get_config_filename_for_writing ()

gchar *             midori_paths_get_config_filename_for_writing
                                                        (const gchar *filename);

midori_paths_get_cache_dir ()

const gchar *       midori_paths_get_cache_dir          (void);

midori_paths_get_user_data_dir ()

const gchar *       midori_paths_get_user_data_dir      (void);

midori_paths_get_user_data_dir_for_reading ()

const gchar *       midori_paths_get_user_data_dir_for_reading
                                                        (void);

midori_paths_get_cache_dir_for_reading ()

const gchar *       midori_paths_get_cache_dir_for_reading
                                                        (void);

midori_paths_get_tmp_dir ()

const gchar *       midori_paths_get_tmp_dir            (void);

midori_paths_make_tmp_dir ()

gchar *             midori_paths_make_tmp_dir           (const gchar *tmpl);

midori_paths_init_exec_path ()

void                midori_paths_init_exec_path         (gchar **new_command_line,
                                                         int new_command_line_length1);

midori_paths_get_command_line ()

gchar **            midori_paths_get_command_line       (int *result_length1);

midori_paths_get_command_line_str ()

gchar *             midori_paths_get_command_line_str   (gboolean for_display);

midori_paths_get_lib_path ()

gchar *             midori_paths_get_lib_path           (const gchar *package);

midori_paths_get_res_filename ()

gchar *             midori_paths_get_res_filename       (const gchar *filename);

midori_paths_get_data_filename ()

gchar *             midori_paths_get_data_filename      (const gchar *filename,
                                                         gboolean res);

midori_paths_get_preset_filename ()

gchar *             midori_paths_get_preset_filename    (const gchar *folder,
                                                         const gchar *filename);

midori_paths_clear_icons ()

void                midori_paths_clear_icons            (void);

midori_paths_get_icon ()

GdkPixbuf *         midori_paths_get_icon               (const gchar *uri,
                                                         GtkWidget *widget);

midori_uri_parse_hostname ()

gchar *             midori_uri_parse_hostname           (const gchar *uri,
                                                         gchar **path);

midori_uri_parse ()

gchar *             midori_uri_parse                    (const gchar *uri,
                                                         gchar **path);

midori_uri_to_ascii ()

gchar *             midori_uri_to_ascii                 (const gchar *uri);

midori_uri_get_base_domain ()

gchar *             midori_uri_get_base_domain          (const gchar *uri);

midori_uri_unescape ()

gchar *             midori_uri_unescape                 (const gchar *uri);

midori_uri_strip_prefix_for_display ()

gchar *             midori_uri_strip_prefix_for_display (const gchar *uri);

midori_uri_format_for_display ()

gchar *             midori_uri_format_for_display       (const gchar *uri);

midori_uri_for_search ()

gchar *             midori_uri_for_search               (const gchar *uri,
                                                         const gchar *keywords);

midori_uri_is_blank ()

gboolean            midori_uri_is_blank                 (const gchar *uri);

midori_uri_is_http ()

gboolean            midori_uri_is_http                  (const gchar *uri);

midori_uri_is_resource ()

gboolean            midori_uri_is_resource              (const gchar *uri);

midori_uri_is_location ()

gboolean            midori_uri_is_location              (const gchar *uri);

midori_uri_is_ip_address ()

gboolean            midori_uri_is_ip_address            (const gchar *uri);

midori_uri_is_valid ()

gboolean            midori_uri_is_valid                 (const gchar *uri);

midori_uri_get_folder ()

gchar *             midori_uri_get_folder               (const gchar *uri);

midori_uri_get_fingerprint ()

GChecksumType       midori_uri_get_fingerprint          (const gchar *uri,
                                                         gchar **checksum,
                                                         gchar **label);

midori_uri_recursive_fork_protection ()

gboolean            midori_uri_recursive_fork_protection
                                                        (const gchar *uri,
                                                         gboolean set_uri);

midori_uri_get_icon ()

void                midori_uri_get_icon                 (const gchar *uri,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);

midori_uri_get_icon_finish ()

GIcon *             midori_uri_get_icon_finish          (GAsyncResult *_res_,
                                                         GError **error);

midori_uri_get_icon_fallback ()

void                midori_uri_get_icon_fallback        (const gchar *uri,
                                                         GIcon *fallback,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);

midori_uri_get_icon_fallback_finish ()

GIcon *             midori_uri_get_icon_fallback_finish (GAsyncResult *_res_);

midori_uri_new ()

MidoriURI *         midori_uri_new                      (void);

midori_uri_construct ()

MidoriURI *         midori_uri_construct                (GType object_type);

midori_uri_icon_new ()

MidoriURIIcon *     midori_uri_icon_new                 (const gchar *website_uri,
                                                         GIcon *fallback);

midori_uri_icon_construct ()

MidoriURIIcon *     midori_uri_icon_construct           (GType object_type,
                                                         const gchar *website_uri,
                                                         GIcon *fallback);

midori_uri_icon_get_uri ()

const gchar *       midori_uri_icon_get_uri             (MidoriURIIcon *self);

midori_uri_icon_get_fallback ()

GIcon *             midori_uri_icon_get_fallback        (MidoriURIIcon *self);

midori_database_error_quark ()

GQuark              midori_database_error_quark         (void);

midori_bookmarks_database_new ()

MidoriBookmarksDatabase * midori_bookmarks_database_new (GError **error);

midori_bookmarks_database_construct ()

MidoriBookmarksDatabase * midori_bookmarks_database_construct
                                                        (GType object_type,
                                                         GError **error);

midori_bookmarks_database_preinit ()

void                midori_bookmarks_database_preinit   (MidoriBookmarksDatabase *self,
                                                         GError **error);

midori_timeout_add_seconds ()

guint               midori_timeout_add_seconds          (guint interval,
                                                         GSourceFunc function,
                                                         void *function_target,
                                                         GDestroyNotify function_target_destroy_notify);

midori_timeout_add ()

guint               midori_timeout_add                  (guint interval,
                                                         GSourceFunc function,
                                                         void *function_target,
                                                         GDestroyNotify function_target_destroy_notify);

midori_test_init ()

void                midori_test_init                    (int *args_length1,
                                                         gchar ***args);

midori_test_grab_max_timeout ()

void                midori_test_grab_max_timeout        (void);

midori_test_release_max_timeout ()

void                midori_test_release_max_timeout     (void);

midori_test_idle_timeouts ()

void                midori_test_idle_timeouts           (void);

midori_test_job_run ()

void                midori_test_job_run                 (MidoriTestJob *self,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);

midori_test_job_run_finish ()

void                midori_test_job_run_finish          (MidoriTestJob *self,
                                                         GAsyncResult *_res_,
                                                         GError **error);

midori_test_job_run_sync ()

void                midori_test_job_run_sync            (MidoriTestJob *self);

midori_test_job_construct ()

MidoriTestJob *     midori_test_job_construct           (GType object_type);

midori_test_log_set_fatal_handler_for_icons ()

void                midori_test_log_set_fatal_handler_for_icons
                                                        (void);

midori_test_set_dialog_response ()

void                midori_test_set_dialog_response     (GtkResponseType response);

midori_test_set_file_chooser_filename ()

void                midori_test_set_file_chooser_filename
                                                        (const gchar *filename);

midori_show_message_dialog ()

void                midori_show_message_dialog          (GtkMessageType type,
                                                         const gchar *_short_,
                                                         const gchar *detailed,
                                                         gboolean modal);

midori_file_chooser_dialog_new ()

MidoriFileChooserDialog * midori_file_chooser_dialog_new
                                                        (const gchar *title,
                                                         GtkWindow *window,
                                                         GtkFileChooserAction action);

midori_file_chooser_dialog_construct ()

MidoriFileChooserDialog * midori_file_chooser_dialog_construct
                                                        (GType object_type,
                                                         const gchar *title,
                                                         GtkWindow *window,
                                                         GtkFileChooserAction action);

midori_dialog_run ()

gint                midori_dialog_run                   (GtkDialog *dialog);

midori_download_is_finished ()

gboolean            midori_download_is_finished         (WebKitDownload *download);

midori_download_set_type ()

void                midori_download_set_type            (WebKitDownload *download,
                                                         gint type);

midori_download_get_progress ()

gdouble             midori_download_get_progress        (WebKitDownload *download);

midori_download_get_tooltip ()

gchar *             midori_download_get_tooltip         (WebKitDownload *download);

midori_download_get_content_type ()

gchar *             midori_download_get_content_type    (WebKitDownload *download,
                                                         const gchar *mime_type);

midori_download_has_wrong_checksum ()

gboolean            midori_download_has_wrong_checksum  (WebKitDownload *download);

midori_download_action_clear ()

gboolean            midori_download_action_clear        (WebKitDownload *download,
                                                         GtkWidget *widget,
                                                         GError **error);

midori_download_action_stock_id ()

gchar *             midori_download_action_stock_id     (WebKitDownload *download);

midori_download_open ()

gboolean            midori_download_open                (WebKitDownload *download,
                                                         GtkWidget *widget,
                                                         GError **error);

midori_download_fallback_extension ()

const gchar *       midori_download_fallback_extension  (const gchar *extension,
                                                         const gchar *mime_type);

midori_download_clean_filename ()

gchar *             midori_download_clean_filename      (const gchar *filename);

midori_download_get_suggested_filename ()

gchar *             midori_download_get_suggested_filename
                                                        (WebKitDownload *download);

midori_download_get_filename_suggestion_for_uri ()

gchar *             midori_download_get_filename_suggestion_for_uri
                                                        (const gchar *mime_type,
                                                         const gchar *uri);

midori_download_get_extension_for_uri ()

gchar *             midori_download_get_extension_for_uri
                                                        (const gchar *uri,
                                                         gchar **basename);

midori_download_get_unique_filename ()

gchar *             midori_download_get_unique_filename (const gchar *filename);

midori_download_get_basename_for_display ()

gchar *             midori_download_get_basename_for_display
                                                        (const gchar *uri);

midori_download_prepare_destination_uri ()

gchar *             midori_download_prepare_destination_uri
                                                        (WebKitDownload *download,
                                                         const gchar *folder);

midori_download_has_enough_space ()

gboolean            midori_download_has_enough_space    (WebKitDownload *download,
                                                         const gchar *destination_uri,
                                                         gboolean quiet);

midori_search_completion_new ()

MidoriSearchCompletion * midori_search_completion_new   (void);

midori_search_completion_construct ()

MidoriSearchCompletion * midori_search_completion_construct
                                                        (GType object_type);

midori_history_completion_new ()

MidoriHistoryCompletion * midori_history_completion_new (void);

midori_history_completion_construct ()

MidoriHistoryCompletion * midori_history_completion_construct
                                                        (GType object_type);

midori_speed_dial_error_quark ()

GQuark              midori_speed_dial_error_quark       (void);

midori_speed_dial_new ()

MidoriSpeedDial *   midori_speed_dial_new               (const gchar *new_filename,
                                                         const gchar *fallback);

midori_speed_dial_construct ()

MidoriSpeedDial *   midori_speed_dial_construct         (GType object_type,
                                                         const gchar *new_filename,
                                                         const gchar *fallback);

midori_speed_dial_get_next_free_slot ()

gchar *             midori_speed_dial_get_next_free_slot
                                                        (MidoriSpeedDial *self,
                                                         guint *count);

midori_speed_dial_add ()

void                midori_speed_dial_add               (MidoriSpeedDial *self,
                                                         const gchar *uri,
                                                         const gchar *title,
                                                         GdkPixbuf *img);

midori_speed_dial_add_with_id ()

void                midori_speed_dial_add_with_id       (MidoriSpeedDial *self,
                                                         const gchar *id,
                                                         const gchar *uri,
                                                         const gchar *title,
                                                         GdkPixbuf *img);

midori_speed_dial_get_html ()

const gchar *       midori_speed_dial_get_html          (MidoriSpeedDial *self,
                                                         GError **error);

midori_speed_dial_save_message ()

void                midori_speed_dial_save_message      (MidoriSpeedDial *self,
                                                         const gchar *message,
                                                         GError **error);

midori_speed_dial_get_close_buttons_left ()

gboolean            midori_speed_dial_get_close_buttons_left
                                                        (MidoriSpeedDial *self);

midori_speed_dial_set_close_buttons_left ()

void                midori_speed_dial_set_close_buttons_left
                                                        (MidoriSpeedDial *self,
                                                         gboolean value);

midori_speed_dial_spec_ref ()

gpointer            midori_speed_dial_spec_ref          (gpointer instance);

midori_speed_dial_spec_unref ()

void                midori_speed_dial_spec_unref        (gpointer instance);

midori_speed_dial_param_spec_spec ()

GParamSpec *        midori_speed_dial_param_spec_spec   (const gchar *name,
                                                         const gchar *nick,
                                                         const gchar *blurb,
                                                         GType object_type,
                                                         GParamFlags flags);

midori_speed_dial_value_set_spec ()

void                midori_speed_dial_value_set_spec    (GValue *value,
                                                         gpointer v_object);

midori_speed_dial_value_take_spec ()

void                midori_speed_dial_value_take_spec   (GValue *value,
                                                         gpointer v_object);

midori_speed_dial_value_get_spec ()

gpointer            midori_speed_dial_value_get_spec    (const GValue *value);

midori_speed_dial_spec_new ()

MidoriSpeedDialSpec * midori_speed_dial_spec_new        (const gchar *dial_id,
                                                         const gchar *uri);

midori_speed_dial_spec_construct ()

MidoriSpeedDialSpec * midori_speed_dial_spec_construct  (GType object_type,
                                                         const gchar *dial_id,
                                                         const gchar *uri);

midori_context_action_new ()

MidoriContextAction * midori_context_action_new         (const gchar *name,
                                                         const gchar *label,
                                                         const gchar *tooltip,
                                                         const gchar *stock_id);

midori_context_action_construct ()

MidoriContextAction * midori_context_action_construct   (GType object_type,
                                                         const gchar *name,
                                                         const gchar *label,
                                                         const gchar *tooltip,
                                                         const gchar *stock_id);

midori_context_action_new_escaped ()

MidoriContextAction * midori_context_action_new_escaped (const gchar *name,
                                                         const gchar *label,
                                                         const gchar *tooltip,
                                                         const gchar *stock_id);

midori_context_action_construct_escaped ()

MidoriContextAction * midori_context_action_construct_escaped
                                                        (GType object_type,
                                                         const gchar *name,
                                                         const gchar *label,
                                                         const gchar *tooltip,
                                                         const gchar *stock_id);

midori_context_action_add_simple ()

void                midori_context_action_add_simple    (MidoriContextAction *self,
                                                         const gchar *name,
                                                         const gchar *label,
                                                         const gchar *tooltip,
                                                         const gchar *stock_id,
                                                         MidoriContextActionActionActivateCallback callback,
                                                         void *callback_target);

midori_context_action_add ()

void                midori_context_action_add           (MidoriContextAction *self,
                                                         GtkAction *action);

midori_context_action_add_action_group ()

void                midori_context_action_add_action_group
                                                        (MidoriContextAction *self,
                                                         GtkActionGroup *action_group);

midori_context_action_add_by_name ()

void                midori_context_action_add_by_name   (MidoriContextAction *self,
                                                         const gchar *name);

midori_context_action_create_menu ()

GtkMenu *           midori_context_action_create_menu   (MidoriContextAction *self,
                                                         GtkMenu *default_menu,
                                                         gboolean accels);

midori_context_action_get_by_name ()

GtkAction *         midori_context_action_get_by_name   (MidoriContextAction *self,
                                                         const gchar *name);

midori_separator_context_action_new ()

MidoriSeparatorContextAction * midori_separator_context_action_new
                                                        (void);

midori_separator_context_action_construct ()

MidoriSeparatorContextAction * midori_separator_context_action_construct
                                                        (GType object_type);

midori_database_statement_new ()

MidoriDatabaseStatement * midori_database_statement_new (MidoriDatabase *database,
                                                         const gchar *query,
                                                         GError **error);

midori_database_statement_construct ()

MidoriDatabaseStatement * midori_database_statement_construct
                                                        (GType object_type,
                                                         MidoriDatabase *database,
                                                         const gchar *query,
                                                         GError **error);

midori_database_statement_init ()

gboolean            midori_database_statement_init      (MidoriDatabaseStatement *self,
                                                         GCancellable *cancellable,
                                                         GError **error);

midori_database_statement_bind ()

void                midori_database_statement_bind      (MidoriDatabaseStatement *self,
                                                         const gchar *pname,
                                                         GError **error,
                                                         ...);

midori_database_statement_exec ()

gboolean            midori_database_statement_exec      (MidoriDatabaseStatement *self,
                                                         GError **error);

midori_database_statement_step ()

gboolean            midori_database_statement_step      (MidoriDatabaseStatement *self,
                                                         GError **error);

midori_database_statement_row_id ()

gint64              midori_database_statement_row_id    (MidoriDatabaseStatement *self,
                                                         GError **error);

midori_database_statement_get_string ()

gchar *             midori_database_statement_get_string
                                                        (MidoriDatabaseStatement *self,
                                                         const gchar *name,
                                                         GError **error);

midori_database_statement_get_int64 ()

gint64              midori_database_statement_get_int64 (MidoriDatabaseStatement *self,
                                                         const gchar *name,
                                                         GError **error);

midori_database_statement_get_double ()

gdouble             midori_database_statement_get_double
                                                        (MidoriDatabaseStatement *self,
                                                         const gchar *name,
                                                         GError **error);

midori_database_statement_get_stmt ()

sqlite3_stmt *      midori_database_statement_get_stmt  (MidoriDatabaseStatement *self);

midori_database_statement_get_database ()

MidoriDatabase *    midori_database_statement_get_database
                                                        (MidoriDatabaseStatement *self);

midori_database_statement_set_database ()

void                midori_database_statement_set_database
                                                        (MidoriDatabaseStatement *self,
                                                         MidoriDatabase *value);

midori_database_statement_get_query ()

const gchar *       midori_database_statement_get_query (MidoriDatabaseStatement *self);

midori_database_statement_set_query ()

void                midori_database_statement_set_query (MidoriDatabaseStatement *self,
                                                         const gchar *value);

midori_database_new ()

MidoriDatabase *    midori_database_new                 (const gchar *path,
                                                         GError **error);

midori_database_construct ()

MidoriDatabase *    midori_database_construct           (GType object_type,
                                                         const gchar *path,
                                                         GError **error);

midori_database_init ()

gboolean            midori_database_init                (MidoriDatabase *self,
                                                         GCancellable *cancellable,
                                                         GError **error);

midori_database_attach ()

gboolean            midori_database_attach              (MidoriDatabase *self,
                                                         const gchar *path,
                                                         const gchar *alias,
                                                         GError **error);

midori_database_exec_script ()

gboolean            midori_database_exec_script         (MidoriDatabase *self,
                                                         const gchar *filename,
                                                         GError **error);

midori_database_transaction ()

gboolean            midori_database_transaction         (MidoriDatabase *self,
                                                         MidoriDatabaseCallback callback,
                                                         void *callback_target,
                                                         GError **error);

midori_database_exec ()

gboolean            midori_database_exec                (MidoriDatabase *self,
                                                         const gchar *query,
                                                         GError **error);

midori_database_prepare ()

MidoriDatabaseStatement * midori_database_prepare       (MidoriDatabase *self,
                                                         const gchar *query,
                                                         GError **error,
                                                         ...);

midori_database_get_db ()

sqlite3 *           midori_database_get_db              (MidoriDatabase *self);

midori_database_get_path ()

const gchar *       midori_database_get_path            (MidoriDatabase *self);

midori_database_set_path ()

void                midori_database_set_path            (MidoriDatabase *self,
                                                         const gchar *value);

midori_database_get_first_use ()

gboolean            midori_database_get_first_use       (MidoriDatabase *self);

midori_database_set_first_use ()

void                midori_database_set_first_use       (MidoriDatabase *self,
                                                         gboolean value);

midori_paned_action_set_child1 ()

void                midori_paned_action_set_child1      (MidoriPanedAction *self,
                                                         GtkWidget *widget,
                                                         const gchar *name,
                                                         gboolean resize,
                                                         gboolean shrink);

midori_paned_action_set_child2 ()

void                midori_paned_action_set_child2      (MidoriPanedAction *self,
                                                         GtkWidget *widget,
                                                         const gchar *name,
                                                         gboolean resize,
                                                         gboolean shrink);

midori_paned_action_get_child1 ()

GtkWidget *         midori_paned_action_get_child1      (MidoriPanedAction *self);

midori_paned_action_get_child2 ()

GtkWidget *         midori_paned_action_get_child2      (MidoriPanedAction *self);

midori_paned_action_get_child_by_name ()

GtkWidget *         midori_paned_action_get_child_by_name
                                                        (MidoriPanedAction *self,
                                                         const gchar *name);

midori_paned_action_get_child1_name ()

gchar *             midori_paned_action_get_child1_name (MidoriPanedAction *self);

midori_paned_action_get_child2_name ()

gchar *             midori_paned_action_get_child2_name (MidoriPanedAction *self);

midori_paned_action_new ()

MidoriPanedAction * midori_paned_action_new             (void);

midori_paned_action_construct ()

MidoriPanedAction * midori_paned_action_construct       (GType object_type);

midori_viewable_get_stock_id ()

const gchar *       midori_viewable_get_stock_id        (MidoriViewable *self);

midori_viewable_get_label ()

const gchar *       midori_viewable_get_label           (MidoriViewable *self);

midori_viewable_get_toolbar ()

GtkWidget *         midori_viewable_get_toolbar         (MidoriViewable *self);

midori_extensions_column_new ()

MidoriExtensionsColumn * midori_extensions_column_new   (void);

midori_extensions_column_construct ()

MidoriExtensionsColumn * midori_extensions_column_construct
                                                        (GType object_type);

midori_suggestion_new ()

MidoriSuggestion *  midori_suggestion_new               (const gchar *uri,
                                                         const gchar *markup,
                                                         gboolean use_markup,
                                                         const gchar *background,
                                                         GIcon *icon,
                                                         gint *priority);

midori_suggestion_construct ()

MidoriSuggestion *  midori_suggestion_construct         (GType object_type,
                                                         const gchar *uri,
                                                         const gchar *markup,
                                                         gboolean use_markup,
                                                         const gchar *background,
                                                         GIcon *icon,
                                                         gint *priority);

midori_suggestion_get_uri ()

const gchar *       midori_suggestion_get_uri           (MidoriSuggestion *self);

midori_suggestion_set_uri ()

void                midori_suggestion_set_uri           (MidoriSuggestion *self,
                                                         const gchar *value);

midori_suggestion_get_markup ()

const gchar *       midori_suggestion_get_markup        (MidoriSuggestion *self);

midori_suggestion_set_markup ()

void                midori_suggestion_set_markup        (MidoriSuggestion *self,
                                                         const gchar *value);

midori_suggestion_get_use_markup ()

gboolean            midori_suggestion_get_use_markup    (MidoriSuggestion *self);

midori_suggestion_set_use_markup ()

void                midori_suggestion_set_use_markup    (MidoriSuggestion *self,
                                                         gboolean value);

midori_suggestion_get_background ()

const gchar *       midori_suggestion_get_background    (MidoriSuggestion *self);

midori_suggestion_set_background ()

void                midori_suggestion_set_background    (MidoriSuggestion *self,
                                                         const gchar *value);

midori_suggestion_get_icon ()

GIcon *             midori_suggestion_get_icon          (MidoriSuggestion *self);

midori_suggestion_set_icon ()

void                midori_suggestion_set_icon          (MidoriSuggestion *self,
                                                         GIcon *value);

midori_suggestion_get_action ()

gboolean            midori_suggestion_get_action        (MidoriSuggestion *self);

midori_suggestion_set_action ()

void                midori_suggestion_set_action        (MidoriSuggestion *self,
                                                         gboolean value);

midori_suggestion_get_priority ()

gint                midori_suggestion_get_priority      (MidoriSuggestion *self);

midori_suggestion_set_priority ()

void                midori_suggestion_set_priority      (MidoriSuggestion *self,
                                                         gint value);

midori_completion_prepare ()

void                midori_completion_prepare           (MidoriCompletion *self,
                                                         GObject *app);

midori_completion_can_complete ()

gboolean            midori_completion_can_complete      (MidoriCompletion *self,
                                                         const gchar *prefix);

midori_completion_can_action ()

gboolean            midori_completion_can_action        (MidoriCompletion *self,
                                                         const gchar *action);

midori_completion_complete ()

void                midori_completion_complete          (MidoriCompletion *self,
                                                         const gchar *text,
                                                         const gchar *action,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);

midori_completion_complete_finish ()

GList *             midori_completion_complete_finish   (MidoriCompletion *self,
                                                         GAsyncResult *_res_);

midori_completion_construct ()

MidoriCompletion *  midori_completion_construct         (GType object_type);

midori_completion_get_description ()

const gchar *       midori_completion_get_description   (MidoriCompletion *self);

midori_completion_set_description ()

void                midori_completion_set_description   (MidoriCompletion *self,
                                                         const gchar *value);

midori_completion_get_max_items ()

gint                midori_completion_get_max_items     (MidoriCompletion *self);

midori_autocompleter_new ()

MidoriAutocompleter * midori_autocompleter_new          (GObject *app);

midori_autocompleter_construct ()

MidoriAutocompleter * midori_autocompleter_construct    (GType object_type,
                                                         GObject *app);

midori_autocompleter_add ()

void                midori_autocompleter_add            (MidoriAutocompleter *self,
                                                         MidoriCompletion *completion);

midori_autocompleter_can_complete ()

gboolean            midori_autocompleter_can_complete   (MidoriAutocompleter *self,
                                                         const gchar *text);

midori_autocompleter_complete ()

void                midori_autocompleter_complete       (MidoriAutocompleter *self,
                                                         const gchar *text,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);

midori_autocompleter_complete_finish ()

void                midori_autocompleter_complete_finish
                                                        (MidoriAutocompleter *self,
                                                         GAsyncResult *_res_);

midori_autocompleter_can_action ()

gboolean            midori_autocompleter_can_action     (MidoriAutocompleter *self,
                                                         const gchar *action);

midori_autocompleter_action ()

void                midori_autocompleter_action         (MidoriAutocompleter *self,
                                                         const gchar *action,
                                                         const gchar *text,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);

midori_autocompleter_action_finish ()

void                midori_autocompleter_action_finish  (MidoriAutocompleter *self,
                                                         GAsyncResult *_res_);

midori_autocompleter_get_model ()

GtkListStore *      midori_autocompleter_get_model      (MidoriAutocompleter *self);

midori_settings_delay_saving ()

gboolean            midori_settings_delay_saving        (MidoriSettings *self,
                                                         const gchar *property);

midori_settings_new ()

MidoriSettings *    midori_settings_new                 (void);

midori_settings_construct ()

MidoriSettings *    midori_settings_construct           (GType object_type);

midori_settings_get_enable_javascript ()

gboolean            midori_settings_get_enable_javascript
                                                        (MidoriSettings *self);

midori_settings_set_enable_javascript ()

void                midori_settings_set_enable_javascript
                                                        (MidoriSettings *self,
                                                         gboolean value);

midori_settings_get_default_charset ()

gchar *             midori_settings_get_default_charset (MidoriSettings *self);

midori_settings_set_default_charset ()

void                midori_settings_set_default_charset (MidoriSettings *self,
                                                         const gchar *value);

midori_settings_get_zoom_text_and_images ()

gboolean            midori_settings_get_zoom_text_and_images
                                                        (MidoriSettings *self);

midori_settings_set_zoom_text_and_images ()

void                midori_settings_set_zoom_text_and_images
                                                        (MidoriSettings *self,
                                                         gboolean value);

midori_settings_get_remember_last_window_size ()

gboolean            midori_settings_get_remember_last_window_size
                                                        (MidoriSettings *self);

midori_settings_set_remember_last_window_size ()

void                midori_settings_set_remember_last_window_size
                                                        (MidoriSettings *self,
                                                         gboolean value);

midori_settings_get_last_window_width ()

gint                midori_settings_get_last_window_width
                                                        (MidoriSettings *self);

midori_settings_set_last_window_width ()

void                midori_settings_set_last_window_width
                                                        (MidoriSettings *self,
                                                         gint value);

midori_settings_get_last_window_height ()

gint                midori_settings_get_last_window_height
                                                        (MidoriSettings *self);

midori_settings_set_last_window_height ()

void                midori_settings_set_last_window_height
                                                        (MidoriSettings *self,
                                                         gint value);

midori_settings_get_last_panel_position ()

gint                midori_settings_get_last_panel_position
                                                        (MidoriSettings *self);

midori_settings_set_last_panel_position ()

void                midori_settings_set_last_panel_position
                                                        (MidoriSettings *self,
                                                         gint value);

midori_settings_get_last_panel_page ()

gint                midori_settings_get_last_panel_page (MidoriSettings *self);

midori_settings_set_last_panel_page ()

void                midori_settings_set_last_panel_page (MidoriSettings *self,
                                                         gint value);

midori_settings_get_last_web_search ()

gint                midori_settings_get_last_web_search (MidoriSettings *self);

midori_settings_set_last_web_search ()

void                midori_settings_set_last_web_search (MidoriSettings *self,
                                                         gint value);

midori_settings_get_search_width ()

gint                midori_settings_get_search_width    (MidoriSettings *self);

midori_settings_set_search_width ()

void                midori_settings_set_search_width    (MidoriSettings *self,
                                                         gint value);

midori_settings_get_last_inspector_attached ()

gboolean            midori_settings_get_last_inspector_attached
                                                        (MidoriSettings *self);

midori_settings_set_last_inspector_attached ()

void                midori_settings_set_last_inspector_attached
                                                        (MidoriSettings *self,
                                                         gboolean value);

midori_settings_get_last_window_state ()

MidoriWindowState   midori_settings_get_last_window_state
                                                        (MidoriSettings *self);

midori_settings_set_last_window_state ()

void                midori_settings_set_last_window_state
                                                        (MidoriSettings *self,
                                                         MidoriWindowState value);

midori_settings_get_inactivity_reset ()

guint               midori_settings_get_inactivity_reset
                                                        (MidoriSettings *self);

midori_settings_set_inactivity_reset ()

void                midori_settings_set_inactivity_reset
                                                        (MidoriSettings *self,
                                                         guint value);

midori_settings_get_default_theme_name ()

const gchar *       midori_settings_get_default_theme_name
                                                        (MidoriSettings *self);

midori_settings_get_theme_name ()

const gchar *       midori_settings_get_theme_name      (MidoriSettings *self);

midori_settings_set_theme_name ()

void                midori_settings_set_theme_name      (MidoriSettings *self,
                                                         const gchar *value);

midori_settings_get_block_uris ()

const gchar *       midori_settings_get_block_uris      (MidoriSettings *self);

midori_settings_set_block_uris ()

void                midori_settings_set_block_uris      (MidoriSettings *self,
                                                         const gchar *value);

midori_settings_get_custom_title ()

const gchar *       midori_settings_get_custom_title    (MidoriSettings *self);

midori_settings_set_custom_title ()

void                midori_settings_set_custom_title    (MidoriSettings *self,
                                                         const gchar *value);

midori_settings_get_location_entry_search ()

const gchar *       midori_settings_get_location_entry_search
                                                        (MidoriSettings *self);

midori_settings_set_location_entry_search ()

void                midori_settings_set_location_entry_search
                                                        (MidoriSettings *self,
                                                         const gchar *value);

midori_settings_get_clear_private_data ()

gint                midori_settings_get_clear_private_data
                                                        (MidoriSettings *self);

midori_settings_set_clear_private_data ()

void                midori_settings_set_clear_private_data
                                                        (MidoriSettings *self,
                                                         gint value);

midori_settings_get_clear_data ()

const gchar *       midori_settings_get_clear_data      (MidoriSettings *self);

midori_settings_set_clear_data ()

void                midori_settings_set_clear_data      (MidoriSettings *self,
                                                         const gchar *value);

midori_settings_get_compact_sidepanel ()

gboolean            midori_settings_get_compact_sidepanel
                                                        (MidoriSettings *self);

midori_settings_set_compact_sidepanel ()

void                midori_settings_set_compact_sidepanel
                                                        (MidoriSettings *self,
                                                         gboolean value);

midori_settings_get_open_panels_in_windows ()

gboolean            midori_settings_get_open_panels_in_windows
                                                        (MidoriSettings *self);

midori_settings_set_open_panels_in_windows ()

void                midori_settings_set_open_panels_in_windows
                                                        (MidoriSettings *self,
                                                         gboolean value);

midori_settings_get_right_align_sidepanel ()

gboolean            midori_settings_get_right_align_sidepanel
                                                        (MidoriSettings *self);

midori_settings_set_right_align_sidepanel ()

void                midori_settings_set_right_align_sidepanel
                                                        (MidoriSettings *self,
                                                         gboolean value);

midori_settings_get_show_menubar ()

gboolean            midori_settings_get_show_menubar    (MidoriSettings *self);

midori_settings_set_show_menubar ()

void                midori_settings_set_show_menubar    (MidoriSettings *self,
                                                         gboolean value);

midori_settings_get_show_navigationbar ()

gboolean            midori_settings_get_show_navigationbar
                                                        (MidoriSettings *self);

midori_settings_set_show_navigationbar ()

void                midori_settings_set_show_navigationbar
                                                        (MidoriSettings *self,
                                                         gboolean value);

midori_settings_get_show_bookmarkbar ()

gboolean            midori_settings_get_show_bookmarkbar
                                                        (MidoriSettings *self);

midori_settings_set_show_bookmarkbar ()

void                midori_settings_set_show_bookmarkbar
                                                        (MidoriSettings *self,
                                                         gboolean value);

midori_settings_get_show_panel ()

gboolean            midori_settings_get_show_panel      (MidoriSettings *self);

midori_settings_set_show_panel ()

void                midori_settings_set_show_panel      (MidoriSettings *self,
                                                         gboolean value);

midori_settings_get_show_statusbar ()

gboolean            midori_settings_get_show_statusbar  (MidoriSettings *self);

midori_settings_set_show_statusbar ()

void                midori_settings_set_show_statusbar  (MidoriSettings *self,
                                                         gboolean value);

midori_settings_get_show_crash_dialog ()

gboolean            midori_settings_get_show_crash_dialog
                                                        (MidoriSettings *self);

midori_settings_set_show_crash_dialog ()

void                midori_settings_set_show_crash_dialog
                                                        (MidoriSettings *self,
                                                         gboolean value);

midori_settings_get_toolbar_items ()

const gchar *       midori_settings_get_toolbar_items   (MidoriSettings *self);

midori_settings_set_toolbar_items ()

void                midori_settings_set_toolbar_items   (MidoriSettings *self,
                                                         const gchar *value);

midori_settings_get_find_while_typing ()

gboolean            midori_settings_get_find_while_typing
                                                        (MidoriSettings *self);

midori_settings_set_find_while_typing ()

void                midori_settings_set_find_while_typing
                                                        (MidoriSettings *self,
                                                         gboolean value);

midori_settings_get_zoom_level ()

gdouble             midori_settings_get_zoom_level      (MidoriSettings *self);

midori_settings_set_zoom_level ()

void                midori_settings_set_zoom_level      (MidoriSettings *self,
                                                         gdouble value);

midori_settings_get_open_popups_in_tabs ()

gboolean            midori_settings_get_open_popups_in_tabs
                                                        (MidoriSettings *self);

midori_settings_set_open_popups_in_tabs ()

void                midori_settings_set_open_popups_in_tabs
                                                        (MidoriSettings *self,
                                                         gboolean value);

midori_settings_get_kinetic_scrolling ()

gboolean            midori_settings_get_kinetic_scrolling
                                                        (MidoriSettings *self);

midori_settings_set_kinetic_scrolling ()

void                midori_settings_set_kinetic_scrolling
                                                        (MidoriSettings *self,
                                                         gboolean value);

midori_settings_get_middle_click_opens_selection ()

gboolean            midori_settings_get_middle_click_opens_selection
                                                        (MidoriSettings *self);

midori_settings_set_middle_click_opens_selection ()

void                midori_settings_set_middle_click_opens_selection
                                                        (MidoriSettings *self,
                                                         gboolean value);

midori_settings_get_flash_window_on_new_bg_tabs ()

gboolean            midori_settings_get_flash_window_on_new_bg_tabs
                                                        (MidoriSettings *self);

midori_settings_set_flash_window_on_new_bg_tabs ()

void                midori_settings_set_flash_window_on_new_bg_tabs
                                                        (MidoriSettings *self,
                                                         gboolean value);

midori_settings_get_close_buttons_on_tabs ()

gboolean            midori_settings_get_close_buttons_on_tabs
                                                        (MidoriSettings *self);

midori_settings_set_close_buttons_on_tabs ()

void                midori_settings_set_close_buttons_on_tabs
                                                        (MidoriSettings *self,
                                                         gboolean value);

midori_settings_get_open_tabs_in_the_background ()

gboolean            midori_settings_get_open_tabs_in_the_background
                                                        (MidoriSettings *self);

midori_settings_set_open_tabs_in_the_background ()

void                midori_settings_set_open_tabs_in_the_background
                                                        (MidoriSettings *self,
                                                         gboolean value);

midori_settings_get_open_tabs_next_to_current ()

gboolean            midori_settings_get_open_tabs_next_to_current
                                                        (MidoriSettings *self);

midori_settings_set_open_tabs_next_to_current ()

void                midori_settings_set_open_tabs_next_to_current
                                                        (MidoriSettings *self,
                                                         gboolean value);

midori_settings_get_always_show_tabbar ()

gboolean            midori_settings_get_always_show_tabbar
                                                        (MidoriSettings *self);

midori_settings_set_always_show_tabbar ()

void                midori_settings_set_always_show_tabbar
                                                        (MidoriSettings *self,
                                                         gboolean value);

midori_settings_get_homepage ()

const gchar *       midori_settings_get_homepage        (MidoriSettings *self);

midori_settings_set_homepage ()

void                midori_settings_set_homepage        (MidoriSettings *self,
                                                         const gchar *value);

midori_settings_get_tabhome ()

const gchar *       midori_settings_get_tabhome         (MidoriSettings *self);

midori_settings_set_tabhome ()

void                midori_settings_set_tabhome         (MidoriSettings *self,
                                                         const gchar *value);

midori_settings_get_download_folder ()

const gchar *       midori_settings_get_download_folder (MidoriSettings *self);

midori_settings_set_download_folder ()

void                midori_settings_set_download_folder (MidoriSettings *self,
                                                         const gchar *value);

midori_settings_get_text_editor ()

const gchar *       midori_settings_get_text_editor     (MidoriSettings *self);

midori_settings_set_text_editor ()

void                midori_settings_set_text_editor     (MidoriSettings *self,
                                                         const gchar *value);

midori_settings_get_news_aggregator ()

const gchar *       midori_settings_get_news_aggregator (MidoriSettings *self);

midori_settings_set_news_aggregator ()

void                midori_settings_set_news_aggregator (MidoriSettings *self,
                                                         const gchar *value);

midori_settings_get_http_proxy ()

const gchar *       midori_settings_get_http_proxy      (MidoriSettings *self);

midori_settings_set_http_proxy ()

void                midori_settings_set_http_proxy      (MidoriSettings *self,
                                                         const gchar *value);

midori_settings_get_http_proxy_port ()

gint                midori_settings_get_http_proxy_port (MidoriSettings *self);

midori_settings_set_http_proxy_port ()

void                midori_settings_set_http_proxy_port (MidoriSettings *self,
                                                         gint value);

midori_settings_get_maximum_cache_size ()

gint                midori_settings_get_maximum_cache_size
                                                        (MidoriSettings *self);

midori_settings_set_maximum_cache_size ()

void                midori_settings_set_maximum_cache_size
                                                        (MidoriSettings *self,
                                                         gint value);

midori_settings_get_strip_referer ()

gboolean            midori_settings_get_strip_referer   (MidoriSettings *self);

midori_settings_set_strip_referer ()

void                midori_settings_set_strip_referer   (MidoriSettings *self,
                                                         gboolean value);

midori_settings_get_first_party_cookies_only ()

gboolean            midori_settings_get_first_party_cookies_only
                                                        (MidoriSettings *self);

midori_settings_set_first_party_cookies_only ()

void                midori_settings_set_first_party_cookies_only
                                                        (MidoriSettings *self,
                                                         gboolean value);

midori_settings_get_maximum_cookie_age ()

gint                midori_settings_get_maximum_cookie_age
                                                        (MidoriSettings *self);

midori_settings_set_maximum_cookie_age ()

void                midori_settings_set_maximum_cookie_age
                                                        (MidoriSettings *self,
                                                         gint value);

midori_settings_get_maximum_history_age ()

gint                midori_settings_get_maximum_history_age
                                                        (MidoriSettings *self);

midori_settings_set_maximum_history_age ()

void                midori_settings_set_maximum_history_age
                                                        (MidoriSettings *self,
                                                         gint value);

midori_history_website_new ()

MidoriHistoryWebsite * midori_history_website_new       (const gchar *uri,
                                                         const gchar *title,
                                                         gint64 date);

midori_history_website_construct ()

MidoriHistoryWebsite * midori_history_website_construct (GType object_type,
                                                         const gchar *uri,
                                                         const gchar *title,
                                                         gint64 date);

midori_history_website_get_uri ()

const gchar *       midori_history_website_get_uri      (MidoriHistoryWebsite *self);

midori_history_website_set_uri ()

void                midori_history_website_set_uri      (MidoriHistoryWebsite *self,
                                                         const gchar *value);

midori_history_search_new ()

MidoriHistorySearch * midori_history_search_new         (const gchar *uri,
                                                         const gchar *keywords,
                                                         gint64 date);

midori_history_search_construct ()

MidoriHistorySearch * midori_history_search_construct   (GType object_type,
                                                         const gchar *uri,
                                                         const gchar *keywords,
                                                         gint64 date);

midori_history_search_get_uri ()

const gchar *       midori_history_search_get_uri       (MidoriHistorySearch *self);

midori_history_search_set_uri ()

void                midori_history_search_set_uri       (MidoriHistorySearch *self,
                                                         const gchar *value);

midori_history_search_get_keywords ()

const gchar *       midori_history_search_get_keywords  (MidoriHistorySearch *self);

midori_history_search_set_keywords ()

void                midori_history_search_set_keywords  (MidoriHistorySearch *self,
                                                         const gchar *value);

midori_history_item_new ()

MidoriHistoryItem * midori_history_item_new             (void);

midori_history_item_construct ()

MidoriHistoryItem * midori_history_item_construct       (GType object_type);

midori_history_item_get_title ()

const gchar *       midori_history_item_get_title       (MidoriHistoryItem *self);

midori_history_item_set_title ()

void                midori_history_item_set_title       (MidoriHistoryItem *self,
                                                         const gchar *value);

midori_history_item_get_date ()

gint64              midori_history_item_get_date        (MidoriHistoryItem *self);

midori_history_item_set_date ()

void                midori_history_item_set_date        (MidoriHistoryItem *self,
                                                         gint64 value);

midori_history_database_new ()

MidoriHistoryDatabase * midori_history_database_new     (GObject *app,
                                                         GError **error);

midori_history_database_construct ()

MidoriHistoryDatabase * midori_history_database_construct
                                                        (GType object_type,
                                                         GObject *app,
                                                         GError **error);

midori_history_database_query ()

void                midori_history_database_query       (MidoriHistoryDatabase *self,
                                                         const gchar *sqlcmd,
                                                         const gchar *filter,
                                                         gint64 day,
                                                         gint64 max_items,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);

midori_history_database_query_finish ()

GList *             midori_history_database_query_finish
                                                        (MidoriHistoryDatabase *self,
                                                         GAsyncResult *_res_);

midori_history_database_list_by_count_with_bookmarks ()

void                midori_history_database_list_by_count_with_bookmarks
                                                        (MidoriHistoryDatabase *self,
                                                         const gchar *filter,
                                                         gint max_items,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);

midori_history_database_list_by_count_with_bookmarks_finish ()

GList *             midori_history_database_list_by_count_with_bookmarks_finish
                                                        (MidoriHistoryDatabase *self,
                                                         GAsyncResult *_res_);

midori_history_database_insert ()

gboolean            midori_history_database_insert      (MidoriHistoryDatabase *self,
                                                         const gchar *uri,
                                                         const gchar *title,
                                                         gint64 date,
                                                         gint64 day,
                                                         GError **error);

midori_history_database_clear ()

gboolean            midori_history_database_clear       (MidoriHistoryDatabase *self,
                                                         gint64 maximum_age,
                                                         GError **error);

midori_tab_is_blank ()

gboolean            midori_tab_is_blank                 (MidoriTab *self);

midori_tab_inject_stylesheet ()

void                midori_tab_inject_stylesheet        (MidoriTab *self,
                                                         const gchar *stylesheet);

midori_tab_can_view_source ()

gboolean            midori_tab_can_view_source          (MidoriTab *self);

midori_tab_get_display_title ()

gchar *             midori_tab_get_display_title        (const gchar *title,
                                                         const gchar *uri);

midori_tab_get_display_ellipsize ()

PangoEllipsizeMode  midori_tab_get_display_ellipsize    (const gchar *title,
                                                         const gchar *uri);

midori_tab_can_save ()

gboolean            midori_tab_can_save                 (MidoriTab *self);

midori_tab_stop_loading ()

void                midori_tab_stop_loading             (MidoriTab *self);

midori_tab_can_go_forward ()

gboolean            midori_tab_can_go_forward           (MidoriTab *self);

midori_tab_go_forward ()

void                midori_tab_go_forward               (MidoriTab *self);

midori_tab_unmark_text_matches ()

void                midori_tab_unmark_text_matches      (MidoriTab *self);

midori_tab_find ()

gboolean            midori_tab_find                     (MidoriTab *self,
                                                         const gchar *text,
                                                         gboolean case_sensitive,
                                                         gboolean forward);

midori_tab_update_actions ()

void                midori_tab_update_actions           (MidoriTab *self,
                                                         GtkActionGroup *actions,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);

midori_tab_update_actions_finish ()

void                midori_tab_update_actions_finish    (MidoriTab *self,
                                                         GAsyncResult *_res_);

midori_tab_new ()

MidoriTab *         midori_tab_new                      (void);

midori_tab_construct ()

MidoriTab *         midori_tab_construct                (GType object_type);

midori_tab_get_related ()

MidoriTab *         midori_tab_get_related              (MidoriTab *self);

midori_tab_set_related ()

void                midori_tab_set_related              (MidoriTab *self,
                                                         MidoriTab *value);

midori_tab_get_web_view ()

WebKitWebView *     midori_tab_get_web_view             (MidoriTab *self);

midori_tab_get_uri ()

const gchar *       midori_tab_get_uri                  (MidoriTab *self);

midori_tab_set_uri ()

void                midori_tab_set_uri                  (MidoriTab *self,
                                                         const gchar *value);

midori_tab_get_special ()

gboolean            midori_tab_get_special              (MidoriTab *self);

midori_tab_set_special ()

void                midori_tab_set_special              (MidoriTab *self,
                                                         gboolean value);

midori_tab_get_minimized ()

gboolean            midori_tab_get_minimized            (MidoriTab *self);

midori_tab_set_minimized ()

void                midori_tab_set_minimized            (MidoriTab *self,
                                                         gboolean value);

midori_tab_get_mime_type ()

const gchar *       midori_tab_get_mime_type            (MidoriTab *self);

midori_tab_set_mime_type ()

void                midori_tab_set_mime_type            (MidoriTab *self,
                                                         const gchar *value);

midori_tab_get_security ()

MidoriSecurity      midori_tab_get_security             (MidoriTab *self);

midori_tab_set_security ()

void                midori_tab_set_security             (MidoriTab *self,
                                                         MidoriSecurity value);

midori_tab_get_load_status ()

MidoriLoadStatus    midori_tab_get_load_status          (MidoriTab *self);

midori_tab_set_load_status ()

void                midori_tab_set_load_status          (MidoriTab *self,
                                                         MidoriLoadStatus value);

midori_tab_get_load_error ()

MidoriLoadError     midori_tab_get_load_error           (MidoriTab *self);

midori_tab_set_load_error ()

void                midori_tab_set_load_error           (MidoriTab *self,
                                                         MidoriLoadError value);

midori_tab_get_statusbar_text ()

const gchar *       midori_tab_get_statusbar_text       (MidoriTab *self);

midori_tab_set_statusbar_text ()

void                midori_tab_set_statusbar_text       (MidoriTab *self,
                                                         const gchar *value);

midori_tab_get_fg_color ()

GdkColor *          midori_tab_get_fg_color             (MidoriTab *self);

midori_tab_set_fg_color ()

void                midori_tab_set_fg_color             (MidoriTab *self,
                                                         GdkColor *value);

midori_tab_get_bg_color ()

GdkColor *          midori_tab_get_bg_color             (MidoriTab *self);

midori_tab_set_bg_color ()

void                midori_tab_set_bg_color             (MidoriTab *self,
                                                         GdkColor *value);

midori_tab_get_progress ()

gdouble             midori_tab_get_progress             (MidoriTab *self);

midori_tab_set_progress ()

void                midori_tab_set_progress             (MidoriTab *self,
                                                         gdouble value);

midori_tab_get_is_dialog ()

gboolean            midori_tab_get_is_dialog            (MidoriTab *self);

midori_tab_set_is_dialog ()

void                midori_tab_set_is_dialog            (MidoriTab *self,
                                                         gboolean value);

midori_tab_get_view_source ()

gboolean            midori_tab_get_view_source          (MidoriTab *self);

midori_tab_set_view_source ()

void                midori_tab_set_view_source          (MidoriTab *self,
                                                         gboolean value);

midori_tally_new ()

MidoriTally *       midori_tally_new                    (MidoriTab *tab);

midori_tally_construct ()

MidoriTally *       midori_tally_construct              (GType object_type,
                                                         MidoriTab *tab);

midori_tally_get_tab ()

MidoriTab *         midori_tally_get_tab                (MidoriTally *self);

midori_tally_set_tab ()

void                midori_tally_set_tab                (MidoriTally *self,
                                                         MidoriTab *value);

midori_tally_get_close_button_left ()

gboolean            midori_tally_get_close_button_left  (MidoriTally *self);

midori_tally_set_close_button_left ()

void                midori_tally_set_close_button_left  (MidoriTally *self,
                                                         gboolean value);

midori_tally_get_close_button_visible ()

gboolean            midori_tally_get_close_button_visible
                                                        (MidoriTally *self);

midori_tally_set_close_button_visible ()

void                midori_tally_set_close_button_visible
                                                        (MidoriTally *self,
                                                         gboolean value);

midori_notebook_new ()

GtkWidget *         midori_notebook_new                 (void);

midori_notebook_construct ()

GtkWidget *         midori_notebook_construct           (GType object_type);

midori_notebook_get_context_action ()

MidoriContextAction * midori_notebook_get_context_action
                                                        (MidoriNotebook *self);

midori_notebook_insert ()

void                midori_notebook_insert              (MidoriNotebook *self,
                                                         MidoriTab *tab,
                                                         gint index);

midori_notebook_get_tab_context_action ()

MidoriContextAction * midori_notebook_get_tab_context_action
                                                        (MidoriNotebook *self,
                                                         MidoriTab *tab);

midori_notebook_move ()

void                midori_notebook_move                (MidoriNotebook *self,
                                                         MidoriTab *tab,
                                                         gint index);

midori_notebook_remove ()

void                midori_notebook_remove              (MidoriNotebook *self,
                                                         MidoriTab *tab);

midori_notebook_get_nth_tab ()

MidoriTab *         midori_notebook_get_nth_tab         (MidoriNotebook *self,
                                                         gint index);

midori_notebook_get_tab_index ()

gint                midori_notebook_get_tab_index       (MidoriNotebook *self,
                                                         MidoriTab *tab);

midori_notebook_get_count ()

guint               midori_notebook_get_count           (MidoriNotebook *self);

midori_notebook_get_index ()

gint                midori_notebook_get_index           (MidoriNotebook *self);

midori_notebook_set_index ()

void                midori_notebook_set_index           (MidoriNotebook *self,
                                                         gint value);

midori_notebook_get_tab ()

MidoriTab *         midori_notebook_get_tab             (MidoriNotebook *self);

midori_notebook_set_tab ()

void                midori_notebook_set_tab             (MidoriNotebook *self,
                                                         MidoriTab *value);

midori_notebook_get_close_buttons_left ()

gboolean            midori_notebook_get_close_buttons_left
                                                        (MidoriNotebook *self);

midori_notebook_set_close_buttons_left ()

void                midori_notebook_set_close_buttons_left
                                                        (MidoriNotebook *self,
                                                         gboolean value);

midori_notebook_get_close_buttons_visible ()

gboolean            midori_notebook_get_close_buttons_visible
                                                        (MidoriNotebook *self);

midori_notebook_set_close_buttons_visible ()

void                midori_notebook_set_close_buttons_visible
                                                        (MidoriNotebook *self,
                                                         gboolean value);

midori_notebook_get_labels_visible ()

gboolean            midori_notebook_get_labels_visible  (MidoriNotebook *self);

midori_notebook_set_labels_visible ()

void                midori_notebook_set_labels_visible  (MidoriNotebook *self,
                                                         gboolean value);

midori_view_completion_new ()

MidoriViewCompletion * midori_view_completion_new       (void);

midori_view_completion_construct ()

MidoriViewCompletion * midori_view_completion_construct (GType object_type);

MidoriBookmarksDatabasePrivate

typedef struct _MidoriBookmarksDatabasePrivate MidoriBookmarksDatabasePrivate;

MidoriSearchCompletionPrivate

typedef struct _MidoriSearchCompletionPrivate MidoriSearchCompletionPrivate;

MidoriCompletionPrivate

typedef struct _MidoriCompletionPrivate MidoriCompletionPrivate;

MidoriViewCompletionPrivate

typedef struct _MidoriViewCompletionPrivate MidoriViewCompletionPrivate;

MidoriContextActionPrivate

typedef struct _MidoriContextActionPrivate MidoriContextActionPrivate;

MidoriDatabasePrivate

typedef struct _MidoriDatabasePrivate MidoriDatabasePrivate;