Qt platform layer added. Based on an implementation from Jason Haslam

at Scientific Toolworks, Inc. with additions performed for Wingware.

22 files changed, 4838 insertions, 0 deletions

diff --git a/qt/README b/qt/README
new file mode 100644
index 000000000..a39008b38
--- /dev/null
+++ b/qt/README
@@ -0,0 +1,36 @@
+README for building of Scintilla on Qt

+

+There are three different Scintilla libraries that can be produced:

+

+	ScintillaEditBase

+A basic widget callable from C++ which is small and can be used just as is 

+or with higher level functionality added.

+

+	ScintillaEdit

+A more complete C++ widget with a method for every Scintilla API and a

+secondary API allowing direct access to document objects.

+

+	ScintillaEditPy

+A Python callable version of ScintillaEdit using the PySide bindings.

+

+	Building a library

+

+ScintillaEditBase can be built without performing any generation steps.

+The ScintillaEditBase/ScintillaEditBase.pro project can be loaded into 

+Qt Creator and the "Build All" command performed.

+Alternatively, run "qmake" to build make files and then use the platform

+make to build. Most commonly, use "make" on Unix and "nmake"

+on Windows.

+

+ScintillaEdit requires a generation command be run first. From the 

+ScintillaEdit directory:

+

+python WidgetGen.py

+

+After the generation command has run, the ScintillaEdit.h and

+ScintillaEdit.cpp files will have been populated with the Scintilla API

+methods. 

+To build, use Qt Creator or qmake and make as for ScintillaEditBase.

+

+ScintillaEditPy is more complex and instructions are found in 

+ScintillaEditPy/README.

diff --git a/qt/ScintillaEdit/ScintillaDocument.cpp b/qt/ScintillaEdit/ScintillaDocument.cpp
new file mode 100644
index 000000000..801f6a385
--- /dev/null
+++ b/qt/ScintillaEdit/ScintillaDocument.cpp
@@ -0,0 +1,286 @@
+// ScintillaDocument.cpp
+// Wrapper for Scintilla document object so it can be manipulated independently.
+// Copyright (c) 2011 Archaeopteryx Software, Inc. d/b/a Wingware
+
+#include <vector>
+#include <map>
+
+#include "ScintillaDocument.h"
+
+#include "Platform.h"
+
+#include "ILexer.h"
+#include "Scintilla.h"
+
+#include "SplitVector.h"
+#include "Partitioning.h"
+#include "RunStyles.h"
+#include "ContractionState.h"
+#include "CellBuffer.h"
+#include "KeyMap.h"
+#include "Indicator.h"
+#include "XPM.h"
+#include "LineMarker.h"
+#include "Style.h"
+#include "ViewStyle.h"
+#include "CharClassify.h"
+#include "Decoration.h"
+#include "Document.h"
+
+class WatcherHelper : public DocWatcher {
+	ScintillaDocument *owner;
+public:
+	WatcherHelper(ScintillaDocument *owner_);
+	virtual ~WatcherHelper();
+
+	void NotifyModifyAttempt(Document *doc, void *userData);
+	void NotifySavePoint(Document *doc, void *userData, bool atSavePoint);
+	void NotifyModified(Document *doc, DocModification mh, void *userData);
+	void NotifyDeleted(Document *doc, void *userData);
+	void NotifyStyleNeeded(Document *doc, void *userData, int endPos);
+	void NotifyLexerChanged(Document *doc, void *userData);
+	void NotifyErrorOccurred(Document *doc, void *userData, int status);
+};
+
+WatcherHelper::WatcherHelper(ScintillaDocument *owner_) : owner(owner_) {
+}
+
+WatcherHelper::~WatcherHelper() {
+}
+
+void WatcherHelper::NotifyModifyAttempt(Document *, void *) {
+	owner->emit_modify_attempt();
+}
+
+void WatcherHelper::NotifySavePoint(Document *, void *, bool atSavePoint) {
+	owner->emit_save_point(atSavePoint);
+}
+
+void WatcherHelper::NotifyModified(Document *, DocModification mh, void *) {
+    int length = mh.length;
+    if (!mh.text)
+        length = 0;
+    QByteArray ba = QByteArray::fromRawData(mh.text, length);
+    owner->emit_modified(mh.position, mh.modificationType, ba, length,
+        mh.linesAdded, mh.line, mh.foldLevelNow, mh.foldLevelPrev);
+}
+
+void WatcherHelper::NotifyDeleted(Document *, void *) {
+}
+
+void WatcherHelper::NotifyStyleNeeded(Document *, void *, int endPos) {
+	owner->emit_style_needed(endPos);
+}
+
+void WatcherHelper::NotifyLexerChanged(Document *, void *) {
+    owner->emit_lexer_changed();
+}
+
+void WatcherHelper::NotifyErrorOccurred(Document *, void *, int status) {
+    owner->emit_error_occurred(status);
+}
+
+ScintillaDocument::ScintillaDocument(QObject *parent, void *pdoc_) :
+    QObject(parent), pdoc(pdoc_), docWatcher(0) {
+    if (!pdoc) {
+        pdoc = new Document();
+    }
+    docWatcher = new WatcherHelper(this);
+    ((Document *)pdoc)->AddRef();
+    ((Document *)pdoc)->AddWatcher(docWatcher, pdoc);
+}
+
+ScintillaDocument::~ScintillaDocument() {
+    Document *doc = static_cast<Document *>(pdoc);
+    if (doc) {
+        doc->RemoveWatcher(docWatcher, doc);
+        doc->Release();
+    }
+    pdoc = NULL;
+    delete docWatcher;
+    docWatcher = NULL;
+}
+
+void *ScintillaDocument::pointer() {
+	return pdoc;
+}
+
+int ScintillaDocument::line_from_position(int pos) {
+    return ((Document *)pdoc)->LineFromPosition(pos);
+}
+
+bool ScintillaDocument::is_cr_lf(int pos) {
+    return ((Document *)pdoc)->IsCrLf(pos);
+}
+
+bool ScintillaDocument::delete_chars(int pos, int len) {
+    return ((Document *)pdoc)->DeleteChars(pos, len);
+}
+
+int ScintillaDocument::undo() {
+    return ((Document *)pdoc)->Undo();
+}
+
+int ScintillaDocument::redo() {
+    return ((Document *)pdoc)->Redo();
+}
+
+bool ScintillaDocument::can_undo() {
+    return ((Document *)pdoc)->CanUndo();
+}
+
+bool ScintillaDocument::can_redo() {
+    return ((Document *)pdoc)->CanRedo();
+}
+
+void ScintillaDocument::delete_undo_history() {
+    ((Document *)pdoc)->DeleteUndoHistory();
+}
+
+bool ScintillaDocument::set_undo_collection(bool collect_undo) {
+    return ((Document *)pdoc)->SetUndoCollection(collect_undo);
+}
+
+bool ScintillaDocument::is_collecting_undo() {
+    return ((Document *)pdoc)->IsCollectingUndo();
+}
+
+void ScintillaDocument::begin_undo_action() {
+    ((Document *)pdoc)->BeginUndoAction();
+}
+
+void ScintillaDocument::end_undo_action() {
+    ((Document *)pdoc)->EndUndoAction();
+}
+
+void ScintillaDocument::set_save_point() {
+    ((Document *)pdoc)->SetSavePoint();
+}
+
+bool ScintillaDocument::is_save_point() {
+    return ((Document *)pdoc)->IsSavePoint();
+}
+
+void ScintillaDocument::set_read_only(bool read_only) {
+    ((Document *)pdoc)->SetReadOnly(read_only);
+}
+
+bool ScintillaDocument::is_read_only() {
+    return ((Document *)pdoc)->IsReadOnly();
+}
+
+void ScintillaDocument::insert_string(int position, QByteArray &str) {
+    ((Document *)pdoc)->InsertString(position, str.data(), str.size());
+}
+
+QByteArray ScintillaDocument::get_char_range(int position, int length) {
+    Document *doc = (Document *)pdoc;
+
+    if (position < 0 || length <= 0 || position + length > doc->Length())
+        return QByteArray();
+
+    QByteArray ba(length, '\0');
+    doc->GetCharRange(ba.data(), position, length);
+    return ba;
+}
+
+char ScintillaDocument::style_at(int position) {
+    return ((Document *)pdoc)->StyleAt(position);
+}
+
+int ScintillaDocument::line_start(int lineno) {
+    return ((Document *)pdoc)->LineStart(lineno);
+}
+
+int ScintillaDocument::line_end(int lineno) {
+    return ((Document *)pdoc)->LineEnd(lineno);
+}
+
+int ScintillaDocument::line_end_position(int pos) {
+    return ((Document *)pdoc)->LineEndPosition(pos);
+}
+
+int ScintillaDocument::length() {
+    return ((Document *)pdoc)->Length();
+}
+
+int ScintillaDocument::lines_total() {
+    return ((Document *)pdoc)->LinesTotal();
+}
+
+void ScintillaDocument::start_styling(int position, char flags) {
+    ((Document *)pdoc)->StartStyling(position, flags);
+}
+
+bool ScintillaDocument::set_style_for(int length, char style) {
+    return ((Document *)pdoc)->SetStyleFor(length, style);
+}
+
+int ScintillaDocument::get_end_styled() {
+    return ((Document *)pdoc)->GetEndStyled();
+}
+
+void ScintillaDocument::ensure_styled_to(int position) {
+    ((Document *)pdoc)->EnsureStyledTo(position);
+}
+
+void ScintillaDocument::set_current_indicator(int indic) {
+    ((Document *)pdoc)->decorations.SetCurrentIndicator(indic);
+}
+
+void ScintillaDocument::decoration_fill_range(int position, int value, int fillLength) {
+    ((Document *)pdoc)->DecorationFillRange(position, value, fillLength);
+}
+
+int ScintillaDocument::decorations_value_at(int indic, int position) {
+    return ((Document *)pdoc)->decorations.ValueAt(indic, position);
+}
+
+int ScintillaDocument::decorations_start(int indic, int position) {
+    return ((Document *)pdoc)->decorations.Start(indic, position);
+}
+
+int ScintillaDocument::decorations_end(int indic, int position) {
+    return ((Document *)pdoc)->decorations.End(indic, position);
+}
+
+int ScintillaDocument::get_code_page() {
+    return ((Document *)pdoc)->CodePage();
+}
+
+void ScintillaDocument::set_code_page(int code_page) {
+    ((Document *)pdoc)->dbcsCodePage = code_page;
+}
+
+int ScintillaDocument::move_position_outside_char(int pos, int move_dir, bool check_line_end) {
+    return ((Document *)pdoc)->MovePositionOutsideChar(pos, move_dir, check_line_end);
+}
+
+// Signal emitters
+
+void ScintillaDocument::emit_modify_attempt() {
+    emit modify_attempt();
+}
+
+void ScintillaDocument::emit_save_point(bool atSavePoint) {
+    emit save_point(atSavePoint);
+}
+
+void ScintillaDocument::emit_modified(int position, int modification_type, const QByteArray& text, int length,
+    int linesAdded, int line, int foldLevelNow, int foldLevelPrev) {
+    emit modified(position, modification_type, text, length,
+        linesAdded, line, foldLevelNow, foldLevelPrev);
+}
+
+void ScintillaDocument::emit_style_needed(int pos) {
+    emit style_needed(pos);
+}
+
+void ScintillaDocument::emit_lexer_changed() {
+    emit lexer_changed();
+}
+
+void ScintillaDocument::emit_error_occurred(int status) {
+    emit error_occurred(status);
+}
+
diff --git a/qt/ScintillaEdit/ScintillaDocument.h b/qt/ScintillaEdit/ScintillaDocument.h
new file mode 100644
index 000000000..3cf16e334
--- /dev/null
+++ b/qt/ScintillaEdit/ScintillaDocument.h
@@ -0,0 +1,97 @@
+// ScintillaDocument.h
+// Wrapper for Scintilla document object so it can be manipulated independently.
+// Copyright (c) 2011 Archaeopteryx Software, Inc. d/b/a Wingware
+
+#ifndef SCINTILLADOCUMENT_H
+#define SCINTILLADOCUMENT_H
+
+#include <QObject>
+
+class WatcherHelper;
+
+#ifndef EXPORT_IMPORT_API
+#ifdef WIN32
+#ifdef MAKING_LIBRARY
+#define EXPORT_IMPORT_API __declspec(dllexport)
+#else
+// Defining dllimport upsets moc
+#define EXPORT_IMPORT_API __declspec(dllimport)
+//#define EXPORT_IMPORT_API
+#endif
+#else
+#define EXPORT_IMPORT_API
+#endif
+#endif
+
+class EXPORT_IMPORT_API ScintillaDocument : public QObject
+{
+    Q_OBJECT
+
+    void *pdoc;
+    WatcherHelper *docWatcher;
+
+public:
+    explicit ScintillaDocument(QObject *parent = 0, void *pdoc_=0);
+    virtual ~ScintillaDocument();
+    void *pointer();
+
+    int line_from_position(int pos);
+    bool is_cr_lf(int pos);
+    bool delete_chars(int pos, int len);
+    int undo();
+    int redo();
+    bool can_undo();
+    bool can_redo();
+    void delete_undo_history();
+    bool set_undo_collection(bool collect_undo);
+    bool is_collecting_undo();
+    void begin_undo_action();
+    void end_undo_action();
+    void set_save_point();
+    bool is_save_point();
+    void set_read_only(bool read_only);
+    bool is_read_only();
+    void insert_string(int position, QByteArray &str);
+    QByteArray get_char_range(int position, int length);
+    char style_at(int position);
+    int line_start(int lineno);
+    int line_end(int lineno);
+    int line_end_position(int pos);
+    int length();
+    int lines_total();
+    void start_styling(int position, char flags);
+    bool set_style_for(int length, char style);
+    int get_end_styled();
+    void ensure_styled_to(int position);
+    void set_current_indicator(int indic);
+    void decoration_fill_range(int position, int value, int fillLength);
+    int decorations_value_at(int indic, int position);
+    int decorations_start(int indic, int position);
+    int decorations_end(int indic, int position);
+    int get_code_page();
+    void set_code_page(int code_page);
+    int move_position_outside_char(int pos, int move_dir, bool check_line_end);
+
+private:
+    void emit_modify_attempt();
+    void emit_save_point(bool atSavePoint);
+    void emit_modified(int position, int modification_type, const QByteArray& text, int length,
+	int linesAdded, int line, int foldLevelNow, int foldLevelPrev);
+    void emit_style_needed(int pos);
+    void emit_lexer_changed();
+    void emit_error_occurred(int status);
+
+signals:
+    void modify_attempt();
+    void save_point(bool atSavePoint);
+    void modified(int position, int modification_type, const QByteArray& text, int length,
+	int linesAdded, int line, int foldLevelNow, int foldLevelPrev);
+    void style_needed(int pos);
+    void lexer_changed();
+    void error_occurred(int status);
+
+    friend class WatcherHelper;
+
+};
+
+#endif // SCINTILLADOCUMENT_H
diff --git a/qt/ScintillaEdit/ScintillaEdit.cpp.template b/qt/ScintillaEdit/ScintillaEdit.cpp.template
new file mode 100644
index 000000000..431e79c4e
--- /dev/null
+++ b/qt/ScintillaEdit/ScintillaEdit.cpp.template
@@ -0,0 +1,59 @@
+// ScintillaEdit.cpp
+// Extended version of ScintillaEditBase with a method for each API
+// Copyright (c) 2011 Archaeopteryx Software, Inc. d/b/a Wingware
+
+#include "ScintillaEdit.h"
+
+ScintillaEdit::ScintillaEdit(QWidget *parent) : ScintillaEditBase(parent) {
+}
+
+ScintillaEdit::~ScintillaEdit() {
+}
+
+QByteArray ScintillaEdit::TextReturner(int message, uptr_t wParam) const {
+    int length = send(message, wParam, 0);
+    QByteArray ba(length, '\0');
+    send(message, wParam, (sptr_t)ba.data());
+    // Remove extra NULs
+    if (ba.size() > 0 && ba.at(ba.size()-1) == 0)
+        ba.chop(1);
+    return ba;
+}
+
+QPair<int, int>ScintillaEdit::find_text(int flags, const char *text, int cpMin, int cpMax) {
+    struct TextToFind ft = {{0, 0}, 0, {0, 0}};
+    ft.chrg.cpMin = cpMin;
+    ft.chrg.cpMax = cpMax;
+    ft.chrgText.cpMin = cpMin;
+    ft.chrgText.cpMax = cpMax;
+    ft.lpstrText = const_cast<char *>(text);
+
+    send(SCI_FINDTEXT, flags, (uptr_t) (&ft));
+
+    return QPair<int,int>(ft.chrgText.cpMin, ft.chrgText.cpMax);
+}
+
+QByteArray ScintillaEdit::get_text_range(int start, int end) {
+    if (start > end)
+        start = end;
+
+    int length = end-start;
+    QByteArray ba(length+1, '\0');
+    struct TextRange tr = {{start, end}, ba.data()};
+
+    length = send(SCI_GETTEXTRANGE, 0, (sptr_t)&tr);
+    ba.chop(1); // Remove extra NUL
+
+    return ba;
+}
+
+ScintillaDocument *ScintillaEdit::get_doc() {
+    return new ScintillaDocument(0, (void *)send(SCI_GETDOCPOINTER, 0, 0));
+}
+
+void ScintillaEdit::set_doc(ScintillaDocument *pdoc_) {
+    send(SCI_SETDOCPOINTER, 0, (sptr_t)(pdoc_->pointer()));
+}
+
+/* ++Autogenerated -- start of section automatically generated from Scintilla.iface */
+/* --Autogenerated -- end of section automatically generated from Scintilla.iface */
diff --git a/qt/ScintillaEdit/ScintillaEdit.h.template b/qt/ScintillaEdit/ScintillaEdit.h.template
new file mode 100644
index 000000000..32c8a7726
--- /dev/null
+++ b/qt/ScintillaEdit/ScintillaEdit.h.template
@@ -0,0 +1,63 @@
+// ScintillaEdit.h
+// Extended version of ScintillaEditBase with a method for each API
+// Copyright (c) 2011 Archaeopteryx Software, Inc. d/b/a Wingware
+
+#ifndef SCINTILLAEDIT_H
+#define SCINTILLAEDIT_H
+
+#include <QPair>
+
+#include "ScintillaEditBase.h"
+#include "ScintillaDocument.h"
+
+#ifdef SCI_NAMESPACE
+namespace Scintilla {
+#endif
+
+#ifndef EXPORT_IMPORT_API
+#ifdef WIN32
+#ifdef MAKING_LIBRARY
+#define EXPORT_IMPORT_API __declspec(dllexport)
+#else
+// Defining dllimport upsets moc
+#define EXPORT_IMPORT_API __declspec(dllimport)
+//#define EXPORT_IMPORT_API
+#endif
+#else
+#define EXPORT_IMPORT_API
+#endif
+#endif
+
+class EXPORT_IMPORT_API ScintillaEdit : public ScintillaEditBase {
+	Q_OBJECT
+
+public:
+	ScintillaEdit(QWidget *parent = 0);
+	virtual ~ScintillaEdit();
+
+	QByteArray TextReturner(int message, uptr_t wParam) const;
+
+	QPair<int, int>find_text(int flags, const char *text, int cpMin, int cpMax);
+	QByteArray get_text_range(int start, int end);
+        ScintillaDocument *get_doc();
+        void set_doc(ScintillaDocument *pdoc_);
+
+	// Same as previous two methods but with Qt style names
+	QPair<int, int>findText(int flags, const char *text, int cpMin, int cpMax) {
+		return find_text(flags, text, cpMin, cpMax);
+	}
+
+	QByteArray textRange(int start, int end) {
+		return get_text_range(start, end);
+	}
+
+/* ++Autogenerated -- start of section automatically generated from Scintilla.iface */
+/* --Autogenerated -- end of section automatically generated from Scintilla.iface */
+
+};
+
+#ifdef SCI_NAMESPACE
+}
+#endif
+
+#endif /* SCINTILLAEDIT_H */
diff --git a/qt/ScintillaEdit/ScintillaEdit.pro b/qt/ScintillaEdit/ScintillaEdit.pro
new file mode 100644
index 000000000..d6422ac54
--- /dev/null
+++ b/qt/ScintillaEdit/ScintillaEdit.pro
@@ -0,0 +1,72 @@
+#-------------------------------------------------
+#
+# Project created by QtCreator 2011-05-05T12:41:23
+#
+#-------------------------------------------------
+
+QT       += core gui
+
+TARGET = ScintillaEdit
+TEMPLATE = lib
+CONFIG += lib_bundle
+
+VERSION = 3.1.0
+
+SOURCES += \
+    ScintillaEdit.cpp \
+    ScintillaDocument.cpp \
+    ../ScintillaEditBase/PlatQt.cpp \
+    ../ScintillaEditBase/ScintillaQt.cpp \
+    ../ScintillaEditBase/ScintillaEditBase.cpp \
+    ../../src/XPM.cxx \
+    ../../src/ViewStyle.cxx \
+    ../../src/UniConversion.cxx \
+    ../../src/Style.cxx \
+    ../../src/Selection.cxx \
+    ../../src/ScintillaBase.cxx \
+    ../../src/RunStyles.cxx \
+    ../../src/RESearch.cxx \
+    ../../src/PositionCache.cxx \
+    ../../src/PerLine.cxx \
+    ../../src/LineMarker.cxx \
+    ../../src/KeyMap.cxx \
+    ../../src/Indicator.cxx \
+    ../../src/ExternalLexer.cxx \
+    ../../src/Editor.cxx \
+    ../../src/Document.cxx \
+    ../../src/Decoration.cxx \
+    ../../src/ContractionState.cxx \
+    ../../src/CharClassify.cxx \
+    ../../src/CellBuffer.cxx \
+    ../../src/Catalogue.cxx \
+    ../../src/CallTip.cxx \
+    ../../src/AutoComplete.cxx \
+    ../../lexlib/WordList.cxx \
+    ../../lexlib/StyleContext.cxx \
+    ../../lexlib/PropSetSimple.cxx \
+    ../../lexlib/LexerSimple.cxx \
+    ../../lexlib/LexerNoExceptions.cxx \
+    ../../lexlib/LexerModule.cxx \
+    ../../lexlib/LexerBase.cxx \
+    ../../lexlib/CharacterSet.cxx \
+    ../../lexlib/Accessor.cxx \
+    ../../lexers/*.cxx
+
+HEADERS  += \
+    ScintillaEdit.h \
+    ScintillaDocument.h \
+    ../ScintillaEditBase/ScintillaEditBase.h \
+    ../ScintillaEditBase/ScintillaQt.h
+
+OTHER_FILES +=
+
+INCLUDEPATH += ../ScintillaEditBase ../../include ../../src ../../lexlib
+
+DEFINES += SCINTILLA_QT=1 MAKING_LIBRARY=1 SCI_LEXER=1 _CRT_SECURE_NO_DEPRECATE=1
+
+DESTDIR = ../../bin
+DLLDESTDIR = ../../bin
+
+macx {
+	QMAKE_LFLAGS_SONAME = -Wl,-install_name,@executable_path/../Frameworks/
+}
diff --git a/qt/ScintillaEdit/WidgetGen.py b/qt/ScintillaEdit/WidgetGen.py
new file mode 100644
index 000000000..8065b5f9d
--- /dev/null
+++ b/qt/ScintillaEdit/WidgetGen.py
@@ -0,0 +1,275 @@
+#!/usr/bin/env python
+# WidgetGen.py - regenerate the ScintillaWidgetCpp.cpp and ScintillaWidgetCpp.h files
+# Check that API includes all gtkscintilla2 functions
+
+import sys
+import os
+import getopt
+
+scintillaDirectory = "../.."
+scintillaIncludeDirectory = os.path.join(scintillaDirectory, "include")
+sys.path.append(scintillaIncludeDirectory)
+import Face
+
+def Contains(s,sub):
+	return s.find(sub) != -1
+
+def underscoreName(s):
+	# Name conversion fixes to match gtkscintilla2
+	irregular = ['WS', 'EOL', 'AutoC', 'KeyWords', 'BackSpace', 'UnIndents', 'RE', 'RGBA']
+	for word in irregular:
+		replacement = word[0] + word[1:].lower()
+		s = s.replace(word, replacement)
+
+	out = ""
+	for c in s:
+		if c.isupper():
+			if out:
+				out += "_"
+			out += c.lower()
+		else:
+			out += c
+	return out
+
+def normalisedName(s, options, role=None):
+	if options["qtStyle"]:
+		if role == "get":
+			s = s.replace("Get", "")
+		return s[0].lower() + s[1:]
+	else:
+		return underscoreName(s)
+
+typeAliases = {
+	"position": "int",
+	"colour": "int",
+	"keymod": "int",
+	"string": "const char *",
+	"stringresult": "const char *",
+	"cells": "const char *",
+}
+
+def cppAlias(s):
+	if s in typeAliases:
+		return typeAliases[s]
+	else:
+		return s
+
+understoodTypes = ["", "void", "int", "bool", "position",
+	"colour", "keymod", "string", "stringresult", "cells"]
+
+def checkTypes(name, v):
+	understandAllTypes = True
+	if v["ReturnType"] not in understoodTypes:
+		#~ print("Do not understand", v["ReturnType"], "for", name)
+		understandAllTypes = False
+	if v["Param1Type"] not in understoodTypes:
+		#~ print("Do not understand", v["Param1Type"], "for", name)
+		understandAllTypes = False
+	if v["Param2Type"] not in understoodTypes:
+		#~ print("Do not understand", v["Param2Type"], "for", name)
+		understandAllTypes = False
+	return understandAllTypes
+
+def arguments(v, stringResult, options):
+	ret = ""
+	p1Type = cppAlias(v["Param1Type"])
+	if p1Type:
+		ret = ret + p1Type + " " + normalisedName(v["Param1Name"], options)
+	p2Type = cppAlias(v["Param2Type"])
+	if p2Type and not stringResult:
+		if p1Type:
+			ret = ret + ", "
+		ret = ret + p2Type + " " + normalisedName(v["Param2Name"], options)
+	return ret
+
+def printPyFile(f,out, options):
+	for name in f.order:
+		v = f.features[name]
+		if v["Category"] != "Deprecated":
+			feat = v["FeatureType"]
+			if feat in ["val"]:
+				out.write(name + "=" + v["Value"] + "\n")
+			if feat in ["evt"]:
+				out.write("SCN_" + name.upper() + "=" + v["Value"] + "\n")
+
+def printHFile(f,out, options):
+	for name in f.order:
+		v = f.features[name]
+		if v["Category"] != "Deprecated":
+			feat = v["FeatureType"]
+			if feat in ["fun", "get", "set"]:
+				if checkTypes(name, v):
+					constDeclarator = " const" if feat == "get" else ""
+					returnType = cppAlias(v["ReturnType"])
+					stringResult = v["Param2Type"] == "stringresult"
+					if stringResult:
+						returnType = "QByteArray"
+					out.write("\t" + returnType + " " + normalisedName(name, options, feat) + "(")
+					out.write(arguments(v, stringResult, options))
+					out.write(")" + constDeclarator + ";\n")
+
+def methodNames(f, options):
+	for name in f.order:
+		v = f.features[name]
+		if v["Category"] != "Deprecated":
+			feat = v["FeatureType"]
+			if feat in ["fun", "get", "set"]:
+				if checkTypes(name, v):
+					yield normalisedName(name, options)
+
+def printCPPFile(f,out, options):
+	for name in f.order:
+		v = f.features[name]
+		if v["Category"] != "Deprecated":
+			feat = v["FeatureType"]
+			if feat in ["fun", "get", "set"]:
+				if checkTypes(name, v):
+					constDeclarator = " const" if feat == "get" else ""
+					featureDefineName = "SCI_" + name.upper()
+					returnType = cppAlias(v["ReturnType"])
+					stringResult = v["Param2Type"] == "stringresult"
+					if stringResult:
+						returnType = "QByteArray"
+					returnStatement = ""
+					if returnType != "void":
+						returnStatement = "return "
+					out.write(returnType + " ScintillaEdit::" + normalisedName(name, options, feat) + "(")
+					out.write(arguments(v, stringResult, options))
+					out.write(")" + constDeclarator + " {\n")
+					if stringResult:
+						out.write("    " + returnStatement + "TextReturner(" + featureDefineName + ", ")
+						if "*" in cppAlias(v["Param1Type"]):
+							out.write("(uptr_t)")
+						if v["Param1Name"]:
+							out.write(normalisedName(v["Param1Name"], options))
+						else:
+							out.write("0")
+						out.write(");\n")
+					else:
+						out.write("    " + returnStatement + "send(" + featureDefineName + ", ")
+						if "*" in cppAlias(v["Param1Type"]):
+							out.write("(uptr_t)")
+						if v["Param1Name"]:
+							out.write(normalisedName(v["Param1Name"], options))
+						else:
+							out.write("0")
+						out.write(", ")
+						if "*" in cppAlias(v["Param2Type"]):
+							out.write("(sptr_t)")
+						if v["Param2Name"]:
+							out.write(normalisedName(v["Param2Name"], options))
+						else:
+							out.write("0")
+						out.write(");\n")
+					out.write("}\n")
+					out.write("\n")
+
+def CopyWithInsertion(input, output, genfn, definition, options):
+	copying = 1
+	for line in input.readlines():
+		if copying:
+			output.write(line)
+		if "/* ++Autogenerated" in line or "# ++Autogenerated" in line or "<!-- ++Autogenerated" in line:
+			copying = 0
+			genfn(definition, output, options)
+		# ~~ form needed as XML comments can not contain --
+		if "/* --Autogenerated" in line or "# --Autogenerated" in line or "<!-- ~~Autogenerated" in line:
+			copying = 1
+			output.write(line)
+
+def contents(filename):
+	with open(filename, "U") as f:
+		t = f.read()
+		return t
+
+def Generate(templateFile, destinationFile, genfn, definition, options):
+	inText = contents(templateFile)
+	try:
+		currentText = contents(destinationFile)
+	except IOError:
+		currentText = ""
+	tempname = "WidgetGen.tmp"
+	with open(tempname, "w") as out:
+		with open(templateFile, "U") as hfile:
+			CopyWithInsertion(hfile, out, genfn, definition, options)
+	outText = contents(tempname)
+	if currentText == outText:
+		os.unlink(tempname)
+	else:
+		try:
+			os.unlink(destinationFile)
+		except OSError:
+			# Will see failure if file does not yet exist
+			pass
+		os.rename(tempname, destinationFile)
+
+def gtkNames():
+	# The full path on my machine: should be altered for anyone else
+	p = "C:/Users/Neil/Downloads/wingide-source-4.0.1-1/wingide-source-4.0.1-1/external/gtkscintilla2/gtkscintilla.c"
+	with open(p) as f:
+		for l in f.readlines():
+			if "gtk_scintilla_" in l:
+				name = l.split()[1][14:]
+				if '(' in name:
+					name = name.split('(')[0]
+					yield name
+
+def usage():
+	print("WidgetGen.py [-c|--clean][-h|--help][-u|--underscore-names]")
+	print("")
+	print("Generate full APIs for ScintillaEdit class and ScintillaConstants.py.")
+	print("")
+	print("options:")
+	print("")
+	print("-c --clean remove all generated code from files")
+	print("-h --help  display this text")
+	print("-u --underscore-names  use method_names consistent with GTK+ standards")
+
+def readInterface(cleanGenerated):
+	f = Face.Face()
+	if not cleanGenerated:
+		f.ReadFromFile("../../include/Scintilla.iface")
+	return f
+
+def main(argv):
+	# Using local path for gtkscintilla2 so don't default to checking
+	checkGTK = False
+	cleanGenerated = False
+	qtStyleInterface = True
+	# The --gtk-check option checks for full coverage of the gtkscintilla2 API but
+	# depends on a particular directory so is not mentioned in --help.
+	opts, args = getopt.getopt(argv, "hcgu", ["help", "clean", "gtk-check", "underscore-names"])
+	for opt, arg in opts:
+		if opt in ("-h", "--help"):
+			usage()
+			sys.exit()
+		elif opt in ("-c", "--clean"):
+			cleanGenerated = True
+		elif opt in ("-g", "--gtk-check"):
+			checkGTK = True
+		elif opt in ("-u", "--underscore-names"):
+			qtStyleInterface = False
+
+	options = {"qtStyle": qtStyleInterface}
+	f = readInterface(cleanGenerated)
+	try:
+		Generate("ScintillaEdit.cpp.template", "ScintillaEdit.cpp", printCPPFile, f, options)
+		Generate("ScintillaEdit.h.template", "ScintillaEdit.h", printHFile, f, options)
+		Generate("../ScintillaEditPy/ScintillaConstants.py.template",
+			"../ScintillaEditPy/ScintillaConstants.py",
+			printPyFile, f, options)
+		if checkGTK:
+			names = set(methodNames(f))
+			#~ print("\n".join(names))
+			namesGtk = set(gtkNames())
+			for name in namesGtk:
+				if name not in names:
+					print(name, "not found in Qt version")
+			for name in names:
+				if name not in namesGtk:
+					print(name, "not found in GTK+ version")
+	except:
+		raise
+
+if __name__ == "__main__":
+	main(sys.argv[1:])
diff --git a/qt/ScintillaEditBase/Notes.txt b/qt/ScintillaEditBase/Notes.txt
new file mode 100644
index 000000000..6658aaa7a
--- /dev/null
+++ b/qt/ScintillaEditBase/Notes.txt
@@ -0,0 +1,18 @@
+
+Issues with Scintilla for Qt
+
+Qt reports character descenders are 1 pixel shorter than they really are.
+There is a tweak in the code to add a pixel in. This may have to be reviewed for Qt 5.
+There's a comment in the Qt code for Windows:
+       // ### we substract 1 to even out the historical +1 in QFontMetrics's
+       // ### height=asc+desc+1 equation. Fix in Qt5.
+
+The clocks used aren't great. QTime is a time since midnight clock so wraps around and
+is only accurate to, at best, milliseconds.
+
+On OS X drawing text into a pixmap moves it around 1 pixel to the right compared to drawing
+it directly onto a window. Buffered drawing turned off by default to avoid this.
+Reported as QTBUG-19483.
+
+Only one QPainter can be active on any widget at a time. Scintilla only draws into one
+widget but reenters for measurement.
diff --git a/qt/ScintillaEditBase/PlatQt.cpp b/qt/ScintillaEditBase/PlatQt.cpp
new file mode 100644
index 000000000..b386df5a0
--- /dev/null
+++ b/qt/ScintillaEditBase/PlatQt.cpp
@@ -0,0 +1,1282 @@
+//
+//          Copyright (c) 1990-2011, Scientific Toolworks, Inc.
+//
+// The License.txt file describes the conditions under which this software may be distributed.
+//
+// Author: Jason Haslam
+//
+// Additions Copyright (c) 2011 Archaeopteryx Software, Inc. d/b/a Wingware
+// Scintilla platform layer for Qt
+
+#include "PlatQt.h"
+#include "Scintilla.h"
+#include "FontQuality.h"
+
+#include <QApplication>
+#include <QFont>
+#include <QColor>
+#include <QRect>
+#include <QPaintDevice>
+#include <QPaintEngine>
+#include <QWidget>
+#include <QPixmap>
+#include <QPainter>
+#include <QMenu>
+#include <QAction>
+#include <QTime>
+#include <QMessageBox>
+#include <QTextCodec>
+#include <QListWidget>
+#include <QVarLengthArray>
+#include <QScrollBar>
+#include <QDesktopWidget>
+#include <QTextLayout>
+#include <QTextLine>
+#include <QLibrary>
+#include <cstdio>
+
+#ifdef SCI_NAMESPACE
+namespace Scintilla {
+#endif
+
+//----------------------------------------------------------------------
+
+// Convert from a Scintilla characterSet value to a Qt codec name.
+const char *CharacterSetID(int characterSet)
+{
+	switch (characterSet) {
+		//case SC_CHARSET_ANSI:
+		//	return "";
+	case SC_CHARSET_DEFAULT:
+		return "ISO 8859-1";
+	case SC_CHARSET_BALTIC:
+		return "ISO 8859-13";
+	case SC_CHARSET_CHINESEBIG5:
+		return "Big5";
+	case SC_CHARSET_EASTEUROPE:
+		return "ISO 8859-2";
+	case SC_CHARSET_GB2312:
+		return "GB18030-0";
+	case SC_CHARSET_GREEK:
+		return "ISO 8859-7";
+	case SC_CHARSET_HANGUL:
+		return "CP949";
+	case SC_CHARSET_MAC:
+		return "Apple Roman";
+		//case SC_CHARSET_OEM:
+		//	return "ASCII";
+	case SC_CHARSET_RUSSIAN:
+		return "KOI8-R";
+	case SC_CHARSET_CYRILLIC:
+		return "Windows-1251";
+	case SC_CHARSET_SHIFTJIS:
+		return "Shift-JIS";
+		//case SC_CHARSET_SYMBOL:
+		//        return "";
+	case SC_CHARSET_TURKISH:
+		return "ISO 8859-9";
+		//case SC_CHARSET_JOHAB:
+		//        return "CP1361";
+	case SC_CHARSET_HEBREW:
+		return "ISO 8859-8";
+	case SC_CHARSET_ARABIC:
+		return "ISO 8859-6";
+	case SC_CHARSET_VIETNAMESE:
+		return "Windows-1258";
+	case SC_CHARSET_THAI:
+		return "TIS-620";
+	case SC_CHARSET_8859_15:
+		return "ISO 8859-15";
+	default:
+		return "ISO 8859-1";
+	}
+}
+
+class FontAndCharacterSet {
+public:
+	int characterSet;
+	QFont *pfont;
+	FontAndCharacterSet(int characterSet_, QFont *pfont):
+		characterSet(characterSet_), pfont(pfont) {
+	}
+	~FontAndCharacterSet() {
+		delete pfont;
+		pfont = 0;
+	}
+};
+
+static int FontCharacterSet(Font &f)
+{
+	return reinterpret_cast<FontAndCharacterSet *>(f.GetID())->characterSet;
+}
+
+static QFont *FontPointer(Font &f)
+{
+	return reinterpret_cast<FontAndCharacterSet *>(f.GetID())->pfont;
+}
+
+Font::Font() : fid(0) {}
+
+Font::~Font()
+{
+	delete reinterpret_cast<FontAndCharacterSet *>(fid);
+	fid = 0;
+}
+
+static QFont::StyleStrategy ChooseStrategy(int eff)
+{
+	switch (eff) {
+		case SC_EFF_QUALITY_DEFAULT:         return QFont::PreferDefault;
+		case SC_EFF_QUALITY_NON_ANTIALIASED: return QFont::NoAntialias;
+		case SC_EFF_QUALITY_ANTIALIASED:     return QFont::PreferAntialias;
+		case SC_EFF_QUALITY_LCD_OPTIMIZED:   return QFont::PreferAntialias;
+		default:                             return QFont::PreferDefault;
+	}
+}
+
+void Font::Create(const FontParameters &fp)
+{
+	Release();
+
+	QFont *font = new QFont;
+	font->setStyleStrategy(ChooseStrategy(fp.extraFontFlag));
+	font->setFamily(QString::fromUtf8(fp.faceName));
+	font->setPointSize(fp.size);
+	font->setBold(fp.weight > 500);
+	font->setItalic(fp.italic);
+
+	fid = new FontAndCharacterSet(fp.characterSet, font);
+}
+
+void Font::Release()
+{
+	if (fid)
+		delete reinterpret_cast<FontAndCharacterSet *>(fid);
+
+	fid = 0;
+}
+
+
+SurfaceImpl::SurfaceImpl()
+: device(0), painter(0), deviceOwned(false), painterOwned(false), x(0), y(0),
+	  unicodeMode(false), codePage(0), codecName(0), codec(0)
+{}
+
+SurfaceImpl::~SurfaceImpl()
+{
+	Release();
+}
+
+void SurfaceImpl::Init(WindowID wid)
+{
+	Release();
+	device = static_cast<QWidget *>(wid);
+}
+
+void SurfaceImpl::Init(SurfaceID sid, WindowID /*wid*/)
+{
+	Release();
+	device = static_cast<QPaintDevice *>(sid);
+}
+
+void SurfaceImpl::InitPixMap(int width,
+        int height,
+        Surface * /*surface*/,
+        WindowID /*wid*/)
+{
+	Release();
+	if (width < 1) width = 1;
+	if (height < 1) height = 1;
+	deviceOwned = true;
+	device = new QPixmap(width, height);
+}
+
+void SurfaceImpl::Release()
+{
+	if (painterOwned && painter) {
+		delete painter;
+	}
+
+	if (deviceOwned && device) {
+		delete device;
+	}
+
+	device = 0;
+	painter = 0;
+	deviceOwned = false;
+	painterOwned = false;
+}
+
+bool SurfaceImpl::Initialised()
+{
+	return device != 0;
+}
+
+void SurfaceImpl::PenColour(ColourDesired fore)
+{
+	QPen penOutline(QColorFromCA(fore));
+	penOutline.setCapStyle(Qt::FlatCap);
+	GetPainter()->setPen(penOutline);
+}
+
+void SurfaceImpl::BrushColour(ColourDesired back)
+{
+	GetPainter()->setBrush(QBrush(QColorFromCA(back)));
+}
+
+void SurfaceImpl::SetCodec(Font &font)
+{
+	if (font.GetID()) {
+		const char *csid = "UTF-8";
+		if (!unicodeMode)
+			csid = CharacterSetID(FontCharacterSet(font));
+		if (csid != codecName) {
+			codecName = csid;
+			codec = QTextCodec::codecForName(csid);
+		}
+	}
+}
+
+void SurfaceImpl::SetFont(Font &font)
+{
+	if (font.GetID()) {
+		GetPainter()->setFont(*FontPointer(font));
+		SetCodec(font);
+	}
+}
+
+int SurfaceImpl::LogPixelsY()
+{
+	return device->logicalDpiY();
+}
+
+int SurfaceImpl::DeviceHeightFont(int points)
+{
+	return points;
+}
+
+void SurfaceImpl::MoveTo(int x_, int y_)
+{
+	x = x_;
+	y = y_;
+}
+
+void SurfaceImpl::LineTo(int x_, int y_)
+{
+	QLineF line(x, y, x_, y_);
+	GetPainter()->drawLine(line);
+	x = x_;
+	y = y_;
+}
+
+void SurfaceImpl::Polygon(Point *pts,
+                          int npts,
+                          ColourDesired fore,
+                          ColourDesired back)
+{
+	PenColour(fore);
+	BrushColour(back);
+
+	QPoint *qpts = new QPoint[npts];
+	for (int i = 0; i < npts; i++) {
+		qpts[i] = QPoint(pts[i].x, pts[i].y);
+	}
+
+	GetPainter()->drawPolygon(qpts, npts);
+	delete [] qpts;
+}
+
+void SurfaceImpl::RectangleDraw(PRectangle rc,
+                                ColourDesired fore,
+                                ColourDesired back)
+{
+	PenColour(fore);
+	BrushColour(back);
+	QRect rect = QRect(rc.left, rc.top, rc.Width() - 1, rc.Height() - 1);
+	GetPainter()->drawRect(rect);
+}
+
+void SurfaceImpl::FillRectangle(PRectangle rc, ColourDesired back)
+{
+	BrushColour(back);
+	GetPainter()->setPen(Qt::NoPen);
+	GetPainter()->drawRect(QRectFromPRect(rc));
+}
+
+void SurfaceImpl::FillRectangle(PRectangle rc, Surface &surfacePattern)
+{
+	// Tile pattern over rectangle
+	SurfaceImpl *surface = static_cast<SurfaceImpl *>(&surfacePattern);
+	// Currently assumes 8x8 pattern
+	int widthPat = 8;
+	int heightPat = 8;
+	for (int xTile = rc.left; xTile < rc.right; xTile += widthPat) {
+		int widthx = (xTile + widthPat > rc.right) ? rc.right - xTile : widthPat;
+		for (int yTile = rc.top; yTile < rc.bottom; yTile += heightPat) {
+			int heighty = (yTile + heightPat > rc.bottom) ? rc.bottom - yTile : heightPat;
+			QRect source(0, 0, widthx, heighty);
+			QRect target(xTile, yTile, widthx, heighty);
+			QPixmap *pixmap = static_cast<QPixmap *>(surface->GetPaintDevice());
+			GetPainter()->drawPixmap(target, *pixmap, source);
+		}
+	}
+}
+
+void SurfaceImpl::RoundedRectangle(PRectangle rc,
+                                   ColourDesired fore,
+                                   ColourDesired back)
+{
+	PenColour(fore);
+	BrushColour(back);
+	GetPainter()->drawRoundRect(QRectFromPRect(rc));
+}
+
+void SurfaceImpl::AlphaRectangle(PRectangle rc,
+                                 int cornerSize,
+                                 ColourDesired fill,
+                                 int alphaFill,
+                                 ColourDesired outline,
+                                 int alphaOutline,
+                                 int /*flags*/)
+{
+	QColor qOutline = QColorFromCA(outline);
+	qOutline.setAlpha(alphaOutline);
+	GetPainter()->setPen(QPen(qOutline));
+
+	QColor qFill = QColorFromCA(fill);
+	qFill.setAlpha(alphaFill);
+	GetPainter()->setBrush(QBrush(qFill));
+
+	// A radius of 1 shows no curve so add 1
+	qreal radius = cornerSize+1;
+	QRect rect(rc.left, rc.top, rc.Width() - 1, rc.Height() - 1);
+	GetPainter()->drawRoundedRect(rect, radius, radius);
+}
+
+static std::vector<unsigned char> ImageByteSwapped(int width, int height, const unsigned char *pixelsImage)
+{
+	// Input is RGBA, but Format_ARGB32 is BGRA, so swap the red bytes and blue bytes
+	size_t bytes = width * height * 4;
+	std::vector<unsigned char> imageBytes(pixelsImage, pixelsImage+bytes);
+	for (size_t i=0; i<bytes; i+=4)
+		std::swap(imageBytes[i], imageBytes[i+2]);
+	return imageBytes;
+}
+
+void SurfaceImpl::DrawRGBAImage(PRectangle rc, int width, int height, const unsigned char *pixelsImage)
+{
+	std::vector<unsigned char> imageBytes = ImageByteSwapped(width, height, pixelsImage);
+	QImage image(&imageBytes[0], width, height, QImage::Format_ARGB32);
+	QPoint pt(rc.left, rc.top);
+	GetPainter()->drawImage(pt, image);
+}
+
+void SurfaceImpl::Ellipse(PRectangle rc,
+                          ColourDesired fore,
+                          ColourDesired back)
+{
+	PenColour(fore);
+	BrushColour(back);
+	GetPainter()->drawEllipse(QRectFromPRect(rc));
+}
+
+void SurfaceImpl::Copy(PRectangle rc, Point from, Surface &surfaceSource)
+{
+	SurfaceImpl *source = static_cast<SurfaceImpl *>(&surfaceSource);
+	QPixmap *pixmap = static_cast<QPixmap *>(source->GetPaintDevice());
+
+	GetPainter()->drawPixmap(rc.left, rc.top, *pixmap, from.x, from.y, -1, -1);
+}
+
+void SurfaceImpl::DrawTextNoClip(PRectangle rc,
+                                 Font &font,
+                                 XYPOSITION ybase,
+                                 const char *s,
+                                 int len,
+                                 ColourDesired fore,
+                                 ColourDesired back)
+{
+	SetFont(font);
+	PenColour(fore);
+
+	GetPainter()->setBackground(QColorFromCA(back));
+	GetPainter()->setBackgroundMode(Qt::OpaqueMode);
+	QString su = codec->toUnicode(s, len);
+	GetPainter()->drawText(QPointF(rc.left, ybase), su);
+}
+
+void SurfaceImpl::DrawTextClipped(PRectangle rc,
+                                  Font &font,
+                                  XYPOSITION ybase,
+                                  const char *s,
+                                  int len,
+                                  ColourDesired fore,
+                                  ColourDesired back)
+{
+	SetClip(rc);
+	DrawTextNoClip(rc, font, ybase, s, len, fore, back);
+	GetPainter()->setClipping(false);
+}
+
+void SurfaceImpl::DrawTextTransparent(PRectangle rc,
+                                      Font &font,
+                                      XYPOSITION ybase,
+                                      const char *s,
+                                      int len,
+        ColourDesired fore)
+{
+	SetFont(font);
+	PenColour(fore);
+
+	GetPainter()->setBackgroundMode(Qt::TransparentMode);
+	QString su = codec->toUnicode(s, len);
+	GetPainter()->drawText(QPointF(rc.left, ybase), su);
+}
+
+void SurfaceImpl::SetClip(PRectangle rc)
+{
+	GetPainter()->setClipRect(QRectFromPRect(rc));
+}
+
+static size_t utf8LengthFromLead(unsigned char uch)
+{
+	if (uch >= (0x80 + 0x40 + 0x20 + 0x10)) {
+		return 4;
+	} else if (uch >= (0x80 + 0x40 + 0x20)) {
+		return 3;
+	} else if (uch >= (0x80)) {
+		return 2;
+	} else {
+		return 1;
+	}
+}
+
+void SurfaceImpl::MeasureWidths(Font &font,
+                                const char *s,
+                                int len,
+                                XYPOSITION *positions)
+{
+	if (!font.GetID())
+		return;
+	SetCodec(font);
+	QString su = codec->toUnicode(s, len);
+	QTextLayout tlay(su, *FontPointer(font));
+	tlay.beginLayout();
+	QTextLine tl = tlay.createLine();
+	tlay.endLayout();
+	if (unicodeMode) {
+		int fit = su.size();
+		int ui=0;
+		const unsigned char *us = reinterpret_cast<const unsigned char *>(s);
+		int i=0;
+		while (ui<fit) {
+			size_t lenChar = utf8LengthFromLead(us[i]);
+			size_t codeUnits = (lenChar < 4) ? 1 : 2;
+			qreal xPosition = tl.cursorToX(ui+codeUnits);
+			for (unsigned int bytePos=0; (bytePos<lenChar) && (i<len); bytePos++) {
+				positions[i++] = qRound(xPosition);
+			}
+			ui += codeUnits;
+		}
+		int lastPos = 0;
+		if (i > 0)
+			lastPos = positions[i-1];
+		while (i<len) {
+			positions[i++] = lastPos;
+		}
+	} else if (codePage) {
+		// DBCS
+		int ui = 0;
+		for (int i=0; i<len;) {
+			size_t lenChar = Platform::IsDBCSLeadByte(codePage, s[i]) ? 2 : 1;
+			qreal xPosition = tl.cursorToX(ui+1);
+			for (unsigned int bytePos=0; (bytePos<lenChar) && (i<len); bytePos++) {
+				positions[i++] = qRound(xPosition);
+			}
+			ui++;
+		}
+	} else {
+		// Single byte encoding
+		for (int i=0; i<len; i++) {
+			positions[i] = qRound(tl.cursorToX(i+1));
+		}
+	}
+}
+
+XYPOSITION SurfaceImpl::WidthText(Font &font, const char *s, int len)
+{
+	QFontMetrics metrics(*FontPointer(font), device);
+	SetCodec(font);
+	QString string = codec->toUnicode(s, len);
+	return metrics.width(string);
+}
+
+XYPOSITION SurfaceImpl::WidthChar(Font &font, char ch)
+{
+	QFontMetrics metrics(*FontPointer(font), device);
+	return metrics.width(ch);
+}
+
+XYPOSITION SurfaceImpl::Ascent(Font &font)
+{
+	QFontMetrics metrics(*FontPointer(font), device);
+	return metrics.ascent();
+}
+
+XYPOSITION SurfaceImpl::Descent(Font &font)
+{
+	QFontMetrics metrics(*FontPointer(font), device);
+	// Qt returns 1 less than true descent
+	// See: QFontEngineWin::descent which says:
+	// ### we substract 1 to even out the historical +1 in QFontMetrics's
+	// ### height=asc+desc+1 equation. Fix in Qt5.
+	return metrics.descent() + 1;
+}
+
+XYPOSITION SurfaceImpl::InternalLeading(Font & /* font */)
+{
+	return 0;
+}
+
+XYPOSITION SurfaceImpl::ExternalLeading(Font &font)
+{
+	QFontMetrics metrics(*FontPointer(font), device);
+	return metrics.leading();
+}
+
+XYPOSITION SurfaceImpl::Height(Font &font)
+{
+	QFontMetrics metrics(*FontPointer(font), device);
+	return metrics.height();
+}
+
+XYPOSITION SurfaceImpl::AverageCharWidth(Font &font)
+{
+	QFontMetrics metrics(*FontPointer(font), device);
+	return metrics.averageCharWidth();
+}
+
+void SurfaceImpl::FlushCachedState()
+{
+	if (device->paintingActive()) {
+		GetPainter()->setPen(QPen());
+		GetPainter()->setBrush(QBrush());
+	}
+}
+
+void SurfaceImpl::SetUnicodeMode(bool unicodeMode_)
+{
+	unicodeMode=unicodeMode_;
+}
+
+void SurfaceImpl::SetDBCSMode(int codePage_)
+{
+	codePage = codePage_;
+}
+
+QPaintDevice *SurfaceImpl::GetPaintDevice()
+{
+	return device;
+}
+
+QPainter *SurfaceImpl::GetPainter()
+{
+	Q_ASSERT(device);
+
+	if (painter == 0) {
+		if (device->paintingActive()) {
+			painter = device->paintEngine()->painter();
+		} else {
+			painterOwned = true;
+			painter = new QPainter(device);
+		}
+
+		// Set text antialiasing unconditionally.
+		// The font's style strategy will override.
+		painter->setRenderHint(QPainter::TextAntialiasing, true);
+	}
+
+	return painter;
+}
+
+Surface *Surface::Allocate(int)
+{
+	return new SurfaceImpl;
+}
+
+
+//----------------------------------------------------------------------
+
+namespace {
+QWidget *window(WindowID wid)
+{
+	return static_cast<QWidget *>(wid);
+}
+}
+
+Window::~Window() {}
+
+void Window::Destroy()
+{
+	if (wid)
+		delete window(wid);
+
+	wid = 0;
+}
+
+bool Window::HasFocus()
+{
+	return wid ? window(wid)->hasFocus() : false;
+}
+
+PRectangle Window::GetPosition()
+{
+	// Before any size allocated pretend its 1000 wide so not scrolled
+	return wid ? PRectFromQRect(window(wid)->frameGeometry()) : PRectangle(0, 0, 1000, 1000);
+}
+
+void Window::SetPosition(PRectangle rc)
+{
+	if (wid)
+		window(wid)->setGeometry(QRectFromPRect(rc));
+}
+
+void Window::SetPositionRelative(PRectangle rc, Window relativeTo)
+{
+	QPoint oPos = window(relativeTo.wid)->mapToGlobal(QPoint(0,0));
+	int ox = oPos.x();
+	int oy = oPos.y();
+	ox += rc.left;
+	if (ox < 0)
+		ox = 0;
+	oy += rc.top;
+	if (oy < 0)
+		oy = 0;
+
+	QDesktopWidget *desktop = QApplication::desktop();
+	QRect rectDesk = desktop->availableGeometry(window(wid));
+	/* do some corrections to fit into screen */
+	int sizex = rc.right - rc.left;
+	int sizey = rc.bottom - rc.top;
+	int screenWidth = rectDesk.width();
+	int screenHeight = rectDesk.height();
+	if (sizex > screenWidth)
+		ox = 0; /* the best we can do */
+	else if (ox + sizex > screenWidth)
+		ox = screenWidth - sizex;
+	if (oy + sizey > screenHeight)
+		oy = screenHeight - sizey;
+
+	Q_ASSERT(wid);
+	window(wid)->move(ox, oy);
+	window(wid)->resize(sizex, sizey);
+}
+
+PRectangle Window::GetClientPosition()
+{
+	// The client position is the window position
+	return GetPosition();
+}
+
+void Window::Show(bool show)
+{
+	if (wid)
+		window(wid)->setVisible(show);
+}
+
+void Window::InvalidateAll()
+{
+	if (wid)
+		window(wid)->update();
+}
+
+void Window::InvalidateRectangle(PRectangle rc)
+{
+	if (wid)
+		window(wid)->update(QRectFromPRect(rc));
+}
+
+void Window::SetFont(Font &font)
+{
+	if (wid)
+		window(wid)->setFont(*FontPointer(font));
+}
+
+void Window::SetCursor(Cursor curs)
+{
+	if (wid) {
+		Qt::CursorShape shape;
+
+		switch (curs) {
+			case cursorText:  shape = Qt::IBeamCursor;        break;
+			case cursorArrow: shape = Qt::ArrowCursor;        break;
+			case cursorUp:    shape = Qt::UpArrowCursor;      break;
+			case cursorWait:  shape = Qt::WaitCursor;         break;
+			case cursorHoriz: shape = Qt::SizeHorCursor;      break;
+			case cursorVert:  shape = Qt::SizeVerCursor;      break;
+			case cursorHand:  shape = Qt::PointingHandCursor; break;
+			default:          shape = Qt::ArrowCursor;        break;
+		}
+
+		QCursor cursor = QCursor(shape);
+
+		if (curs != cursorLast) {
+			window(wid)->setCursor(cursor);
+			cursorLast = curs;
+		}
+	}
+}
+
+void Window::SetTitle(const char *s)
+{
+	if (wid)
+		window(wid)->setWindowTitle(s);
+}
+
+/* Returns rectangle of monitor pt is on, both rect and pt are in Window's
+   window coordinates */
+PRectangle Window::GetMonitorRect(Point pt)
+{
+	QPoint originGlobal = window(wid)->mapToGlobal(QPoint(0, 0));
+	QPoint posGlobal = window(wid)->mapToGlobal(QPoint(pt.x, pt.y));
+	QDesktopWidget *desktop = QApplication::desktop();
+	QRect rectScreen = desktop->availableGeometry(posGlobal);
+	rectScreen.moveLeft(-originGlobal.x());
+	rectScreen.moveTop(-originGlobal.y());
+	return PRectangle(rectScreen.left(), rectScreen.top(),
+	        rectScreen.right(), rectScreen.bottom());
+}
+
+
+//----------------------------------------------------------------------
+
+class ListBoxImpl : public ListBox {
+public:
+	ListBoxImpl();
+	~ListBoxImpl();
+
+	virtual void SetFont(Font &font);
+	virtual void Create(Window &parent, int ctrlID, Point location,
+						int lineHeight, bool unicodeMode, int technology);
+	virtual void SetAverageCharWidth(int width);
+	virtual void SetVisibleRows(int rows);
+	virtual int GetVisibleRows() const;
+	virtual PRectangle GetDesiredRect();
+	virtual int CaretFromEdge();
+	virtual void Clear();
+	virtual void Append(char *s, int type = -1);
+	virtual int Length();
+	virtual void Select(int n);
+	virtual int GetSelection();
+	virtual int Find(const char *prefix);
+	virtual void GetValue(int n, char *value, int len);
+	virtual void RegisterImage(int type, const char *xpmData);
+	virtual void RegisterRGBAImage(int type, int width, int height,
+		const unsigned char *pixelsImage);
+	virtual void ClearRegisteredImages();
+	virtual void SetDoubleClickAction(CallBackAction action, void *data);
+	virtual void SetList(const char *list, char separator, char typesep);
+private:
+	bool unicodeMode;
+	int visibleRows;
+	QMap<int,QPixmap> images;
+};
+
+class ListWidget : public QListWidget {
+public:
+	ListWidget(QWidget *parent);
+	virtual ~ListWidget();
+
+	void setDoubleClickAction(CallBackAction action, void *data);
+
+protected:
+	virtual void mouseDoubleClickEvent(QMouseEvent *event);
+	virtual QStyleOptionViewItem viewOptions() const;
+
+private:
+	CallBackAction doubleClickAction;
+	void *doubleClickActionData;
+};
+
+
+ListBoxImpl::ListBoxImpl()
+: unicodeMode(false), visibleRows(5)
+{}
+
+ListBoxImpl::~ListBoxImpl() {}
+
+void ListBoxImpl::Create(Window &parent,
+                         int /*ctrlID*/,
+                         Point location,
+                         int /*lineHeight*/,
+                         bool unicodeMode_,
+			 int)
+{
+	unicodeMode = unicodeMode_;
+
+	QWidget *qparent = static_cast<QWidget *>(parent.GetID());
+	ListWidget *list = new ListWidget(qparent);
+
+#if defined(Q_OS_WIN)
+	// On Windows, Qt::ToolTip causes a crash when the list is clicked on
+	// so Qt::Tool is used.
+	list->setParent(0, Qt::Tool | Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint);
+#else
+	// On OS X, Qt::Tool takes focus so main window loses focus so
+	// keyboard stops working. Qt::ToolTip works but its only really
+	// documented for tooltips.
+	// On Linux / X this setting allows clicking on list items.
+	list->setParent(0, Qt::ToolTip | Qt::FramelessWindowHint);
+#endif
+	list->setAttribute(Qt::WA_ShowWithoutActivating);
+	list->setFocusPolicy(Qt::NoFocus);
+	list->setUniformItemSizes(true);
+	list->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
+	list->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+	list->move(location.x, location.y);
+
+	wid = list;
+}
+
+void ListBoxImpl::SetFont(Font &font)
+{
+	ListWidget *list = static_cast<ListWidget *>(wid);
+	list->setFont(*FontPointer(font));
+}
+
+void ListBoxImpl::SetAverageCharWidth(int /*width*/) {}
+
+void ListBoxImpl::SetVisibleRows(int rows)
+{
+	visibleRows = rows;
+}
+
+int ListBoxImpl::GetVisibleRows() const
+{
+	return visibleRows;
+}
+
+PRectangle ListBoxImpl::GetDesiredRect()
+{
+	ListWidget *list = static_cast<ListWidget *>(wid);
+
+	int rows = Length();
+	if (rows == 0 || rows > visibleRows) {
+		rows = visibleRows;
+	}
+	int rowHeight = list->sizeHintForRow(0);
+	int height = (rows * rowHeight) + (2 * list->frameWidth());
+
+	QStyle *style = QApplication::style();
+	int width = list->sizeHintForColumn(0) + (2 * list->frameWidth());
+	if (Length() > rows) {
+		width += style->pixelMetric(QStyle::PM_ScrollBarExtent);
+	}
+
+	return PRectangle(0, 0, width, height);
+}
+
+int ListBoxImpl::CaretFromEdge()
+{
+	ListWidget *list = static_cast<ListWidget *>(wid);
+
+	int maxIconWidth = 0;
+	foreach (QPixmap im, images) {
+		if (maxIconWidth < im.width())
+			maxIconWidth = im.width();
+	}
+
+	// The '7' is from trial and error on Windows - there may be
+	// a better programmatic way to find any padding factors.
+	return maxIconWidth  + (2 * list->frameWidth()) + 7;
+}
+
+void ListBoxImpl::Clear()
+{
+	ListWidget *list = static_cast<ListWidget *>(wid);
+	list->clear();
+}
+
+void ListBoxImpl::Append(char *s, int type)
+{
+	ListWidget *list = static_cast<ListWidget *>(wid);
+
+	QString str = unicodeMode ? QString::fromUtf8(s) : QString::fromLocal8Bit(s);
+	QIcon icon;
+	if (type >= 0) {
+		Q_ASSERT(images.contains(type));
+		icon = images.value(type);
+	}
+	new QListWidgetItem(icon, str, list);
+}
+
+int ListBoxImpl::Length()
+{
+	ListWidget *list = static_cast<ListWidget *>(wid);
+	return list->count();
+}
+
+void ListBoxImpl::Select(int n)
+{
+	ListWidget *list = static_cast<ListWidget *>(wid);
+	list->setCurrentRow(n);
+}
+
+int ListBoxImpl::GetSelection()
+{
+	ListWidget *list = static_cast<ListWidget *>(wid);
+	return list->currentRow();
+}
+
+int ListBoxImpl::Find(const char *prefix)
+{
+	ListWidget *list = static_cast<ListWidget *>(wid);
+	QString sPrefix = unicodeMode ? QString::fromUtf8(prefix) : QString::fromLocal8Bit(prefix);
+	QList<QListWidgetItem *> ms = list->findItems(sPrefix, Qt::MatchStartsWith);
+
+	int result = -1;
+	if (!ms.isEmpty()) {
+		result = list->row(ms.first());
+	}
+
+	return result;
+}
+
+void ListBoxImpl::GetValue(int n, char *value, int len)
+{
+	ListWidget *list = static_cast<ListWidget *>(wid);
+	QListWidgetItem *item = list->item(n);
+	QString str = item->data(Qt::DisplayRole).toString();
+	QByteArray bytes = unicodeMode ? str.toUtf8() : str.toLocal8Bit();
+
+	strncpy(value, bytes.constData(), len);
+	value[len-1] = '\0';
+}
+
+void ListBoxImpl::RegisterImage(int type, const char *xpmData)
+{
+	images[type] = QPixmap(reinterpret_cast<const char * const *>(xpmData));
+}
+
+void ListBoxImpl::RegisterRGBAImage(int type, int width, int height, const unsigned char *pixelsImage)
+{
+	std::vector<unsigned char> imageBytes = ImageByteSwapped(width, height, pixelsImage);
+	QImage image(&imageBytes[0], width, height, QImage::Format_ARGB32);
+	images[type] = QPixmap::fromImage(image);
+}
+
+void ListBoxImpl::ClearRegisteredImages()
+{
+	images.clear();
+}
+
+void ListBoxImpl::SetDoubleClickAction(CallBackAction action, void *data)
+{
+	ListWidget *list = static_cast<ListWidget *>(wid);
+	list->setDoubleClickAction(action, data);
+}
+
+void ListBoxImpl::SetList(const char *list, char separator, char typesep)
+{
+	// This method is *not* platform dependent.
+	// It is borrowed from the GTK implementation.
+	Clear();
+	int count = strlen(list) + 1;
+	char *words = new char[count];
+	if (words) {
+		memcpy(words, list, count);
+		char *startword = words;
+		char *numword = NULL;
+		int i = 0;
+		for (; words[i]; i++) {
+			if (words[i] == separator) {
+				words[i] = '\0';
+				if (numword)
+					*numword = '\0';
+				Append(startword, numword?atoi(numword + 1):-1);
+				startword = words + i + 1;
+				numword = NULL;
+			} else if (words[i] == typesep) {
+				numword = words + i;
+			}
+		}
+		if (startword) {
+			if (numword)
+				*numword = '\0';
+			Append(startword, numword?atoi(numword + 1):-1);
+		}
+		delete []words;
+	}
+}
+
+ListBox::ListBox() {}
+
+ListBox::~ListBox() {}
+
+ListBox *ListBox::Allocate()
+{
+	return new ListBoxImpl();
+}
+
+ListWidget::ListWidget(QWidget *parent)
+: QListWidget(parent), doubleClickActionData(0)
+{}
+
+ListWidget::~ListWidget() {}
+
+void ListWidget::setDoubleClickAction(CallBackAction action, void *data)
+{
+	doubleClickAction = action;
+	doubleClickActionData = data;
+}
+
+void ListWidget::mouseDoubleClickEvent(QMouseEvent * /* event */)
+{
+	if (doubleClickAction != 0) {
+		doubleClickAction(doubleClickActionData);
+	}
+}
+
+QStyleOptionViewItem ListWidget::viewOptions() const
+{
+	QStyleOptionViewItem result = QListWidget::viewOptions();
+	result.state |= QStyle::State_Active;
+	return result;
+}
+
+//----------------------------------------------------------------------
+
+Menu::Menu() : mid(0) {}
+
+void Menu::CreatePopUp()
+{
+	Destroy();
+	mid = new QMenu();
+}
+
+void Menu::Destroy()
+{
+	if (mid) {
+		QMenu *menu = static_cast<QMenu *>(mid);
+		delete menu;
+	}
+	mid = 0;
+}
+
+void Menu::Show(Point pt, Window & /*w*/)
+{
+	QMenu *menu = static_cast<QMenu *>(mid);
+	menu->exec(QPoint(pt.x, pt.y));
+	Destroy();
+}
+
+//----------------------------------------------------------------------
+
+class DynamicLibraryImpl : public DynamicLibrary {
+protected:
+	QLibrary *lib;
+public:
+	DynamicLibraryImpl(const char *modulePath) {
+		QString path = QString::fromUtf8(modulePath);
+		lib = new QLibrary(path);
+	}
+
+	virtual ~DynamicLibraryImpl() {
+		if (lib)
+			lib->unload();
+		lib = 0;
+	}
+
+	virtual Function FindFunction(const char *name) {
+		if (lib) {
+			void *fnAddress = lib->resolve(name);
+			return static_cast<Function>(fnAddress);
+		}
+		return NULL;
+	}
+
+	virtual bool IsValid() {
+		return lib != NULL;
+	}
+};
+
+DynamicLibrary *DynamicLibrary::Load(const char *modulePath)
+{
+	return static_cast<DynamicLibrary *>(new DynamicLibraryImpl(modulePath));
+}
+
+ColourDesired Platform::Chrome()
+{
+	QColor c(Qt::gray);
+	return ColourDesired(c.red(), c.green(), c.blue());
+}
+
+ColourDesired Platform::ChromeHighlight()
+{
+	QColor c(Qt::lightGray);
+	return ColourDesired(c.red(), c.green(), c.blue());
+}
+
+const char *Platform::DefaultFont()
+{
+	static char fontNameDefault[200] = "";
+	if (!fontNameDefault[0]) {
+		QFont font = QApplication::font();
+		strcpy(fontNameDefault, font.family().toAscii());
+	}
+	return fontNameDefault;
+}
+
+int Platform::DefaultFontSize()
+{
+	QFont font = QApplication::font();
+	return font.pointSize();
+}
+
+unsigned int Platform::DoubleClickTime()
+{
+	return QApplication::doubleClickInterval();
+}
+
+bool Platform::MouseButtonBounce()
+{
+	return false;
+}
+
+bool Platform::IsKeyDown(int /*key*/)
+{
+	return false;
+}
+
+long Platform::SendScintilla(WindowID /*w*/,
+                             unsigned int /*msg*/,
+                             unsigned long /*wParam*/,
+                             long /*lParam*/)
+{
+	return 0;
+}
+
+long Platform::SendScintillaPointer(WindowID /*w*/,
+                                    unsigned int /*msg*/,
+                                    unsigned long /*wParam*/,
+                                    void * /*lParam*/)
+{
+	return 0;
+}
+
+int Platform::Minimum(int a, int b)
+{
+	return qMin(a, b);
+}
+
+int Platform::Maximum(int a, int b)
+{
+	return qMax(a, b);
+}
+
+int Platform::Clamp(int val, int minVal, int maxVal)
+{
+	return qBound(minVal, val, maxVal);
+}
+
+void Platform::DebugDisplay(const char *s)
+{
+	qWarning("Scintilla: %s", s);
+}
+
+void Platform::DebugPrintf(const char *format, ...)
+{
+	char buffer[2000];
+	va_list pArguments;
+	va_start(pArguments, format);
+	vsprintf(buffer, format, pArguments);
+	va_end(pArguments);
+	Platform::DebugDisplay(buffer);
+}
+
+bool Platform::ShowAssertionPopUps(bool /*assertionPopUps*/)
+{
+	return false;
+}
+
+void Platform::Assert(const char *c, const char *file, int line)
+{
+	char buffer[2000];
+	sprintf(buffer, "Assertion [%s] failed at %s %d", c, file, line);
+	if (Platform::ShowAssertionPopUps(false)) {
+		QMessageBox mb("Assertion Failure", buffer, QMessageBox::NoIcon,
+			QMessageBox::Ok, QMessageBox::NoButton, QMessageBox::NoButton);
+		mb.exec();
+	} else {
+		strcat(buffer, "\n");
+		Platform::DebugDisplay(buffer);
+	}
+}
+
+
+bool Platform::IsDBCSLeadByte(int codePage, char ch)
+{
+	// Byte ranges found in Wikipedia articles with relevant search strings in each case
+	unsigned char uch = static_cast<unsigned char>(ch);
+	switch (codePage) {
+	case 932:
+		// Shift_jis
+		return ((uch >= 0x81) && (uch <= 0x9F)) ||
+		       ((uch >= 0xE0) && (uch <= 0xEF));
+	case 936:
+		// GBK
+		return (uch >= 0x81) && (uch <= 0xFE);
+	case 949:
+		// Korean Wansung KS C-5601-1987
+		return (uch >= 0x81) && (uch <= 0xFE);
+	case 950:
+		// Big5
+		return (uch >= 0x81) && (uch <= 0xFE);
+	case 1361:
+		// Korean Johab KS C-5601-1992
+		return
+		    ((uch >= 0x84) && (uch <= 0xD3)) ||
+		    ((uch >= 0xD8) && (uch <= 0xDE)) ||
+		    ((uch >= 0xE0) && (uch <= 0xF9));
+	}
+	return false;
+}
+
+int Platform::DBCSCharLength(int codePage, const char *s)
+{
+	if (codePage == 932 || codePage == 936 || codePage == 949 ||
+	        codePage == 950 || codePage == 1361) {
+		return IsDBCSLeadByte(codePage, s[0]) ? 2 : 1;
+	} else {
+		return 1;
+	}
+}
+
+int Platform::DBCSCharMaxLength()
+{
+	return 2;
+}
+
+
+//----------------------------------------------------------------------
+
+static QTime timer;
+
+ElapsedTime::ElapsedTime()
+{
+	timer.start();
+}
+
+double ElapsedTime::Duration(bool reset)
+{
+	double result = timer.elapsed();
+	if (reset) {
+		timer.restart();
+	}
+	result /= 1000.0;
+	return result;
+}
+
+#ifdef SCI_NAMESPACE
+}
+#endif
diff --git a/qt/ScintillaEditBase/PlatQt.h b/qt/ScintillaEditBase/PlatQt.h
new file mode 100644
index 000000000..60a7e7300
--- /dev/null
+++ b/qt/ScintillaEditBase/PlatQt.h
@@ -0,0 +1,127 @@
+//
+//          Copyright (c) 1990-2011, Scientific Toolworks, Inc.
+//
+// The License.txt file describes the conditions under which this software may be distributed.
+//
+// Author: Jason Haslam
+//
+// Additions Copyright (c) 2011 Archaeopteryx Software, Inc. d/b/a Wingware
+// Scintilla platform layer for Qt
+
+#ifndef PLATQT_H
+#define PLATQT_H
+
+#include "Platform.h"
+
+#include <QPaintDevice>
+#include <QPainter>
+#include <QHash>
+
+#ifdef SCI_NAMESPACE
+namespace Scintilla {
+#endif
+
+const char *CharacterSetID(int characterSet);
+
+inline QColor QColorFromCA(ColourDesired ca)
+{
+	long c = ca.AsLong();
+	return QColor(c & 0xff, (c >> 8) & 0xff, (c >> 16) & 0xff);
+}
+
+inline QRect QRectFromPRect(PRectangle pr)
+{
+	return QRect(pr.left, pr.top, pr.Width(), pr.Height());
+}
+
+inline PRectangle PRectFromQRect(QRect qr)
+{
+	return PRectangle(qr.x(), qr.y(), qr.x() + qr.width(), qr.y() + qr.height());
+}
+
+inline Point PointFromQPoint(QPoint qp)
+{
+	return Point(qp.x(), qp.y());
+}
+
+class SurfaceImpl : public Surface {
+private:
+	QPaintDevice *device;
+	QPainter *painter;
+	bool deviceOwned;
+	bool painterOwned;
+	float x, y;
+	bool unicodeMode;
+	int codePage;
+	const char *codecName;
+	QTextCodec *codec;
+
+public:
+	SurfaceImpl();
+	virtual ~SurfaceImpl();
+
+	virtual void Init(WindowID wid);
+	virtual void Init(SurfaceID sid, WindowID wid);
+	virtual void InitPixMap(int width, int height,
+		Surface *surface, WindowID wid);
+
+	virtual void Release();
+	virtual bool Initialised();
+	virtual void PenColour(ColourDesired fore);
+	virtual int LogPixelsY();
+	virtual int DeviceHeightFont(int points);
+	virtual void MoveTo(int x, int y);
+	virtual void LineTo(int x, int y);
+	virtual void Polygon(Point *pts, int npts, ColourDesired fore,
+		ColourDesired back);
+	virtual void RectangleDraw(PRectangle rc, ColourDesired fore,
+		ColourDesired back);
+	virtual void FillRectangle(PRectangle rc, ColourDesired back);
+	virtual void FillRectangle(PRectangle rc, Surface &surfacePattern);
+	virtual void RoundedRectangle(PRectangle rc, ColourDesired fore,
+		ColourDesired back);
+	virtual void AlphaRectangle(PRectangle rc, int corner, ColourDesired fill,
+		int alphaFill, ColourDesired outline, int alphaOutline, int flags);
+	virtual void DrawRGBAImage(PRectangle rc, int width, int height,
+		const unsigned char *pixelsImage);
+	virtual void Ellipse(PRectangle rc, ColourDesired fore,
+		ColourDesired back);
+	virtual void Copy(PRectangle rc, Point from, Surface &surfaceSource);
+
+	virtual void DrawTextNoClip(PRectangle rc, Font &font, XYPOSITION ybase,
+		const char *s, int len, ColourDesired fore, ColourDesired back);
+	virtual void DrawTextClipped(PRectangle rc, Font &font, XYPOSITION ybase,
+		const char *s, int len, ColourDesired fore, ColourDesired back);
+	virtual void DrawTextTransparent(PRectangle rc, Font &font, XYPOSITION ybase,
+		const char *s, int len, ColourDesired fore);
+	virtual void MeasureWidths(Font &font, const char *s, int len,
+		XYPOSITION *positions);
+	virtual XYPOSITION WidthText(Font &font, const char *s, int len);
+	virtual XYPOSITION WidthChar(Font &font, char ch);
+	virtual XYPOSITION Ascent(Font &font);
+	virtual XYPOSITION Descent(Font &font);
+	virtual XYPOSITION InternalLeading(Font &font);
+	virtual XYPOSITION ExternalLeading(Font &font);
+	virtual XYPOSITION Height(Font &font);
+	virtual XYPOSITION AverageCharWidth(Font &font);
+
+	virtual void SetClip(PRectangle rc);
+	virtual void FlushCachedState();
+
+	virtual void SetUnicodeMode(bool unicodeMode);
+	virtual void SetDBCSMode(int codePage);
+
+	void BrushColour(ColourDesired back);
+	void SetCodec(Font &font);
+	void SetFont(Font &font);
+
+	QPaintDevice *GetPaintDevice();
+	void SetPainter(QPainter *painter);
+	QPainter *GetPainter();
+};
+
+#ifdef SCI_NAMESPACE
+}
+#endif
+
+#endif
diff --git a/qt/ScintillaEditBase/ScintillaEditBase.cpp b/qt/ScintillaEditBase/ScintillaEditBase.cpp
new file mode 100644
index 000000000..b6cca8166
--- /dev/null
+++ b/qt/ScintillaEditBase/ScintillaEditBase.cpp
@@ -0,0 +1,635 @@
+//
+//          Copyright (c) 1990-2011, Scientific Toolworks, Inc.
+//
+// The License.txt file describes the conditions under which this software may be distributed.
+//
+// Author: Jason Haslam
+//
+// Additions Copyright (c) 2011 Archaeopteryx Software, Inc. d/b/a Wingware
+// ScintillaEditBase.cpp - Qt widget that wraps ScintillaQt and provides events and scrolling
+
+#include "ScintillaEditBase.h"
+#include "ScintillaQt.h"
+#include "PlatQt.h"
+
+#include <QApplication>
+#include <QInputContext>
+#include <QPainter>
+#include <QScrollBar>
+#include <QTextFormat>
+#include <QVarLengthArray>
+
+#define INDIC_INPUTMETHOD 24
+
+#ifdef SCI_NAMESPACE
+using namespace Scintilla;
+#endif
+
+ScintillaEditBase::ScintillaEditBase(QWidget *parent)
+: QAbstractScrollArea(parent), sqt(0), preeditPos(-1), wheelDelta(0)
+{
+	sqt = new ScintillaQt(this);
+
+	time.start();
+
+	// Set Qt defaults.
+	setAcceptDrops(true);
+	setMouseTracking(true);
+	setAutoFillBackground(false);
+	setFrameStyle(QFrame::NoFrame);
+	setFocusPolicy(Qt::StrongFocus);
+	setAttribute(Qt::WA_StaticContents);
+	setAttribute(Qt::WA_OpaquePaintEvent);
+	setAttribute(Qt::WA_KeyCompression);
+	setAttribute(Qt::WA_InputMethodEnabled);
+
+	connect(sqt, SIGNAL(notifyParent(SCNotification)),
+	        this, SLOT(notifyParent(SCNotification)));
+
+	// Connect scroll bars.
+	connect(verticalScrollBar(), SIGNAL(valueChanged(int)),
+	        this, SLOT(scrollVertical(int)));
+	connect(horizontalScrollBar(), SIGNAL(valueChanged(int)),
+	        this, SLOT(scrollHorizontal(int)));
+
+	// Connect pass-through signals.
+	connect(sqt, SIGNAL(horizontalRangeChanged(int,int)),
+	        this, SIGNAL(horizontalRangeChanged(int,int)));
+	connect(sqt, SIGNAL(verticalRangeChanged(int,int)),
+	        this, SIGNAL(verticalRangeChanged(int,int)));
+	connect(sqt, SIGNAL(horizontalScrolled(int)),
+	        this, SIGNAL(horizontalScrolled(int)));
+	connect(sqt, SIGNAL(verticalScrolled(int)),
+	        this, SIGNAL(verticalScrolled(int)));
+
+	connect(sqt, SIGNAL(notifyChange()),
+	        this, SIGNAL(notifyChange()));
+
+	connect(sqt, SIGNAL(command(uptr_t, sptr_t)),
+	        this, SLOT(event_command(uptr_t, sptr_t)));
+
+	connect(sqt, SIGNAL(aboutToCopy(QMimeData *)),
+	        this, SIGNAL(aboutToCopy(QMimeData *)));
+}
+
+ScintillaEditBase::~ScintillaEditBase() {}
+
+sptr_t ScintillaEditBase::send(
+	unsigned int iMessage,
+	uptr_t wParam,
+	sptr_t lParam) const
+{
+	return sqt->WndProc(iMessage, wParam, lParam);
+}
+
+sptr_t ScintillaEditBase::sends(
+    unsigned int iMessage,
+    uptr_t wParam,
+    const char *s) const
+{
+	return sqt->WndProc(iMessage, wParam, (sptr_t)s);
+}
+
+void ScintillaEditBase::scrollHorizontal(int value)
+{
+	sqt->HorizontalScrollTo(value);
+}
+
+void ScintillaEditBase::scrollVertical(int value)
+{
+	sqt->ScrollTo(value);
+}
+
+bool ScintillaEditBase::event(QEvent *event)
+{
+	bool result = false;
+
+	if (event->type() == QEvent::KeyPress) {
+		// Circumvent the tab focus convention.
+		keyPressEvent(static_cast<QKeyEvent *>(event));
+		result = event->isAccepted();
+	} else {
+		result = QAbstractScrollArea::event(event);
+	}
+
+	return result;
+}
+
+void ScintillaEditBase::paintEvent(QPaintEvent *event)
+{
+	sqt->PartialPaint(PRectFromQRect(event->rect()));
+}
+
+void ScintillaEditBase::wheelEvent(QWheelEvent *event)
+{
+	if (event->orientation() == Qt::Horizontal) {
+		if (horizontalScrollBarPolicy() == Qt::ScrollBarAlwaysOff)
+			event->ignore();
+		else
+			QAbstractScrollArea::wheelEvent(event);
+	} else {
+		if (event->modifiers() & Qt::ControlModifier) {
+			// Zoom! We play with the font sizes in the styles.
+			// Number of steps/line is ignored, we just care if sizing up or down
+			if (event->delta() > 0) {
+				sqt->KeyCommand(SCI_ZOOMIN);
+			} else {
+				sqt->KeyCommand(SCI_ZOOMOUT);
+			}
+		} else {
+			// Ignore wheel events when the scroll bars are disabled.
+			if (verticalScrollBarPolicy() == Qt::ScrollBarAlwaysOff) {
+				event->ignore();
+			} else {
+				// Scroll
+				QAbstractScrollArea::wheelEvent(event);
+			}
+		}
+	}
+}
+
+void ScintillaEditBase::focusInEvent(QFocusEvent *event)
+{
+	sqt->SetFocusState(true);
+	emit updateUi();
+
+	QAbstractScrollArea::focusInEvent(event);
+}
+
+void ScintillaEditBase::focusOutEvent(QFocusEvent *event)
+{
+	sqt->SetFocusState(false);
+
+	QAbstractScrollArea::focusOutEvent(event);
+}
+
+void ScintillaEditBase::resizeEvent(QResizeEvent *)
+{
+	sqt->ChangeSize();
+	emit resized();
+}
+
+void ScintillaEditBase::keyPressEvent(QKeyEvent *event)
+{
+	// All keystrokes containing the meta modifier are
+	// assumed to be shortcuts not handled by scintilla.
+	if (event->modifiers() & Qt::MetaModifier) {
+		QAbstractScrollArea::keyPressEvent(event);
+		emit keyPressed(event);
+		return;
+	}
+
+	int key = 0;
+	switch (event->key()) {
+		case Qt::Key_Down:          key = SCK_DOWN;     break;
+		case Qt::Key_Up:            key = SCK_UP;       break;
+		case Qt::Key_Left:          key = SCK_LEFT;     break;
+		case Qt::Key_Right:         key = SCK_RIGHT;    break;
+		case Qt::Key_Home:          key = SCK_HOME;     break;
+		case Qt::Key_End:           key = SCK_END;      break;
+		case Qt::Key_PageUp:        key = SCK_PRIOR;    break;
+		case Qt::Key_PageDown:      key = SCK_NEXT;     break;
+		case Qt::Key_Delete:        key = SCK_DELETE;   break;
+		case Qt::Key_Insert:        key = SCK_INSERT;   break;
+		case Qt::Key_Escape:        key = SCK_ESCAPE;   break;
+		case Qt::Key_Backspace:     key = SCK_BACK;     break;
+		case Qt::Key_Plus:          key = SCK_ADD;      break;
+		case Qt::Key_Minus:         key = SCK_SUBTRACT; break;
+		case Qt::Key_Backtab:       // fall through
+		case Qt::Key_Tab:           key = SCK_TAB;      break;
+		case Qt::Key_Enter:         // fall through
+		case Qt::Key_Return:        key = SCK_RETURN;   break;
+		case Qt::Key_Control:       key = 0;            break;
+		case Qt::Key_Alt:           key = 0;            break;
+		case Qt::Key_Shift:         key = 0;            break;
+		case Qt::Key_Meta:          key = 0;            break;
+		default:                    key = event->key(); break;
+	}
+
+	bool shift = event->modifiers() & Qt::ShiftModifier;
+	bool ctrl  = event->modifiers() & Qt::ControlModifier;
+	bool alt   = event->modifiers() & Qt::AltModifier;
+
+	bool consumed = false;
+	bool added = sqt->KeyDown(key, shift, ctrl, alt, &consumed) != 0;
+	if (!consumed)
+		consumed = added;
+
+	if (!consumed) {
+		// Don't insert text if the control key was pressed unless
+		// it was pressed in conjunction with alt for AltGr emulation.
+		bool input = (!ctrl || alt);
+
+		// Additionally, on non-mac platforms, don't insert text
+		// if the alt key was pressed unless control is also present.
+		// On mac alt can be used to insert special characters.
+#ifndef Q_WS_MAC
+		input &= (!alt || ctrl);
+#endif
+
+		QString text = event->text();
+		if (input && !text.isEmpty() && text[0].isPrint()) {
+			QByteArray utext = sqt->BytesForDocument(text);
+			sqt->AddCharUTF(utext.data(), utext.size());
+		} else {
+			event->ignore();
+		}
+	}
+
+	emit keyPressed(event);
+}
+
+static int modifierTranslated(int sciModifier)
+{
+	switch (sciModifier) {
+		case SCMOD_SHIFT:
+			return Qt::ShiftModifier;
+		case SCMOD_CTRL:
+			return Qt::ControlModifier;
+		case SCMOD_ALT:
+			return Qt::AltModifier;
+		case SCMOD_SUPER:
+			return Qt::MetaModifier;
+		default:
+			return 0;
+	}
+}
+
+void ScintillaEditBase::mousePressEvent(QMouseEvent *event)
+{
+	Point pos = PointFromQPoint(event->pos());
+
+	emit buttonPressed(event);
+
+	if (event->button() == Qt::MidButton &&
+	    QApplication::clipboard()->supportsSelection()) {
+		SelectionPosition selPos = sqt->SPositionFromLocation(
+					pos, false, false, sqt->UserVirtualSpace());
+		sqt->sel.Clear();
+		sqt->SetSelection(selPos, selPos);
+		sqt->PasteFromMode(QClipboard::Selection);
+		return;
+	}
+
+	bool button = event->button() == Qt::LeftButton;
+
+	if (button) {
+		bool shift = event->modifiers() & Qt::ShiftModifier;
+		bool ctrl  = event->modifiers() & Qt::ControlModifier;
+#ifdef Q_WS_X11
+		// On X allow choice of rectangular modifier since most window
+		// managers grab alt + click for moving windows.
+		bool alt   = event->modifiers() & modifierTranslated(sqt->rectangularSelectionModifier);
+#else
+		bool alt   = event->modifiers() & Qt::AltModifier;
+#endif
+
+		sqt->ButtonDown(pos, time.elapsed(), shift, ctrl, alt);
+	}
+}
+
+void ScintillaEditBase::mouseReleaseEvent(QMouseEvent *event)
+{
+	Point point = PointFromQPoint(event->pos());
+	bool ctrl  = event->modifiers() & Qt::ControlModifier;
+	if (event->button() == Qt::LeftButton)
+		sqt->ButtonUp(point, time.elapsed(), ctrl);
+
+	int pos = send(SCI_POSITIONFROMPOINT, point.x, point.y);
+	int line = send(SCI_LINEFROMPOSITION, pos);
+	int modifiers = event->modifiers();
+
+	emit textAreaClicked(line, modifiers);
+	emit buttonReleased(event);
+}
+
+void ScintillaEditBase::mouseDoubleClickEvent(QMouseEvent *event)
+{
+	// Scintilla does its own double-click detection.
+	mousePressEvent(event);
+}
+
+void ScintillaEditBase::mouseMoveEvent(QMouseEvent *event)
+{
+	Point pos = PointFromQPoint(event->pos());
+	sqt->ButtonMove(pos);
+}
+
+void ScintillaEditBase::contextMenuEvent(QContextMenuEvent *event)
+{
+	Point pos = PointFromQPoint(event->globalPos());
+	Point pt = PointFromQPoint(event->pos());
+	if (!sqt->PointInSelection(pt))
+		sqt->SetEmptySelection(sqt->PositionFromLocation(pt));
+	sqt->ContextMenu(pos);
+}
+
+void ScintillaEditBase::dragEnterEvent(QDragEnterEvent *event)
+{
+	if (event->mimeData()->hasText()) {
+		event->acceptProposedAction();
+
+		Point point = PointFromQPoint(event->pos());
+		sqt->DragEnter(point);
+	} else {
+		event->ignore();
+	}
+}
+
+void ScintillaEditBase::dragLeaveEvent(QDragLeaveEvent * /* event */)
+{
+	sqt->DragLeave();
+}
+
+void ScintillaEditBase::dragMoveEvent(QDragMoveEvent *event)
+{
+	if (event->mimeData()->hasText()) {
+		event->acceptProposedAction();
+
+		Point point = PointFromQPoint(event->pos());
+		sqt->DragMove(point);
+	} else {
+		event->ignore();
+	}
+}
+
+void ScintillaEditBase::dropEvent(QDropEvent *event)
+{
+	if (event->mimeData()->hasText()) {
+		event->acceptProposedAction();
+
+		Point point = PointFromQPoint(event->pos());
+		bool move = (event->source() == this &&
+                 event->proposedAction() == Qt::MoveAction);
+		sqt->Drop(point, event->mimeData(), move);
+	} else {
+		event->ignore();
+	}
+}
+
+void ScintillaEditBase::inputMethodEvent(QInputMethodEvent *event)
+{
+	// Clear the current selection.
+	sqt->ClearSelection();
+	if (preeditPos >= 0)
+		sqt->SetSelection(preeditPos, preeditPos);
+
+	// Insert the commit string.
+	if (!event->commitString().isEmpty() || event->replacementLength()) {
+		// Select the text to be removed.
+		int commitPos = send(SCI_GETCURRENTPOS);
+		int start = commitPos + event->replacementStart();
+		int end = start + event->replacementLength();
+		sqt->SetSelection(start, end);
+
+		// Replace the selection with the commit string.
+		QByteArray commitBytes = sqt->BytesForDocument(event->commitString());
+		char *commitData = commitBytes.data();
+		sqt->AddCharUTF(commitData, strlen(commitData));
+	}
+
+	// Select the previous preedit string.
+	int pos = send(SCI_GETCURRENTPOS);
+	int length = sqt->BytesForDocument(preeditString).length();
+	sqt->SetSelection(pos, pos + length);
+
+	// Replace the selection with the new preedit string.
+	QByteArray bytes = sqt->BytesForDocument(event->preeditString());
+	char *data = bytes.data();
+	bool recording = sqt->recordingMacro;
+	sqt->recordingMacro = false;
+	send(SCI_SETUNDOCOLLECTION, false);
+	sqt->AddCharUTF(data, strlen(data));
+	send(SCI_SETUNDOCOLLECTION, true);
+	sqt->recordingMacro = recording;
+	sqt->SetSelection(pos, pos);
+
+	// Store the state of the current preedit string.
+	preeditString = event->preeditString();
+	preeditPos = !preeditString.isEmpty() ? send(SCI_GETCURRENTPOS) : -1;
+
+	if (!preeditString.isEmpty()) {
+		// Apply attributes to the preedit string.
+		int indicNum = 0;
+		sqt->ShowCaretAtCurrentPosition();
+		foreach (QInputMethodEvent::Attribute a, event->attributes()) {
+			QString prefix = preeditString.left(a.start);
+			QByteArray prefixBytes = sqt->BytesForDocument(prefix);
+			int prefixLength = prefixBytes.length();
+			int caretPos = preeditPos + prefixLength;
+
+			if (a.type == QInputMethodEvent::Cursor) {
+				sqt->SetSelection(caretPos, caretPos);
+				if (!a.length)
+					sqt->DropCaret();
+
+			} else if (a.type == QInputMethodEvent::TextFormat) {
+				Q_ASSERT(a.value.canConvert(QVariant::TextFormat));
+				QTextFormat format = a.value.value<QTextFormat>();
+				Q_ASSERT(format.isCharFormat());
+				QTextCharFormat charFormat = format.toCharFormat();
+
+				QString sub = preeditString.mid(a.start, a.length);
+				QByteArray subBytes = sqt->BytesForDocument(sub);
+				int subLength = subBytes.length();
+
+				if (charFormat.underlineStyle() != QTextCharFormat::NoUnderline) {
+					// Set temporary indicator for underline style.
+					QColor uc = charFormat.underlineColor();
+					int style = INDIC_PLAIN;
+					if (charFormat.underlineStyle() == QTextCharFormat::DashUnderline)
+						style = INDIC_DASH;
+					send(SCI_INDICSETSTYLE, INDIC_INPUTMETHOD + indicNum, style);
+					send(SCI_INDICSETFORE, INDIC_INPUTMETHOD + indicNum, uc.rgb());
+					send(SCI_SETINDICATORCURRENT, INDIC_INPUTMETHOD + indicNum);
+					send(SCI_INDICATORFILLRANGE, caretPos, subLength);
+					indicNum++;
+				}
+			}
+		}
+	}
+}
+
+QVariant ScintillaEditBase::inputMethodQuery(Qt::InputMethodQuery query) const
+{
+	int pos = send(SCI_GETCURRENTPOS);
+	int line = send(SCI_LINEFROMPOSITION, pos);
+
+	switch (query) {
+		case Qt::ImMicroFocus:
+		{
+			int startPos = (preeditPos >= 0) ? preeditPos : pos;
+			Point pt = sqt->LocationFromPosition(startPos);
+			int width = send(SCI_GETCARETWIDTH);
+			int height = send(SCI_TEXTHEIGHT, line);
+			return QRect(pt.x, pt.y, width, height);
+		}
+
+		case Qt::ImFont:
+		{
+			char fontName[64];
+			int style = send(SCI_GETSTYLEAT, pos);
+			int len = send(SCI_STYLEGETFONT, style, (long)fontName);
+			int size = send(SCI_STYLEGETSIZE, style);
+			bool italic = send(SCI_STYLEGETITALIC, style);
+			int weight = send(SCI_STYLEGETBOLD, style) ? QFont::Bold : -1;
+			return QFont(QString::fromUtf8(fontName, len), size, weight, italic);
+		}
+
+		case Qt::ImCursorPosition:
+		{
+			int paraStart = sqt->pdoc->ParaUp(pos);
+			return pos - paraStart;
+		}
+
+		case Qt::ImSurroundingText:
+		{
+			int paraStart = sqt->pdoc->ParaUp(pos);
+			int paraEnd = sqt->pdoc->ParaDown(pos);
+			QVarLengthArray<char,1024> buffer(paraEnd - paraStart + 1);
+
+			Sci_CharacterRange charRange;
+			charRange.cpMin = paraStart;
+			charRange.cpMax = paraEnd;
+
+			Sci_TextRange textRange;
+			textRange.chrg = charRange;
+			textRange.lpstrText = buffer.data();
+
+			send(SCI_GETTEXTRANGE, 0, (long)&textRange);
+
+			return sqt->StringFromDocument(buffer.constData());
+		}
+
+		case Qt::ImCurrentSelection:
+		{
+			QVarLengthArray<char,1024> buffer(send(SCI_GETSELTEXT));
+			send(SCI_GETSELTEXT, 0, (long)buffer.data());
+
+			return sqt->StringFromDocument(buffer.constData());
+		}
+
+		default:
+			return QVariant();
+	}
+}
+
+void ScintillaEditBase::notifyParent(SCNotification scn)
+{
+	emit notify(&scn);
+	switch (scn.nmhdr.code) {
+		case SCN_STYLENEEDED:
+			emit styleNeeded(scn.position);
+			break;
+
+		case SCN_CHARADDED:
+			emit charAdded(scn.ch);
+			break;
+
+		case SCN_SAVEPOINTREACHED:
+			emit savePointChanged(false);
+			break;
+
+		case SCN_SAVEPOINTLEFT:
+			emit savePointChanged(true);
+			break;
+
+		case SCN_MODIFYATTEMPTRO:
+			emit modifyAttemptReadOnly();
+			break;
+
+		case SCN_KEY:
+			emit key(scn.ch);
+			break;
+
+		case SCN_DOUBLECLICK:
+			emit doubleClick(scn.position, scn.line);
+			break;
+
+		case SCN_UPDATEUI:
+			emit updateUi();
+			break;
+
+		case SCN_MODIFIED:
+		{
+			bool added = scn.modificationType & SC_MOD_INSERTTEXT;
+			bool deleted = scn.modificationType & SC_MOD_DELETETEXT;
+
+			int length = send(SCI_GETTEXTLENGTH);
+			bool firstLineAdded = (added && length == 1) ||
+			                      (deleted && length == 0);
+
+			if (scn.linesAdded != 0) {
+				emit linesAdded(scn.linesAdded);
+			} else if (firstLineAdded) {
+				emit linesAdded(added ? 1 : -1);
+			}
+
+			const QByteArray bytes = QByteArray::fromRawData(scn.text, scn.length);
+			emit modified(scn.modificationType, scn.position, scn.length,
+			              scn.linesAdded, bytes, scn.line,
+			              scn.foldLevelNow, scn.foldLevelPrev);
+			break;
+		}
+
+		case SCN_MACRORECORD:
+			emit macroRecord(scn.message, scn.wParam, scn.lParam);
+			break;
+
+		case SCN_MARGINCLICK:
+			emit marginClicked(scn.position, scn.modifiers, scn.margin);
+			break;
+
+		case SCN_NEEDSHOWN:
+			emit needShown(scn.position, scn.length);
+			break;
+
+		case SCN_PAINTED:
+			emit painted();
+			break;
+
+		case SCN_USERLISTSELECTION:
+			emit userListSelection();
+			break;
+
+		case SCN_URIDROPPED:
+			emit uriDropped();
+			break;
+
+		case SCN_DWELLSTART:
+			emit dwellStart(scn.x, scn.y);
+			break;
+
+		case SCN_DWELLEND:
+			emit dwellEnd(scn.x, scn.y);
+			break;
+
+		case SCN_ZOOM:
+			emit zoom(send(SCI_GETZOOM));
+			break;
+
+		case SCN_HOTSPOTCLICK:
+			emit hotSpotClick(scn.position, scn.modifiers);
+			break;
+
+		case SCN_HOTSPOTDOUBLECLICK:
+			emit hotSpotDoubleClick(scn.position, scn.modifiers);
+			break;
+
+		case SCN_CALLTIPCLICK:
+			emit callTipClick();
+			break;
+
+		case SCN_AUTOCSELECTION:
+			emit autoCompleteSelection(scn.lParam, QString::fromUtf8(scn.text));
+			break;
+
+		default:
+			return;
+	}
+}
+
+void ScintillaEditBase::event_command(uptr_t wParam, sptr_t lParam)
+{
+	emit command(wParam, lParam);
+}
diff --git a/qt/ScintillaEditBase/ScintillaEditBase.h b/qt/ScintillaEditBase/ScintillaEditBase.h
new file mode 100644
index 000000000..0f625eba3
--- /dev/null
+++ b/qt/ScintillaEditBase/ScintillaEditBase.h
@@ -0,0 +1,151 @@
+//
+//          Copyright (c) 1990-2011, Scientific Toolworks, Inc.
+//
+// The License.txt file describes the conditions under which this software may be distributed.
+//
+// Author: Jason Haslam
+//
+// Additions Copyright (c) 2011 Archaeopteryx Software, Inc. d/b/a Wingware
+// ScintillaWidget.h - Qt widget that wraps ScintillaQt and provides events and scrolling
+
+
+#ifndef SCINTILLAEDITBASE_H
+#define SCINTILLAEDITBASE_H
+
+#include "Platform.h"
+#include "Scintilla.h"
+
+#include <QAbstractScrollArea>
+#include <QMimeData>
+#include <QTime>
+
+#ifdef SCI_NAMESPACE
+namespace Scintilla {
+#endif
+
+class ScintillaQt;
+class SurfaceImpl;
+struct SCNotification;
+
+#ifdef WIN32
+#ifdef MAKING_LIBRARY
+#define EXPORT_IMPORT_API __declspec(dllexport)
+#else
+// Defining dllimport upsets moc
+#define EXPORT_IMPORT_API __declspec(dllimport)
+//#define EXPORT_IMPORT_API
+#endif
+#else
+#define EXPORT_IMPORT_API
+#endif
+
+class EXPORT_IMPORT_API ScintillaEditBase : public QAbstractScrollArea {
+	Q_OBJECT
+
+public:
+	ScintillaEditBase(QWidget *parent = 0);
+	virtual ~ScintillaEditBase();
+
+	virtual sptr_t send(
+		unsigned int iMessage,
+		uptr_t wParam = 0,
+		sptr_t lParam = 0) const;
+
+	virtual sptr_t sends(
+		unsigned int iMessage,
+		uptr_t wParam = 0,
+		const char *s = 0) const;
+
+public slots:
+	// Scroll events coming from GUI to be sent to Scintilla.
+	void scrollHorizontal(int value);
+	void scrollVertical(int value);
+
+	// Emit Scintilla notifications as signals.
+	void notifyParent(SCNotification scn);
+	void event_command(uptr_t wParam, sptr_t lParam);
+
+signals:
+	void horizontalScrolled(int value);
+	void verticalScrolled(int value);
+	void horizontalRangeChanged(int max, int page);
+	void verticalRangeChanged(int max, int page);
+	void notifyChange();
+	void linesAdded(int linesAdded);
+
+	// Clients can use this hook to add additional
+	// formats (e.g. rich text) to the MIME data.
+	void aboutToCopy(QMimeData *data);
+
+	// Scintilla Notifications
+	void styleNeeded(int position);
+	void charAdded(int ch);
+	void savePointChanged(bool dirty);
+	void modifyAttemptReadOnly();
+	void key(int key);
+	void doubleClick(int position, int line);
+	void updateUi();
+	void modified(int type, int position, int length, int linesAdded,
+	              const QByteArray &text, int line, int foldNow, int foldPrev);
+	void macroRecord(int message, uptr_t wParam, sptr_t lParam);
+	void marginClicked(int position, int modifiers, int margin);
+	void textAreaClicked(int line, int modifiers);
+	void needShown(int position, int length);
+	void painted();
+	void userListSelection(); // Wants some args.
+	void uriDropped();        // Wants some args.
+	void dwellStart(int x, int y);
+	void dwellEnd(int x, int y);
+	void zoom(int zoom);
+	void hotSpotClick(int position, int modifiers);
+	void hotSpotDoubleClick(int position, int modifiers);
+	void callTipClick();
+	void autoCompleteSelection(int position, const QString &text);
+
+	// Base notifications for compatibility with other Scintilla implementations
+	void notify(SCNotification *pscn);
+	void command(uptr_t wParam, sptr_t lParam);
+
+	// GUI event notifications needed under Qt
+	void buttonPressed(QMouseEvent *event);
+	void buttonReleased(QMouseEvent *event);
+	void keyPressed(QKeyEvent *event);
+	void resized();
+
+protected:
+	virtual bool event(QEvent *event);
+	virtual void paintEvent(QPaintEvent *event);
+	virtual void wheelEvent(QWheelEvent *event);
+	virtual void focusInEvent(QFocusEvent *event);
+	virtual void focusOutEvent(QFocusEvent *event);
+	virtual void resizeEvent(QResizeEvent *event);
+	virtual void keyPressEvent(QKeyEvent *event);
+	virtual void mousePressEvent(QMouseEvent *event);
+	virtual void mouseReleaseEvent(QMouseEvent *event);
+	virtual void mouseDoubleClickEvent(QMouseEvent *event);
+	virtual void mouseMoveEvent(QMouseEvent *event);
+	virtual void contextMenuEvent(QContextMenuEvent *event);
+	virtual void dragEnterEvent(QDragEnterEvent *event);
+	virtual void dragLeaveEvent(QDragLeaveEvent *event);
+	virtual void dragMoveEvent(QDragMoveEvent *event);
+	virtual void dropEvent(QDropEvent *event);
+	virtual void inputMethodEvent(QInputMethodEvent *event);
+	virtual QVariant inputMethodQuery(Qt::InputMethodQuery query) const;
+	virtual void scrollContentsBy(int, int) {}
+
+private:
+	ScintillaQt *sqt;
+
+	QTime time;
+
+	int preeditPos;
+	QString preeditString;
+
+	int wheelDelta;
+};
+
+#ifdef SCI_NAMESPACE
+}
+#endif
+
+#endif /* SCINTILLAEDITBASE_H */
diff --git a/qt/ScintillaEditBase/ScintillaEditBase.pro b/qt/ScintillaEditBase/ScintillaEditBase.pro
new file mode 100644
index 000000000..cdf0b685e
--- /dev/null
+++ b/qt/ScintillaEditBase/ScintillaEditBase.pro
@@ -0,0 +1,111 @@
+#-------------------------------------------------
+#
+# Project created by QtCreator 2011-05-05T12:41:23
+#
+#-------------------------------------------------
+
+QT       += core gui
+
+TARGET = ScintillaEditBase
+TEMPLATE = lib
+CONFIG += lib_bundle
+
+VERSION = 3.1.0
+
+SOURCES += \
+    PlatQt.cpp \
+    ScintillaQt.cpp \
+    ScintillaEditBase.cpp \
+    ../../src/XPM.cxx \
+    ../../src/ViewStyle.cxx \
+    ../../src/UniConversion.cxx \
+    ../../src/Style.cxx \
+    ../../src/Selection.cxx \
+    ../../src/ScintillaBase.cxx \
+    ../../src/RunStyles.cxx \
+    ../../src/RESearch.cxx \
+    ../../src/PositionCache.cxx \
+    ../../src/PerLine.cxx \
+    ../../src/LineMarker.cxx \
+    ../../src/KeyMap.cxx \
+    ../../src/Indicator.cxx \
+    ../../src/ExternalLexer.cxx \
+    ../../src/Editor.cxx \
+    ../../src/Document.cxx \
+    ../../src/Decoration.cxx \
+    ../../src/ContractionState.cxx \
+    ../../src/CharClassify.cxx \
+    ../../src/CellBuffer.cxx \
+    ../../src/Catalogue.cxx \
+    ../../src/CallTip.cxx \
+    ../../src/AutoComplete.cxx \
+    ../../lexlib/WordList.cxx \
+    ../../lexlib/StyleContext.cxx \
+    ../../lexlib/PropSetSimple.cxx \
+    ../../lexlib/LexerSimple.cxx \
+    ../../lexlib/LexerNoExceptions.cxx \
+    ../../lexlib/LexerModule.cxx \
+    ../../lexlib/LexerBase.cxx \
+    ../../lexlib/CharacterSet.cxx \
+    ../../lexlib/Accessor.cxx \
+    ../../lexers/*.cxx
+
+HEADERS  += \
+    PlatQt.h \
+    ScintillaQt.h \
+    ScintillaEditBase.h \
+    ../../src/XPM.h \
+    ../../src/ViewStyle.h \
+    ../../src/UniConversion.h \
+    ../../src/SVector.h \
+    ../../src/Style.h \
+    ../../src/SplitVector.h \
+    ../../src/Selection.h \
+    ../../src/ScintillaBase.h \
+    ../../src/RunStyles.h \
+    ../../src/RESearch.h \
+    ../../src/PositionCache.h \
+    ../../src/PerLine.h \
+    ../../src/Partitioning.h \
+    ../../src/LineMarker.h \
+    ../../src/KeyMap.h \
+    ../../src/Indicator.h \
+    ../../src/FontQuality.h \
+    ../../src/ExternalLexer.h \
+    ../../src/Editor.h \
+    ../../src/Document.h \
+    ../../src/Decoration.h \
+    ../../src/ContractionState.h \
+    ../../src/CharClassify.h \
+    ../../src/CellBuffer.h \
+    ../../src/Catalogue.h \
+    ../../src/CallTip.h \
+    ../../src/AutoComplete.h \
+    ../../include/Scintilla.h \
+    ../../include/SciLexer.h \
+    ../../include/Platform.h \
+    ../../include/ILexer.h \
+    ../../lexlib/WordList.h \
+    ../../lexlib/StyleContext.h \
+    ../../lexlib/SparseState.h \
+    ../../lexlib/PropSetSimple.h \
+    ../../lexlib/OptionSet.h \
+    ../../lexlib/LexerSimple.h \
+    ../../lexlib/LexerNoExceptions.h \
+    ../../lexlib/LexerModule.h \
+    ../../lexlib/LexerBase.h \
+    ../../lexlib/LexAccessor.h \
+    ../../lexlib/CharacterSet.h \
+    ../../lexlib/Accessor.h
+
+OTHER_FILES +=
+
+INCLUDEPATH += ../../include ../../src ../../lexlib
+
+DEFINES += SCINTILLA_QT=1 MAKING_LIBRARY=1 SCI_LEXER=1 _CRT_SECURE_NO_DEPRECATE=1
+
+DESTDIR = ../../bin
+
+macx {
+	QMAKE_LFLAGS_SONAME = -Wl,-install_name,@executable_path/../Frameworks/
+}
diff --git a/qt/ScintillaEditBase/ScintillaQt.cpp b/qt/ScintillaEditBase/ScintillaQt.cpp
new file mode 100644
index 000000000..e65390f4a
--- /dev/null
+++ b/qt/ScintillaEditBase/ScintillaQt.cpp
@@ -0,0 +1,772 @@
+//
+//          Copyright (c) 1990-2011, Scientific Toolworks, Inc.
+//
+// The License.txt file describes the conditions under which this software may be distributed.
+//
+// Author: Jason Haslam
+//
+// Additions Copyright (c) 2011 Archaeopteryx Software, Inc. d/b/a Wingware
+// ScintillaQt.cpp - Qt specific subclass of ScintillaBase
+
+#include "PlatQt.h"
+#include "ScintillaQt.h"
+#ifdef SCI_LEXER
+#include "LexerModule.h"
+#include "ExternalLexer.h"
+#endif
+
+#include <QApplication>
+#include <QDrag>
+#include <QInputContext>
+#include <QMimeData>
+#include <QMenu>
+#include <QScrollBar>
+#include <QTimer>
+#include <QTextCodec>
+
+#ifdef SCI_NAMESPACE
+using namespace Scintilla;
+#endif
+
+
+ScintillaQt::ScintillaQt(QAbstractScrollArea *parent)
+: QObject(parent), scrollArea(parent), vMax(0),  hMax(0), vPage(0), hPage(0),
+ haveMouseCapture(false), dragWasDropped(false)
+{
+
+	wMain = scrollArea->viewport();
+
+	// On OS X drawing text into a pixmap moves it around 1 pixel to
+	// the right compared to drawing it directly onto a window.
+	// Buffered drawing turned off by default to avoid this.
+	WndProc(SCI_SETBUFFEREDDRAW, false, 0);
+
+	Initialise();
+}
+
+ScintillaQt::~ScintillaQt()
+{
+	SetTicking(false);
+}
+
+void ScintillaQt::tick()
+{
+	Tick();
+}
+
+void ScintillaQt::execCommand(QAction *action)
+{
+	int command = action->data().toInt();
+	Command(command);
+}
+
+#if defined(Q_OS_WIN)
+static const QString sMSDEVColumnSelect("MSDEVColumnSelect");
+static const QString sWrappedMSDEVColumnSelect("application/x-qt-windows-mime;value=\"MSDEVColumnSelect\"");
+#elif defined(Q_OS_MAC)
+static const QString sScintillaRecPboardType("com.scintilla.utf16-plain-text.rectangular");
+static const QString sScintillaRecMimeType("text/x-scintilla.utf16-plain-text.rectangular");
+#else
+// Linux
+static const QString sMimeRectangularMarker("text/x-rectangular-marker");
+#endif
+
+#ifdef Q_OS_MAC
+
+class ScintillaRectangularMime : public QMacPasteboardMime {
+public:
+	ScintillaRectangularMime() : QMacPasteboardMime(MIME_ALL) {
+	}
+
+	QString convertorName() {
+		return QString("ScintillaRectangularMime");
+	}
+
+	bool canConvert(const QString &mime, QString flav) {
+		return mimeFor(flav) == mime;
+	}
+
+	QString mimeFor(QString flav) {
+		if (flav == sScintillaRecPboardType)
+			return sScintillaRecMimeType;
+		return QString();
+	}
+
+	QString flavorFor(const QString &mime) {
+		if (mime == sScintillaRecMimeType)
+			return sScintillaRecPboardType;
+		return QString();
+	}
+
+	QVariant convertToMime(const QString & /* mime */, QList<QByteArray> data, QString /* flav */) {
+		QByteArray all;
+		foreach (QByteArray i, data) {
+			all += i;
+		}
+		return QVariant(all);
+	}
+
+	QList<QByteArray> convertFromMime(const QString & /* mime */, QVariant data, QString /* flav */) {
+		QByteArray a = data.toByteArray();
+		QList<QByteArray> l;
+		l.append(a);
+		return l;
+	}
+
+};
+
+// The Mime object registers itself but only want one for all Scintilla instances.
+// Should delete at exit to help memory leak detection but that would be extra work
+// and, since the clipboard exists after last Scintilla instance, may be complex.
+static ScintillaRectangularMime *singletonMime = 0;
+
+#endif
+
+void ScintillaQt::Initialise()
+{
+#if defined(Q_OS_WIN) || defined(Q_OS_MAC)
+	rectangularSelectionModifier = SCMOD_ALT;
+#else
+	rectangularSelectionModifier = SCMOD_CTRL;
+#endif
+
+#ifdef Q_OS_MAC
+	if (!singletonMime) {
+		singletonMime = new ScintillaRectangularMime();
+
+		QStringList slTypes(sScintillaRecPboardType);
+		qRegisterDraggedTypes(slTypes);
+	}
+#endif
+
+	connect(QApplication::clipboard(), SIGNAL(selectionChanged()),
+		this, SLOT(SelectionChanged()));
+}
+
+void ScintillaQt::Finalise()
+{
+	SetTicking(false);
+	ScintillaBase::Finalise();
+}
+
+void ScintillaQt::SelectionChanged()
+{
+	bool nowPrimary = QApplication::clipboard()->ownsSelection();
+	if (nowPrimary != primarySelection) {
+		primarySelection = nowPrimary;
+		Redraw();
+	}
+}
+
+bool ScintillaQt::DragThreshold(Point ptStart, Point ptNow)
+{
+	int xMove = abs(ptStart.x - ptNow.x);
+	int yMove = abs(ptStart.y - ptNow.y);
+	return (xMove > QApplication::startDragDistance()) ||
+		(yMove > QApplication::startDragDistance());
+}
+
+static QString StringFromSelectedText(const SelectionText &selectedText)
+{
+	if (selectedText.codePage == SC_CP_UTF8) {
+		return QString::fromUtf8(selectedText.s, selectedText.len-1);
+	} else {
+		QTextCodec *codec = QTextCodec::codecForName(
+				CharacterSetID(selectedText.characterSet));
+		return codec->toUnicode(selectedText.s, selectedText.len-1);
+	}
+}
+
+static void AddRectangularToMime(QMimeData *mimeData, QString su)
+{
+#if defined(Q_OS_WIN)
+	// Add an empty marker
+	mimeData->setData(sMSDEVColumnSelect, QByteArray());
+#elif defined(Q_OS_MAC)
+	// OS X gets marker + data to work with other implementations.
+	// Don't understand how this works but it does - the
+	// clipboard format is supposed to be UTF-16, not UTF-8.
+	mimeData->setData(sScintillaRecMimeType, su.toUtf8());
+#else
+	Q_UNUSED(su);
+	// Linux
+	// Add an empty marker
+	mimeData->setData(sMimeRectangularMarker, QByteArray());
+#endif
+}
+
+static bool IsRectangularInMime(const QMimeData *mimeData)
+{
+	QStringList formats = mimeData->formats();
+	for (int i = 0; i < formats.size(); ++i) {
+#if defined(Q_OS_WIN)
+		// Windows rectangular markers
+		// If rectangular copies made by this application, see base name.
+		if (formats[i] == sMSDEVColumnSelect)
+			return true;
+		// Otherwise see wrapped name.
+		if (formats[i] == sWrappedMSDEVColumnSelect)
+			return true;
+#elif defined(Q_OS_MAC)
+		if (formats[i] == sScintillaRecMimeType)
+			return true;
+#else
+		// Linux
+		if (formats[i] == sMimeRectangularMarker)
+			return true;
+#endif
+	}
+	return false;
+}
+
+bool ScintillaQt::ValidCodePage(int codePage) const
+{
+	return codePage == 0
+	|| codePage == SC_CP_UTF8
+	|| codePage == 932
+	|| codePage == 936
+	|| codePage == 949
+	|| codePage == 950
+	|| codePage == 1361;
+}
+
+
+void ScintillaQt::ScrollText(int linesToMove)
+{
+	int dy = vs.lineHeight * (linesToMove);
+	scrollArea->viewport()->scroll(0, dy);
+}
+
+void ScintillaQt::SetVerticalScrollPos()
+{
+	scrollArea->verticalScrollBar()->setValue(topLine);
+	emit verticalScrolled(topLine);
+}
+
+void ScintillaQt::SetHorizontalScrollPos()
+{
+	scrollArea->horizontalScrollBar()->setValue(xOffset);
+	emit horizontalScrolled(xOffset);
+}
+
+bool ScintillaQt::ModifyScrollBars(int nMax, int nPage)
+{
+	bool modified = false;
+
+	int vNewPage = nPage;
+	int vNewMax = nMax - vNewPage + 1;
+	if (vMax != vNewMax || vPage != vNewPage) {
+		vMax = vNewMax;
+		vPage = vNewPage;
+		modified = true;
+
+		scrollArea->verticalScrollBar()->setMaximum(vMax);
+		scrollArea->verticalScrollBar()->setPageStep(vPage);
+		emit verticalRangeChanged(vMax, vPage);
+	}
+
+	int hNewPage = GetTextRectangle().Width();
+	int hNewMax = (scrollWidth > hNewPage) ? scrollWidth - hNewPage : 0;
+	int charWidth = vs.styles[STYLE_DEFAULT].aveCharWidth;
+	if (hMax != hNewMax || hPage != hNewPage ||
+	    scrollArea->horizontalScrollBar()->singleStep() != charWidth) {
+		hMax = hNewMax;
+		hPage = hNewPage;
+		modified = true;
+
+		scrollArea->horizontalScrollBar()->setMaximum(hMax);
+		scrollArea->horizontalScrollBar()->setPageStep(hPage);
+		scrollArea->horizontalScrollBar()->setSingleStep(charWidth);
+		emit horizontalRangeChanged(hMax, hPage);
+	}
+
+	return modified;
+}
+
+void ScintillaQt::ReconfigureScrollBars()
+{
+	if (verticalScrollBarVisible) {
+		scrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
+	} else {
+		scrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+	}
+
+	if (horizontalScrollBarVisible && (wrapState == eWrapNone)) {
+		scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
+	} else {
+		scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+	}
+}
+
+void ScintillaQt::CopyToModeClipboard(const SelectionText &selectedText, QClipboard::Mode clipboardMode_)
+{
+	QClipboard *clipboard = QApplication::clipboard();
+	clipboard->clear(clipboardMode_);
+	QString su = StringFromSelectedText(selectedText);
+	QMimeData *mimeData = new QMimeData();
+	mimeData->setText(su);
+	if (selectedText.rectangular) {
+		AddRectangularToMime(mimeData, su);
+	}
+
+	// Allow client code to add additional data (e.g rich text).
+	emit aboutToCopy(mimeData);
+
+	clipboard->setMimeData(mimeData, clipboardMode_);
+}
+
+void ScintillaQt::Copy()
+{
+	if (!sel.Empty()) {
+		SelectionText st;
+		CopySelectionRange(&st);
+		CopyToClipboard(st);
+	}
+}
+
+void ScintillaQt::CopyToClipboard(const SelectionText &selectedText)
+{
+	CopyToModeClipboard(selectedText, QClipboard::Clipboard);
+}
+
+void ScintillaQt::PasteFromMode(QClipboard::Mode clipboardMode_)
+{
+	QClipboard *clipboard = QApplication::clipboard();
+	const QMimeData *mimeData = clipboard->mimeData(clipboardMode_);
+	bool isRectangular = IsRectangularInMime(mimeData);
+	QString text = clipboard->text(clipboardMode_);
+	QByteArray utext = BytesForDocument(text);
+	int len = utext.length();
+	char *dest = Document::TransformLineEnds(&len, utext, len, pdoc->eolMode);
+	SelectionText selText;
+	selText.Set(dest, len, pdoc->dbcsCodePage, CharacterSetOfDocument(), isRectangular, false);
+
+	UndoGroup ug(pdoc);
+	ClearSelection(multiPasteMode == SC_MULTIPASTE_EACH);
+	SelectionPosition selStart = sel.IsRectangular() ?
+		sel.Rectangular().Start() :
+		sel.Range(sel.Main()).Start();
+	if (selText.rectangular) {
+		PasteRectangular(selStart, selText.s, selText.len);
+	} else {
+		InsertPaste(selStart, selText.s, selText.len);
+	}
+	EnsureCaretVisible();
+}
+
+void ScintillaQt::Paste()
+{
+	PasteFromMode(QClipboard::Clipboard);
+}
+
+void ScintillaQt::ClaimSelection()
+{
+	if (QApplication::clipboard()->supportsSelection()) {
+		// X Windows has a 'primary selection' as well as the clipboard.
+		// Whenever the user selects some text, we become the primary selection
+		if (!sel.Empty()) {
+			primarySelection = true;
+			SelectionText st;
+			CopySelectionRange(&st);
+			CopyToModeClipboard(st, QClipboard::Selection);
+		} else {
+			primarySelection = false;
+		}
+	}
+}
+
+void ScintillaQt::NotifyChange()
+{
+	emit notifyChange();
+	emit command(
+			Platform::LongFromTwoShorts(GetCtrlID(), SCEN_CHANGE),
+			reinterpret_cast<sptr_t>(wMain.GetID()));
+}
+
+void ScintillaQt::NotifyFocus(bool focus)
+{
+	emit command(
+			Platform::LongFromTwoShorts
+					(GetCtrlID(), focus ? SCEN_SETFOCUS : SCEN_KILLFOCUS),
+			reinterpret_cast<sptr_t>(wMain.GetID()));
+}
+
+void ScintillaQt::NotifyParent(SCNotification scn)
+{
+	scn.nmhdr.hwndFrom = wMain.GetID();
+	scn.nmhdr.idFrom = GetCtrlID();
+	emit notifyParent(scn);
+}
+
+void ScintillaQt::SetTicking(bool on)
+{
+	QTimer *qTimer;
+	if (timer.ticking != on) {
+		timer.ticking = on;
+		if (timer.ticking) {
+			qTimer = new QTimer;
+			connect(qTimer, SIGNAL(timeout()), this, SLOT(tick()));
+			qTimer->start(timer.tickSize);
+			timer.tickerID = qTimer;
+		} else {
+			qTimer = static_cast<QTimer *>(timer.tickerID);
+			qTimer->stop();
+			disconnect(qTimer, SIGNAL(timeout()), 0, 0);
+			delete qTimer;
+			timer.tickerID = 0;
+		}
+	}
+	timer.ticksToWait = caret.period;
+}
+
+void ScintillaQt::onIdle()
+{
+	bool continueIdling = Idle();
+	if (!continueIdling) {
+		SetIdle(false);
+	}
+}
+
+bool ScintillaQt::SetIdle(bool on)
+{
+	QTimer *qIdle;
+	if (on) {
+		// Start idler, if it's not running.
+		if (!idler.state) {
+			idler.state = true;
+			qIdle = new QTimer;
+			connect(qIdle, SIGNAL(timeout()), this, SLOT(onIdle()));
+			qIdle->start(0);
+			idler.idlerID = qIdle;
+		}
+	} else {
+		// Stop idler, if it's running
+		if (idler.state) {
+			idler.state = false;
+			qIdle = static_cast<QTimer *>(idler.idlerID);
+			qIdle->stop();
+			disconnect(qIdle, SIGNAL(timeout()), 0, 0);
+			delete qIdle;
+			idler.idlerID = 0;
+		}
+	}
+	return true;
+}
+
+int ScintillaQt::CharacterSetOfDocument() const
+{
+	return vs.styles[STYLE_DEFAULT].characterSet;
+}
+
+const char *ScintillaQt::CharacterSetIDOfDocument() const
+{
+	return CharacterSetID(CharacterSetOfDocument());
+}
+
+QString ScintillaQt::StringFromDocument(const char *s) const
+{
+	if (IsUnicodeMode()) {
+		return QString::fromUtf8(s);
+	} else {
+		QTextCodec *codec = QTextCodec::codecForName(
+				CharacterSetID(CharacterSetOfDocument()));
+		return codec->toUnicode(s);
+	}
+}
+
+QByteArray ScintillaQt::BytesForDocument(const QString &text) const
+{
+	if (IsUnicodeMode()) {
+		return text.toUtf8();
+	} else {
+		QTextCodec *codec = QTextCodec::codecForName(
+				CharacterSetID(CharacterSetOfDocument()));
+		return codec->fromUnicode(text);
+	}
+}
+
+
+class CaseFolderUTF8 : public CaseFolderTable {
+public:
+	CaseFolderUTF8() {
+		StandardASCII();
+	}
+	virtual size_t Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed) {
+		if ((lenMixed == 1) && (sizeFolded > 0)) {
+			folded[0] = mapping[static_cast<unsigned char>(mixed[0])];
+			return 1;
+		} else {
+			QString su = QString::fromUtf8(mixed, lenMixed);
+			QString suFolded = su.toCaseFolded();
+			QByteArray bytesFolded = suFolded.toUtf8();
+			if (bytesFolded.length() < static_cast<int>(sizeFolded)) {
+				memcpy(folded, bytesFolded,  bytesFolded.length());
+				return bytesFolded.length();
+			} else {
+				folded[0] = '\0';
+				return 0;
+			}
+		}
+	}
+};
+
+class CaseFolderDBCS : public CaseFolderTable {
+	QTextCodec *codec;
+public:
+	CaseFolderDBCS(QTextCodec *codec_) : codec(codec_) {
+		StandardASCII();
+	}
+	virtual size_t Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed) {
+		if ((lenMixed == 1) && (sizeFolded > 0)) {
+			folded[0] = mapping[static_cast<unsigned char>(mixed[0])];
+			return 1;
+		} else if (codec) {
+			QString su = codec->toUnicode(mixed, lenMixed);
+			QString suFolded = su.toCaseFolded();
+			QByteArray bytesFolded = codec->fromUnicode(suFolded);
+
+			if (bytesFolded.length() < static_cast<int>(sizeFolded)) {
+				memcpy(folded, bytesFolded,  bytesFolded.length());
+				return bytesFolded.length();
+			}
+		}
+		// Something failed so return a single NUL byte
+		folded[0] = '\0';
+		return 1;
+	}
+};
+
+CaseFolder *ScintillaQt::CaseFolderForEncoding()
+{
+	if (pdoc->dbcsCodePage == SC_CP_UTF8) {
+		return new CaseFolderUTF8();
+	} else {
+		const char *charSetBuffer = CharacterSetIDOfDocument();
+		if (charSetBuffer) {
+			if (pdoc->dbcsCodePage == 0) {
+				CaseFolderTable *pcf = new CaseFolderTable();
+				pcf->StandardASCII();
+				QTextCodec *codec = QTextCodec::codecForName(charSetBuffer);
+				// Only for single byte encodings
+				for (int i=0x80; i<0x100; i++) {
+					char sCharacter[2] = "A";
+					sCharacter[0] = i;
+					QString su = codec->toUnicode(sCharacter, 1);
+					QString suFolded = su.toCaseFolded();
+					QByteArray bytesFolded = codec->fromUnicode(suFolded);
+					if (bytesFolded.length() == 1) {
+						pcf->SetTranslation(sCharacter[0], bytesFolded[0]);
+					}
+				}
+				return pcf;
+			} else {
+				return new CaseFolderDBCS(QTextCodec::codecForName(charSetBuffer));
+			}
+		}
+		return 0;
+	}
+}
+
+std::string ScintillaQt::CaseMapString(const std::string &s, int caseMapping)
+{
+	if (s.size() == 0)
+		return std::string();
+
+	if (caseMapping == cmSame)
+		return s;
+
+	QTextCodec *codec = 0;
+	QString text;
+	if (IsUnicodeMode()) {
+		text = QString::fromUtf8(s.c_str(), s.length());
+	} else {
+		codec = QTextCodec::codecForName(CharacterSetIDOfDocument());
+		text = codec->toUnicode(s.c_str(), s.length());
+	}
+
+	if (caseMapping == cmUpper) {
+		text = text.toUpper();
+	} else {
+		text = text.toLower();
+	}
+
+	QByteArray bytes = BytesForDocument(text);
+	return std::string(bytes.data(), bytes.length());
+}
+
+void ScintillaQt::SetMouseCapture(bool on)
+{
+	// This is handled automatically by Qt
+	if (mouseDownCaptures) {
+		haveMouseCapture = on;
+	}
+}
+
+bool ScintillaQt::HaveMouseCapture()
+{
+	return haveMouseCapture;
+}
+
+void ScintillaQt::StartDrag()
+{
+	inDragDrop = ddDragging;
+	dropWentOutside = true;
+	if (drag.len) {
+		QMimeData *mimeData = new QMimeData;
+		QString sText = StringFromSelectedText(drag);
+		mimeData->setText(sText);
+		if (drag.rectangular) {
+			AddRectangularToMime(mimeData, sText);
+		}
+		// This QDrag is not freed as that causes a crash on Linux
+		QDrag *dragon = new QDrag(scrollArea);
+		dragon->setMimeData(mimeData);
+
+		Qt::DropAction dropAction = dragon->exec(Qt::CopyAction|Qt::MoveAction);
+		if ((dropAction == Qt::MoveAction) && dropWentOutside) {
+			// Remove dragged out text
+			ClearSelection();
+		}
+	}
+	inDragDrop = ddNone;
+	SetDragPosition(SelectionPosition(invalidPosition));
+}
+
+void ScintillaQt::CreateCallTipWindow(PRectangle rc)
+{
+
+	if (!ct.wCallTip.Created()) {
+		QWidget *pCallTip =  new QWidget(0, Qt::ToolTip);
+		ct.wCallTip = pCallTip;
+		pCallTip->move(rc.left, rc.top);
+		pCallTip->resize(rc.Width(), rc.Height());
+	}
+}
+
+void ScintillaQt::AddToPopUp(const char *label,
+                             int cmd,
+                             bool enabled)
+{
+	QMenu *menu = static_cast<QMenu *>(popup.GetID());
+	QString text(label);
+
+	if (text.isEmpty()) {
+		menu->addSeparator();
+	} else {
+		QAction *action = menu->addAction(text);
+		action->setData(cmd);
+		action->setEnabled(enabled);
+	}
+
+	// Make sure the menu's signal is connected only once.
+	menu->disconnect();
+	connect(menu, SIGNAL(triggered(QAction *)),
+	        this, SLOT(execCommand(QAction *)));
+}
+
+sptr_t ScintillaQt::WndProc(unsigned int message, uptr_t wParam, sptr_t lParam)
+{
+	try {
+		switch (message) {
+
+		case SCI_GRABFOCUS:
+			scrollArea->setFocus(Qt::OtherFocusReason);
+			break;
+
+		case SCI_GETDIRECTFUNCTION:
+			return reinterpret_cast<sptr_t>(DirectFunction);
+
+		case SCI_GETDIRECTPOINTER:
+			return reinterpret_cast<sptr_t>(this);
+
+#ifdef SCI_LEXER
+		case SCI_LOADLEXERLIBRARY:
+			LexerManager::GetInstance()->Load(reinterpret_cast<const char *>(lParam));
+			break;
+#endif
+
+		default:
+			return ScintillaBase::WndProc(message, wParam, lParam);
+		}
+	} catch (std::bad_alloc &) {
+		errorStatus = SC_STATUS_BADALLOC;
+	} catch (...) {
+		errorStatus = SC_STATUS_FAILURE;
+	}
+	return 0l;
+}
+
+sptr_t ScintillaQt::DefWndProc(unsigned int, uptr_t, sptr_t)
+{
+	return 0;
+}
+
+sptr_t ScintillaQt::DirectFunction(
+    ScintillaQt *sciThis, unsigned int iMessage, uptr_t wParam, sptr_t lParam)
+{
+	return sciThis->WndProc(iMessage, wParam, lParam);
+}
+
+// Additions to merge in Scientific Toolworks widget structure
+
+void ScintillaQt::PartialPaint(const PRectangle &rect)
+{
+	rcPaint = rect;
+	paintState = painting;
+	PRectangle rcClient = GetClientRectangle();
+	paintingAllText = rcPaint.Contains(rcClient);
+
+	AutoSurface surface(this);
+	Paint(surface, rcPaint);
+	surface->Release();
+
+	if (paintState == paintAbandoned) {
+		// FIXME: Failure to paint the requested rectangle in each
+		// paint event causes flicker on some platforms (Mac?)
+		// Paint rect immediately.
+		paintState = painting;
+		paintingAllText = true;
+
+		AutoSurface surface(this);
+		Paint(surface, rcPaint);
+		surface->Release();
+
+		// Queue a full repaint.
+		scrollArea->viewport()->update();
+	}
+
+	paintState = notPainting;
+}
+
+void ScintillaQt::DragEnter(const Point &point)
+{
+	SetDragPosition(SPositionFromLocation(point,
+					      false, false, UserVirtualSpace()));
+}
+
+void ScintillaQt::DragMove(const Point &point)
+{
+	SetDragPosition(SPositionFromLocation(point,
+					      false, false, UserVirtualSpace()));
+}
+
+void ScintillaQt::DragLeave()
+{
+	SetDragPosition(SelectionPosition(invalidPosition));
+}
+
+void ScintillaQt::Drop(const Point &point, const QMimeData *data, bool move)
+{
+	QString text = data->text();
+	bool rectangular = IsRectangularInMime(data);
+	QByteArray bytes = BytesForDocument(text);
+	int len = bytes.length();
+	char *dest = Document::TransformLineEnds(&len, bytes, len, pdoc->eolMode);
+
+	SelectionPosition movePos = SPositionFromLocation(point,
+				false, false, UserVirtualSpace());
+
+	DropAt(movePos, dest, move, rectangular);
+
+	delete []dest;
+}
diff --git a/qt/ScintillaEditBase/ScintillaQt.h b/qt/ScintillaEditBase/ScintillaQt.h
new file mode 100644
index 000000000..61e24290d
--- /dev/null
+++ b/qt/ScintillaEditBase/ScintillaQt.h
@@ -0,0 +1,158 @@
+//
+//          Copyright (c) 1990-2011, Scientific Toolworks, Inc.
+//
+// The License.txt file describes the conditions under which this software may be distributed.
+//
+// Author: Jason Haslam
+//
+// Additions Copyright (c) 2011 Archaeopteryx Software, Inc. d/b/a Wingware
+// ScintillaQt.h - Qt specific subclass of ScintillaBase
+
+#ifndef SCINTILLAQT_H
+#define SCINTILLAQT_H
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <time.h>
+#include <string>
+#include <vector>
+#include <map>
+
+#include "Scintilla.h"
+#include "Platform.h"
+#include "ILexer.h"
+#include "SVector.h"
+#include "SplitVector.h"
+#include "Partitioning.h"
+#include "RunStyles.h"
+#include "ContractionState.h"
+#include "CellBuffer.h"
+#include "CallTip.h"
+#include "KeyMap.h"
+#include "Indicator.h"
+#include "XPM.h"
+#include "LineMarker.h"
+#include "Style.h"
+#include "AutoComplete.h"
+#include "ViewStyle.h"
+#include "CharClassify.h"
+#include "Decoration.h"
+#include "Document.h"
+#include "Selection.h"
+#include "PositionCache.h"
+#include "Editor.h"
+#include "ScintillaBase.h"
+
+#ifdef SCI_LEXER
+#include "SciLexer.h"
+#include "PropSetSimple.h"
+#endif
+
+#include <QObject>
+#include <QAbstractScrollArea>
+#include <QAction>
+#include <QClipboard>
+#include <QPaintEvent>
+
+#ifdef SCI_NAMESPACE
+namespace Scintilla {
+#endif
+
+class ScintillaQt : public QObject, public ScintillaBase {
+	Q_OBJECT
+
+public:
+	ScintillaQt(QAbstractScrollArea *parent);
+	virtual ~ScintillaQt();
+
+signals:
+	void horizontalScrolled(int value);
+	void verticalScrolled(int value);
+	void horizontalRangeChanged(int max, int page);
+	void verticalRangeChanged(int max, int page);
+
+	void notifyParent(SCNotification scn);
+	void notifyChange();
+
+	// Clients can use this hook to add additional
+	// formats (e.g. rich text) to the MIME data.
+	void aboutToCopy(QMimeData *data);
+
+	void command(uptr_t wParam, sptr_t lParam);
+
+private slots:
+	void tick();
+	void onIdle();
+	void execCommand(QAction *action);
+	void SelectionChanged();
+
+private:
+	virtual void Initialise();
+	virtual void Finalise();
+	virtual bool DragThreshold(Point ptStart, Point ptNow);
+	virtual bool ValidCodePage(int codePage) const;
+
+private:
+	virtual void ScrollText(int linesToMove);
+	virtual void SetVerticalScrollPos();
+	virtual void SetHorizontalScrollPos();
+	virtual bool ModifyScrollBars(int nMax, int nPage);
+	virtual void ReconfigureScrollBars();
+	void CopyToModeClipboard(const SelectionText &selectedText, QClipboard::Mode clipboardMode_);
+	virtual void Copy();
+	virtual void CopyToClipboard(const SelectionText &selectedText);
+	void PasteFromMode(QClipboard::Mode clipboardMode_);
+	virtual void Paste();
+	virtual void ClaimSelection();
+	virtual void NotifyChange();
+	virtual void NotifyFocus(bool focus);
+	virtual void NotifyParent(SCNotification scn);
+	virtual void SetTicking(bool on);
+	virtual bool SetIdle(bool on);
+	virtual void SetMouseCapture(bool on);
+	virtual bool HaveMouseCapture();
+	virtual void StartDrag();
+	int CharacterSetOfDocument() const;
+	const char *CharacterSetIDOfDocument() const;
+	QString StringFromDocument(const char *s) const;
+	QByteArray BytesForDocument(const QString &text) const;
+	virtual CaseFolder *CaseFolderForEncoding();
+	virtual std::string CaseMapString(const std::string &s, int caseMapping);
+
+	virtual void CreateCallTipWindow(PRectangle rc);
+	virtual void AddToPopUp(const char *label, int cmd = 0, bool enabled = true);
+	virtual sptr_t WndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
+	virtual sptr_t DefWndProc(unsigned int iMessage, uptr_t wParam, sptr_t lParam);
+
+	static sptr_t DirectFunction(ScintillaQt *sciThis,
+				     unsigned int iMessage, uptr_t wParam, sptr_t lParam);
+
+protected:
+
+	void PartialPaint(const PRectangle &rect);
+
+	void DragEnter(const Point &point);
+	void DragMove(const Point &point);
+	void DragLeave();
+	void Drop(const Point &point, const QMimeData *data, bool move);
+
+private:
+	QAbstractScrollArea *scrollArea;
+
+	int vMax, hMax;   // Scroll bar maximums.
+	int vPage, hPage; // Scroll bar page sizes.
+
+	bool haveMouseCapture;
+	bool dragWasDropped;
+	int rectangularSelectionModifier;
+
+	friend class ScintillaEditBase;
+};
+
+#ifdef SCI_NAMESPACE
+}
+#endif
+
+#endif // SCINTILLAQT_H
diff --git a/qt/ScintillaEditPy/README b/qt/ScintillaEditPy/README
new file mode 100644
index 000000000..c07397031
--- /dev/null
+++ b/qt/ScintillaEditPy/README
@@ -0,0 +1,85 @@
+README for building of ScintillaEditPy on Qt with PySide

+

+This directory is for building a Python encapsulation of Scintilla for use

+with PySide. For C++ libraries see the README in the parent directory.

+

+	Prerequisites

+	

+PySide and ScintillaEditPy currently only support Python 2.x.

+

+CMake may be used to rebuild PySide and is required on Windows.

+It can be downloaded from

+http://www.cmake.org/cmake/resources/software.html

+

+On Windows, PySide only supports Visual C++ 2008. The "Visual Studio 2008

+Command Prompt" should be used to run all build commands.

+Visual C++ 2008 Express Edition can be downloaded from

+http://msdn.microsoft.com/en-us/express/future/bb421473

+

+Download and install PySide. Instructions are on the PySide web site

+http://developer.qt.nokia.com/wiki/Category:LanguageBindings::PySide::Downloads

+

+For Linux, there may be both PySide library packages and PySide development

+files. Both should be installed as ScintillaEditPy needs the headers and

+libraries from the development package and runs with the normal library package.

+On apt-based systems, the packages are libshiboken-dev, shiboken, libpyside-dev,

+and python-pyside. python-dev is also needed for Python language headers.

+On yum-based systems the libpyside-dev package is called python-pyside-devel.

+The qmake program may not be in the path and can be found with

+"find /usr -name qmake".

+

+On Windows, the PySide library packages can be downloaded from 

+http://developer.qt.nokia.com/wiki/PySide_Binaries_Windows

+The PySide development files must be built from source using CMake as 

+described on the PySide site. This will create a Unix-style set of [bin, include,

+lib, and share] directories in packaging\setuptools\install-py<ver>-qt<qver>. 

+There is no standard place for the PySide development files so copy them

+to "\usr", creating it if needed.

+

+On OS X, a combined package with PySide libraries and PySide development

+files can be downloaded from 

+http://developer.qt.nokia.com/wiki/PySide_Binaries_MacOSX

+This package works best in combination with the Qt libraries for Mac from

+http://qt.nokia.com/downloads/downloads#qt-lib

+

+The path should be modified so that a Python 2.x interpreter and Qt's "qmake"

+program can be run by typing "python" or "qmake".

+

+	Building

+

+There are several steps to building and they are encapsulated in the sepbuild.py

+script which is run:

+

+python sepbuild.py

+

+This script first runs the WidgetGen.py script to fill out the ScintillaEdit.h, 

+ScintillaEdit.cpp and ScintillaConstants.py files.

+

+A short file "sepbuild.pri" is written out which contains a series of version and 

+path properties discovered by sepbuild.py which are used by qmake.

+

+Then it runs PySide's "shiboken" program to create C++ code that will act as a

+bridge between Python and the C++ libraries. This code goes into the 

+ScintillaEditPy/ScintillaEditPy directory. Several log files are produced which can

+help uncover problems in the bridge if it fails to build.

+

+The qmake program is run to produce make files from ScintillaEditPy.pro.

+

+The system make program is then run to build the library. The library is located in

+the scintilla/bin directory as ScintillaEditPy.so for Unix systems and 

+ScintillaEditPy.pyd for Windows.

+

+A demonstration program can be run:

+

+python testswp.py

+

+The individual steps in the script can be run manually if wanted although the

+shiboken program has complex arguments and differs between systems so run 

+sepbuild.py and copy the section starting with a line containing "generatorrunner"

+and continuing to "typesystem_ScintillaEdit.xml".

+

+On Windows, it is more difficult to set up an environment to debug ScintillaEditPy

+since all the libraries have to be debug or all have to be release. The easy path 

+is to always build for release with "nmake release".

+

+To remove generated code, run "python sepbuild.py --clean".

diff --git a/qt/ScintillaEditPy/ScintillaConstants.py.template b/qt/ScintillaEditPy/ScintillaConstants.py.template
new file mode 100644
index 000000000..31b82398d
--- /dev/null
+++ b/qt/ScintillaEditPy/ScintillaConstants.py.template
@@ -0,0 +1,6 @@
+# ScintillaConstants.py
+# Define all the symbolic constants from Scintilla.iface so Python code can use them
+# Copyright (c) 2011 Archaeopteryx Software, Inc. d/b/a Wingware
+
+# ++Autogenerated -- start of section automatically generated from Scintilla.iface */
+# --Autogenerated -- end of section automatically generated from Scintilla.iface */
diff --git a/qt/ScintillaEditPy/ScintillaEditPy.pro b/qt/ScintillaEditPy/ScintillaEditPy.pro
new file mode 100644
index 000000000..c578a314c
--- /dev/null
+++ b/qt/ScintillaEditPy/ScintillaEditPy.pro
@@ -0,0 +1,116 @@
+TEMPLATE = lib
+QT += core gui
+
+TARGET = ScintillaEditPy
+
+# Clear debug & release so that sepbuild.pri can set one or the other
+CONFIG -= debug release
+
+include(sepbuild.pri)
+
+VERSION = $$SCINTILLA_VERSION
+
+win32 {
+	DebugBuild {
+		TARGET_EXT = _d.pyd
+	}
+	else {
+		TARGET_EXT = .pyd
+	}
+}
+
+INCLUDEPATH += ../ScintillaEdit
+INCLUDEPATH += ../ScintillaEditBase
+INCLUDEPATH += ../../include ../../lexlib ../../src
+
+INCLUDEPATH += $$PY_INCLUDES
+
+INCLUDEPATH += $$SHIBOKEN_INCLUDES
+INCLUDEPATH += $$PYSIDE_INCLUDES
+INCLUDEPATH += $$PYSIDE_INCLUDES/QtCore
+INCLUDEPATH += $$PYSIDE_INCLUDES/QtGui
+
+unix:!mac {
+	LIBS += -ldl
+	LIBS += `pkg-config pyside --libs`
+}
+
+macx {
+	# Only build for x64 for now
+	# QMAKE_CFLAGS = -arch i386 -arch x86_64
+	# QMAKE_CXXFLAGS = -arch i386 -arch x86_64
+	# QMAKE_LFLAGS = -arch i386 -arch x86_64
+	LIBS += -L$$PY_LIBDIR -lpython$$PY_VERSION_SUFFIX
+	LIBS += -L$$PYSIDE_LIB
+	debug {
+		LIBS += -lshiboken-python$$PY_VERSION_SUFFIX-dbg
+		LIBS += -lpyside-python$$PY_VERSION_SUFFIX-dbg
+	}
+	else {
+		LIBS += -lshiboken-python$$PY_VERSION_SUFFIX
+		LIBS += -lpyside-python$$PY_VERSION_SUFFIX
+	}
+}
+
+win32 {
+	DebugBuild {
+		DEFINES += DEBUG
+		LIBS += -lQtCored4
+	}
+	else {
+		LIBS += -lQtCore
+	}
+	LIBS += -L$$PY_PREFIX/libs # Note python lib is pulled in via a #pragma
+	LIBS += -L$$PYSIDE_LIB
+	# PySide uses x.y suffix on Windows even though Python uses xy
+	DebugBuild {
+		LIBS += -lshiboken-python$${PY_VERSION}_d
+		LIBS += -lpyside-python$${PY_VERSION}_d
+	}
+	else {
+		LIBS += -lshiboken-python$${PY_VERSION}
+		LIBS += -lpyside-python$${PY_VERSION}
+	}
+}
+
+# Wrapper sources; notifyheader commented out due to shiboken bug
+SOURCES += \
+	ScintillaEditPy/scintillaeditpy_module_wrapper.cpp \
+	ScintillaEditPy/sci_notifyheader_wrapper.cpp \
+	ScintillaEditPy/scnotification_wrapper.cpp \
+	ScintillaEditPy/scintillaeditbase_wrapper.cpp \
+	ScintillaEditPy/scintillaedit_wrapper.cpp \
+	ScintillaEditPy/scintilladocument_wrapper.cpp
+
+# ScintillaEdit sources
+
+SOURCES += \
+    ../ScintillaEdit/ScintillaEdit.cpp \
+    ../ScintillaEdit/ScintillaDocument.cpp \
+    ../ScintillaEditBase/PlatQt.cpp \
+    ../ScintillaEditBase/ScintillaQt.cpp \
+    ../ScintillaEditBase/ScintillaEditBase.cpp \
+    ../../src/*.cxx \
+    ../../lexlib/*.cxx \
+    ../../lexers/*.cxx
+
+# HEADERS is used to find what needs to be run through moc
+HEADERS  += \
+    ../ScintillaEdit/ScintillaEdit.h \
+    ../ScintillaEdit/ScintillaDocument.h \
+    ../ScintillaEditBase/ScintillaQt.h \
+    ../ScintillaEditBase/ScintillaEditBase.h
+
+DEFINES += SCINTILLA_QT=1 MAKING_LIBRARY=1 SCI_LEXER=1 _CRT_SECURE_NO_DEPRECATE=1
+
+DESTDIR = ../../bin
+
+unix:!mac {
+	# Rename to not have 'lib' at start
+	QMAKE_POST_LINK += rm -rf ../../bin/ScintillaEditPy.so && ln -s libScintillaEditPy.so ../../bin/ScintillaEditPy.so
+}
+
+macx {
+	# Rename to .so and not have 'lib' at start
+	QMAKE_POST_LINK += rm -rf ../../bin/ScintillaEditPy.so && ln -s libScintillaEditPy.dylib ../../bin/ScintillaEditPy.so
+}
diff --git a/qt/ScintillaEditPy/global.h b/qt/ScintillaEditPy/global.h
new file mode 100644
index 000000000..8b4be843a
--- /dev/null
+++ b/qt/ScintillaEditPy/global.h
@@ -0,0 +1,4 @@
+#include "pyside_global.h"
+
+#include "ScintillaEditBase.h"
+#include "ScintillaEdit.h"
diff --git a/qt/ScintillaEditPy/sepbuild.py b/qt/ScintillaEditPy/sepbuild.py
new file mode 100644
index 000000000..b694f15b0
--- /dev/null
+++ b/qt/ScintillaEditPy/sepbuild.py
@@ -0,0 +1,312 @@
+import distutils.sysconfig
+import getopt
+import glob
+import os
+import platform
+import shutil
+import subprocess
+import stat
+import sys
+
+sys.path.append(os.path.join("..", "ScintillaEdit"))
+import WidgetGen
+
+# Decide up front which platform, treat anything other than Windows or OS X as Linux
+PLAT_WINDOWS = platform.system() == "Windows"
+PLAT_DARWIN = platform.system() == "Darwin"
+PLAT_LINUX = not (PLAT_DARWIN or PLAT_WINDOWS)
+
+def IsFileNewer(name1, name2):
+	""" Returns whether file with name1 is newer than file with name2.  Returns 1
+	if name2 doesn't exist. """
+
+	if not os.path.exists(name1):
+		return 0
+
+	if not os.path.exists(name2):
+		return 1
+
+	mod_time1 = os.stat(name1)[stat.ST_MTIME]
+	mod_time2 = os.stat(name2)[stat.ST_MTIME]
+	return (mod_time1 > mod_time2)
+
+def textFromRun(args):
+	(stdoutdata, stderrdata) = subprocess.Popen(args, shell=True, stdout=subprocess.PIPE).communicate()
+	return stdoutdata
+
+def runProgram(args, exitOnFailure):
+	print(" ".join(args))
+	retcode = subprocess.call(" ".join(args), shell=True, stderr=subprocess.STDOUT)
+	if retcode:
+		print("Failed in " + " ".join(args) + " return code = " + str(retcode))
+		if exitOnFailure:
+			sys.exit()
+
+def usage():
+	print("sepbuild.py [-h|--help][-c|--clean][-u|--underscore-names]")
+	print("")
+	print("Generate PySide wappers and build them.")
+	print("")
+	print("options:")
+	print("")
+	print("-c --clean remove all object and generated files")
+	print("-b --pyside-base  Location of the PySide+Qt4 sandbox to use")
+	print("-h --help  display this text")
+	print("-d --debug=yes|no  force debug build (or non-debug build)")
+	print("-u --underscore-names  use method_names consistent with GTK+ standards")
+
+modifyFunctionElement = """		<modify-function signature="%s">%s
+		</modify-function>
+"""
+
+injectCode = """
+			<inject-code class="target" position="beginning">%s
+			</inject-code>"""
+
+injectCheckN = """
+				if (!cppArg%d) {
+					PyErr_SetString(PyExc_ValueError, "Null string argument");
+					return 0;
+				}"""
+
+def methodSignature(name, v, options):
+	argTypes = ""
+	p1Type = WidgetGen.cppAlias(v["Param1Type"])
+	if p1Type:
+		argTypes = argTypes + p1Type
+	p2Type = WidgetGen.cppAlias(v["Param2Type"])
+	if p2Type and v["Param2Type"] != "stringresult":
+		if p1Type:
+			argTypes = argTypes + ", "
+		argTypes = argTypes + p2Type
+	methodName = WidgetGen.normalisedName(name, options, v["FeatureType"])
+	constDeclarator = " const" if v["FeatureType"] == "get" else ""
+	return methodName + "(" + argTypes + ")" + constDeclarator
+
+def printTypeSystemFile(f,out, options):
+	for name in f.order:
+		v = f.features[name]
+		if v["Category"] != "Deprecated":
+			feat = v["FeatureType"]
+			if feat in ["fun", "get", "set"]:
+				checks = ""
+				if v["Param1Type"] == "string":
+					checks = checks + (injectCheckN % 0)
+				if v["Param2Type"] == "string":
+					if v["Param1Type"] == "":	# Only arg 2 -> treat as first
+						checks = checks + (injectCheckN % 0)
+					else:
+						checks = checks + (injectCheckN % 1)
+				if checks:
+					inject = injectCode % checks
+					out.write(modifyFunctionElement % (methodSignature(name, v, options), inject))
+				#if v["Param1Type"] == "string":
+				#	out.write("<string-xml>" + name + "</string-xml>\n")
+
+def doubleBackSlashes(s):
+	# Quote backslashes so qmake does not produce warnings
+	return s.replace("\\", "\\\\")
+
+class SepBuilder:
+	def __init__(self):
+		# Discover configuration parameters
+		self.ScintillaEditIncludes = [".", "../ScintillaEdit", "../ScintillaEditBase", "../../include"]
+		if PLAT_WINDOWS:
+			self.MakeCommand = "nmake"
+			self.MakeTarget = "release"
+		else:
+			self.MakeCommand = "make"
+			self.MakeTarget = ""
+
+		if PLAT_DARWIN:
+			self.QMakeOptions = "-spec macx-g++"
+		else:
+			self.QMakeOptions = ""
+
+		# Default to debug build if running in a debug build interpreter
+		self.DebugBuild = hasattr(sys, 'getobjects')
+
+		# Python
+		self.PyVersion = "%d.%d" % sys.version_info[:2]
+		self.PyVersionSuffix = distutils.sysconfig.get_config_var("VERSION")
+		self.PyIncludes = distutils.sysconfig.get_python_inc()
+		self.PyPrefix = distutils.sysconfig.get_config_var("prefix")
+		self.PyLibDir = distutils.sysconfig.get_config_var(
+			("LIBDEST" if sys.platform == 'win32' else "LIBDIR"))
+
+		# Scintilla
+		with open("../../version.txt") as f:
+			version = f.read()
+			self.ScintillaVersion = version[0] + '.' + version[1] + '.' + version[2]
+
+		# Qt default location from qmake
+		self._SetQtIncludeBase(textFromRun("qmake -query QT_INSTALL_HEADERS").rstrip())
+
+		# PySide default location
+		# No standard for installing PySide development headers and libs on Windows so
+		# choose /usr to be like Linux
+		self._setPySideBase('\\usr' if PLAT_WINDOWS else '/usr')
+
+		self.ProInclude = "sepbuild.pri"
+
+		self.qtStyleInterface = True
+
+	def _setPySideBase(self, base):
+		
+		self.PySideBase = base
+		if PLAT_LINUX:
+			self.PySideTypeSystem = textFromRun("pkg-config --variable=typesystemdir pyside").rstrip()
+			self.PySideIncludeBase = textFromRun("pkg-config --variable=includedir pyside").rstrip()
+			self.ShibokenIncludeBase = textFromRun("pkg-config --variable=includedir shiboken").rstrip()
+		else:
+			self.PySideTypeSystem = os.path.join(self.PySideBase, "share", "PySide", "typesystems")
+			self.ShibokenIncludeBase = os.path.join(self.PySideBase, "include", "shiboken")
+			self.PySideIncludeBase = os.path.join(self.PySideBase, "include", "PySide")
+
+		self.PySideIncludes = [
+			self.ShibokenIncludeBase,
+			self.PySideIncludeBase,
+			os.path.join(self.PySideIncludeBase, "QtCore"),
+			os.path.join(self.PySideIncludeBase, "QtGui")]
+
+		self.PySideLibDir = os.path.join(self.PySideBase, "lib")
+		self.AllIncludes = os.pathsep.join(self.QtIncludes + self.ScintillaEditIncludes + self.PySideIncludes)
+
+		self.ShibokenGenerator = "shiboken"
+		# Is this still needed? It doesn't work with latest shiboken sources
+		#if PLAT_DARWIN:
+		#	# On OS X, can not automatically find Shiboken dylib so provide a full path
+		#	self.ShibokenGenerator = os.path.join(self.PySideLibDir, "generatorrunner", "shiboken")
+
+	def generateAPI(self, args):
+		os.chdir(os.path.join("..", "ScintillaEdit"))
+		if not self.qtStyleInterface:
+			args.insert(0, '--underscore-names')
+		WidgetGen.main(args)
+		f = WidgetGen.readInterface(False)
+		os.chdir(os.path.join("..", "ScintillaEditPy"))
+		options = {"qtStyle": self.qtStyleInterface}
+		WidgetGen.Generate("typesystem_ScintillaEdit.xml.template", "typesystem_ScintillaEdit.xml", printTypeSystemFile, f, options)
+
+	def runGenerator(self):
+		generatorrunner = "shiboken"
+		for name in ('shiboken', 'generatorrunner'):
+			if PLAT_WINDOWS:
+				name += '.exe'
+			name = os.path.join(self.PySideBase, "bin", name)
+			if os.path.exists(name):
+				generatorrunner = name
+				break
+				
+		args = [
+			generatorrunner,
+			"--generator-set=" + self.ShibokenGenerator,
+			"global.h ",
+			"--avoid-protected-hack",
+			"--enable-pyside-extensions",
+			"--include-paths=" + self.AllIncludes,
+			"--typesystem-paths=" + self.PySideTypeSystem,
+			"--output-directory=.",
+			"typesystem_ScintillaEdit.xml"]
+		print(" ".join(args))
+		retcode = subprocess.call(" ".join(args), shell=True, stderr=subprocess.STDOUT)
+		if retcode:
+			print("Failed in generatorrunner", retcode)
+			sys.exit()
+
+	def writeVariables(self):
+		# Write variables needed into file to be included from project so it does not have to discover much
+		with open(self.ProInclude, "w") as f:
+			f.write("SCINTILLA_VERSION=" + self.ScintillaVersion + "\n")
+			f.write("PY_VERSION=" + self.PyVersion + "\n")
+			f.write("PY_VERSION_SUFFIX=" + self.PyVersionSuffix + "\n")
+			f.write("PY_PREFIX=" + doubleBackSlashes(self.PyPrefix) + "\n")
+			f.write("PY_INCLUDES=" + doubleBackSlashes(self.PyIncludes) + "\n")
+			f.write("PY_LIBDIR=" + doubleBackSlashes(self.PyLibDir) + "\n")
+			f.write("PYSIDE_INCLUDES=" + doubleBackSlashes(self.PySideIncludeBase) + "\n")
+			f.write("PYSIDE_LIB=" + doubleBackSlashes(self.PySideLibDir) + "\n")
+			f.write("SHIBOKEN_INCLUDES=" + doubleBackSlashes(self.ShibokenIncludeBase) + "\n")
+			if self.DebugBuild:
+				f.write("CONFIG += debug\n")
+			else:
+				f.write("CONFIG += release\n")
+
+	def make(self):
+		runProgram(["qmake", self.QMakeOptions], exitOnFailure=True)
+		runProgram([self.MakeCommand, self.MakeTarget], exitOnFailure=True)
+
+	def cleanEverything(self):
+		self.generateAPI(["--clean"])
+		runProgram([self.MakeCommand, "distclean"], exitOnFailure=False)
+		try:
+			os.remove(self.ProInclude)
+		except OSError:
+			pass
+		for logFile in glob.glob("*.log"):
+			try:
+				os.remove(logFile)
+			except OSError:
+				pass
+		shutil.rmtree("debug", ignore_errors=True)
+		shutil.rmtree("release", ignore_errors=True)
+		shutil.rmtree("ScintillaEditPy", ignore_errors=True)
+
+	def buildEverything(self):
+		cleanGenerated = False
+		opts, args = getopt.getopt(sys.argv[1:], "hcdub",
+					["help", "clean", "debug=", 
+					"underscore-names", "pyside-base="])
+		for opt, arg in opts:
+			if opt in ("-h", "--help"):
+				usage()
+				sys.exit()
+			elif opt in ("-c", "--clean"):
+				cleanGenerated = True
+			elif opt in ("-d", "--debug"):
+				self.DebugBuild = (arg == '' or arg.lower() == 'yes')
+				if self.DebugBuild and sys.platform == 'win32':
+					self.MakeTarget = 'debug'
+			elif opt in ("-b", '--pyside-base'):
+				self._SetQtIncludeBase(os.path.join(os.path.normpath(arg), 'include'))
+				self._setPySideBase(os.path.normpath(arg))
+			elif opt in ("-u", "--underscore-names"):
+				self.qtStyleInterface = False
+
+		if cleanGenerated:
+			self.cleanEverything()
+		else:
+			self.writeVariables()
+			self.generateAPI([""])
+			self.runGenerator()
+			self.make()
+			self.copyScintillaConstants()
+			
+	def copyScintillaConstants(self):
+		
+		orig = 'ScintillaConstants.py'
+		dest = '../../bin/' + orig
+		if IsFileNewer(dest, orig):
+			return
+		
+		f = open(orig, 'r')
+		contents = f.read()
+		f.close()
+		
+		f = open(dest, 'w')
+		f.write(contents)
+		f.close()
+
+	def _SetQtIncludeBase(self, base):
+
+		self.QtIncludeBase = base
+		self.QtIncludes = [self.QtIncludeBase] + [os.path.join(self.QtIncludeBase, sub) for sub in ["QtCore", "QtGui"]]
+		# Set path so correct qmake is found
+		path = os.environ.get('PATH', '').split(os.pathsep)
+		qt_bin_dir = os.path.join(os.path.dirname(base), 'bin')
+		if qt_bin_dir not in path:
+			path.insert(0, qt_bin_dir)
+			os.environ['PATH'] = os.pathsep.join(path)
+
+if __name__ == "__main__":
+	sepBuild = SepBuilder()
+	sepBuild.buildEverything()
diff --git a/qt/ScintillaEditPy/testsepq.py b/qt/ScintillaEditPy/testsepq.py
new file mode 100644
index 000000000..a3849295d
--- /dev/null
+++ b/qt/ScintillaEditPy/testsepq.py
@@ -0,0 +1,157 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+import sys
+
+from PySide.QtCore import *
+from PySide.QtGui import *
+
+import ScintillaConstants as sci
+
+sys.path.append("../..")
+from bin import ScintillaEditPy
+
+txtInit =	"int main(int argc, char **argv) {\n" \
+		"    // Start up the gnome\n" \
+		"    gnome_init(\"stest\", \"1.0\", argc, argv);\n}\n";
+
+keywords = \
+		"and and_eq asm auto bitand bitor bool break " \
+		"case catch char class compl const const_cast continue " \
+		"default delete do double dynamic_cast else enum explicit export extern false float for " \
+		"friend goto if inline int long mutable namespace new not not_eq " \
+		"operator or or_eq private protected public " \
+		"register reinterpret_cast return short signed sizeof static static_cast struct switch " \
+		"template this throw true try typedef typeid typename union unsigned using " \
+		"virtual void volatile wchar_t while xor xor_eq";
+
+def uriDropped():
+	print "uriDropped"
+
+class Form(QDialog):
+
+	def __init__(self, parent=None):
+		super(Form, self).__init__(parent)
+		self.resize(460,300)
+		# Create widgets
+		self.edit = ScintillaEditPy.ScintillaEdit(self)
+		self.edit.uriDropped.connect(uriDropped)
+		self.edit.command.connect(self.receive_command)
+		self.edit.notify.connect(self.receive_notification)
+
+		self.edit.styleClearAll()
+		self.edit.setMarginWidthN(0, 35)
+		self.edit.setScrollWidth(200)
+		self.edit.setScrollWidthTracking(1)
+		self.edit.setLexer(sci.SCLEX_CPP)
+		self.edit.styleSetFore(sci.SCE_C_COMMENT, 0x008000)
+		self.edit.styleSetFore(sci.SCE_C_COMMENTLINE, 0x008000)
+		self.edit.styleSetFore(sci.SCE_C_COMMENTDOC, 0x008040)
+		self.edit.styleSetItalic(sci.SCE_C_COMMENTDOC, 1)
+		self.edit.styleSetFore(sci.SCE_C_NUMBER, 0x808000)
+		self.edit.styleSetFore(sci.SCE_C_WORD, 0x800000)
+		self.edit.styleSetBold(sci.SCE_C_WORD, True)
+		self.edit.styleSetFore(sci.SCE_C_STRING, 0x800080)
+		self.edit.styleSetFore(sci.SCE_C_PREPROCESSOR, 0x008080)
+		self.edit.styleSetBold(sci.SCE_C_OPERATOR, True)
+		self.edit.setMultipleSelection(1)
+		self.edit.setVirtualSpaceOptions(
+			sci.SCVS_RECTANGULARSELECTION | sci.SCVS_USERACCESSIBLE)
+		self.edit.setAdditionalSelectionTyping(1)
+
+		self.edit.styleSetFore(sci.STYLE_INDENTGUIDE, 0x808080)
+		self.edit.setIndentationGuides(sci.SC_IV_LOOKBOTH)
+
+		self.edit.setKeyWords(0, keywords)
+		self.edit.addText(len(txtInit), txtInit)
+		self.edit.setSel(1,10)
+		retriever = str(self.edit.getLine(1))
+		print(type(retriever), len(retriever))
+		print('[' + retriever + ']')
+		someText = str(self.edit.textRange(2,5))
+		print(len(someText), '[' + someText + ']')
+		someText = self.edit.getCurLine(100)
+		print(len(someText), '[' + someText + ']')
+		someText = self.edit.styleGetFont(1)
+		print(len(someText), '[' + someText + ']')
+		someText = self.edit.getSelText()
+		print(len(someText), '[' + someText + ']')
+		someText = self.edit.getTag(1)
+		print(len(someText), '[' + someText + ']')
+		someText = self.edit.autoCGetCurrentText()
+		print(len(someText), '[' + someText + ']')
+		someText = self.edit.annotationText(1)
+		print(len(someText), '[' + someText + ']')
+		someText = self.edit.annotationStyles(1)
+		print(len(someText), '[' + someText + ']')
+		someText = self.edit.describeKeyWordSets()
+		print(len(someText), '[' + someText + ']')
+		someText = self.edit.propertyNames()
+		print(len(someText), '[' + someText + ']')
+		self.edit.setProperty("fold", "1")
+		someText = self.edit.getProperty("fold")
+		print(len(someText), '[' + someText + ']')
+		someText = self.edit.getPropertyExpanded("fold")
+		print(len(someText), '[' + someText + ']')
+		someText = self.edit.lexerLanguage()
+		print(len(someText), '[' + someText + ']')
+		someText = self.edit.describeProperty("styling.within.preprocessor")
+		print(len(someText), '[' + someText + ']')
+
+		xx = self.edit.findText(0, "main", 0, 25)
+		print(type(xx), xx)
+		print("isBold", self.edit.styleBold(sci.SCE_C_WORD))
+
+		# Retrieve the document and write into it
+		doc = self.edit.get_doc()
+		doc.insert_string(40, "***")
+		stars = doc.get_char_range(40,3)
+		assert stars == "***"
+
+		# Create a new independent document and attach it to the editor
+		doc = ScintillaEditPy.ScintillaDocument()
+		doc.insert_string(0, "/***/\nif(a)\n")
+		self.edit.set_doc(doc)
+		self.edit.setLexer(sci.SCLEX_CPP)
+
+	def Call(self, message, wParam=0, lParam=0):
+		return self.edit.send(message, wParam, lParam)
+
+	def resizeEvent(self, e):
+		self.edit.resize(e.size().width(), e.size().height())
+
+	def receive_command(self, wParam, lParam):
+		# Show underline at start when focussed
+		notifyCode = wParam >> 16
+		if (notifyCode == sci.SCEN_SETFOCUS) or (notifyCode == sci.SCEN_KILLFOCUS):
+			self.edit.setIndicatorCurrent(sci.INDIC_CONTAINER);
+			self.edit.indicatorClearRange(0, self.edit.length())
+			if notifyCode == sci.SCEN_SETFOCUS:
+				self.edit.indicatorFillRange(0, 2);
+
+	def receive_notification(self, scn):
+		if scn.nmhdr.code == sci.SCN_CHARADDED:
+			print "Char %02X" % scn.ch
+		elif scn.nmhdr.code == sci.SCN_SAVEPOINTREACHED:
+			print "Saved"
+		elif scn.nmhdr.code == sci.SCN_SAVEPOINTLEFT:
+			print "Unsaved"
+		elif scn.nmhdr.code == sci.SCN_MODIFIED:
+			print "Modified"
+		elif scn.nmhdr.code == sci.SCN_UPDATEUI:
+			print "Update UI"
+		elif scn.nmhdr.code == sci.SCN_PAINTED:
+			#print "Painted"
+			pass
+		else:
+			print "Notification", scn.nmhdr.code
+			pass
+
+if __name__ == '__main__':
+    # Create the Qt Application
+    app = QApplication(sys.argv)
+    # Create and show the form
+    form = Form()
+    form.show()
+    # Run the main Qt loop
+    sys.exit(app.exec_())
diff --git a/qt/ScintillaEditPy/typesystem_ScintillaEdit.xml.template b/qt/ScintillaEditPy/typesystem_ScintillaEdit.xml.template
new file mode 100644
index 000000000..4c2c897a2
--- /dev/null
+++ b/qt/ScintillaEditPy/typesystem_ScintillaEdit.xml.template
@@ -0,0 +1,16 @@
+<?xml version="1.0"?>
+<typesystem package="ScintillaEditPy">
+	<load-typesystem name="typesystem_core.xml" generate="no" />
+	<load-typesystem name="typesystem_gui_common.xml" generate="no"/>
+	<primitive-type name="sptr_t"/>
+	<primitive-type name="uptr_t"/>
+	<value-type name="Sci_NotifyHeader" />
+	<rejection class="Sci_NotifyHeader" field-name="hwndFrom" />
+	<value-type name="SCNotification" />
+	<object-type name="ScintillaEditBase" />
+	<object-type name="ScintillaEdit">
+	<!-- ++Autogenerated start of section automatically generated from Scintilla.iface -->
+	<!-- ~~Autogenerated end of section automatically generated from Scintilla.iface -->
+	</object-type>
+	<object-type name="ScintillaDocument" />
+</typesystem>