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
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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 "nsScreenManagerWin.h"
#include "mozilla/gfx/2D.h"
#include "nsScreenWin.h"
#include "gfxWindowsPlatform.h"
#include "nsIWidget.h"
#include "WinUtils.h"
using namespace mozilla;
BOOL CALLBACK CountMonitors(HMONITOR, HDC, LPRECT, LPARAM ioCount);
nsScreenManagerWin::nsScreenManagerWin()
: mNumberOfScreens(0)
{
// nothing to do. I guess we could cache a bunch of information
// here, but we want to ask the device at runtime in case anything
// has changed.
}
nsScreenManagerWin::~nsScreenManagerWin()
{
}
// addref, release, QI
NS_IMPL_ISUPPORTS(nsScreenManagerWin, nsIScreenManager)
//
// CreateNewScreenObject
//
// Utility routine. Creates a new screen object from the given device handle
//
// NOTE: For this "single-monitor" impl, we just always return the cached primary
// screen. This should change when a multi-monitor impl is done.
//
nsIScreen*
nsScreenManagerWin::CreateNewScreenObject(HMONITOR inScreen)
{
nsIScreen* retScreen = nullptr;
// look through our screen list, hoping to find it. If it's not there,
// add it and return the new one.
for (unsigned i = 0; i < mScreenList.Length(); ++i) {
ScreenListItem& curr = mScreenList[i];
if (inScreen == curr.mMon) {
NS_IF_ADDREF(retScreen = curr.mScreen.get());
return retScreen;
}
} // for each screen.
retScreen = new nsScreenWin(inScreen);
mScreenList.AppendElement(ScreenListItem(inScreen, retScreen));
NS_IF_ADDREF(retScreen);
return retScreen;
}
NS_IMETHODIMP
nsScreenManagerWin::ScreenForId(uint32_t aId, nsIScreen **outScreen)
{
*outScreen = nullptr;
for (unsigned i = 0; i < mScreenList.Length(); ++i) {
ScreenListItem& curr = mScreenList[i];
uint32_t id;
nsresult rv = curr.mScreen->GetId(&id);
if (NS_SUCCEEDED(rv) && id == aId) {
NS_IF_ADDREF(*outScreen = curr.mScreen.get());
return NS_OK;
}
}
return NS_ERROR_FAILURE;
}
//
// ScreenForRect
//
// Returns the screen that contains the rectangle. If the rect overlaps
// multiple screens, it picks the screen with the greatest area of intersection.
//
// The coordinates are in pixels (not twips) and in logical screen coordinates.
//
NS_IMETHODIMP
nsScreenManagerWin::ScreenForRect(int32_t inLeft, int32_t inTop,
int32_t inWidth, int32_t inHeight,
nsIScreen **outScreen)
{
if (!(inWidth || inHeight)) {
NS_WARNING("trying to find screen for sizeless window, using primary monitor");
*outScreen = CreateNewScreenObject(nullptr); // addrefs
return NS_OK;
}
gfx::Rect logicalBounds(inLeft, inTop, inWidth, inHeight);
HMONITOR genScreen = widget::WinUtils::MonitorFromRect(logicalBounds);
*outScreen = CreateNewScreenObject(genScreen); // addrefs
return NS_OK;
} // ScreenForRect
//
// GetPrimaryScreen
//
// The screen with the menubar/taskbar. This shouldn't be needed very
// often.
//
NS_IMETHODIMP
nsScreenManagerWin::GetPrimaryScreen(nsIScreen** aPrimaryScreen)
{
*aPrimaryScreen = CreateNewScreenObject(nullptr); // addrefs
return NS_OK;
} // GetPrimaryScreen
//
// CountMonitors
//
// Will be called once for every monitor in the system. Just
// increments the parameter, which holds a ptr to a PRUin32 holding the
// count up to this point.
//
BOOL CALLBACK
CountMonitors(HMONITOR, HDC, LPRECT, LPARAM ioParam)
{
uint32_t* countPtr = reinterpret_cast<uint32_t*>(ioParam);
++(*countPtr);
return TRUE; // continue the enumeration
} // CountMonitors
//
// GetNumberOfScreens
//
// Returns how many physical screens are available.
//
NS_IMETHODIMP
nsScreenManagerWin::GetNumberOfScreens(uint32_t *aNumberOfScreens)
{
if (mNumberOfScreens)
*aNumberOfScreens = mNumberOfScreens;
else {
uint32_t count = 0;
BOOL result = ::EnumDisplayMonitors(nullptr, nullptr, (MONITORENUMPROC)CountMonitors, (LPARAM)&count);
if (!result)
return NS_ERROR_FAILURE;
*aNumberOfScreens = mNumberOfScreens = count;
}
return NS_OK;
} // GetNumberOfScreens
NS_IMETHODIMP
nsScreenManagerWin::GetSystemDefaultScale(float *aDefaultScale)
{
HMONITOR primary = widget::WinUtils::GetPrimaryMonitor();
*aDefaultScale = float(widget::WinUtils::LogToPhysFactor(primary));
return NS_OK;
}
NS_IMETHODIMP
nsScreenManagerWin::ScreenForNativeWidget(void *aWidget, nsIScreen **outScreen)
{
HMONITOR mon = MonitorFromWindow((HWND) aWidget, MONITOR_DEFAULTTOPRIMARY);
*outScreen = CreateNewScreenObject(mon);
return NS_OK;
}
|
