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

Rename MidoriPane to MidoriView and add protocol support

Browse source
This commit is contained in:
Christian Dywan 2008-11-29 16:45:24 +01:00
parent 417493caa3
commit 9b24d58553
7 changed files with 409 additions and 260 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

131
midori/midori-pane.c
View file

@ -1,131 +0,0 @@
/*
Copyright (C) 2008 Christian Dywan <christian@twotoasts.de>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
See the file COPYING for the full license text.
*/
#include "midori-pane.h"
#include <glib/gi18n.h>
struct _MidoriPane
{
GtkHBox parent_instance;
};
static void
midori_pane_base_init (MidoriPaneIface* iface);
GType
midori_pane_get_type (void)
{
static GType pane_type = 0;
if (!pane_type)
{
const GTypeInfo pane_info =
{
sizeof (MidoriPaneIface),
(GBaseInitFunc) midori_pane_base_init,
(GBaseFinalizeFunc) NULL,
};
pane_type = g_type_register_static (G_TYPE_INTERFACE,
"MidoriPane",
&pane_info, 0);
g_type_interface_add_prerequisite (pane_type, GTK_TYPE_WIDGET);
}
return pane_type;
}
static const gchar*
midori_pane_default_get_stock_id (MidoriPane* pane)
{
return NULL;
}
static const gchar*
midori_pane_default_get_label (MidoriPane* pane)
{
return NULL;
}
static GtkWidget*
midori_pane_default_get_toolbar (MidoriPane* pane)
{
return NULL;
}
static void
midori_pane_base_init (MidoriPaneIface* iface)
{
static gboolean initialized = FALSE;
if (initialized)
return;
iface->get_stock_id = midori_pane_default_get_stock_id;
iface->get_label = midori_pane_default_get_label;
iface->get_toolbar = midori_pane_default_get_toolbar;
initialized = TRUE;
}
/**
* midori_pane_get_stock_id:
* @pane: a #MidoriPane
*
* Retrieves the stock ID of the pane.
*
* Return value: a stock ID
**/
const gchar*
midori_pane_get_stock_id (MidoriPane* pane)
{
g_return_val_if_fail (MIDORI_IS_PANE (pane), NULL);
return MIDORI_PANE_GET_IFACE (pane)->get_stock_id (pane);
}
/**
* midori_pane_get_label:
* @pane: a #MidoriPane
*
* Retrieves the label of the pane.
*
* Return value: a label string
**/
const gchar*
midori_pane_get_label (MidoriPane* pane)
{
g_return_val_if_fail (MIDORI_IS_PANE (pane), NULL);
return MIDORI_PANE_GET_IFACE (pane)->get_label (pane);
}
/**
* midori_pane_get_toolbar:
* @pane: a #MidoriPane
*
* Retrieves the toolbar of the pane.
*
* Return value: a toolbar
**/
GtkWidget*
midori_pane_get_toolbar (MidoriPane* pane)
{
GtkWidget* toolbar;
g_return_val_if_fail (MIDORI_IS_PANE (pane), NULL);
toolbar = MIDORI_PANE_GET_IFACE (pane)->get_toolbar (pane);
if (!toolbar)
toolbar = gtk_event_box_new ();
return toolbar;
}

62
midori/midori-pane.h
View file

@ -1,62 +0,0 @@
/*
Copyright (C) 2008 Christian Dywan <christian@twotoasts.de>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
See the file COPYING for the full license text.
*/
#ifndef __MIDORI_PANE_H__
#define __MIDORI_PANE_H__
#include <gtk/gtk.h>
#include <katze/katze.h>
G_BEGIN_DECLS
#define MIDORI_TYPE_PANE \
(midori_pane_get_type ())
#define MIDORI_PANE(obj) \
(G_TYPE_CHECK_INSTANCE_CAST ((obj), MIDORI_TYPE_PANE, MidoriPane))
#define MIDORI_IS_PANE(obj) \
(G_TYPE_CHECK_INSTANCE_TYPE ((obj), MIDORI_TYPE_PANE))
#define MIDORI_PANE_GET_IFACE(inst) \
(G_TYPE_INSTANCE_GET_INTERFACE ((inst), MIDORI_TYPE_PANE, MidoriPaneIface))
typedef struct _MidoriPane MidoriPane;
typedef struct _MidoriPaneIface MidoriPaneIface;
struct _MidoriPaneIface
{
GTypeInterface base_iface;
/* Virtual functions */
const gchar*
(*get_stock_id) (MidoriPane* pane);
const gchar*
(*get_label) (MidoriPane* pane);
GtkWidget*
(*get_toolbar) (MidoriPane* pane);
};
GType
midori_pane_get_type (void);
const gchar*
midori_pane_get_stock_id (MidoriPane* pane);
const gchar*
midori_pane_get_label (MidoriPane* pane);
GtkWidget*
midori_pane_get_toolbar (MidoriPane* pane);
G_END_DECLS
#endif /* __MIDORI_PANE_H__ */

129
midori/midori-panel.c
View file

@ -377,13 +377,13 @@ midori_panel_menu_item_activate_cb (GtkWidget* widget,
/**
* midori_panel_append_page:
* @panel: a #MidoriPanel
* @child: the child widget
* @viewable: a viewable widget
* @toolbar: a toolbar widget, or %NULL
* @stock_id: a stock ID
* @label: a string to use as the label
*
* Appends a new page to the panel. If @toolbar is specified it will
* be packed above @child.
* be packed above @viewable.
*
* In the case of an error, -1 is returned.
*
@ -391,7 +391,7 @@ midori_panel_menu_item_activate_cb (GtkWidget* widget,
**/
gint
midori_panel_append_page (MidoriPanel* panel,
MidoriPane* pane)
MidoriViewable* viewable)
{
GtkWidget* scrolled;
GObjectClass* gobject_class;
@ -405,10 +405,10 @@ midori_panel_append_page (MidoriPanel* panel,
guint n;
g_return_val_if_fail (MIDORI_IS_PANEL (panel), -1);
g_return_val_if_fail (MIDORI_IS_PANE (pane), -1);
g_return_val_if_fail (MIDORI_IS_VIEWABLE (viewable), -1);
if (GTK_IS_SCROLLED_WINDOW (pane))
scrolled = (GtkWidget*)pane;
if (GTK_IS_SCROLLED_WINDOW (viewable))
scrolled = (GtkWidget*)viewable;
else
{
scrolled = gtk_scrolled_window_new (NULL, NULL);
@ -417,26 +417,26 @@ midori_panel_append_page (MidoriPanel* panel,
GTK_POLICY_AUTOMATIC);
GTK_WIDGET_SET_FLAGS (scrolled, GTK_CAN_FOCUS);
gtk_widget_show (scrolled);
gobject_class = G_OBJECT_GET_CLASS (pane);
gobject_class = G_OBJECT_GET_CLASS (viewable);
if (GTK_WIDGET_CLASS (gobject_class)->set_scroll_adjustments_signal)
widget = (GtkWidget*)pane;
widget = (GtkWidget*)viewable;
else
{
widget = gtk_viewport_new (NULL, NULL);
gtk_widget_show (widget);
gtk_container_add (GTK_CONTAINER (widget), GTK_WIDGET (pane));
gtk_container_add (GTK_CONTAINER (widget), GTK_WIDGET (viewable));
}
gtk_container_add (GTK_CONTAINER (scrolled), widget);
}
gtk_container_add (GTK_CONTAINER (panel->notebook), scrolled);
toolbar = midori_pane_get_toolbar (pane);
toolbar = midori_viewable_get_toolbar (viewable);
gtk_widget_show (toolbar);
gtk_container_add (GTK_CONTAINER (panel->toolbook), toolbar);
n = midori_panel_page_num (panel, scrolled);
label = midori_pane_get_label (pane);
stock_id = midori_pane_get_stock_id (pane);
label = midori_viewable_get_label (viewable);
stock_id = midori_viewable_get_stock_id (viewable);
toolitem = gtk_radio_tool_button_new_from_stock (panel->group, stock_id);
panel->group = gtk_radio_tool_button_get_group (GTK_RADIO_TOOL_BUTTON (
@ -448,7 +448,7 @@ midori_panel_append_page (MidoriPanel* panel,
gtk_tool_button_set_label (GTK_TOOL_BUTTON (toolitem), label);
gtk_widget_set_tooltip_text (GTK_WIDGET (toolitem), label);
}
g_object_set_data (G_OBJECT (toolitem), "page", pane);
g_object_set_data (G_OBJECT (toolitem), "page", viewable);
g_signal_connect (toolitem, "clicked",
G_CALLBACK (midori_panel_menu_item_activate_cb), panel);
gtk_widget_show_all (GTK_WIDGET (toolitem));
@ -458,7 +458,7 @@ midori_panel_append_page (MidoriPanel* panel,
{
menuitem = gtk_image_menu_item_new_from_stock (stock_id, NULL);
gtk_widget_show (menuitem);
g_object_set_data (G_OBJECT (menuitem), "page", pane);
g_object_set_data (G_OBJECT (menuitem), "page", viewable);
g_object_set_data (G_OBJECT (menuitem), "toolitem", toolitem);
g_signal_connect (menuitem, "activate",
G_CALLBACK (midori_panel_menu_item_activate_cb),
@ -597,16 +597,18 @@ void
midori_panel_set_current_page (MidoriPanel* panel,
gint n)
{
GtkWidget* pane;
GtkWidget* viewable;
g_return_if_fail (MIDORI_IS_PANEL (panel));
gtk_notebook_set_current_page (GTK_NOTEBOOK (panel->toolbook), n);
gtk_notebook_set_current_page (GTK_NOTEBOOK (panel->notebook), n);
if ((pane = midori_panel_get_nth_page (panel, n)))
if ((viewable = midori_panel_get_nth_page (panel, n)))
{
const gchar* label = midori_pane_get_label (MIDORI_PANE (pane));
const gchar* label;
label = midori_viewable_get_label (MIDORI_VIEWABLE (viewable));
g_object_set (panel->toolbar_label, "label", label, NULL);
}
}
@ -618,95 +620,96 @@ typedef struct
gchar* label;
gchar* stock_id;
GtkWidget* toolbar;
} MidoriDummyPane;
} MidoriDummyViewable;
typedef struct
{
GtkAlignmentClass parent_class;
} MidoriDummyPaneClass;
} MidoriDummyViewableClass;
#define MIDORI_TYPE_DUMMY_PANE (midori_dummy_pane_get_type ())
#define MIDORI_DUMMY_PANE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
MIDORI_TYPE_DUMMY_PANE, MidoriDummyPane))
#define MIDORI_IS_DUMMY_PANE(obj) \
(G_TYPE_CHECK_INSTANCE_TYPE ((obj), MIDORI_TYPE_DUMMY_PANE))
#define MIDORI_TYPE_DUMMY_VIEWABLE (midori_dummy_viewable_get_type ())
#define MIDORI_DUMMY_VIEWABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
MIDORI_TYPE_DUMMY_VIEWABLE, MidoriDummyViewable))
#define MIDORI_IS_DUMMY_VIEWABLE(obj) \
(G_TYPE_CHECK_INSTANCE_TYPE ((obj), MIDORI_TYPE_DUMMY_VIEWABLE))
static void
midori_dummy_pane_iface_init (MidoriPaneIface* iface);
midori_dummy_viewable_iface_init (MidoriViewableIface* iface);
static void
midori_dummy_pane_finalize (GObject* object);
midori_dummy_viewable_finalize (GObject* object);
G_DEFINE_TYPE_WITH_CODE (MidoriDummyPane, midori_dummy_pane, GTK_TYPE_ALIGNMENT,
G_IMPLEMENT_INTERFACE (MIDORI_TYPE_PANE,
midori_dummy_pane_iface_init));
G_DEFINE_TYPE_WITH_CODE (MidoriDummyViewable, midori_dummy_viewable,
GTK_TYPE_ALIGNMENT,
G_IMPLEMENT_INTERFACE (MIDORI_TYPE_VIEWABLE,
midori_dummy_viewable_iface_init));
static void
midori_dummy_pane_class_init (MidoriDummyPaneClass* class)
midori_dummy_viewable_class_init (MidoriDummyViewableClass* class)
{
GObjectClass* gobject_class;
gobject_class = G_OBJECT_CLASS (class);
gobject_class->finalize = midori_dummy_pane_finalize;
gobject_class->finalize = midori_dummy_viewable_finalize;
}
static const gchar*
midori_dummy_pane_get_label (MidoriPane* pane)
midori_dummy_viewable_get_label (MidoriViewable* viewable)
{
return MIDORI_DUMMY_PANE (pane)->label;
return MIDORI_DUMMY_VIEWABLE (viewable)->label;
}
static const gchar*
midori_dummy_pane_get_stock_id (MidoriPane* pane)
midori_dummy_viewable_get_stock_id (MidoriViewable* viewable)
{
return MIDORI_DUMMY_PANE (pane)->stock_id;
return MIDORI_DUMMY_VIEWABLE (viewable)->stock_id;
}
static GtkWidget*
midori_dummy_pane_get_toolbar (MidoriPane* pane)
midori_dummy_viewable_get_toolbar (MidoriViewable* viewable)
{
return MIDORI_DUMMY_PANE (pane)->toolbar;
return MIDORI_DUMMY_VIEWABLE (viewable)->toolbar;
}
static void
midori_dummy_pane_iface_init (MidoriPaneIface* iface)
midori_dummy_viewable_iface_init (MidoriViewableIface* iface)
{
iface->get_stock_id = midori_dummy_pane_get_stock_id;
iface->get_label = midori_dummy_pane_get_label;
iface->get_toolbar = midori_dummy_pane_get_toolbar;
iface->get_stock_id = midori_dummy_viewable_get_stock_id;
iface->get_label = midori_dummy_viewable_get_label;
iface->get_toolbar = midori_dummy_viewable_get_toolbar;
}
static void
midori_dummy_pane_init (MidoriDummyPane* pane)
midori_dummy_viewable_init (MidoriDummyViewable* viewable)
{
pane->stock_id = NULL;
pane->label = NULL;
pane->toolbar = NULL;
viewable->stock_id = NULL;
viewable->label = NULL;
viewable->toolbar = NULL;
}
static void
midori_dummy_pane_finalize (GObject* object)
midori_dummy_viewable_finalize (GObject* object)
{
MidoriDummyPane* pane = MIDORI_DUMMY_PANE (object);
MidoriDummyViewable* viewable = MIDORI_DUMMY_VIEWABLE (object);
katze_assign (pane->stock_id, NULL);
katze_assign (pane->label, NULL);
katze_assign (viewable->stock_id, NULL);
katze_assign (viewable->label, NULL);
G_OBJECT_CLASS (midori_dummy_pane_parent_class)->finalize (object);
G_OBJECT_CLASS (midori_dummy_viewable_parent_class)->finalize (object);
}
static GtkWidget*
midori_dummy_pane_new (const gchar* stock_id,
midori_dummy_viewable_new (const gchar* stock_id,
const gchar* label,
GtkWidget* toolbar)
{
GtkWidget* pane = g_object_new (MIDORI_TYPE_DUMMY_PANE, NULL);
GtkWidget* viewable = g_object_new (MIDORI_TYPE_DUMMY_VIEWABLE, NULL);
MIDORI_DUMMY_PANE (pane)->stock_id = g_strdup (stock_id);
MIDORI_DUMMY_PANE (pane)->label = g_strdup (label);
MIDORI_DUMMY_PANE (pane)->toolbar = toolbar;
MIDORI_DUMMY_VIEWABLE (viewable)->stock_id = g_strdup (stock_id);
MIDORI_DUMMY_VIEWABLE (viewable)->label = g_strdup (label);
MIDORI_DUMMY_VIEWABLE (viewable)->toolbar = toolbar;
return pane;
return viewable;
}
/**
@ -718,9 +721,9 @@ midori_dummy_pane_new (const gchar* stock_id,
* @toolbar: a toolbar widget, or %NULL
*
* Appends an arbitrary widget to the panel by wrapping it
* in a #MidoriPane created on the fly.
* in a #MidoriViewable created on the fly.
*
* Actually implementing #MidoriPane instead of using
* Actually implementing #MidoriViewable instead of using
* this convenience is recommended.
*
* In the case of an error, -1 is returned.
@ -734,7 +737,7 @@ midori_panel_append_widget (MidoriPanel* panel,
const gchar* label,
GtkWidget* toolbar)
{
GtkWidget* pane;
GtkWidget* viewable;
g_return_val_if_fail (MIDORI_IS_PANEL (panel), -1);
g_return_val_if_fail (GTK_IS_WIDGET (widget), -1);
@ -742,8 +745,8 @@ midori_panel_append_widget (MidoriPanel* panel,
g_return_val_if_fail (stock_id != NULL, -1);
g_return_val_if_fail (!toolbar || GTK_IS_WIDGET (toolbar), -1);
pane = midori_dummy_pane_new (stock_id, label, toolbar);
gtk_widget_show (pane);
gtk_container_add (GTK_CONTAINER (pane), widget);
return midori_panel_append_page (panel, MIDORI_PANE (pane));
viewable = midori_dummy_viewable_new (stock_id, label, toolbar);
gtk_widget_show (viewable);
gtk_container_add (GTK_CONTAINER (viewable), widget);
return midori_panel_append_page (panel, MIDORI_VIEWABLE (viewable));
}

4
midori/midori-panel.h
View file

@ -16,7 +16,7 @@
#include <katze/katze.h>
#include "midori-pane.h"
#include "midori-viewable.h"
G_BEGIN_DECLS
@ -48,7 +48,7 @@ midori_panel_set_compact (MidoriPanel* panel,
gint
midori_panel_append_page (MidoriPanel* panel,
MidoriPane* pane);
MidoriViewable* viewable);
gint
midori_panel_get_current_page (MidoriPanel* panel);

266
midori/midori-viewable.c Normal file
View file

@ -0,0 +1,266 @@
/*
Copyright (C) 2008 Christian Dywan <christian@twotoasts.de>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
See the file COPYING for the full license text.
*/
#include "midori-viewable.h"
#include <glib/gi18n.h>
static void
midori_viewable_base_init (MidoriViewableIface* iface);
static void
midori_viewable_base_finalize (MidoriViewableIface* iface);
GType
midori_viewable_get_type (void)
{
static GType viewable_type = 0;
if (!viewable_type)
{
const GTypeInfo viewable_info =
{
sizeof (MidoriViewableIface),
(GBaseInitFunc) midori_viewable_base_init,
(GBaseFinalizeFunc) midori_viewable_base_finalize,
};
viewable_type = g_type_register_static (G_TYPE_INTERFACE,
"MidoriViewable",
&viewable_info, 0);
g_type_interface_add_prerequisite (viewable_type, GTK_TYPE_WIDGET);
}
return viewable_type;
}
static const gchar*
midori_viewable_default_get_stock_id (MidoriViewable* viewable)
{
return NULL;
}
static const gchar*
midori_viewable_default_get_label (MidoriViewable* viewable)
{
return NULL;
}
static GtkWidget*
midori_viewable_default_get_toolbar (MidoriViewable* viewable)
{
return NULL;
}
static void
midori_viewable_base_init (MidoriViewableIface* iface)
{
static gboolean initialized = FALSE;
if (initialized)
return;
iface->p = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
iface->get_stock_id = midori_viewable_default_get_stock_id;
iface->get_label = midori_viewable_default_get_label;
iface->get_toolbar = midori_viewable_default_get_toolbar;
initialized = TRUE;
}
static void
midori_viewable_base_finalize (MidoriViewableIface* iface)
{
g_hash_table_destroy (iface->p);
}
/**
* midori_viewable_new_from_uri:
* @uri: an URI
*
* Attempts to create a new #MidoriViewable from the specified URI.
*
* The protocol of @uri must previously have been registered by
* the #MidoriViewable via midori_viewable_register_protocol().
*
* Return value: a new #MidoriViewable, or %NULL
**/
GtkWidget*
midori_viewable_new_from_uri (const gchar* uri)
{
MidoriViewableIface* iface;
gchar** parts;
gchar* type_name;
GType type;
if (!(iface = g_type_default_interface_peek (MIDORI_TYPE_VIEWABLE)))
{
g_warning ("No viewable interface available");
return NULL;
}
g_return_val_if_fail (uri != NULL, NULL);
g_debug ("size: %d", g_hash_table_size (iface->p));
if (!g_hash_table_size (iface->p))
return NULL;
if ((parts = g_strsplit (uri, "://", 2)))
{
g_debug ("%s, %s", parts[0], uri);
if (!(type_name = g_hash_table_lookup (iface->p, parts[0])))
{
/* FIXME: Support midori://dummy/foo */
type_name = g_hash_table_lookup (iface->p, uri);
}
g_strfreev (parts);
if (type_name)
{
type = g_type_from_name (type_name);
g_free (type_name);
if (type)
return g_object_new (type, "uri", uri, NULL);
}
}
else if ((parts = g_strsplit_set (uri, ":", 2)))
{
g_debug (parts[0]);
type_name = g_hash_table_lookup (iface->p, parts[0]);
g_strfreev (parts);
if (type_name)
{
type = g_type_from_name (type_name);
g_free (type_name);
if (type)
return g_object_new (type, "uri", uri, NULL);
}
}
return NULL;
}
static gboolean
viewable_type_implements (GType type,
GType interface)
{
GType *interfaces;
guint i;
if (!(interfaces = g_type_interfaces (type, NULL)))
return FALSE;
for (i = 0; interfaces[i]; i++)
{
if (interfaces[i] == interface)
{
g_free (interfaces);
return TRUE;
}
}
g_free (interfaces);
return FALSE;
}
/**
* midori_viewable_register_protocol:
* @type: a type that implements #MidoriViewable
* @protocol: a protocol
*
* Registers the specified protocol as supported by @type.
*
* The following kinds of protocols are supported:
*
* "dummy": support URIs like "dummy://foo/bar"
* "about:dummy": support URIs like "about:dummy"
* FIXME: The following is not yet fully supported
* "midori://dummy": support URIs like "midori://dummy/foo"
*
* Return value: a new #MidoriViewable, or %NULL
**/
void
midori_viewable_register_protocol (GType type,
const gchar* protocol)
{
MidoriViewableIface* iface;
GObjectClass* class;
if (!(iface = g_type_default_interface_peek (MIDORI_TYPE_VIEWABLE)))
{
g_warning ("No viewable interface available");
return;
}
g_return_if_fail (viewable_type_implements (type, MIDORI_TYPE_VIEWABLE));
if (!(class = g_type_class_peek (type)))
{
g_warning ("No class for %s available", g_type_name (type));
return;
}
g_return_if_fail (g_object_class_find_property (class, "uri"));
/* FIXME: Verify the syntax of protocol */
g_hash_table_insert (iface->p, g_strdup (protocol),
g_strdup (g_type_name (type)));
}
/**
* midori_viewable_get_stock_id:
* @viewable: a #MidoriViewable
*
* Retrieves the stock ID of the viewable.
*
* Return value: a stock ID
**/
const gchar*
midori_viewable_get_stock_id (MidoriViewable* viewable)
{
g_return_val_if_fail (MIDORI_IS_VIEWABLE (viewable), NULL);
return MIDORI_VIEWABLE_GET_IFACE (viewable)->get_stock_id (viewable);
}
/**
* midori_viewable_get_label:
* @viewable: a #MidoriViewable
*
* Retrieves the label of the viewable.
*
* Return value: a label string
**/
const gchar*
midori_viewable_get_label (MidoriViewable* viewable)
{
g_return_val_if_fail (MIDORI_IS_VIEWABLE (viewable), NULL);
return MIDORI_VIEWABLE_GET_IFACE (viewable)->get_label (viewable);
}
/**
* midori_viewable_get_toolbar:
* @viewable: a #MidoriViewable
*
* Retrieves the toolbar of the viewable.
*
* Return value: a toolbar
**/
GtkWidget*
midori_viewable_get_toolbar (MidoriViewable* viewable)
{
GtkWidget* toolbar;
g_return_val_if_fail (MIDORI_IS_VIEWABLE (viewable), NULL);
toolbar = MIDORI_VIEWABLE_GET_IFACE (viewable)->get_toolbar (viewable);
if (!toolbar)
toolbar = gtk_event_box_new ();
return toolbar;
}

73
midori/midori-viewable.h Normal file
View file

@ -0,0 +1,73 @@
/*
Copyright (C) 2008 Christian Dywan <christian@twotoasts.de>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
See the file COPYING for the full license text.
*/
#ifndef __MIDORI_VIEWABLE_H__
#define __MIDORI_VIEWABLE_H__
#include <gtk/gtk.h>
#include <katze/katze.h>
G_BEGIN_DECLS
#define MIDORI_TYPE_VIEWABLE \
(midori_viewable_get_type ())
#define MIDORI_VIEWABLE(obj) \
(G_TYPE_CHECK_INSTANCE_CAST ((obj), MIDORI_TYPE_VIEWABLE, MidoriViewable))
#define MIDORI_IS_VIEWABLE(obj) \
(G_TYPE_CHECK_INSTANCE_TYPE ((obj), MIDORI_TYPE_VIEWABLE))
#define MIDORI_VIEWABLE_GET_IFACE(inst) \
(G_TYPE_INSTANCE_GET_INTERFACE ((inst), MIDORI_TYPE_VIEWABLE, \
MidoriViewableIface))
typedef struct _MidoriViewable MidoriViewable;
typedef struct _MidoriViewableIface MidoriViewableIface;
struct _MidoriViewableIface
{
GTypeInterface base_iface;
/* Virtual functions */
const gchar*
(*get_stock_id) (MidoriViewable* viewable);
const gchar*
(*get_label) (MidoriViewable* viewable);
GtkWidget*
(*get_toolbar) (MidoriViewable* viewable);
/* Private data */
gpointer p;
};
GType
midori_viewable_get_type (void);
GtkWidget*
midori_viewable_new_from_uri (const gchar* uri);
void
midori_viewable_register_protocol (GType type,
const gchar* protocol);
const gchar*
midori_viewable_get_stock_id (MidoriViewable* viewable);
const gchar*
midori_viewable_get_label (MidoriViewable* viewable);
GtkWidget*
midori_viewable_get_toolbar (MidoriViewable* viewable);
G_END_DECLS
#endif /* __MIDORI_VIEWABLE_H__ */

2
midori/midori.h
View file

@ -19,13 +19,13 @@
#include "midori-extension.h"
#include "midori-locationaction.h"
#include "midori-locationentry.h"
#include "midori-pane.h"
#include "midori-panel.h"
#include "midori-preferences.h"
#include "midori-searchaction.h"
#include "midori-source.h"
#include "midori-stock.h"
#include "midori-view.h"
#include "midori-viewable.h"
#include "midori-websettings.h"
/* For convenience, include localization header */