source: trunk/src/gui/widgets/qmainwindowlayout_mac.mm@ 784

Last change on this file since 784 was 769, checked in by Dmitry A. Kuminov, 15 years ago

trunk: Merged in qt 4.6.3 sources from branches/vendor/nokia/qt.
File size: 22.4 KB
Line 
1/****************************************************************************
2**
3** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
4** All rights reserved.
5** Contact: Nokia Corporation ([email protected])
6**
7** This file is part of the QtGui module of the Qt Toolkit.
8**
9** $QT_BEGIN_LICENSE:LGPL$
10** Commercial Usage
11** Licensees holding valid Qt Commercial licenses may use this file in
12** accordance with the Qt Commercial License Agreement provided with the
13** Software or, alternatively, in accordance with the terms contained in
14** a written agreement between you and Nokia.
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** GNU General Public License Usage
29** Alternatively, this file may be used under the terms of the GNU
30** General Public License version 3.0 as published by the Free Software
31** Foundation and appearing in the file LICENSE.GPL included in the
32** packaging of this file. Please review the following information to
33** ensure the GNU General Public License version 3.0 requirements will be
34** met: http://www.gnu.org/copyleft/gpl.html.
35**
36** If you have questions regarding the use of this file, please contact
37** Nokia at [email protected].
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
53QT_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
65static CFStringRef kQToolBarHIToolbarItemClassID = CFSTR(S);
66static CFStringRef kQToolBarHIToolbarIdentifier = CFSTR(SToolbar);
67#else
68static NSString *kQToolBarNSToolbarIdentifier = @SNSToolbar;
69#endif
70static 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
80static CFStringRef kQToolBarHIToolbarItemClassID = CFSTR("com.trolltech.qt.qmainwindow.qtoolbarInHIToolbar");
81static CFStringRef kQToolBarHIToolbarIdentifier = CFSTR("com.trolltech.qt.hitoolbar-qtoolbar");
82#else
83static NSString *kQToolBarNSToolbarIdentifier = @"com.trolltech.qt.qmainwindow.qtoolbarInNSToolbar";
84#endif
85static CFStringRef kQMainWindowMacToolbarID = CFSTR("com.trolltech.qt.qmainwindow.mactoolbar");
86#endif // QT_NAMESPACE
87
88#ifndef QT_MAC_USE_COCOA
89
90static const int kEventParamQToolBar = 'QTBR';
91static const int kEventParamQMainWindowLayout = 'QMWL';
92
93const EventTypeSpec qtoolbarEvents[] =
94{
95 { kEventClassHIObject, kEventHIObjectConstruct },
96 { kEventClassHIObject, kEventHIObjectDestruct },
97 { kEventClassHIObject, kEventHIObjectInitialize },
98 { kEventClassToolbarItem, kEventToolbarItemCreateCustomView }
99};
100
101struct QToolBarInHIToolbarInfo
102{
103 QToolBarInHIToolbarInfo(HIToolbarItemRef item)
104 : toolbarItem(item), mainWindowLayout(0)
105 {}
106 HIToolbarItemRef toolbarItem;
107 QMainWindowLayout *mainWindowLayout;
108};
109
110OSStatus 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
175void 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
187static void GetToolbarAllowedItems(CFMutableArrayRef array)
188{
189 CFArrayAppendValue(array, kQToolBarHIToolbarIdentifier);
190}
191
192HIToolbarItemRef 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
219HIToolbarItemRef 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
235static const EventTypeSpec kToolbarEvents[] = {
236{ kEventClassToolbar, kEventToolbarGetDefaultIdentifiers },
237{ kEventClassToolbar, kEventToolbarGetAllowedIdentifiers },
238{ kEventClassToolbar, kEventToolbarCreateItemWithIdentifier },
239{ kEventClassToolbar, kEventToolbarItemAdded },
240{ kEventClassToolbar, kEventToolbarItemRemoved }
241};
242
243OSStatus 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
326void 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
362void 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
443void 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 unifiedToolbarHash.remove(item);
467 qtoolbarsInUnifiedToolbarList.removeAll(toolbar);
468#endif
469 break;
470 }
471 ++it;
472 }
473}
474
475void QMainWindowLayout::cleanUpMacToolbarItems()
476{
477#ifdef QT_MAC_USE_COCOA
478 QMacCocoaAutoReleasePool pool;
479#endif
480 for (int i = 0; i < toolbarItemsCopy.size(); ++i) {
481#ifdef QT_MAC_USE_COCOA
482 NSToolbarItem *item = static_cast<NSToolbarItem *>(toolbarItemsCopy.at(i));
483 [item setView:0];
484#endif
485 CFRelease(toolbarItemsCopy.at(i));
486 }
487 toolbarItemsCopy.clear();
488 unifiedToolbarHash.clear();
489
490#ifdef QT_MAC_USE_COCOA
491 OSWindowRef window = qt_mac_window_for(layoutState.mainWindow);
492 NSToolbar *macToolbar = [window toolbar];
493 if (macToolbar) {
494 [[macToolbar delegate] release];
495 [macToolbar setDelegate:nil];
496 }
497#endif
498}
499
500void QMainWindowLayout::fixSizeInUnifiedToolbar(QToolBar *tb) const
501{
502#ifdef QT_MAC_USE_COCOA
503 QHash<void *, QToolBar *>::const_iterator it = unifiedToolbarHash.constBegin();
504 NSToolbarItem *item = nil;
505 while (it != unifiedToolbarHash.constEnd()) {
506 if (tb == it.value()) {
507 item = static_cast<NSToolbarItem *>(it.key());
508 break;
509 }
510 ++it;
511 }
512 if (item) {
513 QMacCocoaAutoReleasePool pool;
514 QWidgetItem layoutItem(tb);
515 QSize size = layoutItem.maximumSize();
516 NSSize nssize = NSMakeSize(size.width(), size.height() - 2);
517 [item setMaxSize:nssize];
518 size = layoutItem.minimumSize();
519 nssize.width = size.width();
520 nssize.height = size.height() - 2;
521 [item setMinSize:nssize];
522 }
523#else
524 Q_UNUSED(tb);
525#endif
526}
527
528void QMainWindowLayout::syncUnifiedToolbarVisibility()
529{
530 if (blockVisiblityCheck)
531 return;
532
533 Q_ASSERT(layoutState.mainWindow->unifiedTitleAndToolBarOnMac());
534 bool show = false;
535 const int ToolBarCount = qtoolbarsInUnifiedToolbarList.count();
536 for (int i = 0; i < ToolBarCount; ++i) {
537 if (qtoolbarsInUnifiedToolbarList.at(i)->isVisible()) {
538 show = true;
539 break;
540 }
541 }
542 macWindowToolbarShow(layoutState.mainWindow, show);
543}
544
545QT_END_NAMESPACE
Note: See TracBrowser for help on using the repository browser.