Revision control
Copy as Markdown
// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include <AppKit/AppKit.h>
#include <QtCore/qtimer.h>
#include <QtGui/qfontdatabase.h>
#include <qpa/qplatformtheme.h>
#include <private/qfont_p.h>
#include <private/qfontengine_p.h>
#include <private/qfontengine_coretext_p.h>
#include "qcocoafontdialoghelper.h"
#include "qcocoahelpers.h"
#include "qcocoaeventdispatcher.h"
#include "qnsview.h"
#if !CGFLOAT_DEFINED
typedef float CGFloat; // Should only not be defined on 32-bit platforms
#endif
QT_USE_NAMESPACE
static QFont qfontForCocoaFont(NSFont *cocoaFont, const QFont &resolveFont)
{
QFont newFont;
if (cocoaFont) {
int pSize = qRound([cocoaFont pointSize]);
QCFType<CTFontDescriptorRef> font(CTFontCopyFontDescriptor((CTFontRef)cocoaFont));
QString family(QCFString((CFStringRef)CTFontDescriptorCopyAttribute(font, kCTFontFamilyNameAttribute)));
QString style(QCFString(((CFStringRef)CTFontDescriptorCopyAttribute(font, kCTFontStyleNameAttribute))));
newFont = QFontDatabase::font(family, style, pSize);
newFont.setUnderline(resolveFont.underline());
newFont.setStrikeOut(resolveFont.strikeOut());
}
return newFont;
}
@interface QT_MANGLE_NAMESPACE(QNSFontPanelDelegate) : NSObject<NSWindowDelegate, QNSPanelDelegate>
- (void)restoreOriginalContentView;
- (void)updateQtFont;
- (void)changeFont:(id)sender;
- (void)finishOffWithCode:(NSInteger)code;
@end
QT_NAMESPACE_ALIAS_OBJC_CLASS(QNSFontPanelDelegate);
@implementation QNSFontPanelDelegate {
@public
NSFontPanel *mFontPanel;
QCocoaFontDialogHelper *mHelper;
NSView *mStolenContentView;
QNSPanelContentsWrapper *mPanelButtons;
QFont mQtFont;
NSInteger mResultCode;
BOOL mDialogIsExecuting;
BOOL mResultSet;
}
- (instancetype)init
{
if ((self = [super init])) {
mFontPanel = [NSFontPanel sharedFontPanel];
mHelper = nullptr;
mStolenContentView = nil;
mPanelButtons = nil;
mResultCode = NSModalResponseCancel;
mDialogIsExecuting = false;
mResultSet = false;
[mFontPanel setRestorable:NO];
[mFontPanel setDelegate:self];
[mFontPanel retain];
}
return self;
}
- (void)dealloc
{
[mStolenContentView release];
[mFontPanel setDelegate:nil];
[[NSNotificationCenter defaultCenter] removeObserver:self];
[super dealloc];
}
- (void)setDialogHelper:(QCocoaFontDialogHelper *)helper
{
mHelper = helper;
[mFontPanel setTitle:helper->options()->windowTitle().toNSString()];
if (mHelper->options()->testOption(QFontDialogOptions::NoButtons)) {
[self restoreOriginalContentView];
} else if (!mStolenContentView) {
// steal the font panel's contents view
mStolenContentView = mFontPanel.contentView;
[mStolenContentView retain];
mFontPanel.contentView = nil;
// create a new content view and add the stolen one as a subview
mPanelButtons = [[QNSPanelContentsWrapper alloc] initWithPanelDelegate:self];
[mPanelButtons addSubview:mStolenContentView];
mPanelButtons.panelContentsMargins = NSEdgeInsetsMake(0, 0, 7, 0);
mFontPanel.contentView = mPanelButtons;
mFontPanel.defaultButtonCell = mPanelButtons.okButton.cell;
}
}
- (void)closePanel
{
[mFontPanel close];
}
- (void)restoreOriginalContentView
{
if (mStolenContentView) {
// return stolen stuff to its rightful owner
[mStolenContentView removeFromSuperview];
[mFontPanel setContentView:mStolenContentView];
mStolenContentView = nil;
[mPanelButtons release];
mPanelButtons = nil;
}
}
- (void)onOkClicked
{
[mFontPanel close];
[self finishOffWithCode:NSModalResponseOK];
}
- (void)onCancelClicked
{
if (mPanelButtons) {
[mFontPanel close];
mQtFont = QFont();
[self finishOffWithCode:NSModalResponseCancel];
}
}
- (void)changeFont:(id)sender
{
Q_UNUSED(sender);
[self updateQtFont];
}
- (void)updateQtFont
{
// Get selected font
NSFontManager *fontManager = [NSFontManager sharedFontManager];
NSFont *selectedFont = [fontManager selectedFont];
if (!selectedFont) {
selectedFont = [NSFont systemFontOfSize:[NSFont systemFontSize]];
}
NSFont *panelFont = [fontManager convertFont:selectedFont];
mQtFont = qfontForCocoaFont(panelFont, mQtFont);
if (mHelper)
emit mHelper->currentFontChanged(mQtFont);
}
- (void)showModelessPanel
{
mDialogIsExecuting = false;
mResultSet = false;
// Make this an asynchronous call, so the panel is made key only
// in the next event loop run. This is to make sure that by
// the time the modal loop is run in runModalForWindow below,
// which internally also sets the panel to key window,
// the panel is not yet key, and the NSApp still has the right
// reference to the _previousKeyWindow. Otherwise both NSApp.key
// and NSApp._previousKeyWindow would wrongly point to the panel,
// loosing any reference to the window that was key before.
dispatch_async(dispatch_get_main_queue(), ^{
[mFontPanel makeKeyAndOrderFront:mFontPanel];
});
}
- (BOOL)runApplicationModalPanel
{
mDialogIsExecuting = true;
// Call processEvents in case the event dispatcher has been interrupted, and needs to do
// cleanup of modal sessions. Do this before showing the native dialog, otherwise it will
// close down during the cleanup.
qApp->processEvents(QEventLoop::ExcludeUserInputEvents | QEventLoop::ExcludeSocketNotifiers);
// Make sure we don't interrupt the runModalForWindow call.
QCocoaEventDispatcher::clearCurrentThreadCocoaEventDispatcherInterruptFlag();
[NSApp runModalForWindow:mFontPanel];
mDialogIsExecuting = false;
// Wake up the event dispatcher so it can check whether the
// current event loop should continue spinning or not.
QCoreApplication::eventDispatcher()->wakeUp();
return (mResultCode == NSModalResponseOK);
}
// Future proofing in case _NSTargetForSendAction checks this
// property before sending us the changeFont: message.
- (BOOL)worksWhenModal
{
return YES;
}
- (QPlatformDialogHelper::DialogCode)dialogResultCode
{
return (mResultCode == NSModalResponseOK) ? QPlatformDialogHelper::Accepted : QPlatformDialogHelper::Rejected;
}
- (BOOL)windowShouldClose:(id)window
{
Q_UNUSED(window);
if (!mPanelButtons)
[self updateQtFont];
if (mDialogIsExecuting) {
[self finishOffWithCode:NSModalResponseCancel];
} else {
mResultSet = true;
if (mHelper)
emit mHelper->reject();
}
return true;
}
- (void)finishOffWithCode:(NSInteger)code
{
mResultCode = code;
if (mDialogIsExecuting) {
// We stop the current modal event loop. The control
// will then return inside -(void)exec below.
// It's important that the modal event loop is stopped before
// we accept/reject QFontDialog, since QFontDialog has its
// own event loop that needs to be stopped last.
[NSApp stopModalWithCode:code];
} else {
// Since we are not in a modal event loop, we can safely close
// down QFontDialog
// Calling accept() or reject() can in turn call closeCocoaFontPanel.
// This check will prevent any such recursion.
if (!mResultSet) {
mResultSet = true;
if (mResultCode == NSModalResponseCancel) {
emit mHelper->reject();
} else {
emit mHelper->accept();
}
}
}
}
@end
@interface QNSView (FontPanel)
- (void)changeFont:(id)sender;
@end
@implementation QNSView (FontPanel)
- (void)changeFont:(id)sender
{
if (auto *delegate = qt_objc_cast<QNSFontPanelDelegate*>(NSFontPanel.sharedFontPanel.delegate))
[delegate changeFont:sender];
}
@end
QT_BEGIN_NAMESPACE
class QCocoaFontPanel
{
public:
QCocoaFontPanel()
{
mDelegate = [[QNSFontPanelDelegate alloc] init];
}
~QCocoaFontPanel()
{
[mDelegate release];
}
void init(QCocoaFontDialogHelper *helper)
{
[mDelegate setDialogHelper:helper];
}
void cleanup(QCocoaFontDialogHelper *helper)
{
if (mDelegate->mHelper == helper)
mDelegate->mHelper = nullptr;
}
bool exec()
{
// Note: If NSApp is not running (which is the case if e.g a top-most
// QEventLoop has been interrupted, and the second-most event loop has not
// yet been reactivated (regardless if [NSApp run] is still on the stack)),
// showing a native modal dialog will fail.
return [mDelegate runApplicationModalPanel];
}
bool show(Qt::WindowModality windowModality, QWindow *parent)
{
Q_UNUSED(parent);
if (windowModality != Qt::ApplicationModal)
[mDelegate showModelessPanel];
// no need to show a Qt::ApplicationModal dialog here, because it will be shown in runApplicationModalPanel
return true;
}
void hide()
{
[mDelegate closePanel];
}
QFont currentFont() const
{
return mDelegate->mQtFont;
}
void setCurrentFont(const QFont &font)
{
NSFontManager *mgr = [NSFontManager sharedFontManager];
NSFont *nsFont = nil;
int weight = 5;
NSFontTraitMask mask = 0;
if (font.style() == QFont::StyleItalic) {
mask |= NSItalicFontMask;
}
if (font.weight() == QFont::Bold) {
weight = 9;
mask |= NSBoldFontMask;
}
QFontInfo fontInfo(font);
nsFont = [mgr fontWithFamily:fontInfo.family().toNSString()
traits:mask
weight:weight
size:fontInfo.pointSize()];
[mgr setSelectedFont:nsFont isMultiple:NO];
mDelegate->mQtFont = font;
}
private:
QNSFontPanelDelegate *mDelegate;
};
Q_GLOBAL_STATIC(QCocoaFontPanel, sharedFontPanel)
QCocoaFontDialogHelper::QCocoaFontDialogHelper()
{
}
QCocoaFontDialogHelper::~QCocoaFontDialogHelper()
{
sharedFontPanel()->cleanup(this);
}
void QCocoaFontDialogHelper::exec()
{
if (sharedFontPanel()->exec())
emit accept();
else
emit reject();
}
bool QCocoaFontDialogHelper::show(Qt::WindowFlags, Qt::WindowModality windowModality, QWindow *parent)
{
if (windowModality == Qt::ApplicationModal)
windowModality = Qt::WindowModal;
sharedFontPanel()->init(this);
return sharedFontPanel()->show(windowModality, parent);
}
void QCocoaFontDialogHelper::hide()
{
sharedFontPanel()->hide();
}
void QCocoaFontDialogHelper::setCurrentFont(const QFont &font)
{
sharedFontPanel()->init(this);
sharedFontPanel()->setCurrentFont(font);
}
QFont QCocoaFontDialogHelper::currentFont() const
{
return sharedFontPanel()->currentFont();
}
QT_END_NAMESPACE