whytofly
/
qt6-bb10
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Mac: Remove old unified toolbar implementation. 

This has been dead code in Qt 5 since WS_MAC isn't
defined any more.

The new implementation is far less intrusive and does
not require a separate layout.

Task-number: QTBUG-34411
Change-Id: I91bf2294086cb7334a0f56eb1bb97464d8d7b2e3
Reviewed-by: Gabriel de Dietrich <gabriel.dedietrich@digia.com>
bb10
Morten Johan Sørvig 2013-12-16 23:36:14 +01:00 committed by The Qt Project
parent ba507f6690
commit e1330ecfdc
8 changed files with 5 additions and 705 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

95
src/widgets/kernel/qwidget.cpp
View File

@ -5026,16 +5026,6 @@ void QWidgetPrivate::drawWidget(QPaintDevice *pdev, const QRegion &rgn, const QP
if (rgn.isEmpty())
return;
#ifdef Q_WS_MAC
if (qt_mac_clearDirtyOnWidgetInsideDrawWidget)
dirtyOnWidget = QRegion();
// We disable the rendering of QToolBar in the backingStore if
// it's supposed to be in the unified toolbar on Mac OS X.
if (backingStore && isInUnifiedToolbar)
return;
#endif // Q_WS_MAC
const bool asRoot = flags & DrawAsRoot;
bool onScreen = paintOnScreen();
@ -9403,26 +9393,13 @@ QWidget *QWidgetPrivate::childAt_helper(const QPoint &p, bool ignoreChildrenInDe
if (children.isEmpty())
return 0;
#ifdef Q_WS_MAC
Q_Q(const QWidget);
// Unified tool bars on the Mac require special handling since they live outside
// QMainWindow's geometry(). See commit: 35667fd45ada49269a5987c235fdedfc43e92bb8
bool includeFrame = q->isWindow() && qobject_cast<const QMainWindow *>(q)
&& static_cast<const QMainWindow *>(q)->unifiedTitleAndToolBarOnMac();
if (includeFrame)
return childAtRecursiveHelper(p, ignoreChildrenInDestructor, includeFrame);
#endif
if (!pointInsideRectAndMask(p))
return 0;
return childAtRecursiveHelper(p, ignoreChildrenInDestructor);
}
QWidget *QWidgetPrivate::childAtRecursiveHelper(const QPoint &p, bool ignoreChildrenInDestructor, bool includeFrame) const
QWidget *QWidgetPrivate::childAtRecursiveHelper(const QPoint &p, bool ignoreChildrenInDestructor) const
{
#ifndef Q_WS_MAC
Q_UNUSED(includeFrame);
#endif
for (int i = children.size() - 1; i >= 0; --i) {
QWidget *child = qobject_cast<QWidget *>(children.at(i));
if (!child || child->isWindow() || child->isHidden() || child->testAttribute(Qt::WA_TransparentForMouseEvents)
@ -9432,14 +9409,6 @@ QWidget *QWidgetPrivate::childAtRecursiveHelper(const QPoint &p, bool ignoreChil
// Map the point 'p' from parent coordinates to child coordinates.
QPoint childPoint = p;
#ifdef Q_WS_MAC
// 'includeFrame' is true if the child's parent is a top-level QMainWindow with an unified tool bar.
// An unified tool bar on the Mac lives outside QMainWindow's geometry(), so a normal
// QWidget::mapFromParent won't do the trick.
if (includeFrame && qobject_cast<QToolBar *>(child))
childPoint = qt_mac_nativeMapFromParent(child, p);
else
#endif
childPoint -= child->data->crect.topLeft();
// Check if the point hits the child.
@ -9614,13 +9583,7 @@ void QWidget::setParent(QWidget *parent, Qt::WindowFlags f)
bool newParent = (parent != parentWidget()) || !wasCreated || desktopWidget;
if (newParent && parent && !desktopWidget) {
if (testAttribute(Qt::WA_NativeWindow) && !qApp->testAttribute(Qt::AA_DontCreateNativeWidgetSiblings)
#ifdef Q_WS_MAC
// On Mac, toolbars inside the unified title bar will never overlap with
// siblings in the content view. So we skip enforce native siblings in that case
&& !d->isInUnifiedToolbar && parentWidget() && parentWidget()->isWindow()
#endif // Q_WS_MAC
)
if (testAttribute(Qt::WA_NativeWindow) && !qApp->testAttribute(Qt::AA_DontCreateNativeWidgetSiblings))
parent->d_func()->enforceNativeChildren();
else if (parent->d_func()->nativeChildrenForced() || parent->testAttribute(Qt::WA_PaintOnScreen))
setAttribute(Qt::WA_NativeWindow);
@ -9879,12 +9842,6 @@ void QWidget::repaint(const QRect &rect)
return;
if (hasBackingStoreSupport()) {
#ifdef Q_WS_MAC
if (qt_widget_private(this)->isInUnifiedToolbar) {
qt_widget_private(this)->unifiedSurface->renderToolbar(this, true);
return;
}
#endif // Q_WS_MAC
QTLWExtra *tlwExtra = window()->d_func()->maybeTopData();
if (tlwExtra && !tlwExtra->inTopLevelResize && tlwExtra->backingStore) {
tlwExtra->inRepaint = true;
@ -9914,12 +9871,6 @@ void QWidget::repaint(const QRegion &rgn)
return;
if (hasBackingStoreSupport()) {
#ifdef Q_WS_MAC
if (qt_widget_private(this)->isInUnifiedToolbar) {
qt_widget_private(this)->unifiedSurface->renderToolbar(this, true);
return;
}
#endif // Q_WS_MAC
QTLWExtra *tlwExtra = window()->d_func()->maybeTopData();
if (tlwExtra && !tlwExtra->inTopLevelResize && tlwExtra->backingStore) {
tlwExtra->inRepaint = true;
@ -9982,12 +9933,6 @@ void QWidget::update(const QRect &rect)
}
if (hasBackingStoreSupport()) {
#ifdef Q_WS_MAC
if (qt_widget_private(this)->isInUnifiedToolbar) {
qt_widget_private(this)->unifiedSurface->renderToolbar(this, true);
return;
}
#endif // Q_WS_MAC
QTLWExtra *tlwExtra = window()->d_func()->maybeTopData();
if (tlwExtra && !tlwExtra->inTopLevelResize && tlwExtra->backingStore)
tlwExtra->backingStoreTracker->markDirty(r, this);
@ -10017,12 +9962,6 @@ void QWidget::update(const QRegion &rgn)
}
if (hasBackingStoreSupport()) {
#ifdef Q_WS_MAC
if (qt_widget_private(this)->isInUnifiedToolbar) {
qt_widget_private(this)->unifiedSurface->renderToolbar(this, true);
return;
}
#endif // Q_WS_MAC
QTLWExtra *tlwExtra = window()->d_func()->maybeTopData();
if (tlwExtra && !tlwExtra->inTopLevelResize && tlwExtra->backingStore)
tlwExtra->backingStoreTracker->markDirty(r, this);
@ -10218,13 +10157,7 @@ void QWidget::setAttribute(Qt::WidgetAttribute attribute, bool on)
qApp->inputMethod()->commit();
qApp->inputMethod()->update(Qt::ImEnabled);
}
if (!qApp->testAttribute(Qt::AA_DontCreateNativeWidgetSiblings) && parentWidget()
#ifdef Q_WS_MAC
// On Mac, toolbars inside the unified title bar will never overlap with
// siblings in the content view. So we skip enforce native siblings in that case
&& !d->isInUnifiedToolbar && parentWidget()->isWindow()
#endif // Q_WS_MAC
)
if (!qApp->testAttribute(Qt::AA_DontCreateNativeWidgetSiblings) && parentWidget())
parentWidget()->d_func()->enforceNativeChildren();
if (on && !internalWinId() && testAttribute(Qt::WA_WState_Created))
d->createWinId();
@ -11544,28 +11477,6 @@ void QWidget::clearMask()
setMask(QRegion());
}
#ifdef Q_WS_MAC
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 // Q_WS_MAC
QT_END_NAMESPACE
#include "moc_qwidget.cpp"

3
src/widgets/kernel/qwidget_p.h
View File

@ -495,7 +495,7 @@ public:
void setConstraints_sys();
bool pointInsideRectAndMask(const QPoint &) const;
QWidget *childAt_helper(const QPoint &, bool) const;
QWidget *childAtRecursiveHelper(const QPoint &p, bool, bool includeFrame = false) const;
QWidget *childAtRecursiveHelper(const QPoint &p, bool) const;
void updateGeometry_helper(bool forceUpdate);
void getLayoutItemMargins(int *left, int *top, int *right, int *bottom) const;
@ -780,7 +780,6 @@ 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?

151
src/widgets/widgets/qcocoatoolbardelegate_mac.mm
View File

@ -1,151 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of the QtWidgets module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#import <private/qcocoatoolbardelegate_mac_p.h>
#include <private/qmainwindowlayout_p.h>
#include <private/qt_mac_p.h>
#include <private/qt_cocoa_helpers_mac_p.h>
#include <private/qcocoaview_mac_p.h>
#include <private/qwidget_p.h>
#include <qtoolbar.h>
#include <qlayout.h>
#include <qdebug.h>
QT_BEGIN_NAMESPACE
extern QWidgetPrivate *qt_widget_private(QWidget *widget);
QT_END_NAMESPACE
QT_FORWARD_DECLARE_CLASS(QMainWindowLayout);
QT_FORWARD_DECLARE_CLASS(QToolBar);
QT_FORWARD_DECLARE_CLASS(QCFString);
@implementation QT_MANGLE_NAMESPACE(QCocoaToolBarDelegate)
- (id)initWithMainWindowLayout:(QMainWindowLayout *)layout
{
self = [super init];
if (self) {
mainWindowLayout = layout;
}
return self;
}
- (NSArray *)toolbarAllowedItemIdentifiers:(NSToolbar *)toolbar
{
Q_UNUSED(toolbar);
return [NSArray arrayWithObject:@"org.qt-project.qt.nstoolbar-qtoolbar"];
}
- (NSArray *)toolbarDefaultItemIdentifiers:(NSToolbar *)toolbar
{
return [self toolbarAllowedItemIdentifiers:toolbar];
}
- (void)toolbarDidRemoveItem:(NSNotification *)notification
{
NSToolbarItem *item = [[notification userInfo] valueForKey:@"item"];
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);
[item release];
break;
}
}
}
- (NSToolbarItem *)toolbar:(NSToolbar *)nstoolbar itemForItemIdentifier:(NSString *)itemIdentifier
willBeInsertedIntoToolbar:(BOOL)flag
{
Q_UNUSED(flag);
Q_UNUSED(nstoolbar);
QToolBar *tb = mainWindowLayout->cocoaItemIDToToolbarHash.value(
QT_PREPEND_NAMESPACE(qt_mac_NSStringToQString)(itemIdentifier));
NSToolbarItem *item = nil;
if (tb) {
item = [[NSToolbarItem alloc] initWithItemIdentifier:itemIdentifier];
mainWindowLayout->unifiedToolbarHash.insert(item, tb);
}
return item;
}
- (void)toolbarWillAddItem:(NSNotification *)notification
{
NSToolbarItem *item = [[notification userInfo] valueForKey:@"item"];
QToolBar *tb = mainWindowLayout->cocoaItemIDToToolbarHash.value(
QT_PREPEND_NAMESPACE(qt_mac_NSStringToQString)([item itemIdentifier]));
if (!tb)
return; // I can't really do anything about this.
[item retain];
[item setView:QT_PREPEND_NAMESPACE(qt_mac_nativeview_for)(tb)];
NSArray *items = [[qt_mac_window_for(mainWindowLayout->layoutState.mainWindow->window()) toolbar] items];
int someIndex = 0;
for (NSToolbarItem *i in items) {
if (i == item)
break;
++someIndex;
}
mainWindowLayout->toolbarItemsCopy.insert(someIndex, item);
// This is synchronization code that was needed in Carbon, but may not be needed anymore here.
QToolBar *toolbar = mainWindowLayout->unifiedToolbarHash.value(item);
if (toolbar) {
int toolbarIndex = mainWindowLayout->qtoolbarsInUnifiedToolbarList.indexOf(toolbar);
if (someIndex != 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)));
}
}
toolbar->update();
}
}
@end

69
src/widgets/widgets/qcocoatoolbardelegate_mac_p.h
View File

@ -1,69 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of the QtWidgets module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists purely as an
// implementation detail. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
#include "qmacdefines_mac.h"
#import <Cocoa/Cocoa.h>
QT_BEGIN_NAMESPACE
class QMainWindowLayout;
class QToolBar;
QT_END_NAMESPACE
@class NSToolbarItem;
@interface QT_MANGLE_NAMESPACE(QCocoaToolBarDelegate) : NSObject {
QT_PREPEND_NAMESPACE(QMainWindowLayout) *mainWindowLayout;
NSToolbarItem *toolbarItem;
}
- (id)initWithMainWindowLayout:(QT_PREPEND_NAMESPACE(QMainWindowLayout) *)layout;
@end

292
src/widgets/widgets/qmainwindowlayout_mac.mm
View File

@ -1,292 +0,0 @@
/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of the QtWidgets module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include <private/qmainwindowlayout_p.h>
#include <qtoolbar.h>
#include <private/qtoolbarlayout_p.h>
#include <private/qt_cocoa_helpers_mac_p.h>
#include <private/qtoolbar_p.h>
#include <private/qcocoatoolbardelegate_mac_p.h>
#import <private/qcocoawindowdelegate_mac_p.h>
QT_BEGIN_NAMESPACE
#ifdef QT_NAMESPACE
// namespace up the stuff
#define SS(x) #x
#define S0(x) SS(x)
#define S "org.qt-project.qt-" S0(QT_NAMESPACE) ".qmainwindow.qtoolbarInHIToolbar"
#define SToolbar "org.qt-project.qt-" S0(QT_NAMESPACE) ".hitoolbar-qtoolbar"
#define SNSToolbar "org.qt-project.qt-" S0(QT_NAMESPACE) ".qtoolbarInNSToolbar"
#define MacToolbar "org.qt-project.qt-" S0(QT_NAMESPACE) ".qmainwindow.mactoolbar"
static NSString *kQToolBarNSToolbarIdentifier = @SNSToolbar;
static CFStringRef kQMainWindowMacToolbarID = CFSTR(MacToolbar);
#undef SS
#undef S0
#undef S
#undef SToolbar
#undef SNSToolbar
#undef MacToolbar
#else
static NSString *kQToolBarNSToolbarIdentifier = @"org.qt-project.qt.qmainwindow.qtoolbarInNSToolbar";
static CFStringRef kQMainWindowMacToolbarID = CFSTR("org.qt-project.qt.qmainwindow.mactoolbar");
#endif // QT_NAMESPACE
#ifndef kWindowUnifiedTitleAndToolbarAttribute
#define kWindowUnifiedTitleAndToolbarAttribute (1 << 7)
#endif
void QMainWindowLayout::updateHIToolBarStatus()
{
bool useMacToolbar = layoutState.mainWindow->unifiedTitleAndToolBarOnMac();
layoutState.mainWindow->setUpdatesEnabled(false); // reduces a little bit of flicker, not all though
QMacCocoaAutoReleasePool pool;
NSView *cView = [qt_mac_window_for(layoutState.mainWindow) contentView];
if (useMacToolbar) {
[cView setPostsFrameChangedNotifications:YES];
[[NSNotificationCenter defaultCenter] addObserver: [QT_MANGLE_NAMESPACE(QCocoaWindowDelegate) sharedDelegate]
selector: @selector(syncContentViewFrame:)
name: NSViewFrameDidChangeNotification
object: cView];
}
if (!useMacToolbar) {
macWindowToolbarShow(layoutState.mainWindow, false);
// Move everything out of the HIToolbar into the main toolbar.
while (!qtoolbarsInUnifiedToolbarList.isEmpty()) {
// Should shrink the list by one every time.
QToolBar *toolbar = qtoolbarsInUnifiedToolbarList.first();
unifiedSurface->removeToolbar(toolbar);
layoutState.mainWindow->addToolBar(Qt::TopToolBarArea, toolbar);
}
macWindowToolbarSet(qt_mac_window_for(layoutState.mainWindow), 0);
} 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) {
// Do this here, because we are in an in-between state.
removeWidget(toolbar);
layoutState.mainWindow->addToolBar(Qt::TopToolBarArea, toolbar);
}
}
syncUnifiedToolbarVisibility();
}
if (!useMacToolbar) {
[cView setPostsFrameChangedNotifications:NO];
[[NSNotificationCenter defaultCenter] removeObserver: [QT_MANGLE_NAMESPACE(QCocoaWindowDelegate) sharedDelegate]
name: NSViewFrameDidChangeNotification
object: cView];
}
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;
// toolbar will now become native (if not already) since we need
// an nsview for it inside the corresponding NSToolbarItem.
// Setting isInUnifiedToolbar will (among other things) stop alien
// siblings from becoming native when this happends since the toolbar
// will not overlap with other children of the QMainWindow. NB: Switching
// unified toolbar off after this stage is not supported, as this means
// that either the menubar must be alien again, or the sibling must
// be backed by an nsview to protect from overlapping issues:
toolbar->d_func()->isInUnifiedToolbar = true;
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->winId(); // 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);
QMacCocoaAutoReleasePool pool;
NSToolbar *macToolbar = [window toolbar];
if (macToolbar == nil) {
macToolbar = [[NSToolbar alloc] initWithIdentifier:(NSString *)kQMainWindowMacToolbarID];
[macToolbar setDisplayMode:NSToolbarDisplayModeIconOnly];
[macToolbar setSizeMode:NSToolbarSizeModeRegular];
[macToolbar setDelegate:[[QT_MANGLE_NAMESPACE(QCocoaToolBarDelegate) alloc] initWithMainWindowLayout:this]];
[window setToolbar:macToolbar];
[macToolbar release];
}
if (toolbarIndex != -1) {
qtoolbarsInUnifiedToolbarList.removeAt(toolbarIndex);
[macToolbar removeItemAtIndex:toolbarIndex];
}
qtoolbarsInUnifiedToolbarList.insert(beforeIndex, toolbar);
// Adding to the unified toolbar surface for the raster engine.
if (layoutState.mainWindow->windowSurface()) {
QPoint offset(0, 0);
for (int i = 0; i < beforeIndex; ++i) {
offset.setX(offset.x() + qtoolbarsInUnifiedToolbarList.at(i)->size().width());
}
unifiedSurface->insertToolbar(toolbar, offset);
}
NSString *toolbarID = kQToolBarNSToolbarIdentifier;
toolbarID = [toolbarID stringByAppendingFormat:@"%p", toolbar];
cocoaItemIDToToolbarHash.insert(qt_mac_NSStringToQString(toolbarID), toolbar);
[macToolbar insertItemWithItemIdentifier:toolbarID atIndex:beforeIndex];
}
void QMainWindowLayout::updateUnifiedToolbarOffset()
{
QPoint offset(0, 0);
for (int i = 1; i < qtoolbarsInUnifiedToolbarList.length(); ++i) {
offset.setX(offset.x() + qtoolbarsInUnifiedToolbarList.at(i - 1)->size().width());
qtoolbarsInUnifiedToolbarList.at(i)->d_func()->toolbar_offset = offset;
}
}
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);
NSToolbarItem *item = static_cast<NSToolbarItem *>(it.key());
[[qt_mac_window_for(layoutState.mainWindow->window()) toolbar]
removeItemAtIndex:toolbarItemsCopy.indexOf(item)];
unifiedToolbarHash.remove(item);
qtoolbarsInUnifiedToolbarList.removeAll(toolbar);
break;
}
++it;
}
}
void QMainWindowLayout::cleanUpMacToolbarItems()
{
QMacCocoaAutoReleasePool pool;
for (int i = 0; i < toolbarItemsCopy.size(); ++i) {
NSToolbarItem *item = static_cast<NSToolbarItem *>(toolbarItemsCopy.at(i));
[item setView:0];
CFRelease(toolbarItemsCopy.at(i));
}
toolbarItemsCopy.clear();
unifiedToolbarHash.clear();
OSWindowRef window = qt_mac_window_for(layoutState.mainWindow);
NSToolbar *macToolbar = [window toolbar];
if (macToolbar) {
[[macToolbar delegate] release];
[macToolbar setDelegate:nil];
}
}
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];
}
}
void QMainWindowLayout::syncUnifiedToolbarVisibility()
{
if (blockVisiblityCheck)
return;
Q_ASSERT(layoutState.mainWindow->unifiedTitleAndToolBarOnMac());
bool show = false;
const int ToolBarCount = qtoolbarsInUnifiedToolbarList.count();
for (int i = 0; i < ToolBarCount; ++i) {
if (qtoolbarsInUnifiedToolbarList.at(i)->isVisible()) {
show = true;
break;
}
}
macWindowToolbarShow(layoutState.mainWindow, show);
}
QT_END_NAMESPACE

68
src/widgets/widgets/qtoolbar.cpp
View File

@ -57,11 +57,6 @@
#include <qwidgetaction.h>
#include <qtimer.h>
#include <private/qwidgetaction_p.h>
#ifdef Q_WS_MAC
#include <private/qt_mac_p.h>
#include <private/qt_cocoa_helpers_mac_p.h>
#endif
#include <private/qmainwindowlayout_p.h>
#include "qtoolbar_p.h"
@ -74,14 +69,6 @@
QT_BEGIN_NAMESPACE
#ifdef Q_WS_MAC
static void qt_mac_updateToolBarButtonHint(QWidget *parentWidget)
{
if (!(parentWidget->windowFlags() & Qt::CustomizeWindowHint))
parentWidget->setWindowFlags(parentWidget->windowFlags() | Qt::MacWindowToolBarButtonHint);
}
#endif
// qmainwindow.cpp
extern QMainWindowLayout *qt_mainwindow_layout(const QMainWindow *window);
@ -104,17 +91,6 @@ void QToolBarPrivate::init()
layout = new QToolBarLayout(q);
layout->updateMarginAndSpacing();
#ifdef Q_WS_MAC
if (q->parentWidget() && q->parentWidget()->isWindow()) {
// Make sure that the window has the "toolbar" button.
QWidget *parentWidget = q->parentWidget();
qt_mac_updateToolBarButtonHint(parentWidget);
reinterpret_cast<QToolBar *>(parentWidget)->d_func()->createWinId(); // Please let me create your winId...
extern OSWindowRef qt_mac_window_for(const QWidget *); // qwidget_mac.cpp
macWindowToolbarShow(q->parentWidget(), true);
}
#endif
toggleViewAction = new QAction(q);
toggleViewAction->setCheckable(true);
q->setMovable(q->style()->styleHint(QStyle::SH_ToolBar_Movable, 0, q ));
@ -158,12 +134,8 @@ void QToolBarPrivate::updateWindowFlags(bool floating, bool unplug)
flags |= Qt::FramelessWindowHint;
if (unplug) {
if (unplug)
flags |= Qt::X11BypassWindowManagerHint;
#ifdef Q_WS_MAC
flags |= Qt::WindowStaysOnTopHint;
#endif
}
q->setWindowFlags(flags);
}
@ -569,16 +541,6 @@ QToolBar::QToolBar(const QString &title, QWidget *parent)
*/
QToolBar::~QToolBar()
{
// Remove the toolbar button if there is nothing left.
QMainWindow *mainwindow = qobject_cast<QMainWindow *>(parentWidget());
if (mainwindow) {
#ifdef Q_WS_MAC
QMainWindowLayout *mainwin_layout = qt_mainwindow_layout(mainwindow);
if (mainwin_layout && mainwin_layout->layoutState.toolBarAreaLayout.isEmpty()
&& mainwindow->testAttribute(Qt::WA_WState_Created))
macWindowToolbarShow(mainwindow, false);
#endif
}
}
/*! \property QToolBar::movable
@ -665,12 +627,6 @@ void QToolBar::setAllowedAreas(Qt::ToolBarAreas areas)
Qt::ToolBarAreas QToolBar::allowedAreas() const
{
Q_D(const QToolBar);
#ifdef Q_WS_MAC
if (QMainWindow *window = qobject_cast<QMainWindow *>(parentWidget())) {
if (window->unifiedTitleAndToolBarOnMac()) // Don't allow drags to the top (for now).
return (d->allowedAreas & ~Qt::TopToolBarArea);
}
#endif
return d->allowedAreas;
}
@ -1083,15 +1039,6 @@ static bool waitForPopup(QToolBar *tb, QWidget *popup)
return false;
}
#if defined(Q_WS_MAC)
static bool toolbarInUnifiedToolBar(QToolBar *toolbar)
{
const QMainWindow *mainWindow = qobject_cast<const QMainWindow *>(toolbar->parentWidget());
return mainWindow && mainWindow->unifiedTitleAndToolBarOnMac()
&& mainWindow->toolBarArea(toolbar) == Qt::TopToolBarArea;
}
#endif
/*! \reimp */
bool QToolBar::event(QEvent *event)
{
@ -1115,22 +1062,9 @@ bool QToolBar::event(QEvent *event)
case QEvent::Show:
d->toggleViewAction->setChecked(event->type() == QEvent::Show);
emit visibilityChanged(event->type() == QEvent::Show);
#if defined(Q_WS_MAC)
if (toolbarInUnifiedToolBar(this)) {
// I can static_cast because I did the qobject_cast in the if above, therefore
// we must have a QMainWindowLayout here.
QMainWindowLayout *mwLayout = qt_mainwindow_layout(qobject_cast<QMainWindow *>(parentWidget()));
mwLayout->fixSizeInUnifiedToolbar(this);
mwLayout->syncUnifiedToolbarVisibility();
}
#endif // Q_WS_MAC
break;
case QEvent::ParentChange:
d->layout->checkUsePopupMenu();
#if defined(Q_WS_MAC)
if (parentWidget() && parentWidget()->isWindow())
qt_mac_updateToolBarButtonHint(parentWidget());
#endif
break;
case QEvent::MouseButtonPress: {

23
src/widgets/widgets/qtoolbarlayout.cpp
View File

@ -332,20 +332,6 @@ void QToolBarLayout::updateGeomArray() const
rpick(o, that->hint) += handleExtent;
that->hint += QSize(2*margin, 2*margin);
that->dirty = false;
#ifdef Q_WS_MAC
if (QMainWindow *mw = qobject_cast<QMainWindow *>(parentWidget()->parentWidget())) {
if (mw->unifiedTitleAndToolBarOnMac()
&& mw->toolBarArea(static_cast<QToolBar *>(parentWidget())) == Qt::TopToolBarArea) {
if (expandFlag) {
tb->setMaximumSize(0xFFFFFF, 0xFFFFFF);
} else {
tb->setMaximumSize(hint);
}
}
}
#endif
that->dirty = false;
}
@ -401,15 +387,6 @@ void QToolBarLayout::setGeometry(const QRect &rect)
if (!extension->isHidden())
extension->hide();
}
#ifdef Q_WS_MAC
if (QMainWindow *win = qobject_cast<QMainWindow*>(tb->parentWidget())) {
Qt::ToolBarArea area = win->toolBarArea(tb);
if (win->unifiedTitleAndToolBarOnMac() && area == Qt::TopToolBarArea) {
qt_mainwindow_layout(win)->fixSizeInUnifiedToolbar(tb);
}
}
#endif
}
bool QToolBarLayout::layoutActions(const QSize &size)

9
src/widgets/widgets/widgets.pri
View File

@ -155,15 +155,6 @@ macx {
widgets/qmaccocoaviewcontainer_mac.mm
}
# TODO
false:mac {
OBJECTIVE_HEADERS += widgets/qcocoatoolbardelegate_mac_p.h \
widgets/qcocoamenu_mac_p.h
OBJECTIVE_SOURCES += widgets/qcocoatoolbardelegate_mac.mm \
widgets/qmainwindowlayout_mac.mm
}
wince*: {
SOURCES += widgets/qmenu_wince.cpp
HEADERS += widgets/qmenu_wince_resource_p.h