← Back to branch summary

~oif-team/ubuntu/natty/qt4-x11/xi2.1

« back to all changes in this revision

Viewing changes to src/gui/widgets/qmainwindowlayout_mac.mm

  • Committer: Bazaar Package Importer
  • Author(s): Alessandro Ghersi
  • Date: 2009-11-02 18:30:08 UTC
  • mfrom: (1.2.2 upstream)
  • mto: (15.2.5 experimental)
  • mto: This revision was merged to the branch mainline in revision 88.
  • Revision ID: james.westby@ubuntu.com-20091102183008-b6a4gcs128mvfb3m
Tags: upstream-4.6.0~beta1
Import upstream version 4.6.0~beta1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gui/widgets/qmainwindowlayout_mac.mm
 
1
/****************************************************************************
 
2
**
 
3
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
 
4
** All rights reserved.
 
5
** Contact: Nokia Corporation (qt-info@nokia.com)
 
6
**
 
7
** This file is part of the QtGui module of the Qt Toolkit.
 
8
**
 
9
** $QT_BEGIN_LICENSE:LGPL$
 
10
** No Commercial Usage
 
11
** This file contains pre-release code and may not be distributed.
 
12
** You may use this file in accordance with the terms and conditions
 
13
** contained in the Technology Preview License Agreement accompanying
 
14
** this package.
 
15
**
 
16
** GNU Lesser General Public License Usage
 
17
** Alternatively, this file may be used under the terms of the GNU Lesser
 
18
** General Public License version 2.1 as published by the Free Software
 
19
** Foundation and appearing in the file LICENSE.LGPL included in the
 
20
** packaging of this file.  Please review the following information to
 
21
** ensure the GNU Lesser General Public License version 2.1 requirements
 
22
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 
23
**
 
24
** In addition, as a special exception, Nokia gives you certain additional
 
25
** rights.  These rights are described in the Nokia Qt LGPL Exception
 
26
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 
27
**
 
28
** If you have questions regarding the use of this file, please contact
 
29
** Nokia at qt-info@nokia.com.
 
30
**
 
31
**
 
32
**
 
33
**
 
34
**
 
35
**
 
36
**
 
37
**
 
38
** $QT_END_LICENSE$
 
39
**
 
40
****************************************************************************/
 
41
 
 
42
#include <private/qmainwindowlayout_p.h>
 
43
#include <qtoolbar.h>
 
44
#include <private/qtoolbarlayout_p.h>
 
45
#include <private/qt_cocoa_helpers_mac_p.h>
 
46
 
 
47
#ifndef QT_MAC_USE_COCOA
 
48
#include <Carbon/Carbon.h>
 
49
#else
 
50
#include <private/qcocoatoolbardelegate_mac_p.h>
 
51
#endif
 
52
 
 
53
QT_BEGIN_NAMESPACE
 
54
#ifdef QT_NAMESPACE
 
55
 
 
56
// namespace up the stuff
 
57
#define SS(x) #x
 
58
#define S0(x) SS(x)
 
59
#define S "com.trolltech.qt-" S0(QT_NAMESPACE) ".qmainwindow.qtoolbarInHIToolbar"
 
60
#define SToolbar "com.trolltech.qt-" S0(QT_NAMESPACE) ".hitoolbar-qtoolbar"
 
61
#define SNSToolbar "com.trolltech.qt-" S0(QT_NAMESPACE) ".qtoolbarInNSToolbar"
 
62
#define MacToolbar "com.trolltech.qt-" S0(QT_NAMESPACE) ".qmainwindow.mactoolbar"
 
63
 
 
64
#ifndef QT_MAC_USE_COCOA
 
65
static CFStringRef kQToolBarHIToolbarItemClassID = CFSTR(S);
 
66
static CFStringRef kQToolBarHIToolbarIdentifier = CFSTR(SToolbar);
 
67
#else
 
68
static NSString *kQToolBarNSToolbarIdentifier = @SNSToolbar;
 
69
#endif
 
70
static CFStringRef kQMainWindowMacToolbarID = CFSTR(MacToolbar);
 
71
#undef SS
 
72
#undef S0
 
73
#undef S
 
74
#undef SToolbar
 
75
#undef SNSToolbar
 
76
#undef MacToolbar
 
77
 
 
78
#else
 
79
#ifndef QT_MAC_USE_COCOA
 
80
static CFStringRef kQToolBarHIToolbarItemClassID = CFSTR("com.trolltech.qt.qmainwindow.qtoolbarInHIToolbar");
 
81
static CFStringRef kQToolBarHIToolbarIdentifier = CFSTR("com.trolltech.qt.hitoolbar-qtoolbar");
 
82
#else
 
83
static NSString *kQToolBarNSToolbarIdentifier = @"com.trolltech.qt.qmainwindow.qtoolbarInNSToolbar";
 
84
#endif
 
85
static CFStringRef kQMainWindowMacToolbarID = CFSTR("com.trolltech.qt.qmainwindow.mactoolbar");
 
86
#endif // QT_NAMESPACE
 
87
 
 
88
#ifndef QT_MAC_USE_COCOA
 
89
 
 
90
static const int kEventParamQToolBar = 'QTBR';
 
91
static const int kEventParamQMainWindowLayout = 'QMWL';
 
92
 
 
93
const EventTypeSpec qtoolbarEvents[] =
 
94
{
 
95
    { kEventClassHIObject, kEventHIObjectConstruct },
 
96
    { kEventClassHIObject, kEventHIObjectDestruct },
 
97
    { kEventClassHIObject, kEventHIObjectInitialize },
 
98
    { kEventClassToolbarItem, kEventToolbarItemCreateCustomView }
 
99
};
 
100
 
 
101
struct QToolBarInHIToolbarInfo
 
102
{
 
103
    QToolBarInHIToolbarInfo(HIToolbarItemRef item)
 
104
        : toolbarItem(item), mainWindowLayout(0)
 
105
    {}
 
106
    HIToolbarItemRef toolbarItem;
 
107
    QMainWindowLayout *mainWindowLayout;
 
108
};
 
109
 
 
110
OSStatus QMainWindowLayout::qtoolbarInHIToolbarHandler(EventHandlerCallRef inCallRef,
 
111
                                                       EventRef event, void *data)
 
112
{
 
113
    OSStatus result = eventNotHandledErr;
 
114
    QToolBarInHIToolbarInfo *object = static_cast<QToolBarInHIToolbarInfo *>(data);
 
115
 
 
116
    switch (GetEventClass(event)) {
 
117
        case kEventClassHIObject:
 
118
            switch (GetEventKind(event)) {
 
119
                case kEventHIObjectConstruct:
 
120
                {
 
121
                    HIObjectRef toolbarItem;
 
122
                    GetEventParameter(event, kEventParamHIObjectInstance, typeHIObjectRef,
 
123
                                      0, sizeof( HIObjectRef ), 0, &toolbarItem);
 
124
 
 
125
                    QToolBarInHIToolbarInfo *item = new QToolBarInHIToolbarInfo(toolbarItem);
 
126
                    SetEventParameter(event, kEventParamHIObjectInstance, typeVoidPtr,
 
127
                                      sizeof(void *), &item);
 
128
                    result = noErr;
 
129
                }
 
130
                    break;
 
131
                case kEventHIObjectInitialize:
 
132
                    result = CallNextEventHandler(inCallRef, event);
 
133
                    if (result == noErr) {
 
134
                        QToolBar *toolbar = 0;
 
135
                        QMainWindowLayout *layout = 0;
 
136
                        GetEventParameter(event, kEventParamQToolBar, typeVoidPtr,
 
137
                                          0, sizeof(void *), 0, &toolbar);
 
138
                        GetEventParameter(event, kEventParamQMainWindowLayout, typeVoidPtr,
 
139
                                          0, sizeof(void *), 0, &layout);
 
140
                        object->mainWindowLayout = layout;
 
141
                        object->mainWindowLayout->unifiedToolbarHash.insert(object->toolbarItem, toolbar);
 
142
                        HIToolbarItemChangeAttributes(object->toolbarItem,
 
143
                                                      kHIToolbarItemLabelDisabled, 0);
 
144
                    }
 
145
                    break;
 
146
 
 
147
                case kEventHIObjectDestruct:
 
148
                    delete object;
 
149
                    result = noErr;
 
150
                    break;
 
151
            }
 
152
            break;
 
153
 
 
154
        case kEventClassToolbarItem:
 
155
            switch (GetEventKind(event))
 
156
        {
 
157
            case kEventToolbarItemCreateCustomView:
 
158
            {
 
159
                QToolBar *toolbar
 
160
                = object->mainWindowLayout->unifiedToolbarHash.value(object->toolbarItem);
 
161
                if (toolbar) {
 
162
                    HIViewRef hiview = HIViewRef(toolbar->winId());
 
163
                    SetEventParameter(event, kEventParamControlRef, typeControlRef,
 
164
                                      sizeof(HIViewRef), &hiview);
 
165
                    result = noErr;
 
166
                }
 
167
            }
 
168
                break;
 
169
        }
 
170
            break;
 
171
    }
 
172
    return result;
 
173
}
 
174
 
 
175
void QMainWindowLayout::qtMacHIToolbarRegisterQToolBarInHIToolborItemClass()
 
176
{
 
177
    static bool registered = false;
 
178
 
 
179
    if (!registered) {
 
180
        HIObjectRegisterSubclass( kQToolBarHIToolbarItemClassID,
 
181
                                 kHIToolbarItemClassID, 0, QMainWindowLayout::qtoolbarInHIToolbarHandler,
 
182
                                 GetEventTypeCount(qtoolbarEvents), qtoolbarEvents, 0, 0 );
 
183
        registered = true;
 
184
    }
 
185
}
 
186
 
 
187
static void GetToolbarAllowedItems(CFMutableArrayRef array)
 
188
{
 
189
    CFArrayAppendValue(array, kQToolBarHIToolbarIdentifier);
 
190
}
 
191
 
 
192
HIToolbarItemRef QMainWindowLayout::createQToolBarInHIToolbarItem(QToolBar *toolbar,
 
193
                                                                  QMainWindowLayout *layout)
 
194
{
 
195
    QMainWindowLayout::qtMacHIToolbarRegisterQToolBarInHIToolborItemClass();
 
196
 
 
197
    EventRef event;
 
198
    HIToolbarItemRef result = 0;
 
199
 
 
200
    CFStringRef identifier = kQToolBarHIToolbarIdentifier;
 
201
    UInt32 options = kHIToolbarItemAllowDuplicates;
 
202
 
 
203
    CreateEvent(0, kEventClassHIObject, kEventHIObjectInitialize,
 
204
                GetCurrentEventTime(), 0, &event);
 
205
    SetEventParameter(event, kEventParamToolbarItemIdentifier, typeCFStringRef,
 
206
                      sizeof(CFStringRef), &identifier);
 
207
    SetEventParameter(event, kEventParamAttributes, typeUInt32, sizeof(UInt32), &options);
 
208
    SetEventParameter(event, kEventParamQToolBar, typeVoidPtr, sizeof(void *), &toolbar);
 
209
    SetEventParameter(event, kEventParamQMainWindowLayout, typeVoidPtr, sizeof(void *), &layout);
 
210
 
 
211
    HIObjectCreate(kQToolBarHIToolbarItemClassID, event,
 
212
                   static_cast<HIObjectRef *>(&result));
 
213
 
 
214
    ReleaseEvent(event);
 
215
    return result;
 
216
 
 
217
}
 
218
 
 
219
HIToolbarItemRef QMainWindowLayout::CreateToolbarItemForIdentifier(CFStringRef identifier,
 
220
                                                                   CFTypeRef data)
 
221
{
 
222
    HIToolbarItemRef item = 0;
 
223
    if (CFStringCompare(kQToolBarHIToolbarIdentifier, identifier,
 
224
                        kCFCompareBackwards) == kCFCompareEqualTo) {
 
225
        if (data && CFGetTypeID(data) == CFArrayGetTypeID()) {
 
226
            CFArrayRef array = static_cast<CFArrayRef>(data);
 
227
            QToolBar *toolbar = static_cast<QToolBar *>(const_cast<void *>(CFArrayGetValueAtIndex(array, 0)));
 
228
            QMainWindowLayout *layout = static_cast<QMainWindowLayout *>(const_cast<void *>(CFArrayGetValueAtIndex(array, 1)));
 
229
            item = createQToolBarInHIToolbarItem(toolbar, layout);
 
230
        }
 
231
    }
 
232
    return item;
 
233
}
 
234
 
 
235
static const EventTypeSpec kToolbarEvents[] = {
 
236
{ kEventClassToolbar, kEventToolbarGetDefaultIdentifiers },
 
237
{ kEventClassToolbar, kEventToolbarGetAllowedIdentifiers },
 
238
{ kEventClassToolbar, kEventToolbarCreateItemWithIdentifier },
 
239
{ kEventClassToolbar, kEventToolbarItemAdded },
 
240
{ kEventClassToolbar, kEventToolbarItemRemoved }
 
241
};
 
242
 
 
243
OSStatus QMainWindowLayout::qtmacToolbarDelegate(EventHandlerCallRef, EventRef event, void *data)
 
244
{
 
245
    QMainWindowLayout *mainWindowLayout = static_cast<QMainWindowLayout *>(data);
 
246
    OSStatus            result = eventNotHandledErr;
 
247
    CFMutableArrayRef   array;
 
248
    CFStringRef         identifier;
 
249
    switch (GetEventKind(event)) {
 
250
        case kEventToolbarGetDefaultIdentifiers:
 
251
        case kEventToolbarGetAllowedIdentifiers:
 
252
            GetEventParameter(event, kEventParamMutableArray, typeCFMutableArrayRef, 0,
 
253
                              sizeof(CFMutableArrayRef), 0, &array);
 
254
            GetToolbarAllowedItems(array);
 
255
            result = noErr;
 
256
            break;
 
257
        case kEventToolbarCreateItemWithIdentifier: {
 
258
            HIToolbarItemRef item;
 
259
            CFTypeRef data = 0;
 
260
            OSStatus err = GetEventParameter(event, kEventParamToolbarItemIdentifier, typeCFStringRef,
 
261
                                             0, sizeof(CFStringRef), 0, &identifier);
 
262
            err = GetEventParameter(event, kEventParamToolbarItemConfigData, typeCFTypeRef,
 
263
                                    0, sizeof(CFTypeRef), 0, &data);
 
264
            item = CreateToolbarItemForIdentifier(identifier, data);
 
265
            if (item) {
 
266
                result = SetEventParameter(event, kEventParamToolbarItem, typeHIToolbarItemRef,
 
267
                                           sizeof(HIToolbarItemRef), &item );
 
268
            }
 
269
            break;
 
270
        }
 
271
        case kEventToolbarItemAdded: {
 
272
            // Double check that our "view" of the toolbar is similar.
 
273
            HIToolbarItemRef item;
 
274
            CFIndex index;
 
275
            if (GetEventParameter(event, kEventParamToolbarItem, typeHIToolbarItemRef,
 
276
                                  0, sizeof(HIToolbarItemRef), 0, &item) == noErr
 
277
                && GetEventParameter(event, kEventParamIndex, typeCFIndex, 0,
 
278
                                     sizeof(CFIndex), 0, &index) == noErr) {
 
279
                CFRetain(item); // We will watch this until it's removed from the list (or bust).
 
280
                mainWindowLayout->toolbarItemsCopy.insert(index, item);
 
281
                QToolBar *toolbar = mainWindowLayout->unifiedToolbarHash.value(item);
 
282
                if (toolbar) {
 
283
                    int toolbarIndex = mainWindowLayout->qtoolbarsInUnifiedToolbarList.indexOf(toolbar);
 
284
                    if (index != toolbarIndex) {
 
285
                        // Dang, we must be out of sync, rebuild it from the "toolbarItemsCopy"
 
286
                        mainWindowLayout->qtoolbarsInUnifiedToolbarList.clear();
 
287
                        for (int i = 0; i < mainWindowLayout->toolbarItemsCopy.size(); ++i) {
 
288
                            // This will either append the correct toolbar or an
 
289
                            // null toolbar. This is fine because this list
 
290
                            // is really only kept to make sure that things are but in the right order.
 
291
                            mainWindowLayout->qtoolbarsInUnifiedToolbarList.append(
 
292
                                                                                   mainWindowLayout->unifiedToolbarHash.value(mainWindowLayout->
 
293
                                                                                                                              toolbarItemsCopy.at(i)));
 
294
                        }
 
295
                    }
 
296
                }
 
297
            }
 
298
            break;
 
299
        }
 
300
        case kEventToolbarItemRemoved: {
 
301
            HIToolbarItemRef item;
 
302
            if (GetEventParameter(event, kEventParamToolbarItem, typeHIToolbarItemRef,
 
303
                                  0, sizeof(HIToolbarItemRef), 0, &item) == noErr) {
 
304
                mainWindowLayout->unifiedToolbarHash.remove(item);
 
305
                for (int i = 0; i < mainWindowLayout->toolbarItemsCopy.size(); ++i) {
 
306
                    if (mainWindowLayout->toolbarItemsCopy.at(i) == item) {
 
307
                        // I know about it, so release it.
 
308
                        mainWindowLayout->toolbarItemsCopy.removeAt(i);
 
309
                        mainWindowLayout->qtoolbarsInUnifiedToolbarList.removeAt(i);
 
310
                        CFRelease(item);
 
311
                        break;
 
312
                    }
 
313
                }
 
314
            }
 
315
            break;
 
316
        }
 
317
    }
 
318
    return result;
 
319
}
 
320
#endif // ! QT_MAC_USE_COCOA
 
321
 
 
322
#ifndef kWindowUnifiedTitleAndToolbarAttribute
 
323
#define kWindowUnifiedTitleAndToolbarAttribute (1 << 7)
 
324
#endif
 
325
 
 
326
void QMainWindowLayout::updateHIToolBarStatus()
 
327
{
 
328
    bool useMacToolbar = layoutState.mainWindow->unifiedTitleAndToolBarOnMac();
 
329
#ifndef QT_MAC_USE_COCOA
 
330
    if (useMacToolbar) {
 
331
        ChangeWindowAttributes(qt_mac_window_for(layoutState.mainWindow),
 
332
                               kWindowUnifiedTitleAndToolbarAttribute, 0);
 
333
    } else {
 
334
        ChangeWindowAttributes(qt_mac_window_for(layoutState.mainWindow),
 
335
                               0, kWindowUnifiedTitleAndToolbarAttribute);
 
336
    }
 
337
#endif
 
338
 
 
339
    layoutState.mainWindow->setUpdatesEnabled(false);  // reduces a little bit of flicker, not all though
 
340
    if (!useMacToolbar) {
 
341
        macWindowToolbarShow(layoutState.mainWindow, false);
 
342
        // Move everything out of the HIToolbar into the main toolbar.
 
343
        while (!qtoolbarsInUnifiedToolbarList.isEmpty()) {
 
344
            // Should shrink the list by one every time.
 
345
            layoutState.mainWindow->addToolBar(Qt::TopToolBarArea, qtoolbarsInUnifiedToolbarList.first());
 
346
        }
 
347
        macWindowToolbarSet(qt_mac_window_for(layoutState.mainWindow), 0);
 
348
    } else {
 
349
        QList<QToolBar *> toolbars = layoutState.mainWindow->findChildren<QToolBar *>();
 
350
        for (int i = 0; i < toolbars.size(); ++i) {
 
351
            QToolBar *toolbar = toolbars.at(i);
 
352
            if (toolBarArea(toolbar) == Qt::TopToolBarArea) {
 
353
                removeWidget(toolbar);  // Do this here, because we are in an in-between state.
 
354
                layoutState.mainWindow->addToolBar(Qt::TopToolBarArea, toolbar);
 
355
            }
 
356
        }
 
357
        syncUnifiedToolbarVisibility();
 
358
    }
 
359
    layoutState.mainWindow->setUpdatesEnabled(true);
 
360
}
 
361
 
 
362
void QMainWindowLayout::insertIntoMacToolbar(QToolBar *before, QToolBar *toolbar)
 
363
{
 
364
    // This layering could go on to one more level, but I decided to stop here.
 
365
    // The HIToolbar and NSToolbar APIs are fairly similar as you will see.
 
366
    if (toolbar == 0)
 
367
        return;
 
368
 
 
369
 
 
370
    QToolBarLayout *toolbarLayout = static_cast<QToolBarLayout *>(toolbar->layout());
 
371
    toolbarSaveState.insert(toolbar, ToolBarSaveState(toolbar->isMovable(),
 
372
                                                      toolbar->maximumSize()));
 
373
 
 
374
    if (toolbarLayout->hasExpandFlag() == false)
 
375
        toolbar->setMaximumSize(toolbar->sizeHint());
 
376
 
 
377
    toolbar->setMovable(false);
 
378
    toolbarLayout->setUsePopupMenu(true);
 
379
    // Make the toolbar a child of the mainwindow to avoid creating a window.
 
380
    toolbar->setParent(layoutState.mainWindow);
 
381
    toolbar->createWinId();  // Now create the OSViewRef.
 
382
 
 
383
    layoutState.mainWindow->createWinId();
 
384
 
 
385
    OSWindowRef window = qt_mac_window_for(layoutState.mainWindow);
 
386
    int beforeIndex = qtoolbarsInUnifiedToolbarList.indexOf(before);
 
387
    if (beforeIndex == -1)
 
388
        beforeIndex = qtoolbarsInUnifiedToolbarList.size();
 
389
 
 
390
    int toolbarIndex = qtoolbarsInUnifiedToolbarList.indexOf(toolbar);
 
391
#ifndef QT_MAC_USE_COCOA
 
392
    HIToolbarRef macToolbar = NULL;
 
393
    if ((GetWindowToolbar(window, &macToolbar) == noErr) && !macToolbar) {
 
394
        HIToolbarCreate(kQMainWindowMacToolbarID,
 
395
                        kHIToolbarItemAllowDuplicates, &macToolbar);
 
396
        InstallEventHandler(HIObjectGetEventTarget(static_cast<HIToolbarRef>(macToolbar)),
 
397
                            QMainWindowLayout::qtmacToolbarDelegate, GetEventTypeCount(kToolbarEvents),
 
398
                            kToolbarEvents, this, 0);
 
399
        HIToolbarSetDisplaySize(macToolbar, kHIToolbarDisplaySizeNormal);
 
400
        HIToolbarSetDisplayMode(macToolbar, kHIToolbarDisplayModeIconOnly);
 
401
        macWindowToolbarSet(window, macToolbar);
 
402
        if (layoutState.mainWindow->isVisible())
 
403
            macWindowToolbarShow(layoutState.mainWindow, true);
 
404
        CFRelease(macToolbar);
 
405
    }
 
406
#else
 
407
    QMacCocoaAutoReleasePool pool;
 
408
    NSToolbar *macToolbar = [window toolbar];
 
409
    if (macToolbar == nil) {
 
410
        macToolbar = [[NSToolbar alloc] initWithIdentifier:(NSString *)kQMainWindowMacToolbarID];
 
411
        [macToolbar setDisplayMode:NSToolbarDisplayModeIconOnly];
 
412
        [macToolbar setSizeMode:NSToolbarSizeModeRegular];
 
413
        [macToolbar setDelegate:[[QCocoaToolBarDelegate alloc] initWithMainWindowLayout:this]];
 
414
        [window setToolbar:macToolbar];
 
415
        [macToolbar release];
 
416
    }
 
417
#endif
 
418
    if (toolbarIndex != -1) {
 
419
        qtoolbarsInUnifiedToolbarList.removeAt(toolbarIndex);
 
420
#ifndef QT_MAC_USE_COCOA
 
421
        HIToolbarRemoveItemAtIndex(macToolbar, toolbarIndex);
 
422
#else
 
423
        [macToolbar removeItemAtIndex:toolbarIndex];
 
424
#endif
 
425
    }
 
426
    qtoolbarsInUnifiedToolbarList.insert(beforeIndex, toolbar);
 
427
#ifndef QT_MAC_USE_COCOA
 
428
    QCFType<HIToolbarItemRef> outItem;
 
429
    const QObject *stupidArray[] = { toolbar, this };
 
430
    QCFType<CFArrayRef> array = CFArrayCreate(0, reinterpret_cast<const void **>(&stupidArray),
 
431
                                              2, 0);
 
432
    HIToolbarCreateItemWithIdentifier(macToolbar, kQToolBarHIToolbarIdentifier,
 
433
                                      array, &outItem);
 
434
    HIToolbarInsertItemAtIndex(macToolbar, outItem, beforeIndex);
 
435
#else
 
436
    NSString *toolbarID = kQToolBarNSToolbarIdentifier;
 
437
    toolbarID = [toolbarID stringByAppendingFormat:@"%p", toolbar];
 
438
    cocoaItemIDToToolbarHash.insert(qt_mac_NSStringToQString(toolbarID), toolbar);
 
439
    [macToolbar insertItemWithItemIdentifier:toolbarID atIndex:beforeIndex];
 
440
#endif
 
441
}
 
442
 
 
443
void QMainWindowLayout::removeFromMacToolbar(QToolBar *toolbar)
 
444
{
 
445
    QHash<void *, QToolBar *>::iterator it = unifiedToolbarHash.begin();
 
446
    while (it != unifiedToolbarHash.end()) {
 
447
        if (it.value() == toolbar) {
 
448
            // Rescue our HIView and set it on the mainWindow again.
 
449
            bool saveVisible = !toolbar->isHidden();
 
450
            toolbar->setParent(0);
 
451
            toolbar->setParent(parentWidget());
 
452
            toolbar->setVisible(saveVisible);
 
453
            ToolBarSaveState saveState = toolbarSaveState.value(toolbar);
 
454
            static_cast<QToolBarLayout *>(toolbar->layout())->setUsePopupMenu(false);
 
455
            toolbar->setMovable(saveState.movable);
 
456
            toolbar->setMaximumSize(saveState.maximumSize);
 
457
            toolbarSaveState.remove(toolbar);
 
458
#ifndef QT_MAC_USE_COCOA
 
459
            HIToolbarItemRef item = static_cast<HIToolbarItemRef>(it.key());
 
460
            HIToolbarRemoveItemAtIndex(HIToolbarItemGetToolbar(item),
 
461
                                       toolbarItemsCopy.indexOf(item));
 
462
#else
 
463
            NSToolbarItem *item = static_cast<NSToolbarItem *>(it.key());
 
464
            [[qt_mac_window_for(layoutState.mainWindow->window()) toolbar]
 
465
                removeItemAtIndex:toolbarItemsCopy.indexOf(item)];
 
466
            // In Carbon this hash and list gets emptied via events. In Cocoa, we have to do it ourselves here.
 
467
            it = unifiedToolbarHash.erase(it);
 
468
            qtoolbarsInUnifiedToolbarList.removeAll(toolbar);
 
469
#endif
 
470
            break;
 
471
        }
 
472
        ++it;
 
473
    }
 
474
}
 
475
 
 
476
void QMainWindowLayout::cleanUpMacToolbarItems()
 
477
{
 
478
    for (int i = 0; i < toolbarItemsCopy.size(); ++i)
 
479
        CFRelease(toolbarItemsCopy.at(i));
 
480
    toolbarItemsCopy.clear();
 
481
    unifiedToolbarHash.clear();
 
482
}
 
483
 
 
484
void QMainWindowLayout::fixSizeInUnifiedToolbar(QToolBar *tb) const
 
485
{
 
486
#ifdef QT_MAC_USE_COCOA
 
487
    QHash<void *, QToolBar *>::const_iterator it = unifiedToolbarHash.constBegin();
 
488
    NSToolbarItem *item = nil;
 
489
    while (it != unifiedToolbarHash.constEnd()) {
 
490
        if (tb == it.value()) {
 
491
            item = static_cast<NSToolbarItem *>(it.key());
 
492
            break;
 
493
        }
 
494
        ++it;
 
495
    }
 
496
    if (item) {
 
497
        QMacCocoaAutoReleasePool pool;
 
498
        QWidgetItem layoutItem(tb);
 
499
        QSize size = layoutItem.maximumSize();
 
500
        NSSize nssize = NSMakeSize(size.width(), size.height() - 2);
 
501
        [item setMaxSize:nssize];
 
502
        size = layoutItem.minimumSize();
 
503
        nssize.width = size.width();
 
504
        nssize.height = size.height() - 2;
 
505
        [item setMinSize:nssize];
 
506
    }
 
507
#else
 
508
    Q_UNUSED(tb);
 
509
#endif
 
510
}
 
511
 
 
512
void QMainWindowLayout::syncUnifiedToolbarVisibility()
 
513
{
 
514
    if (blockVisiblityCheck)
 
515
        return;
 
516
 
 
517
    Q_ASSERT(layoutState.mainWindow->unifiedTitleAndToolBarOnMac());
 
518
    bool show = false;
 
519
    const int ToolBarCount = qtoolbarsInUnifiedToolbarList.count();
 
520
    for (int i = 0; i < ToolBarCount; ++i) {
 
521
        if (qtoolbarsInUnifiedToolbarList.at(i)->isVisible()) {
 
522
            show = true;
 
523
            break;
 
524
        }
 
525
    }
 
526
    macWindowToolbarShow(layoutState.mainWindow, show);
 
527
}
 
528
 
 
529
QT_END_NAMESPACE