Replace QWebView with TypicaWebView for XML and script instantiations

src/Typica.pro

 HEADERS += moc_typica.cpp \
     helpmenu.h \
     abouttypica.h \
-    units.h
+    units.h \
+    webview.h
 SOURCES += typica.cpp \
     helpmenu.cpp \
     abouttypica.cpp \
-    units.cpp
+    units.cpp \
+    webview.cpp
 
 RESOURCES += \
     resources.qrc

src/typica.w

 	out = device;
 }
 
-@* Web views.
-
-The |QWebView| class was initially brought in to handle printing roast profile
-data. This works by transforming the roasting data to an XHTML+SVG document,
-loading it into a web view, and calling the |print()| method on that. Support
-has since been extended to make it easier to produce reports that require either
-postprocessing database results or database capabilities that are not readily
-available in the reporting framework.
-
-With this new use, future development should allow inclusion of a web view in
-the user interface without needing to instantiate it from a script.
-
-@<Set up the scripting engine@>=
-constructor = engine->newFunction(constructWebView);
-value = engine->newQMetaObject(&QWebView::staticMetaObject, constructor);
-engine->globalObject().setProperty("WebView", value);
-
-@ A few properties are required. These should be available regardless of how the
-object was created.
-
-@<Functions for scripting@>=
-QScriptValue constructWebView(QScriptContext *, QScriptEngine *engine)
-{
-	QScriptValue object = engine->newQObject(new QWebView());
-	setQWebViewProperties(object, engine);
-	return object;
-}
-
-void setQWebViewProperties(QScriptValue value, QScriptEngine *engine)
-{
-	setQWidgetProperties(value, engine);
-	value.setProperty("load", engine->newFunction(WebView_load));
-	value.setProperty("print", engine->newFunction(WebView_print));
-	value.setProperty("setHtml", engine->newFunction(WebView_setHtml));
-	value.setProperty("setContent", engine->newFunction(WebView_setContent));
-	value.setProperty("saveXml", engine->newFunction(WebView_saveXml));
-}
-
-@ To get data into the web view, we load it from a URL passed in the form of a
-string. This will usually be a local file, but it doesn't have to be.
-
-@<Functions for scripting@>=
-QScriptValue WebView_load(QScriptContext *context, QScriptEngine *)
-{
-	QWebView *self = getself<QWebView *>(context);
-	QString file = argument<QString>(0, context);
-	self->load(QUrl(file));
-	return QScriptValue();
-}
-
-@ When wrapping |QWebView::print()|, we need to obtain a |QPrinter| which that
-method expects. In order to set everything up properly, we display a standard
-print dialog.
-
-@<Functions for scripting@>=
-QScriptValue WebView_print(QScriptContext *context, QScriptEngine *)
-{
-	QWebView *self = getself<QWebView *>(context);
-	QPrinter *printer = new QPrinter(QPrinter::HighResolution);
-	QPrintDialog printDialog(printer, NULL);
-	if(printDialog.exec() == QDialog::Accepted)
-	{
-		self->print(printer);
-	}
-	return QScriptValue();
-}
-
-@ When wrapping |QWebView::setHtml()|, only the first argument containing the
-content is required.
-
-@<Functions for scripting@>=
-QScriptValue WebView_setHtml(QScriptContext *context, QScriptEngine *)
-{
-	QWebView *self = getself<QWebView *>(context);
-	QString content = argument<QString>(0, context);
-	self->setHtml(content);
-	return QScriptValue();
-}
-
-@ This is a simple wrapper around |QWebView::setContent()|, but it obtains its
-argument from the data in a |QIODevice|. A MIME type of application/xhtml+xml is
-specified by default to allow embedding SVG.
-
-@<Functions for scripting@>=
-QScriptValue WebView_setContent(QScriptContext *context, QScriptEngine *)
-{
-	QWebView *self = getself<QWebView *>(context);
-	QIODevice *device = argument<QIODevice *>(0, context);
-	device->reset();
-	QByteArray content = device->readAll();
-	self->setContent(content, "application/xhtml+xml");
-	return QScriptValue();
-}
-
-@ It should be possible to save the XHTML documents generated for reports. The
-saveXml property provides one way to do this.
-
-@<Functions for scripting@>=
-QScriptValue WebView_saveXml(QScriptContext *context, QScriptEngine *)
-{
-	QWebView *self = getself<QWebView *>(context);
-	return QScriptValue(self->page()->currentFrame()->documentElement().toOuterXml());
-}
-
-@ The web view can be created from the XML portion of the configuration
-document. This function adds the view to a box layout.
-
-@<Functions for scripting@>=
-void addWebViewToLayout(QDomElement element, QStack<QWidget *> *,
-                        QStack<QLayout *> *layoutStack)
-{
-	QWebView *view = new QWebView;
-	if(element.hasAttribute("id"))
-	{
-		view->setObjectName(element.attribute("id"));
-	}
-	QBoxLayout *layout = qobject_cast<QBoxLayout *>(layoutStack->top());
-	layout->addWidget(view);
-}
-
-@ The function prototypes used above follow.
-
-@<Function prototypes for scripting@>=
-QScriptValue constructWebView(QScriptContext *context, QScriptEngine *engine);
-QScriptValue WebView_load(QScriptContext *context, QScriptEngine *engine);
-QScriptValue WebView_print(QScriptContext *context, QScriptEngine *engine);
-QScriptValue WebView_setContent(QScriptContext *context, QScriptEngine *engine);
-QScriptValue WebView_setHtml(QScriptContext *context, QScriptEngine *engine);
-QScriptValue WebView_saveXml(QScriptContext *context, QScriptEngine *);
-void addWebViewToLayout(QDomElement element, QStack<QWidget *> *widgetStack,
-                        QStack<QLayout *> *layoutStack);
-void setQWebViewProperties(QScriptValue value, QScriptEngine *engine);
+@i webview.w
 
 @* The Application class.
 

src/webview.w

+@* Web Views in Typica.
+
+\noindent Typica makes extensive use of web views. All printing is currently
+handled by generating HTML with the required information, loading it into a web
+view, and using the print capabilities provided there. Reports are provided by
+running SQL queries, generating HTML, and displaying the results in a web view.
+Even the program'@q'@>s about window is primarily a web view.
+
+In order to simplify the implementation of certain features, we subclass
+|QWebView| and provide some additional functionality.
+
+@(webview.h@>=
+#include <QWebView>
+#include <QFile>
+#include <QMessageBox>
+#include <QDesktopServices>
+#include <QPrinter>
+#include <QPrintDialog>
+#include <QWebFrame>
+#include <QWebElement>
+
+#ifndef TypicaWebViewHeader
+#define TypicaWebViewHeader
+
+class TypicaWebView : public QWebView
+{
+	Q_OBJECT
+	public:
+		TypicaWebView();
+		Q_INVOKABLE void load(const QString &url);
+		Q_INVOKABLE void print();
+		Q_INVOKABLE void setHtml(const QString &html);
+		Q_INVOKABLE void setContent(QIODevice *device);
+		Q_INVOKABLE QString saveXml();
+	signals:
+		void scriptLinkClicked(const QString &link);
+	private slots:
+		void linkDelegate(const QUrl &url);
+};
+
+#endif
+
+@ The implementation is in a separate file.
+
+@(webview.cpp@>=
+#include "webview.h"
+
+@<TypicaWebView implementation@>@;
+
+@ In the constructor we set up our link delegation policy.
+
+@<TypicaWebView implementation@>=
+TypicaWebView::TypicaWebView() : QWebView()
+{
+	page()->setLinkDelegationPolicy(QWebPage::DelegateExternalLinks);
+	connect(page(), SIGNAL(linkClicked(QUrl)), this, SLOT(linkDelegate(QUrl)));
+}
+
+@ When a link is clicked, one of three things may happen. Certain reserved URLs
+will trigger an immediate event which is just handled internally without
+providing any kind of external notification. URLs that start with
+|"typica://script/"| will produce a signal containing the rest of the URL. This
+is intended for script code to intercept, interpret, and update the web view
+with the requested information. Everything else is passed to |QDesktopServices|
+which will defer to system-wide preferences for how to handle different link
+and file types.
+
+@<TypicaWebView implementation@>=
+void TypicaWebView::linkDelegate(const QUrl &url)
+{
+	if(url.scheme() == "typica")
+	{
+		QString address(url.toEncoded());
+		@<Detect and handle special links@>@;
+		@<Detect and handle script links@>@;
+	}
+	else
+	{
+		QDesktopServices::openUrl(url);
+	}
+}
+
+@ Currently the only special link is |"typica://aboutqt"| which brings up
+information about the Qt framework. This is used in the About Typica window.
+
+@<Detect and handle special links@>=
+if(address == "typica://aboutqt")
+{
+	QMessageBox::aboutQt(this);
+	return;
+}
+
+@ Script links split the link data to simplify interpretation in script code.
+
+@<Detect and handle script links@>=
+if(address.startsWith("typica://script/"))
+{
+	emit scriptLinkClicked(address.remove(0, 16));
+	return;
+}
+
+@ There is a limited set of functions that should be available to the host
+environment which are not declared as slots or otherwise have some missing
+functionality in the base class. In some cases the new functions can be
+distinguished by signature.
+
+@<TypicaWebView implementation@>=
+void TypicaWebView::load(const QString &url)
+{
+	QWebView::load(QUrl(url));
+}
+
+void TypicaWebView::print()
+{
+	QPrinter *printer = new QPrinter(QPrinter::HighResolution);
+	QPrintDialog printDialog(printer, NULL);
+	if(printDialog.exec() == QDialog::Accepted)
+	{
+		QWebView::print(printer);
+	}
+}
+
+void TypicaWebView::setHtml(const QString &html)
+{
+	QWebView::setHtml(html);
+}
+
+void TypicaWebView::setContent(QIODevice *device)
+{
+	device->reset();
+	QByteArray content = device->readAll();
+	QWebView::setContent(content, "application/xhtml+xml");
+}
+
+QString TypicaWebView::saveXml()
+{
+	return page()->currentFrame()->documentElement().toOuterXml();
+}
+
+@ Web views are exposed to the host environment in the usual manner.
+
+@<Set up the scripting engine@>=
+constructor = engine->newFunction(constructWebView);
+value = engine->newQMetaObject(&TypicaWebView::staticMetaObject, constructor);
+engine->globalObject().setProperty("WebView", value);
+
+@ Now that |QWebView| is subclassed, all of the features that we need should
+be available through the meta-object system automatically.
+
+@<Functions for scripting@>=
+QScriptValue constructWebView(QScriptContext *, QScriptEngine *engine)
+{
+	QScriptValue object = engine->newQObject(new TypicaWebView);
+	setQWebViewProperties(object, engine);
+	return object;
+}
+
+void setQWebViewProperties(QScriptValue value, QScriptEngine *engine)
+{
+	setQWidgetProperties(value, engine);
+}
+
+@ It is also possible to create these web views from the XML portion of the
+configuration document. A function is provided to add a new view to a box
+layout.
+
+@<Functions for scripting@>=
+void addWebViewToLayout(QDomElement element, QStack<QWidget *> *,
+                        QStack<QLayout *> *layoutStack)
+{
+	TypicaWebView *view = new TypicaWebView;
+	if(element.hasAttribute("id"))
+	{
+		view->setObjectName(element.attribute("id"));
+	}
+	QBoxLayout *layout = qobject_cast<QBoxLayout *>(layoutStack->top());
+	layout->addWidget(view);
+}
+
+@ Prototypes must be provided for these functions.
+
+@<Function prototypes for scripting@>=
+QScriptValue constructWebView(QScriptContext *context, QScriptEngine *engine);
+void setQWebViewProperties(QScriptValue value, QScriptEngine *engine);
+void addWebViewToLayout(QDomElement element, QStack<QWidget *> *widgetStack,
+                        QStack<QLayout *> *layoutStack);
+
+@ Finally, we must include our new header in |"typica.cpp"|.
+
+@<Header files to include@>=
+#include "webview.h"
+