diff --git a/mozilla/webshell/embed/gtk/examples/simplebrowser/simplebrowser.c b/mozilla/webshell/embed/gtk/examples/simplebrowser/simplebrowser.c index 2816305aced..4456e7d0e4b 100644 --- a/mozilla/webshell/embed/gtk/examples/simplebrowser/simplebrowser.c +++ b/mozilla/webshell/embed/gtk/examples/simplebrowser/simplebrowser.c @@ -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[] = "testing HTML streaming..."; + 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); diff --git a/mozilla/webshell/embed/gtk/lib/GtkMozillaContainer.cpp b/mozilla/webshell/embed/gtk/lib/GtkMozillaContainer.cpp index 14b59b4de72..48cbcf63388 100644 --- a/mozilla/webshell/embed/gtk/lib/GtkMozillaContainer.cpp +++ b/mozilla/webshell/embed/gtk/lib/GtkMozillaContainer.cpp @@ -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); +} diff --git a/mozilla/webshell/embed/gtk/lib/GtkMozillaContainer.h b/mozilla/webshell/embed/gtk/lib/GtkMozillaContainer.h index 2d99ce88e5e..ca9c2c32603 100644 --- a/mozilla/webshell/embed/gtk/lib/GtkMozillaContainer.h +++ b/mozilla/webshell/embed/gtk/lib/GtkMozillaContainer.h @@ -19,6 +19,7 @@ #include #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 */ diff --git a/mozilla/webshell/embed/gtk/lib/GtkMozillaInputStream.cpp b/mozilla/webshell/embed/gtk/lib/GtkMozillaInputStream.cpp new file mode 100644 index 00000000000..3f4552d7b0c --- /dev/null +++ b/mozilla/webshell/embed/gtk/lib/GtkMozillaInputStream.cpp @@ -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 (mCountmozilla_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(); +} + + + diff --git a/mozilla/webshell/embed/gtk/lib/gtkmozilla.h b/mozilla/webshell/embed/gtk/lib/gtkmozilla.h index c4a32f0798f..405cf6d60ec 100644 --- a/mozilla/webshell/embed/gtk/lib/gtkmozilla.h +++ b/mozilla/webshell/embed/gtk/lib/gtkmozilla.h @@ -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 }