Bommels05/Mozilla
Bommels05/Mozilla
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

First shot at streaming html or xml data to the widget.

Browse Source 
Try it out.
I've not updated to the tip yet, so i hope it works.


git-svn-id: svn://10.0.0.236/trunk@34118 18797224-902f-48f8-a5cc-f745e15eee43
This commit is contained in:
alla%lysator.liu.se 1999-06-07 23:00:10 +00:00
parent 1b96bb936c
commit 80ce270063
9 changed files with 467 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

83
mozilla/webshell/embed/gtk/examples/simplebrowser/simplebrowser.c
View File

@ -27,15 +27,15 @@ static void
set_buttons(struct browser *browser)
{
gtk_widget_set_sensitive(browser->back_button,
gtk_mozilla_can_back(browser->mozilla));
gtk_mozilla_can_back(browser->mozilla));
gtk_widget_set_sensitive(browser->forward_button,
gtk_mozilla_can_forward(browser->mozilla));
gtk_mozilla_can_forward(browser->mozilla));
}
static gint configure_event_after(GtkWidget *window,
GdkEvent *event,
GtkMozilla *moz)
GdkEvent *event,
GtkMozilla *moz)
{
GtkAllocation *alloc;
@ -45,17 +45,17 @@ static gint configure_event_after(GtkWidget *window,
}
static gint will_load_url(GtkWidget *mozilla,
const char *url,
GtkMozillaLoadType load_type,
struct browser *browser)
const char *url,
GtkMozillaLoadType load_type,
struct browser *browser)
{
printf("will_load_url(%s, %d)\n", url, load_type);
return 1; /* Return 0 if you don't want to load this url */
}
static void begin_load_url(GtkWidget *mozilla,
const char *url,
struct browser *browser)
const char *url,
struct browser *browser)
{
printf("begin_load_url(%s)\n", url);
gtk_entry_set_text(GTK_ENTRY(browser->url_entry), url);
@ -63,28 +63,46 @@ static void begin_load_url(GtkWidget *mozilla,
}
static void end_load_url(GtkMozilla *mozilla,
const gchar *url,
gint status)
const gchar *url,
gint status)
{
printf("end_load_url(%s, %d)\n", url, status);
}
static void back_clicked(GtkWidget *button,
gpointer arg)
gpointer arg)
{
GtkMozilla *moz = GTK_MOZILLA(arg);
gtk_mozilla_back(moz);
}
static void forward_clicked(GtkWidget *button,
gpointer arg)
gpointer arg)
{
GtkMozilla *moz = GTK_MOZILLA(arg);
gtk_mozilla_forward(moz);
}
static void stream_clicked(GtkWidget *button,
gpointer arg)
{
char buf[] = "<html><body>testing <a href=\"test.html\">HTML</a> streaming...</body></html>";
GtkMozilla *moz = GTK_MOZILLA(arg);
int c,i,size;
gtk_mozilla_stream_start_html(moz, "file://dummy/url/");
size = sizeof(buf);
i = 0;
while (size>0) {
c = gtk_mozilla_stream_write(moz, &buf[i], size );
size -= c;
i += c;
}
gtk_mozilla_stream_end(moz);
}
static void url_activate(GtkWidget *entry,
gpointer arg)
gpointer arg)
{
const char *str;
@ -103,6 +121,7 @@ int main( int argc,
GtkWidget *back_button;
GtkWidget *forward_button;
GtkWidget *url_entry;
GtkWidget *stream_button;
GtkWidget *mozilla;
struct browser browser;
@ -140,6 +159,10 @@ int main( int argc,
gtk_box_pack_start (GTK_BOX (hbox), url_entry, TRUE, TRUE, 0);
gtk_widget_show(url_entry);
stream_button = gtk_button_new_with_label("Test Stream");
gtk_box_pack_start (GTK_BOX (hbox), stream_button, FALSE, FALSE, 0);
gtk_widget_show(stream_button);
gtk_widget_show(hbox);
mozilla = gtk_mozilla_new();
@ -155,32 +178,36 @@ int main( int argc,
browser.url_entry = url_entry;
gtk_signal_connect_after(GTK_OBJECT (window), "configure_event",
(GtkSignalFunc) configure_event_after,
mozilla);
(GtkSignalFunc) configure_event_after,
mozilla);
gtk_signal_connect(GTK_OBJECT (mozilla), "will_load_url",
(GtkSignalFunc) will_load_url,
&browser);
(GtkSignalFunc) will_load_url,
&browser);
gtk_signal_connect(GTK_OBJECT (mozilla), "begin_load_url",
(GtkSignalFunc) begin_load_url,
&browser);
(GtkSignalFunc) begin_load_url,
&browser);
gtk_signal_connect(GTK_OBJECT (mozilla), "end_load_url",
(GtkSignalFunc) end_load_url,
&browser);
(GtkSignalFunc) end_load_url,
&browser);
gtk_signal_connect(GTK_OBJECT (back_button), "clicked",
(GtkSignalFunc) back_clicked,
mozilla);
(GtkSignalFunc) back_clicked,
mozilla);
gtk_signal_connect(GTK_OBJECT (url_entry), "activate",
(GtkSignalFunc) url_activate,
mozilla);
(GtkSignalFunc) url_activate,
mozilla);
gtk_signal_connect(GTK_OBJECT (forward_button), "clicked",
(GtkSignalFunc) forward_clicked,
mozilla);
(GtkSignalFunc) forward_clicked,
mozilla);
gtk_signal_connect(GTK_OBJECT (stream_button), "clicked",
(GtkSignalFunc) stream_clicked,
mozilla);
set_buttons(&browser);

165
mozilla/webshell/embed/gtk/lib/GtkMozillaContainer.cpp
View File

@ -18,17 +18,23 @@
#include "nsRepository.h"
#include "nsIWebShell.h"
#include "nsIURL.h"
#include "nsFileSpec.h"
#include "nsIDocumentLoader.h"
#include "nsIContentViewer.h"
#include "prprf.h"
static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
static NS_DEFINE_IID(kIWebShellIID, NS_IWEB_SHELL_IID);
static NS_DEFINE_IID(kWebShellCID, NS_WEB_SHELL_CID);
static NS_DEFINE_IID(kIWebShellContainerIID, NS_IWEB_SHELL_CONTAINER_IID);
static NS_DEFINE_IID(kIDocumentLoaderFactoryIID, NS_IDOCUMENTLOADERFACTORY_IID);
GtkMozillaContainer::GtkMozillaContainer(GtkMozilla *moz)
{
mWebShell = nsnull;
width = height = 0;
mStream = nsnull;
mozilla = moz;
gtk_widget_set_app_paintable(GTK_WIDGET(moz), PR_TRUE);
@ -235,8 +241,8 @@ static char *simple_unicode_to_char(const PRUnichar* aURL)
NS_IMETHODIMP
GtkMozillaContainer::WillLoadURL(nsIWebShell* aShell,
const PRUnichar* aURL,
nsLoadType aReason)
const PRUnichar* aURL,
nsLoadType aReason)
{
gint result = 1;
char *url = simple_unicode_to_char(aURL);
@ -261,7 +267,7 @@ GtkMozillaContainer::BeginLoadURL(nsIWebShell* aShell, const PRUnichar* aURL)
NS_IMETHODIMP
GtkMozillaContainer::EndLoadURL(nsIWebShell* aShell,
const PRUnichar* aURL, PRInt32 aStatus)
const PRUnichar* aURL, PRInt32 aStatus)
{
char *url = simple_unicode_to_char(aURL);
gtk_signal_emit_by_name(GTK_OBJECT(mozilla), "end_load_url",
@ -271,9 +277,48 @@ GtkMozillaContainer::EndLoadURL(nsIWebShell* aShell,
return NS_OK;
}
nsresult
GtkMozillaContainer::CreateContentViewer(nsIURL* aURL,
const char* aContentType,
const char *aCommand,
nsIContentViewerContainer* aContainer,
nsISupports* aExtraInfo,
nsIStreamListener** aDocListenerResult,
nsIContentViewer** aDocViewerResult)
{
// Lookup class-id for the command plus content-type combination
nsCID cid;
char id[500];
PR_snprintf(id, sizeof(id),
NS_DOCUMENT_LOADER_FACTORY_PROGID_PREFIX "%s/%s",
aCommand, aContentType);
nsresult rv = nsComponentManager::ProgIDToCLSID(id, &cid);
if (NS_FAILED(rv)) {
return rv;
}
// Create an instance of the document-loader-factory object
nsIDocumentLoaderFactory* factory;
rv = nsComponentManager::CreateInstance(cid, (nsISupports *)nsnull,
kIDocumentLoaderFactoryIID,
(void **)&factory);
if (NS_FAILED(rv)) {
return rv;
}
// Now create an instance of the content viewer
rv = factory->CreateInstance(aURL, aContentType, aCommand, aContainer,
aExtraInfo, aDocListenerResult,
aDocViewerResult);
NS_RELEASE(factory);
return rv;
}
NS_IMETHODIMP
GtkMozillaContainer::ProgressLoadURL(nsIWebShell* aShell, const PRUnichar* aURL, PRInt32 aProgress,
PRInt32 aProgressMax)
PRInt32 aProgressMax)
{
printf("Progress: %d (0..%d)\n", aProgress, aProgressMax);
return NS_OK;
@ -309,9 +354,9 @@ GtkMozillaContainer::ContentShellAdded(nsIWebShell* aChildShell, nsIContent* fra
NS_IMETHODIMP
GtkMozillaContainer::CreatePopup(nsIDOMElement* aElement, nsIDOMElement* aPopupContent,
PRInt32 aXPos, PRInt32 aYPos,
const nsString& aPopupType, const nsString& aPopupAlignment,
nsIDOMWindow* aWindow)
PRInt32 aXPos, PRInt32 aYPos,
const nsString& aPopupType, const nsString& aPopupAlignment,
nsIDOMWindow* aWindow)
{
printf("CreatePopup\n");
return NS_ERROR_FAILURE;
@ -346,3 +391,109 @@ GtkMozillaContainer::FocusAvailable(nsIWebShell* aFocusedWebShell, PRBool& aFocu
printf("FocusAvailable\n");
return NS_ERROR_FAILURE;
}
gint
GtkMozillaContainer::StartStream(const char *base_url, const char *action,
const char *content_type)
{
nsresult rv = NS_OK;
nsString url_str(base_url);
nsIURL* url = nsnull;
nsIContentViewer* viewer = nsnull;
nsIStreamListener* listener = nsnull;
rv = NS_NewURL(&url, url_str, NULL, mWebShell);
if (NS_FAILED(rv)) {
goto done;
}
rv = CreateContentViewer(url,
content_type,
action,
mWebShell,
nsnull,
&listener,
&viewer);
if (NS_FAILED(rv)) {
printf("GtkMozillaContainer: Unable to create ContentViewer for action=%s, content-type=%s\n", action, content_type);
goto done;
}
rv = viewer->SetContainer((nsIContentViewerContainer*)mWebShell);
if (NS_FAILED(rv)) {
goto done;
}
rv = mWebShell->Embed(viewer, action, nsnull);
if (NS_FAILED(rv)) {
goto done;
}
/*
* Pass the OnStartBinding(...) notification out to the document
* IStreamListener.
*/
rv = listener->OnStartBinding(url, content_type);
if (NS_FAILED(rv)) {
goto done;
}
mStream = new GtkMozillaInputStream();
mStreamURL = url;
mListener = listener;
done:
NS_IF_RELEASE(viewer);
if (NS_SUCCEEDED(rv))
return 0;
else
return -1;
}
gint
GtkMozillaContainer::WriteStream(const char *data, gint len)
{
nsresult rv = NS_OK;
PRUint32 Count;
mStream->Fill(data, len);
rv = mListener->OnDataAvailable(mStreamURL, mStream, len);
if (NS_FAILED(rv))
return 0;
rv = mListener->OnProgress(mStreamURL, len, len+1);
if (NS_FAILED(rv))
return 0;
mStream->FillResult(&Count);
return (gint) Count;
}
void
GtkMozillaContainer::EndStream(void)
{
nsresult rv = NS_OK;
mStream->Fill(NULL, 0);
rv = mListener->OnDataAvailable(mStreamURL, mStream, 0);
if (NS_FAILED(rv))
return;
rv = mListener->OnStopBinding(mStreamURL, NS_OK, NULL);
if (NS_FAILED(rv))
return;
rv = mListener->OnProgress(mStreamURL, 10, 10);
if (NS_FAILED(rv))
return;
NS_IF_RELEASE(mStreamURL);
NS_IF_RELEASE(mListener);
NS_IF_RELEASE(mStream);
}

22
mozilla/webshell/embed/gtk/lib/GtkMozillaContainer.h
View File

@ -19,6 +19,7 @@
#include <gtk/gtk.h>
#include "nsIWebShell.h"
#include "GtkMozillaInputStream.h"
#include "gtkmozilla.h"
@ -79,10 +80,29 @@ public:
gint GetHistoryLength();
gint GetHistoryIndex();
private:
/* Stream stuff: */
gint StartStream(const char *base_url, const char *action,
const char *content_type);
gint WriteStream(const char *data, gint len);
void EndStream(void);
protected:
nsresult CreateContentViewer(nsIURL* aURL,
const char* aContentType,
const char *aCommand,
nsIContentViewerContainer* aContainer,
nsISupports* aExtraInfo,
nsIStreamListener** aDocListenerResult,
nsIContentViewer** aDocViewerResult);
nsIWebShell *mWebShell;
GtkMozilla *mozilla;
int width, height;
/* Stream stuff: */
GtkMozillaInputStream *mStream;
nsIURL *mStreamURL;
nsIStreamListener *mListener;
};
#endif /* GTKMOZILLACONTAINER_H */

110
mozilla/webshell/embed/gtk/lib/GtkMozillaInputStream.cpp Normal file
View File

@ -0,0 +1,110 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* The contents of this file are subject to the Mozilla Public License
* Version 1.1 (the "MPL"); you may not use this file except in
* compliance with the MPL. You may obtain a copy of the NPL at
* http://www.mozilla.org/NPL/
*
* Software distributed under the NPL is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
* for the specific language governing rights and limitations under the
* NPL.
*
* The Initial Developer of the Original Code is Alexander. Portions
* created by Alexander Larsson are Copyright (C) 1999
* Alexander Larsson. All Rights Reserved.
*/
#include "GtkMozillaInputStream.h"
static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
static NS_DEFINE_IID(kIInputStreamIID, NS_IINPUTSTREAM_IID);
static NS_DEFINE_IID(kIBaseStreamIID, NS_IBASESTREAM_IID);
GtkMozillaInputStream::GtkMozillaInputStream(void)
{
mBuffer = nsnull;
}
GtkMozillaInputStream::~GtkMozillaInputStream(void)
{
}
NS_IMETHODIMP
GtkMozillaInputStream::QueryInterface(REFNSIID aIID, void** aInstancePtr)
{
if (NULL == aInstancePtr) {
return NS_ERROR_NULL_POINTER;
}
nsISupports *ifp = nsnull;
if (aIID.Equals(kIInputStreamIID)) {
ifp = (nsIInputStream*)this;
} else if(aIID.Equals(kIBaseStreamIID)) {
ifp = (nsIBaseStream*)this;;
} else if(aIID.Equals(kISupportsIID)) {
ifp = this;
} else {
*aInstancePtr = 0;
return NS_NOINTERFACE;
}
*aInstancePtr = (void *)ifp;
NS_ADDREF(ifp);
return NS_OK;
}
NS_IMPL_RELEASE(GtkMozillaInputStream)
NS_IMPL_ADDREF(GtkMozillaInputStream)
// nsIInputStream interface
NS_IMETHODIMP
GtkMozillaInputStream::GetLength(PRUint32 *aLength)
{
*aLength = mCount;
return NS_OK;
}
NS_IMETHODIMP
GtkMozillaInputStream::Read(char* aBuf, PRUint32 aCount, PRUint32 *aReadCount)
{
if (mCount<aCount)
mReadCount = mCount;
else
mReadCount = aCount;
memcpy(aBuf, mBuffer, mReadCount);
*aReadCount = mReadCount;
mBuffer = nsnull;
mCount = 0;
return NS_OK;
}
// nsIBaseStream interface
NS_IMETHODIMP
GtkMozillaInputStream::Close(void)
{
printf("GtkMozillaInputStream::Close() called.\n");
return NS_OK;
}
// Specific interface
NS_IMETHODIMP
GtkMozillaInputStream::Fill(const char *aBuffer, PRUint32 aCount)
{
mBuffer = aBuffer;
mCount = aCount;
return NS_OK;
}
NS_IMETHODIMP
GtkMozillaInputStream::FillResult(PRUint32 *aReadCount)
{
*aReadCount = mReadCount;
return NS_OK;
}

49
mozilla/webshell/embed/gtk/lib/GtkMozillaInputStream.h Normal file
View File

@ -0,0 +1,49 @@
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* The contents of this file are subject to the Mozilla Public License
* Version 1.1 (the "MPL"); you may not use this file except in
* compliance with the MPL. You may obtain a copy of the NPL at
* http://www.mozilla.org/NPL/
*
* Software distributed under the NPL is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
* for the specific language governing rights and limitations under the
* NPL.
*
* The Initial Developer of the Original Code is Alexander. Portions
* created by Alexander Larsson are Copyright (C) 1999
* Alexander Larsson. All Rights Reserved.
*/
#ifndef GTKMOZILLAINPUTSTREAM_H
#define GTKMOZILLAINPUTSTREAM_H
#include "nsIInputStream.h"
class GtkMozillaInputStream : public nsIInputStream {
public:
GtkMozillaInputStream(void);
~GtkMozillaInputStream(void);
// nsISupports interface
NS_DECL_ISUPPORTS
// nsIInputStream interface
NS_IMETHOD GetLength(PRUint32 *aLength);
NS_IMETHOD Read(char* aBuf, PRUint32 aCount, PRUint32 *aReadCount);
// nsIBaseStream interface
NS_IMETHOD Close(void);
// Specific interface
NS_IMETHOD Fill(const char *buffer, PRUint32 aCount);
NS_IMETHOD FillResult(PRUint32 *aReadCount);
protected:
PRUint32 mReadCount;
PRUint32 mCount;
const char *mBuffer;
};
#endif /* GTKMOZILLAINPUTSTREAM_H */

2
mozilla/webshell/embed/gtk/lib/Makefile.am
View File

@ -7,6 +7,8 @@ libgtkmozilla_la_SOURCES = \
gtkmozilla.h \
GtkMozillaContainer.h \
GtkMozillaContainer.cpp \
GtkMozillaInputStream.h \
GtkMozillaInputStream.cpp \
nsSetupRegistry.cpp
MOZILLA_INCLUDES = -I@MOZILLA_DIR@/dist/include

8
mozilla/webshell/embed/gtk/lib/Makefile.in
View File

@ -82,7 +82,7 @@ VERSION = @VERSION@
lib_LTLIBRARIES = libgtkmozilla.la
include_HEADERS = gtkmozilla.h
libgtkmozilla_la_SOURCES = gtkmozilla.cpp gtkmozilla.h GtkMozillaContainer.h GtkMozillaContainer.cpp nsSetupRegistry.cpp
libgtkmozilla_la_SOURCES = gtkmozilla.cpp gtkmozilla.h GtkMozillaContainer.h GtkMozillaContainer.cpp GtkMozillaInputStream.h GtkMozillaInputStream.cpp nsSetupRegistry.cpp
MOZILLA_INCLUDES = -I@MOZILLA_DIR@/dist/include
@ -141,7 +141,7 @@ LIBS = @LIBS@
libgtkmozilla_la_LDFLAGS =
libgtkmozilla_la_DEPENDENCIES =
libgtkmozilla_la_OBJECTS = gtkmozilla.lo GtkMozillaContainer.lo \
nsSetupRegistry.lo
GtkMozillaInputStream.lo nsSetupRegistry.lo
CXXFLAGS = @CXXFLAGS@
CXXCOMPILE = $(CXX) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
LTCXXCOMPILE = $(LIBTOOL) --mode=compile $(CXX) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
@ -161,8 +161,8 @@ DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) $(TEXINFOS) $(EXTRA_DIST)
TAR = gtar
GZIP_ENV = --best
DEP_FILES = .deps/GtkMozillaContainer.P .deps/gtkmozilla.P \
.deps/nsSetupRegistry.P
DEP_FILES = .deps/GtkMozillaContainer.P .deps/GtkMozillaInputStream.P \
.deps/gtkmozilla.P .deps/nsSetupRegistry.P
SOURCES = $(libgtkmozilla_la_SOURCES)
OBJECTS = $(libgtkmozilla_la_OBJECTS)

44
mozilla/webshell/embed/gtk/lib/gtkmozilla.cpp
View File

@ -353,3 +353,47 @@ gtk_mozilla_get_history_index(GtkMozilla *moz)
moz_container = (class GtkMozillaContainer *)moz->mozilla_container;
return moz_container->GetHistoryIndex();
}
gint
gtk_mozilla_stream_start(GtkMozilla *moz,
const char *base_url,
const char *action,
const char *content_type)
{
class GtkMozillaContainer *moz_container;
moz_container = (class GtkMozillaContainer *)moz->mozilla_container;
return moz_container->StartStream(base_url, action, content_type);
}
gint
gtk_mozilla_stream_start_html(GtkMozilla *moz,
const char *base_url)
{
gtk_mozilla_stream_start(moz, base_url, "view", "text/html");
}
gint
gtk_mozilla_stream_write(GtkMozilla *moz,
const char *data,
gint len)
{
class GtkMozillaContainer *moz_container;
moz_container = (class GtkMozillaContainer *)moz->mozilla_container;
// Returns the number of bytes written!
return moz_container->WriteStream(data, len);
}
void
gtk_mozilla_stream_end(GtkMozilla *moz)
{
class GtkMozillaContainer *moz_container;
moz_container = (class GtkMozillaContainer *)moz->mozilla_container;
moz_container->EndStream();
}

39
mozilla/webshell/embed/gtk/lib/gtkmozilla.h
View File

@ -43,10 +43,9 @@ typedef enum GtkMozillaLoadType {
GTK_LOAD_REFRESH
} GtkMozillaLoadType;
typedef struct _GtkMozilla GtkMozilla;
typedef struct _GtkMozillaClass GtkMozillaClass;
struct _GtkMozilla
{
GtkLayout layout;
@ -68,21 +67,31 @@ struct _GtkMozillaClass
gint status);
};
GtkType gtk_mozilla_get_type (void);
GtkWidget* gtk_mozilla_new (void);
extern GtkType gtk_mozilla_get_type(void);
extern GtkWidget* gtk_mozilla_new(void);
void gtk_mozilla_load_url(GtkMozilla *moz, const char *url);
void gtk_mozilla_stop(GtkMozilla *moz);
void gtk_mozilla_reload(GtkMozilla *moz, GtkMozillaReloadType reload_type);
void gtk_mozilla_resize(GtkMozilla *moz, gint width, gint height);
extern void gtk_mozilla_load_url(GtkMozilla *moz, const char *url);
extern void gtk_mozilla_stop(GtkMozilla *moz);
extern void gtk_mozilla_reload(GtkMozilla *moz, GtkMozillaReloadType reload_type);
extern void gtk_mozilla_resize(GtkMozilla *moz, gint width, gint height);
void gtk_mozilla_back(GtkMozilla *moz);
void gtk_mozilla_forward(GtkMozilla *moz);
gint gtk_mozilla_can_back(GtkMozilla *moz);
gint gtk_mozilla_can_forward(GtkMozilla *moz);
void gtk_mozilla_goto_history(GtkMozilla *moz, gint index);
gint gtk_mozilla_get_history_length(GtkMozilla *moz);
gint gtk_mozilla_get_history_index(GtkMozilla *moz);
extern void gtk_mozilla_back(GtkMozilla *moz);
extern void gtk_mozilla_forward(GtkMozilla *moz);
extern gint gtk_mozilla_can_back(GtkMozilla *moz);
extern gint gtk_mozilla_can_forward(GtkMozilla *moz);
extern void gtk_mozilla_goto_history(GtkMozilla *moz, gint index);
extern gint gtk_mozilla_get_history_length(GtkMozilla *moz);
extern gint gtk_mozilla_get_history_index(GtkMozilla *moz);
extern gint gtk_mozilla_stream_start(GtkMozilla *moz,
const char *base_url,
const char *action,
const char *content_type);
extern gint gtk_mozilla_stream_start_html(GtkMozilla *moz,
const char *base_url);
extern gint gtk_mozilla_stream_write(GtkMozilla *moz, const char *data,
gint len);
extern void gtk_mozilla_stream_end(GtkMozilla *moz);
#ifdef __cplusplus
}