ฉันรู้ว่าฉันสามารถรับขนาดของหน้าจอหลักได้โดยใช้ไฟล์
System.Windows.SystemParameters.PrimaryScreenWidth;
System.Windows.SystemParameters.PrimaryScreenHeight;
แต่ฉันจะได้ขนาดของหน้าจอปัจจุบันได้อย่างไร? (ผู้ใช้หลายหน้าจอไม่ได้ใช้หน้าจอหลักเสมอไปและไม่ใช่ว่าทุกหน้าจอจะใช้ความละเอียดเดียวกันใช่ไหม)
จะเป็นการดีที่สามารถรับขนาดจาก XAML ได้ แต่การทำเช่นนั้นจากรหัส (C #) ก็เพียงพอแล้ว
คำตอบ:
เท่าที่ฉันรู้ไม่มีฟังก์ชัน WPF ดั้งเดิมที่จะรับขนาดของจอภาพปัจจุบัน แต่คุณสามารถ PInvoke ฟังก์ชันจอภาพแบบเนทีฟหลายจอให้รวมไว้ในคลาสที่มีการจัดการและแสดงคุณสมบัติทั้งหมดที่คุณต้องการใช้จาก XAML
ฉันสร้างกระดาษห่อเล็ก ๆ รอบ ๆ หน้าจอจาก System.Windows.Forms ตอนนี้ทุกอย่างใช้งานได้ ... ไม่แน่ใจเกี่ยวกับ "พิกเซลอิสระของอุปกรณ์"
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; }
}
}
ที่นี่ตา สิ่งนี้จะให้ความกว้างและความสูงของพื้นที่ทำงานเท่านั้น
System.Windows.SystemParameters.WorkArea.Width
System.Windows.SystemParameters.WorkArea.Height
ซึ่งจะให้หน้าจอปัจจุบันตามด้านซ้ายบนของหน้าต่างเพียงแค่เรียกสิ่งนี้ CurrentScreen () เพื่อดูข้อมูลบนหน้าจอปัจจุบัน
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));
}
}
}
ฉันต้องการขนาดหน้าจอปัจจุบันโดยเฉพาะพื้นที่ทำงานซึ่งส่งคืนสี่เหลี่ยมผืนผ้าไม่รวมความกว้างของแถบงาน
ฉันใช้มันเพื่อเปลี่ยนตำแหน่งหน้าต่างซึ่งเปิดไปทางขวาและลงไปที่ตำแหน่งของเมาส์ เนื่องจากหน้าต่างมีขนาดค่อนข้างใหญ่ในหลาย ๆ กรณีจึงหลุดออกจากขอบเขตหน้าจอ รหัสต่อไปนี้อ้างอิงจากคำตอบของ @ej: นี่จะให้หน้าจอปัจจุบัน ...... ความแตกต่างคือฉันยังแสดงอัลกอริทึมการเปลี่ยนตำแหน่งของฉันซึ่งฉันคิดว่าเป็นประเด็นจริง
รหัส:
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;
}
}
}
คำอธิบายบางส่วน:
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>ใช้เวลาในการสแกนผ่านสมาชิก SystemParameters
VirtualScreenWidthVirtualScreenHeightสิ่งเหล่านี้ยังคำนึงถึงตำแหน่งสัมพัทธ์ของหน้าจอด้วย
ทดสอบกับจอภาพสองจอเท่านั้น
ทำไมไม่ใช้แค่นี้?
var interopHelper = new WindowInteropHelper(System.Windows.Application.Current.MainWindow);
var activeScreen = Screen.FromHandle(interopHelper.Handle);
System.Windows.Forms.Screenเพื่อรับมือกับพิกเซลอิสระของอุปกรณ์
หากคุณคุ้นเคยกับการใช้คลาสSystem.Windows.Formsคุณสามารถเพิ่มการอ้างอิงได้ของคลาส System.Windows.Forms ในโครงการของคุณ:
โซลูชัน Explorer -> การอ้างอิง -> เพิ่มการอ้างอิง ... -> (แอสเซมบลี: กรอบงาน) -> เลื่อนลงและตรวจสอบแอสเซมบลีSystem.Windows.Forms -> ตกลงตกลง
ตอนนี้คุณสามารถเพิ่มโดยใช้ System.Windows.Forms; คำสั่งและใช้หน้าจอในโครงการ wpf ของคุณเหมือนเมื่อก่อน
ฉันเข้าใจความต้องการ สิ่งนี้คือมีวิธี WPF ในการรับค่าเหล่านั้น แต่ใช่หนึ่งในผู้ร่วมให้ข้อมูลถูกต้องไม่ใช่โดยตรง วิธีแก้ปัญหาไม่ใช่การแก้ปัญหาเหล่านั้นทั้งหมด แต่เป็นการเปลี่ยนแนวทางเริ่มต้นตามการออกแบบและพัฒนาที่สะอาด
A) ตั้งค่าหน้าต่างหลักเริ่มต้นเป็นหน้าจอ
B) รับค่าสำหรับ ActualWindow รวมถึงวิธี WPF ที่มีประโยชน์มากมาย
C) คุณสามารถเพิ่ม Windows ได้มากเท่าที่คุณต้องการสำหรับพฤติกรรมที่คุณต้องการเช่นปรับขนาดได้ย่อเล็กสุด ... แต่ตอนนี้คุณสามารถเข้าถึงหน้าจอที่โหลดและแสดงผลได้ตลอดเวลา
โปรดใช้ความระมัดระวังกับตัวอย่างต่อไปนี้มี Code บางอย่างที่ทำให้จำเป็นต้องใช้วิธีการแบบนั้นอย่างไรก็ตามควรใช้งานได้ (จะให้คะแนนสำหรับแต่ละมุมของหน้าจอของคุณ): ตัวอย่างการทำงานใน Single, จอภาพคู่และความละเอียดที่แตกต่างกัน (ภายในคลาสหน้าต่างหลักเบื้องต้น):
InitializeComponent();
[…]
ActualWindow.AddHandler(Window.LoadedEvent, new RoutedEventHandler(StartUpScreenLoaded));
เหตุการณ์ที่กำหนดเส้นทาง:
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);
}
หากคุณใช้หน้าต่างแบบเต็มหน้าจอ (มีWindowState = WindowState.Maximized, WindowStyle = WindowStyle.None) คุณสามารถรวมเนื้อหาในSystem.Windows.Controls.Canvasลักษณะนี้:
<Canvas Name="MyCanvas" Width="auto" Height="auto">
...
</Canvas>
จากนั้นคุณสามารถใช้MyCanvas.ActualWidthและMyCanvas.ActualHeightรับความละเอียดของหน้าจอปัจจุบันโดยคำนึงถึงการตั้งค่า DPI และในหน่วยอิสระของอุปกรณ์ มันไม่ได้เพิ่มระยะขอบใด ๆ เช่นเดียวกับหน้าต่างที่ขยายใหญ่สุดเอง
(Canvas ยอมรับUIElementว่าเป็นเด็กดังนั้นคุณควรใช้กับเนื้อหาใดก็ได้)
Center Window บนหน้าจอใน XAML WindowStartupLocation="CenterOwner"จากนั้นเรียกเข้า WindowLoaded ()
double ScreenHeight = 2 * (Top + 0.5 * Height);
double screenWidth = System.Windows.SystemParameters.PrimaryScreenWidth;
double screenhight= System.Windows.SystemParameters.PrimaryScreenHeight;
มันใช้ได้กับ
this.Width = System.Windows.SystemParameters.VirtualScreenWidth;
this.Height = System.Windows.SystemParameters.VirtualScreenHeight;
ทดสอบกับ 2 จอภาพ
VirtualScreenทุกประการคุณจะเห็นว่าครอบคลุมทุกหน้าจอดังนั้นสิ่งนี้จะไม่ได้ผลหากคุณมีมากกว่าหนึ่งหน้าจอ!