Updates to documentation

Author: cwensley

.editorconfig

@@ -37,7 +37,7 @@ indent_size = 2
 
 [*.md]
 indent_style = space
-indent_size = 4
+indent_size = 2
 
 [*.{cs,vb}]
 # Indentation style/size

.github/workflows/publish-docs.yml

@@ -35,17 +35,17 @@ jobs:
         with:
           docfx-file-path: "docs/docfx.json"
 
-      - name: Push files to target repo
+      - name: Checkout target repository
         uses: actions/checkout@v4
         with:
           repository: picoe/Eto.Support 
           token: ${{ secrets.PUBLISH_DOCS_PAT }}
           path: target-repo
 
-      - name: Copy files
+      - name: Copy files to target repository
         run: |
           rm -rf ./target-repo/docs/*
-          cp -r ./artifacts/docs/* ./target-repo/docs/
+          cp -R ./artifacts/docs/_site/* ./target-repo/docs/
 
       - name: Commit and push changes
         run: |

.vscode/tasks.json

@@ -182,16 +182,22 @@
 			"command": "docfx docfx.json --serve",
 			"problemMatcher": "$msCompile",
 			"options": {
-				"cwd": "${workspaceFolder}/docs"
+				"cwd": "${workspaceFolder}/docs",
+			},
+			"presentation": {
+				"clear": true
 			}
 		},
 		{
 			"label": "docfx-build",
 			"type": "shell",
-			"command": "docfx build docfx.json",
+			"command": "docfx ${input:docfx-config} docfx.json",
 			"problemMatcher": "$msCompile",
 			"options": {
 				"cwd": "${workspaceFolder}/docs"
+			},
+			"presentation": {
+				"clear": true
 			}
 		}
 	],
@@ -219,6 +225,15 @@
 			"id": "version",
 			"description": "Enter the version to update to",
 			"default": "2.5.x-dev"
-		}
+		},
+		{
+			"type": "pickString",
+			"id": "docfx-config",
+			"description": "Docfx Configuration",
+			"options": [
+				"build",
+				"metadata"
+			]
+		},
 	]
 }

README.md

@@ -5,7 +5,7 @@
 [![Build](https://github.com/picoe/Eto/actions/workflows/build.yml/badge.svg)](https://github.com/picoe/Eto/actions/workflows/build.yml)
 [![discussions](https://img.shields.io/badge/join-the%20discussions-yellowgreen.svg)](https://github.com/picoe/Eto/discussions)
 [![Gitter](https://img.shields.io/gitter/room/nwjs/nw.js.svg)](https://gitter.im/picoe/Eto)
-[![wiki](https://img.shields.io/badge/browse-the%20wiki-orange.svg)](https://github.com/picoe/Eto/wiki)
+[![docs](https://img.shields.io/badge/browse-the%20docs-orange.svg)](http://pages.picoe.ca/docs/docs)
 [![NuGet](http://img.shields.io/nuget/v/Eto.Forms.svg?style=flat)](https://www.nuget.org/packages/Eto.Forms/)
 [![MyGet](http://img.shields.io/myget/eto/vpre/Eto.Forms.svg?style=flat&label=MyGet)](https://www.myget.org/gallery/eto)
 
@@ -65,9 +65,9 @@ form.Show()
 
 ## Getting Started
 
-To begin creating apps using Eto.Forms, follow the [Quick Start Guide](https://github.com/picoe/Eto/wiki/Quick-Start).
+To begin creating apps using Eto.Forms, follow the [Quick Start Guide](http://pages.picoe.ca/docs/docs/Quick-Start.html).
 
-To compile or contribute to Eto.Forms, read the [Contributing Guide](https://github.com/picoe/Eto/wiki/Contributing).
+To compile or contribute to Eto.Forms, read the [Contributing Guide](http://pages.picoe.ca/docs/docs/Contributing.html).
 
 ## Screenshots
 
@@ -118,7 +118,7 @@ Linux via GTK#3:
 
 ## Assemblies
 
-Your project only needs to reference Eto.dll, and include the corresponding platform assembly that you wish to target. To run on a Mac platform, you need to [bundle your app](https://github.com/picoe/Eto/wiki/Running-your-application).
+Your project only needs to reference Eto.dll, and include the corresponding platform assembly that you wish to target. To run on a Mac platform, you need to [bundle your app](http://pages.picoe.ca/docs/docs/Running-your-application.html).
 
 * Eto.dll - Eto.Forms (UI), Eto.Drawing (Graphics), and platform loading
 * Eto.Mac64.dll - Lightweight Mac platform using .NET 6+ or mono

docs/docfx.json

@@ -4,9 +4,11 @@
     {
       "src": [
         {
-          "src": "../src/Eto",
+          "src": "../src/",
           "files": [
-            "**/*.csproj"
+            "Eto/Eto.csproj",
+            "Eto.Serialization.Xaml/Eto.Serialization.Xaml.csproj",
+            "Eto.Serialization.Json/Eto.Serialization.Json.csproj"
           ]
         }
       ],
@@ -21,15 +23,15 @@
 		  "../README.md"
         ],
         "exclude": [
-          "_site/**"
+          "_site/**",
+		  "filterConfig*.yml"
         ]
       }
     ],
     "resource": [
       {
         "files": [
-          "images/**",
-		  "favicon.ico"
+          "images/**"
         ]
       }
     ],
@@ -42,7 +44,7 @@
       "_appName": "Eto.Forms",
       "_appTitle": "Eto.Forms",
       "_enableSearch": true,
-	  "_appFaviconPath": "favicon.ico",
+	  "_appFaviconPath": "images/logo.svg",
 	  "_appLogoPath": "images/logo.svg"
     }
 

docs/docs/Mac-Code-Signing-and-Notarization.md

@@ -2,12 +2,12 @@
 
 In order for you to distribute your Mac applications, you need to code sign and notarize them.  More information about this can be found [here](https://developer.apple.com/documentation/security/notarizing_macos_software_before_distribution).  Code signing and notarization require Xcode tools, so this can only be done on a Mac.
 
-Eto.Forms provides msbuild targets that will automatically code sign and notarize your software during the build process.  These are the steps to follow to get it going:
+Eto.Forms provides msbuild targets that will automatically code sign and notarize your software during the build process for the Mac64 platform target.  These are the steps to follow to get it going:
 
 1. Get an [Apple developer account](https://developer.apple.com/programs/enroll/).
 2. Import your code signing and notarization certificates.  For GitHub Actions, [`apple-actions/import-codesign-certs`](https://github.com/apple-actions/import-codesign-certs) has been used with success.
-3. (Optional) create an app-specific password for your apple developer account [here](https://appleid.apple.com/account/manage) to use for notarization
-4. Store your apple notarization credentials in the keychain using altool with the name AC_PASSWORD (replace the ${{ secrets.* }} with the appropriate values, or add the secrets to your GitHub Actions project or organization):
+3. (Optional) create an app-specific password for your [apple developer account](https://appleid.apple.com/account/manage) to use for notarization
+4. Store your apple notarization credentials in the keychain using altool with the name `AC_PASSWORD` (replace `${{ secrets.* }}` with the appropriate values, or add the secrets to your GitHub Actions project or organization):
 
     ```sh
     xcrun altool --store-password-in-keychain-item "AC_PASSWORD" -u "${{ secrets.AC_USERNAME }}" -p "${{ secrets.AC_PASSWORD }}"
@@ -29,4 +29,4 @@ Eto.Forms provides msbuild targets that will automatically code sign and notariz
     dotnet build -c Release MyProject.Mac/MyProject.Mac.csproj
     ```
 
-Note that notarization can take a while to get results for stapling the .dmg.  If your app is not stapled it will still run on users machines when connected to the internet. You can disable stapling by setting the `EnableNotarizationStapler` property.  E.g. `<EnableNotarizationStapler>False</EnableNotarizationStapler>`
+Note that notarization can take a while to get results for stapling the .dmg.  If your app is not stapled it will still run on users machines when connected to the internet. You can disable stapling by setting the `EnableNotarizationStapler` property.  E.g. `<EnableNotarizationStapler>False</EnableNotarizationStapler>`

docs/docs/Publishing-your-app.md

@@ -1,52 +1,63 @@
+# Publishing Your Eto.Forms Application
+
 Publishing your app can be quite different depending on the OS you're publishing to.
 
 ## Publish for Windows
+
 Simply compile your Wpf or Winforms project in the IDE of your choice, or compile it with `dotnet build` from the command line.
 
-Compiling for Windows can **only** be done from Windows. Mac and Linux are unable to compile Wpf / Winform projects.
+To compile WPF and WinForms on Mac or Linux, you can add `<EnableWindowsTargeting>true</EnableWindowsTargeting>` to your project properties.
+
+To distribute your application to users, an MSI or MSIX installer is the usual mechanism.  You can follow [Microsoft's guide](https://learn.microsoft.com/en-us/windows/msix/desktop/desktop-to-uwp-packaging-dot-net) on how to set that up.
 
 ## Publish for Linux
+
 Simply compile your Gtk project in the IDE of your choice, or compile it with `dotnet build` from the command line.  
 Please keep the following notes in mind:
+
 - If you compile from Windows, due to NTFS not supporting executable file bits, users will first have to mark the application as executable. This can either be done via a command line with `chmod +x MyApp.Gtk`, or by **right-clicking -> Properties -> Permissions -> Mark as executable**.
+
 - On distros using GNOME as their DE (Ubuntu, Fedora etc.) your icon will not be displayed unless you provide a .desktop file along with it. For details on how to write one, consult the following documentation pages:
-    - https://specifications.freedesktop.org/desktop-entry-spec/latest/
-    - https://wiki.archlinux.org/title/Desktop_entries
-    - https://help.ubuntu.com/community/UnityLaunchersAndDesktopFiles
+  - <https://specifications.freedesktop.org/desktop-entry-spec/latest/>
+  - <https://wiki.archlinux.org/title/Desktop_entries>
+  - <https://help.ubuntu.com/community/UnityLaunchersAndDesktopFiles> 
+
 - Users will have to install dependencies to run your program first. This includes: [the .NET Core runtime version of the project you're using](https://docs.microsoft.com/en-us/dotnet/core/install/linux) **or** mono if you're using .NET Framework, `gtk3`, `webkitgtk`, `openssl`, `icu` and `libappindicator`. The latter 5 should be preinstalled on most distros, but this isn't a guarantee.  
 NOTE FOR DEBIAN USERS: Debian 11 "bullseye" removed `libappindicator` from their package repos, and their alternative `libayatana-appindicator` currently does not work with Eto. They can circumvent this by going [here](https://packages.debian.org/buster/amd64/libappindicator3-1/download) to either install `libappindicator` from there or follow the instructions listed there to add the "buster" repos to their package manager
+
 - If you want to package the dependencies with your app, you have a few choices:
-    - Create distro-specific packaging formats.
-        - For .deb's (Debian and Ubuntu based) packages, you can consult this guide: https://www.internalpointers.com/post/build-binary-deb-package-practical-guide  
+  - Create distro-specific packaging formats.
+    - For .deb's (Debian and Ubuntu based) packages, you can consult this guide: <https://www.internalpointers.com/post/build-binary-deb-package-practical-guide>  
           Note that you likely need different .deb files for Debian and Ubuntu, due to them having different package names
-        - For .rpm's (Red Hat based) packages, you can consult Red Hat's documentation: https://www.redhat.com/sysadmin/create-rpm-package
-    - Create a universal packaging format:  
-        - For AppImage, a one file click-and-run distribution method, see their guides here: https://github.com/AppImage/AppImageKit/wiki/Bundling-.NET-Core-apps
-        - For Flatpaks, a sandboxed environment for your application, install-able via a package manger, consult their guide here:  https://docs.flatpak.org/en/latest/first-build.html  
+    - For .rpm's (Red Hat based) packages, you can consult Red Hat's documentation: https://www.redhat.com/sysadmin/create-rpm-package
+  
+  - Create a universal packaging format:  
+    - For AppImage, a one file click-and-run distribution method, see their guides here: <https://github.com/AppImage/AppImageKit/wiki/Bundling-.NET-Core-apps>
+    - For Flatpaks, a sandboxed environment for your application, install-able via a package manger, consult their guide here:  <https://docs.flatpak.org/en/latest/first-build.html>  
 
       Note that on Linux it's preferred to not have duplicate dependencies. So while universal packaging formats with .NET Core bundled might be tempting, try to create distro-specific package formats that specify .NET Core as a dependency if it's possible. Unfortunately, this isn't always possible as some distos (Debian or Ubuntu for example) don't have it in their package repos.
 
 ## Publish for Mac
-Simply compile your Mac project in the IDE of your choice, or compile it with `dotnet build` from the command line.  
-If you use a Xamarin.Mac or a `Eto.Platforms.macOS` project, it can only be compiled from MacOS.
 
-It is worth noting, that for a `Eto.Platforms.macOS` project you need to ensure the following:
+Simply compile your Mac project in the IDE of your choice, or compile it with `dotnet build` from the command line.
+
+For `Eto.Platform.Mac64` platform targets, see [Mac Code Signing and Notarization](./Mac-Code-Signing-and-Notarization.md) page for more information on packaging your app for distribution, including codesigning, notarization, and bundling in a .dmg.
+
+If you use a `Eto.Platforms.macOS` project, it can only be compiled (fully) from MacOS. It is worth noting that you need to ensure the following:
+
 - That you have the macos dotnet workload installed. If you don't, you can install it via `dotnet workload install macos`.
 - That your project's output type is `Exe` and not `WinExe` as it otherwise won't compile
 - That your project's TFM has a `-macos` suffix (i.e. `net6.0-macos`)
 - That your RID is set to `osx-x64;osx-arm64` if you want to support both Intel and M1 Macs
 - That your project's `csproj` contains a `SupportedOSPlatformVersion` attribute, which should be set to the same version as the `LSMinimumSystemVersion` attribute in your `plist` file.
 
 If you compile from Windows, due to NTFS not supporting executable file bits, users will first have to mark the application as executable. This can either be done via a command line with:
+
 ```sh
 chmod +x MyApplication.Desktop.app/Contents/MacOS/MyApplication.Desktop
 xattr -c MyApplication.Desktop.app
-
 ```
 
-In order to distribute your apps to run on the Mac they should be [code signed and notarized](https://developer.apple.com/developer-id/).  Details on how to do that via command line are [here for code signing](https://developer.apple.com/library/archive/documentation/Security/Conceptual/CodeSigningGuide/Procedures/Procedures.html#//apple_ref/doc/uid/TP40005929-CH4-SW2) and [here for notarization](https://developer.apple.com/documentation/xcode/notarizing_macos_software_before_distribution/customizing_the_notarization_workflow). See [#Mac-Code-Signing-and-Notarization](https://github.com/picoe/Eto/wiki/Mac-Code-Signing-and-Notarization) page for more information.
+In order to distribute your apps to run on the Mac they should be [code signed and notarized](https://developer.apple.com/developer-id/).  Details on how to do that via command line are [here for code signing](https://developer.apple.com/library/archive/documentation/Security/Conceptual/CodeSigningGuide/Procedures/Procedures.html#//apple_ref/doc/uid/TP40005929-CH4-SW2) and [here for notarization](https://developer.apple.com/documentation/xcode/notarizing_macos_software_before_distribution/customizing_the_notarization_workflow).
 
 You should also package your app in a .dmg or .pkg for distribution. [This site](https://www.recitalsoftware.com/blogs/148-howto-build-a-dmg-file-from-the-command-line-on-mac-os-x) has some good details on how to do that.
-
-For Mac64 targets, it's recommended to publish your app as a [self-contained](https://docs.microsoft.com/en-us/dotnet/core/deploying/#publish-self-contained) application if you intend to have M1 support.
-For unified builds, [single-file](https://docs.microsoft.com/en-us/dotnet/core/deploying/single-file/overview) deployment is needed as well.

docs/docs/Running-your-application.md

@@ -1,26 +1,32 @@
+# Running Your Application
+
 To run your application, you will need to include one or more of the platform nuget packages in your executable project.
 
 **For Windows:**
+
 - [Eto.Platform.Wpf](https://www.nuget.org/packages/Eto.Platform.Wpf/): for Windows Presentation Foundation (recommended)
 - [Eto.Platform.Windows](https://www.nuget.org/packages/Eto.Platform.Windows/): for Windows Forms
 
 **For Linux / Unix:**
+
 - [Eto.Platform.Gtk](https://www.nuget.org/packages/Eto.Platform.Gtk/): for Gtk 3.14+ and includes Gtk# assemblies as nuget dependencies (recommended)
 - [Eto.Platform.Gtk2](https://www.nuget.org/packages/Eto.Platform.Gtk2/): for Gtk# 2.12, and requires gtk-sharp2
 - [Eto.Platform.Gtk3](https://www.nuget.org/packages/Eto.Platform.Gtk3/): for Gtk# 3.0 and requires gtk-sharp3
 
-**For macOS:** 
+**For macOS:**
 
 - [Eto.Platform.Mac64](https://www.nuget.org/packages/Eto.Platform.Mac64/): 64-bit via MonoMac (recommended)
-- [Eto.Platform.XamMac2](https://www.nuget.org/packages/Eto.Platform.XamMac2/): For Xamarin.Mac unified mobile or full projects (recommended)
+- [Eto.Platform.macOS](https://www.nuget.org/packages/Eto.Platform.macOS/): using .NET Core's macos workload (recommended)
 
-The Eto.Platform.Mac64 nuget package will create an .app bundle (or folder) in the project output directory, even when built on non-mac platforms. In release builds it will bundle mono or .NET Core, which you can override using `<MacBundleMono>` or `<MacBundleDotNet>` properties in your .csproj, which allows the application to run without installing any dependencies. Note that if you build on Windows then copy to macOS you need to perform the following steps after copying:
+The `Eto.Platform.Mac64` platform target will create an .app bundle (or folder) in the project output directory, even when built on non-mac platforms. In release builds it will bundle the .NET Core runtime, which you can override using `<MacBundleDotNet>` property in your .csproj, which allows the application to run without installing any dependencies. Note that if you build on Windows then copy to macOS you need to perform the following steps after copying:
 
 ```bash
 > chmod +x YourApp.app/Contents/MacOS/YourApp # set the executable bit
 > xattr -c YourApp.app # Clear the extended attributes of the .app
 ```
 
-If you use a [Xamarin.Mac](http://xamarin.com) project, it automatically bundles the mono framework inside the .app as well.  However, it can only be built on a Mac using VS for Mac.  This is required if you want your app to be published on the Mac App Store.
+The `Eto.Platform.macOS` platform target will also automatically bundle the .NET Core runtime inside the .app.  However, it can only be built on a Mac.
+
+## Next Steps
 
-To distribute your app for macOS (even without publishing to the App Store), you need to code sign and notarize your application, otherwise your users will need to execute the `xattr -c` command above on macOS Catalina 10.15 or later.
+After building and testing your application, you can follow the [Publishing Your Application](./Publishing-your-app.md) to learn how to distribute the application to users.

docs/docs/controls/PixelLayout.md

@@ -2,7 +2,7 @@
 
 The Pixel Layout provides a way to position your controls based on pixel co-ordinates.
 
-*Note*: Using the pixel layout to position standard controls is highly discouraged, as each control may be different sizes based on the platform. It is highly recommended to use the [[TableLayout]] or [[DynamicLayout]] when using standard controls, as they will auto fit to the size of each control.
+*Note*: Using the pixel layout to position standard controls is highly discouraged, as each control may be different sizes based on the platform. It is highly recommended to use the [TableLayout](TableLayout.md) or [DynamicLayout](DynamicLayout.md) when using standard controls, as they will auto fit to the size of each control.
 
 ```c#
 using Eto.Forms;