Merge pull request #26 from skrysmanski/feature/alert-support

Add support for Hugo alerts

Author: Sebastian Krysmanski

.vscode/settings.json

@@ -3,6 +3,7 @@
 	"cSpell.words": [
 		"baseof",
 		"blittable",
+		"blockquotes",
 		"CJKT",
 		"decompiled",
 		"decompiling",

content/articles/GitHub/Actions/dump-context/index.md

@@ -14,8 +14,7 @@ The following workflow step prints the values of all variables available in the
         run: echo "$GITHUB_CONTEXT"
 ```
 
-```tip
-For easier browsing of this huge JSON structure, open job's raw log and copy the JSON to a text editor that supports JSON code folding:
-
-![View raw build logs](view-raw-logs@2x.png)
-```
+> [!TIP]
+> For easier browsing of this huge JSON structure, open job's raw log and copy the JSON to a text editor that supports JSON code folding:
+>
+> ![View raw build logs](view-raw-logs@2x.png)

content/articles/R/plotting-graphs/index.md

@@ -13,9 +13,8 @@ I recently stumbled over [R](http://www.r-project.org/), a programming language
 
 This post is about how to display (draw) a mathematical function with R.
 
-```tip
-There's a very nice and interactive [tutorial for R](http:*www.codeschool.com/courses/try-r) available over at [codeschool.com](http:*www.codeschool.com/). It's free and takes about 3 - 4 hours to complete.
-```
+> [!TIP]
+> There's a very nice and interactive [tutorial for R](http:*www.codeschool.com/courses/try-r) available over at [codeschool.com](http:*www.codeschool.com/). It's free and takes about 3 - 4 hours to complete.
 
 <!--more-->
 

content/articles/algorithms/easy-compare-function.md

@@ -44,6 +44,5 @@ int Compare(int a, int b) {
 
 That's it.
 
-```note
-Care should be taken if `a` and/or `b` can come close to `int.MaxValue` or `int.MinValue`. In this case the results may not be what one wants (like if `a = int.MinValue` and `b = 1` then the result will be `int.MaxValue` which is wrong).
-```
+> [!NOTE]
+> Care should be taken if `a` and/or `b` can come close to `int.MaxValue` or `int.MinValue`. In this case the results may not be what one wants (like if `a = int.MinValue` and `b = 1` then the result will be `int.MaxValue` which is wrong).

content/articles/algorithms/visitor-pattern.md

@@ -291,9 +291,8 @@ public class Document {
 }
 ```
 
-```note
-The implementations of `Accept()` seem to be identical for all child classes of `DocumentPart`. However, we can't move the code into the base class because `IVisitor` doesn't have an method `Visit(DocumentPart)` but only for the concrete implementations. (We could solve this through reflection, though, but would lose compile-time checking.)
-```
+> [!NOTE]
+> The implementations of `Accept()` seem to be identical for all child classes of `DocumentPart`. However, we can't move the code into the base class because `IVisitor` doesn't have an method `Visit(DocumentPart)` but only for the concrete implementations. (We could solve this through reflection, though, but would lose compile-time checking.)
 
 ### Putting It All Together
 
@@ -366,9 +365,8 @@ Console.WriteLine(ship.GetShipType());
 
 This will print "ApolloSpacecraft". The actual method implementation to be called is chosen **at runtime** based solely on the actual type of `ship`. So, only the type of a *single* object is used to select the method, hence the name *single* dispatch.
 
-```note
-"Single dispatch" is one form of "dynamic dispatch", i.e. the method is chosen at runtime. If the method is chosen at compile time (true for all non-virtual methods), it's called "static dispatch".
-```
+> [!NOTE]
+> "Single dispatch" is one form of "dynamic dispatch", i.e. the method is chosen at runtime. If the method is chosen at compile time (true for all non-virtual methods), it's called "static dispatch".
 
 ### Double Dispatch
 

content/articles/cpp-cli/cheat-sheet.md

@@ -12,9 +12,8 @@ aliases:
 
 This article provides a quick comparison between C++/CLI and C#. It's meant for those who know C# (and possibly C++) and will explain which C++/CLI language construct correspond with which in C#. (I don't know Visual Basic so I can't add infos about this here.)
 
-```note
-This is not a complete reference but rather quick reference for those features that are (in my opinion) the most unclear.
-```
+> [!NOTE]
+> This is not a complete reference but rather quick reference for those features that are (in my opinion) the most unclear.
 
 <!--more-->
 
@@ -24,9 +23,8 @@ C++/CLI is - as the name suggest - an extension of C++ to allow it to use Micros
 
 C++/CLI is the successor of "Managed C++", which felt unnatural to many developers. However, both "languages" have the same goal: combine native code with managed code.
 
-```note
-C++/CLI is currently only available on Windows. At the time of writing (mid 2010) there are no plans in the Mono project to support C++/CLI. Such support would be necessary as a C++/CLI compiler creates mixed code that contains native and managed code. While the managed code could be executed by the Mono runtime the native can't. Therefore a C++/CLI library can't be used on Linux or MacOSX (or any other Mono supported OS).
-```
+> [!NOTE]
+> C++/CLI is currently only available on Windows. At the time of writing (mid 2010) there are no plans in the Mono project to support C++/CLI. Such support would be necessary as a C++/CLI compiler creates mixed code that contains native and managed code. While the managed code could be executed by the Mono runtime the native can't. Therefore a C++/CLI library can't be used on Linux or MacOSX (or any other Mono supported OS).
 
 See also:
 
@@ -458,9 +456,8 @@ protected:
 
 You only need destructor *and* finalizer when the class hosts some unmanaged data (e.g. a pointer to a C++ class). If you don't have unmanaged data in your class, you neither need destructor nor finalizer (unless you have some members implementing `IDisposable`).
 
-```warn
-The destructor (`Dispose()`) will **not** be called automatically from the finalizer.
-```
+> [!WARNING]
+> The destructor (`Dispose()`) will **not** be called automatically from the finalizer.
 
 Since freeing unmanaged resources should occur in the finalizer (see [](idisposable-and-finalizers.md)), the default implementation pattern for finalizer and destructor looks like this:
 
@@ -574,9 +571,8 @@ Calling an event is identical to calling a delegate:
 this->MyCustomEvent(this, EventArgs::Empty);
 ```
 
-```note
-Checking the event against `nullptr` isn't required in C++/CLI (unlike C#). That's because the event's `raise()` method automatically checks whether there are actually any event handlers ([source](http://stackoverflow.com/a/2014752/614177)).
-```
+> [!NOTE]
+> Checking the event against `nullptr` isn't required in C++/CLI (unlike C#). That's because the event's `raise()` method automatically checks whether there are actually any event handlers ([source](http://stackoverflow.com/a/2014752/614177)).
 
 ## Templates and Generics
 
@@ -630,9 +626,8 @@ T MyClass::ReturnNull() {
 }
 ```
 
-```note
-The syntax of `T()` may be misleading. It does **not** create an instance of `T` on the stack and call `T`'s default constructor (as the syntax would suggest). It indeed results in `nullptr`.
-```
+> [!NOTE]
+> The syntax of `T()` may be misleading. It does **not** create an instance of `T` on the stack and call `T`'s default constructor (as the syntax would suggest). It indeed results in `nullptr`.
 
 ## Referencing managed type from other file (in the same project)
 

content/articles/cpp-cli/passing-native-pointers/index.md

@@ -248,9 +248,8 @@ void ExternalTestClass::doSomething() {
 
 Of course, this also allows you to actually do something (e.g. call methods) with the `nativeClass` pointer.
 
-```tip
-If you only want to store a pointer to a native class (i.e. don't do anything with it), you don't need to link against the native type's `.lib` file.
-```
+> [!TIP]
+> If you only want to store a pointer to a native class (i.e. don't do anything with it), you don't need to link against the native type's `.lib` file.
 
 ### Native Types From C++/CLI Projects
 

content/articles/cpp/project-tutorial/part-1--create-project/index.md

@@ -127,9 +127,8 @@ For this to work, you add the preprocessor definition `COMPILE_MYLIBRARY` to the
 
 ![Preprocessor configuration](preprocessor-definition.png)
 
-```note
-The keyword `__declspec(...)` is a Microsoft specific extension to C++ (see [here](http:*msdn.microsoft.com/en-us/library/3y1sfaz2.aspx)). So it only works in Visual C++. There is an alternative (more portable?) way to specify which classes/functions are to be exported. For this, a "Module-Definition File" (`.def`) needs to be created. However, creating such a file is more tedious than specifying the export statement directly in the code. For more information, see [this article](http:*www.codeguru.com/cpp/cpp/cpp_mfc/tutorials/article.php/c9855).
-```
+> [!NOTE]
+> The keyword `__declspec(...)` is a Microsoft specific extension to C++ (see [here](http:*msdn.microsoft.com/en-us/library/3y1sfaz2.aspx)). So it only works in Visual C++. There is an alternative (more portable?) way to specify which classes/functions are to be exported. For this, a "Module-Definition File" (`.def`) needs to be created. However, creating such a file is more tedious than specifying the export statement directly in the code. For more information, see [this article](http:*www.codeguru.com/cpp/cpp/cpp_mfc/tutorials/article.php/c9855).
 
 Now, when you compile the library project, an additional `.lib` file will be created. This file is used to import the exported classes/functions in another project. (If you don't export anything, the file won't be created.) How to do this, is explained in [part two of this mini series](part-2--project-dependencies.md).
 
@@ -187,9 +186,8 @@ std::string PrintableInt<T>::toString() const
 
 This adds the type parameter `T` to the class. Note that `__declspec(dllimport)` has been commented out to demonstrate the problem.
 
-```note
+> [!NOTE]
 The type parameter `T` serves no purpose in this implementation. It's just there to demonstrate the problem.
-```
 
 Now, assume another project using the library project like this:
 

content/articles/cpp/project-tutorial/part-2--project-dependencies/index.md

@@ -134,14 +134,13 @@ And that's it. Your project should now compile.
 
 Besides being easier to use, the new way has also another advantage: The information about project dependencies are now stored in the project file instead of the solution file (which is the case with the way described in [](#specify_build_order)). This way you can use a library project that has some dependencies itself in several different solutions and always have the dependencies already set up correctly. (With the old way you had to recreate the dependencies for each solution manually.)
 
-```note
-There are two options - available in the project settings - that influence how these references work. Both can be found under "Linker" --> "General":
-
-* *Ignore Import Library:* This is specified in the library project. When this is set, the `.lib` file generated by the project won't be used automatically by projects that depend on it. (Default: No)
-* *Link Library Dependencies:* This is the opposite of the other option. It's specified on the project that uses other projects. If set to "No", dependencies won't be linked automatically. (Default: Yes)
-
-![Linker options](automatic-linking-option.png)
-```
+> [!NOTE]
+> There are two options - available in the project settings - that influence how these references work. Both can be found under "Linker" --> "General":
+>
+> * *Ignore Import Library:* This is specified in the library project. When this is set, the `.lib` file generated by the project won't be used automatically by projects that depend on it. (Default: No)
+> * *Link Library Dependencies:* This is the opposite of the other option. It's specified on the project that uses other projects. If set to "No", dependencies won't be linked automatically. (Default: Yes)
+>
+> ![Linker options](automatic-linking-option.png)
 
 ### What's not working
 

content/articles/cpp/property-sheets/index.md

@@ -12,23 +12,20 @@ aliases:
 
 Everyone who has ever created and managed a C++ project in Visual Studio knows that there are hundreds of compiler switches and options to choose from. While setting the desired values for one project may be ok, it's quite time-consuming and error-prone to do this for multiple projects. I'm currently working with a solution containing about 30 or so projects that share most of their project settings. I always wished there was a way to sync or share these common settings among the projects in the solution. Fortunately, there is: *property sheets*. They're a bit hidden though, so I'll explain how to use them in this article.
 
-```note
-This only applies to C++ and C++/CLI projects. .NET projects (C# and Visual Basic) don't have that many options to be tweaked and (therefore?) can't have shared settings.
-```
+> [!NOTE]
+> This only applies to C++ and C++/CLI projects. .NET projects (C# and Visual Basic) don't have that many options to be tweaked and (therefore?) can't have shared settings.
 
-```note
-This article describes property sheets as they appear in Visual Studio 2010. They may work slightly different in other versions of Visual Studio.
-```
+> [!NOTE]
+> This article describes property sheets as they appear in Visual Studio 2010. They may work slightly different in other versions of Visual Studio.
 
 <!--more-->
 
 ## The Property Manager
 
 While property sheets (file extension: `.props`) are simply XML files and therefore could be edited with a simple text editor, Visual Studio also provides an editor for property sheets. This editor is available through the so called Property Manager. To display the Property Manager pane, in the menu go to `View` --> `Other Windows` --> `Property Manager`.
 
-```note
+> [!NOTE]
 Property sheet files share the same XML syntax as `.vcxproj` files.
-```
 
 ![Property Manager in main menu](property-manager-in-menu.png)
 
@@ -48,17 +45,15 @@ Let's examine the property sheets a bit closer:
 * Property sheets have an order in which they're evaluated. This is important, if two property sheets define a value for the same setting. The order can be seen in the Property Manager and is bottom up. So in the image above, for the "Debug" configuration first `Core Windows Libraries` is evaluated, then `Unicode Support` and so forth. We'll examine the effects of this order a little later.
 * Property sheets belong to a certain configuration (such as "Debug|Win32"). The stack of property sheets defines the value that can be inherited for this specific configuration (i.e. that's what you get when you choose `<inherit from parent or project defaults>` for a value in the project settings).
 
-```note
-The property sheet `Microsoft.Cpp.Win32.user` is located somewhere in the current user's application settings. It's contents therefore will be different for each user. By keeping it *the top item* in every configuration you allow the user to override any option, if necessary, without needing to change the project file.
-```
+> [!NOTE]
+> The property sheet `Microsoft.Cpp.Win32.user` is located somewhere in the current user's application settings. It's contents therefore will be different for each user. By keeping it *the top item* in every configuration you allow the user to override any option, if necessary, without needing to change the project file.
 
 ## Creating a shared property sheet
 
 The first step is to create a new property sheet file. To do this, right-click on the project and choose `Add New Project Property Sheet`. This will add a new property sheet to all configurations of the project. In this article, we'll called the file `commons.props` and place it in a directory called `shared-properties` directly in the solution directory.
 
-```note
-You can also right-click on a configuration and choose the same menu item. In this case the new property sheet will only be added to the selected configuration. You can, of course, add this property sheet later to the other configurations as well.
-```
+> [!NOTE]
+> You can also right-click on a configuration and choose the same menu item. In this case the new property sheet will only be added to the selected configuration. You can, of course, add this property sheet later to the other configurations as well.
 
 As mentioned before, we want to keep the property sheet `Microsoft.Cpp.Win32.user` the top item in every configuration. So, select an instance of the new property sheets and click on the down arrow in the Property Manager's toolbar. Repeat this also for the property sheet(s) in the other configuration(s).
 
@@ -72,9 +67,8 @@ The result then should look like this:
 
 To edit a property sheet (file), simply double-click on it in the Property Manager.
 
-```note
-The same property sheet file can be listed multiple times in the Property Manager. Editing one "instance" of this file will, of course, update all other "instances" as well (since all "instances" share the same file).
-```
+> [!NOTE]
+> The same property sheet file can be listed multiple times in the Property Manager. Editing one "instance" of this file will, of course, update all other "instances" as well (since all "instances" share the same file).
 
 This will pop up a dialog that's very similar to the "Project Settings" dialog of a C++ project. Note that since the property sheet file itself isn't bound to any specified project kind or configuration, the dialog may display more options than are actually available to the project the property sheet is currently associated with.
 
@@ -90,19 +84,17 @@ After clicking on `Apply`, the result should look like this:
 
 Now, again, open the property sheet editor for the `common` property sheet we created earlier. There, set the `Warning Level` to `Level3 (/W3)`. Then click `OK`.
 
-```note
-You may need to save the property sheet manually. For this, use the `Save` button in the Property Manager's toolbar.
-```
+> [!NOTE]
+> You may need to save the property sheet manually. For this, use the `Save` button in the Property Manager's toolbar.
 
 When you now open the project's settings again, you should see that the inherited value (not in bold) of `Warning Level` *changed* from level 1 to level 3.
 
 ![New default value](default-value-w3.png)
 
 That's the effect of the property sheet. You can define as many settings in a single property sheet file as you want. Then you can add the same property sheet file to multiple project thereby sharing this set of common project settings among all projects.
 
-```note
-A value of a setting specified in a property sheet is only used in a project, when there isn't a custom value (printed in bold) assigned to this setting in the project settings. To take the value of the property sheet (instead of defining a value in the project file), select `<inherit from parent or project defaults>` from the drop-down menu of this setting.
-```
+> [!NOTE]
+> A value of a setting specified in a property sheet is only used in a project, when there isn't a custom value (printed in bold) assigned to this setting in the project settings. To take the value of the property sheet (instead of defining a value in the project file), select `<inherit from parent or project defaults>` from the drop-down menu of this setting.
 
 ## Property Sheet Order
 
@@ -141,9 +133,8 @@ The XML code for inheritance is:
 
 Property sheets can also contain *conditional property values*. This means that the value of a property depends on some other value. Usually, this is used to place values for debug and release builds in the same property sheet file. Unfortunately, you can edit these conditions in Visual Studio's property editor. You need to use a text editor.
 
-```note
-When you've modified a property sheet outside of Visual Studio, you need to close the solution(s) it belongs to and reopen them afterwards. Otherwise Visual Studio won't detect the changes to the property sheet.
-```
+> [!NOTE]
+> When you've modified a property sheet outside of Visual Studio, you need to close the solution(s) it belongs to and reopen them afterwards. Otherwise Visual Studio won't detect the changes to the property sheet.
 
 First, you can define conditions on single properties by using the `Condition` attribute: