c# Comment obtenir les événements lorsque l'écran/affichage passe à l'appareil HORS tension ou SUR?

Ont un coup d'oeil à ce blog ici qui vous aidera à réaliser ce que vous essayez d'atteindre. En outre vous avez besoin de faire un événement personnalisé de le faire pour vous quelque chose comme ceci:

public enum PowerMgmt{
StandBy,
Off,
On
};
public class ScreenPowerMgmtEventArgs{
private PowerMgmt _PowerStatus;
public ScreenPowerMgmtEventArgs(PowerMgmt powerStat){
this._PowerStatus = powerStat;
}
public PowerMgmt PowerStatus{
get{ return this._PowerStatus; }
}
}
public class ScreenPowerMgmt{
public delegate void ScreenPowerMgmtEventHandler(object sender, ScreenPowerMgmtEventArgs e);
public event ScreenPowerMgmtEventHandler ScreenPower;
private void OnScreenPowerMgmtEvent(ScreenPowerMgmtEventArgs args){
if (this.ScreenPower != null) this.ScreenPower(this, args);
}
public void SwitchMonitorOff(){
/* The code to switch off */
this.OnScreenPowerMgmtEvent(new ScreenPowerMgmtEventArgs(PowerMgmt.Off));
}
public void SwitchMonitorOn(){
/* The code to switch on */
this.OnScreenPowerMgmtEvent(new ScreenPowerMgmtEventArgs(PowerMgmt.On));
}
public void SwitchMonitorStandby(){
/* The code to switch standby */
this.OnScreenPowerMgmtEvent(new ScreenPowerMgmtEventArgs(PowerMgmt.StandBy));
}
}

Edit: Comme Manu n'était pas sûr de la façon de récupérer les événements, cette édition comprendra un exemple de code sur comment utiliser cette classe, comme indiqué ci-dessous.

Using System;
Using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Runtime.Interop;
using System.Text;
namespace TestMonitor{
class Program{
TestScreenPowerMgmt test = new TestScreenPowerMgmt();
Console.WriteLine("Press a key to continue...");
Console.ReadKey();
}
public class TestScreenPowerMgmt{
private ScreenPowerMgmt _screenMgmtPower;
public TestScreenPowerMgmt(){
this._screenMgmtPower = new ScreenPowerMgmt;
this._screenMgmtPower.ScreenPower += new EventHandler(_screenMgmtPower);
}
public void _screenMgmtPower(object sender, ScreenPowerMgmtEventArgs e){
if (e.PowerStatus == PowerMgmt.StandBy) Console.WriteLine("StandBy Event!");
if (e.PowerStatus == PowerMgmt.Off) Console.WriteLine("Off Event!");
if (e.PowerStatus == PowerMgmt.On) Console.WriteLine("On Event!");
}
}
}

Après avoir regardé ce code, et se rendre compte que quelque chose n'allait pas, il m'est apparu que Manu était à la recherche d'un moyen d'interroger le système pour détecter le Moniteur d'état de l'alimentation qui n'est pas disponible, mais, le code indique que la programmation, le moniteur peut être allumé/éteint/veille, dans le même temps, le déclenchement de l'événement, mais il voulait qu'elle soit en mesure de crochet dans le WndProc d'un formulaire et de traiter le message indiquant l'état de la Surveiller...maintenant, à ce stade, je vais exprimer mon opinion sur ce point.

Je ne suis pas sûr à 100% si cela peut être fait ou est-ce que Windows fait d'envoyer un message de diffusion en disant quelque chose comme " Hé! Le moniteur est d'aller dormir " ou " Hey! Le moniteur est mise sous tension', j'ai peur de dire, que les Moniteurs ne pas envoyer certains logiciels de signal de Windows pour informer c'est d'aller dormir/off/on. Maintenant si quelqu'un a des suggestions, des conseils, des indices à ce sujet, n'hésitez pas à poster votre commentaire...

Energy Star logiciel dans le cadre de l'onglet écran de veille que l'on trouve lorsque vous faites un clic droit sur le bureau, n'importe où, un menu pop-up apparaît, cliquez à gauche sur "Propriétés", un "Affichage de la boîte de dialogue s'affiche, avec les différentes pages d'onglet de gauche, cliquez sur "Économiseur d'écran", Cliquez sur le bouton "Alimentation du Moniteur" groupement de la boîte, la partie de la boîte de dialogue, en quelque sorte déclenche le sous-système Windows (carte graphique?/Energy Star pilote?) pour envoyer un signal matériel pour passer sur les économies d'énergie, la fonctionnalité de l'écran lui-même...(les Moniteurs sont neufs, n'ont pas cette activé par défaut, autant que je sache...hésitez pas à faire disparaître cette notion...)

Moins qu'il y a un sans-papiers de l'API quelque part embarqués et enfouis dans les profondeurs de l'Énergie-Puissance pilote logiciel (une API est certainement en effet déclenché comment, en cliquant sur le bouton envoyer ce signal à l'écran dans lequel le mode d'Alimentation, en effet, activés par la suite!) alors, peut-être, par l'exécution d'un thread en arrière-plan de ce formulaire de demande, les bureaux de vote pour interroger encore inconnu de fonctionnalités, ou une API pour vérifier l'état de l'alimentation: il doit y avoir quelque chose là-bas que seul Microsoft sait...après tout, Energy Star, Microsoft a montré comment déclencher le mode d'économie d'énergie sur le Moniteur lui-même, ce n'est sûrement pas une rue à sens unique? ou est-il?

Désolé Manu, si je ne pouvais pas aider les autres .... 🙁

Edit #2: j'ai pensé à ce que j'ai écrit plus tôt dans l'édition et fait un peu de creuser autour d'enracinement pour une réponse et je crois que j'ai la réponse, mais d'abord, une pensée surgit dans ma tête, voir ce document ici - un document pdf à partir d' 'terranovum.com', l'indice (ou alors j'ai pensé...) était dans le registre, en utilisant les deux dernières clés de registre sur la dernière page de ce document contient l'offset spécifié dans le nombre de secondes, et en conjonction avec ce CodeProject l'article, à savoir le temps d'inactivité, il serait facile de déterminer quand le moniteur passe en mode d'attente, les sons simples ou alors j'ai pensé, Manu ne voudrais pas que l'idée soit....

Complément d'enquête avec google m'amènent à cette conclusion, la réponse se trouve dans le prolongement de la VESA BIOS spécification DPMS (Display Power Management de Signalisation), maintenant la question que se posent de ce, est de savoir comment vous interroger que la signalisation sur le VESA bios, maintenant, beaucoup de cartes graphiques modernes ont que VESA Bios monté en elle, donc il doit y avoir un port matériel quelque part où vous pouvez lire les valeurs des pins, à l'aide de cette route exigerait l'utilisation de InpOut32 ou si vous avez 64 bits de Windows, il y a un InpOut64 via pinvoke. Fondamentalement, si vous pouvez rappeler à l'aide de Turbo C ou Turbo Pascal (à la fois sur 16 bits pour le DOS), il y a une routine appelée port d'entrée/port ou similaire à lire le port matériel, ou même GWBASIC à l'aide de peek/poke. Si l'adresse du port matériel peut être trouvé, alors les valeurs peuvent être interrogés afin de déterminer si le Moniteur est en mode veille/éteint/suspendu/sur par vérification de la Synchronisation Horizontale et Verticale de la Synchronisation, je pense que c'est le plus fiable solution...

Excuses pour cette longue réponse, mais j'ai senti que je devais écrire mes pensées....

Il y a encore de l'espoir, il y a Manu 🙂 😉

OriginalL'auteur t0mm13b

Cela fonctionne pour moi, même MainWindow est caché. Le code est basé sur le post ci-dessus, et le code C++ de https://www.codeproject.com/Articles/1193099/Determining-the-Monitors-On-Off-sleep-Status.

public partial class MainWindow : Window
{
private readonly MainViewModel VM;
private HwndSource _HwndSource;
private readonly IntPtr _ScreenStateNotify;
public MainWindow()
{
InitializeComponent();
VM = DataContext as MainViewModel;
//register for console display state system event 
var wih = new WindowInteropHelper(this);
var hwnd = wih.EnsureHandle();
_ScreenStateNotify = NativeMethods.RegisterPowerSettingNotification(hwnd, ref NativeMethods.GUID_CONSOLE_DISPLAY_STATE, NativeMethods.DEVICE_NOTIFY_WINDOW_HANDLE);
_HwndSource = HwndSource.FromHwnd(hwnd);
_HwndSource.AddHook(HwndHook);
}
private IntPtr HwndHook(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
{
//handler of console display state system event 
if (msg == NativeMethods.WM_POWERBROADCAST)
{
if (wParam.ToInt32() == NativeMethods.PBT_POWERSETTINGCHANGE)
{
var s = (NativeMethods.POWERBROADCAST_SETTING) Marshal.PtrToStructure(lParam, typeof(NativeMethods.POWERBROADCAST_SETTING));
if (s.PowerSetting == NativeMethods.GUID_CONSOLE_DISPLAY_STATE)
{
VM?.ConsoleDisplayStateChanged(s.Data);
}
}
}
return IntPtr.Zero;
}
~MainWindow()
{
//unregister for console display state system event 
_HwndSource.RemoveHook(HwndHook);
NativeMethods.UnregisterPowerSettingNotification(_ScreenStateNotify);
}
}

Et des méthodes Indigènes ici:

internal static class NativeMethods
{
public static Guid GUID_CONSOLE_DISPLAY_STATE = new Guid(0x6fe69556, 0x704a, 0x47a0, 0x8f, 0x24, 0xc2, 0x8d, 0x93, 0x6f, 0xda, 0x47);
public const int DEVICE_NOTIFY_WINDOW_HANDLE = 0x00000000;
public const int WM_POWERBROADCAST = 0x0218;
public const int PBT_POWERSETTINGCHANGE = 0x8013;
[StructLayout(LayoutKind.Sequential, Pack = 4)]
public struct POWERBROADCAST_SETTING
{
public Guid PowerSetting;
public uint DataLength;
public byte Data;
}
[DllImport(@"User32", SetLastError = true, EntryPoint = "RegisterPowerSettingNotification", CallingConvention = CallingConvention.StdCall)]
public static extern IntPtr RegisterPowerSettingNotification(IntPtr hRecipient, ref Guid PowerSettingGuid, Int32 Flags);
[DllImport(@"User32", SetLastError = true, EntryPoint = "UnregisterPowerSettingNotification", CallingConvention = CallingConvention.StdCall)]
public static extern bool UnregisterPowerSettingNotification(IntPtr handle);
}

OriginalL'auteur PetrCZ