Merge branch '4.7' of scm.dev.nokia.troll.no:qt/oslo-staging-1 into 4.7-integration

* '4.7' of scm.dev.nokia.troll.no:qt/oslo-staging-1:
  Fix compilation with QT_NO_TEXTSTREAM
  Fix the compilation with QT_NO_TOOLTIP
  Add unit tests for a number of QList methods.
  Crash while dragging on Mac OS X (Cocoa)
  Doc & menubar hidden for QtDemo after switching back from fullscreen
  qdoc: Added breadcrumbs for class pages.
  QTabWidget documentMode not working correctly on Mac
  qdoc: Removed MacRefs for Xcode documentation stuff.
  Slight QList documentation fix.

18 files changed, 798 insertions, 43 deletions

diff --git a/src/corelib/tools/qlist.cpp b/src/corelib/tools/qlist.cpp
index 6f5bb9b..6cc6fc1 100644
--- a/src/corelib/tools/qlist.cpp
+++ b/src/corelib/tools/qlist.cpp
@@ -853,9 +853,7 @@ void **QListData::erase(void **xi)
     same as takeAt(0). This function assumes the list is not empty. To
     avoid failure, call isEmpty() before calling this function.
 
-    This operation is very fast (\l{constant time}), because QList
-    preallocates extra space on both sides of its internal buffer to
-    allow for fast growth at both ends of the list.
+    This operation takes \l{constant time}.
 
     If you don't use the return value, removeFirst() is more
     efficient.
@@ -870,9 +868,7 @@ void **QListData::erase(void **xi)
     not empty. To avoid failure, call isEmpty() before calling this
     function.
 
-    This operation is very fast (\l{constant time}), because QList
-    preallocates extra space on both sides of its internal buffer to
-    allow for fast growth at both ends of the list.
+    This operation takes \l{constant time}.
 
     If you don't use the return value, removeLast() is more
     efficient.
diff --git a/src/gui/graphicsview/qgraphicsproxywidget.cpp b/src/gui/graphicsview/qgraphicsproxywidget.cpp
index 1f89714..320395e 100644
--- a/src/gui/graphicsview/qgraphicsproxywidget.cpp
+++ b/src/gui/graphicsview/qgraphicsproxywidget.cpp
@@ -975,6 +975,7 @@ bool QGraphicsProxyWidget::eventFilter(QObject *object, QEvent *event)
                 d->styleChangeMode = QGraphicsProxyWidgetPrivate::NoMode;
             }
             break;
+#ifndef QT_NO_TOOLTIP
         case QEvent::ToolTipChange:
             // Propagate tooltip change to the proxy.
             if (!d->tooltipChangeMode) {
@@ -983,6 +984,7 @@ bool QGraphicsProxyWidget::eventFilter(QObject *object, QEvent *event)
                 d->tooltipChangeMode = QGraphicsProxyWidgetPrivate::NoMode;
             }
             break;
+#endif
         default:
             break;
         }
diff --git a/src/gui/kernel/qcocoasharedwindowmethods_mac_p.h b/src/gui/kernel/qcocoasharedwindowmethods_mac_p.h
index e94d247..8652816 100644
--- a/src/gui/kernel/qcocoasharedwindowmethods_mac_p.h
+++ b/src/gui/kernel/qcocoasharedwindowmethods_mac_p.h
@@ -363,3 +363,57 @@ QT_END_NAMESPACE
     }
     [super displayIfNeeded];
 }
+
+// This is a hack and it should be removed once we find the real cause for
+// the painting problems.
+// We have a static variable that signals if we have been called before or not.
+static bool firstDrawingInvocation = true;
+
+// The method below exists only as a workaround to draw/not draw the baseline
+// in the title bar. This is to support unifiedToolbar look.
+
+// This method is very special. To begin with, it is a
+// method that will get called only if we enable documentMode.
+// Furthermore, it won't get called as a normal method, we swap
+// this method with the normal implementation of drawRect in
+// _NSThemeFrame. When this method is active, its mission is to
+// first call the original drawRect implementation so the widget
+// gets proper painting. After that, it needs to detect if there
+// is a toolbar or not, in order to decide how to handle the unified
+// look. The distinction is important since the presence and
+// visibility of a toolbar change the way we enter into unified mode.
+// When there is a toolbar and that toolbar is visible, the problem
+// is as simple as to tell the toolbar not to draw its baseline.
+// However when there is not toolbar or the toolbar is not visible,
+// we need to draw a line on top of the baseline, because the baseline
+// in that case will belong to the title. For this case we need to draw
+// a line on top of the baseline.
+// As usual, there is a special case. When we first are called, we might
+// need to repaint ourselves one more time. We only need that if we
+// didn't get the activation, i.e. when we are launched via the command
+// line. And this only if the toolbar is visible from the beginning,
+// so we have a special flag that signals if we need to repaint or not.
+- (void)drawRectSpecial:(NSRect)rect
+{
+    // Call the original drawing method.
+    [self drawRectOriginal:rect];
+    NSWindow *window = [self window];
+    NSToolbar *toolbar = [window toolbar];
+    if(!toolbar) {
+        // There is no toolbar, we have to draw a line on top of the line drawn by Cocoa.
+        macDrawRectOnTop((void *)window);
+    } else {
+        if([toolbar isVisible]) {
+            // We tell Cocoa to avoid drawing the line at the end.
+            if(firstDrawingInvocation) {
+                firstDrawingInvocation = false;
+                macSyncDrawingOnFirstInvocation((void *)window);
+            } else
+                [toolbar setShowsBaselineSeparator:NO];
+        } else {
+            // There is a toolbar but it is not visible so
+            // we have to draw a line on top of the line drawn by Cocoa.
+            macDrawRectOnTop((void *)window);
+        }
+    }
+}
diff --git a/src/gui/kernel/qcocoaview_mac.mm b/src/gui/kernel/qcocoaview_mac.mm
index dd12f65..4953c48 100644
--- a/src/gui/kernel/qcocoaview_mac.mm
+++ b/src/gui/kernel/qcocoaview_mac.mm
@@ -1554,7 +1554,8 @@ Qt::DropAction QDragManager::drag(QDrag *o)
     qt_button_down = 0;
     [dndParams.view release];
     [image release];
-    dragPrivate()->executed_action = Qt::IgnoreAction;
+    if (dragPrivate())
+        dragPrivate()->executed_action = Qt::IgnoreAction;
     object = 0;
     Qt::DropAction performedAction(qt_mac_mapNSDragOperation(qMacDnDParams()->performedAction));
     // do post drag processing, if required.
diff --git a/src/gui/kernel/qt_cocoa_helpers_mac.mm b/src/gui/kernel/qt_cocoa_helpers_mac.mm
index a05c7d5..024c1fc 100644
--- a/src/gui/kernel/qt_cocoa_helpers_mac.mm
+++ b/src/gui/kernel/qt_cocoa_helpers_mac.mm
@@ -1163,15 +1163,81 @@ void qt_mac_updateContentBorderMetricts(void * /*OSWindowRef */window, const ::H
 #endif
 }
 
+#if QT_MAC_USE_COCOA
+void qt_mac_replaceDrawRect(void * /*OSWindowRef */window, QWidgetPrivate *widget)
+{
+    QMacCocoaAutoReleasePool pool;
+    OSWindowRef theWindow = static_cast<OSWindowRef>(window);
+    if(!theWindow)
+        return;
+    id theClass = [[[theWindow contentView] superview] class];
+    // What we do here is basically to add a new selector to NSThemeFrame called
+    // "drawRectOriginal:" which will contain the original implementation of
+    // "drawRect:". After that we get the new implementation from QCocoaWindow
+    // and exchange them. The new implementation is called drawRectSpecial.
+    // We cannot just add the method because it might have been added before and since
+    // we cannot remove a method once it has been added we need to ask QCocoaWindow if
+    // we did the swap or not.
+    if(!widget->drawRectOriginalAdded) {
+        Method m2 = class_getInstanceMethod(theClass, @selector(drawRect:));
+        if(!m2) {
+            // This case is pretty extreme, no drawRect means no drawing!
+            return;
+        }
+        class_addMethod(theClass, @selector(drawRectOriginal:), method_getImplementation(m2), method_getTypeEncoding(m2));
+        widget->drawRectOriginalAdded = true;
+    }
+    if(widget->originalDrawMethod) {
+        Method m0 = class_getInstanceMethod([theWindow class], @selector(drawRectSpecial:));
+        if(!m0) {
+            // Ok, this means the methods were never swapped. Just ignore
+            return;
+        }
+        Method m1 = class_getInstanceMethod(theClass, @selector(drawRect:));
+        if(!m1) {
+            // Ok, this means the methods were never swapped. Just ignore
+            return;
+        }
+        // We have the original method here. Proceed and swap the methods.
+        method_exchangeImplementations(m1, m0);
+        widget->originalDrawMethod = false;
+        [window display];
+    }
+}
+
+void qt_mac_replaceDrawRectOriginal(void * /*OSWindowRef */window, QWidgetPrivate *widget)
+{
+    QMacCocoaAutoReleasePool pool;
+    OSWindowRef theWindow = static_cast<OSWindowRef>(window);
+    id theClass = [[[theWindow contentView] superview] class];
+    // Now we need to revert the methods to their original state.
+    // We cannot remove the method, so we just keep track of it in QCocoaWindow.
+    Method m0 = class_getInstanceMethod([theWindow class], @selector(drawRectSpecial:));
+    if(!m0) {
+        // Ok, this means the methods were never swapped. Just ignore
+        return;
+    }
+    Method m1 = class_getInstanceMethod(theClass, @selector(drawRect:));
+    if(!m1) {
+        // Ok, this means the methods were never swapped. Just ignore
+        return;
+    }
+    method_exchangeImplementations(m1, m0);
+    widget->originalDrawMethod = true;
+    [window display];
+}
+#endif // QT_MAC_USE_COCOA
+
 void qt_mac_showBaseLineSeparator(void * /*OSWindowRef */window, bool show)
 {
+    if(!window)
+        return;
 #if QT_MAC_USE_COCOA
     QMacCocoaAutoReleasePool pool;
     OSWindowRef theWindow = static_cast<OSWindowRef>(window);
     NSToolbar *macToolbar = [theWindow toolbar];
-    if (macToolbar)
-        [macToolbar setShowsBaselineSeparator: show];
-#endif
+    [macToolbar setShowsBaselineSeparator:show];
+#endif // QT_MAC_USE_COCOA
 }
 
 QStringList qt_mac_NSArrayToQStringList(void *nsarray)
@@ -1403,4 +1469,52 @@ void qt_mac_post_retranslateAppMenu()
 #endif
 }
 
+#ifdef QT_MAC_USE_COCOA
+// This method implements the magic for the drawRectSpecial method.
+// We draw a line at the upper edge of the content view in order to
+// override the title baseline.
+void macDrawRectOnTop(void * /*OSWindowRef */window)
+{
+    OSWindowRef theWindow = static_cast<OSWindowRef>(window);
+    NSView *contentView = [theWindow contentView];
+    if(!contentView)
+        return;
+    // Get coordinates of the content view
+    NSRect contentRect = [contentView frame];
+    // Draw a line on top of the already drawn line.
+    // We need to check if we are active or not to use the proper color.
+    if([window isKeyWindow] || [window isMainWindow]) {
+        [[NSColor colorWithCalibratedRed:1.0 green:1.0 blue:1.0 alpha:1.0] set];
+    } else {
+        [[NSColor colorWithCalibratedRed:1.0 green:1.0 blue:1.0 alpha:1.0] set];
+    }
+    NSPoint origin = NSMakePoint(0, contentRect.size.height);
+    NSPoint end = NSMakePoint(contentRect.size.width, contentRect.size.height);
+    [NSBezierPath strokeLineFromPoint:origin toPoint:end];
+}
+
+// This method will (or at least should) get called only once.
+// Its mission is to find out if we are active or not. If we are active
+// we assume that we were launched via finder, otherwise we assume
+// we were called from the command line. The distinction is important,
+// since in the first case we don't need to trigger a paintEvent, while
+// in the second case we do.
+void macSyncDrawingOnFirstInvocation(void * /*OSWindowRef */window)
+{
+    OSWindowRef theWindow = static_cast<OSWindowRef>(window);
+    NSApplication *application = [NSApplication sharedApplication];
+    NSToolbar *toolbar = [window toolbar];
+    if([application isActive]) {
+        // Launched from finder
+        [toolbar setShowsBaselineSeparator:NO];
+    } else {
+        // Launched from commandline
+        [toolbar setVisible:false];
+        [toolbar setShowsBaselineSeparator:NO];
+        [toolbar setVisible:true];
+        [theWindow display];
+    }
+}
+#endif // QT_MAC_USE_COCOA
+
 QT_END_NAMESPACE
diff --git a/src/gui/kernel/qt_cocoa_helpers_mac_p.h b/src/gui/kernel/qt_cocoa_helpers_mac_p.h
index 3fd62a4..5db121a 100644
--- a/src/gui/kernel/qt_cocoa_helpers_mac_p.h
+++ b/src/gui/kernel/qt_cocoa_helpers_mac_p.h
@@ -131,6 +131,8 @@ void macWindowSetHasShadow( void * /*OSWindowRef*/ window, bool hasShadow );
 void macWindowFlush(void * /*OSWindowRef*/ window);
 void macSendToolbarChangeEvent(QWidget *widget);
 void qt_mac_updateContentBorderMetricts(void * /*OSWindowRef */window, const ::HIContentBorderMetrics &metrics);
+void qt_mac_replaceDrawRect(void * /*OSWindowRef */window, QWidgetPrivate *widget);
+void qt_mac_replaceDrawRectOriginal(void * /*OSWindowRef */window, QWidgetPrivate *widget);
 void qt_mac_showBaseLineSeparator(void * /*OSWindowRef */window, bool show);
 void * /*NSImage */qt_mac_create_nsimage(const QPixmap &pm);
 void qt_mac_update_mouseTracking(QWidget *widget);
@@ -140,6 +142,9 @@ void qt_dispatchTabletProximityEvent(void * /*NSEvent * */ tabletEvent);
 #ifdef QT_MAC_USE_COCOA
 bool qt_dispatchKeyEventWithCocoa(void * /*NSEvent * */ keyEvent, QWidget *widgetToGetEvent);
 void qt_cocoaChangeOverrideCursor(const QCursor &cursor);
+// These methods exists only for supporting unified mode.
+void macDrawRectOnTop(void * /*OSWindowRef */ window);
+void macSyncDrawingOnFirstInvocation(void * /*OSWindowRef */window);
 #endif
 void qt_mac_menu_collapseSeparators(void * /*NSMenu */ menu, bool collapse);
 bool qt_dispatchKeyEvent(void * /*NSEvent * */ keyEvent, QWidget *widgetToGetEvent);
diff --git a/src/gui/kernel/qt_mac_p.h b/src/gui/kernel/qt_mac_p.h
index 7bfb257..3341ce1 100644
--- a/src/gui/kernel/qt_mac_p.h
+++ b/src/gui/kernel/qt_mac_p.h
@@ -57,6 +57,7 @@
 
 #ifdef __OBJC__
 #include <Cocoa/Cocoa.h>
+#include <objc/runtime.h>
 #endif
 
 #include <CoreServices/CoreServices.h>
diff --git a/src/gui/kernel/qwidget.cpp b/src/gui/kernel/qwidget.cpp
index b59824c..20d1d30 100644
--- a/src/gui/kernel/qwidget.cpp
+++ b/src/gui/kernel/qwidget.cpp
@@ -220,6 +220,11 @@ QWidgetPrivate::QWidgetPrivate(int version)
 
     isWidget = true;
     memset(high_attributes, 0, sizeof(high_attributes));
+#if QT_MAC_USE_COCOA
+    drawRectOriginalAdded = false;
+    originalDrawMethod = true;
+    changeMethods = false;
+#endif // QT_MAC_USE_COCOA
 #ifdef QWIDGET_EXTRA_DEBUG
     static int count = 0;
     qDebug() << "widgets" << ++count;
@@ -12292,6 +12297,28 @@ void QWidgetPrivate::_q_delayedDestroy(WId winId)
 }
 #endif
 
+#if QT_MAC_USE_COCOA
+void QWidgetPrivate::syncUnifiedMode() {
+    // The whole purpose of this method is to keep the unifiedToolbar in sync.
+    // That means making sure we either exchange the drawing methods or we let
+    // the toolbar know that it does not require to draw the baseline.
+    Q_Q(QWidget);
+    // This function makes sense only if this is a top level
+    if(!q->isWindow())
+        return;
+    OSWindowRef window = qt_mac_window_for(q);
+    if(changeMethods) {
+        // Ok, we are in documentMode.
+        if(originalDrawMethod)
+            qt_mac_replaceDrawRect(window, this);
+    } else {
+        if(!originalDrawMethod)
+            qt_mac_replaceDrawRectOriginal(window, this);
+    }
+}
+
+#endif // QT_MAC_USE_COCOA
+
 QT_END_NAMESPACE
 
 #include "moc_qwidget.cpp"
diff --git a/src/gui/kernel/qwidget_p.h b/src/gui/kernel/qwidget_p.h
index 89ea256..cad60b5 100644
--- a/src/gui/kernel/qwidget_p.h
+++ b/src/gui/kernel/qwidget_p.h
@@ -773,6 +773,13 @@ public:
     void finishCreateWindow_sys_Cocoa(void * /*NSWindow * */ windowRef);
     void syncCocoaMask();
     void finishCocoaMaskSetup();
+    void syncUnifiedMode();
+    // Did we add the drawRectOriginal method?
+    bool drawRectOriginalAdded;
+    // Is the original drawRect method available?
+    bool originalDrawMethod;
+    // Do we need to change the methods?
+    bool changeMethods;
 #endif
     void determineWindowClass();
     void transferChildren();
diff --git a/src/gui/widgets/qmenu_mac.mm b/src/gui/widgets/qmenu_mac.mm
index e8400d6..aaa113b 100644
--- a/src/gui/widgets/qmenu_mac.mm
+++ b/src/gui/widgets/qmenu_mac.mm
@@ -2066,6 +2066,7 @@ bool QMenuBarPrivate::macUpdateMenuBarImmediatly()
     cancelAllMenuTracking();
     QWidget *w = findWindowThatShouldDisplayMenubar();
     QMenuBar *mb = findMenubarForWindow(w);
+    extern bool qt_mac_app_fullscreen; //qapplication_mac.mm
 
     // We need to see if we are in full screen mode, if so we need to
     // switch the full screen mode to be able to show or hide the menubar.
@@ -2074,12 +2075,14 @@ bool QMenuBarPrivate::macUpdateMenuBarImmediatly()
         if(w->isFullScreen()) {
             // Ok, switch to showing the menubar when hovering over it.
             SetSystemUIMode(kUIModeAllHidden, kUIOptionAutoShowMenuBar);
+            qt_mac_app_fullscreen = true;
         }
     } else if(w) {
         // Removing a menubar
         if(w->isFullScreen()) {
             // Ok, switch to not showing the menubar when hovering on it
             SetSystemUIMode(kUIModeAllHidden, 0);
+            qt_mac_app_fullscreen = true;
         }
     }
 
diff --git a/src/gui/widgets/qtabbar.cpp b/src/gui/widgets/qtabbar.cpp
index d03a2f4..8aaaade 100644
--- a/src/gui/widgets/qtabbar.cpp
+++ b/src/gui/widgets/qtabbar.cpp
@@ -69,6 +69,7 @@
 
 QT_BEGIN_NAMESPACE
 
+
 inline static bool verticalTabs(QTabBar::Shape shape)
 {
     return shape == QTabBar::RoundedWest
@@ -95,9 +96,20 @@ void QTabBarPrivate::updateMacBorderMetrics()
         metrics.left = 0;
         metrics.right = 0;
         qt_mac_updateContentBorderMetricts(window, metrics);
-        
-        // hide the base line separator if the tabs have docuemnt mode enabled (Cocoa)
-        qt_mac_showBaseLineSeparator(window, !documentMode);
+#if QT_MAC_USE_COCOA
+        // In Cocoa we need to keep track of the drawRect method.
+        // If documentMode is enabled we need to change it, unless
+        // a toolbar is present.
+        // Notice that all the information is kept in the window,
+        // that's why we get the private widget for it instead of
+        // the private widget for this widget.
+        QWidgetPrivate *privateWidget = qt_widget_private(q->window());
+        if(privateWidget)
+            privateWidget->changeMethods = documentMode;
+        // Since in Cocoa there is no simple way to remove the baseline, so we just ask the
+        // top level to do the magic for us.
+        privateWidget->syncUnifiedMode();
+#endif // QT_MAC_USE_COCOA
     }
 #endif
 }
@@ -2193,6 +2205,7 @@ bool QTabBar::documentMode() const
 void QTabBar::setDocumentMode(bool enabled)
 {
     Q_D(QTabBar);
+
     d->documentMode = enabled;
     d->updateMacBorderMetrics();
 }
diff --git a/src/network/access/qftp.cpp b/src/network/access/qftp.cpp
index 7f6df0a..97219f4 100644
--- a/src/network/access/qftp.cpp
+++ b/src/network/access/qftp.cpp
@@ -2311,7 +2311,7 @@ void QFtpPrivate::_q_piError(int errorCode, const QString &text)
     Q_Q(QFtp);
 
     if (pending.isEmpty()) {
-        qWarning() << "QFtpPrivate::_q_piError was called without pending command!";
+        qWarning("QFtpPrivate::_q_piError was called without pending command!");
         return;
     }
 
diff --git a/src/plugins/accessible/widgets/simplewidgets.cpp b/src/plugins/accessible/widgets/simplewidgets.cpp
index daa827e..f39d538 100644
--- a/src/plugins/accessible/widgets/simplewidgets.cpp
+++ b/src/plugins/accessible/widgets/simplewidgets.cpp
@@ -605,7 +605,11 @@ int QAccessibleDisplay::navigate(RelationFlag rel, int entry, QAccessibleInterfa
 /*! \reimp */
 QString QAccessibleDisplay::imageDescription()
 {
+#ifndef QT_NO_TOOLTIP
     return widget()->toolTip();
+#else
+    return QString::null;
+#endif
 }
 
 /*! \reimp */
diff --git a/tests/auto/qlist/tst_qlist.cpp b/tests/auto/qlist/tst_qlist.cpp
index e2944cc..ba8aefa 100644
--- a/tests/auto/qlist/tst_qlist.cpp
+++ b/tests/auto/qlist/tst_qlist.cpp
@@ -62,6 +62,33 @@ private slots:
     void append() const;
     void prepend() const;
     void mid() const;
+    void at() const;
+    void first() const;
+    void last() const;
+    void begin() const;
+    void end() const;
+    void contains() const;
+    void count() const;
+    void empty() const;
+    void endsWith() const;
+    void lastIndexOf() const;
+    void move() const;
+    void removeAll() const;
+    void removeAt() const;
+    void removeOne() const;
+    void replace() const;
+    void startsWith() const;
+    void swap() const;
+    void takeAt() const;
+    void takeFirst() const;
+    void takeLast() const;
+    void toSet() const;
+    void toStdList() const;
+    void toVector() const;
+    void value() const;
+
+    void testSTLIterators() const;
+    void testOperators() const;
 };
 
 void tst_QList::length() const
@@ -173,5 +200,467 @@ void tst_QList::mid() const
              QList<QString>() << "bak" << "buck" << "hello");
 }
 
+void tst_QList::at() const
+{
+    // test at() and make sure it functions correctly with some simple list manipulation.
+    QList<QString> list;
+
+    // create a list
+    list << "foo" << "bar" << "baz";
+    QVERIFY(list.size() == 3);
+    QCOMPARE(list.at(0), QLatin1String("foo"));
+    QCOMPARE(list.at(1), QLatin1String("bar"));
+    QCOMPARE(list.at(2), QLatin1String("baz"));
+
+    // append an item
+    list << "hello";
+    QVERIFY(list.size() == 4);
+    QCOMPARE(list.at(0), QLatin1String("foo"));
+    QCOMPARE(list.at(1), QLatin1String("bar"));
+    QCOMPARE(list.at(2), QLatin1String("baz"));
+    QCOMPARE(list.at(3), QLatin1String("hello"));
+
+    // remove an item
+    list.removeAt(1);
+    QVERIFY(list.size() == 3);
+    QCOMPARE(list.at(0), QLatin1String("foo"));
+    QCOMPARE(list.at(1), QLatin1String("baz"));
+    QCOMPARE(list.at(2), QLatin1String("hello"));
+}
+
+void tst_QList::first() const
+{
+    QList<QString> list;
+    list << "foo" << "bar";
+
+    QCOMPARE(list.first(), QLatin1String("foo"));
+
+    // remove an item, make sure it still works
+    list.pop_front();
+    QVERIFY(list.size() == 1);
+    QCOMPARE(list.first(), QLatin1String("bar"));
+}
+
+void tst_QList::last() const
+{
+    QList<QString> list;
+    list << "foo" << "bar";
+
+    QCOMPARE(list.last(), QLatin1String("bar"));
+
+    // remove an item, make sure it still works
+    list.pop_back();
+    QVERIFY(list.size() == 1);
+    QCOMPARE(list.last(), QLatin1String("foo"));
+}
+
+void tst_QList::begin() const
+{
+    QList<QString> list;
+    list << "foo" << "bar";
+
+    QCOMPARE(*list.begin(), QLatin1String("foo"));
+
+    // remove an item, make sure it still works
+    list.pop_front();
+    QVERIFY(list.size() == 1);
+    QCOMPARE(*list.begin(), QLatin1String("bar"));
+}
+
+void tst_QList::end() const
+{
+    QList<QString> list;
+    list << "foo" << "bar";
+
+    QCOMPARE(*--list.end(), QLatin1String("bar"));
+
+    // remove an item, make sure it still works
+    list.pop_back();
+    QVERIFY(list.size() == 1);
+    QCOMPARE(*--list.end(), QLatin1String("foo"));
+}
+
+void tst_QList::contains() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    QVERIFY(list.contains(QLatin1String("foo")) == true);
+    QVERIFY(list.contains(QLatin1String("pirates")) != true);
+
+    // add it and make sure it matches
+    list.append(QLatin1String("ninjas"));
+    QVERIFY(list.contains(QLatin1String("ninjas")) == true);
+}
+
+void tst_QList::count() const
+{
+    QList<QString> list;
+
+    // starts empty
+    QVERIFY(list.count() == 0);
+
+    // goes up
+    list.append(QLatin1String("foo"));
+    QVERIFY(list.count() == 1);
+
+    // and up
+    list.append(QLatin1String("bar"));
+    QVERIFY(list.count() == 2);
+
+    // and down
+    list.pop_back();
+    QVERIFY(list.count() == 1);
+
+    // and empty. :)
+    list.pop_back();
+    QVERIFY(list.count() == 0);
+}
+
+void tst_QList::empty() const
+{
+    QList<QString> list;
+
+    // make sure it starts empty
+    QVERIFY(list.empty());
+
+    // and doesn't stay empty
+    list.append(QLatin1String("foo"));
+    QVERIFY(!list.empty());
+
+    // and goes back to being empty
+    list.pop_back();
+    QVERIFY(list.empty());
+}
+
+void tst_QList::endsWith() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    // test it returns correctly in both cases
+    QVERIFY(list.endsWith(QLatin1String("baz")));
+    QVERIFY(!list.endsWith(QLatin1String("bar")));
+
+    // remove an item and make sure the end item changes
+    list.pop_back();
+    QVERIFY(list.endsWith(QLatin1String("bar")));
+}
+
+void tst_QList::lastIndexOf() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    // one instance of the target item
+    QVERIFY(list.lastIndexOf(QLatin1String("baz")) == 2);
+
+    // shouldn't find this
+    QVERIFY(list.lastIndexOf(QLatin1String("shouldntfindme")) == -1);
+
+    // multiple instances
+    list.append("baz");
+    list.append("baz");
+    QVERIFY(list.lastIndexOf(QLatin1String("baz")) == 4);
+
+    // search from the middle to find the last one
+    QVERIFY(list.lastIndexOf(QLatin1String("baz"), 3) == 3);
+
+    // try find none
+    QVERIFY(list.lastIndexOf(QLatin1String("baz"), 1) == -1);
+}
+
+void tst_QList::move() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    // move an item
+    list.move(0, list.count() - 1);
+    QCOMPARE(list, QList<QString>() << "bar" << "baz" << "foo");
+
+    // move it back
+    list.move(list.count() - 1, 0);
+    QCOMPARE(list, QList<QString>() << "foo" << "bar" << "baz");
+
+    // move an item in the middle
+    list.move(1, 0);
+    QCOMPARE(list, QList<QString>() << "bar" << "foo" << "baz");
+}
+
+void tst_QList::removeAll() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    // remove one instance
+    list.removeAll(QLatin1String("bar"));
+    QCOMPARE(list, QList<QString>() << "foo" << "baz");
+
+    // many instances
+    list << "foo" << "bar" << "baz";
+    list << "foo" << "bar" << "baz";
+    list << "foo" << "bar" << "baz";
+    list.removeAll(QLatin1String("bar"));
+    QCOMPARE(list, QList<QString>() << "foo" << "baz" << "foo" << "baz" << "foo" << "baz" << "foo" << "baz");
+
+    // try remove something that doesn't exist
+    list.removeAll(QLatin1String("you won't remove anything I hope"));
+    QCOMPARE(list, QList<QString>() << "foo" << "baz" << "foo" << "baz" << "foo" << "baz" << "foo" << "baz");
+}
+
+void tst_QList::removeAt() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    // middle
+    list.removeAt(1);
+    QCOMPARE(list, QList<QString>() << "foo" << "baz");
+
+    // start
+    list.removeAt(0);
+    QCOMPARE(list, QList<QString>() << "baz");
+
+    // final
+    list.removeAt(0);
+    QCOMPARE(list, QList<QString>());
+}
+
+void tst_QList::removeOne() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    // middle
+    list.removeOne(QLatin1String("bar"));
+    QCOMPARE(list, QList<QString>() << "foo" << "baz");
+
+    // start
+    list.removeOne(QLatin1String("foo"));
+    QCOMPARE(list, QList<QString>() << "baz");
+
+    // last
+    list.removeOne(QLatin1String("baz"));
+    QCOMPARE(list, QList<QString>());
+
+    // make sure it really only removes one :)
+    list << "foo" << "foo";
+    list.removeOne("foo");
+    QCOMPARE(list, QList<QString>() << "foo");
+
+    // try remove something that doesn't exist
+    list.removeOne(QLatin1String("you won't remove anything I hope"));
+    QCOMPARE(list, QList<QString>() << "foo");
+}
+
+void tst_QList::replace() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    // start
+    list.replace(0, "moo");
+    QCOMPARE(list, QList<QString>() << "moo" << "bar" << "baz");
+
+    // middle
+    list.replace(1, "cow");
+    QCOMPARE(list, QList<QString>() << "moo" << "cow" << "baz");
+
+    // end
+    list.replace(2, "milk");
+    QCOMPARE(list, QList<QString>() << "moo" << "cow" << "milk");
+}
+
+void tst_QList::startsWith() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    // make sure it starts ok
+    QVERIFY(list.startsWith(QLatin1String("foo")));
+
+    // remove an item
+    list.removeFirst();
+    QVERIFY(list.startsWith(QLatin1String("bar")));
+}
+
+void tst_QList::swap() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    // swap
+    list.swap(0, 2);
+    QCOMPARE(list, QList<QString>() << "baz" << "bar" << "foo");
+
+    // swap again
+    list.swap(1, 2);
+    QCOMPARE(list, QList<QString>() << "baz" << "foo" << "bar");
+}
+
+void tst_QList::takeAt() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    QCOMPARE(list.takeAt(0), QLatin1String("foo"));
+    QVERIFY(list.size() == 2);
+    QCOMPARE(list.takeAt(1), QLatin1String("baz"));
+    QVERIFY(list.size() == 1);
+    QCOMPARE(list.takeAt(0), QLatin1String("bar"));
+    QVERIFY(list.size() == 0);
+}
+
+void tst_QList::takeFirst() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    QCOMPARE(list.takeFirst(), QLatin1String("foo"));
+    QVERIFY(list.size() == 2);
+    QCOMPARE(list.takeFirst(), QLatin1String("bar"));
+    QVERIFY(list.size() == 1);
+    QCOMPARE(list.takeFirst(), QLatin1String("baz"));
+    QVERIFY(list.size() == 0);
+}
+
+void tst_QList::takeLast() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    QCOMPARE(list.takeLast(), QLatin1String("baz"));
+    QCOMPARE(list.takeLast(), QLatin1String("bar"));
+    QCOMPARE(list.takeLast(), QLatin1String("foo"));
+}
+
+void tst_QList::toSet() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    // no duplicates
+    QCOMPARE(list.toSet(), QSet<QString>() << "foo" << "bar" << "baz");
+    QCOMPARE(list, QList<QString>() << "foo" << "bar" << "baz");
+
+    // duplicates (is this more of a QSet test?)
+    list << "foo" << "bar" << "baz";
+    QCOMPARE(list.toSet(), QSet<QString>() << "foo" << "bar" << "baz");
+    QCOMPARE(list, QList<QString>() << "foo" << "bar" << "baz" << "foo" << "bar" << "baz");
+}
+
+void tst_QList::toStdList() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    // yuck.
+    std::list<QString> slist;
+    slist.push_back(QLatin1String("foo"));
+    slist.push_back(QLatin1String("bar"));
+    slist.push_back(QLatin1String("baz"));
+
+    QCOMPARE(list.toStdList(), slist);
+    QCOMPARE(list, QList<QString>() << "foo" << "bar" << "baz");
+}
+
+void tst_QList::toVector() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    QCOMPARE(list.toVector(), QVector<QString>() << "foo" << "bar" << "baz");
+}
+
+void tst_QList::value() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    // test real values
+    QCOMPARE(list.value(0), QLatin1String("foo"));
+    QCOMPARE(list.value(2), QLatin1String("baz"));
+
+    // test empty default
+    QCOMPARE(list.value(3), QString());
+    QCOMPARE(list.value(-1), QString());
+
+    // test defaults
+    QLatin1String defaultstr("default");
+    QCOMPARE(list.value(-1, defaultstr), defaultstr);
+    QCOMPARE(list.value(3, defaultstr), defaultstr);
+}
+
+void tst_QList::testOperators() const
+{
+    QList<QString> list;
+    list << "foo" << "bar" << "baz";
+
+    QList<QString> listtwo;
+    listtwo << "foo" << "bar" << "baz";
+
+    // test equal
+    QVERIFY(list == listtwo);
+
+    // not equal
+    listtwo.append("not equal");
+    QVERIFY(list != listtwo);
+
+    // +=
+    list += listtwo;
+    QVERIFY(list.size() == 7);
+    QVERIFY(listtwo.size() == 4);
+    QCOMPARE(list, QList<QString>() << "foo" << "bar" << "baz" << "foo" << "bar" << "baz" << "not equal");
+
+    // =
+    list = listtwo;
+    QCOMPARE(list, listtwo);
+    QCOMPARE(list, QList<QString>() << "foo" << "bar" << "baz" << "not equal");
+
+    // []
+    QCOMPARE(list[0], QLatin1String("foo"));
+    QCOMPARE(list[list.size() - 1], QLatin1String("not equal"));
+}
+
+void tst_QList::testSTLIterators() const
+{
+    QList<QString> list;
+
+    // create a list
+    list << "foo" << "bar" << "baz";
+    QList<QString>::iterator it = list.begin();
+    QCOMPARE(*it, QLatin1String("foo")); it++;
+    QCOMPARE(*it, QLatin1String("bar")); it++;
+    QCOMPARE(*it, QLatin1String("baz")); it++;
+    QCOMPARE(it, list.end()); it--;
+
+    // walk backwards
+    QCOMPARE(*it, QLatin1String("baz")); it--;
+    QCOMPARE(*it, QLatin1String("bar")); it--;
+    QCOMPARE(*it, QLatin1String("foo"));
+
+    // test erase
+    it = list.erase(it);
+    QVERIFY(list.size() == 2);
+    QCOMPARE(*it, QLatin1String("bar"));
+
+    // test multiple erase
+    it = list.erase(it, it + 2);
+    QVERIFY(list.size() == 0);
+    QCOMPARE(it, list.end());
+
+    // insert again
+    it = list.insert(it, QLatin1String("foo"));
+    QVERIFY(list.size() == 1);
+    QCOMPARE(*it, QLatin1String("foo"));
+
+    // insert again
+    it = list.insert(it, QLatin1String("bar"));
+    QVERIFY(list.size() == 2);
+    QCOMPARE(*it++, QLatin1String("bar"));
+    QCOMPARE(*it, QLatin1String("foo"));
+}
+
 QTEST_APPLESS_MAIN(tst_QList)
 #include "tst_qlist.moc"
diff --git a/tools/qdoc3/htmlgenerator.cpp b/tools/qdoc3/htmlgenerator.cpp
index 6b7d350..8e3b38c 100644
--- a/tools/qdoc3/htmlgenerator.cpp
+++ b/tools/qdoc3/htmlgenerator.cpp
@@ -259,6 +259,9 @@ void HtmlGenerator::initializeGenerator(const Config &config)
     postHeader = config.getString(HtmlGenerator::format() +
                                   Config::dot +
                                   HTMLGENERATOR_POSTHEADER);
+    postPostHeader = config.getString(HtmlGenerator::format() +
+                                      Config::dot +
+                                      HTMLGENERATOR_POSTPOSTHEADER);
     footer = config.getString(HtmlGenerator::format() +
                               Config::dot +
                               HTMLGENERATOR_FOOTER);
@@ -1671,31 +1674,44 @@ QString HtmlGenerator::fileExtension(const Node * /* node */) const
     return "html";
 }
 
-#if 0
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-  <title>Qt Reference Documentation</title>
-  <link rel="stylesheet" type="text/css" href="style/style.css" />
-  <!--[if IE]>
-	<meta name="MSSmartTagsPreventParsing" content="true">
-	<meta http-equiv="imagetoolbar" content="no">
-	<![endif]-->
-  <!--[if lt IE 7]>
-	<link rel="stylesheet" type="text/css" href="style/style_ie6.css">
-	<![endif]-->
-  <!--[if IE 7]>
-	<link rel="stylesheet" type="text/css" href="style/style_ie7.css">
-	<![endif]-->
-  <!--[if IE 8]>
-	<link rel="stylesheet" type="text/css" href="style/style_ie8.css">
-	<![endif]-->
-
-  <script src="scripts/jquery.js" type="text/javascript"></script>
-
-</head>
-#endif
+void HtmlGenerator::generateBreadCrumbs(const QString& title,
+                                        const Node *node,
+                                        CodeMarker *marker)
+{
+    Text breadcrumb;
+    if (node->type() == Node::Class) {
+        ClassNode* cn = static_cast<const ClassNode*>(node);
+        QString name =  node->moduleName();
+        if (!name.isEmpty()) {
+            out() << "              <li>";
+            breadcrumb << Atom(Atom::AutoLink,name);
+            generateText(breadcrumb, node, marker);
+            out() << "</li>\n";
+        }
+        breadcrumb.clear();
+        if (!cn->name().isEmpty()) {
+            out() << "              <li>";
+            breadcrumb << Atom(Atom::AutoLink,cn->name());
+            generateText(breadcrumb, 0, marker);
+            out() << "</li>\n";
+        }
+    }
+    else if (node->type() == Node::Fake) {
+        const FakeNode* fn = static_cast<const FakeNode*>(node);
+        if (node->subType() == Node::Module) {
+        }
+        else if (node->subType() == Node::Page) {
+        }
+        else if (node->subType() == Node::QmlClass) {
+        }
+        else if (node->subType() == Node::Example) {
+        }
+    }
+    else if (node->type() == Node::Namespace) {
+        const NamespaceNode* nsn = static_cast<const NamespaceNode*>(node);
+    }
+}
+
 
 void HtmlGenerator::generateHeader(const QString& title,
                                    const Node *node,
@@ -1748,9 +1764,13 @@ void HtmlGenerator::generateHeader(const QString& title,
     else
         out() << "<body class=\"\">\n";
 
+#ifdef GENERATE_MAC_REFS    
     if (mainPage)
         generateMacRef(node, marker);
+#endif    
     out() << QString(postHeader).replace("\\" + COMMAND_VERSION, myTree->version());
+    generateBreadCrumbs(title,node,marker);
+    out() << QString(postPostHeader).replace("\\" + COMMAND_VERSION, myTree->version());
 
 #if 0 // Removed for new docf format. MWS
     if (node && !node->links().empty())
@@ -3687,10 +3707,14 @@ void HtmlGenerator::generateDetailedMember(const Node *node,
 {
     const EnumNode *enume;
 
+#ifdef GENERATE_MAC_REFS    
     generateMacRef(node, marker);
+#endif    
     if (node->type() == Node::Enum
             && (enume = static_cast<const EnumNode *>(node))->flagsType()) {
+#ifdef GENERATE_MAC_REFS    
         generateMacRef(enume->flagsType(), marker);
+#endif        
         out() << "<h3 class=\"flags\">";
         out() << "<a name=\"" + refForNode(node) + "\"></a>";
         generateSynopsis(enume, relative, marker, CodeMarker::Detailed);
@@ -4204,6 +4228,10 @@ void HtmlGenerator::generateStatus(const Node *node, CodeMarker *marker)
     }
 }
 
+#ifdef GENERATE_MAC_REFS    
+/*
+  No longer valid.
+ */
 void HtmlGenerator::generateMacRef(const Node *node, CodeMarker *marker)
 {
     if (!pleaseGenerateMacRef || marker == 0)
@@ -4213,6 +4241,7 @@ void HtmlGenerator::generateMacRef(const Node *node, CodeMarker *marker)
     foreach (const QString &macRef, macRefs)
         out() << "<a name=\"" << "//apple_ref/" << macRef << "\"></a>\n";
 }
+#endif
 
 void HtmlGenerator::beginLink(const QString &link,
                               const Node *node,
@@ -4314,7 +4343,9 @@ void HtmlGenerator::generateDetailedQmlMember(const Node *node,
                                               CodeMarker *marker)
 {
     const QmlPropertyNode* qpn = 0;
+#ifdef GENERATE_MAC_REFS    
     generateMacRef(node, marker);
+#endif    
     out() << "<div class=\"qmlitem\">";
     if (node->subType() == Node::QmlPropertyGroup) {
         const QmlPropGroupNode* qpgn = static_cast<const QmlPropGroupNode*>(node);
diff --git a/tools/qdoc3/htmlgenerator.h b/tools/qdoc3/htmlgenerator.h
index 2a365e9..68e620e 100644
--- a/tools/qdoc3/htmlgenerator.h
+++ b/tools/qdoc3/htmlgenerator.h
@@ -131,6 +131,9 @@ class HtmlGenerator : public PageGenerator
                                   const Node *relative,
                                   CodeMarker *marker, 
                                   const Atom *atom = 0);
+    void generateBreadCrumbs(const QString& title,
+                             const Node *node,
+                             CodeMarker *marker);
     void generateHeader(const QString& title, const Node *node = 0,
                         CodeMarker *marker = 0, bool mainPage = true);
     void generateTitle(const QString& title, 
@@ -262,7 +265,9 @@ class HtmlGenerator : public PageGenerator
     virtual void generateIndex(const QString &fileBase, 
                                const QString &url,
                                const QString &title);
+#ifdef GENERATE_MAC_REFS    
     void generateMacRef(const Node *node, CodeMarker *marker);
+#endif
     void beginLink(const QString &link, 
                    const Node *node, 
                    const Node *relative, 
@@ -303,6 +308,7 @@ class HtmlGenerator : public PageGenerator
     QRegExp funcLeftParen;
     QString style;
     QString postHeader;
+    QString postPostHeader;
     QString footer;
     QString address;
     bool pleaseGenerateMacRef;
@@ -337,8 +343,9 @@ class HtmlGenerator : public PageGenerator
 
 #define HTMLGENERATOR_ADDRESS           "address"
 #define HTMLGENERATOR_FOOTER            "footer"
-#define HTMLGENERATOR_GENERATEMACREFS    "generatemacrefs" // ### document me
+#define HTMLGENERATOR_GENERATEMACREFS   "generatemacrefs" // ### document me
 #define HTMLGENERATOR_POSTHEADER        "postheader"
+#define HTMLGENERATOR_POSTPOSTHEADER    "postpostheader"
 #define HTMLGENERATOR_STYLE             "style"
 #define HTMLGENERATOR_STYLESHEETS       "stylesheets"
 #define HTMLGENERATOR_CUSTOMHEADELEMENTS "customheadelements"
diff --git a/tools/qdoc3/test/qt-html-templates.qdocconf b/tools/qdoc3/test/qt-html-templates.qdocconf
index 8253c45..944a32c 100644
--- a/tools/qdoc3/test/qt-html-templates.qdocconf
+++ b/tools/qdoc3/test/qt-html-templates.qdocconf
@@ -87,8 +87,9 @@ HTML.postheader         = " <div class=\"header\" id=\"qtdocheader\">\n" \
 			  "          <div class=\"breadcrumb toolblock\">\n" \
 			  "            <ul>\n" \
 			  "              <li class=\"first\"><a href=\"index.html\">Home</a></li>\n" \
-			  "              <!--  Bread crumbs goes here -->\n" \
-			  "            </ul>\n" \
+			  "              <!--  Bread crumbs goes here -->\n"
+
+HTML.postpostheader     = "            </ul>\n" \
 			  "          </div>\n" \
 			  "          <div class=\"toolbuttons toolblock\">\n" \
 			  "            <ul>\n" \
diff --git a/tools/qdoc3/text.h b/tools/qdoc3/text.h
index fa3ecda..879f6da 100644
--- a/tools/qdoc3/text.h
+++ b/tools/qdoc3/text.h
@@ -75,6 +75,7 @@ class Text
     const Atom *lastAtom() const { return last; }
     Text subText(Atom::Type left, Atom::Type right, const Atom *from = 0) const;
     void dump() const;
+    void clear();
 
     static Text subText(const Atom *begin, const Atom *end = 0);
     static Text sectionHeading(const Atom *sectionBegin);
@@ -82,7 +83,6 @@ class Text
     static int compare(const Text &text1, const Text &text2);
 
  private:
-    void clear();
 
     Atom *first;
     Atom *last;