Initial import of statemachine branch from the old kinetic repository

1 files changed, 469 insertions, 0 deletions

diff --git a/src/gui/widgets/qmainwindowlayout_mac.mm b/src/gui/widgets/qmainwindowlayout_mac.mm
new file mode 100644
index 0000000..950f758
--- /dev/null
+++ b/src/gui/widgets/qmainwindowlayout_mac.mm
@@ -0,0 +1,469 @@
+#include <private/qmainwindowlayout_p.h>
+#include <qtoolbar.h>
+#include <private/qtoolbarlayout_p.h>
+#include <private/qt_cocoa_helpers_mac_p.h>
+
+#ifndef QT_MAC_USE_COCOA
+#include <Carbon/Carbon.h>
+#else
+#include <private/qcocoatoolbardelegate_mac_p.h>
+#endif
+
+QT_BEGIN_NAMESPACE
+#ifdef QT_NAMESPACE
+
+// namespace up the stuff
+#define SS(x) #x
+#define S0(x) SS(x)
+#define S "com.trolltech.qt-" S0(QT_NAMESPACE) ".qmainwindow.qtoolbarInHIToolbar"
+#define SToolbar "com.trolltech.qt-" S0(QT_NAMESPACE) ".hitoolbar-qtoolbar"
+#define SNSToolbar "com.trolltech.qt-" S0(QT_NAMESPACE) ".qtoolbarInNSToolbar"
+#define MacToolbar "com.trolltech.qt-" S0(QT_NAMESPACE) ".qmainwindow.mactoolbar"
+
+#ifndef QT_MAC_USE_COCOA
+static CFStringRef kQToolBarHIToolbarItemClassID = CFSTR(S);
+static CFStringRef kQToolBarHIToolbarIdentifier = CFSTR(SToolbar);
+#else
+static NSString *kQToolBarNSToolbarIdentifier = @SNSToolbar;
+#endif
+static CFStringRef kQMainWindowMacToolbarID = CFSTR(MacToolbar);
+#undef SS
+#undef S0
+#undef S
+#undef SToolbar
+#undef SNSToolbar
+#undef MacToolbar
+
+#else
+#ifndef QT_MAC_USE_COCOA
+static CFStringRef kQToolBarHIToolbarItemClassID = CFSTR("com.trolltech.qt.qmainwindow.qtoolbarInHIToolbar");
+static CFStringRef kQToolBarHIToolbarIdentifier = CFSTR("com.trolltech.qt.hitoolbar-qtoolbar");
+#else
+static NSString *kQToolBarNSToolbarIdentifier = @"com.trolltech.qt.qmainwindow.qtoolbarInNSToolbar";
+#endif
+static CFStringRef kQMainWindowMacToolbarID = CFSTR("com.trolltech.qt.qmainwindow.mactoolbar");
+#endif // QT_NAMESPACE
+
+#ifndef QT_MAC_USE_COCOA
+
+static const int kEventParamQToolBar = 'QTBR';
+static const int kEventParamQMainWindowLayout = 'QMWL';
+
+const EventTypeSpec qtoolbarEvents[] =
+{
+    { kEventClassHIObject, kEventHIObjectConstruct },
+    { kEventClassHIObject, kEventHIObjectDestruct },
+    { kEventClassHIObject, kEventHIObjectInitialize },
+    { kEventClassToolbarItem, kEventToolbarItemCreateCustomView }
+};
+
+struct QToolBarInHIToolbarInfo
+{
+    QToolBarInHIToolbarInfo(HIToolbarItemRef item)
+        : toolbarItem(item), mainWindowLayout(0)
+    {}
+    HIToolbarItemRef toolbarItem;
+    QMainWindowLayout *mainWindowLayout;
+};
+
+OSStatus QMainWindowLayout::qtoolbarInHIToolbarHandler(EventHandlerCallRef inCallRef,
+                                                       EventRef event, void *data)
+{
+    OSStatus result = eventNotHandledErr;
+    QToolBarInHIToolbarInfo *object = static_cast<QToolBarInHIToolbarInfo *>(data);
+
+    switch (GetEventClass(event)) {
+        case kEventClassHIObject:
+            switch (GetEventKind(event)) {
+                case kEventHIObjectConstruct:
+                {
+                    HIObjectRef toolbarItem;
+                    GetEventParameter(event, kEventParamHIObjectInstance, typeHIObjectRef,
+                                      0, sizeof( HIObjectRef ), 0, &toolbarItem);
+
+                    QToolBarInHIToolbarInfo *item = new QToolBarInHIToolbarInfo(toolbarItem);
+                    SetEventParameter(event, kEventParamHIObjectInstance, typeVoidPtr,
+                                      sizeof(void *), &item);
+                    result = noErr;
+                }
+                    break;
+                case kEventHIObjectInitialize:
+                    result = CallNextEventHandler(inCallRef, event);
+                    if (result == noErr) {
+                        QToolBar *toolbar = 0;
+                        QMainWindowLayout *layout = 0;
+                        GetEventParameter(event, kEventParamQToolBar, typeVoidPtr,
+                                          0, sizeof(void *), 0, &toolbar);
+                        GetEventParameter(event, kEventParamQMainWindowLayout, typeVoidPtr,
+                                          0, sizeof(void *), 0, &layout);
+                        object->mainWindowLayout = layout;
+                        object->mainWindowLayout->unifiedToolbarHash.insert(object->toolbarItem, toolbar);
+                        HIToolbarItemChangeAttributes(object->toolbarItem,
+                                                      kHIToolbarItemLabelDisabled, 0);
+                    }
+                    break;
+
+                case kEventHIObjectDestruct:
+                    delete object;
+                    result = noErr;
+                    break;
+            }
+            break;
+
+        case kEventClassToolbarItem:
+            switch (GetEventKind(event))
+        {
+            case kEventToolbarItemCreateCustomView:
+            {
+                QToolBar *toolbar
+                = object->mainWindowLayout->unifiedToolbarHash.value(object->toolbarItem);
+                if (toolbar) {
+                    HIViewRef hiview = HIViewRef(toolbar->winId());
+                    SetEventParameter(event, kEventParamControlRef, typeControlRef,
+                                      sizeof(HIViewRef), &hiview);
+                    result = noErr;
+                }
+            }
+                break;
+        }
+            break;
+    }
+    return result;
+}
+
+void QMainWindowLayout::qtMacHIToolbarRegisterQToolBarInHIToolborItemClass()
+{
+    static bool registered = false;
+
+    if (!registered) {
+        HIObjectRegisterSubclass( kQToolBarHIToolbarItemClassID,
+                                 kHIToolbarItemClassID, 0, QMainWindowLayout::qtoolbarInHIToolbarHandler,
+                                 GetEventTypeCount(qtoolbarEvents), qtoolbarEvents, 0, 0 );
+        registered = true;
+    }
+}
+
+static void GetToolbarAllowedItems(CFMutableArrayRef array)
+{
+    CFArrayAppendValue(array, kQToolBarHIToolbarIdentifier);
+}
+
+HIToolbarItemRef QMainWindowLayout::createQToolBarInHIToolbarItem(QToolBar *toolbar,
+                                                                  QMainWindowLayout *layout)
+{
+    QMainWindowLayout::qtMacHIToolbarRegisterQToolBarInHIToolborItemClass();
+
+    EventRef event;
+    HIToolbarItemRef result = 0;
+
+    CFStringRef identifier = kQToolBarHIToolbarIdentifier;
+    UInt32 options = kHIToolbarItemAllowDuplicates;
+
+    CreateEvent(0, kEventClassHIObject, kEventHIObjectInitialize,
+                GetCurrentEventTime(), 0, &event);
+    SetEventParameter(event, kEventParamToolbarItemIdentifier, typeCFStringRef,
+                      sizeof(CFStringRef), &identifier);
+    SetEventParameter(event, kEventParamAttributes, typeUInt32, sizeof(UInt32), &options);
+    SetEventParameter(event, kEventParamQToolBar, typeVoidPtr, sizeof(void *), &toolbar);
+    SetEventParameter(event, kEventParamQMainWindowLayout, typeVoidPtr, sizeof(void *), &layout);
+
+    HIObjectCreate(kQToolBarHIToolbarItemClassID, event,
+                   static_cast<HIObjectRef *>(&result));
+
+    ReleaseEvent(event);
+    return result;
+
+}
+
+HIToolbarItemRef QMainWindowLayout::CreateToolbarItemForIdentifier(CFStringRef identifier,
+                                                                   CFTypeRef data)
+{
+    HIToolbarItemRef item = 0;
+    if (CFStringCompare(kQToolBarHIToolbarIdentifier, identifier,
+                        kCFCompareBackwards) == kCFCompareEqualTo) {
+        if (data && CFGetTypeID(data) == CFArrayGetTypeID()) {
+            CFArrayRef array = static_cast<CFArrayRef>(data);
+            QToolBar *toolbar = static_cast<QToolBar *>(const_cast<void *>(CFArrayGetValueAtIndex(array, 0)));
+            QMainWindowLayout *layout = static_cast<QMainWindowLayout *>(const_cast<void *>(CFArrayGetValueAtIndex(array, 1)));
+            item = createQToolBarInHIToolbarItem(toolbar, layout);
+        }
+    }
+    return item;
+}
+
+static const EventTypeSpec kToolbarEvents[] = {
+{ kEventClassToolbar, kEventToolbarGetDefaultIdentifiers },
+{ kEventClassToolbar, kEventToolbarGetAllowedIdentifiers },
+{ kEventClassToolbar, kEventToolbarCreateItemWithIdentifier },
+{ kEventClassToolbar, kEventToolbarItemAdded },
+{ kEventClassToolbar, kEventToolbarItemRemoved }
+};
+
+OSStatus QMainWindowLayout::qtmacToolbarDelegate(EventHandlerCallRef, EventRef event, void *data)
+{
+    QMainWindowLayout *mainWindowLayout = static_cast<QMainWindowLayout *>(data);
+    OSStatus            result = eventNotHandledErr;
+    CFMutableArrayRef   array;
+    CFStringRef         identifier;
+    switch (GetEventKind(event)) {
+        case kEventToolbarGetDefaultIdentifiers:
+        case kEventToolbarGetAllowedIdentifiers:
+            GetEventParameter(event, kEventParamMutableArray, typeCFMutableArrayRef, 0,
+                              sizeof(CFMutableArrayRef), 0, &array);
+            GetToolbarAllowedItems(array);
+            result = noErr;
+            break;
+        case kEventToolbarCreateItemWithIdentifier: {
+            HIToolbarItemRef item;
+            CFTypeRef data = 0;
+            OSStatus err = GetEventParameter(event, kEventParamToolbarItemIdentifier, typeCFStringRef,
+                                             0, sizeof(CFStringRef), 0, &identifier);
+            err = GetEventParameter(event, kEventParamToolbarItemConfigData, typeCFTypeRef,
+                                    0, sizeof(CFTypeRef), 0, &data);
+            item = CreateToolbarItemForIdentifier(identifier, data);
+            if (item) {
+                result = SetEventParameter(event, kEventParamToolbarItem, typeHIToolbarItemRef,
+                                           sizeof(HIToolbarItemRef), &item );
+            }
+            break;
+        }
+        case kEventToolbarItemAdded: {
+            // Double check that our "view" of the toolbar is similar.
+            HIToolbarItemRef item;
+            CFIndex index;
+            if (GetEventParameter(event, kEventParamToolbarItem, typeHIToolbarItemRef,
+                                  0, sizeof(HIToolbarItemRef), 0, &item) == noErr
+                && GetEventParameter(event, kEventParamIndex, typeCFIndex, 0,
+                                     sizeof(CFIndex), 0, &index) == noErr) {
+                CFRetain(item); // We will watch this until it's removed from the list (or bust).
+                mainWindowLayout->toolbarItemsCopy.insert(index, item);
+                QToolBar *toolbar = mainWindowLayout->unifiedToolbarHash.value(item);
+                if (toolbar) {
+                    int toolbarIndex = mainWindowLayout->qtoolbarsInUnifiedToolbarList.indexOf(toolbar);
+                    if (index != toolbarIndex) {
+                        // Dang, we must be out of sync, rebuild it from the "toolbarItemsCopy"
+                        mainWindowLayout->qtoolbarsInUnifiedToolbarList.clear();
+                        for (int i = 0; i < mainWindowLayout->toolbarItemsCopy.size(); ++i) {
+                            // This will either append the correct toolbar or an
+                            // null toolbar. This is fine because this list
+                            // is really only kept to make sure that things are but in the right order.
+                            mainWindowLayout->qtoolbarsInUnifiedToolbarList.append(
+                                                                                   mainWindowLayout->unifiedToolbarHash.value(mainWindowLayout->
+                                                                                                                              toolbarItemsCopy.at(i)));
+                        }
+                    }
+                }
+            }
+            break;
+        }
+        case kEventToolbarItemRemoved: {
+            HIToolbarItemRef item;
+            if (GetEventParameter(event, kEventParamToolbarItem, typeHIToolbarItemRef,
+                                  0, sizeof(HIToolbarItemRef), 0, &item) == noErr) {
+                mainWindowLayout->unifiedToolbarHash.remove(item);
+                for (int i = 0; i < mainWindowLayout->toolbarItemsCopy.size(); ++i) {
+                    if (mainWindowLayout->toolbarItemsCopy.at(i) == item) {
+                        // I know about it, so release it.
+                        mainWindowLayout->toolbarItemsCopy.removeAt(i);
+                        mainWindowLayout->qtoolbarsInUnifiedToolbarList.removeAt(i);
+                        CFRelease(item);
+                        break;
+                    }
+                }
+            }
+            break;
+        }
+    }
+    return result;
+}
+#endif // ! QT_MAC_USE_COCOA
+
+#ifndef kWindowUnifiedTitleAndToolbarAttribute
+#define kWindowUnifiedTitleAndToolbarAttribute (1 << 7)
+#endif
+
+void QMainWindowLayout::updateHIToolBarStatus()
+{
+    bool useMacToolbar = layoutState.mainWindow->unifiedTitleAndToolBarOnMac();
+    if (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_4) {
+#ifndef QT_MAC_USE_COCOA
+        if (useMacToolbar) {
+            ChangeWindowAttributes(qt_mac_window_for(layoutState.mainWindow),
+                                   kWindowUnifiedTitleAndToolbarAttribute, 0);
+        } else {
+            ChangeWindowAttributes(qt_mac_window_for(layoutState.mainWindow),
+                                   0, kWindowUnifiedTitleAndToolbarAttribute);
+        }
+#endif
+        macWindowToolbarShow(layoutState.mainWindow, useMacToolbar);
+    }
+
+    layoutState.mainWindow->setUpdatesEnabled(false);  // reduces a little bit of flicker, not all though
+    if (!useMacToolbar) {
+        OSWindowRef windowRef = qt_mac_window_for(parentWidget());
+        macWindowToolbarShow(parentWidget(), false);
+        // Move everything out of the HIToolbar into the main toolbar.
+        while (!qtoolbarsInUnifiedToolbarList.isEmpty()) {
+            // Should shrink the list by one every time.
+            layoutState.mainWindow->addToolBar(Qt::TopToolBarArea, qtoolbarsInUnifiedToolbarList.first());
+        }
+        macWindowToolbarSet(windowRef, NULL);
+    } else {
+        QList<QToolBar *> toolbars = layoutState.mainWindow->findChildren<QToolBar *>();
+        for (int i = 0; i < toolbars.size(); ++i) {
+            QToolBar *toolbar = toolbars.at(i);
+            if (toolBarArea(toolbar) == Qt::TopToolBarArea) {
+                removeWidget(toolbar);  // Do this here, because we are in an in-between state.
+                layoutState.mainWindow->addToolBar(Qt::TopToolBarArea, toolbar);
+            }
+        }
+    }
+    layoutState.mainWindow->setUpdatesEnabled(true);
+}
+
+void QMainWindowLayout::insertIntoMacToolbar(QToolBar *before, QToolBar *toolbar)
+{
+    // This layering could go on to one more level, but I decided to stop here.
+    // The HIToolbar and NSToolbar APIs are fairly similar as you will see.
+    if (toolbar == 0)
+        return;
+
+
+    QToolBarLayout *toolbarLayout = static_cast<QToolBarLayout *>(toolbar->layout());
+    toolbarSaveState.insert(toolbar, ToolBarSaveState(toolbar->isMovable(),
+                                                      toolbar->maximumSize()));
+
+    if (toolbarLayout->hasExpandFlag() == false)
+        toolbar->setMaximumSize(toolbar->sizeHint());
+
+    toolbar->setMovable(false);
+    toolbarLayout->setUsePopupMenu(true);
+    // Make the toolbar a child of the mainwindow to avoid creating a window.
+    toolbar->setParent(layoutState.mainWindow);
+    toolbar->createWinId();  // Now create the OSViewRef.
+
+    layoutState.mainWindow->createWinId();
+
+    OSWindowRef window = qt_mac_window_for(layoutState.mainWindow);
+    int beforeIndex = qtoolbarsInUnifiedToolbarList.indexOf(before);
+    if (beforeIndex == -1)
+        beforeIndex = qtoolbarsInUnifiedToolbarList.size();
+
+    int toolbarIndex = qtoolbarsInUnifiedToolbarList.indexOf(toolbar);
+#ifndef QT_MAC_USE_COCOA
+    HIToolbarRef macToolbar = NULL;
+    if ((GetWindowToolbar(window, &macToolbar) == noErr) && !macToolbar) {
+        HIToolbarCreate(kQMainWindowMacToolbarID,
+                        kHIToolbarItemAllowDuplicates, &macToolbar);
+        InstallEventHandler(HIObjectGetEventTarget(static_cast<HIToolbarRef>(macToolbar)),
+                            QMainWindowLayout::qtmacToolbarDelegate, GetEventTypeCount(kToolbarEvents),
+                            kToolbarEvents, this, 0);
+        HIToolbarSetDisplaySize(macToolbar, kHIToolbarDisplaySizeNormal);
+        HIToolbarSetDisplayMode(macToolbar, kHIToolbarDisplayModeIconOnly);
+        macWindowToolbarSet(window, macToolbar);
+        if (layoutState.mainWindow->isVisible())
+            macWindowToolbarShow(layoutState.mainWindow, true);
+        CFRelease(macToolbar);
+    }
+#else
+    QMacCocoaAutoReleasePool pool;
+    NSToolbar *macToolbar = [window toolbar];
+    if (macToolbar == nil) {
+        macToolbar = [[NSToolbar alloc] initWithIdentifier:(NSString *)kQMainWindowMacToolbarID];
+        [macToolbar setDisplayMode:NSToolbarDisplayModeIconOnly];
+        [macToolbar setSizeMode:NSToolbarSizeModeRegular];
+        [macToolbar setDelegate:[[QCocoaToolBarDelegate alloc] initWithMainWindowLayout:this]];
+        [window setToolbar:macToolbar];
+        [macToolbar release];
+    }
+#endif
+    if (toolbarIndex != -1) {
+        qtoolbarsInUnifiedToolbarList.removeAt(toolbarIndex);
+#ifndef QT_MAC_USE_COCOA
+        HIToolbarRemoveItemAtIndex(macToolbar, toolbarIndex);
+#else
+        [macToolbar removeItemAtIndex:toolbarIndex];
+#endif
+    }
+    qtoolbarsInUnifiedToolbarList.insert(beforeIndex, toolbar);
+#ifndef QT_MAC_USE_COCOA
+    QCFType<HIToolbarItemRef> outItem;
+    const QObject *stupidArray[] = { toolbar, this };
+    QCFType<CFArrayRef> array = CFArrayCreate(0, reinterpret_cast<const void **>(&stupidArray),
+                                              2, 0);
+    HIToolbarCreateItemWithIdentifier(macToolbar, kQToolBarHIToolbarIdentifier,
+                                      array, &outItem);
+    HIToolbarInsertItemAtIndex(macToolbar, outItem, beforeIndex);
+#else
+    NSString *toolbarID = kQToolBarNSToolbarIdentifier;
+    toolbarID = [toolbarID stringByAppendingFormat:@"%p", toolbar];
+    cocoaItemIDToToolbarHash.insert(QCFString::toQString(CFStringRef(toolbarID)), toolbar);
+    [macToolbar insertItemWithItemIdentifier:toolbarID atIndex:beforeIndex];
+#endif
+}
+
+void QMainWindowLayout::removeFromMacToolbar(QToolBar *toolbar)
+{
+    QHash<void *, QToolBar *>::iterator it = unifiedToolbarHash.begin();
+    while (it != unifiedToolbarHash.end()) {
+        if (it.value() == toolbar) {
+            // Rescue our HIView and set it on the mainWindow again.
+            bool saveVisible = !toolbar->isHidden();
+            toolbar->setParent(0);
+            toolbar->setParent(parentWidget());
+            toolbar->setVisible(saveVisible);
+            ToolBarSaveState saveState = toolbarSaveState.value(toolbar);
+            static_cast<QToolBarLayout *>(toolbar->layout())->setUsePopupMenu(false);
+            toolbar->setMovable(saveState.movable);
+            toolbar->setMaximumSize(saveState.maximumSize);
+            toolbarSaveState.remove(toolbar);
+#ifndef QT_MAC_USE_COCOA
+            HIToolbarItemRef item = static_cast<HIToolbarItemRef>(it.key());
+            HIToolbarRemoveItemAtIndex(HIToolbarItemGetToolbar(item),
+                                       toolbarItemsCopy.indexOf(item));
+#else
+            NSToolbarItem *item = static_cast<NSToolbarItem *>(it.key());
+            [[qt_mac_window_for(layoutState.mainWindow->window()) toolbar]
+                removeItemAtIndex:toolbarItemsCopy.indexOf(item)];
+            // In Carbon this hash and list gets emptied via events. In Cocoa, we have to do it ourselves here.
+            it = unifiedToolbarHash.erase(it);
+            qtoolbarsInUnifiedToolbarList.removeAll(toolbar);
+#endif
+            break;
+        }
+        ++it;
+    }
+}
+
+void QMainWindowLayout::cleanUpMacToolbarItems()
+{
+    for (int i = 0; i < toolbarItemsCopy.size(); ++i)
+        CFRelease(toolbarItemsCopy.at(i));
+    toolbarItemsCopy.clear();
+    unifiedToolbarHash.clear();
+}
+
+void QMainWindowLayout::fixSizeInUnifiedToolbar(QToolBar *tb) const
+{
+    QHash<void *, QToolBar *>::const_iterator it = unifiedToolbarHash.constBegin();
+    NSToolbarItem *item = nil;
+    while (it != unifiedToolbarHash.constEnd()) {
+        if (tb == it.value()) {
+            item = static_cast<NSToolbarItem *>(it.key());
+            break;
+        }
+        ++it;
+    }
+    if (item) {
+        QMacCocoaAutoReleasePool pool;
+        QWidgetItem layoutItem(tb);
+        QSize size = layoutItem.maximumSize();
+        NSSize nssize = NSMakeSize(size.width(), size.height());
+        [item setMaxSize:nssize];
+        size = layoutItem.minimumSize();
+        nssize.width = size.width();
+        nssize.height = size.height();
+        [item setMinSize:nssize];
+    }
+}
+QT_END_NAMESPACE