Tôi biết tôi có thể nhận được kích thước của màn hình chính bằng cách sử dụng
System.Windows.SystemParameters.PrimaryScreenWidth;
System.Windows.SystemParameters.PrimaryScreenHeight;
Nhưng làm thế nào để tôi có được kích thước của màn hình hiện tại? (Người dùng Đa màn hình không phải lúc nào cũng sử dụng màn hình chính và không phải tất cả các màn hình đều sử dụng cùng một độ phân giải, phải không?)
Sẽ rất tuyệt nếu có thể tăng kích thước từ XAML, nhưng làm như vậy từ mã (C #) là đủ.
Câu trả lời:
Theo như tôi biết không có chức năng WPF gốc để lấy kích thước của màn hình hiện tại. Thay vào đó, bạn có thể PInvoke các chức năng của nhiều màn hình hiển thị gốc , bọc chúng trong lớp được quản lý và hiển thị tất cả các thuộc tính bạn cần sử dụng chúng từ XAML.
Tôi đã tạo một trình bao bọc nhỏ xung quanh Màn hình từ System.Windows.Forms, hiện tại mọi thứ đều hoạt động ... Tuy nhiên, không chắc chắn về "pixel độc lập với thiết bị".
public class WpfScreen
{
public static IEnumerable<WpfScreen> AllScreens()
{
foreach (Screen screen in System.Windows.Forms.Screen.AllScreens)
{
yield return new WpfScreen(screen);
}
}
public static WpfScreen GetScreenFrom(Window window)
{
WindowInteropHelper windowInteropHelper = new WindowInteropHelper(window);
Screen screen = System.Windows.Forms.Screen.FromHandle(windowInteropHelper.Handle);
WpfScreen wpfScreen = new WpfScreen(screen);
return wpfScreen;
}
public static WpfScreen GetScreenFrom(Point point)
{
int x = (int) Math.Round(point.X);
int y = (int) Math.Round(point.Y);
// are x,y device-independent-pixels ??
System.Drawing.Point drawingPoint = new System.Drawing.Point(x, y);
Screen screen = System.Windows.Forms.Screen.FromPoint(drawingPoint);
WpfScreen wpfScreen = new WpfScreen(screen);
return wpfScreen;
}
public static WpfScreen Primary
{
get { return new WpfScreen(System.Windows.Forms.Screen.PrimaryScreen); }
}
private readonly Screen screen;
internal WpfScreen(System.Windows.Forms.Screen screen)
{
this.screen = screen;
}
public Rect DeviceBounds
{
get { return this.GetRect(this.screen.Bounds); }
}
public Rect WorkingArea
{
get { return this.GetRect(this.screen.WorkingArea); }
}
private Rect GetRect(Rectangle value)
{
// should x, y, width, height be device-independent-pixels ??
return new Rect
{
X = value.X,
Y = value.Y,
Width = value.Width,
Height = value.Height
};
}
public bool IsPrimary
{
get { return this.screen.Primary; }
}
public string DeviceName
{
get { return this.screen.DeviceName; }
}
}
Đây này. Điều này sẽ chỉ cung cấp cho bạn chiều rộng và chiều cao của vùng làm việc
System.Windows.SystemParameters.WorkArea.Width
System.Windows.SystemParameters.WorkArea.Height
Điều này sẽ cung cấp cho bạn màn hình hiện tại dựa trên phía trên bên trái của cửa sổ, chỉ cần gọi this.CurrentScreen () để nhận thông tin trên màn hình hiện tại.
using System.Windows;
using System.Windows.Forms;
namespace Common.Helpers
{
public static class WindowHelpers
{
public static Screen CurrentScreen(this Window window)
{
return Screen.FromPoint(new System.Drawing.Point((int)window.Left,(int)window.Top));
}
}
}
Hãy dành thời gian để quét qua các thành viên SystemParameters.
VirtualScreenWidthVirtualScreenHeightChúng thậm chí còn tính đến vị trí tương đối của các màn hình.
Chỉ được thử nghiệm với hai màn hình.
Tại sao không chỉ sử dụng cái này?
var interopHelper = new WindowInteropHelper(System.Windows.Application.Current.MainWindow);
var activeScreen = Screen.FromHandle(interopHelper.Handle);
System.Windows.Forms.Screenthành để đối phó với pixel độc lập với thiết bị
Nếu bạn đã quen với việc sử dụng lớp System.Windows.Forms thì bạn chỉ cần thêm một tham chiếu của lớp System.Windows.Forms vào dự án của mình:
Solution Explorer -> References -> Add References ... -> (Assemblies: Framework) -> cuộn xuống và kiểm tra lắp ráp System.Windows.Forms -> OK .
Bây giờ bạn có thể thêm bằng cách sử dụng System.Windows.Forms; tuyên bố và sử dụng màn hình trong dự án wpf của bạn giống như trước đây.
Tôi cũng cần kích thước màn hình hiện tại, cụ thể là Vùng làm việc, trả về hình chữ nhật không bao gồm chiều rộng Thanh tác vụ.
Tôi đã sử dụng nó để đặt lại vị trí của một cửa sổ, được mở sang bên phải và xuống vị trí của con chuột. Vì cửa sổ khá lớn, trong nhiều trường hợp, nó đã vượt ra khỏi giới hạn màn hình. Các mã sau đây được dựa trên @ej câu trả lời: Điều này sẽ cung cấp cho bạn màn hình hiện tại ... . Sự khác biệt là tôi cũng hiển thị thuật toán định vị lại của mình, mà tôi cho rằng đó thực sự là điểm mấu chốt.
Mật mã:
using System.Windows;
using System.Windows.Forms;
namespace MySample
{
public class WindowPostion
{
/// <summary>
/// This method adjust the window position to avoid from it going
/// out of screen bounds.
/// </summary>
/// <param name="topLeft">The requiered possition without its offset</param>
/// <param name="maxSize">The max possible size of the window</param>
/// <param name="offset">The offset of the topLeft postion</param>
/// <param name="margin">The margin from the screen</param>
/// <returns>The adjusted position of the window</returns>
System.Drawing.Point Adjust(System.Drawing.Point topLeft, System.Drawing.Point maxSize, int offset, int margin)
{
Screen currentScreen = Screen.FromPoint(topLeft);
System.Drawing.Rectangle rect = currentScreen.WorkingArea;
// Set an offset from mouse position.
topLeft.Offset(offset, offset);
// Check if the window needs to go above the task bar,
// when the task bar shadows the HUD window.
int totalHight = topLeft.Y + maxSize.Y + margin;
if (totalHight > rect.Bottom)
{
topLeft.Y -= (totalHight - rect.Bottom);
// If the screen dimensions exceed the hight of the window
// set it just bellow the top bound.
if (topLeft.Y < rect.Top)
{
topLeft.Y = rect.Top + margin;
}
}
int totalWidth = topLeft.X + maxSize.X + margin;
// Check if the window needs to move to the left of the mouse,
// when the HUD exceeds the right window bounds.
if (totalWidth > rect.Right)
{
// Since we already set an offset remove it and add the offset
// to the other side of the mouse (2x) in addition include the
// margin.
topLeft.X -= (maxSize.X + (2 * offset + margin));
// If the screen dimensions exceed the width of the window
// don't exceed the left bound.
if (topLeft.X < rect.Left)
{
topLeft.X = rect.Left + margin;
}
}
return topLeft;
}
}
}
Một số giải thích:
1) topLeft - position of the top left at the desktop (works
for multi screens - with different aspect ratio).
Screen1 Screen2
─ ┌───────────────────┐┌───────────────────┐ Screen3
▲ │ ││ │┌─────────────────┐ ─
│ │ ││ ││ ▼- │ ▲
1080 │ │ ││ ││ │ │
│ │ ││ ││ │ │ 900
▼ │ ││ ││ │ ▼
─ └──────┬─────┬──────┘└──────┬─────┬──────┘└──────┬────┬─────┘ ─
─┴─────┴─ ─┴─────┴─ ─┴────┴─
│◄─────────────────►││◄─────────────────►││◄───────────────►│
1920 1920 1440
If the mouse is in Screen3 a possible value might be:
topLeft.X=4140 topLeft.Y=195
2) offset - the offset from the top left, one value for both
X and Y directions.
3) maxSize - the maximal size of the window - including its
size when it is expanded - from the following example
we need maxSize.X = 200, maxSize.Y = 150 - To avoid the expansion
being out of bound.
Non expanded window:
┌──────────────────────────────┐ ─
│ Window Name [X]│ ▲
├──────────────────────────────┤ │
│ ┌─────────────────┐ │ │ 100
│ Text1: │ │ │ │
│ └─────────────────┘ │ │
│ [▼] │ ▼
└──────────────────────────────┘ ─
│◄────────────────────────────►│
200
Expanded window:
┌──────────────────────────────┐ ─
│ Window Name [X]│ ▲
├──────────────────────────────┤ │
│ ┌─────────────────┐ │ │
│ Text1: │ │ │ │
│ └─────────────────┘ │ │ 150
│ [▲] │ │
│ ┌─────────────────┐ │ │
│ Text2: │ │ │ │
│ └─────────────────┘ │ ▼
└──────────────────────────────┘ ─
│◄────────────────────────────►│
200
4) margin - The distance the window should be from the screen
work-area - Example:
┌─────────────────────────────────────────────────────────────┐ ─
│ │ ↕ Margin
│ │ ─
│ │
│ │
│ │
│ ┌──────────────────────────────┐ │
│ │ Window Name [X]│ │
│ ├──────────────────────────────┤ │
│ │ ┌─────────────────┐ │ │
│ │ Text1: │ │ │ │
│ │ └─────────────────┘ │ │
│ │ [▲] │ │
│ │ ┌─────────────────┐ │ │
│ │ Text2: │ │ │ │
│ │ └─────────────────┘ │ │
│ └──────────────────────────────┘ │ ─
│ │ ↕ Margin
├──────────────────────────────────────────────────┬──────────┤ ─
│[start] [♠][♦][♣][♥] │en│ 12:00 │
└──────────────────────────────────────────────────┴──────────┘
│◄─►│ │◄─►│
Margin Margin
* Note that this simple algorithm will always want to leave the cursor
out of the window, therefor the window will jumps to its left:
┌─────────────────────────────────┐ ┌─────────────────────────────────┐
│ ▼-┌──────────────┐ │ ┌──────────────┐▼- │
│ │ Window [X]│ │ │ Window [X]│ │
│ ├──────────────┤ │ ├──────────────┤ │
│ │ ┌───┐ │ │ │ ┌───┐ │ │
│ │ Val: │ │ │ -> │ │ Val: │ │ │ │
│ │ └───┘ │ │ │ └───┘ │ │
│ └──────────────┘ │ └──────────────┘ │
│ │ │ │
├──────────────────────┬──────────┤ ├──────────────────────┬──────────┤
│[start] [♠][♦][♣] │en│ 12:00 │ │[start] [♠][♦][♣] │en│ 12:00 │
└──────────────────────┴──────────┘ └──────────────────────┴──────────┘
If this is not a requirement, you can add a parameter to just use
the margin:
┌─────────────────────────────────┐ ┌─────────────────────────────────┐
│ ▼-┌──────────────┐ │ ┌─▼-───────────┐ │
│ │ Window [X]│ │ │ Window [X]│ │
│ ├──────────────┤ │ ├──────────────┤ │
│ │ ┌───┐ │ │ │ ┌───┐ │ │
│ │ Val: │ │ │ -> │ │ Val: │ │ │ │
│ │ └───┘ │ │ │ └───┘ │ │
│ └──────────────┘ │ └──────────────┘ │
│ │ │ │
├──────────────────────┬──────────┤ ├──────────────────────┬──────────┤
│[start] [♠][♦][♣] │en│ 12:00 │ │[start] [♠][♦][♣] │en│ 12:00 │
└──────────────────────┴──────────┘ └──────────────────────┴──────────┘
* Supports also the following scenarios:
1) Screen over screen:
┌─────────────────┐
│ │
│ │
│ │
│ │
└─────────────────┘
┌───────────────────┐
│ │
│ ▼- │
│ │
│ │
│ │
└──────┬─────┬──────┘
─┴─────┴─
2) Window bigger than screen hight or width
┌─────────────────────────────────┐ ┌─────────────────────────────────┐
│ │ │ ┌──────────────┐ │
│ │ │ │ Window [X]│ │
│ ▼-┌────────────│─┐ │ ├──────────────┤ ▼- │
│ │ Window [│]│ │ │ ┌───┐ │ │
│ ├────────────│─┤ -> │ │ Val: │ │ │ │
│ │ ┌───┐│ │ │ │ └───┘ │ │
│ │ Val: │ ││ │ │ │ ┌───┐ │ │
│ │ └───┘│ │ │ │ Val: │ │ │ │
├──────────────────────┬──────────┤ │ ├──────────────────────┬──────────┤
│[start] [♠][♦][♣] │en│ 12:00 │ │ │[start] [♠][♦][♣] │en│ 12:00 │
└──────────────────────┴──────────┘ │ └──────────────────────┴──────────┘
│ ┌───┐ │ │ └───┘ │
│ Val: │ │ │ └──────────────┘
│ └───┘ │
└──────────────┘
┌─────────────────────────────────┐ ┌─────────────────────────────────┐
│ │ │ │
│ │ │ ┌───────────────────────────────│───┐
│ ▼-┌──────────────────────────│────────┐ │ │ W▼-dow │[X]│
│ │ Window │ [X]│ │ ├───────────────────────────────│───┤
│ ├──────────────────────────│────────┤ │ │ ┌───┐ ┌───┐ ┌─┤─┐ │
│ │ ┌───┐ ┌───┐ │ ┌───┐ │ -> │ │ Val: │ │ Val: │ │ Val: │ │ │ │
│ │ Val: │ │ Val: │ │ Va│: │ │ │ │ │ └───┘ └───┘ └─┤─┘ │
│ │ └───┘ └───┘ │ └───┘ │ │ └───────────────────────────────│───┘
├──────────────────────┬──────────┤────────┘ ├──────────────────────┬──────────┤
│[start] [♠][♦][♣] │en│ 12:00 │ │[start] [♠][♦][♣] │en│ 12:00 │
└──────────────────────┴──────────┘ └──────────────────────┴──────────┘
<remark><code>...</code></remark>Tôi hiểu những yêu cầu. Vấn đề là, có các Phương pháp WPF để nhận các giá trị đó - nhưng có, một trong những người đóng góp là đúng, không phải trực tiếp. Giải pháp không phải là để có được tất cả những cách giải quyết đó, mà là thay đổi cách tiếp cận ban đầu theo Thiết kế và Phát triển sạch.
A) Đặt Cửa sổ chính ban đầu thành Màn hình
B) Nhận các giá trị cho ActualWindow bao gồm nhiều phương pháp WPF hữu ích
C) Bạn có thể thêm bao nhiêu Windows tùy thích cho hành vi bạn muốn, như có thể thay đổi kích thước, thu nhỏ bất kỳ thứ gì… nhưng bây giờ bạn luôn có thể truy cập Màn hình đã tải và Kết xuất
Hãy cẩn thận với ví dụ sau, có một số Mã xung quanh khiến bạn cần phải sử dụng kiểu tiếp cận đó, tuy nhiên nó sẽ hoạt động (Nó sẽ cung cấp cho bạn Điểm cho mỗi góc của màn hình của bạn): Ví dụ làm việc trên đơn, Màn hình kép và các độ phân giải khác nhau (Trong lớp cửa sổ chính Primal):
InitializeComponent();
[…]
ActualWindow.AddHandler(Window.LoadedEvent, new RoutedEventHandler(StartUpScreenLoaded));
Sự kiện được định tuyến:
private void StartUpScreenLoaded(object sender, RoutedEventArgs e)
{
Window StartUpScreen = sender as Window;
// Dispatcher Format B:
Dispatcher.Invoke(new Action(() =>
{
// Get Actual Window on Loaded
StartUpScreen.InvalidateVisual();
System.Windows.Point CoordinatesTopRight = StartUpScreen.TranslatePoint(new System.Windows.Point((StartUpScreen.ActualWidth), (0d)), ActualWindow);
System.Windows.Point CoordinatesBottomRight = StartUpScreen.TranslatePoint(new System.Windows.Point((StartUpScreen.ActualWidth), (StartUpScreen.ActualHeight)), ActualWindow);
System.Windows.Point CoordinatesBottomLeft = StartUpScreen.TranslatePoint(new System.Windows.Point((0d), (StartUpScreen.ActualHeight)), ActualWindow);
// Set the Canvas Top Right, Bottom Right, Bottom Left Coordinates
System.Windows.Application.Current.Resources["StartUpScreenPointTopRight"] = CoordinatesTopRight;
System.Windows.Application.Current.Resources["StartUpScreenPointBottomRight"] = CoordinatesBottomRight;
System.Windows.Application.Current.Resources["StartUpScreenPointBottomLeft"] = CoordinatesBottomLeft;
}), DispatcherPriority.Loaded);
}
Nếu bạn sử dụng bất kỳ cửa sổ toàn màn hình nào (có cửa sổ WindowState = WindowState.Maximized, WindowStyle = WindowStyle.None), bạn có thể bọc nội dung của nó System.Windows.Controls.Canvasnhư sau:
<Canvas Name="MyCanvas" Width="auto" Height="auto">
...
</Canvas>
Sau đó, bạn có thể sử dụng MyCanvas.ActualWidthvàMyCanvas.ActualHeight lấy độ phân giải của màn hình hiện tại, có tính đến cài đặt DPI và trong các đơn vị độc lập với thiết bị. Nó không thêm bất kỳ lề nào như chính cửa sổ được phóng to.
(Canvas chấp nhận UIElementcác trẻ em là trẻ em, vì vậy bạn có thể sử dụng nó với bất kỳ nội dung nào.)
double screenWidth = System.Windows.SystemParameters.PrimaryScreenWidth;
double screenhight= System.Windows.SystemParameters.PrimaryScreenHeight;
Nó hoạt động với
this.Width = System.Windows.SystemParameters.VirtualScreenWidth;
this.Height = System.Windows.SystemParameters.VirtualScreenHeight;
Đã test trên 2 màn hình.
VirtualScreentrải dài trên tất cả các màn hình - vì vậy điều này sẽ không bao giờ hoạt động nếu bạn có nhiều màn hình!