Preventing TV / Monitor burn in, in a WPF program

Question

I've recently finished a WPF program for a client that will be on burn-in prone TVs at least 12 (Maybe even 16+) hours a day. Problem is, the data is near static (Some text changes every few hours, but for the most part it's static). Another issue is that the design is very specific and needs to stay that way - so I can't move the elements around randomly. I also can't do anything dramatic like have something bouncing around the screen as the screens will show important information.

So, I'm struggling to find a way to prevent burn in. What's a good way to prevent this? Preferably in WPF. The client and I have come up with the possible solution of having an AHK script trigger the screen saver every hour, but that seems really hacky.

Answer 1

Why not just build a storyboard in blend that slowly, over the course of say 30 minutes, changes the color scheme to something else that doesn't clash then changes it back again?

Answer 2

Could you use something like a vertical "Refresh Bar" that sweep across the screen periodically, drawn in exclusive-or mode over the status text and boxes?

By a "XOR mode refersh bar" I mean something like this, that crawls across the screen every few minutes in the direction of the arrow shown:

Answer 3

Doing a quick google search I found this and it may be useful.

CRTs and Older plasma TVs were quite susceptible to burn-in, but many modern TVs have features designed to lower the risk. Many contain a feature called "pixel shifting," for example, that shifts the image on your screen just enough so that the pixels are regularly changing, (but not so much that it's noticeable to you). Some cheaper plasmas may be more susceptible, so this is an area where you get what you pay for.

With that said, perhaps you can emulate the same effect with your program. You could shift the whole view a few pixels left or right and through out the day have them shift back. Could be easier than said as I have no actual WPF experience but I thought this was a neat idea.

Reference: http://lifehacker.com/5982108/is-burn-in-still-an-issue-on-tvs-and-monitors

Answer 4

New answer for a new approach. This is much simpler, and has animation:

<Grid x:Name="MyGrid">
    <Grid.Background>
        <SolidColorBrush x:Name="bg" Color="Red"/>
    </Grid.Background>
    <Grid.Triggers>
        <EventTrigger RoutedEvent="Window.Loaded">
            <BeginStoryboard>
                <Storyboard RepeatBehavior="Forever">
                    <ColorAnimation Storyboard.TargetName="bg"
                                    Storyboard.TargetProperty="Color" 
                                    From="Red" To="Blue" 
                                    Duration="0:0:10" BeginTime="0:0:0"/>
                    <ColorAnimation Storyboard.TargetName="bg"
                                    Storyboard.TargetProperty="Color" 
                                    From="Blue" To="Red" 
                                    Duration="0:0:10" BeginTime="0:0:10"/>
                </Storyboard>
            </BeginStoryboard>
        </EventTrigger>
    </Grid.Triggers>
</Grid>

Set the duration to 30 minutes. Naturally, this will cause the colour to be purple at times. I didn't think that was acceptable to your client, which is why I didn't suggest it initially.

If this is not acceptable, an option would be to fade the controls out before switching colours. (Add two more double animations for Opacity to the storyboard).

Answer 5

Here is an example that toggles the colour of the Grid every second using a DispatcherTimer:

public partial class MainWindow : Window, INotifyPropertyChanged
{
    private bool _isMainColour;

    public SolidColorBrush CurrentColour { get; set; }

    private DispatcherTimer _timer;

    public MainWindow()
    {
        InitializeComponent();
        DataContext = this;
        _timer = new DispatcherTimer();
        _timer.Interval = new TimeSpan(0, 0, 1);
        _timer.Tick += _timer_Tick;
        _timer.Start();
    }

    void _timer_Tick(object sender, EventArgs e)
    {
        if (_isMainColour)
        {
            CurrentColour = new SolidColorBrush(Colors.Blue);
        }
        else
        {
            CurrentColour = new SolidColorBrush(Colors.Red);
        }
        _isMainColour = !_isMainColour;
        if (PropertyChanged != null)
        {
            PropertyChanged(this, new PropertyChangedEventArgs("CurrentColour"));
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;
}

And the XAML:

<Window x:Class="WpfApplication4.MainWindow"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="MainWindow" Height="350" Width="525" Background="Black">
    <Grid Background="{Binding CurrentColour}">

    </Grid>
</Window>

Obviously, it needs better structuring, but it shows the basic principle.

Answer 6

I would say binding the colours to resources using DyanmicResource binding is a good start.

You can then implement a timer in your app.cs that when triggered updates the values:

this.Resource["PrimaryColour"] = Color.FromRgb(200, 200, 200);