Created CheckDwmApi utility

Author: melanchall

Docs/articles/composing/Pattern.md

@@ -160,7 +160,7 @@ Each line starts with a note. Think about the line as a piano roll lane in your
 
 Hyphen (`'-'`) means nothing except a step of a cell's length. We will call it as **fill symbol**.
 
-> [!IMPORTANT]
+> [!WARNING]
 > Spaces will be cut from the piano roll string before processing. So it's required to use a fill symbol to specify an empty space (rest) to get correct results. For example, this pattern:
 > ```text
 > F2   ||||

Docs/articles/dev/Support.md

@@ -6,7 +6,7 @@ uid: a_support
 
 Here you'll find information about how to create good issues on the DryWetMIDI so I (author of the library) can help you with your problem. The main rule – provide as many details as possible. I'm developing the library in my spare time and don't ask money for it. Please respect my time.
 
-> [!IMPORTANT]
+> [!WARNING]
 > If you make no effort to get your issue clear, I will make no effort to help you.
 
 Things to pay attention for are:

Docs/articles/dev/Using-in-Unity.md

@@ -155,5 +155,5 @@ public class DemoScript : MonoBehaviour
 }
 ```
 
-> [!IMPORTANT]
+> [!WARNING]
 > Pay attention to `OnApplicationQuit` method. You should always take care about disposing of MIDI devices. Without it all resources taken by the device will live until GC collects them. In the case of Unity, it means Unity may need to be reopened to be able to use the same devices again (for example, on Windows).

Docs/articles/dev/Utility-CheckDwmApi.md

@@ -46,7 +46,7 @@ Of course, you can see [the source code](https://github.com/melanchall/drywetmid
 
 ## Running the utility
 
-> [!IMPORTANT]
+> [!WARNING]
 > If you're on Windows, you need to have a virtual MIDI device installed to run the utility. For example, you can use [loopMIDI](https://www.tobias-erichsen.de/software/loopmidi.html):
 >
 > ![CheckDwmApi loopMIDI Create](images/CheckDwmApi-loopMIDI-Create.png)

Docs/articles/devices/Devices-watcher.md

@@ -4,7 +4,7 @@ uid: a_dev_watcher
 
 # Devices watcher
 
-> [!IMPORTANT]
+> [!WARNING]
 > Devices watching API is a platform-specific one so please refer to the [Supported OS](xref:a_develop_supported_os) article to learn more.
 
 DryWetMIDI allows to track whether a MIDI device is added to or removed from the system. There is the [DevicesWatcher](xref:Melanchall.DryWetMidi.Multimedia.DevicesWatcher) class for that purpose. The class is singleton and you can get the instance with [Instance](xref:Melanchall.DryWetMidi.Multimedia.DevicesWatcher.Instance) property.
@@ -156,5 +156,5 @@ Name is MyDevice
 
 Device instances comparison can be useful in programs with GUI where you need to update the list of available devices. So when a device is added, you just add it to the list. When some device is removed, you find the corresponding item in the current list via `Equals` on device instances and remove that item.
 
-> [!IMPORTANT]
+> [!WARNING]
 > Checking for devices equality supported for **macOS** only. On Windows call of `Equals` will just compare references.

Docs/articles/devices/Input-device.md

@@ -8,14 +8,14 @@ In DryWetMIDI an input MIDI device is represented by the [IInputDevice](xref:Mel
 
 The library provides built-in implementation of `IInputDevice`: [InputDevice](xref:Melanchall.DryWetMidi.Multimedia.InputDevice) class. To get an instance of `InputDevice` you can use either [GetByName](xref:Melanchall.DryWetMidi.Multimedia.InputDevice.GetByName(System.String)) or [GetByIndex](xref:Melanchall.DryWetMidi.Multimedia.InputDevice.GetByIndex(System.Int32)) static methods. ID of a MIDI device is a number from `0` to _devices count minus one_. To get count of input MIDI devices presented in the system there is the [GetDevicesCount](xref:Melanchall.DryWetMidi.Multimedia.InputDevice.GetDevicesCount) method. You can get all input MIDI devices with the [GetAll](xref:Melanchall.DryWetMidi.Multimedia.InputDevice.GetAll) method.
 
-> [!IMPORTANT]
+> [!WARNING]
 > You can use `InputDevice` built-in implementation of `IInputDevice` only on the systems listed in the [Supported OS](xref:a_develop_supported_os) article. Of course you can create your own implementation of `IInputDevice` as described in the [Custom input device](#custom-input-device) section below.
 
 After an instance of `InputDevice` is obtained, call [StartEventsListening](xref:Melanchall.DryWetMidi.Multimedia.IInputDevice.StartEventsListening) to start listening to incoming MIDI events going from an input MIDI device. If you don't need to listen for events anymore, call [StopEventsListening](xref:Melanchall.DryWetMidi.Multimedia.IInputDevice.StopEventsListening). Also this method will be called automatically on [Dispose](xref:Melanchall.DryWetMidi.Multimedia.MidiDevice.Dispose). To check whether `InputDevice` is currently listening for events or not use [IsListeningForEvents](xref:Melanchall.DryWetMidi.Multimedia.IInputDevice.IsListeningForEvents) property.
 
 If an input device is listening for events, it will fire the [EventReceived](xref:Melanchall.DryWetMidi.Multimedia.IInputDevice.EventReceived) event for each incoming MIDI event. Received MIDI event will be passed to an event's handler.
 
-> [!IMPORTANT]
+> [!WARNING]
 > If you use an instance of the `InputDevice` within a `using` block, you need to be very careful. In general it's not a good practice and can cause problems. For example, with this code
 > ```csharp
 > using (var inputDevice = InputDevice.GetByName("Some MIDI device"))
@@ -66,7 +66,7 @@ namespace InputDeviceExample
 }
 ```
 
-> [!IMPORTANT]
+> [!WARNING]
 > You must always take care about disposing an `InputDevice`, so use it inside `using` block or call `Dispose` manually. Without it all resources taken by the device will live until GC collects them via the finalizer of the `InputDevice`. It means that sometimes you will not be able to use different instances of the same device across multiple applications or different pieces of a program.
 
 `InputDevice` has the [MidiTimeCodeReceived](xref:Melanchall.DryWetMidi.Multimedia.InputDevice.MidiTimeCodeReceived) event which, by default, will be fired only when **all** MIDI Time Code components (separate [MidiTimeCodeEvent](xref:Melanchall.DryWetMidi.Core.MidiTimeCodeEvent) events) are received forming _hours:minutes:seconds:frames_ timestamp. You can turn this behavior off by setting [RaiseMidiTimeCodeReceived](xref:Melanchall.DryWetMidi.Multimedia.InputDevice.RaiseMidiTimeCodeReceived) to `false`.

Docs/articles/devices/Output-device.md

@@ -20,7 +20,7 @@ foreach (var outputDevice in OutputDevice.GetAll())
 }
 ```
 
-> [!IMPORTANT]
+> [!WARNING]
 > You can use `OutputDevice` built-in implementation of `IOutputDevice` only on the systems listed in the [Supported OS](xref:a_develop_supported_os) article. Of course you can create your own implementation of `IOutputDevice` as described in the [Custom output device](#custom-output-device) section below.
 
 After an instance of `OutputDevice` is obtained, you can send MIDI events to the device via [SendEvent](xref:Melanchall.DryWetMidi.Multimedia.OutputDevice.SendEvent(Melanchall.DryWetMidi.Core.MidiEvent)) method. You cannot send [meta events](xref:Melanchall.DryWetMidi.Core.MetaEvent) since such events can be inside a MIDI file only. If you pass an instance of meta event class, `SendEvent` will do nothing. [EventSent](xref:Melanchall.DryWetMidi.Multimedia.IOutputDevice.EventSent) event will be fired for each event sent with `SendEvent` (except meta events) holding the MIDI event sent. The value of [DeltaTime](xref:Melanchall.DryWetMidi.Core.MidiEvent.DeltaTime) property of MIDI events will be ignored, events will be sent to the device immediately. To take delta-times into account, use [Playback](xref:Melanchall.DryWetMidi.Multimedia.Playback) class.
@@ -59,10 +59,10 @@ private void OnEventSent(object sender, MidiEventSentEventArgs e)
 _outputDevice?.Dispose();
 ```
 
-> [!IMPORTANT]
+> [!WARNING]
 > You must always take care about disposing an `OutputDevice`, so use it inside `using` block or call `Dispose` manually. Without it all resources taken by the device will live until GC collects them via the finalizer of the `OutputDevice`. It means that sometimes you will not be able to use different instances of the same device across multiple applications or different pieces of a program.
 
-> [!IMPORTANT]
+> [!WARNING]
 > If you use an instance of the `OutputDevice` within a `using` block, you need to be very careful. In general it's not a good practice and can cause problems. For example, with this code
 > ```csharp
 > using (var outputDevice = OutputDevice.GetByName("Some MIDI device"))

Docs/articles/devices/Overview.md

@@ -12,7 +12,7 @@ DryWetMIDI provides the ability to send MIDI data to or receive it from MIDI dev
 
 The library provides implementations for both `IInputDevice` and `IOutputDevice`: [InputDevice](xref:Melanchall.DryWetMidi.Multimedia.InputDevice) and [OutputDevice](xref:Melanchall.DryWetMidi.Multimedia.OutputDevice) correspondingly which represent MIDI devices visible by the operating system. Both classes implement [IDisposable](xref:System.IDisposable) interface so you should always dispose of them to free devices for use by other applications.
 
-> [!IMPORTANT]
+> [!WARNING]
 > You can use `InputDevice` and `OutputDevice` built-in implementations of `IInputDevice` and `IOutputDevice` only on the systems listed in the [Supported OS](xref:a_develop_supported_os) article. Of course you can create your own implementations of `IInputDevice` and `IOutputDevice`.
 
 All classes that interact with devices work with interfaces mentioned above, so you can create custom implementations of your devices (see examples in [Input device](Input-device.md) and [Output device](Output-device.md) articles) and use it for playback or recording, for example.

Docs/articles/devices/Virtual-device.md

@@ -4,7 +4,7 @@ uid: a_dev_virtual
 
 # Virtual device
 
-> [!IMPORTANT]
+> [!WARNING]
 > Virtual devices API is a platform-specific one so please refer to the [Supported OS](xref:a_develop_supported_os) article to learn more. For Windows you can use products like [virtualMIDI SDK](https://www.tobias-erichsen.de/software/virtualmidi/virtualmidi-sdk.html) or similar to work with virtual MIDI ports programmatically. Be careful with the license of these products.
 
 With DryWetMIDI you can programmatically create virtual MIDI devices with the specified name using [VirtualDevice.Create](xref:Melanchall.DryWetMidi.Multimedia.VirtualDevice.Create(System.String)) method. In fact, virtual device is an [input](xref:a_dev_input) and an [output](xref:a_dev_output) devices paired together in a way that any MIDI event sent to the output device will be immediately transferred back from the virtual device and can be received by an application from its input subdevice.
@@ -111,7 +111,7 @@ Event Note On [5] (70, 60) received on device Leaf1.
 Event Note On [5] (70, 60) received on device Leaf2.
 ```
 
-> [!IMPORTANT]
+> [!WARNING]
 > As with input and output device you must always [dispose](xref:Melanchall.DryWetMidi.Multimedia.MidiDevice.Dispose) virtual device when you're done with it:
 >
 > ```csharp

Docs/articles/high-level-managing/Processing-objects.md

@@ -4,7 +4,7 @@ uid: a_processing_objects
 
 # Processing objects
 
-> [!IMPORTANT]
+> [!WARNING]
 > Please read the [Getting objects](xref:a_getting_objects) article before reading this one.
 
 This article describes ways to process different objects (like [timed events](xref:Melanchall.DryWetMidi.Interaction.TimedEvent) or [notes](xref:Melanchall.DryWetMidi.Interaction.Note)) within MIDI files and track chunks. Processing means changing properties of the objects, including time or length.