1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "ScreenHelperCocoa.h"
#import <Cocoa/Cocoa.h>
#include "mozilla/Logging.h"
#include "nsCocoaFeatures.h"
#include "nsCocoaUtils.h"
#include "nsObjCExceptions.h"
using namespace mozilla;
static LazyLogModule sScreenLog("WidgetScreen");
@interface ScreenHelperDelegate : NSObject {
@private
mozilla::widget::ScreenHelperCocoa* mHelper;
}
- (id)initWithScreenHelper:(mozilla::widget::ScreenHelperCocoa*)aScreenHelper;
- (void)didChangeScreenParameters:(NSNotification*)aNotification;
@end
@implementation ScreenHelperDelegate
- (id)initWithScreenHelper:(mozilla::widget::ScreenHelperCocoa*)aScreenHelper {
if ((self = [self init])) {
mHelper = aScreenHelper;
[[NSNotificationCenter defaultCenter]
addObserver:self
selector:@selector(didChangeScreenParameters:)
name:NSApplicationDidChangeScreenParametersNotification
object:nil];
}
return self;
}
- (void)dealloc {
[[NSNotificationCenter defaultCenter] removeObserver:self];
[super dealloc];
}
- (void)didChangeScreenParameters:(NSNotification*)aNotification {
MOZ_LOG(sScreenLog, LogLevel::Debug,
("Received NSApplicationDidChangeScreenParametersNotification"));
mHelper->RefreshScreens();
}
@end
namespace mozilla {
namespace widget {
ScreenHelperCocoa::ScreenHelperCocoa() {
NS_OBJC_BEGIN_TRY_IGNORE_BLOCK;
MOZ_LOG(sScreenLog, LogLevel::Debug, ("ScreenHelperCocoa created"));
mDelegate = [[ScreenHelperDelegate alloc] initWithScreenHelper:this];
RefreshScreens();
NS_OBJC_END_TRY_IGNORE_BLOCK;
}
ScreenHelperCocoa::~ScreenHelperCocoa() {
NS_OBJC_BEGIN_TRY_IGNORE_BLOCK;
[mDelegate release];
NS_OBJC_END_TRY_IGNORE_BLOCK;
}
static already_AddRefed<Screen> MakeScreen(NSScreen* aScreen) {
NS_OBJC_BEGIN_TRY_BLOCK_RETURN;
DesktopToLayoutDeviceScale contentsScaleFactor(
nsCocoaUtils::GetBackingScaleFactor(aScreen));
CSSToLayoutDeviceScale defaultCssScaleFactor(contentsScaleFactor.scale);
NSRect frame = [aScreen frame];
LayoutDeviceIntRect rect = nsCocoaUtils::CocoaRectToGeckoRectDevPix(
frame, contentsScaleFactor.scale);
frame = [aScreen visibleFrame];
LayoutDeviceIntRect availRect = nsCocoaUtils::CocoaRectToGeckoRectDevPix(
frame, contentsScaleFactor.scale);
// aScreen may be capable of displaying multiple pixel depths, for example by
// transitioning to an HDR-capable depth when required by a window displayed
// on the screen. We want to note the maximum capabilities of the screen, so
// we use the largest depth it offers.
uint32_t pixelDepth = 0;
const NSWindowDepth* depths = [aScreen supportedWindowDepths];
for (size_t d = 0; NSWindowDepth depth = depths[d]; d++) {
uint32_t bpp = NSBitsPerPixelFromDepth(depth);
if (bpp > pixelDepth) {
pixelDepth = bpp;
}
}
// But it confuses content if we return too-high a value here. Cap depth with
// a value that matches what Chrome returns for high bpp screens.
static const uint32_t MAX_REPORTED_PIXEL_DEPTH = 30;
if (pixelDepth > MAX_REPORTED_PIXEL_DEPTH) {
pixelDepth = MAX_REPORTED_PIXEL_DEPTH;
}
// What's the maximum color component value this screen can display? This
// is a reasonable stand-in for measuring peak brightness.
CGFloat componentValueMax =
aScreen.maximumPotentialExtendedDynamicRangeColorComponentValue;
// Should we treat this as HDR? Based on spec at
// https://drafts.csswg.org/mediaqueries-5/#dynamic-range, we'll consider it
// HDR if it has pixel depth greater than 24, and if has high peak brightness,
// which we measure by checking if it can represent component values greater
// than 1.0.
//
// Also, on HDR screens, users may want to force SDR by setting a different
// colorspace, for example by using the "Photography (P3 D65)" preset. In that
// case, componentValueMax will be 1.0 and we want to treat the display as
// SDR.
bool isHDR = pixelDepth > 24 && componentValueMax > 1.0;
// Double-check HDR against the platform capabilities.
isHDR &= nsCocoaFeatures::OnBigSurOrLater();
float dpi = 96.0f;
CGDirectDisplayID displayID =
[[[aScreen deviceDescription] objectForKey:@"NSScreenNumber"] intValue];
CGFloat heightMM = ::CGDisplayScreenSize(displayID).height;
if (heightMM > 0) {
dpi = rect.height / (heightMM / MM_PER_INCH_FLOAT);
}
MOZ_LOG(sScreenLog, LogLevel::Debug,
("New screen [%d %d %d %d (%d %d %d %d) %d %f %f %f]", rect.x, rect.y,
rect.width, rect.height, availRect.x, availRect.y, availRect.width,
availRect.height, pixelDepth, contentsScaleFactor.scale,
defaultCssScaleFactor.scale, dpi));
// Getting the refresh rate is a little hard on OS X. We could use
// CVDisplayLinkGetNominalOutputVideoRefreshPeriod, but that's a little
// involved. Ideally we could query it from vsync. For now, we leave it out.
RefPtr<Screen> screen =
new Screen(rect, availRect, pixelDepth, pixelDepth, 0,
contentsScaleFactor, defaultCssScaleFactor, dpi,
Screen::IsPseudoDisplay::No, Screen::IsHDR(isHDR));
return screen.forget();
NS_OBJC_END_TRY_BLOCK_RETURN(nullptr);
}
void ScreenHelperCocoa::RefreshScreens() {
NS_OBJC_BEGIN_TRY_IGNORE_BLOCK;
MOZ_LOG(sScreenLog, LogLevel::Debug, ("Refreshing screens"));
AutoTArray<RefPtr<Screen>, 4> screens;
for (NSScreen* screen in [NSScreen screens]) {
NSDictionary* desc = [screen deviceDescription];
if ([desc objectForKey:NSDeviceIsScreen] == nil) {
continue;
}
screens.AppendElement(MakeScreen(screen));
}
ScreenManager::Refresh(std::move(screens));
NS_OBJC_END_TRY_IGNORE_BLOCK;
}
NSScreen* ScreenHelperCocoa::CocoaScreenForScreen(nsIScreen* aScreen) {
NS_OBJC_BEGIN_TRY_BLOCK_RETURN;
for (NSScreen* screen in [NSScreen screens]) {
NSDictionary* desc = [screen deviceDescription];
if ([desc objectForKey:NSDeviceIsScreen] == nil) {
continue;
}
LayoutDeviceIntRect rect;
double scale;
aScreen->GetRect(&rect.x, &rect.y, &rect.width, &rect.height);
aScreen->GetContentsScaleFactor(&scale);
NSRect frame = [screen frame];
LayoutDeviceIntRect frameRect =
nsCocoaUtils::CocoaRectToGeckoRectDevPix(frame, scale);
if (rect == frameRect) {
return screen;
}
}
return [NSScreen mainScreen];
NS_OBJC_END_TRY_BLOCK_RETURN(nil);
}
} // namespace widget
} // namespace mozilla
|
