Bildschirm verdunkeln in C#

Gibt es eine Möglichkeit den Bildschirm einzufrieren?

So wie beim Windows XP wenn man auf:

Start-->Beenden-->"Der Bildschirm wird langsam grau"

oder wie beim Vista wenn man eine *.exe startet und die Benutzerkontensteuerung kommt

Hat jemand eine Idee?

Mach in dem Moment ein Screenshot des Desktops und "verdunkle" dann diesen.

Beim Herunterfahren von XP wird es genauso gemacht. Halt nur als Fade-Effekt. Bei Vista ist das ebenfalls so.

Ein direkter API Aufruf ist mir nicht bekannt.

Hi,

Wenn es dir nur um das Verdunkeln geht und nicht um das Einfrieren des Hintergrunds, wäre es auch möglich, eine Form (borderstyle = none) mit BackColor=Black über den Bildschirm zu legen und (für den Fade - Effekt mit einem Timer) die Opacity Eigenschaft zu verändern.

mfg dechavue

Edit: tja die Rechtschreibung

Original von dechavue
Hi,

Wenn es dir nur um das Verdunkeln geht und nicht um das Einfrieren des Hintergrunds, wäre es auch möglich, eine Form (borderstyle = none) mit BackColor=Black über den Bildschirm zu legen und (für den Fade - Effekt mit einem Timer) die Opacity Eigenschaft zu verändern.

mfg dechavue

Edit: tja die Rechtschreibung

Ich glaub mit einfrieren meint er eher dass man nichts drauf anklicken kann was in diesem Falle sowieso gewährleistet wäre weil man ja durch die Form nix klicken kann 😉
Er müsste dann halt nur schauen das der Focus auf der Mainform bleibt dann hat er ihn schon eingefroren 😉

Also aus meinen VB Zeiten kann ich mich errinern das man mit einer API den Focus eines Fensters setzen kann (wenn nich auch ohne API) - müsste in C# eig. auch gehen 😉

api

Original von apid0x
Also aus meinen VB Zeiten kann ich mich errinern das man mit einer API den Focus eines Fensters setzen kann (wenn nich auch ohne API) - müsste in C# eig. auch gehen 😉

Setzt doch einfach Form.TopMost auf true

Original von dechavue
Hi,

Wenn es dir nur um das Verdunkeln geht und nicht um das Einfrieren des Hintergrunds, wäre es auch möglich, eine Form (borderstyle = none) mit BackColor=Black über den Bildschirm zu legen und (für den Fade - Effekt mit einem Timer) die Opacity Eigenschaft zu verändern.

mfg dechavue

Edit: tja die Rechtschreibung

Das macht aber das gesamte Form mit allen seiner Controls durchsichtig, oder?

Er will doch sicher das ein oder andere Control auf dem Form haben, welches dann nicht durchsichtig werden soll, oder?

Ich denke er meinte das als extra Form. Also das hinter der eigentlichen Form nochmal eine ist, die alles abdeckt.

Genau so habe ich es gemeint
(also die abdunkelungsform Topmost dazu die Hauptform mit owner = TransparentForm)

Ich habs bei meinem aktuellen Projekt sogar 3 - Lagig (Die abgedunkelte mit Löcher über transparencykey - farbige panels, eine mit 1% opacity zum verhindern des klickens durch dieses Loch und die eigentliche in die ich zeichne

Auch ne gute Idee. 👍

Mir fällte gerade auf, dass der Windows-Dialog den ganymedes meinte ja nicht nur abdunkelt, sondern die Farben 'ausgraut'.

Das geht aber nur mit Hilfe eines Screenshots, oder?

Hi.

Das Thema hat mich irgendwie gepackt und ich habe mal etwas zusammengestrickt.

Eine Basisklasse:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

using System.Drawing.Imaging;

namespace ShadowScreenTest
{
    public abstract class DialogShadowTopForm : Form
    {
        #region --- Fields ---
        Timer _shadowTimer = new Timer();
        Form _shadowForm = new Form();

        bool _formMoveable = false;
        ShadowMode _activeShadowMode = ShadowMode.GreyOut;
        Color _greyOutModeBaseColor = Color.Black;
        int _timerInitWait = 2000;
        int _timerInterval = 10;
        int _timerIntervalSlowDownByOpacityFactor = 150;
        Single _opacityStep = 0.05f;
        Single _opacityMax = 0.7f;
        #endregion

        #region --- Public properties ---
        public bool FormMoveable
        {
            get { return _formMoveable; }
            set { _formMoveable = value; }
        }

        public ShadowMode ActiveShadowMode
        {
            get { return _activeShadowMode; }
            set { _activeShadowMode = value; }
        }

        public Color GreyOutModeBaseColor
        {
            get { return _greyOutModeBaseColor; }
            set { _greyOutModeBaseColor = value; }
        }

        public int TimerInitWait
        {
            get { return _timerInitWait; }
            set
            {
                if (value < 0)
                    _timerInitWait = 0;
                else
                    _timerInitWait = value;
            }
        }

        public int TimerInterval
        {
            get { return _timerInterval; }
            set
            {
                if (value < 0)
                    _timerInterval = 0;
                else
                    _timerInterval = value;
            }
        }

        public int TimerIntervalSlowDownByOpacityFactor
        {
            get { return _timerIntervalSlowDownByOpacityFactor; }
            set
            {
                if (value < 0)
                    _timerIntervalSlowDownByOpacityFactor = 0;
                else
                    _timerIntervalSlowDownByOpacityFactor = value;
            }
        }

        public Single OpacityStep
        {
            get { return _opacityStep; }
            set
            {
                if (value < 0)
                    _opacityStep = 0.01f;
                else
                    if (value > 1)
                        _opacityStep = 1.0f;
                    else
                        _opacityStep = value;
            }
        }

        public Single OpacityMax
        {
            get { return _opacityMax; }
            set
            {
                if (value < 0)
                    _opacityMax = 0;
                else
                    if (value > 1)
                        _opacityMax = 1.0f;
                    else
                        _opacityMax = value;
            }
        }
        #endregion

        #region --- Private methods ---
        private Image GrayScaleImage(Image image)
        {
            ImageAttributes imageAttributes = new ImageAttributes();

            Single[][] colorMatrixAttributes;

            // Greyscale
            colorMatrixAttributes = new Single[][]
            {
                new Single[] { 0.299f, 0.299f, 0.299f, 0, 0 },
                new Single[] { 0.587f, 0.587f, 0.587f, 0, 0 },
                new Single[] { 0.114f, 0.114f, 0.114f, 0, 0 },
                new Single[] { 0, 0, 0, 1, 0 },
                new Single[] { 0, 0, 0, 0, 1 }
            };

            ColorMatrix colorMatrix = new ColorMatrix(colorMatrixAttributes);

            imageAttributes.SetColorMatrix(colorMatrix);

            Bitmap bitmap = new Bitmap(image.Width, image.Height, PixelFormat.Format32bppArgb);

            bitmap.SetResolution(image.HorizontalResolution, image.VerticalResolution);

            Graphics graphics = Graphics.FromImage(bitmap);

            graphics.DrawImage(image, new Rectangle(0, 0, bitmap.Width, bitmap.Height), 0, 0, image.Width, image.Height, GraphicsUnit.Pixel, imageAttributes);

            graphics.Dispose();
            imageAttributes.Dispose();

            return bitmap;
        }
        #endregion

        #region --- Protected methods ---
        // Make the form unmoveable.
        protected override void WndProc(ref Message m)
        {
            const int WM_NCHITTEST = 0x84;
            const int HTCAPTION = 0x02;
            const int HTCLIENT = 0x01;

            base.WndProc(ref m);

            if (FormMoveable) return;

            if (m.Msg == WM_NCHITTEST && (int)m.Result == HTCAPTION)
            {
                m.Result = (IntPtr)HTCLIENT;
            }
        }
        #endregion

        #region --- Public methods ---
        public void ShowShadow()
        {
            switch (ActiveShadowMode)
            {
                case ShadowMode.GreyOut:
                    {
                        Bitmap bitmap = new Bitmap(Screen.PrimaryScreen.Bounds.Width, Screen.PrimaryScreen.Bounds.Height, PixelFormat.Format32bppArgb);
                        using (Graphics graphics = Graphics.FromImage(bitmap))
                        {
                            graphics.CopyFromScreen(Screen.PrimaryScreen.Bounds.X, Screen.PrimaryScreen.Bounds.Y, 0, 0, Screen.PrimaryScreen.Bounds.Size);
                        }
                        _shadowForm.BackgroundImage = GrayScaleImage((Image)bitmap);
                        break;
                    }
                case ShadowMode.Darken:
                    _shadowForm.BackColor = GreyOutModeBaseColor;
                    break;
            }

            _shadowForm.TopMost = true;
            _shadowForm.WindowState = FormWindowState.Maximized;
            _shadowForm.FormBorderStyle = FormBorderStyle.None;
            _shadowForm.Opacity = 0;

            this.Owner = _shadowForm;
            this.TopMost = true;

            _shadowForm.Show();

            _shadowTimer.Interval = TimerInitWait;
            _shadowTimer.Tick += new EventHandler(shadowTimer_Tick);
            _shadowTimer.Enabled = true;
        }
        #endregion

        #region --- Event handlers ---
        private void shadowTimer_Tick(object sender, EventArgs e)
        {
            _shadowTimer.Interval = TimerInterval + (int)(_shadowForm.Opacity * TimerIntervalSlowDownByOpacityFactor);

            _shadowForm.Opacity += OpacityStep;

            if (_shadowForm.Opacity >= OpacityMax)
                _shadowTimer.Enabled = false;
        }
        #endregion

        #region --- Enumerators ---
        public enum ShadowMode : int
        {
            Darken,
            GreyOut
        }
        #endregion
    }
}

und verwendet werden kann es mittels Ableitung eines Forms von der Klasse so:

.
.
.
    public partial class DialogShadowTopFormTest : DialogShadowTopForm
    {
        .
        .
        .
        private void DialogShadowTopFormTest_Load(object sender, EventArgs e)
        {
            FormMoveable = false;
            FormBorderStyle = FormBorderStyle.FixedToolWindow;

            ActiveShadowMode = ShadowMode.GreyOut;
            GreyOutModeBaseColor = Color.Black;
            TimerInitWait = 2000;
            TimerInterval = 10;
            TimerIntervalSlowDownByOpacityFactor = 150;
            OpacityStep = 0.05f;
            OpacityMax = 0.7f;

            ShowShadow();
        }
        .
        .
        .
    }
.
.
.

Gibt's von eurer Seite evtl. technische Umsetzungsverbesserungen?
Man lernt ja gerne nie aus. 😉

Gruß,
AtzeX

Hi,

gefällt mir sehr gut.

Eine Kleinigkeit die mir aufgefallen ist, dass dein Code bei Multiscreen - Systemen nur den aktuellen Monitor ausgraut / abdunkelt.

Ich habe mir erlaubt den Konstruktor so zu verändern, dass es auch bei mehreren Monitoren Funktioniert:

        public void ShowShadow ( ) {

            _shadowForm.TopMost = true;
            
            _shadowForm.FormBorderStyle = FormBorderStyle.None;
            _shadowForm.Opacity = 0;

            this.Owner = _shadowForm;
            this.TopMost = true;

            _shadowForm.Show ( );

// ////////////////////////////////////////////////////////////////////////
            _shadowForm.Location = Screen.GetBounds ( new Rectangle ( int.MinValue / 2, int.MaxValue / 2, int.MaxValue, int.MaxValue ) ).Location;
            _shadowForm.Size = new Size ( int.MaxValue, int.MaxValue );

// ////////////////////////////////////////////////////////////////////////
            
            switch ( ActiveShadowMode ) {
                case ShadowMode.GreyOut: {
                        Bitmap bitmap = new Bitmap ( _shadowForm.Width, _shadowForm.Height, PixelFormat.Format32bppArgb ); // ///
                        using ( Graphics graphics = Graphics.FromImage ( bitmap ) ) { 
                            graphics.CopyFromScreen ( _shadowForm.Location, new Point (0,0) , _shadowForm.Size );          // ///
                        }
                        _shadowForm.BackgroundImage = GrayScaleImage ( (Image)bitmap );
                        break;
                    }
                case ShadowMode.Darken:
                    _shadowForm.BackColor = GreyOutModeBaseColor;
                    break;
            }

            _shadowTimer.Interval = TimerInitWait;
            _shadowTimer.Tick += new EventHandler ( shadowTimer_Tick );
            _shadowTimer.Enabled = true;
        }

Aber gerne doch. Habe ich mit meinem einen Screen gar nicht drüber nachgedacht. 😉

Gruß,
AtzeX

Ich bringe es nochmal hoch, um die Herren mit deutlich mehr Erfahrung als ich sie vorzuweisen habe zu fragen, ob es an der technischen Umsetzung bzw. dem technischen Style etwas zu verbessern gibt?

Ich erweitere meinen Horizont gerne und bin offen für Kritik. 😉

Gruß,
AtzeX

P.S.:
Macht es Sinn, das in die "C#-Snippets" zu bringen?

@dechavue:
Ich habe meine Klasse mal bei dotnet-snippets.de veröffentlicht.

Hast du was dagegen, wenn ich deine Änderungen bzgl. des Mehrschirm-Aspekts mit aufnehme?
Momentan habe ich ihn rausgelassen.

Kein Problem, kannst du gerne dazunehmen

Ich veröffentliche diese GERNE auch hier.
Hatte ich ja weiter oben schon angefragt, nur dass ich dachte es wäre nicht von Interesse, da ja diesbezüglich kein Feedback kam.
😉

Mach' ich dann heute noch.

Gruß,
AtzeX