--- a/demos/browser/TODO.txt	Wed May 20 22:44:31 2009 +0000
+++ b/demos/browser/TODO.txt	Fri May 22 10:59:00 2009 +0000
@@ -7,7 +7,7 @@
 - some '::' and most '->' have been replaced by '.'
 
 Todo:
-- *.ui files need to converted to source files and translated to D
 - imports need to be corrected
 - module declarations are probably missing
+- what about Q_PROPERTY/Q_UNUSED?
 - everything else...

--- a/demos/browser/autosaver.d	Wed May 20 22:44:31 2009 +0000
+++ b/demos/browser/autosaver.d	Fri May 22 10:59:00 2009 +0000
@@ -40,75 +40,82 @@
 ****************************************************************************/
 module autosaver;
 
-import QtCore.QObject;
-import QtCore.QBasicTimer;
-import QtCore.QTime;
 
-import QtCore.QDir;
-import QtCore.QCoreApplication;
-import QtCore.QMetaObject;
+import qt.core.QObject;
+import qt.core.QBasicTimer;
+import qt.core.QTime;
+import qt.core.QDir;
+import qt.core.QCoreApplication;
+import qt.core.QMetaObject;
+
 import QtDebug;
 
+
 const uint AUTOSAVE_IN  = 1000 * 3  // seconds
 const uint MAXWAIT = 1000 * 15 // seconds
 
+
 /*
-    This class will call the save() slot on the parent object when the parent changes.
-    It will wait several seconds after changed() to combining multiple changes and
-    prevent continuous writing to disk.
-  */
+This class will call the save() slot on the parent object when the parent changes.
+It will wait several seconds after changed() to combining multiple changes and
+prevent continuous writing to disk.
+*/
+
 class AutoSaver : public QObject {
 
-Q_OBJECT
-
 public:
-    this(QObject *parent)
-{
-	super(parent);
-    Q_ASSERT(parent);
-}
-    ~this();
-{
-    if (m_timer.isActive())
-        qWarning() << "AutoSaver: still active when destroyed, changes not saved.";
-}
-    void saveIfNeccessary()
-{
-    if (!m_timer.isActive())
-        return;
-    m_timer.stop();
-    m_firstChange = QTime();
-    if (!QMetaObject::invokeMethod(parent(), "save", Qt::DirectConnection)) {
-        qWarning() << "AutoSaver: error invoking slot save() on parent";
-    }
+
+	this(QObject parent)
+	{
+		super(parent);
+		assert(parent);
+	}
+	
+	~this();
+	{
+		if (m_timer.isActive())
+			qWarning() << "AutoSaver: still active when destroyed, changes not saved.";
+	}
+	
+	void saveIfNeccessary()
+	{
+		if (!m_timer.isActive())
+			return;
+		m_timer.stop();
+		m_firstChange = QTime();
+		if (!QMetaObject.invokeMethod(parent(), "save", Qt.DirectConnection)) {
+			qWarning() << "AutoSaver: error invoking slot save() on parent";
+		}
+	}
+
+public:
+
+	void changeOccurred();
+	{
+		if (m_firstChange.isNull())
+			m_firstChange.start();
+
+		if (m_firstChange.elapsed() > MAXWAIT) {
+			saveIfNeccessary();
+		} else {
+			m_timer.start(AUTOSAVE_IN, this);
+		}
+	}
+
+protected:
+
+	void timerEvent(QTimerEvent event)
+	{
+		if (event.timerId() == m_timer.timerId()) {
+			saveIfNeccessary();
+		} else {
+			QObject.timerEvent(event);
+		}
+	}
+
+private:
+
+	QBasicTimer m_timer;
+	QTime m_firstChange;
 }
 
-public slots:
-    void changeOccurred();
-{
-    if (m_firstChange.isNull())
-        m_firstChange.start();
-
-    if (m_firstChange.elapsed() > MAXWAIT) {
-        saveIfNeccessary();
-    } else {
-        m_timer.start(AUTOSAVE_IN, this);
-    }
-}
-
-protected:
-    void timerEvent(QTimerEvent *event)
-{
-    if (event.timerId() == m_timer.timerId()) {
-        saveIfNeccessary();
-    } else {
-        QObject::timerEvent(event);
-    }
-}
-
-
-private:
-    QBasicTimer m_timer;
-    QTime m_firstChange;
-}
-

--- a/demos/browser/bookmarks.d	Wed May 20 22:44:31 2009 +0000
+++ b/demos/browser/bookmarks.d	Fri May 22 10:59:00 2009 +0000
@@ -75,744 +75,743 @@
 
 
 /*!
-    Bookmark manager, owner of the bookmarks, loads, saves and basic tasks
-  */
-
+Bookmark manager, owner of the bookmarks, loads, saves and basic tasks
+*/
 class BookmarksManager : public QObject
 {
-	
-   mixin Signal!("entryAdded", BookmarkNode item);
-     mixin Signal!("entryRemoved", BookmarkNode parent, int row, BookmarkNode item);
-     mixin Signal!("entryChanged", BookmarkNode item);
+	mixin Signal!("entryAdded", BookmarkNode item);
+	mixin Signal!("entryRemoved", BookmarkNode parent, int row, BookmarkNode item);
+	mixin Signal!("entryChanged", BookmarkNode item);
 
 public:
-    BookmarksManager(QObject parent = null)
-{
-	super(parent);
-	m_loaded = false;
-	m_saveTimer = new AutoSaver(this);
-	m_bookmarkRootNode = null;
-	m_bookmarkModel = null;
-    this.entryAdded.connect(&m_saveTimer.changeOccurred);
-    this.entryRemoved.connect(&m_saveTimer.changeOccurred);
-    this.entryChanged.connect(&m_saveTimer.changeOccurred);
-}
+
+	this(QObject parent = null)
+	{
+		super(parent);
+		m_loaded = false;
+		m_saveTimer = new AutoSaver(this);
+		m_bookmarkRootNode = null;
+		m_bookmarkModel = null;
+		this.entryAdded.connect(&m_saveTimer.changeOccurred);
+		this.entryRemoved.connect(&m_saveTimer.changeOccurred);
+		this.entryChanged.connect(&m_saveTimer.changeOccurred);
+	}
 
+	~this()
+	{
+		m_saveTimer.saveIfNeccessary();
+	}
 
-    ~this()
-{
-    m_saveTimer.saveIfNeccessary();
-}
+	void addBookmark(BookmarkNode parent, BookmarkNode node, int row = -1)
+	{
+		if (!m_loaded)
+			return;
+		assert(parent);
+		InsertBookmarksCommand command = new InsertBookmarksCommand(this, parent, node, row);
+		m_commands.push(command);
+	}
 
 
-    void addBookmark(BookmarkNode parent, BookmarkNode node, int row = -1)
-{
-    if (!m_loaded)
-        return;
-    assert(parent);
-    InsertBookmarksCommand command = new InsertBookmarksCommand(this, parent, node, row);
-    m_commands.push(command);
-}
+	void removeBookmark(BookmarkNode node);
+	{
+		if (!m_loaded)
+			return;
+
+		assert(node);
+		BookmarkNode parent = node.parent();
+		int row = parent.children().indexOf(node);
+		RemoveBookmarksCommand command = new RemoveBookmarksCommand(this, parent, row);
+		m_commands.push(command);
+	}
+
+	void setTitle(BookmarkNode node, QString newTitle);
+	{
+		if (!m_loaded)
+			return;
+
+		assert(node);
+		ChangeBookmarkCommand command = new ChangeBookmarkCommand(this, node, newTitle, true);
+		m_commands.push(command);
+	}
 
 
-    void removeBookmark(BookmarkNode node);
-{
-    if (!m_loaded)
-        return;
-
-    assert(node);
-    BookmarkNode parent = node.parent();
-    int row = parent.children().indexOf(node);
-    RemoveBookmarksCommand command = new RemoveBookmarksCommand(this, parent, row);
-    m_commands.push(command);
-}
+	void setUrl(BookmarkNode node, QString newUrl);
+	{
+		if (!m_loaded)
+			return;
 
-    void setTitle(BookmarkNode node, QString newTitle);
-{
-    if (!m_loaded)
-        return;
-
-    assert(node);
-    ChangeBookmarkCommand command = new ChangeBookmarkCommand(this, node, newTitle, true);
-    m_commands.push(command);
-}
-
-
-    void setUrl(BookmarkNode node, QString newUrl);
-{
-    if (!m_loaded)
-        return;
-
-    assert(node);
-    ChangeBookmarkCommand command = new ChangeBookmarkCommand(this, node, newUrl, false);
-    m_commands.push(command);
-}
+		assert(node);
+		ChangeBookmarkCommand command = new ChangeBookmarkCommand(this, node, newUrl, false);
+		m_commands.push(command);
+	}
 
 
-void changeExpanded()
-{
-    m_saveTimer.changeOccurred();
-}
+	void changeExpanded()
+	{
+		m_saveTimer.changeOccurred();
+	}
 
-    BookmarkNode bookmarks();
-{
-    if (!m_loaded)
-        load();
-    return m_bookmarkRootNode;
-}
+	BookmarkNode bookmarks();
+	{
+		if (!m_loaded)
+			load();
+		return m_bookmarkRootNode;
+	}
 
-    BookmarkNode menu();
-{
-    if (!m_loaded)
-        load();
+	BookmarkNode menu();
+	{
+		if (!m_loaded)
+			load();
 
-    for (int i = m_bookmarkRootNode.children().count() - 1; i >= 0; --i) {
-        BookmarkNode node = m_bookmarkRootNode.children().at(i);
-        if (node.title == tr(BOOKMARKMENU))
-            return node;
-    }
-    assert(false);
-    return 0;
-}
+		for (int i = m_bookmarkRootNode.children().count() - 1; i >= 0; --i) {
+			BookmarkNode node = m_bookmarkRootNode.children().at(i);
+			if (node.title == tr(BOOKMARKMENU))
+				return node;
+		}
+		assert(false);
+		return 0;
+	}
 
-    BookmarkNode toolbar();
-{
-    if (!m_loaded)
-        load();
+	BookmarkNode toolbar();
+	{
+		if (!m_loaded)
+			load();
 
-    for (int i = m_bookmarkRootNode.children().count() - 1; i >= 0; --i) {
-        BookmarkNode node = m_bookmarkRootNode.children().at(i);
-        if (node.title == tr(BOOKMARKBAR))
-            return node;
-    }
-    assert(false);
-    return 0;
-}
+		for (int i = m_bookmarkRootNode.children().count() - 1; i >= 0; --i) {
+			BookmarkNode node = m_bookmarkRootNode.children().at(i);
+			if (node.title == tr(BOOKMARKBAR))
+				return node;
+		}
+		assert(false);
+		return 0;
+	}
 
-BookmarksModel bookmarksModel()
-{
-    if (!m_bookmarkModel)
-        m_bookmarkModel = new BookmarksModel(this, this);
-    return m_bookmarkModel;
-}
+	BookmarksModel bookmarksModel()
+	{
+		if (!m_bookmarkModel)
+			m_bookmarkModel = new BookmarksModel(this, this);
+		return m_bookmarkModel;
+	}
 
-    QUndoStack undoRedoStack() { return m_commands; };
+	QUndoStack undoRedoStack() { return m_commands; };
 
-public slots:
-    void importBookmarks()
-{
-    QString fileName = QFileDialog.getOpenFileName(0, tr("Open File"),
-                                                     QString(),
-                                                     tr("XBEL (*.xbel *.xml)"));
-    if (fileName.isEmpty())
-        return;
+public:
+
+	void importBookmarks()
+	{
+		QString fileName = QFileDialog.getOpenFileName(0, tr("Open File"), QString(), tr("XBEL (*.xbel *.xml)"));
+		if (fileName.isEmpty())
+			return;
 
-    XbelReader reader;
-    BookmarkNode importRootNode = reader.read(fileName);
-    if (reader.error() != QXmlStreamReader.NoError) {
-        QMessageBox.warning(0, QLatin1String("Loading Bookmark"),
-            tr("Error when loading bookmarks on line %1, column %2:\n"
-               "%3").arg(reader.lineNumber()).arg(reader.columnNumber()).arg(reader.errorString()));
-    }
+		XbelReader reader;
+		BookmarkNode importRootNode = reader.read(fileName);
+		if (reader.error() != QXmlStreamReader.NoError) {
+			QMessageBox.warning(0, QLatin1String("Loading Bookmark"),
+				tr("Error when loading bookmarks on line %1, column %2:\n"
+				"%3").arg(reader.lineNumber()).arg(reader.columnNumber()).arg(reader.errorString()));
+		}
 
-    importRootNode.setType(BookmarkNode.Folder);
-    importRootNode.title = (tr("Imported %1").arg(QDate.currentDate().toString(Qt.SystemLocaleShortDate)));
-    addBookmark(menu(), importRootNode);
-}
+		importRootNode.setType(BookmarkNode.Folder);
+		importRootNode.title = (tr("Imported %1").arg(QDate.currentDate().toString(Qt.SystemLocaleShortDate)));
+		addBookmark(menu(), importRootNode);
+	}
 
 
-    void exportBookmarks()
-{
-    QString fileName = QFileDialog.getSaveFileName(0, tr("Save File"),
-                                tr("%1 Bookmarks.xbel").arg(QCoreApplication.applicationName()),
-                                tr("XBEL (*.xbel *.xml)"));
-    if (fileName.isEmpty())
-        return;
+	void exportBookmarks()
+	{
+		QString fileName = QFileDialog.getSaveFileName(0, tr("Save File"),
+				tr("%1 Bookmarks.xbel").arg(QCoreApplication.applicationName()),
+				tr("XBEL (*.xbel *.xml)"));
+		if (fileName.isEmpty())
+			return;
 
-    XbelWriter writer;
-    if (!writer.write(fileName, m_bookmarkRootNode))
-        QMessageBox.critical(0, tr("Export error"), tr("error saving bookmarks"));
-}
+		XbelWriter writer;
+		if (!writer.write(fileName, m_bookmarkRootNode))
+			QMessageBox.critical(0, tr("Export error"), tr("error saving bookmarks"));
+	}
 
-private slots:
-    void save()
-{
-    if (!m_loaded)
-        return;
+private:
+
+	void save()
+	{
+		if (!m_loaded)
+			return;
 
-    XbelWriter writer;
-    QString dir = QDesktopServices.storageLocation(QDesktopServices.DataLocation);
-    QString bookmarkFile = dir + QLatin1String("/bookmarks.xbel");
-    if (!writer.write(bookmarkFile, m_bookmarkRootNode))
-        qWarning() << "BookmarkManager: error saving to" << bookmarkFile;
-}
+		XbelWriter writer;
+		QString dir = QDesktopServices.storageLocation(QDesktopServices.DataLocation);
+		QString bookmarkFile = dir + QLatin1String("/bookmarks.xbel");
+		if (!writer.write(bookmarkFile, m_bookmarkRootNode))
+			qWarning() << "BookmarkManager: error saving to" << bookmarkFile;
+	}
 
 private:
-    void load()
-{
-    if (m_loaded)
-        return;
-    m_loaded = true;
+	
+	void load()
+	{
+		if (m_loaded)
+			return;
+		m_loaded = true;
 
-    QString dir = QDesktopServices.storageLocation(QDesktopServices.DataLocation);
-    QString bookmarkFile = dir + QLatin1String("/bookmarks.xbel");
-    if (!QFile.exists(bookmarkFile))
-        bookmarkFile = QLatin1String(":defaultbookmarks.xbel");
+		QString dir = QDesktopServices.storageLocation(QDesktopServices.DataLocation);
+		QString bookmarkFile = dir + QLatin1String("/bookmarks.xbel");
+		if (!QFile.exists(bookmarkFile))
+			bookmarkFile = QLatin1String(":defaultbookmarks.xbel");
 
-    XbelReader reader;
-    m_bookmarkRootNode = reader.read(bookmarkFile);
-    if (reader.error() != QXmlStreamReader.NoError) {
-        QMessageBox.warning(0, QLatin1String("Loading Bookmark"),
-            tr("Error when loading bookmarks on line %1, column %2:\n"
-               "%3").arg(reader.lineNumber()).arg(reader.columnNumber()).arg(reader.errorString()));
-    }
+		XbelReader reader;
+		m_bookmarkRootNode = reader.read(bookmarkFile);
+		if (reader.error() != QXmlStreamReader.NoError) {
+			QMessageBox.warning(0, QLatin1String("Loading Bookmark"),
+			tr("Error when loading bookmarks on line %1, column %2:\n"
+			"%3").arg(reader.lineNumber()).arg(reader.columnNumber()).arg(reader.errorString()));
+		}
 
-    BookmarkNode toolbar = null;
-    BookmarkNode menu = null;
-    QList<BookmarkNode> others;
-    for (int i = m_bookmarkRootNode.children().count() - 1; i >= 0; --i) {
-        BookmarkNode node = m_bookmarkRootNode.children().at(i);
-        if (node.type() == BookmarkNode.Folder) {
-            // Automatically convert
-            if (node.title == tr("Toolbar Bookmarks") && !toolbar) {
-                node.title = tr(BOOKMARKBAR);
-            }
-            if (node.title == tr(BOOKMARKBAR) && !toolbar) {
-                toolbar = node;
-            }
+		BookmarkNode toolbar = null;
+		BookmarkNode menu = null;
+		QList<BookmarkNode> others;
+		for (int i = m_bookmarkRootNode.children().count() - 1; i >= 0; --i) {
+			BookmarkNode node = m_bookmarkRootNode.children().at(i);
+			if (node.type() == BookmarkNode.Folder) {
+				// Automatically convert
+				if (node.title == tr("Toolbar Bookmarks") && !toolbar) {
+					node.title = tr(BOOKMARKBAR);
+				}
+				if (node.title == tr(BOOKMARKBAR) && !toolbar) {
+					toolbar = node;
+				}
 
-            // Automatically convert
-            if (node.title == tr("Menu") && !menu) {
-                node.title = tr(BOOKMARKMENU);
-            }
-            if (node.title == tr(BOOKMARKMENU) && !menu) {
-                menu = node;
-            }
-        } else {
-            others.append(node);
-        }
-        m_bookmarkRootNode.remove(node);
-    }
-    assert(m_bookmarkRootNode.children().count() == 0);
-    if (!toolbar) {
-        toolbar = new BookmarkNode(BookmarkNode.Folder, m_bookmarkRootNode);
-        toolbar.title = tr(BOOKMARKBAR);
-    } else {
-        m_bookmarkRootNode.add(toolbar);
-    }
+				// Automatically convert
+				if (node.title == tr("Menu") && !menu) {
+					node.title = tr(BOOKMARKMENU);
+				}
+				if (node.title == tr(BOOKMARKMENU) && !menu) {
+					menu = node;
+				}
+			} else {
+				others.append(node);
+			}
+			m_bookmarkRootNode.remove(node);
+		}
+		assert(m_bookmarkRootNode.children().count() == 0);
+		if (!toolbar) {
+			toolbar = new BookmarkNode(BookmarkNode.Folder, m_bookmarkRootNode);
+			toolbar.title = tr(BOOKMARKBAR);
+		} else {
+			m_bookmarkRootNode.add(toolbar);
+		}
 
-    if (!menu) {
-        menu = new BookmarkNode(BookmarkNode.Folder, m_bookmarkRootNode);
-        menu.title = tr(BOOKMARKMENU);
-    } else {
-        m_bookmarkRootNode.add(menu);
-    }
+		if (!menu) {
+			menu = new BookmarkNode(BookmarkNode.Folder, m_bookmarkRootNode);
+			menu.title = tr(BOOKMARKMENU);
+		} else {
+			m_bookmarkRootNode.add(menu);
+		}
 
-    for (int i = 0; i < others.count(); ++i)
-        menu.add(others.at(i));
-}
-
+		for (int i = 0; i < others.count(); ++i)
+			menu.add(others.at(i));
+	}
 
-    bool m_loaded;
-    AutoSaver m_saveTimer;
-    BookmarkNode m_bookmarkRootNode;
-    BookmarksModel m_bookmarkModel;
-    QUndoStack m_commands;
-
-    friend class RemoveBookmarksCommand;
-    friend class ChangeBookmarkCommand;
+	bool m_loaded;
+	AutoSaver m_saveTimer;
+	BookmarkNode m_bookmarkRootNode;
+	BookmarksModel m_bookmarkModel;
+	QUndoStack m_commands;
 }
 
 class RemoveBookmarksCommand : public QUndoCommand
 {
+public:
 
-public:
-    this(BookmarksManager m_bookmarkManagaer, BookmarkNode parent, int row)
-{
-	super(BookmarksManager.tr("Remove Bookmark"))
-	m_row = row;
-	m_bookmarkManagaer = m_bookmarkManagaer;
-	m_node = parent.children().value(row);
-	m_parent = parent;
-	m_done = false;
-}
+	this(BookmarksManager m_bookmarkManagaer, BookmarkNode parent, int row)
+	{
+		super(BookmarksManager.tr("Remove Bookmark"))
+		m_row = row;
+		m_bookmarkManagaer = m_bookmarkManagaer;
+		m_node = parent.children().value(row);
+		m_parent = parent;
+		m_done = false;
+	}
 
-~this()
-{
-    if (m_done && !m_node.parent()) {
-        delete m_node;
-    }
-}
+	~this()
+	{
+		if (m_done && !m_node.parent()) {
+			delete m_node;
+		}
+	}
 
-void undo()
-{
-    m_parent.add(m_node, m_row);
-    emit m_bookmarkManagaer.entryAdded(m_node);
-    m_done = false;
-}
+	void undo()
+	{
+		m_parent.add(m_node, m_row);
+		emit m_bookmarkManagaer.entryAdded(m_node);
+		m_done = false;
+	}
 
-void redo()
-{
-    m_parent.remove(m_node);
-    emit m_bookmarkManagaer.entryRemoved(m_parent, m_row, m_node);
-    m_done = true;
-}
+	void redo()
+	{
+		m_parent.remove(m_node);
+		emit m_bookmarkManagaer.entryRemoved(m_parent, m_row, m_node);
+		m_done = true;
+	}
 
 protected:
-    int m_row;
-    BookmarksManager m_bookmarkManagaer;
-    BookmarkNode m_node;
-    BookmarkNode m_parent;
-    bool m_done;
-};
+
+	int m_row;
+	BookmarksManager m_bookmarkManagaer;
+	BookmarkNode m_node;
+	BookmarkNode m_parent;
+	bool m_done;
+}
 
 class InsertBookmarksCommand : public RemoveBookmarksCommand
 {
+public:
+	this(BookmarksManager m_bookmarkManagaer, BookmarkNode parent, BookmarkNode node, int row)
+	{
+		super(m_bookmarkManagaer, parent, row);
 
-public:
-this(BookmarksManager m_bookmarkManagaer,
-                BookmarkNode parent, BookmarkNode node, int row)
-{
-	super(m_bookmarkManagaer, parent, row);
-	
-    setText(BookmarksManager.tr("Insert Bookmark"));
-    m_node = node;
-}
+		setText(BookmarksManager.tr("Insert Bookmark"));
+		m_node = node;
+	}
 
-    void undo() { RemoveBookmarksCommand.redo(); }
-    void redo() { RemoveBookmarksCommand.undo(); }
+	void undo() { RemoveBookmarksCommand.redo(); }
+	void redo() { RemoveBookmarksCommand.undo(); }
 }
 
 class ChangeBookmarkCommand : public QUndoCommand
 {
+public:
 
-public:
-    this(BookmarksManager m_bookmarkManagaer,
-        BookmarkNode node, QString newValue, bool title)
-{
-	super();
-	m_bookmarkManagaer = m_bookmarkManagaer;
-    m_title = title;
-    m_newValue = newValue;
-    m_node = node;
-    if (m_title) {
-        m_oldValue = m_node.title;
-        setText(BookmarksManager.tr("Name Change"));
-    } else {
-        m_oldValue = m_node.url;
-        setText(BookmarksManager.tr("Address Change"));
-    }
-}
+	this(BookmarksManager m_bookmarkManagaer, BookmarkNode node, QString newValue, bool title)
+	{
+		super();
+		m_bookmarkManagaer = m_bookmarkManagaer;
+		m_title = title;
+		m_newValue = newValue;
+		m_node = node;
+		if (m_title) {
+			m_oldValue = m_node.title;
+			setText(BookmarksManager.tr("Name Change"));
+		} else {
+			m_oldValue = m_node.url;
+			setText(BookmarksManager.tr("Address Change"));
+		}
+	}
 
-void undo()
-{
-    if (m_title)
-        m_node.title = m_oldValue;
-    else
-        m_node.url = m_oldValue;
-    emit m_bookmarkManagaer.entryChanged(m_node);
-}
+	void undo()
+	{
+		if (m_title)
+			m_node.title = m_oldValue;
+		else
+			m_node.url = m_oldValue;
+		emit m_bookmarkManagaer.entryChanged(m_node);
+	}
 
-void redo()
-{
-    if (m_title)
-        m_node.title = m_newValue;
-    else
-        m_node.url = m_newValue;
-    emit m_bookmarkManagaer.entryChanged(m_node);
-}
+	void redo()
+	{
+		if (m_title)
+			m_node.title = m_newValue;
+		else
+			m_node.url = m_newValue;
+		emit m_bookmarkManagaer.entryChanged(m_node);
+	}
 
 private:
-    BookmarksManager m_bookmarkManagaer;
-    bool m_title;
-    QString m_oldValue;
-    QString m_newValue;
-    BookmarkNode m_node;
+	
+	BookmarksManager m_bookmarkManagaer;
+	bool m_title;
+	QString m_oldValue;
+	QString m_newValue;
+	BookmarkNode m_node;
 }
 
 /*!
-    BookmarksModel is a QAbstractItemModel wrapper around the BookmarkManager
-  */
+BookmarksModel is a QAbstractItemModel wrapper around the BookmarkManager
+*/
 import qt.gui.QIcon;
 
 class BookmarksModel : public QAbstractItemModel
 {
+public:
 
-public:
-    void entryAdded(BookmarkNode item)
-{
-    assert(item && item.parent());
-    int row = item.parent().children().indexOf(item);
-    BookmarkNode parent = item.parent();
-    // item was already added so remove beore beginInsertRows is called
-    parent.remove(item);
-    beginInsertRows(index(parent), row, row);
-    parent.add(item, row);
-    endInsertRows();
-}
+	void entryAdded(BookmarkNode item)
+	{
+		assert(item && item.parent());
+		int row = item.parent().children().indexOf(item);
+		BookmarkNode parent = item.parent();
+		// item was already added so remove beore beginInsertRows is called
+		parent.remove(item);
+		beginInsertRows(index(parent), row, row);
+		parent.add(item, row);
+		endInsertRows();
+	}
 
 
-    void entryRemoved(BookmarkNode parent, int row, BookmarkNode item);
-{
-    // item was already removed, re-add so beginRemoveRows works
-    parent.add(item, row);
-    beginRemoveRows(index(parent), row, row);
-    parent.remove(item);
-    endRemoveRows();
-}
+	void entryRemoved(BookmarkNode parent, int row, BookmarkNode item);
+	{
+		// item was already removed, re-add so beginRemoveRows works
+		parent.add(item, row);
+		beginRemoveRows(index(parent), row, row);
+		parent.remove(item);
+		endRemoveRows();
+	}
 
-    void entryChanged(BookmarkNode item);
-{
-    QModelIndex idx = index(item);
-    emit dataChanged(idx, idx);
-}
+	void entryChanged(BookmarkNode item);
+	{
+		QModelIndex idx = index(item);
+		emit dataChanged(idx, idx);
+	}
+
 public:
-    enum Roles {
-        TypeRole = Qt.UserRole + 1,
-        UrlRole = Qt.UserRole + 2,
-        UrlStringRole = Qt.UserRole + 3,
-        SeparatorRole = Qt.UserRole + 4
-    }
+
+	enum Roles {
+		TypeRole = Qt.UserRole + 1,
+		UrlRole = Qt.UserRole + 2,
+		UrlStringRole = Qt.UserRole + 3,
+		SeparatorRole = Qt.UserRole + 4
+	}
 
-    BookmarksModel(BookmarksManager bookmarkManager, QObject parent = null)
-{
-	super(parent)
-    m_endMacro = false;
-    m_bookmarksManager = bookmarkManager;
-    bookmarkManager.entryAdded.connect(&this.entryAdded);
-	bookmarkManager.entryRemoved.connect(&this.entryRemoved);
-	bookmarkManager.entryChanged.connect(&this.entryChanged);
-}
+	BookmarksModel(BookmarksManager bookmarkManager, QObject parent = null)
+	{
+		super(parent)
+		m_endMacro = false;
+		m_bookmarksManager = bookmarkManager;
+		bookmarkManager.entryAdded.connect(&this.entryAdded);
+		bookmarkManager.entryRemoved.connect(&this.entryRemoved);
+		bookmarkManager.entryChanged.connect(&this.entryChanged);
+	}
     
     
-    inline BookmarksManager bookmarksManager() { return m_bookmarksManager; }
+	BookmarksManager bookmarksManager() { return m_bookmarksManager; }
 
-    QVariant headerData(int section, Qt.Orientation orientation, int role = Qt.DisplayRole);
-{
-    if (orientation == Qt.Horizontal && role == Qt.DisplayRole) {
-        switch (section) {
-            case 0: return tr("Title");
-            case 1: return tr("Address");
-        }
-    }
-    return QAbstractItemModel.headerData(section, orientation, role);
-}
+	QVariant headerData(int section, Qt.Orientation orientation, int role = Qt.DisplayRole);
+	{
+		if (orientation == Qt.Horizontal && role == Qt.DisplayRole) {
+			switch (section) {
+				case 0: return tr("Title");
+				case 1: return tr("Address");
+			}
+		}
+		return QAbstractItemModel.headerData(section, orientation, role);
+	}
     
     
-    QVariant data(QModelIndex index, int role = Qt.DisplayRole)
-{
-    if (!index.isValid() || index.model() != this)
-        return QVariant();
+	QVariant data(QModelIndex index, int role = Qt.DisplayRole)
+	{
+		if (!index.isValid() || index.model() != this)
+		return QVariant();
 
-    BookmarkNode bookmarkNode = node(index);
-    switch (role) {
-    case Qt.EditRole:
-    case Qt.DisplayRole:
-        if (bookmarkNode.type() == BookmarkNode.Separator) {
-            switch (index.column()) {
-            case 0: return QString(50, 0xB7);
-            case 1: return QString();
-            }
-        }
+		BookmarkNode bookmarkNode = node(index);
+		switch (role) {
+			case Qt.EditRole:
+			case Qt.DisplayRole:
+				if (bookmarkNode.type() == BookmarkNode.Separator) {
+					switch (index.column()) {
+						case 0: return QString(50, 0xB7);
+						case 1: return QString();
+					}
+				}
 
-        switch (index.column()) {
-        case 0: return bookmarkNode.title;
-        case 1: return bookmarkNode.url;
-        }
-        break;
-    case BookmarksModel.UrlRole:
-        return QUrl(bookmarkNode.url);
-        break;
-    case BookmarksModel.UrlStringRole:
-        return bookmarkNode.url;
-        break;
-    case BookmarksModel.TypeRole:
-        return bookmarkNode.type();
-        break;
-    case BookmarksModel.SeparatorRole:
-        return (bookmarkNode.type() == BookmarkNode.Separator);
-        break;
-    case Qt.DecorationRole:
-        if (index.column() == 0) {
-            if (bookmarkNode.type() == BookmarkNode.Folder)
-                return QApplication.style().standardIcon(QStyle.SP_DirIcon);
-            return BrowserApplication.instance().icon(bookmarkNode.url);
-        }
-    }
+				switch (index.column()) {
+					case 0: return bookmarkNode.title;
+					case 1: return bookmarkNode.url;
+				}
+				break;
+			case BookmarksModel.UrlRole:
+				return QUrl(bookmarkNode.url);
+				break;
+			case BookmarksModel.UrlStringRole:
+				return bookmarkNode.url;
+				break;
+			case BookmarksModel.TypeRole:
+				return bookmarkNode.type();
+				break;
+			case BookmarksModel.SeparatorRole:
+				return (bookmarkNode.type() == BookmarkNode.Separator);
+				break;
+			case Qt.DecorationRole:
+				if (index.column() == 0) {
+					if (bookmarkNode.type() == BookmarkNode.Folder)
+						return QApplication.style().standardIcon(QStyle.SP_DirIcon);
+					return BrowserApplication.instance().icon(bookmarkNode.url);
+				}
+		}
 
-    return QVariant();
-}
+		return QVariant();
+	}
+
+	int columnCount(QModelIndex parent = QModelIndex())
+	{
+		return (parent.column() > 0) ? 0 : 2;
+	}
+
+	int rowCount(QModelIndex parent = QModelIndex())
+	{
+		if (parent.column() > 0)
+			return 0;
 
-    int columnCount(QModelIndex parent = QModelIndex())
-{
-    return (parent.column() > 0) ? 0 : 2;
-}
+		if (!parent.isValid())
+			return m_bookmarksManager.bookmarks().children().count();
 
-    int rowCount(QModelIndex parent = QModelIndex())
-{
-    if (parent.column() > 0)
-        return 0;
+		BookmarkNode item = static_cast<BookmarkNode>(parent.internalPointer());
+		return item.children().count();
+	}
+
+	QModelIndex index(int, int, QModelIndex& = QModelIndex())
+	{
+		if (row < 0 || column < 0 || row >= rowCount(parent) || column >= columnCount(parent))
+			return QModelIndex();
 
-    if (!parent.isValid())
-        return m_bookmarksManager.bookmarks().children().count();
+		// get the parent node
+		BookmarkNode parentNode = node(parent);
+		return createIndex(row, column, parentNode.children().at(row));
+	}
 
-    const BookmarkNode item = static_cast<BookmarkNode>(parent.internalPointer());
-    return item.children().count();
-}
+	QModelIndex parent(QModelIndex& index= QModelIndex())
+	{
+		if (!index.isValid())
+			return QModelIndex();
 
-    QModelIndex index(int, int, QModelIndex& = QModelIndex())
-{
-    if (row < 0 || column < 0 || row >= rowCount(parent) || column >= columnCount(parent))
-        return QModelIndex();
+		BookmarkNode itemNode = node(index);
+		BookmarkNode parentNode = (itemNode ? itemNode.parent() : 0);
+		if (!parentNode || parentNode == m_bookmarksManager.bookmarks())
+			return QModelIndex();
 
-    // get the parent node
-    BookmarkNode parentNode = node(parent);
-    return createIndex(row, column, parentNode.children().at(row));
-}
+		// get the parent's row
+		BookmarkNode grandParentNode = parentNode.parent();
+		int parentRow = grandParentNode.children().indexOf(parentNode);
+		assert(parentRow >= 0);
+		return createIndex(parentRow, 0, parentNode);
+	}
 
-    QModelIndex parent(QModelIndex& index= QModelIndex())
-{
-    if (!index.isValid())
-        return QModelIndex();
+	Qt.ItemFlags flags(QModelIndex index)
+	{
+		if (!index.isValid())
+			return Qt.NoItemFlags;
+
+		Qt.ItemFlags flags = Qt.ItemIsSelectable | Qt.ItemIsEnabled;
 
-    BookmarkNode itemNode = node(index);
-    BookmarkNode parentNode = (itemNode ? itemNode.parent() : 0);
-    if (!parentNode || parentNode == m_bookmarksManager.bookmarks())
-        return QModelIndex();
+		BookmarkNode bookmarkNode = node(index);
 
-    // get the parent's row
-    BookmarkNode grandParentNode = parentNode.parent();
-    int parentRow = grandParentNode.children().indexOf(parentNode);
-    assert(parentRow >= 0);
-    return createIndex(parentRow, 0, parentNode);
-}
+		if (bookmarkNode != m_bookmarksManager.menu() && bookmarkNode != m_bookmarksManager.toolbar()) {
+			flags |= Qt.ItemIsDragEnabled;
+			if (bookmarkNode.type() != BookmarkNode.Separator)
+				flags |= Qt.ItemIsEditable;
+		}
+		if (hasChildren(index))
+			flags |= Qt.ItemIsDropEnabled;
+		return flags;
+	}
+
+	Qt.DropActions supportedDropActions ();
+	{
+		return Qt.CopyAction | Qt.MoveAction;
+	}
 
 
-    Qt.ItemFlags flags(QModelIndex index)
-{
-    if (!index.isValid())
-        return Qt.NoItemFlags;
+	bool removeRows(int row, int count, QModelIndex parent = QModelIndex());
+	{
+		if (row < 0 || count <= 0 || row + count > rowCount(parent))
+			return false;
+
+		BookmarkNode bookmarkNode = node(parent);
+		for (int i = row + count - 1; i >= row; --i) {
+			BookmarkNode node = bookmarkNode.children().at(i);
+			if (node == m_bookmarksManager.menu() || node == m_bookmarksManager.toolbar())
+				continue;
 
-    Qt.ItemFlags flags = Qt.ItemIsSelectable | Qt.ItemIsEnabled;
-
-    BookmarkNode bookmarkNode = node(index);
+			m_bookmarksManager.removeBookmark(node);
+		}
+		if (m_endMacro) {
+			m_bookmarksManager.undoRedoStack().endMacro();
+			m_endMacro = false;
+		}
+		return true;
+	}
+    
+	bool setData(QModelIndex index, QVariant value, int role = Qt.EditRole)
+	{
+		if (!index.isValid() || (flags(index) & Qt.ItemIsEditable) == 0)
+			return false;
 
-    if (bookmarkNode != m_bookmarksManager.menu() && bookmarkNode != m_bookmarksManager.toolbar()) {
-        flags |= Qt.ItemIsDragEnabled;
-        if (bookmarkNode.type() != BookmarkNode.Separator)
-            flags |= Qt.ItemIsEditable;
-    }
-    if (hasChildren(index))
-        flags |= Qt.ItemIsDropEnabled;
-    return flags;
-}
+		BookmarkNode item = node(index);
 
-    Qt.DropActions supportedDropActions ();
-{
-    return Qt.CopyAction | Qt.MoveAction;
-}
+		switch (role) {
+			case Qt.EditRole:
+			case Qt.DisplayRole:
+				if (index.column() == 0) {
+					m_bookmarksManager.setTitle(item, value.toString());
+					break;
+				}
+				if (index.column() == 1) {
+					m_bookmarksManager.setUrl(item, value.toString());
+					break;
+				}
+				return false;
+			case BookmarksModel.UrlRole:
+				m_bookmarksManager.setUrl(item, value.toUrl().toString());
+				break;
+			case BookmarksModel.UrlStringRole:
+				m_bookmarksManager.setUrl(item, value.toString());
+				break;
+			default:
+				break;
+				return false;
+		}
+
+		return true;
+	}
 
 
-    bool removeRows(int row, int count, QModelIndex parent = QModelIndex());
-{
-    if (row < 0 || count <= 0 || row + count > rowCount(parent))
-        return false;
-
-    BookmarkNode bookmarkNode = node(parent);
-    for (int i = row + count - 1; i >= row; --i) {
-        BookmarkNode node = bookmarkNode.children().at(i);
-        if (node == m_bookmarksManager.menu()
-            || node == m_bookmarksManager.toolbar())
-            continue;
-
-        m_bookmarksManager.removeBookmark(node);
-    }
-    if (m_endMacro) {
-        m_bookmarksManager.undoRedoStack().endMacro();
-        m_endMacro = false;
-    }
-    return true;
-}
-    
-    bool setData(QModelIndex index, QVariant value, int role = Qt.EditRole)
-{
-    if (!index.isValid() || (flags(index) & Qt.ItemIsEditable) == 0)
-        return false;
-
-    BookmarkNode item = node(index);
-
-    switch (role) {
-    case Qt.EditRole:
-    case Qt.DisplayRole:
-        if (index.column() == 0) {
-            m_bookmarksManager.setTitle(item, value.toString());
-            break;
-        }
-        if (index.column() == 1) {
-            m_bookmarksManager.setUrl(item, value.toString());
-            break;
-        }
-        return false;
-    case BookmarksModel.UrlRole:
-        m_bookmarksManager.setUrl(item, value.toUrl().toString());
-        break;
-    case BookmarksModel.UrlStringRole:
-        m_bookmarksManager.setUrl(item, value.toString());
-        break;
-    default:
-        break;
-        return false;
-    }
-
-    return true;
-}
-
-
-    QMimeData mimeData(QModelIndexList indexes);
-{
-    QMimeData mimeData = new QMimeData();
-    QByteArray data;
-    QDataStream stream(&data, QIODevice.WriteOnly);
-    foreach (QModelIndex index, indexes) {
-        if (index.column() != 0 || !index.isValid())
-            continue;
-        QByteArray encodedData;
-        QBuffer buffer(&encodedData);
-        buffer.open(QBuffer.ReadWrite);
-        XbelWriter writer;
-        const BookmarkNode parentNode = node(index);
-        writer.write(&buffer, parentNode);
-        stream << encodedData;
-    }
-    mimeData.setData(MIMETYPE, data);
-    return mimeData;
-}
+	QMimeData mimeData(QModelIndexList indexes);
+	{
+		QMimeData mimeData = new QMimeData();
+		QByteArray data;
+		auto stream = new QDataStream(&data, QIODevice.WriteOnly);
+		foreach (QModelIndex index, indexes) {
+			if (index.column() != 0 || !index.isValid())
+				continue;
+			QByteArray encodedData;
+			auto buffer = new QBuffer(&encodedData);
+			buffer.open(QBuffer.ReadWrite);
+			XbelWriter writer;
+			const BookmarkNode parentNode = node(index);
+			writer.write(&buffer, parentNode);
+			stream << encodedData;
+		}
+		mimeData.setData(MIMETYPE, data);
+		return mimeData;
+	}
 
 
 const char[] MIMETYPE = QLatin1String("application/bookmarks.xbel")
 
-QStringList mimeTypes()
-{
-    QStringList types;
-    types << MIMETYPE;
-    return types;
-}
+	QStringList mimeTypes()
+	{
+		QStringList types;
+		types << MIMETYPE;
+		return types;
+	}
 
-bool dropMimeData(QMimeData data,  Qt.DropAction action, int row, int column, QModelIndex parent)
-{
-    if (action == Qt.IgnoreAction)
-        return true;
+	bool dropMimeData(QMimeData data,  Qt.DropAction action, int row, int column, QModelIndex parent)
+	{
+		if (action == Qt.IgnoreAction)
+			return true;
 
-    if (!data.hasFormat(MIMETYPE) || column > 0)
-        return false;
+		if (!data.hasFormat(MIMETYPE) || column > 0)
+			return false;
 
-    QByteArray ba = data.data(MIMETYPE);
-    QDataStream stream(&ba, QIODevice.ReadOnly);
-    if (stream.atEnd())
-        return false;
+		QByteArray ba = data.data(MIMETYPE);
+		QDataStream stream(&ba, QIODevice.ReadOnly);
+		if (stream.atEnd())
+			return false;
 
-    QUndoStack undoStack = m_bookmarksManager.undoRedoStack();
-    undoStack.beginMacro(QLatin1String("Move Bookmarks"));
+		QUndoStack undoStack = m_bookmarksManager.undoRedoStack();
+		undoStack.beginMacro(QLatin1String("Move Bookmarks"));
 
-    while (!stream.atEnd()) {
-        QByteArray encodedData;
-        stream >> encodedData;
-        QBuffer buffer(&encodedData);
-        buffer.open(QBuffer.ReadOnly);
+		while (!stream.atEnd()) {
+			QByteArray encodedData;
+			stream >> encodedData;
+			QBuffer buffer(&encodedData);
+			buffer.open(QBuffer.ReadOnly);
 
-        XbelReader reader;
-        BookmarkNode rootNode = reader.read(&buffer);
-        QList<BookmarkNode> children = rootNode.children();
-        for (int i = 0; i < children.count(); ++i) {
-            BookmarkNode bookmarkNode = children.at(i);
-            rootNode.remove(bookmarkNode);
-            row = qMax(0, row);
-            BookmarkNode parentNode = node(parent);
-            m_bookmarksManager.addBookmark(parentNode, bookmarkNode, row);
-            m_endMacro = true;
-        }
-        delete rootNode;
-    }
-    return true;
-}
-
+			XbelReader reader;
+			BookmarkNode rootNode = reader.read(&buffer);
+			QList<BookmarkNode> children = rootNode.children();
+			for (int i = 0; i < children.count(); ++i) {
+				BookmarkNode bookmarkNode = children.at(i);
+				rootNode.remove(bookmarkNode);
+				row = qMax(0, row);
+				BookmarkNode parentNode = node(parent);
+				m_bookmarksManager.addBookmark(parentNode, bookmarkNode, row);
+				m_endMacro = true;
+			}
+			delete rootNode;
+		}
+		return true;
+	}
 
-    bool hasChildren(QModelIndex parent = QModelIndex())
-{
-    if (!parent.isValid())
-        return true;
-    const BookmarkNode parentNode = node(parent);
-    return (parentNode.type() == BookmarkNode.Folder);
-}
+	bool hasChildren(QModelIndex parent = QModelIndex())
+	{
+		if (!parent.isValid())
+			return true;
+		const BookmarkNode parentNode = node(parent);
+		return (parentNode.type() == BookmarkNode.Folder);
+	}
 
-    BookmarkNode node(QModelIndex index)
-{
-    BookmarkNode itemNode = static_cast<BookmarkNode>(index.internalPointer());
-    if (!itemNode)
-        return m_bookmarksManager.bookmarks();
-    return itemNode;
-}
+	BookmarkNode node(QModelIndex index)
+	{
+		BookmarkNode itemNode = static_cast<BookmarkNode>(index.internalPointer());
+		if (!itemNode)
+			return m_bookmarksManager.bookmarks();
+		return itemNode;
+	}
 
-    QModelIndex index(BookmarkNode node)
-{
-    BookmarkNode parent = node.parent();
-    if (!parent)
-        return QModelIndex();
-    return createIndex(parent.children().indexOf(node), 0, node);
-}
+	QModelIndex index(BookmarkNode node)
+	{
+		BookmarkNode parent = node.parent();
+		if (!parent)
+			return QModelIndex();
+		return createIndex(parent.children().indexOf(node), 0, node);
+	}
 
 private:
 
-    bool m_endMacro;
-    BookmarksManager m_bookmarksManager;
+	bool m_endMacro;
+	BookmarksManager m_bookmarksManager;
 }
 
 // Menu that is dynamically populated from the bookmarks
 import modelmenu;
+
 class BookmarksMenu : public ModelMenu
 {
-    mixin Signal!("openUrl", QUrl url);
+	mixin Signal!("openUrl", QUrl url);
 
 public:
-     BookmarksMenu(QWidget parent = null)
-{
-super(parent);	
-	m_bookmarksManager = 0;
-    this.activated.connect(&this.activated);
-    setMaxRows(-1);
-    setHoverRole(BookmarksModel.UrlStringRole);
-    setSeparatorRole(BookmarksModel.SeparatorRole);
-}
-     void setInitialActions(QList<QAction> actions);
-{
-    m_initialActions = actions;
-    for (int i = 0; i < m_initialActions.count(); ++i)
-        addAction(m_initialActions.at(i));
-}
+
+	BookmarksMenu(QWidget parent = null)
+	{
+		super(parent);	
+		m_bookmarksManager = 0;
+		this.activated.connect(&this.activated);
+		setMaxRows(-1);
+		setHoverRole(BookmarksModel.UrlStringRole);
+		setSeparatorRole(BookmarksModel.SeparatorRole);
+	}
+	
+	void setInitialActions(QList<QAction> actions);
+	{
+		m_initialActions = actions;
+		for (int i = 0; i < m_initialActions.count(); ++i)
+			addAction(m_initialActions.at(i));
+	}
+
 protected:
+
 	bool prePopulated()
-{
-    m_bookmarksManager = BrowserApplication.bookmarksManager();
-    setModel(m_bookmarksManager.bookmarksModel());
-    setRootIndex(m_bookmarksManager.bookmarksModel().index(1, 0));
-    // initial actions
-    for (int i = 0; i < m_initialActions.count(); ++i)
-        addAction(m_initialActions.at(i));
-    if (!m_initialActions.isEmpty())
-        addSeparator();
-    createMenu(model().index(0, 0), 1, this);
-    return true;
-}
-
-private slots:
-    void activated(QModelIndex index)
-{
-    emit openUrl(index.data(BookmarksModel.UrlRole).toUrl());
-}
+	{
+		m_bookmarksManager = BrowserApplication.bookmarksManager();
+		setModel(m_bookmarksManager.bookmarksModel());
+		setRootIndex(m_bookmarksManager.bookmarksModel().index(1, 0));
+		// initial actions
+		for (int i = 0; i < m_initialActions.count(); ++i)
+			addAction(m_initialActions.at(i));
+		if (!m_initialActions.isEmpty())
+			addSeparator();
+		createMenu(model().index(0, 0), 1, this);
+		return true;
+	}
 
 private:
-    BookmarksManager m_bookmarksManager;
-    QList<QAction> m_initialActions;
+
+	void activated(QModelIndex index)
+	{
+		emit openUrl(index.data(BookmarksModel.UrlRole).toUrl());
+	}
+
+private:
+
+	BookmarksManager m_bookmarksManager;
+	QList<QAction> m_initialActions;
 }
 
 /*
@@ -823,85 +822,89 @@
 
 class AddBookmarkProxyModel : public QSortFilterProxyModel
 {
-    Q_OBJECT
 public:
-    this(QObject  parent = null)
-{
-	super(parent);
-}
-    int columnCount(QModelIndex  parent = QModelIndex())
-{
-    return qMin(1, QSortFilterProxyModel.columnCount(parent));
-}
-protected:
-    bool filterAcceptsRow(int source_row, QModelIndex source_parent)
-{
-    QModelIndex idx = sourceModel().index(source_row, 0, source_parent);
-    return sourceModel().hasChildren(idx);
-}
+
+	this(QObject  parent = null)
+	{
+		super(parent);
+	}
+	
+	int columnCount(QModelIndex  parent = QModelIndex())
+	{
+		return qMin(1, QSortFilterProxyModel.columnCount(parent));
+	}
+
+	protected:
+
+	bool filterAcceptsRow(int source_row, QModelIndex source_parent)
+	{
+		QModelIndex idx = sourceModel().index(source_row, 0, source_parent);
+		return sourceModel().hasChildren(idx);
+	}
 }
 
 /*!
-    Add bookmark dialog
- */
+Add bookmark dialog
+*/
 
 import ui_addbookmarkdialog;
 
 class AddBookmarkDialog : public QDialog, public Ui_AddBookmarkDialog
 {
+public:
 
-public:
-    this(QString url, QString title, QWidget parent = null, BookmarksManager bookmarkManager = null)
- : QDialog(parent)
-{
-	m_url = url;
-    m_bookmarksManager = bookmarkManager;
-	
-    setWindowFlags(Qt.Sheet);
-    if (!m_bookmarksManager)
-        m_bookmarksManager = BrowserApplication.bookmarksManager();
-    setupUi(this);
-    QTreeView view = new QTreeView(this);
-    m_proxyModel = new AddBookmarkProxyModel(this);
-    BookmarksModel model = m_bookmarksManager.bookmarksModel();
-    m_proxyModel.setSourceModel(model);
-    view.setModel(m_proxyModel);
-    view.expandAll();
-    view.header().setStretchLastSection(true);
-    view.header().hide();
-    view.setItemsExpandable(false);
-    view.setRootIsDecorated(false);
-    view.setIndentation(10);
-    location.setModel(m_proxyModel);
-    view.show();
-    location.setView(view);
-    BookmarkNode menu = m_bookmarksManager.menu();
-    QModelIndex idx = m_proxyModel.mapFromSource(model.index(menu));
-    view.setCurrentIndex(idx);
-    location.setCurrentIndex(idx.row());
-    name.setText(title);
-}
+	this(QString url, QString title, QWidget parent = null, BookmarksManager bookmarkManager = null)
+	: QDialog(parent)
+	{
+		m_url = url;
+		m_bookmarksManager = bookmarkManager;
+
+		setWindowFlags(Qt.Sheet);
+		if (!m_bookmarksManager)
+			m_bookmarksManager = BrowserApplication.bookmarksManager();
+		setupUi(this);
+		QTreeView view = new QTreeView(this);
+		m_proxyModel = new AddBookmarkProxyModel(this);
+		BookmarksModel model = m_bookmarksManager.bookmarksModel();
+		m_proxyModel.setSourceModel(model);
+		view.setModel(m_proxyModel);
+		view.expandAll();
+		view.header().setStretchLastSection(true);
+		view.header().hide();
+		view.setItemsExpandable(false);
+		view.setRootIsDecorated(false);
+		view.setIndentation(10);
+		location.setModel(m_proxyModel);
+		view.show();
+		location.setView(view);
+		BookmarkNode menu = m_bookmarksManager.menu();
+		QModelIndex idx = m_proxyModel.mapFromSource(model.index(menu));
+		view.setCurrentIndex(idx);
+		location.setCurrentIndex(idx.row());
+		name.setText(title);
+	}
 
 private:
 	
-void accept()
-{
-    QModelIndex index = location.view().currentIndex();
-    index = m_proxyModel.mapToSource(index);
-    if (!index.isValid())
-        index = m_bookmarksManager.bookmarksModel().index(0, 0);
-    BookmarkNode parent = m_bookmarksManager.bookmarksModel().node(index);
-    BookmarkNode bookmark = new BookmarkNode(BookmarkNode.Bookmark);
-    bookmark.url = m_url;
-    bookmark.title = name.text();
-    m_bookmarksManager.addBookmark(parent, bookmark);
-    QDialog.accept();
-}
+	void accept()
+	{
+		QModelIndex index = location.view().currentIndex();
+		index = m_proxyModel.mapToSource(index);
+		if (!index.isValid())
+			index = m_bookmarksManager.bookmarksModel().index(0, 0);
+		BookmarkNode parent = m_bookmarksManager.bookmarksModel().node(index);
+		BookmarkNode bookmark = new BookmarkNode(BookmarkNode.Bookmark);
+		bookmark.url = m_url;
+		bookmark.title = name.text();
+		m_bookmarksManager.addBookmark(parent, bookmark);
+		QDialog.accept();
+	}
 
 private:
-    QString m_url;
-    BookmarksManager m_bookmarksManager;
-    AddBookmarkProxyModel m_proxyModel;
+
+	QString m_url;
+	BookmarksManager m_bookmarksManager;
+	AddBookmarkProxyModel m_proxyModel;
 }
 
 import ui_bookmarks;
@@ -909,239 +912,245 @@
 //class TreeProxyModel;
 class BookmarksDialog : public QDialog, public Ui_BookmarksDialog
 {
-	
-    mixin Signal!("openUrl", QUrl url);
+	mixin Signal!("openUrl", QUrl url);
 
 public:
-    this(QWidget parent = null, BookmarksManager manager = null)
-    : QDialog(parent)
-{
-    m_bookmarksManager = manager;
-    if (!m_bookmarksManager)
-        m_bookmarksManager = BrowserApplication.bookmarksManager();
-    setupUi(this);
+
+	this(QWidget parent = null, BookmarksManager manager = null)
+	: QDialog(parent)
+	{
+		m_bookmarksManager = manager;
+		if (!m_bookmarksManager)
+			m_bookmarksManager = BrowserApplication.bookmarksManager();
+		setupUi(this);
 
-    tree.setUniformRowHeights(true);
-    tree.setSelectionBehavior(QAbstractItemView.SelectRows);
-    tree.setSelectionMode(QAbstractItemView.ContiguousSelection);
-    tree.setTextElideMode(Qt.ElideMiddle);
-    m_bookmarksModel = m_bookmarksManager.bookmarksModel();
-    m_proxyModel = new TreeProxyModel(this);
-    search.textChanged.connect(&m_proxyModel.setFilterFixedString);
-    removeButton.clicked.connect(&tree.removeOne);
-    m_proxyModel.setSourceModel(m_bookmarksModel);
-    tree.setModel(m_proxyModel);
-    tree.setDragDropMode(QAbstractItemView.InternalMove);
-    tree.setExpanded(m_proxyModel.index(0, 0), true);
-    tree.setAlternatingRowColors(true);
-   auto fm = new QFontMetrics(font());
-    int header = fm.width(QLatin1Char('m')) * 40;
-    tree.header().resizeSection(0, header);
-    tree.header().setStretchLastSection(true);
-    tree.activated.connect(&this.open);
-    tree.setContextMenuPolicy(Qt.CustomContextMenu);
-    tree.customContextMenuRequested.connect(&this.customContextMenuRequested);
-    addFolderButton.clicked.connect(&this.newFolder);
-    expandNodes(m_bookmarksManager.bookmarks());
-    setAttribute(Qt.WA_DeleteOnClose);
-}
-    ~this()
-{
-    if (saveExpandedNodes(tree.rootIndex()))
-        m_bookmarksManager.changeExpanded();
-}
-
-private slots:
-    void customContextMenuRequested(QPoint pos)
-{
-    QMenu menu;
-    QModelIndex index = tree.indexAt(pos);
-    index = index.sibling(index.row(), 0);
-    if (index.isValid() && !tree.model().hasChildren(index)) {
-        menu.addAction(tr("Open"), this, SLOT(open()));
-        menu.addSeparator();
-    }
-    menu.addAction(tr("Delete"), tree, SLOT(removeOne()));
-    menu.exec(QCursor.pos());
-}
-void open()
-{
-    QModelIndex index = tree.currentIndex();
-    if (!index.parent().isValid())
-        return;
-    emit openUrl(index.sibling(index.row(), 1).data(BookmarksModel.UrlRole).toUrl());
-}
-
-    void newFolder()
-{
-    QModelIndex currentIndex = tree.currentIndex();
-    QModelIndex idx = currentIndex;
-    if (idx.isValid() && !idx.model().hasChildren(idx))
-        idx = idx.parent();
-    if (!idx.isValid())
-        idx = tree.rootIndex();
-    idx = m_proxyModel.mapToSource(idx);
-    BookmarkNode parent = m_bookmarksManager.bookmarksModel().node(idx);
-    BookmarkNode node = new BookmarkNode(BookmarkNode.Folder);
-    node.title = tr("New Folder");
-    m_bookmarksManager.addBookmark(parent, node, currentIndex.row() + 1);
-}
+		tree.setUniformRowHeights(true);
+		tree.setSelectionBehavior(QAbstractItemView.SelectRows);
+		tree.setSelectionMode(QAbstractItemView.ContiguousSelection);
+		tree.setTextElideMode(Qt.ElideMiddle);
+		m_bookmarksModel = m_bookmarksManager.bookmarksModel();
+		m_proxyModel = new TreeProxyModel(this);
+		search.textChanged.connect(&m_proxyModel.setFilterFixedString);
+		removeButton.clicked.connect(&tree.removeOne);
+		m_proxyModel.setSourceModel(m_bookmarksModel);
+		tree.setModel(m_proxyModel);
+		tree.setDragDropMode(QAbstractItemView.InternalMove);
+		tree.setExpanded(m_proxyModel.index(0, 0), true);
+		tree.setAlternatingRowColors(true);
+		auto fm = new QFontMetrics(font());
+		int header = fm.width(QLatin1Char('m')) * 40;
+		tree.header().resizeSection(0, header);
+		tree.header().setStretchLastSection(true);
+		tree.activated.connect(&this.open);
+		tree.setContextMenuPolicy(Qt.CustomContextMenu);
+		tree.customContextMenuRequested.connect(&this.customContextMenuRequested);
+		addFolderButton.clicked.connect(&this.newFolder);
+		expandNodes(m_bookmarksManager.bookmarks());
+		setAttribute(Qt.WA_DeleteOnClose);
+	}
+	
+	~this()
+	{
+		if (saveExpandedNodes(tree.rootIndex()))
+			m_bookmarksManager.changeExpanded();
+	}
 
 private:
-    void expandNodes(BookmarkNode node)
-{
-    for (int i = 0; i < node.children().count(); ++i) {
-        BookmarkNode childNode = node.children()[i];
-        if (childNode.expanded) {
-            QModelIndex idx = m_bookmarksModel.index(childNode);
-            idx = m_proxyModel.mapFromSource(idx);
-            tree.setExpanded(idx, true);
-            expandNodes(childNode);
-        }
-    }
-}
+
+	void customContextMenuRequested(QPoint pos)
+	{
+		QMenu menu;
+		QModelIndex index = tree.indexAt(pos);
+		index = index.sibling(index.row(), 0);
+		if (index.isValid() && !tree.model().hasChildren(index)) {
+			menu.addAction(tr("Open"), this, SLOT(open()));
+			menu.addSeparator();
+		}
+		menu.addAction(tr("Delete"), tree, SLOT(removeOne()));
+		menu.exec(QCursor.pos());
+	}
+	
+	void open()
+	{
+		QModelIndex index = tree.currentIndex();
+		if (!index.parent().isValid())
+			return;
+		emit openUrl(index.sibling(index.row(), 1).data(BookmarksModel.UrlRole).toUrl());
+	}
+
+	void newFolder()
+	{
+		QModelIndex currentIndex = tree.currentIndex();
+		QModelIndex idx = currentIndex;
+		if (idx.isValid() && !idx.model().hasChildren(idx))
+			idx = idx.parent();
+		if (!idx.isValid())
+			idx = tree.rootIndex();
+		idx = m_proxyModel.mapToSource(idx);
+		BookmarkNode parent = m_bookmarksManager.bookmarksModel().node(idx);
+		BookmarkNode node = new BookmarkNode(BookmarkNode.Folder);
+		node.title = tr("New Folder");
+		m_bookmarksManager.addBookmark(parent, node, currentIndex.row() + 1);
+	}
 
-bool saveExpandedNodes(QModelIndex parent)
-{
-    bool changed = false;
-    for (int i = 0; i < m_proxyModel.rowCount(parent); ++i) {
-        QModelIndex child = m_proxyModel.index(i, 0, parent);
-        QModelIndex sourceIndex = m_proxyModel.mapToSource(child);
-        BookmarkNode childNode = m_bookmarksModel.node(sourceIndex);
-        bool wasExpanded = childNode.expanded;
-        if (tree.isExpanded(child)) {
-            childNode.expanded = true;
-            changed |= saveExpandedNodes(child);
-        } else {
-            childNode.expanded = false;
-        }
-        changed |= (wasExpanded != childNode.expanded);
-    }
-    return changed;
-}
+private:
+	void expandNodes(BookmarkNode node)
+	{
+		for (int i = 0; i < node.children().count(); ++i) {
+			BookmarkNode childNode = node.children()[i];
+			if (childNode.expanded) {
+				QModelIndex idx = m_bookmarksModel.index(childNode);
+				idx = m_proxyModel.mapFromSource(idx);
+				tree.setExpanded(idx, true);
+				expandNodes(childNode);
+			}
+		}
+	}
 
-    BookmarksManager m_bookmarksManager;
-    BookmarksModel m_bookmarksModel;
-    TreeProxyModel m_proxyModel;
+	bool saveExpandedNodes(QModelIndex parent)
+	{
+		bool changed = false;
+		for (int i = 0; i < m_proxyModel.rowCount(parent); ++i) {
+			QModelIndex child = m_proxyModel.index(i, 0, parent);
+			QModelIndex sourceIndex = m_proxyModel.mapToSource(child);
+			BookmarkNode childNode = m_bookmarksModel.node(sourceIndex);
+			bool wasExpanded = childNode.expanded;
+			if (tree.isExpanded(child)) {
+				childNode.expanded = true;
+				changed |= saveExpandedNodes(child);
+			} else {
+				childNode.expanded = false;
+			}
+			changed |= (wasExpanded != childNode.expanded);
+		}
+		return changed;
+	}
+
+	BookmarksManager m_bookmarksManager;
+	BookmarksModel m_bookmarksModel;
+	TreeProxyModel m_proxyModel;
 }
 
 import qt.gui.QToolBar;
 
 class BookmarksToolBar : public QToolBar
 {
-    mixin Signal!("openUrl", QUrl url);
+mixin Signal!("openUrl", QUrl url);
 
 public:
-    BookmarksToolBar(BookmarksModel model, QWidget parent = null)
-{
-	super(tr("Bookmark"), parent);
-	m_bookmarksModel = model;
-    this.actionTriggered.connect(&this.triggered);
-    setRootIndex(model.index(0, 0));
-    m_bookmarksModel.modelReset.connect(&this.build);
-    m_bookmarksModel.rowsInserted.connect(&this.build);
-    m_bookmarksModel.rowsRemoved.connect(&this.build);
-    m_bookmarksModel.dataChanged.connect(&this.build);
-    setAcceptDrops(true);
-}
 
-    void setRootIndex(QModelIndex index);
-{
-    m_root = index;
-    build();
-}
+	this(BookmarksModel model, QWidget parent = null)
+	{
+		super(tr("Bookmark"), parent);
+		m_bookmarksModel = model;
+		this.actionTriggered.connect(&this.triggered);
+		setRootIndex(model.index(0, 0));
+		m_bookmarksModel.modelReset.connect(&this.build);
+		m_bookmarksModel.rowsInserted.connect(&this.build);
+		m_bookmarksModel.rowsRemoved.connect(&this.build);
+		m_bookmarksModel.dataChanged.connect(&this.build);
+		setAcceptDrops(true);
+	}
 
-    QModelIndex rootIndex()
-{
-    return m_root;
-}
+	void setRootIndex(QModelIndex index);
+	{
+		m_root = index;
+		build();
+	}
+
+	QModelIndex rootIndex()
+	{
+		return m_root;
+	}
 
 protected:
-    void dragEnterEvent(QDragEnterEvent event)
-{
-    const QMimeData mimeData = event.mimeData();
-    if (mimeData.hasUrls())
-        event.acceptProposedAction();
-    QToolBar.dragEnterEvent(event);
-}
 
-    void dropEvent(QDropEvent event)
-{
-    const QMimeData mimeData = event.mimeData();
-    if (mimeData.hasUrls() && mimeData.hasText()) {
-        QList<QUrl> urls = mimeData.urls();
-        QAction action = actionAt(event.pos());
-        QString dropText;
-        if (action)
-            dropText = action.text();
-        int row = -1;
-        QModelIndex parentIndex = m_root;
-        for (int i = 0; i < m_bookmarksModel.rowCount(m_root); ++i) {
-            QModelIndex idx = m_bookmarksModel.index(i, 0, m_root);
-            QString title = idx.data().toString();
-            if (title == dropText) {
-                row = i;
-                if (m_bookmarksModel.hasChildren(idx)) {
-                    parentIndex = idx;
-                    row = -1;
-                }
-                break;
-            }
-        }
-        BookmarkNode bookmark = new BookmarkNode(BookmarkNode.Bookmark);
-        bookmark.url = urls.at(0).toString();
-        bookmark.title = mimeData.text();
+	void dragEnterEvent(QDragEnterEvent event)
+	{
+		const QMimeData mimeData = event.mimeData();
+		if (mimeData.hasUrls())
+			event.acceptProposedAction();
+		QToolBar.dragEnterEvent(event);
+	}
 
-        BookmarkNode parent = m_bookmarksModel.node(parentIndex);
-        BookmarksManager bookmarksManager = m_bookmarksModel.bookmarksManager();
-        bookmarksManager.addBookmark(parent, bookmark, row);
-        event.acceptProposedAction();
-    }
-    QToolBar.dropEvent(event);
-}
-
-private slots:
-    void triggered(QAction action)
-{
-    QVariant v = action.data();
-    if (v.canConvert<QUrl>()) {
-        emit openUrl(v.toUrl());
-    }
-}
-
-    void activated(QModelIndex index)
-{
-    emit openUrl(index.data(BookmarksModel.UrlRole).toUrl());
-}
-
+	void dropEvent(QDropEvent event)
+	{
+		const QMimeData mimeData = event.mimeData();
+		if (mimeData.hasUrls() && mimeData.hasText()) {
+			QList<QUrl> urls = mimeData.urls();
+			QAction action = actionAt(event.pos());
+			QString dropText;
+			if (action)
+				dropText = action.text();
+			int row = -1;
+			QModelIndex parentIndex = m_root;
+			for (int i = 0; i < m_bookmarksModel.rowCount(m_root); ++i) {
+				QModelIndex idx = m_bookmarksModel.index(i, 0, m_root);
+				QString title = idx.data().toString();
+				if (title == dropText) {
+					row = i;
+					if (m_bookmarksModel.hasChildren(idx)) {
+						parentIndex = idx;
+						row = -1;
+					}
+					break;
+				}
+			}
+			BookmarkNode bookmark = new BookmarkNode(BookmarkNode.Bookmark);
+			bookmark.url = urls.at(0).toString();
+			bookmark.title = mimeData.text();
 
-    void build()
-{
-    clear();
-    for (int i = 0; i < m_bookmarksModel.rowCount(m_root); ++i) {
-        QModelIndex idx = m_bookmarksModel.index(i, 0, m_root);
-        if (m_bookmarksModel.hasChildren(idx)) {
-            QToolButton button = new QToolButton(this);
-            button.setPopupMode(QToolButton.InstantPopup);
-            button.setArrowType(Qt.DownArrow);
-            button.setText(idx.data().toString());
-            ModelMenu menu = new ModelMenu(this);
-            menu.activated.connect(&this.activated);
-            menu.setModel(m_bookmarksModel);
-            menu.setRootIndex(idx);
-            menu.addAction(new QAction(menu));
-            button.setMenu(menu);
-            button.setToolButtonStyle(Qt.ToolButtonTextOnly);
-            QAction a = addWidget(button);
-            a.setText(idx.data().toString());
-        } else {
-            QAction action = addAction(idx.data().toString());
-            action.setData(idx.data(BookmarksModel.UrlRole));
-        }
-    }
-}
+			BookmarkNode parent = m_bookmarksModel.node(parentIndex);
+			BookmarksManager bookmarksManager = m_bookmarksModel.bookmarksManager();
+			bookmarksManager.addBookmark(parent, bookmark, row);
+			event.acceptProposedAction();
+		}
+		QToolBar.dropEvent(event);
+	}
 
 private:
-    BookmarksModel m_bookmarksModel;
-    QPersistentModelIndex m_root;
+
+	void triggered(QAction action)
+	{
+		QVariant v = action.data();
+		if (v.canConvert<QUrl>()) {
+			emit openUrl(v.toUrl());
+		}
+	}
+
+	void activated(QModelIndex index)
+	{
+		emit openUrl(index.data(BookmarksModel.UrlRole).toUrl());
+	}
+
+	void build()
+	{
+		clear();
+		for (int i = 0; i < m_bookmarksModel.rowCount(m_root); ++i) {
+			QModelIndex idx = m_bookmarksModel.index(i, 0, m_root);
+			if (m_bookmarksModel.hasChildren(idx)) {
+				QToolButton button = new QToolButton(this);
+				button.setPopupMode(QToolButton.InstantPopup);
+				button.setArrowType(Qt.DownArrow);
+				button.setText(idx.data().toString());
+				ModelMenu menu = new ModelMenu(this);
+				menu.activated.connect(&this.activated);
+				menu.setModel(m_bookmarksModel);
+				menu.setRootIndex(idx);
+				menu.addAction(new QAction(menu));
+				button.setMenu(menu);
+				button.setToolButtonStyle(Qt.ToolButtonTextOnly);
+				QAction a = addWidget(button);
+				a.setText(idx.data().toString());
+			} else {
+				QAction action = addAction(idx.data().toString());
+				action.setData(idx.data(BookmarksModel.UrlRole));
+			}
+		}
+	}
+
+private:
+
+	BookmarksModel m_bookmarksModel;
+	QPersistentModelIndex m_root;
 }

--- a/demos/browser/browsermainwindow.d	Wed May 20 22:44:31 2009 +0000
+++ b/demos/browser/browsermainwindow.d	Fri May 22 10:59:00 2009 +0000
@@ -38,12 +38,29 @@
 ** $QT_END_LICENSE$
 **
 ****************************************************************************/
+module browsermainwindow:
 
-import QtGui.QMainWindow;
-import QtGui.QIcon;
-import QtCore.QUrl;
 
-import browsermainwindow;
+import qt.core.QUrl;
+import qt.core.QSettings;
+import qt.gui.QMainWindow;
+import qt.gui.QIcon;
+import qt.gui.QDesktopWidget;
+import qt.gui.QFileDialog;
+import qt.gui.QPlainTextEdit;
+import qt.gui.QPrintDialog;
+import qt.gui.QPrintPreviewDialog;
+import qt.gui.QPrinter;
+import qt.gui.QMenuBar;
+import qt.gui.QMessageBox;
+import qt.gui.QStatusBar;
+import qt.gui.QToolBar;
+import qt.gui.QInputDialog;
+
+import qt.core.QDebug;
+
+import qt.webkit.QWebFrame;
+import qt.webkit.QWebHistory;
 
 import autosaver;
 import bookmarks;
@@ -54,1020 +71,955 @@
 import settings;
 import tabwidget;
 import toolbarsearch;
+import webview;
 import ui_passworddialog;
-import webview;
-
-import QtCore.QSettings;
-
-import QtGui.QDesktopWidget;
-import QtGui.QFileDialog;
-import QtGui.QPlainTextEdit;
-import QtGui.QPrintDialog;
-import QtGui.QPrintPreviewDialog;
-import QtGui.QPrinter;
-import QtGui.QMenuBar;
-import QtGui.QMessageBox;
-import QtGui.QStatusBar;
-import QtGui.QToolBar;
-import QtGui.QInputDialog;
-
-import QtWebKit.QWebFrame;
-import QtWebKit.QWebHistory;
-
-import QtCore.QDebug;
 
 
-class AutoSaver;
-class BookmarksToolBar;
-class ChaseWidget;
-class QWebFrame;
-class TabWidget;
-class ToolbarSearch;
-class WebView;
+/*!
+The MainWindow of the Browser Application.
 
-/*!
-    The MainWindow of the Browser Application.
-
-    Handles the tab widget and all the actions
- */
-class BrowserMainWindow : public QMainWindow {
-    Q_OBJECT
-	
-static const qint32 BrowserMainWindowMagic = 0xba;
-	
-public:
-    this(QWidget *parent = null, Qt.WindowFlags flags = 0);
+Handles the tab widget and all the actions
+*/
+class BrowserMainWindow : public QMainWindow
 {
 	
-	super(parent, flags);
-	m_tabWidget = new TabWidget(this);
-	m_autoSaver = new AutoSaver(this);
-	m_historyBack = 0;
-	m_historyForward = 0;
-	m_stop = 0;
-	m_reload = 0;
-	
-    setAttribute(Qt.WA_DeleteOnClose, true);
-    statusBar().setSizeGripEnabled(true);
-    setupMenu();
-    setupToolBar();
+static const qint32 BrowserMainWindowMagic = 0xba;
+
+public:
 
-    QWidget *centralWidget = new QWidget(this);
-    BookmarksModel *boomarksModel = BrowserApplication::bookmarksManager().bookmarksModel();
-    m_bookmarksToolbar = new BookmarksToolBar(boomarksModel, this);
-    connect(m_bookmarksToolbar, SIGNAL(openUrl(const QUrl&)),
-            m_tabWidget, SLOT(loadUrlInCurrentTab(const QUrl&)));
-    connect(m_bookmarksToolbar.toggleViewAction(), SIGNAL(toggled(bool)),
-            this, SLOT(updateBookmarksToolbarActionText(bool)));
+	this(QWidget parent = null, Qt.WindowFlags flags = 0);
+	{
+		super(parent, flags);
+		m_tabWidget = new TabWidget(this);
+		m_autoSaver = new AutoSaver(this);
+		m_historyBack = 0;
+		m_historyForward = 0;
+		m_stop = 0;
+		m_reload = 0;
 
-    QVBoxLayout *layout = new QVBoxLayout;
-    layout.setSpacing(0);
-    layout.setMargin(0);
-version(Q_WS_MAC)
-{
-    layout.addWidget(m_bookmarksToolbar);
-    layout.addWidget(new QWidget); // <- OS X tab widget style bug
-} else {
-    addToolBarBreak();
-    addToolBar(m_bookmarksToolbar);
-}
-    layout.addWidget(m_tabWidget);
-    centralWidget.setLayout(layout);
-	setCentralWidget(centralWidget);
+		setAttribute(Qt.WA_DeleteOnClose, true);
+		statusBar().setSizeGripEnabled(true);
+		setupMenu();
+		setupToolBar();
+
+		QWidget centralWidget = new QWidget(this);
+		BookmarksModel boomarksModel = BrowserApplication.bookmarksManager().bookmarksModel();
+		m_bookmarksToolbar = new BookmarksToolBar(boomarksModel, this);
+		m_bookmarksToolba.openUrl.connect(&m_tabWidget.loadUrlInCurrentTab);
+		m_bookmarksToolbar.toggleViewAction.toggled.connect(&thisupdateBookmarksToolbarActionText);
 
-    connect(m_tabWidget, SIGNAL(loadPage(const QString &)),
-        this, SLOT(loadPage(const QString &)));
-    connect(m_tabWidget, SIGNAL(setCurrentTitle(const QString &)),
-        this, SLOT(slotUpdateWindowTitle(const QString &)));
-    connect(m_tabWidget, SIGNAL(showStatusBarMessage(const QString&)),
-            statusBar(), SLOT(showMessage(const QString&)));
-    connect(m_tabWidget, SIGNAL(linkHovered(const QString&)),
-            statusBar(), SLOT(showMessage(const QString&)));
-    connect(m_tabWidget, SIGNAL(loadProgress(int)),
-            this, SLOT(slotLoadProgress(int)));
-    connect(m_tabWidget, SIGNAL(tabsChanged()),
-            m_autoSaver, SLOT(changeOccurred()));
-    connect(m_tabWidget, SIGNAL(geometryChangeRequested(const QRect &)),
-            this, SLOT(geometryChangeRequested(const QRect &)));
-    connect(m_tabWidget, SIGNAL(printRequested(QWebFrame *)),
-            this, SLOT(printRequested(QWebFrame *)));
-    connect(m_tabWidget, SIGNAL(menuBarVisibilityChangeRequested(bool)),
-            menuBar(), SLOT(setVisible(bool)));
-    connect(m_tabWidget, SIGNAL(statusBarVisibilityChangeRequested(bool)),
-            statusBar(), SLOT(setVisible(bool)));
-    connect(m_tabWidget, SIGNAL(toolBarVisibilityChangeRequested(bool)),
-            m_navigationBar, SLOT(setVisible(bool)));
-    connect(m_tabWidget, SIGNAL(toolBarVisibilityChangeRequested(bool)),
-            m_bookmarksToolbar, SLOT(setVisible(bool)));
-version(Q_WS_MAC) {
-    connect(m_tabWidget, SIGNAL(lastTabClosed()),
-            this, SLOT(close()));
-} else {
-    connect(m_tabWidget, SIGNAL(lastTabClosed()),
-            m_tabWidget, SLOT(newTab()));
-}
+		QVBoxLayout layout = new QVBoxLayout;
+		layout.setSpacing(0);
+		layout.setMargin(0);
+		version(Q_WS_MAC)
+		{
+			layout.addWidget(m_bookmarksToolbar);
+			layout.addWidget(new QWidget); // <- OS X tab widget style bug
+		} else {
+			addToolBarBreak();
+			addToolBar(m_bookmarksToolbar);
+		}
+		layout.addWidget(m_tabWidget);
+		centralWidget.setLayout(layout);
+		setCentralWidget(centralWidget);
 
-    slotUpdateWindowTitle();
-    loadDefaultState();
-    m_tabWidget.newTab();
+		m_tabWidget.loadPage.connect(&thisloadPage);
+		m_tabWidget.setCurrentTitle.connect(&this.slotUpdateWindowTitle);
+		m_tabWidget.showStatusBarMessage.connect(&statusBar().showMessage);
+		m_tabWidget.linkHovered.connect(&statusBar().showMessage);
+		m_tabWidget.loadProgress.connect(&this.slotLoadProgress);
+		m_tabWidget.tabsChanged.connect(&m_autoSaver.changeOccurred);
+		m_tabWidget.geometryChangeRequested.connect(&this.geometryChangeRequested);
+		m_tabWidget.printRequested.connect(&this.printRequested);
+		m_tabWidget.menuBarVisibilityChangeRequested.connect(&menuBar().setVisible);
+		m_tabWidget.statusBarVisibilityChangeRequested.connect(&statusBar().setVisible);
+		m_tabWidget.toolBarVisibilityChangeRequested.connect(&m_navigationBar.setVisible);
+		m_tabWidget.toolBarVisibilityChangeRequested.connect(&m_bookmarksToolbar.setVisible);
+		version(Q_WS_MAC) {
+			m_tabWidget.lastTabClosed().connect(&thisclose);
+		} else {
+			m_tabWidget.lastTabClosed().connect(&m_tabWidget.newTab);
+		}
 
-    int size = m_tabWidget.lineEditStack().sizeHint().height();
-    m_navigationBar.setIconSize(QSize(size, size));
+		slotUpdateWindowTitle();
+		loadDefaultState();
+		m_tabWidget.newTab();
 
-}
+		int size = m_tabWidget.lineEditStack().sizeHint().height();
+		m_navigationBar.setIconSize(QSize(size, size));
+	}
 
+	~this()
+	{
+		m_autoSaver.changeOccurred();
+		m_autoSaver.saveIfNeccessary();
+	}
 
 
-   ~this()
-{
-    m_autoSaver.changeOccurred();
-    m_autoSaver.saveIfNeccessary();
-}
-
-
-QSize sizeHint()
-{
-    QRect desktopRect = QApplication::desktop().screenGeometry();
-    QSize size = desktopRect.size() * qreal(0.9);
-    return size;
-}
+	QSize sizeHint()
+	{
+		QRect desktopRect = QApplication.desktop().screenGeometry();
+		QSize size = desktopRect.size() * qreal(0.9);
+		return size;
+	}
 
 public:
-static QUrl guessUrlFromString(const QString &string)
-{
-    QString urlStr = string.trimmed();
-    QRegExp test(QLatin1String("^[a-zA-Z]+\\:.*"));
+
+	static QUrl guessUrlFromString(QString &string)
+	{
+		QString urlStr = string.trimmed();
+		QRegExp test(QLatin1String("^[a-zA-Z]+\\:.*"));
+
+		// Check if it looks like a qualified URL. Try parsing it and see.
+		bool hasSchema = test.exactMatch(urlStr);
+		if (hasSchema) {
+			QUrl url = QUrl.fromEncoded(urlStr.toUtf8(), QUrl.TolerantMode);
+			if (url.isValid())
+				return url;
+		}
 
-    // Check if it looks like a qualified URL. Try parsing it and see.
-    bool hasSchema = test.exactMatch(urlStr);
-    if (hasSchema) {
-        QUrl url = QUrl::fromEncoded(urlStr.toUtf8(), QUrl::TolerantMode);
-        if (url.isValid())
-            return url;
-    }
+		// Might be a file.
+		if (QFile.exists(urlStr)) {
+			QFileInfo info(urlStr);
+			return QUrl.fromLocalFile(info.absoluteFilePath());
+		}
 
-    // Might be a file.
-    if (QFile::exists(urlStr)) {
-        QFileInfo info(urlStr);
-        return QUrl::fromLocalFile(info.absoluteFilePath());
-    }
+		// Might be a shorturl - try to detect the schema.
+		if (!hasSchema) {
+			int dotIndex = urlStr.indexOf(QLatin1Char('.'));
+			if (dotIndex != -1) {
+				QString prefix = urlStr.left(dotIndex).toLower();
+				QByteArray schema = (prefix == QLatin1String("ftp")) ? prefix.toLatin1() : "http";
+				QUrl url =
+				QUrl.fromEncoded(schema + "://" + urlStr.toUtf8(), QUrl.TolerantMode);
+				if (url.isValid())
+					return url;
+			}
+		}
+
+		// Fall back to QUrl's own tolerant parser.
+		QUrl url = QUrl.fromEncoded(string.toUtf8(), QUrl.TolerantMode);
 
-    // Might be a shorturl - try to detect the schema.
-    if (!hasSchema) {
-        int dotIndex = urlStr.indexOf(QLatin1Char('.'));
-        if (dotIndex != -1) {
-            QString prefix = urlStr.left(dotIndex).toLower();
-            QByteArray schema = (prefix == QLatin1String("ftp")) ? prefix.toLatin1() : "http";
-            QUrl url =
-                QUrl::fromEncoded(schema + "://" + urlStr.toUtf8(), QUrl::TolerantMode);
-            if (url.isValid())
-                return url;
-        }
-    }
+		// finally for cases where the user just types in a hostname add http
+		if (url.scheme().isEmpty())
+			url = QUrl.fromEncoded("http://" + string.toUtf8(), QUrl.TolerantMode);
+		return url;
+	}
+
+	TabWidget tabWidget()
+	{
+		return m_tabWidget;
+	}
+
+	WebView currentTab()
+	{
+		return m_tabWidget.currentWebView();
+	}
 
-    // Fall back to QUrl's own tolerant parser.
-    QUrl url = QUrl::fromEncoded(string.toUtf8(), QUrl::TolerantMode);
+	QByteArray saveState(bool withTabs)
+	{
+		int version = 2;
+		QByteArray data;
+		QDataStream stream(&data, QIODevice.WriteOnly);
+
+		stream << qint32(BrowserMainWindowMagic);
+		stream << qint32(version);
 
-    // finally for cases where the user just types in a hostname add http
-    if (url.scheme().isEmpty())
-        url = QUrl::fromEncoded("http://" + string.toUtf8(), QUrl::TolerantMode);
-    return url;
-}
+		stream << size();
+		stream << !m_navigationBar.isHidden();
+		stream << !m_bookmarksToolbar.isHidden();
+		stream << !statusBar().isHidden();
+		if (withTabs)
+			stream << tabWidget().saveState();
+		else
+			stream << QByteArray();
+		return data;
+	}
 
 
+	bool restoreState(QByteArray state)
+	{
+		int version_ = 2;
+		QByteArray sd = state;
+		QDataStream stream(&sd, QIODevice.ReadOnly);
+		if (stream.atEnd())
+			return false;
 
-TabWidget* tabWidget()
-{
-    return m_tabWidget;
-}
+		qint32 marker;
+		qint32 v;
+		stream >> marker;
+		stream >> v;
+		if (marker != BrowserMainWindowMagic || v != version_)
+			return false;
 
-WebView* currentTab()
-{
-    return m_tabWidget.currentWebView();
-}
+		QSize size;
+		bool showToolbar;
+		bool showBookmarksBar;
+		bool showStatusbar;
+		QByteArray tabState;
 
-QByteArray saveState(bool withTabs)
-{
-    int version = 2;
-    QByteArray data;
-    QDataStream stream(&data, QIODevice::WriteOnly);
+		stream >> size;
+		stream >> showToolbar;
+		stream >> showBookmarksBar;
+		stream >> showStatusbar;
+		stream >> tabState;
 
-    stream << qint32(BrowserMainWindowMagic);
-    stream << qint32(version);
+		resize(size);
+
+		m_navigationBar.setVisible(showToolbar);
+		updateToolbarActionText(showToolbar);
+
+		m_bookmarksToolbar.setVisible(showBookmarksBar);
+		updateBookmarksToolbarActionText(showBookmarksBar);
 
-    stream << size();
-    stream << !m_navigationBar.isHidden();
-    stream << !m_bookmarksToolbar.isHidden();
-    stream << !statusBar().isHidden();
-    if (withTabs)
-        stream << tabWidget().saveState();
-    else
-        stream << QByteArray();
-    return data;
-}
+		statusBar().setVisible(showStatusbar);
+		updateStatusbarActionText(showStatusbar);
+
+		if (!tabWidget().restoreState(tabState))
+			return false;
+
+		return true;
+	}
+
+public:
+
+	void loadPage(QString page)
+	{
+		QUrl url = guessUrlFromString(page);
+		loadUrl(url);
+	}
 
 
-    bool restoreState(const QByteArray &state)
-{
-    int version = 2;
-    QByteArray sd = state;
-    QDataStream stream(&sd, QIODevice::ReadOnly);
-    if (stream.atEnd())
-        return false;
-
-    qint32 marker;
-    qint32 v;
-    stream >> marker;
-    stream >> v;
-    if (marker != BrowserMainWindowMagic || v != version)
-        return false;
-
-    QSize size;
-    bool showToolbar;
-    bool showBookmarksBar;
-    bool showStatusbar;
-    QByteArray tabState;
-
-    stream >> size;
-    stream >> showToolbar;
-    stream >> showBookmarksBar;
-    stream >> showStatusbar;
-    stream >> tabState;
-
-    resize(size);
-
-    m_navigationBar.setVisible(showToolbar);
-    updateToolbarActionText(showToolbar);
-
-    m_bookmarksToolbar.setVisible(showBookmarksBar);
-    updateBookmarksToolbarActionText(showBookmarksBar);
-
-    statusBar().setVisible(showStatusbar);
-    updateStatusbarActionText(showStatusbar);
-
-    if (!tabWidget().restoreState(tabState))
-        return false;
-
-    return true;
-}
-
-
-public slots:
-void loadPage(const QString &page)
-{
-    QUrl url = guessUrlFromString(page);
-    loadUrl(url);
-}
-
-
-void slotHome()
-{
-    QSettings settings;
-    settings.beginGroup(QLatin1String("MainWindow"));
-    QString home = settings.value(QLatin1String("home"), QLatin1String("http://qtsoftware.com/")).toString();
-    loadPage(home);
-}
+	void slotHome()
+	{
+		QSettings settings;
+		settings.beginGroup(QLatin1String("MainWindow"));
+		QString home = settings.value(QLatin1String("home"), QLatin1String("http://qtsoftware.com/")).toString();
+		loadPage(home);
+	}
 
 protected:
-    void closeEvent(QCloseEvent *event);
-{
-    if (m_tabWidget.count() > 1) {
-        int ret = QMessageBox.warning(this, QString(),
-                           tr("Are you sure you want to close the window?"
-                              "  There are %1 tab open").arg(m_tabWidget.count()),
-                           QMessageBox.Yes | QMessageBox.No,
-                           QMessageBox.No);
-        if (ret == QMessageBox.No) {
-            event.ignore();
-            return;
-        }
-    }
-    event.accept();
-    deleteLater();
-}
+
+	void closeEvent(QCloseEvent event);
+	{
+		if (m_tabWidget.count() > 1) {
+			int ret = QMessageBox.warning(this, QString(),
+				   tr("Are you sure you want to close the window?"
+				      "  There are %1 tab open").arg(m_tabWidget.count()),
+				   QMessageBox.Yes | QMessageBox.No,
+				   QMessageBox.No);
+			if (ret == QMessageBox.No) {
+				event.ignore();
+				return;
+			}
+		}
+		event.accept();
+		deleteLater();
+	}
+
+private:
+
+	void save()
+	{
+		BrowserApplication.instance().saveSession();
+
+		QSettings settings;
+		settings.beginGroup(QLatin1String("BrowserMainWindow"));
+		QByteArray data = saveState(false);
+		settings.setValue(QLatin1String("defaultState"), data);
+		settings.endGroup();
+	}
 
-private slots:
-void save()
-{
-    BrowserApplication::instance().saveSession();
+	void slotLoadProgress(int progress)
+	{
+		if (progress < 100 && progress > 0) {
+			m_chaseWidget.setAnimated(true);
+			m_stopReload.triggered.disconnect(&m_reload.trigger);
+			if (m_stopIcon.isNull())
+				m_stopIcon = style().standardIcon(QStyle.SP_BrowserStop);
+			m_stopReload.setIcon(m_stopIcon);
+			m_stopReload.triggered.connect(&m_stop.trigger);
+			m_stopReload.setToolTip(tr("Stop loading the current page"));
+		} else {
+			m_chaseWidget.setAnimated(false);
+			m_stopReload.triggered.disconnect(m_stop.trigger);
+			m_stopReload.setIcon(m_reloadIcon);
+			m_stopReload.triggered.connect(&m_reload.trigger);
+			m_stopReload.setToolTip(tr("Reload the current page"));
+		}
+	}
+
+	void slotUpdateStatusbar(QString &string);
+	{
+		statusBar().showMessage(string, 2000);
+	}
+
+	void slotUpdateWindowTitle(QString &title = QString())
+	{
+		if (title.isEmpty()) {
+			setWindowTitle(tr("Qt Demo Browser"));
+		} else {
+			version(Q_WS_MAC)
+			{
+				setWindowTitle(title);
+			} else {
+				setWindowTitle(tr("%1 - Qt Demo Browser", "Page title and Browser name").arg(title));
+			}
+		}
+	}
+
+	void loadUrl(QUrl &url);
+	{
+		if (!currentTab() || !url.isValid())
+			return;
+
+			m_tabWidget.currentLineEdit().setText(QString.fromUtf8(url.toEncoded()));
+			m_tabWidget.loadUrlInCurrentTab(url);
+	}
+
+	void slotPreferences()
+	{
+		SettingsDialog s = new SettingsDialog(this);
+		s.show();
+	}
+
+	void slotFileNew()
+	{
+		BrowserApplication.instance().newMainWindow();
+		BrowserMainWindow mw = BrowserApplication.instance().mainWindow();
+		mw.slotHome();
+	}
 
-    QSettings settings;
-    settings.beginGroup(QLatin1String("BrowserMainWindow"));
-    QByteArray data = saveState(false);
-    settings.setValue(QLatin1String("defaultState"), data);
-    settings.endGroup();
-}
+	void slotFileOpen()
+	{
+		QString file = QFileDialog.getOpenFileName(this, tr("Open Web Resource"), QString(),
+		tr("Web Resources (*.html *.htm *.svg *.png *.gif *.svgz);;All files (*.*)"));
+
+		if (file.isEmpty())
+			return;
+
+		loadPage(file);
+	}
+
+	void slotFilePrintPreview();
+	{
+		version(QT_NO_PRINTER)
+		{
+			if (!currentTab())
+				return;
+			QPrintPreviewDialog dialog = new QPrintPreviewDialog(this);
+			dialog.paintRequested.connect(&currentTab.print);
+			dialog.exec();
+		}
+	}
+
+	void slotFilePrint()
+	{
+		if (!currentTab())
+			return;
+		printRequested(currentTab().page().mainFrame());
+	}
+
+	void slotPrivateBrowsing()
+	{
+		QWebSettings settings = QWebSettings.globalSettings();
+		bool pb = settings.testAttribute(QWebSettings.PrivateBrowsingEnabled);
+		if (!pb) {
+			QString title = tr("Are you sure you want to turn on private browsing?");
+			QString text = tr("<b>%1</b><br><br>When private browsing in turned on,"
+			" webpages are not added to the history,"
+			" items are automatically removed from the Downloads window," \
+			" new cookies are not stored, current cookies can't be accessed," \
+			" site icons wont be stored, session wont be saved, " \
+			" and searches are not addded to the pop-up menu in the Google search box." \
+			"  Until you close the window, you can still click the Back and Forward buttons" \
+			" to return to the webpages you have opened.").arg(title);
 
-void slotLoadProgress(int progress)
-{
-    if (progress < 100 && progress > 0) {
-        m_chaseWidget.setAnimated(true);
-        disconnect(m_stopReload, SIGNAL(triggered()), m_reload, SLOT(trigger()));
-        if (m_stopIcon.isNull())
-            m_stopIcon = style().standardIcon(QStyle::SP_BrowserStop);
-        m_stopReload.setIcon(m_stopIcon);
-        connect(m_stopReload, SIGNAL(triggered()), m_stop, SLOT(trigger()));
-        m_stopReload.setToolTip(tr("Stop loading the current page"));
-    } else {
-        m_chaseWidget.setAnimated(false);
-        disconnect(m_stopReload, SIGNAL(triggered()), m_stop, SLOT(trigger()));
-        m_stopReload.setIcon(m_reloadIcon);
-        connect(m_stopReload, SIGNAL(triggered()), m_reload, SLOT(trigger()));
-        m_stopReload.setToolTip(tr("Reload the current page"));
-    }
-}
+			QMessageBox.StandardButton button = QMessageBox.question(this, QString(), text,
+			       QMessageBox.Ok | QMessageBox.Cancel,
+			       QMessageBox.Ok);
+			if (button == QMessageBox.Ok) {
+				settings.setAttribute(QWebSettings.PrivateBrowsingEnabled, true);
+			}
+		} else {
+			settings.setAttribute(QWebSettings.PrivateBrowsingEnabled, false);
+
+			QList<BrowserMainWindow*> windows = BrowserApplication.instance().mainWindows();
+			for (int i = 0; i < windows.count(); ++i) {
+				BrowserMainWindow window = windows.at(i);
+				window.m_lastSearch = QString.null;
+				window.tabWidget().clear();
+			}
+		}
+	}
+
+	void slotFileSaveAs()
+	{
+		BrowserApplication.downloadManager().download(currentTab().url(), true);
+	}
 
-    void slotUpdateStatusbar(const QString &string);
-{
-    statusBar().showMessage(string, 2000);
-}
+	void slotEditFind()
+	{
+		if (!currentTab())
+			return;
+		bool ok;
+		QString search = QInputDialog.getText(this, tr("Find"),
+			tr("Text:"), QLineEdit.Normal, m_lastSearch, &ok);
+		if (ok && !search.isEmpty()) {
+			m_lastSearch = search;
+			if (!currentTab().findText(m_lastSearch))
+				slotUpdateStatusbar(tr("\"%1\" not found.").arg(m_lastSearch));
+		}
+	}
+
+	void slotEditFindNext()
+	{
+		if (!currentTab() && !m_lastSearch.isEmpty())
+			return;
+		currentTab().findText(m_lastSearch);
+	}
+
+	void slotEditFindPrevious()
+	{
+		if (!currentTab() && !m_lastSearch.isEmpty())
+			return;
+		currentTab().findText(m_lastSearch, QWebPage.FindBackward);
+	}
 
 
-    void slotUpdateWindowTitle(const QString &title = QString())
-{
-    if (title.isEmpty()) {
-        setWindowTitle(tr("Qt Demo Browser"));
-    } else {
-version(Q_WS_MAC)
-{
-        setWindowTitle(title);
-} else {
-        setWindowTitle(tr("%1 - Qt Demo Browser", "Page title and Browser name").arg(title));
-}
-    }
-}
-
-    void loadUrl(const QUrl &url);
-{
-    if (!currentTab() || !url.isValid())
-        return;
-
-    m_tabWidget.currentLineEdit().setText(QString::fromUtf8(url.toEncoded()));
-    m_tabWidget.loadUrlInCurrentTab(url);
-}
-
-    void slotPreferences()
-{
-    SettingsDialog *s = new SettingsDialog(this);
-    s.show();
-}
+	void slotShowBookmarksDialog();
+	{
+		BookmarksDialog dialog = new BookmarksDialog(this);
+		dialog.openUrl.connect(&m_tabWidget.loadUrlInCurrentTab);
+		dialog.show();
+	}
 
-void slotFileNew()
-{
-    BrowserApplication::instance().newMainWindow();
-    BrowserMainWindow *mw = BrowserApplication::instance().mainWindow();
-    mw.slotHome();
-}
-
-void slotFileOpen()
-{
-    QString file = QFileDialog::getOpenFileName(this, tr("Open Web Resource"), QString(),
-            tr("Web Resources (*.html *.htm *.svg *.png *.gif *.svgz);;All files (*.*)"));
-
-    if (file.isEmpty())
-        return;
+	void slotAddBookmark()
+	{
+		WebView webView = currentTab();
+		QString url = webView.url().toString();
+		QString title = webView.title();
+		AddBookmarkDialog dialog(url, title);
+		dialog.exec();
+	}
 
-    loadPage(file);
-}
-
-    void slotFilePrintPreview();
-{
-version(QT_NO_PRINTER)
+	void slotViewZoomIn()
 	{
-    if (!currentTab())
-        return;
-    QPrintPreviewDialog *dialog = new QPrintPreviewDialog(this);
-    connect(dialog, SIGNAL(paintRequested(QPrinter *)),
-            currentTab(), SLOT(print(QPrinter *)));
-    dialog.exec();
-}
-}
-
+		if (!currentTab())
+			return;
+		currentTab().setZoomFactor(currentTab().zoomFactor() + 0.1);
+	}
 
-    void slotFilePrint()
-{
-    if (!currentTab())
-        return;
-    printRequested(currentTab().page().mainFrame());
-}
+	void BslotViewZoomOut()
+	{
+		if (!currentTab())
+			return;
+		currentTab().setZoomFactor(currentTab().zoomFactor() - 0.1);
+	}
 
-    void slotPrivateBrowsing()
-{
-    QWebSettings *settings = QWebSettings::globalSettings();
-    bool pb = settings.testAttribute(QWebSettings::PrivateBrowsingEnabled);
-    if (!pb) {
-        QString title = tr("Are you sure you want to turn on private browsing?");
-        QString text = tr("<b>%1</b><br><br>When private browsing in turned on,"
-            " webpages are not added to the history,"
-            " items are automatically removed from the Downloads window," \
-            " new cookies are not stored, current cookies can't be accessed," \
-            " site icons wont be stored, session wont be saved, " \
-            " and searches are not addded to the pop-up menu in the Google search box." \
-            "  Until you close the window, you can still click the Back and Forward buttons" \
-            " to return to the webpages you have opened.").arg(title);
-
-        QMessageBox.StandardButton button = QMessageBox.question(this, QString(), text,
-                               QMessageBox.Ok | QMessageBox.Cancel,
-                               QMessageBox.Ok);
-        if (button == QMessageBox.Ok) {
-            settings.setAttribute(QWebSettings::PrivateBrowsingEnabled, true);
-        }
-    } else {
-        settings.setAttribute(QWebSettings::PrivateBrowsingEnabled, false);
+	void slotViewResetZoom()
+	{
+		if (!currentTab())
+			return;
+		currentTab().setZoomFactor(1.0);
+	}
 
-        QList<BrowserMainWindow*> windows = BrowserApplication::instance().mainWindows();
-        for (int i = 0; i < windows.count(); ++i) {
-            BrowserMainWindow *window = windows.at(i);
-            window.m_lastSearch = QString::null;
-            window.tabWidget().clear();
-        }
-    }
-}
-
-    void slotFileSaveAs()
-{
-    BrowserApplication::downloadManager().download(currentTab().url(), true);
-}
+	void slotViewZoomTextOnly(bool enable)
+	{
+		if (!currentTab())
+			return;
+		currentTab().page().settings().setAttribute(QWebSettings.ZoomTextOnly, enable);
+	}
 
-    void slotEditFind()
-{
-    if (!currentTab())
-        return;
-    bool ok;
-    QString search = QInputDialog::getText(this, tr("Find"),
-                                          tr("Text:"), QLineEdit::Normal,
-                                          m_lastSearch, &ok);
-    if (ok && !search.isEmpty()) {
-        m_lastSearch = search;
-        if (!currentTab().findText(m_lastSearch))
-            slotUpdateStatusbar(tr("\"%1\" not found.").arg(m_lastSearch));
-    }
-}
-
-void slotEditFindNext()
-{
-    if (!currentTab() && !m_lastSearch.isEmpty())
-        return;
-    currentTab().findText(m_lastSearch);
-}
-
-void slotEditFindPrevious()
-{
-    if (!currentTab() && !m_lastSearch.isEmpty())
-        return;
-    currentTab().findText(m_lastSearch, QWebPage::FindBackward);
-}
+	void slotViewToolbar()
+	{
+		if (m_navigationBar.isVisible()) {
+			updateToolbarActionText(false);
+			m_navigationBar.close();
+		} else {
+			updateToolbarActionText(true);
+			m_navigationBar.show();
+		}
+		m_autoSaver.changeOccurred();
+	}
 
 
-    void slotShowBookmarksDialog();
-{
-    BookmarksDialog *dialog = new BookmarksDialog(this);
-    connect(dialog, SIGNAL(openUrl(const QUrl&)),
-            m_tabWidget, SLOT(loadUrlInCurrentTab(const QUrl&)));
-    dialog.show();
-}
-
-void slotAddBookmark()
-{
-    WebView *webView = currentTab();
-    QString url = webView.url().toString();
-    QString title = webView.title();
-    AddBookmarkDialog dialog(url, title);
-    dialog.exec();
-}
-
-void slotViewZoomIn()
-{
-    if (!currentTab())
-        return;
-    currentTab().setZoomFactor(currentTab().zoomFactor() + 0.1);
-}
-
-void BslotViewZoomOut()
-{
-    if (!currentTab())
-        return;
-    currentTab().setZoomFactor(currentTab().zoomFactor() - 0.1);
-}
-
-void slotViewResetZoom()
-{
-    if (!currentTab())
-        return;
-    currentTab().setZoomFactor(1.0);
-}
-
-void slotViewZoomTextOnly(bool enable)
-{
-    if (!currentTab())
-        return;
-    currentTab().page().settings().setAttribute(QWebSettings::ZoomTextOnly, enable);
-}
-
-
-    void slotViewToolbar()
-{
-    if (m_navigationBar.isVisible()) {
-        updateToolbarActionText(false);
-        m_navigationBar.close();
-    } else {
-        updateToolbarActionText(true);
-        m_navigationBar.show();
-    }
-    m_autoSaver.changeOccurred();
-}
-
+	void slotViewBookmarksBar()
+	{
+		if (m_bookmarksToolbar.isVisible()) {
+			updateBookmarksToolbarActionText(false);
+			m_bookmarksToolbar.close();
+		} else {
+			updateBookmarksToolbarActionText(true);
+			m_bookmarksToolbar.show();
+		}
+		m_autoSaver.changeOccurred();
+	}
 
-    void slotViewBookmarksBar()
-{
-    if (m_bookmarksToolbar.isVisible()) {
-        updateBookmarksToolbarActionText(false);
-        m_bookmarksToolbar.close();
-    } else {
-        updateBookmarksToolbarActionText(true);
-        m_bookmarksToolbar.show();
-    }
-    m_autoSaver.changeOccurred();
-}
-
-    void slotViewStatusbar()
-{
-    if (statusBar().isVisible()) {
-        updateStatusbarActionText(false);
-        statusBar().close();
-    } else {
-        updateStatusbarActionText(true);
-        statusBar().show();
-    }
-    m_autoSaver.changeOccurred();
-}
-
-void slotViewPageSource()
-{
-    if (!currentTab())
-        return;
+	void slotViewStatusbar()
+	{
+		if (statusBar().isVisible()) {
+			updateStatusbarActionText(false);
+			statusBar().close();
+		} else {
+			updateStatusbarActionText(true);
+			statusBar().show();
+		}
+		m_autoSaver.changeOccurred();
+	}
 
-    QString markup = currentTab().page().mainFrame().toHtml();
-    QPlainTextEdit *view = new QPlainTextEdit(markup);
-    view.setWindowTitle(tr("Page Source of %1").arg(currentTab().title()));
-    view.setMinimumWidth(640);
-    view.setAttribute(Qt.WA_DeleteOnClose);
-    view.show();
-}
-
+	void slotViewPageSource()
+	{
+		if (!currentTab())
+			return;
 
-void slotViewFullScreen(bool makeFullScreen)
-{
-    if (makeFullScreen) {
-        showFullScreen();
-    } else {
-        if (isMinimized())
-            showMinimized();
-        else if (isMaximized())
-            showMaximized();
-        else showNormal();
-    }
-}
-
-void slotWebSearch()
-{
-    m_toolbarSearch.lineEdit().selectAll();
-    m_toolbarSearch.lineEdit().setFocus();
-}
-
-
-    void slotToggleInspector(bool enable);
-{
-    QWebSettings::globalSettings().setAttribute(QWebSettings::DeveloperExtrasEnabled, enable);
-    if (enable) {
-        int result = QMessageBox.question(this, tr("Web Inspector"),
-                                           tr("The web inspector will only work correctly for pages that were loaded after enabling.\n"
-                                           "Do you want to reload all pages?"),
-                                           QMessageBox.Yes | QMessageBox.No);
-        if (result == QMessageBox.Yes) {
-            m_tabWidget.reloadAllTabs();
-        }
-    }
-}
+		QString markup = currentTab().page().mainFrame().toHtml();
+		QPlainTextEdit view = new QPlainTextEdit(markup);
+		view.setWindowTitle(tr("Page Source of %1").arg(currentTab().title()));
+		view.setMinimumWidth(640);
+		view.setAttribute(Qt.WA_DeleteOnClose);
+		view.show();
+	}
 
 
-    void slotAboutApplication()
-{
-    QMessageBox.about(this, tr("About"), tr(
-        "Version %1"
-        "<p>This demo demonstrates Qt's "
-        "webkit facilities in action, providing an example "
-        "browser for you to experiment with.<p>"
-        "<p>QtWebKit is based on the Open Source WebKit Project developed at <a href=\"http://webkit.org/\">http://webkit.org/</a>."
-        ).arg(QCoreApplication::applicationVersion()));
-}
+	void slotViewFullScreen(bool makeFullScreen)
+	{
+		if (makeFullScreen) {
+			showFullScreen();
+		} else {
+			if (isMinimized())
+				showMinimized();
+			else if (isMaximized())
+				showMaximized();
+			else showNormal();
+		}
+	}
 
-    void slotDownloadManager()
-{
-    BrowserApplication::downloadManager().show();
-}
+	void slotWebSearch()
+	{
+		m_toolbarSearch.lineEdit().selectAll();
+		m_toolbarSearch.lineEdit().setFocus();
+	}
+
+	void slotToggleInspector(bool enable);
+	{
+		QWebSettings.globalSettings().setAttribute(QWebSettings.DeveloperExtrasEnabled, enable);
+		if (enable) {
+			int result = QMessageBox.question(this, tr("Web Inspector"),
+						   tr("The web inspector will only work correctly for pages that were loaded after enabling.\n"
+						   "Do you want to reload all pages?"),
+						   QMessageBox.Yes | QMessageBox.No);
+			if (result == QMessageBox.Yes) {
+				m_tabWidget.reloadAllTabs();
+			}
+		}
+	}
 
-    void slotSelectLineEdit();
-{
-    m_tabWidget.currentLineEdit().selectAll();
-    m_tabWidget.currentLineEdit().setFocus();
-}
+	void slotAboutApplication()
+	{
+		QMessageBox.about(this, tr("About"), tr(
+			"Version %1"
+			"<p>This demo demonstrates Qt's "
+			"webkit facilities in action, providing an example "
+			"browser for you to experiment with.<p>"
+			"<p>QtWebKit is based on the Open Source WebKit Project developed at <a href=\"http://webkit.org/\">http://webkit.org/</a>."
+			).arg(QCoreApplication.applicationVersion()));
+	}
+
+	void slotDownloadManager()
+	{
+		BrowserApplication.downloadManager().show();
+	}
 
-    void slotAboutToShowBackMenu();
-{
-    m_historyBackMenu.clear();
-    if (!currentTab())
-        return;
-    QWebHistory *history = currentTab().history();
-    int historyCount = history.count();
-    for (int i = history.backItems(historyCount).count() - 1; i >= 0; --i) {
-        QWebHistoryItem item = history.backItems(history.count()).at(i);
-        QAction *action = new QAction(this);
-        action.setData(-1*(historyCount-i-1));
-        QIcon icon = BrowserApplication::instance().icon(item.url());
-        action.setIcon(icon);
-        action.setText(item.title());
-        m_historyBackMenu.addAction(action);
-    }
-}
+	void slotSelectLineEdit();
+	{
+		m_tabWidget.currentLineEdit().selectAll();
+		m_tabWidget.currentLineEdit().setFocus();
+	}
+
+	void slotAboutToShowBackMenu();
+	{
+		m_historyBackMenu.clear();
+		if (!currentTab())
+			return;
+		QWebHistory history = currentTab().history();
+		int historyCount = history.count();
+		for (int i = history.backItems(historyCount).count() - 1; i >= 0; --i) {
+			QWebHistoryItem item = history.backItems(history.count()).at(i);
+			QAction action = new QAction(this);
+			action.setData(-1*(historyCount-i-1));
+			QIcon icon = BrowserApplication.instance().icon(item.url());
+			action.setIcon(icon);
+			action.setText(item.title());
+			m_historyBackMenu.addAction(action);
+		}
+	}
 
 
-    void slotAboutToShowForwardMenu();
-{
-    m_historyForwardMenu.clear();
-    if (!currentTab())
-        return;
-    QWebHistory *history = currentTab().history();
-    int historyCount = history.count();
-    for (int i = 0; i < history.forwardItems(history.count()).count(); ++i) {
-        QWebHistoryItem item = history.forwardItems(historyCount).at(i);
-        QAction *action = new QAction(this);
-        action.setData(historyCount-i);
-        QIcon icon = BrowserApplication::instance().icon(item.url());
-        action.setIcon(icon);
-        action.setText(item.title());
-        m_historyForwardMenu.addAction(action);
-    }
-}
+	void slotAboutToShowForwardMenu();
+	{
+		m_historyForwardMenu.clear();
+		if (!currentTab())
+			return;
+		QWebHistory history = currentTab().history();
+		int historyCount = history.count();
+		for (int i = 0; i < history.forwardItems(history.count()).count(); ++i) {
+			QWebHistoryItem item = history.forwardItems(historyCount).at(i);
+			QAction action = new QAction(this);
+			action.setData(historyCount-i);
+			QIcon icon = BrowserApplication.instance().icon(item.url());
+			action.setIcon(icon);
+			action.setText(item.title());
+			m_historyForwardMenu.addAction(action);
+		}
+	}
 
-    void slotAboutToShowWindowMenu()
-{
-    m_windowMenu.clear();
-    m_windowMenu.addAction(m_tabWidget.nextTabAction());
-    m_windowMenu.addAction(m_tabWidget.previousTabAction());
-    m_windowMenu.addSeparator();
-    m_windowMenu.addAction(tr("Downloads"), this, SLOT(slotDownloadManager()), QKeySequence(tr("Alt+Ctrl+L", "Download Manager")));
+	void slotAboutToShowWindowMenu()
+	{
+		m_windowMenu.clear();
+		m_windowMenu.addAction(m_tabWidget.nextTabAction());
+		m_windowMenu.addAction(m_tabWidget.previousTabAction());
+		m_windowMenu.addSeparator();
+		m_windowMenu.addAction(tr("Downloads"), this, SLOT(slotDownloadManager()), QKeySequence(tr("Alt+Ctrl+L", "Download Manager")));
 
-    m_windowMenu.addSeparator();
-    QList<BrowserMainWindow*> windows = BrowserApplication::instance().mainWindows();
-    for (int i = 0; i < windows.count(); ++i) {
-        BrowserMainWindow *window = windows.at(i);
-        QAction *action = m_windowMenu.addAction(window.windowTitle(), this, SLOT(slotShowWindow()));
-        action.setData(i);
-        action.setCheckable(true);
-        if (window == this)
-            action.setChecked(true);
-    }
-}
+		m_windowMenu.addSeparator();
+		QList<BrowserMainWindow*> windows = BrowserApplication.instance().mainWindows();
+		for (int i = 0; i < windows.count(); ++i) {
+			BrowserMainWindow window = windows.at(i);
+			QAction action = m_windowMenu.addAction(window.windowTitle(), this, SLOT(slotShowWindow()));
+			action.setData(i);
+			action.setCheckable(true);
+			if (window == this)
+			action.setChecked(true);
+		}
+	}
 
-    void slotOpenActionUrl(QAction *action)
-{
-    int offset = action.data().toInt();
-    QWebHistory *history = currentTab().history();
-    if (offset < 0)
-        history.goToItem(history.backItems(-1*offset).first()); // back
-    else if (offset > 0)
-        history.goToItem(history.forwardItems(history.count() - offset + 1).back()); // forward
- }
-    void slotShowWindow()
-{
-    if (QAction *action = qobject_cast<QAction*>(sender())) {
-        QVariant v = action.data();
-        if (v.canConvert<int>()) {
-            int offset = qvariant_cast<int>(v);
-            QList<BrowserMainWindow*> windows = BrowserApplication::instance().mainWindows();
-            windows.at(offset).activateWindow();
-            windows.at(offset).currentTab().setFocus();
-        }
-    }
-}
+	void slotOpenActionUrl(QAction action)
+	{
+		int offset = action.data().toInt();
+		QWebHistory history = currentTab().history();
+		if (offset < 0)
+			history.goToItem(history.backItems(-1*offset).first()); // back
+		else if (offset > 0)
+			history.goToItem(history.forwardItems(history.count() - offset + 1).back()); // forward
+	}
+
+	void slotShowWindow()
+	{
+		if (QAction action = qobject_cast<QAction*>(sender())) {
+			QVariant v = action.data();
+			if (v.canConvert<int>()) {
+				int offset = qvariant_cast<int>(v);
+				QList<BrowserMainWindow*> windows = BrowserApplication.instance().mainWindows();
+				windows.at(offset).activateWindow();
+				windows.at(offset).currentTab().setFocus();
+			}
+		}
+	}
 
-void slotSwapFocus()
-{
-    if (currentTab().hasFocus())
-        m_tabWidget.currentLineEdit().setFocus();
-    else
-        currentTab().setFocus();
-}
+	void slotSwapFocus()
+	{
+		if (currentTab().hasFocus())
+			m_tabWidget.currentLineEdit().setFocus();
+		else
+			currentTab().setFocus();
+	}
 
-void printRequested(QWebFrame *frame)
-{
-	version(QT_NO_PRINTER)
+	void printRequested(QWebFrame frame)
 	{
-		QPrinter printer;
-		QPrintDialog *dialog = new QPrintDialog(&printer, this);
-		dialog.setWindowTitle(tr("Print Document"));
-		if (dialog.exec() != QDialog::Accepted)
-			return;
-		frame.print(&printer);
+		version(QT_NO_PRINTER)
+		{
+			QPrinter printer;
+			QPrintDialog dialog = new QPrintDialog(&printer, this);
+			dialog.setWindowTitle(tr("Print Document"));
+			if (dialog.exec() != QDialog.Accepted)
+				return;
+			frame.print(&printer);
+		}
 	}
-}
 
-    void geometryChangeRequested(const QRect &geometry)
-{
-    setGeometry(geometry);
-}
+	void geometryChangeRequested(QRect &geometry)
+	{
+		setGeometry(geometry);
+	}
 
 
-    void updateToolbarActionText(bool visible)
-{
-    m_viewToolbar.setText(!visible ? tr("Show Toolbar") : tr("Hide Toolbar"));
-}
+	void updateToolbarActionText(bool visible)
+	{
+		m_viewToolbar.setText(!visible ? tr("Show Toolbar") : tr("Hide Toolbar"));
+	}
     
-    void updateBookmarksToolbarActionText(bool visible)
-{
-    m_viewBookmarkBar.setText(!visible ? tr("Show Bookmarks bar") : tr("Hide Bookmarks bar"));
-}
-
+	void updateBookmarksToolbarActionText(bool visible)
+	{
+		m_viewBookmarkBar.setText(!visible ? tr("Show Bookmarks bar") : tr("Hide Bookmarks bar"));
+	}
 
 private:
-void loadDefaultState()
-{
-    QSettings settings;
-    settings.beginGroup(QLatin1String("BrowserMainWindow"));
-    QByteArray data = settings.value(QLatin1String("defaultState")).toByteArray();
-    restoreState(data);
-    settings.endGroup();
-}
 
+	void loadDefaultState()
+	{
+		QSettings settings;
+		settings.beginGroup(QLatin1String("BrowserMainWindow"));
+		QByteArray data = settings.value(QLatin1String("defaultState")).toByteArray();
+		restoreState(data);
+		settings.endGroup();
+	}
 
-    void setupMenu();
-{
-    new QShortcut(QKeySequence(Qt.Key_F6), this, SLOT(slotSwapFocus()));
+	void setupMenu();
+	{
+		new QShortcut(QKeySequence(Qt.Key_F6), this, SLOT(slotSwapFocus()));
 
-    // File
-    QMenu *fileMenu = menuBar().addMenu(tr("&File"));
+		// File
+		QMenu fileMenu = menuBar().addMenu(tr("&File"));
 
-    fileMenu.addAction(tr("&New Window"), this, SLOT(slotFileNew()), QKeySequence::New);
-    fileMenu.addAction(m_tabWidget.newTabAction());
-    fileMenu.addAction(tr("&Open File..."), this, SLOT(slotFileOpen()), QKeySequence::Open);
-    fileMenu.addAction(tr("Open &Location..."), this,
-                SLOT(slotSelectLineEdit()), QKeySequence(Qt.ControlModifier + Qt.Key_L));
-    fileMenu.addSeparator();
-    fileMenu.addAction(m_tabWidget.closeTabAction());
-    fileMenu.addSeparator();
-    fileMenu.addAction(tr("&Save As..."), this,
-                SLOT(slotFileSaveAs()), QKeySequence(QKeySequence::Save));
-    fileMenu.addSeparator();
-    BookmarksManager *bookmarksManager = BrowserApplication::bookmarksManager();
-    fileMenu.addAction(tr("&Import Bookmarks..."), bookmarksManager, SLOT(importBookmarks()));
-    fileMenu.addAction(tr("&Export Bookmarks..."), bookmarksManager, SLOT(exportBookmarks()));
-    fileMenu.addSeparator();
-    fileMenu.addAction(tr("P&rint Preview..."), this, SLOT(slotFilePrintPreview()));
-    fileMenu.addAction(tr("&Print..."), this, SLOT(slotFilePrint()), QKeySequence::Print);
-    fileMenu.addSeparator();
-    QAction *action = fileMenu.addAction(tr("Private &Browsing..."), this, SLOT(slotPrivateBrowsing()));
-    action.setCheckable(true);
-    fileMenu.addSeparator();
+		fileMenu.addAction(tr("&New Window"), this, SLOT(slotFileNew()), QKeySequence.New);
+		fileMenu.addAction(m_tabWidget.newTabAction());
+		fileMenu.addAction(tr("&Open File..."), this, SLOT(slotFileOpen()), QKeySequence.Open);
+		fileMenu.addAction(tr("Open &Location..."), this, SLOT(slotSelectLineEdit()), QKeySequence(Qt.ControlModifier + Qt.Key_L));
+		fileMenu.addSeparator();
+		fileMenu.addAction(m_tabWidget.closeTabAction());
+		fileMenu.addSeparator();
+		fileMenu.addAction(tr("&Save As..."), this,  SLOT(slotFileSaveAs()), QKeySequence(QKeySequence.Save));
+		fileMenu.addSeparator();
+		BookmarksManager bookmarksManager = BrowserApplication.bookmarksManager();
+		fileMenu.addAction(tr("&Import Bookmarks..."), bookmarksManager, SLOT(importBookmarks()));
+		fileMenu.addAction(tr("&Export Bookmarks..."), bookmarksManager, SLOT(exportBookmarks()));
+		fileMenu.addSeparator();
+		fileMenu.addAction(tr("P&rint Preview..."), this, SLOT(slotFilePrintPreview()));
+		fileMenu.addAction(tr("&Print..."), this, SLOT(slotFilePrint()), QKeySequence.Print);
+		fileMenu.addSeparator();
+		QAction action = fileMenu.addAction(tr("Private &Browsing..."), this, SLOT(slotPrivateBrowsing()));
+		action.setCheckable(true);
+		fileMenu.addSeparator();
 
-version(Q_WS_MAC) {
-    fileMenu.addAction(tr("&Quit"), BrowserApplication::instance(), SLOT(quitBrowser()), QKeySequence(Qt.CTRL | Qt.Key_Q));
-} else {
-    fileMenu.addAction(tr("&Quit"), this, SLOT(close()), QKeySequence(Qt.CTRL | Qt.Key_Q));
-}
+		version(Q_WS_MAC) {
+			fileMenu.addAction(tr("&Quit"), BrowserApplication.instance(), SLOT(quitBrowser()), QKeySequence(Qt.CTRL | Qt.Key_Q));
+		} else {
+			fileMenu.addAction(tr("&Quit"), this, SLOT(close()), QKeySequence(Qt.CTRL | Qt.Key_Q));
+		}
 
-    // Edit
-    QMenu *editMenu = menuBar().addMenu(tr("&Edit"));
-    QAction *m_undo = editMenu.addAction(tr("&Undo"));
-    m_undo.setShortcuts(QKeySequence::Undo);
-    m_tabWidget.addWebAction(m_undo, QWebPage::Undo);
-    QAction *m_redo = editMenu.addAction(tr("&Redo"));
-    m_redo.setShortcuts(QKeySequence::Redo);
-    m_tabWidget.addWebAction(m_redo, QWebPage::Redo);
-    editMenu.addSeparator();
-    QAction *m_cut = editMenu.addAction(tr("Cu&t"));
-    m_cut.setShortcuts(QKeySequence::Cut);
-    m_tabWidget.addWebAction(m_cut, QWebPage::Cut);
-    QAction *m_copy = editMenu.addAction(tr("&Copy"));
-    m_copy.setShortcuts(QKeySequence::Copy);
-    m_tabWidget.addWebAction(m_copy, QWebPage::Copy);
-    QAction *m_paste = editMenu.addAction(tr("&Paste"));
-    m_paste.setShortcuts(QKeySequence::Paste);
-    m_tabWidget.addWebAction(m_paste, QWebPage::Paste);
-    editMenu.addSeparator();
+		// Edit
+		QMenu editMenu = menuBar().addMenu(tr("&Edit"));
+		QAction m_undo = editMenu.addAction(tr("&Undo"));
+		m_undo.setShortcuts(QKeySequence.Undo);
+		m_tabWidget.addWebAction(m_undo, QWebPage.Undo);
+		QAction m_redo = editMenu.addAction(tr("&Redo"));
+		m_redo.setShortcuts(QKeySequence.Redo);
+		m_tabWidget.addWebAction(m_redo, QWebPage.Redo);
+		editMenu.addSeparator();
+		QAction m_cut = editMenu.addAction(tr("Cu&t"));
+		m_cut.setShortcuts(QKeySequence.Cut);
+		m_tabWidget.addWebAction(m_cut, QWebPage.Cut);
+		QAction m_copy = editMenu.addAction(tr("&Copy"));
+		m_copy.setShortcuts(QKeySequence.Copy);
+		m_tabWidget.addWebAction(m_copy, QWebPage.Copy);
+		QAction m_paste = editMenu.addAction(tr("&Paste"));
+		m_paste.setShortcuts(QKeySequence.Paste);
+		m_tabWidget.addWebAction(m_paste, QWebPage.Paste);
+		editMenu.addSeparator();
 
-    QAction *m_find = editMenu.addAction(tr("&Find"));
-    m_find.setShortcuts(QKeySequence::Find);
-    connect(m_find, SIGNAL(triggered()), this, SLOT(slotEditFind()));
-    new QShortcut(QKeySequence(Qt.Key_Slash), this, SLOT(slotEditFind()));
-
-    QAction *m_findNext = editMenu.addAction(tr("&Find Next"));
-    m_findNext.setShortcuts(QKeySequence::FindNext);
-    connect(m_findNext, SIGNAL(triggered()), this, SLOT(slotEditFindNext()));
+		QAction m_find = editMenu.addAction(tr("&Find"));
+		m_find.setShortcuts(QKeySequence.Find);
+		m_find.triggered().connect(&this.slotEditFind);
+		new QShortcut(QKeySequence(Qt.Key_Slash), this, SLOT(slotEditFind()));
 
-    QAction *m_findPrevious = editMenu.addAction(tr("&Find Previous"));
-    m_findPrevious.setShortcuts(QKeySequence::FindPrevious);
-    connect(m_findPrevious, SIGNAL(triggered()), this, SLOT(slotEditFindPrevious()));
+		QAction m_findNext = editMenu.addAction(tr("&Find Next"));
+		m_findNext.setShortcuts(QKeySequence.FindNext);
+		m_findNext.triggered().connect(&this.slotEditFindNext);
 
-    editMenu.addSeparator();
-    editMenu.addAction(tr("&Preferences"), this, SLOT(slotPreferences()), tr("Ctrl+,"));
-
-    // View
-    QMenu *viewMenu = menuBar().addMenu(tr("&View"));
+		QAction m_findPrevious = editMenu.addAction(tr("&Find Previous"));
+		m_findPrevious.setShortcuts(QKeySequence.FindPrevious);
+		m_findPrevious.triggered().connect(&this.slotEditFindPrevious);
 
-    m_viewBookmarkBar = new QAction(this);
-    updateBookmarksToolbarActionText(true);
-    m_viewBookmarkBar.setShortcut(tr("Shift+Ctrl+B"));
-    connect(m_viewBookmarkBar, SIGNAL(triggered()), this, SLOT(slotViewBookmarksBar()));
-    viewMenu.addAction(m_viewBookmarkBar);
+		editMenu.addSeparator();
+		editMenu.addAction(tr("&Preferences"), this, SLOT(slotPreferences()), tr("Ctrl+,"));
+
+		// View
+		QMenu viewMenu = menuBar().addMenu(tr("&View"));
 
-    m_viewToolbar = new QAction(this);
-    updateToolbarActionText(true);
-    m_viewToolbar.setShortcut(tr("Ctrl+|"));
-    connect(m_viewToolbar, SIGNAL(triggered()), this, SLOT(slotViewToolbar()));
-    viewMenu.addAction(m_viewToolbar);
+		m_viewBookmarkBar = new QAction(this);
+		updateBookmarksToolbarActionText(true);
+		m_viewBookmarkBar.setShortcut(tr("Shift+Ctrl+B"));
+		m_viewBookmarkBar.triggered().connect(&this.slotViewBookmarksBar);
+		viewMenu.addAction(m_viewBookmarkBar);
 
-    m_viewStatusbar = new QAction(this);
-    updateStatusbarActionText(true);
-    m_viewStatusbar.setShortcut(tr("Ctrl+/"));
-    connect(m_viewStatusbar, SIGNAL(triggered()), this, SLOT(slotViewStatusbar()));
-    viewMenu.addAction(m_viewStatusbar);
+		m_viewToolbar = new QAction(this);
+		updateToolbarActionText(true);
+		m_viewToolbar.setShortcut(tr("Ctrl+|"));
+		m_viewToolbar.triggered().connect(&this.slotViewToolbar);
+		viewMenu.addAction(m_viewToolbar);
 
-    viewMenu.addSeparator();
+		m_viewStatusbar = new QAction(this);
+		updateStatusbarActionText(true);
+		m_viewStatusbar.setShortcut(tr("Ctrl+/"));
+		m_viewStatusbar.triggered().connect(&this.slotViewStatusbar);
+		viewMenu.addAction(m_viewStatusbar);
 
-    m_stop = viewMenu.addAction(tr("&Stop"));
-    QList<QKeySequence> shortcuts;
-    shortcuts.append(QKeySequence(Qt.CTRL | Qt.Key_Period));
-    shortcuts.append(Qt.Key_Escape);
-    m_stop.setShortcuts(shortcuts);
-    m_tabWidget.addWebAction(m_stop, QWebPage::Stop);
+		viewMenu.addSeparator();
 
-    m_reload = viewMenu.addAction(tr("Reload Page"));
-    m_reload.setShortcuts(QKeySequence::Refresh);
-    m_tabWidget.addWebAction(m_reload, QWebPage::Reload);
+		m_stop = viewMenu.addAction(tr("&Stop"));
+		QList<QKeySequence> shortcuts;
+		shortcuts.append(QKeySequence(Qt.CTRL | Qt.Key_Period));
+		shortcuts.append(Qt.Key_Escape);
+		m_stop.setShortcuts(shortcuts);
+		m_tabWidget.addWebAction(m_stop, QWebPage.Stop);
 
-    viewMenu.addAction(tr("Zoom &In"), this, SLOT(slotViewZoomIn()), QKeySequence(Qt.CTRL | Qt.Key_Plus));
-    viewMenu.addAction(tr("Zoom &Out"), this, SLOT(slotViewZoomOut()), QKeySequence(Qt.CTRL | Qt.Key_Minus));
-    viewMenu.addAction(tr("Reset &Zoom"), this, SLOT(slotViewResetZoom()), QKeySequence(Qt.CTRL | Qt.Key_0));
-    QAction *zoomTextOnlyAction = viewMenu.addAction(tr("Zoom &Text Only"));
-    connect(zoomTextOnlyAction, SIGNAL(toggled(bool)), this, SLOT(slotViewZoomTextOnly(bool)));
-    zoomTextOnlyAction.setCheckable(true);
-    zoomTextOnlyAction.setChecked(false);
+		m_reload = viewMenu.addAction(tr("Reload Page"));
+		m_reload.setShortcuts(QKeySequence.Refresh);
+		m_tabWidget.addWebAction(m_reload, QWebPage.Reload);
 
-    viewMenu.addSeparator();
-    viewMenu.addAction(tr("Page S&ource"), this, SLOT(slotViewPageSource()), tr("Ctrl+Alt+U"));
-    QAction *a = viewMenu.addAction(tr("&Full Screen"), this, SLOT(slotViewFullScreen(bool)),  Qt.Key_F11);
-    a.setCheckable(true);
+		viewMenu.addAction(tr("Zoom &In"), this, SLOT(slotViewZoomIn()), QKeySequence(Qt.CTRL | Qt.Key_Plus));
+		viewMenu.addAction(tr("Zoom &Out"), this, SLOT(slotViewZoomOut()), QKeySequence(Qt.CTRL | Qt.Key_Minus));
+		viewMenu.addAction(tr("Reset &Zoom"), this, SLOT(slotViewResetZoom()), QKeySequence(Qt.CTRL | Qt.Key_0));
+		QAction zoomTextOnlyAction = viewMenu.addAction(tr("Zoom &Text Only"));
+		zoomTextOnlyAction.toggled().connect(&this.slotViewZoomTextOnly);
+		zoomTextOnlyAction.setCheckable(true);
+		zoomTextOnlyAction.setChecked(false);
+
+		viewMenu.addSeparator();
+		viewMenu.addAction(tr("Page S&ource"), this, SLOT(slotViewPageSource()), tr("Ctrl+Alt+U"));
+		QAction a = viewMenu.addAction(tr("&Full Screen"), this, SLOT(slotViewFullScreen(bool)),  Qt.Key_F11);
+		a.setCheckable(true);
 
-    // History
-    HistoryMenu *historyMenu = new HistoryMenu(this);
-    connect(historyMenu, SIGNAL(openUrl(const QUrl&)),
-            m_tabWidget, SLOT(loadUrlInCurrentTab(const QUrl&)));
-    connect(historyMenu, SIGNAL(hovered(const QString&)), this,
-            SLOT(slotUpdateStatusbar(const QString&)));
-    historyMenu.setTitle(tr("Hi&story"));
-    menuBar().addMenu(historyMenu);
-    QList<QAction*> historyActions;
+		// History
+		HistoryMenu historyMenu = new HistoryMenu(this);
+		historyMenu.openUrl.connect(&m_tabWidget.loadUrlInCurrentTab);
+		historyMenu.hovered.connect(&this.slotUpdateStatusbar);
+		historyMenu.setTitle(tr("Hi&story"));
+		menuBar().addMenu(historyMenu);
+		QList<QAction> historyActions;
 
-    m_historyBack = new QAction(tr("Back"), this);
-    m_tabWidget.addWebAction(m_historyBack, QWebPage::Back);
-    m_historyBack.setShortcuts(QKeySequence::Back);
-    m_historyBack.setIconVisibleInMenu(false);
+		m_historyBack = new QAction(tr("Back"), this);
+		m_tabWidget.addWebAction(m_historyBack, QWebPage.Back);
+		m_historyBack.setShortcuts(QKeySequence.Back);
+		m_historyBack.setIconVisibleInMenu(false);
 
-    m_historyForward = new QAction(tr("Forward"), this);
-    m_tabWidget.addWebAction(m_historyForward, QWebPage::Forward);
-    m_historyForward.setShortcuts(QKeySequence::Forward);
-    m_historyForward.setIconVisibleInMenu(false);
-
-    QAction *m_historyHome = new QAction(tr("Home"), this);
-    connect(m_historyHome, SIGNAL(triggered()), this, SLOT(slotHome()));
-    m_historyHome.setShortcut(QKeySequence(Qt.CTRL | Qt.SHIFT | Qt.Key_H));
+		m_historyForward = new QAction(tr("Forward"), this);
+		m_tabWidget.addWebAction(m_historyForward, QWebPage.Forward);
+		m_historyForward.setShortcuts(QKeySequence.Forward);
+		m_historyForward.setIconVisibleInMenu(false);
 
-    m_restoreLastSession = new QAction(tr("Restore Last Session"), this);
-    connect(m_restoreLastSession, SIGNAL(triggered()), BrowserApplication::instance(), SLOT(restoreLastSession()));
-    m_restoreLastSession.setEnabled(BrowserApplication::instance().canRestoreSession());
+		QAction m_historyHome = new QAction(tr("Home"), this);
+		m_historyHome.triggered().connect(&this.slotHome);
+		m_historyHome.setShortcut(QKeySequence(Qt.CTRL | Qt.SHIFT | Qt.Key_H));
 
-    historyActions.append(m_historyBack);
-    historyActions.append(m_historyForward);
-    historyActions.append(m_historyHome);
-    historyActions.append(m_tabWidget.recentlyClosedTabsAction());
-    historyActions.append(m_restoreLastSession);
-    historyMenu.setInitialActions(historyActions);
+		m_restoreLastSession = new QAction(tr("Restore Last Session"), this);
+		m_restoreLastSession.triggered().connect(BrowserApplication.instance().restoreLastSession);
+		m_restoreLastSession.setEnabled(BrowserApplication.instance().canRestoreSession());
+
+		historyActions.append(m_historyBack);
+		historyActions.append(m_historyForward);
+		historyActions.append(m_historyHome);
+		historyActions.append(m_tabWidget.recentlyClosedTabsAction());
+		historyActions.append(m_restoreLastSession);
+		historyMenu.setInitialActions(historyActions);
 
-    // Bookmarks
-    BookmarksMenu *bookmarksMenu = new BookmarksMenu(this);
-    connect(bookmarksMenu, SIGNAL(openUrl(const QUrl&)),
-            m_tabWidget, SLOT(loadUrlInCurrentTab(const QUrl&)));
-    connect(bookmarksMenu, SIGNAL(hovered(const QString&)),
-            this, SLOT(slotUpdateStatusbar(const QString&)));
-    bookmarksMenu.setTitle(tr("&Bookmarks"));
-    menuBar().addMenu(bookmarksMenu);
-
-    QList<QAction*> bookmarksActions;
+		// Bookmarks
+		BookmarksMenu bookmarksMenu = new BookmarksMenu(this);
+		bookmarksMenu.openUrl.connect(&m_tabWidget.loadUrlInCurrentTab);
+		bookmarksMenu.hovered.connect(&this.slotUpdateStatusbar);
+		bookmarksMenu.setTitle(tr("&Bookmarks"));
+		menuBar().addMenu(bookmarksMenu);
 
-    QAction *showAllBookmarksAction = new QAction(tr("Show All Bookmarks"), this);
-    connect(showAllBookmarksAction, SIGNAL(triggered()), this, SLOT(slotShowBookmarksDialog()));
-    m_addBookmark = new QAction(QIcon(QLatin1String(":addbookmark.png")), tr("Add Bookmark..."), this);
-    m_addBookmark.setIconVisibleInMenu(false);
+		QList<QAction> bookmarksActions;
 
-    connect(m_addBookmark, SIGNAL(triggered()), this, SLOT(slotAddBookmark()));
-    m_addBookmark.setShortcut(QKeySequence(Qt.CTRL | Qt.Key_D));
+		QAction showAllBookmarksAction = new QAction(tr("Show All Bookmarks"), this);
+		showAllBookmarksAction.triggered().connect(&this.slotShowBookmarksDialog);
+		m_addBookmark = new QAction(QIcon(QLatin1String(":addbookmark.png")), tr("Add Bookmark..."), this);
+		m_addBookmark.setIconVisibleInMenu(false);
 
-    bookmarksActions.append(showAllBookmarksAction);
-    bookmarksActions.append(m_addBookmark);
-    bookmarksMenu.setInitialActions(bookmarksActions);
+		m_addBookmark.triggered().connect(&this.slotAddBookmark);
+		m_addBookmark.setShortcut(QKeySequence(Qt.CTRL | Qt.Key_D));
 
-    // Window
-    m_windowMenu = menuBar().addMenu(tr("&Window"));
-    connect(m_windowMenu, SIGNAL(aboutToShow()),
-            this, SLOT(slotAboutToShowWindowMenu()));
-    slotAboutToShowWindowMenu();
+		bookmarksActions.append(showAllBookmarksAction);
+		bookmarksActions.append(m_addBookmark);
+		bookmarksMenu.setInitialActions(bookmarksActions);
 
-    QMenu *toolsMenu = menuBar().addMenu(tr("&Tools"));
-    toolsMenu.addAction(tr("Web &Search"), this, SLOT(slotWebSearch()), QKeySequence(tr("Ctrl+K", "Web Search")));
-#ifndef Q_CC_MINGW
-    a = toolsMenu.addAction(tr("Enable Web &Inspector"), this, SLOT(slotToggleInspector(bool)));
-    a.setCheckable(true);
-#endif
+		// Window
+		m_windowMenu = menuBar().addMenu(tr("&Window"));
+		m_windowMenu.aboutToShow().connect(&this.slotAboutToShowWindowMenu);
+		slotAboutToShowWindowMenu();
 
-    QMenu *helpMenu = menuBar().addMenu(tr("&Help"));
-    helpMenu.addAction(tr("About &Qt"), qApp, SLOT(aboutQt()));
-    helpMenu.addAction(tr("About &Demo Browser"), this, SLOT(slotAboutApplication()));
-}
-
+		QMenu toolsMenu = menuBar().addMenu(tr("&Tools"));
+		toolsMenu.addAction(tr("Web &Search"), this, SLOT(slotWebSearch()), QKeySequence(tr("Ctrl+K", "Web Search")));
+		version(Q_CC_MINGW)
+		{
+			a = toolsMenu.addAction(tr("Enable Web &Inspector"), this, SLOT(slotToggleInspector(bool)));
+			a.setCheckable(true);
+		}
 
-    void setupToolBar()
-{
-    setUnifiedTitleAndToolBarOnMac(true);
-    m_navigationBar = addToolBar(tr("Navigation"));
-    connect(m_navigationBar.toggleViewAction(), SIGNAL(toggled(bool)),
-            this, SLOT(updateToolbarActionText(bool)));
+		QMenu helpMenu = menuBar().addMenu(tr("&Help"));
+		helpMenu.addAction(tr("About &Qt"), qApp, SLOT(aboutQt()));
+		helpMenu.addAction(tr("About &Demo Browser"), this, SLOT(slotAboutApplication()));
+	}
+
+	void setupToolBar()
+	{
+		setUnifiedTitleAndToolBarOnMac(true);
+		m_navigationBar = addToolBar(tr("Navigation"));
+		m_navigationBar.toggleViewAction().toggled.connect(&this.updateToolbarActionText);
 
-    m_historyBack.setIcon(style().standardIcon(QStyle::SP_ArrowBack, 0, this));
-    m_historyBackMenu = new QMenu(this);
-    m_historyBack.setMenu(m_historyBackMenu);
-    connect(m_historyBackMenu, SIGNAL(aboutToShow()),
-            this, SLOT(slotAboutToShowBackMenu()));
-    connect(m_historyBackMenu, SIGNAL(triggered(QAction *)),
-            this, SLOT(slotOpenActionUrl(QAction *)));
-    m_navigationBar.addAction(m_historyBack);
+		m_historyBack.setIcon(style().standardIcon(QStyle.SP_ArrowBack, 0, this));
+		m_historyBackMenu = new QMenu(this);
+		m_historyBack.setMenu(m_historyBackMenu);
+		m_historyBackMenu.aboutToShow().connect(&this.slotAboutToShowBackMenu);
+		m_historyBackMenu.triggered.connect(&this.slotOpenActionUrl);
+		m_navigationBar.addAction(m_historyBack);
 
-    m_historyForward.setIcon(style().standardIcon(QStyle::SP_ArrowForward, 0, this));
-    m_historyForwardMenu = new QMenu(this);
-    connect(m_historyForwardMenu, SIGNAL(aboutToShow()),
-            this, SLOT(slotAboutToShowForwardMenu()));
-    connect(m_historyForwardMenu, SIGNAL(triggered(QAction *)),
-            this, SLOT(slotOpenActionUrl(QAction *)));
-    m_historyForward.setMenu(m_historyForwardMenu);
-    m_navigationBar.addAction(m_historyForward);
+		m_historyForward.setIcon(style().standardIcon(QStyle.SP_ArrowForward, 0, this));
+		m_historyForwardMenu = new QMenu(this);
+		m_historyForwardMenu.aboutToShow.connect(&this.slotAboutToShowForwardMenu);
+		m_historyForwardMenu.triggered.connect(&this.slotOpenActionUrl);
+		m_historyForward.setMenu(m_historyForwardMenu);
+		m_navigationBar.addAction(m_historyForward);
 
-    m_stopReload = new QAction(this);
-    m_reloadIcon = style().standardIcon(QStyle::SP_BrowserReload);
-    m_stopReload.setIcon(m_reloadIcon);
+		m_stopReload = new QAction(this);
+		m_reloadIcon = style().standardIcon(QStyle.SP_BrowserReload);
+		m_stopReload.setIcon(m_reloadIcon);
 
-    m_navigationBar.addAction(m_stopReload);
+		m_navigationBar.addAction(m_stopReload);
 
-    m_navigationBar.addWidget(m_tabWidget.lineEditStack());
+		m_navigationBar.addWidget(m_tabWidget.lineEditStack());
 
-    m_toolbarSearch = new ToolbarSearch(m_navigationBar);
-    m_navigationBar.addWidget(m_toolbarSearch);
-    connect(m_toolbarSearch, SIGNAL(search(const QUrl&)), SLOT(loadUrl(const QUrl&)));
+		m_toolbarSearch = new ToolbarSearch(m_navigationBar);
+		m_navigationBar.addWidget(m_toolbarSearch);
+		m_toolbarSearch.search.connect(&loadUrl);
 
-    m_chaseWidget = new ChaseWidget(this);
-    m_navigationBar.addWidget(m_chaseWidget);
-}
+		m_chaseWidget = new ChaseWidget(this);
+		m_navigationBar.addWidget(m_chaseWidget);
+	}
 
-    void updateStatusbarActionText(bool visible)
-{
-    m_viewStatusbar.setText(!visible ? tr("Show Status Bar") : tr("Hide Status Bar"));
-}
-
+	void updateStatusbarActionText(bool visible)
+	{
+		m_viewStatusbar.setText(!visible ? tr("Show Status Bar") : tr("Hide Status Bar"));
+	}
 
 private:
-    QToolBar *m_navigationBar;
-    ToolbarSearch *m_toolbarSearch;
-    BookmarksToolBar *m_bookmarksToolbar;
-    ChaseWidget *m_chaseWidget;
-    TabWidget *m_tabWidget;
-    AutoSaver *m_autoSaver;
 
-    QAction *m_historyBack;
-    QMenu *m_historyBackMenu;
-    QAction *m_historyForward;
-    QMenu *m_historyForwardMenu;
-    QMenu *m_windowMenu;
+	QToolBar m_navigationBar;
+	ToolbarSearch m_toolbarSearch;
+	BookmarksToolBar m_bookmarksToolbar;
+	ChaseWidget m_chaseWidget;
+	TabWidget m_tabWidget;
+	AutoSaver m_autoSaver;
+
+	QAction m_historyBack;
+	QMenu m_historyBackMenu;
+	QAction m_historyForward;
+	QMenu m_historyForwardMenu;
+	QMenu m_windowMenu;
 
-    QAction *m_stop;
-    QAction *m_reload;
-    QAction *m_stopReload;
-    QAction *m_viewToolbar;
-    QAction *m_viewBookmarkBar;
-    QAction *m_viewStatusbar;
-    QAction *m_restoreLastSession;
-    QAction *m_addBookmark;
+	QAction m_stop;
+	QAction m_reload;
+	QAction m_stopReload;
+	QAction m_viewToolbar;
+	QAction m_viewBookmarkBar;
+	QAction m_viewStatusbar;
+	QAction m_restoreLastSession;
+	QAction m_addBookmark;
 
-    QIcon m_reloadIcon;
-    QIcon m_stopIcon;
+	QIcon m_reloadIcon;
+	QIcon m_stopIcon;
 
-    QString m_lastSearch;
+	QString m_lastSearch;
 }