Click here to Skip to main content
14,271,663 members

PVS.AVPlayer - Audio and Video Player Library

Rate this:
4.93 (157 votes)
Please Sign up or sign in to vote.
4.93 (157 votes)
14 Jun 2019CPOL
Microsoft Media Foundation (MF) based easy-to-use library with many added features

Version 0.96: Added .NET 4.8 library, fixed subtitles timeshift, added video color trackbar managers and others. For more information, please see the 'About PVS.AVPlayer versions.txt' download.

Library size: 192 KB
Platform: Microsoft Windows 7 or higher - WinForms Any CPU
Requirements: Microsoft .NET Framework 2.0 or higher
License: The Code Project Open License (CPOL)

PVS.AVPlayer has built in (part of) the Media Foundation .NET library by nowinskie and snarfle (https://sourceforge.net/projects/mfnet). Licensed under either Lesser General Public License v2.1 or BSD. See license.txt or BSDL.txt for details (http://mfnet.sourceforge.net).

PVS.AVPlayer (Media Foundation) plays these media formats: .3g2, .3gp, .3gp2, .3gpp, .aac, .adts, .asf, .avi, .m4a, .m4v, .mov, .mp3, .mp4, .sami, .smi, .wav, .wma and .wmv.

Version 0.96, Copyright © 2019 PVS The Netherlands

Image 1

Caption: PVS.AVPlayer sample application.

Introduction

PVS.AVPlayer is an easy-to-use media player library for playing media files in .NET Framework WinForms applications using Microsoft Media Foundation (MF), Media Foundation .NET and other technologies, with:

  • high quality audio and video
  • built-in audio and video codecs
  • display overlays, shapes and clones
  • multiple full screen display modes
  • video tracks info and selection
  • video preset and custom sizes
  • audio tracks info and selection
  • audio standard volume and balance control, or
  • audio up to 16 channels separate volume control
  • audio devices manager, info and selection
  • trackbar managers (position, audio and others)
  • media info (tags) with album art
  • media subtitles (srt)
  • and more

PVS.AVPlayer and the sample applications are compiled for Microsoft .NET Framework 3.5. Other versions of the library (with exactly the same functionality) are available for the .NET Framework 2.0 to 4.8 via the link at the top of this article. PVS.AVPlayer and the sample applications do not contain viruses, spyware, advertisements or other malware, do not collect information, do not change anything permanently on your computer and do not connect to the internet.

Please note that a VB.NET version of the article can be downloaded from the link at the top of this article.

Image 2

Image 3

PVS.AVPlayer "How To..." sample application.

Brief Instructions on How to Use PVS.AVPlayer

Contents

  1. Adding PVS.AVPlayer to your Application
  2. Check if Media Foundation is Installed
  3. Creating a Player
  4. Error Handling
  5. Player Events
  6. Player Display
  7. Full Screen Display
  8. Display Overlays
  9. Display Clones
  10. Playing a Media File
  11. Audio Settings
  12. Video Settings
  13. Trackbars
  14. From Here On...

Due to the large number of functions of the PVS.AVPlayer library, not all options can be described here. See the sample applications for more information.

This article assumes that you use Microsoft Visual Studio for software development.

1. Adding PVS.AVPlayer to your Application

You can add the PVS.AVPlayer library to your application by adding a reference to the library to the application project and rebuilding the application.

First download "PVS.AVPlayer.zip" via the link at the top of this article and extract the library (DLL) wherever you want on your hard drive. The .XML file contains information for IntelliSense from Visual Studio and is not needed with your finished application.

Next, open your application's project in Visual Studio (or create a new project) and add a reference to the library. You can do this by right-clicking on the project in solution explorer (or using the Project menu) and then select Add Reference: choose the Browse option and locate and select "PVS.AVPlayer.dll". Now you're ready to use PVS.AVPlayer.

Finally, to use shorter names in the Visual Studio Editor, type at the top of each project file that uses the library:

using PVS.AVPlayer;

Before creating one or more PVS.AVPlayer players, ensure that Media Foundation is installed (see also: 2. Check if Media Foundation is Installed). But once you've done that and it's installed, here's a simple way to play a movie in a control (in this case, "panel1") in your application:

Player myPlayer = new Player();
myPlayer.Play(@"C:\MyMovie.mp4", panel1);

To stop playing and remove myPlayer, use:

myPlayer.Dispose();
myPlayer = null;

You should always remove all players by using their Dispose method before your application ends.

2. Check If Media Foundation is Installed

The PVS.AVPlayer library can only be used on computers with Microsoft Media Foundation installed. You can check whether Media Foundation is installed on a computer using the (static) Player.MFPresent method. This method returns 'true' if Media Foundation is installed:

if (! Player.MFPresent) MessageBox.Show ("Media Foundation is not installed.");

If you try to create a player on a computer without Media Foundation, an exception (error) is thrown and the player is not created. Media Foundation is supported by Microsoft Windows Vista or higher, but Windows 7 or higher is recommended for the PVS.AVPlayer library. The library may not work correctly under Windows Vista.

The text and code samples in this article assume that Media Foundation is installed.

3. Creating a Player

If you want to play a media file, you must first create a player. In your application, you can create as many players as you want and also remove them if you no longer need them. You can use them at the same time, even to play the same media file. Once you have created a player, you can continue to use it to play media files. You do not have to stop a playing media file to play another media file, the player will take care of it.

In the following example, the player's name is "myPlayer" and some lines of code are added to use one of the events raised by the player.

A player can inform you about changes in the playback status by sending you 'event messages'. You can 'catch' these events with your player's event handler and act accordingly. For example, in the case of a MediaEnded event (that tells you that a media file has finished playing), you may want to play another (next) media file (see also: 5. Player Events).

Adding a Player with event handler to a new Windows Forms application:

using PVS.AVPlayer;

namespace MyApplication
{
    public partial class Form1 : Form
    {
        Player myPlayer;

        public Form1()
        {
            InitializeComponent();

            myPlayer = new Player();
            myPlayer.Events.MediaEnded += MyPlayer_MediaEnded;
        }

        void MyPlayer_MediaEnded(object sender, EndedEventArgs e)
        {
            switch (e.StopReason)
            {
                case StopReason.Finished:
                    // media has finished playing
                    break;

                case StopReason.AutoStop:
                    // media is stopped by the player to play next media
                    break;

                case StopReason.UserStop:
                    // media is stopped with the Player.Stop method
                    break;

                case StopReason.Error:
                    // media has stopped because an error has occurred
                    break;
            }
        }
    }
}

Now all you have to do is tell the player which media file (path and file name) to play and, if it is a movie, where to display it (player display).

4. Error Handling

Every method and every property of a PVS.AVPlayer player returns a result code (error code). The result can be obtained via the 'LastError' property of the player (and sometimes from a method itself). You should always check if a method or property works as you expect by checking the "LastError" property that returns a Boolean value, for example:

myPlayer.Audio.Volume = 2f; // value out of range (0.0 - 1.0)
if (myPlayer.LastError) MessageBox.Show(myPlayer.LastErrorString);

The 'LastErrorString' property of a player returns a description of the last error that occurred and the 'LastErrorCode' property returns the error code (0 = no error). Subscribing to some events of a player can also cause an error, for example, if the selected option is not supported by the system used.

A PVS.AVPlayer player does not throw or pass on exceptions, so you don't have to use the try-catch construction with the player's instructions. However, an exception is thrown when creating a player while Media Foundation is not installed on the system (see also: 2. Check if Media Foundation is Installed).

5. Player Events

The events raised by PVS.AVPlayer allow your application to react to certain changes in the state of your player, like when a mediafile has finished playing. You don't have to use any of the events, and if you don't, PVS.AVPlayer will ignore them too and not send any event messages to your application.

Some player functions can only be activated by subscribing to a player event, such as obtaining audio peak levels or subtitles. Other events can be very useful for updating interface items in different locations (for example, the playback position or audio volume) or checking whether a setting has really changed (for example, when selecting another audio device).

The MediaPositionChanged event differs slightly from the others because it is sent very often when a media file is being played and it uses a timer. It provides information about the player's playback position and you can use it to update a number of position indicators on the screen, such as a slider (if you are not using the player's position slider) and / or some 'counters':

private void MyPlayer_MediaPositionChanged(object sender, PositionChangedEventArgs e)
{
    TimeSpan fromStart = TimeSpan.FromTicks(e.FromStart);
    TimeSpan toStop = TimeSpan.FromTicks(e.ToStop);

    myTrackBar.Value = fromStart.TotalMilliseconds;

    label1.Text = fromStart.ToString(@"hh\:mm\:ss")
    label2.Text = toStop.ToString(@"hh\:mm\:ss")
}

Other events that may be sent very often are the MediaPeakLevelChanged and the MediaSubtitleChanged events. Because these events are sent so often, the event handlers should handle the events quickly and efficiently to prevent the application from being delayed.

By using the myPlayer.TimerInterval property, you can change the frequency by which the MediaPositionChanged and MediaPeakLevelChanged events are sent (default 100 milliseconds):

myPlayer.TimerInterval = 50;

This timer also controls the updates of the (both optional) player's position slider and taskbar progress indicator.

Image 4

6. Player Display

To view the video images of media files, your player must have a display. You can use any WinForms control (including a form) as a player display, but a panel would be a good choice because it has the least resources attached and is well suited for that. You can specify the player's display when you create a player or at any other time, even when media is being played. The player remembers which display to use, so you don't have to repeat the setting every time (this is the case with all player settings).

Player myPlayer = new Player(panel1);
myPlayer.Display.Window = panel2;
myPlayer.Play(myVideo, this);

The display of a player can be treated as a 'normal' WinForms control, you can add other controls to it and adjust its properties to your needs. This is different from the display of a player before version 0.95 of the PVS.AVPlayer library. To easily add items to a player's display, with transparency and opacity options, you can use a PVS.AVPlayer display overlay (see: 7. Display Overlays).

You can change the way video images are shown on the player's display in many different ways, for example:

// use one of the preset formats (default: DisplayMode.ZoomCenter):
myPlayer.Display.Mode = DisplayMode.Stretch;

// use a custom format (default: DisplayMode.ZoomCenter):
myPlayer.Video.Bounds = new Rectangle(10, 20, 300, 400);

// use a display shape (default: DisplayShape.Normal):
myPlayer.Display.Shape = DisplayShape.Oval;

A player also offers multiple options to copy the contents of its display (without copying any overlapping windows), for example:

myPlayer.ScreenCopy.ToClipboard();

You can use the same display for multiple players if you organize the position of the video with the Player.Video.Bounds property and you can play videos without using a display to hear only the video sound.

7. Full Screen Display

If you want to display a player's display on the entire computer screen, you can use the player's full screen option, for example:

myPlayer.FullScreen = true;

Before (or after) doing this, you can use the player's FullScreenMode option to select what is displayed on the full screen:

  1. FullScreenMode.Form - shows the form (the player's display is on) full screen
  2. FullScreenMode.Parent - shows the parent control (the player's display is in) full screen
  3. FullScreenMode.Display - shows the display of the player in full screen (default setting)
myPlayer.FullScreenMode = FullScreenMode.Form;

The player's display or its parent can't be inside any other control than the form itself if you want to use mode 2 or 3. With each full screen display mode, the player's display always remains part of the form on which it is placed (there is no special or separate full screen window).

Each player can have a full screen display as long as its display is not on a form that already has a full screen display of another player.

8. Display Overlays

With a PVS.AVPlayer display overlay, you can very easily display something (like text, pictures and movies) on top of a movie. A PVS.AVPlayer display overlay is a form, just like the ones you use in your .NET Windows Forms Application projects. PVS.AVPlayer just displays it on top of a player's display.

From version 0.95 of the PVS.AVPlayer library, the player's display window behaviour has changed. The display can now be used as any other control: you can add controls to it and get mouse events from it. However, display overlays can still offer many useful options to display items on top of a player's display, including settings for transparency and opacity.

Simply create a form ("Form2" in this example) and add all desired items, for example an image logo and some code, and add it to the player as follows:

Form2 myOverlay = new Form2();        // create an instance of Form2
myPlayer.Overlay.Window = myOverlay;  // and attach it to the player

To remove a display overlay from the player, set the overlay window to another overlay or to null:

myPlayer.Overlay.Window = null;

A display overlay can be the same size as the player's display or the same size as the video image of the playing media, for example:

myPlayer.Overlay.Mode = OverlayMode.Display;  // the default value is OverlayMode.Video

A central point in a display overlay code is the form's VisibleChanged event. This event indicates when a display overlay is activated or deactivated. You can switch the various used items in the display overlay code, for example a timer, on or off accordingly. See the example applications 'How To ...' for a more detailed description of and various tips for using display overlays.

9. Display Clones

If you want your player to have multiple displays that all show the same image (for example, for use on multiple monitors), you can use one or more PVS.AVPlayer display clones. A display clone is a copy of the main display including all items that you have added to it and (optionally) its display overlay. Each display clone can have its own independent size and has different adjustable features. You can add a display clone to a player with, for example:

myPlayer.DisplayClones.Add(panel4);

Changing the properties of a display clone differs slightly from the standard methods. You must specify a data structure named CloneProperties to change one or more properties of a display clone. You can change an existing CloneProperties structure or create a new one, for example:

CloneProperties props = myPlayer.DisplayClones.GetProperties(panel4);
props.DragEnabled = true;
props.Shape = DisplayShape.Oval;
myPlayer.DisplayClones.SetProperties(panel4, props);

You can also use the CloneProperties structure to set the properties of all existing display clones at once.

Image 5

10. Playing a Media File

To play a media file, you can use one of the Player's Play methods. With the play methods, you can also specify the start and end time of the media and if the media should be repeated when finished playing.

To create a (tiny) mediaplayer, add a button ('button1') and a panel ('panel1') to your form and add the PlayMedia method (see below) to the code (for a 'standard display look', you can set the background color of the panel to black). Double-click the button on your form and add the PlayMedia instruction in the automatically created buttonclick handler. The project code now looks something like this:

using PVS.AVPlayer;

namespace MyProject
{
    public partial class Form1 : Form
    {
        Player myPlayer;
        // Form2 myOverlay; // create a display overlay (Form2)
                            // with the Visual Studio designer
        // Form myDisplayClone;
        OpenFileDialog myOpenFileDialog;
        string[] myMovies;
        int movieToPlay = 0;
        Point buttonLocation;

        public Form1()
        {
            InitializeComponent();

            myPlayer = new Player();
            myPlayer.Events.MediaEnded += myPlayer_MediaEnded;

            myPlayer.Display.Window = panel1;
            myPlayer.Display.Mode = DisplayMode.Stretch;

            myPlayer.Display.DragEnabled = true;
            myPlayer.CursorHide.Add(this);
            myPlayer.TaskbarProgress.Add(this);

            // myOverlay = new Form2();
            // myPlayer.Overlay.Window = myOverlay;

            // myDisplayClone = new Form();
            // myDisplayClone.BackColor = Color.Black;
            // myDisplayClone.Show();
            // myPlayer.DisplayClones.Add(myDisplayClone);

            myOpenFileDialog = new OpenFileDialog();
            myOpenFileDialog.Multiselect = true;

            this.KeyPreview = true;
            this.KeyDown += new KeyEventHandler(Form1_KeyDown);
        }

        void MyPlayer_MediaEnded(object sender, EndedEventArgs e)
        {
            if (e.StopReason == StopReason.Finished) PlayNextMedia();
        }

        private void PlayMedia(string fileName)
        {
            myPlayer.Play(fileName);

            if (myPlayer.LastError)
            {
                MessageBox.Show(fileName + "\r\n\r\n" + myPlayer.LastErrorString);
                if (myMovies.Length > 1) PlayNextMedia();
            }
        }

        private void button1_Click(object sender, EventArgs e)
        {
            if (myOpenFileDialog.ShowDialog(this) == DialogResult.OK)
            {
                myMovies = myOpenFileDialog.FileNames;
                movieToPlay = 0;
                PlayMedia(myMovies[movieToPlay]);
            }
        }

        private void PlayNextMedia()
        {
            if (++movieToPlay >= myMovies.Length) movieToPlay = 0;
            PlayMedia(myMovies[movieToPlay]);
        }

        private void Form1_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Space)
            {
                ToggleFullScreen();
                e.Handled = true;
            }
        }

        private void ToggleFullScreen()
        {
            if (myPlayer.FullScreen)
            {
                myPlayer.FullScreen = false;
                button1.Location = buttonLocation;
            }
            else
            {
                buttonLocation = button1.Location;
                myPlayer.FullScreen = true;
                button1.Location = new Point(24, 24);
                button1.BringToFront();
            }
        }
    }
}

This basic example can easily be expanded with other desired functionality, such as a position slider, a pause and stop button or changing the audio output device. See the text below and the example application "How To ..." how you can do that and for more examples.

Image 6

11. Audio Settings

A media file can contain multiple audio tracks (streams) and each track can have multiple channels. Multiple tracks are used to provide alternative audio for the media, for example, a commentary track or different languages. The channels in a track contain the audio information and usually there are 2 channels for stereo output, but there may also be less or more for surround sound, for example. The media starts playing the standard selected tracks, but these can easily be changed. For example, you can display the tracks in a menu and let the user select one of the tracks.

Information about the available audio tracks in the media being played can be obtained with:

int count = myPlayer.Media.AudioTrackCount; // get the number of audio tracks
AudioTrack[] tracks = myPlayer.Media.GetAudioTracks(); // get information about each track

// the information can be used to display some properties of the tracks, for example in a menu:
myMenu.Items.Add(tracks[0].Name + " " + tracks[0].Language); // and for all other tracks

To select one of the audio tracks in the playing media use, for example:

myPlayer.Audio.Track = 1; // select the second audio track

You can change the audio volume and balance settings of the selected track with, for example:

myPlayer.Audio.Volume = 0.5f; // values from 0.0 to 1.0
myPlayer.Audio.Balance = 0.1f; // values from -1.0 to 1.0

or you can change the volume of each individual channel (values from 0.0 to 1.0, up to 16 channels) with, for example:

// get the audio volumes for each channel with:
float[] channelVolumes = myPlayer.Audio.ChannelVolumes;

 // to change the volume of, for example, the right (or 2nd) channel, use:
channelVolumes[1] = 0.5f;
myPlayer.Audio.ChannelVolumes = channelVolumes;

and of course, you can temporarily mute the audio (while maintaining the volume settings), for example:

myPlayer.Mute = true;

The volume, balance, or channel volume (and the following audio device) settings are player settings, which means that they will be used for all subsequent media until they are changed again.

By default, a PVS.AVPlayer player uses the system's default audio output device (if any), but this can be changed using the Player.Audio.Device property. This property uses an 'AudioDevice' data structure.

The AudioDevice data structures of the system's enabled audio devices can be retrieved with:

AudioDevice[] devices = myPlayer.Audio.GetDevices();
// the information can be used to display some properties of the devices,
// for example in a menu:
myMenu.Items.Add(devices[0].Name); // and for all other devices

To select one of the devices retrieved from GetDevices (usually selected from a menu), use:

myPlayer.Audio.Device = devices[index]; // where index represents a device in the list

A player also offers direct access to the system's audio control panels:

myPlayer.SystemPanels.ShowAudioDevices();
myPlayer.SystemPanels.ShowAudioMixer();

Please refer to the sample applications 'How To ...' for more information about the audio options and settings of the PVS.AVPlayer library.

12. Video Settings

Just as with audio tracks, a media file can also contain multiple video tracks (streams). The media starts playing the standard selected track, but it can easily be changed. For example, you can display the names of the video tracks in a menu and let the user select one of the tracks.

Information about the available video tracks in the media being played can be obtained with:

int count = myPlayer.Media.VideoTrackCount;            // get the number of video tracks
VideoTrack[] tracks = myPlayer.Media.GetVideoTracks(); // get information about each track

// the information can be used to display some properties of the tracks,
// for example in a menu:
myMenu.Items.Add(tracks[0].Name + " " + tracks[0].Language); // and for all other tracks

To select one of the video tracks in the playing media use, for example:

myPlayer.Video.Track = 1; // select the second video track

The video image of a media file can be displayed in any desired size and there are various options, such as adjusting the brightness, to change the video image, for example:

myPlayer.Display.Mode = DisplayMode.Stretch;
myPlayer.Video.Bounds = new Rectangle (10, 20, 300, 400);
myPlayer.Video.Brightness = 0.5;

A player also offers direct access to the system's display control panel:

myPlayer.SystemPanels.ShowDisplaySettings();

See the sample applications 'How To ...' for more information about the video options and settings of the PVS.AVPlayer library.

13. TrackBars

You may want to use a trackbar type control with your player to show and change the playback position of a mediafile. That's not a difficult task, although there's more to it than just might seem at first sight. That's why PVS.AVPlayer can handle this kind of control for you.

Just add a TrackBar control to your form (or display overlay) and tell the player to handle it with:

myPlayer.Sliders.Position.TrackBar = trackBar1;

By setting the myPlayer.Sliders.Position.Mode option, you can have the trackbar show the position between the beginning and end of a mediafile (PositionSliderMode.Track) or between the player's media start- and end time (PositionSliderMode.Progress). The position slider has several other options.

Similarly, you can also let the player handle an audio volume slider (myPlayer.Sliders.AudioVolume), an audio balance slider (myPlayer.Sliders.AudioBalance), a playback speed slider (myPlayer.Sliders.Speed) and/or a playback shuttle slider (myPlayer.Sliders.Shuttle):

myPlayer.Sliders.AudioVolume = trackBar2;

The sliders controlled by the player are only for input by the user. The values of the sliders should not be set from code. Use the corresponding properties (for example, myPlayer.Audio.Volume = 0.5f) to (also) change the sliders.

14. From Here On...

PVS.AVPlayer provides easy access to many standard and advanced media player functions and provides a stable environment for playing media files. It automatically takes care of internal and system changes (such as changes to the sound device used) so that you can fully focus your creativity on playing media files the way you like.

As mentioned, this article provides only a limited overview of the functions offered by the PVS.AVPlayer library. But that shouldn't be a problem, because the beautiful IntelliSense from Visual Studio is well used by the library code and, together with the clearly structured interface, can easily guide you through even the most advanced player options. And then of course, there are the richly documented example apps "How To ..." and the large player demo "AVPlayerExample". And if you still have questions, just ask them here in the comments section at the bottom of this article.

Happy coding!

Image 7

Animation by Arjan Westerdiep (www.drububu.com)

History

  • 14th June, 2019: Initial version

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Peter Vegter
United States United States
No Biography provided

Comments and Discussions

 
GeneralRe: mp4 flicker Pin
Member 102717963-Apr-18 7:35
memberMember 102717963-Apr-18 7:35 
GeneralRe: mp4 flicker Pin
Peter Vegter3-Apr-18 7:55
memberPeter Vegter3-Apr-18 7:55 
AnswerRe: mp4 flicker Pin
kilauea-de30-Apr-18 12:19
memberkilauea-de30-Apr-18 12:19 
GeneralRe: mp4 flicker Pin
Peter Vegter30-Apr-18 12:38
memberPeter Vegter30-Apr-18 12:38 
GeneralRe: mp4 flicker Pin
Peter Vegter30-Apr-18 13:11
memberPeter Vegter30-Apr-18 13:11 
GeneralRe: mp4 flicker Pin
kilauea-de1-May-18 19:20
memberkilauea-de1-May-18 19:20 
GeneralRe: mp4 flicker Pin
Peter Vegter1-May-18 22:41
memberPeter Vegter1-May-18 22:41 
GeneralNice library. Thanks for sharing. Pin
Ganza Charles15-Feb-18 4:42
memberGanza Charles15-Feb-18 4:42 
Thank you for sharing this. It looks promising. I have one question. Does it support MKV, FLV files?
thanks.
GeneralRe: Nice library. Thanks for sharing. Pin
Peter Vegter15-Feb-18 5:12
memberPeter Vegter15-Feb-18 5:12 
GeneralRe: Nice library. Thanks for sharing. Pin
Ganza Charles15-Feb-18 5:20
memberGanza Charles15-Feb-18 5:20 
QuestionWell done, some small issue Pin
vtontodonato6-Feb-18 20:54
membervtontodonato6-Feb-18 20:54 
AnswerRe: Well done, some small issue Pin
Peter Vegter7-Feb-18 0:36
memberPeter Vegter7-Feb-18 0:36 
AnswerRe: Well done, some small issue Pin
Peter Vegter7-Feb-18 17:03
memberPeter Vegter7-Feb-18 17:03 
GeneralRe: Well done, some small issue Pin
vtontodonato8-Feb-18 5:41
membervtontodonato8-Feb-18 5:41 
QuestionSpace Bar Toggles Fullscreen Pin
Member 128707469-Dec-17 14:48
memberMember 128707469-Dec-17 14:48 
AnswerRe: Space Bar Toggles Fullscreen Pin
Peter Vegter9-Dec-17 15:44
memberPeter Vegter9-Dec-17 15:44 
GeneralRe: Space Bar Toggles Fullscreen Pin
Member 1287074612-Dec-17 13:47
memberMember 1287074612-Dec-17 13:47 
GeneralRe: Space Bar Toggles Fullscreen Pin
Peter Vegter12-Dec-17 17:19
memberPeter Vegter12-Dec-17 17:19 
QuestionScreencopy produces black images Pin
Sebastian Putz20-Nov-17 4:33
memberSebastian Putz20-Nov-17 4:33 
AnswerRe: Screencopy produces black images Pin
Peter Vegter20-Nov-17 9:27
memberPeter Vegter20-Nov-17 9:27 
GeneralRe: Screencopy produces black images Pin
Sebastian Putz21-Nov-17 7:55
memberSebastian Putz21-Nov-17 7:55 
GeneralRe: Screencopy produces black images Pin
Peter Vegter21-Nov-17 8:15
memberPeter Vegter21-Nov-17 8:15 
GeneralRe: Screencopy produces black images Pin
Sebastian Putz21-Nov-17 9:06
memberSebastian Putz21-Nov-17 9:06 
GeneralRe: Screencopy produces black images Pin
Peter Vegter21-Nov-17 10:16
memberPeter Vegter21-Nov-17 10:16 
GeneralRe: Screencopy produces black images Pin
Sebastian Putz29-Nov-17 7:53
memberSebastian Putz29-Nov-17 7:53 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

Article
Posted 14 Sep 2010

Stats

778.5K views
32.1K downloads
299 bookmarked