Windows Azure Cloud Storage ermöglicht es Ihnen bereits ab 0,10€ pro GB/Monat die Vorteile der Cloud zu nutzen.
Willkommen bei dotnet-snippets.de! Snippet hinzufügen Login Registrieren
Snippets in der Datenbank: 1549 | Anzahl registrierter User: 1833 | Besucher online: 68
Hauptmenü
Home
Top Ten
Zufälliger Snippet
FAQs
.NET Community
dotnet-forum.de
dotnet-kicks.de
Social

RSS Feeds
Rss Alle Snippets
Rss C#
Rss VB.NET
Rss C++
Rss ASP.NET
Partner
Member of Microsoft Community Leader/Insider Program (CLIP)

Fenster Flashing


Autor: BlackDragon
Sprache: C#
Bewertung: 8,2
(1 Bewertung)
Anzahl der Aufrufe: 4084
  
Kick it on dotnet-kicks.de  

Beschreibung:

Mithilfe dieser Klasse, können Sie Ihr eigenes Fenster + den Button in der Taskleiste, in einem Periodischen Zeitinterval, aufblinken lassen.
Zusätzlich können Sie sich auch noch, an ein Event dranhängen und noch etwas eigenes dazu zu Programmieren

Beispiels weise bei einer längeren Aktion in der der User sogar das Fenster minimieren könnte.

Dieses blinken in der Taskleite könnte die Aufmerksamkeit des User wieder auf das Programm lenken.



Abgelegt unter: Flashing, blinken, Userbenachrichtigung, Flash.



C#
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
#region Using
using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Runtime.InteropServices; 
#endregion

namespace Toolset {
    #region Beschreibung
    /// <summary>
    /// Mithilfe dieser Klasse, können Sie Ihr eigenes Fenster + den Button in der Taskleiste, in einem Periodischen 
    /// Zeitinterval, aufblinken lassen.
    /// Zusätzlich können Sie sich auch noch, an ein Event dranhängen und noch etwas eigenes dazu zu Programmieren
    /// </summary>
    /// <example>
    /// <code lang="C#">
    /// private Toolset.WindowFlasher flasher
    /// //Innerhalb einer Form Klassem zb weil eine längere Arbeitsphase abgeschlossen ist und das Fenster 
    /// //in der Zwischenzeit minimiert wurde
    /// private void StartWindowFlasher(){
    ///     flasher = new Toolset.WindowFlasher(this, 1000);
    ///     flasher.StartFlashing();
    ///     this.Activated += new System.EventHandler(this.Form1_Activated);
    /// }
    /// private void Form1_Activated(object sender, EventArgs e) {
    ///     if (flasher != null && flasher.IsActive) {
    ///         flasher.StopFlashing();
    ///         this.Activated -= this.Form1_Activated;
    ///     }
    /// }
    /// </code>
    /// </example> 
    #endregion
    public class WindowFlasher {
        #region Event
        /// <summary>
        /// Stellt den Typ der Methode dar, die das Ereigniss behandelt.
        /// </summary>
        public delegate void WindowFlashHandler(Object sender, EventArgs ea);
        /// <summary>
        /// Tritt bei jedem Tick auf.
        /// </summary>
        public event WindowFlashHandler WindowFlashed; 
        #endregion

        #region Private Felder
        private Timer timer;
        private Boolean isActive; 
        #endregion

        #region Property
        /// <summary>
        /// Gibt an ob der Timer läuft oder ob er bereits gestoppt wurde.
        /// </summary>
        public Boolean IsActive {
            get {
                return isActive;
            }
        } 
        #endregion

        #region DllImport
        [DllImport("user32.dll")]
        static extern long FlashWindow(IntPtr hwnd, long invert); 
        #endregion

        #region konstruktor
        /// <summary>
        /// Initialisiert eine neue Instanz der MultiClipboard Klasse.
        /// </summary>
        /// <param name="window">die jeweilige Form die Blicken soll</param>
        /// <param name="intervalInMs">ein Interval in ms, in welchen abstand die Form Blincken soll</param>
        public WindowFlasher(Form window, int intervalInMs) {
            IntPtr windowHwnd = window.Handle;
            timer = new Timer();
            timer.Interval = intervalInMs;
            timer.Tick += new EventHandler(delegate(Object sender, EventArgs e) { long l = FlashWindow(windowHwnd, 1); if (WindowFlashed != null) WindowFlashed(window, new EventArgs()); });
        } 
        #endregion

        #region Destruktor
        /// <summary>
        /// aufräumen
        /// </summary>
        ~WindowFlasher() {
            WindowFlashed = null;
            this.StopFlashing();
            timer = null;
        }
        #endregion

        #region Methoden
        /// <summary>
        /// Startet den Flasher Vorgang
        /// </summary>
        public void StartFlashing() {
            if (!isActive) {
                timer.Start();
                isActive = true;
            }
        }

        /// <summary>
        /// Stoppt den Flasher vorgang
        /// </summary>
        public void StopFlashing() {
            if (isActive) {
                isActive = false;
                timer.Stop();
            }
        } 
        #endregion
    }
}
Sie haben Fragen zu diesem Snippet oder brauchen Hilfe bei der .NET Entwicklung?
Freundliche und kompetente Entwickler helfen Ihnen gern weiter im Forum für .NET Entwicklung.



Kommentare:
(Zum Schreiben von Kommentaren bitte anmelden.)

Silerra schrieb am:  06.09.2010 22:26:40

Cooles Code und für meinem Bereich irgendwie wichtig. Jedoch kommt eine Meldung PInokeStackImbalance wenn ich das Code zum Einsatz bringe.


Diese Snippets könnten für Sie interessant sein:
Keine Snippets verfügbar.

schlecht sehr gut
1 2 3 4 5 6 7 8 9 10
Nur angemeldete User können Snippets bewerten.