diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
index b870d118fa..689a1762a3 100644
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -6,3 +6,6 @@ contact_links:
- name: .NET platform and other product feedback
url: https://developercommunity.visualstudio.com/spaces/61/index.html
about: Log product issues here
+ - name: .NET Breaking Change
+ url: https://github.com/dotnet/docs/issues/new?assignees=&labels=&template=dotnet-breaking-change.md&title=
+ about: Breaking changes are documented in the .NET docs repo.
diff --git a/.github/ISSUE_TEMPLATE/doc-issue.md b/.github/ISSUE_TEMPLATE/doc-issue.md
index c338d9e80c..e6a7b6b38b 100644
--- a/.github/ISSUE_TEMPLATE/doc-issue.md
+++ b/.github/ISSUE_TEMPLATE/doc-issue.md
@@ -5,32 +5,40 @@ about: Report a problem in the .NET documentation
**Before you open an issue**
+(Delete this section before you submit your issue)
+
If the issue is:
-- A simple typo or similar correction, consider submitting a PR to fix it instead of logging an issue. See [the contributor guide](https://docs.microsoft.com/contribute/#quick-edits-to-existing-documents) for instructions.
-- A general support question, consider asking on a support forum site.
-- A site design concern, create an issue at [MicrosoftDocs/feedback](https://github.com/MicrosoftDocs/feedback/issues/new/choose).
+- A simple typo or similar correction, consider submitting a PR to fix it instead of logging an issue. See https://docs.microsoft.com/contribute/#quick-edits-to-existing-documents for instructions
+
+- A general support question, consider asking on a support forum site such as StackOverflow.
+
+- A site design concern, create an issue at https://github.com/MicrosoftDocs/feedback/issues/new/choose
+
- A problem completing a tutorial, compare your code with the completed sample.
+
- A duplicate of an open or closed issue, leave a comment on that issue.
+(Delete the content above before you submit your issue)
+
**Issue description**
-<include description here>
+Include description here
-**Target framework**
+**.NET or .NET Framework**
-Check the .NET target framework(s) being used, and include the version number(s).
+Check the .NET target framework(s) being used, and include the version number(s). Put an `x` between the `[ ]` to check it.
-- [ ] .NET Core
+- [ ] .NET (5 or Core)
- [ ] .NET Framework
-- [ ] .NET Standard
-If using the .NET Core SDK, include `dotnet --info` output. If using .NET Framework without the .NET Core SDK, include info from Visual Studio's **Help** > **About Microsoft Visual Studio** dialog.
+**Technology**
+
+Check the .NET target framework(s) being used, and include the version number(s). Put an `x` between the `[ ]` to check it.
+
+- [ ] WPF
+- [ ] Windows Forms
-
-dotnet --info output or About VS info
+**.NET information**
-```console
-
-```
-
+If using the .NET SDK or .NET Core SDK, include `dotnet --info` output. If using .NET Framework without the .NET Core SDK, include info from Visual Studio's **Help** > **About Microsoft Visual Studio** dialog.
diff --git a/.github/ISSUE_TEMPLATE/dotnet-breaking-change.md b/.github/ISSUE_TEMPLATE/dotnet-breaking-change.md
deleted file mode 100644
index 0fbe711d67..0000000000
--- a/.github/ISSUE_TEMPLATE/dotnet-breaking-change.md
+++ /dev/null
@@ -1,92 +0,0 @@
----
-name: .NET Core breaking change
-about: Report a change in .NET Core that breaks something that worked in a previous version (intended mostly for product-team use)
----
-
-
-
-## [Change title]
-
-[Brief description of the change]
-
-### Version introduced
-
-[Version in which the breaking change first occurred (for example, 3.0 for .NET Core 3.0)]
-
-### Old behavior
-
-### New behavior
-
-### Reason for change
-
-### Recommended action
-
-[ Suggested steps if user is affected go here:
-- Possible workarounds
-- Example of code changes to handle change
-]
-
-### Category
-
-[Choose a category from one of the following:
-
-- ASP.NET Core
-- C#
-- Core .NET libraries
-- Cryptography
-- Data
-- Debugger
-- Deployment
-- Globalization
-- Interop
-- JIT
-- LINQ
-- Managed Extensibility Framework (MEF)
-- MSBuild
-- Networking
-- Printing
-- Security
-- Serialization
-- Visual Basic
-- Windows Forms
-- Windows Presentation Foundation (WPF)
-- XML, XSLT
-]
-
-### Affected APIs
-
-[ If no APIs are affected, this should read:
- "Not detectable via API analysis"
-
- If affected APIs are identifiable, include a link for each. The link takes the form:
-
- `[friendly description of API](link to API on docs.microsoft.com)`
-
- For example, `[String.IndexOf(String)](https://docs.microsoft.com/dotnet/api/system.string.indexof#System_String_IndexOf_System_String_)
-
- For methods, if all overloads are affected, link to the general overloaded method page. For example:
-
-
-
- Otherwise, link to the individual method overload. For example:
-
-
-
-]
-
-
-
----
-#### Issue metadata
-
-* Issue type: breaking-change
diff --git a/.openpublishing.publish.config.json b/.openpublishing.publish.config.json
index 2ce82fbb8e..7cc95d61ba 100644
--- a/.openpublishing.publish.config.json
+++ b/.openpublishing.publish.config.json
@@ -5,8 +5,7 @@
"build_source_folder": "dotnet-desktop-guide",
"build_output_subfolder": "dotnet-desktop-guide",
"locale": "en-us",
- "monikers": [],
- "moniker_ranges": [],
+ "moniker_ranges": ["netframeworkdesktop-4.8", "netdesktop-5.0"],
"filemap_share_depots": [
"VS.dotnet-api-docs"
],
diff --git a/README.md b/README.md
index 824a7c6d56..d7f27ae9b5 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,22 @@
-## Microsoft Open Source Code of Conduct
-This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
-For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.
\ No newline at end of file
+# .NET Desktop Guide docs
+
+
+
+This repository contains the conceptual documentation for .NET desktop technologies, such as Windows Presentation Foundation (WPF) and Windows Forms (WinForms). It's published at the [.NET Desktop Guide documentation site](https://docs.microsoft.com/dotnet/desktop).
+
+## Issues
+
+We have a large community using these resources. We make our best effort to respond to issues in a timely fashion. You can read more about our procedures for classifying and resolving issues in our [Issues policy](issues-policy.md) topic.
+
+We welcome contributions to help us improve and complete the .NET docs. This is a very large repo, covering a large area. If this is your first visit, see our [labels and projects roadmap](styleguide/labels-projects.md) for help navigating the issues and projects in this repository.
+
+## Migrate old examples
+
+If you're interested in helping migrate existing code that targets the .NET Framework (specifically WPF and WinForms) from the [retired Code Gallery](https://docs.microsoft.com/teamblog/msdn-code-gallery-retired) site to .NET Core applications stored in our [samples repository](https://github.com/dotnet/samples) and downloadable from the [Samples Browser](https://docs.microsoft.com/samples/browse), see the [Code Gallery migration](https://github.com/dotnet/docs/projects/88) project. The code gallery samples were moved to the [Microsoft Archive](https://github.com/microsoftarchive?q=msdn-code-gallery) organization.
+
+## Code of Conduct
+
+This project has adopted the code of conduct defined by the Contributor Covenant
+to clarify expected behavior in our community.
+
+For more information, see the [.NET Foundation Code of Conduct](https://dotnetfoundation.org/code-of-conduct).
diff --git a/dotnet-desktop-guide/TOC.yml b/dotnet-desktop-guide/TOC.yml
index b5ef71ac32..083f14ca85 100644
--- a/dotnet-desktop-guide/TOC.yml
+++ b/dotnet-desktop-guide/TOC.yml
@@ -1,2 +1,8 @@
-- name: Index
- href: index.md
\ No newline at end of file
+items:
+- name: Windows Forms
+ expanded: true
+ items:
+ - name: ".NET 5 (and .NET Core 3.1)"
+ href: https://docs.microsoft.com/dotnet/desktop/winforms/?view=netdesktop-5.0
+ - name: .NET Framework
+ href: https://docs.microsoft.com/dotnet/desktop/winforms/?view=netframework-4-8
diff --git a/dotnet-desktop-guide/breadcrumb/toc.yml b/dotnet-desktop-guide/breadcrumb/toc.yml
deleted file mode 100644
index 61d8fca61e..0000000000
--- a/dotnet-desktop-guide/breadcrumb/toc.yml
+++ /dev/null
@@ -1,3 +0,0 @@
-- name: Docs
- tocHref: /
- topicHref: /
\ No newline at end of file
diff --git a/dotnet-desktop-guide/docfx.json b/dotnet-desktop-guide/docfx.json
index 80159a3983..14d3c3a668 100644
--- a/dotnet-desktop-guide/docfx.json
+++ b/dotnet-desktop-guide/docfx.json
@@ -16,7 +16,53 @@
"README.md",
"LICENSE",
"LICENSE-CODE",
- "ThirdPartyNotices.md"
+ "ThirdPartyNotices.md",
+ "samples/**/*.*"
+ ],
+ "group": "framework",
+ "src": "framework"
+ },
+ {
+ "files": [
+ "**/*.md",
+ "**/*.yml"
+ ],
+ "exclude": [
+ "**/obj/**",
+ "**/includes/**",
+ "_themes/**",
+ "_themes.pdf/**",
+ "**/docfx.json",
+ "_repo.en-us/**",
+ "README.md",
+ "LICENSE",
+ "LICENSE-CODE",
+ "ThirdPartyNotices.md",
+ "samples/**/*.*"
+ ],
+ "group": "net",
+ "src": "net"
+ },
+ {
+ "files": [
+ "**/*.md",
+ "**/*.yml"
+ ],
+ "exclude": [
+ "framework",
+ "net",
+
+ "**/obj/**",
+ "**/includes/**",
+ "_themes/**",
+ "_themes.pdf/**",
+ "**/docfx.json",
+ "_repo.en-us/**",
+ "README.md",
+ "LICENSE",
+ "LICENSE-CODE",
+ "ThirdPartyNotices.md",
+ "samples/**/*.*"
]
}
],
@@ -33,7 +79,47 @@
"_themes/**",
"_themes.pdf/**",
"**/docfx.json",
- "_repo.en-us/**"
+ "_repo.en-us/**",
+ "samples/**/*.*"
+ ],
+ "group": "framework",
+ "src": "framework"
+ },
+ {
+ "files": [
+ "**/*.png",
+ "**/*.gif",
+ "**/*.jpg"
+ ],
+ "exclude": [
+ "**/obj/**",
+ "**/includes/**",
+ "_themes/**",
+ "_themes.pdf/**",
+ "**/docfx.json",
+ "_repo.en-us/**",
+ "samples/**/*.*"
+ ],
+ "group": "net",
+ "src": "net"
+ },
+ {
+ "files": [
+ "**/*.png",
+ "**/*.gif",
+ "**/*.jpg"
+ ],
+ "exclude": [
+ "framework",
+ "net",
+
+ "**/obj/**",
+ "**/includes/**",
+ "_themes/**",
+ "_themes.pdf/**",
+ "**/docfx.json",
+ "_repo.en-us/**",
+ "samples/**/*.*"
]
}
],
@@ -41,10 +127,12 @@
"externalReference": [],
"globalMetadata": {
"breadcrumb_path": "/dotnet/desktop/breadcrumb/toc.json",
- "extendBreadcrumb": true,
+ "extendBreadcrumb": false,
"feedback_system": "GitHub",
"feedback_github_repo": "dotnet/docs-desktop",
- "feedback_product_url": "https://developercommunity.visualstudio.com/spaces/61/index.html"
+ "feedback_product_url": "https://developercommunity.visualstudio.com/spaces/61/index.html",
+ "author": "adegeo",
+ "ms.author": "adegeo"
},
"fileMetadata": {
"titleSuffix": {
@@ -56,6 +144,16 @@
},
"template": [],
"dest": "dotnet-desktop-guide",
- "markdownEngineName": "markdig"
+ "markdownEngineName": "markdig",
+ "groups": {
+ "framework": {
+ "dest": "framework-dest",
+ "moniker_range": "netframeworkdesktop-4.8"
+ },
+ "net": {
+ "dest": "net-dest",
+ "moniker_range": "netdesktop-5.0"
+ }
+ }
}
}
\ No newline at end of file
diff --git a/dotnet-desktop-guide/framework/breadcrumb/toc.yml b/dotnet-desktop-guide/framework/breadcrumb/toc.yml
new file mode 100644
index 0000000000..1dac05392a
--- /dev/null
+++ b/dotnet-desktop-guide/framework/breadcrumb/toc.yml
@@ -0,0 +1,25 @@
+items:
+- name: Docs
+ tocHref: /
+ topicHref: /
+ items:
+ - name: .NET
+ tocHref: /dotnet/
+ topicHref: /dotnet/index
+ items:
+ - name: Desktop Guide
+ tocHref: /dotnet/desktop
+ topicHref: /dotnet/desktop/index
+ items:
+ - name: .NET Framework
+ items:
+ - name: Windows Forms
+ tocHref: /dotnet/desktop/winforms
+ topicHref: /dotnet/desktop/winforms/index
+ items:
+ - name: Enhance Windows Forms applications
+ tocHref: /dotnet/desktop/winforms/advanced/
+ topicHref: /dotnet/desktop/winforms/advanced/index
+ - name: Controls
+ tocHref: /dotnet/desktop/winforms/controls/
+ topicHref: /dotnet/desktop/winforms/controls/index
diff --git a/dotnet-desktop-guide/framework/winforms/additional-security-considerations-in-windows-forms.md b/dotnet-desktop-guide/framework/winforms/additional-security-considerations-in-windows-forms.md
new file mode 100644
index 0000000000..c42cd8c2f9
--- /dev/null
+++ b/dotnet-desktop-guide/framework/winforms/additional-security-considerations-in-windows-forms.md
@@ -0,0 +1,91 @@
+---
+title: "Additional Security Considerations"
+ms.date: "03/30/2017"
+helpviewer_keywords:
+ - "Windows Forms, secure calls to Windows API"
+ - "security [Windows Forms]"
+ - "security [Windows Forms], calling APIs"
+ - "Clipboard [Windows Forms], securing access"
+ms.assetid: 15abda8b-0527-47c7-aedb-77ab595f2bf1
+---
+# Additional Security Considerations in Windows Forms
+.NET Framework security settings might cause your application to run differently in a partial trust environment than on your local computer. The .NET Framework restricts access to such critical local resources as the file system, network, and unmanaged APIs, among other things. The security settings affect the ability to call the Microsoft Windows API or other APIs that cannot be verified by the security system. Security also affects other aspects of your application, including file and data access, and printing. For more information about file and data access in a partial trust environment, see [More Secure File and Data Access in Windows Forms](more-secure-file-and-data-access-in-windows-forms.md). For more information about printing in a partial trust environment, see [More Secure Printing in Windows Forms](more-secure-printing-in-windows-forms.md).
+
+ The following sections discuss how to work with the Clipboard, perform window manipulation, and call the Windows API from applications that are running in a partial trust environment.
+
+## Clipboard Access
+ The class controls access to the Clipboard, and the associated enumeration value indicates the level of access. The following table shows the possible permission levels.
+
+|UIPermissionClipboard value|Description|
+|---------------------------------|-----------------|
+||The Clipboard can be used without restriction.|
+||The Clipboard can be used with some restrictions. The ability to put data on the Clipboard (Copy or Cut command operations) is unrestricted. Intrinsic controls that accept paste, such as a text box, can accept Clipboard data, but user controls cannot programmatically read from the Clipboard.|
+||The Clipboard cannot be used.|
+
+ By default, the Local Intranet zone receives access and the Internet zone receives access. This means that the application can copy data to the Clipboard, but the application cannot programmatically paste to or read from the Clipboard. These restrictions prevent programs without full trust from reading content copied to the Clipboard by another application. If your application requires full Clipboard access but you do not have the permissions, you will have to elevate the permissions for your application. For more information about elevating permissions, see [General Security Policy Administration](https://docs.microsoft.com/previous-versions/dotnet/netframework-4.0/ed5htz45(v=vs.100)).
+
+## Window Manipulation
+ The class also controls permission to perform window manipulation and other UI-related actions, and the associated enumeration value indicates the level of access. The following table shows the possible permission levels.
+
+ By default, the Local Intranet zone receives access and the Internet zone receives access. This means that in the Internet zone, the application can perform most windowing and UI actions, but the window's appearance will be modified. The modified window displays a balloon notification when first run, contains modified title bar text, and requires a close button on the title bar. The balloon notification and the title bar identify to the user of the application that the application is running under partial trust.
+
+|UIPermissionWindow value|Description|
+|------------------------------|-----------------|
+||Users can use all windows and user input events without restriction.|
+||Users can use only safer top-level windows and safer subwindows for drawing, and can use only user input events for the user interface within those top-level windows and subwindows. These safer windows are clearly labeled and have minimum and maximum size restrictions. The restrictions prevent potentially harmful spoofing attacks, such as imitating system logon screens or the system desktop, and restricts programmatic access to parent windows, focus-related APIs, and use of the control,|
+||Users can use only safer subwindows for drawing, and can use only user input events for the user interface within that subwindow. A control displayed within a browser is an example of a safer subwindow.|
+||Users cannot use any windows or user interface events. No user interface can be used.|
+
+ Each permission level identified by the enumeration allows fewer actions than the level above it. The following tables indicate the actions that are restricted by the and values. For exact permissions that are required for each member, see the reference for that member in the .NET Framework class library documentation.
+
+ permission restricts the actions listed in the following table.
+
+|Component|Restricted actions|
+|---------------|------------------------|
+||- Setting the property.|
+||- Getting the property.
- Setting the `Region` property.
- Calling the , , and , , , or method.
- Calling the method if the control returned is not a child of the calling control.
- Modify control focus inside a container control.|
+||- Setting the property.
- Calling the method.|
+||- Calling the method.|
+||- Getting the or property.
- Setting the , , or property.
- Setting the property below 50%.
- Setting the property to programmatically.
- Calling the method.
- Using the , , and enumeration values.|
+||- Using the component is completely restricted.|
+
+ The value restricts the actions listed in the following table, in addition to the restrictions placed by the value.
+
+|Component|Restricted actions|
+|---------------|------------------------|
+||- Showing a dialog box derived from the class.|
+||- Calling the method.
- Setting the property.|
+||- Setting the property.|
+||- Calling the method.|
+
+### Hosting Third-Party Controls
+ Another kind of window manipulation can occur if your forms host third-party controls. A third-party control is any custom that you have not developed and compiled yourself. Although the hosting scenario is hard to exploit, it is theoretically possible for a third-party control to expand its rendering surface to cover the entire area of your form. This control could then mimic a critical dialog box, and request information such as username/password combinations or bank account numbers from your users.
+
+ To limit this potential risk, use third-party controls only from vendors you can trust. If you use third-party controls you have downloaded from an unverifiable source, we recommend that you review the source code for potential exploits. After you've verified that the source is non-malicious, you should compile the assembly yourself to ensure that the source matches the assembly.
+
+## Windows API Calls
+ If your application design requires calling a function from the Windows API, you are accessing unmanaged code. In this case the code's actions to the window or operating system cannot be determined when you are working with Windows API calls or values. The class and the value of the enumeration control access to unmanaged code. An application can access unmanaged code only when it is granted the permission. By default, only applications that are running locally can call unmanaged code.
+
+ Some Windows Forms members provide unmanaged access that requires the permission. The following table lists the members in the namespace that require the permission. For more information about the permissions that are required for a member, see the .NET Framework class library documentation.
+
+|Component|Member|
+|---------------|------------|
+||- method
- property
- `Exit` method
- method
- event|
+||- method
- \ method
- method
- method|
+||- method
- method
- method
- method|
+||- methods
- method|
+||- class|
+||- method|
+||- method
- method|
+
+ If your application does not have permission to call unmanaged code, your application must request permission, or you must consider alternative ways of implementing features; in many cases, Windows Forms provides a managed alternative to Windows API functions. If no alternative means exist and the application must access unmanaged code, you will have to elevate the permissions for the application.
+
+ Permission to call unmanaged code allows an application to perform most anything. Therefore, permission to call unmanaged code should only be granted for applications that come from a trusted source. Alternatively, depending on the application, the piece of application functionality that makes the call to unmanaged code could be optional, or enabled in the full trust environment only. For more information about dangerous permissions, see [Dangerous Permissions and Policy Administration](https://docs.microsoft.com/dotnet/framework/misc/dangerous-permissions-and-policy-administration). For more information about elevating permissions, see [General Security Policy Administration](https://docs.microsoft.com/previous-versions/dotnet/netframework-4.0/ed5htz45(v=vs.100)).
+
+## See also
+
+- [More Secure File and Data Access in Windows Forms](more-secure-file-and-data-access-in-windows-forms.md)
+- [More Secure Printing in Windows Forms](more-secure-printing-in-windows-forms.md)
+- [Security in Windows Forms Overview](security-in-windows-forms-overview.md)
+- [Windows Forms Security](windows-forms-security.md)
+- [Securing ClickOnce Applications](/visualstudio/deployment/securing-clickonce-applications)
diff --git a/dotnet-desktop-guide/framework/winforms/adjusting-the-size-and-scale-of-windows-forms.md b/dotnet-desktop-guide/framework/winforms/adjusting-the-size-and-scale-of-windows-forms.md
new file mode 100644
index 0000000000..84cee13e28
--- /dev/null
+++ b/dotnet-desktop-guide/framework/winforms/adjusting-the-size-and-scale-of-windows-forms.md
@@ -0,0 +1,35 @@
+---
+title: "Adjust the size and scale"
+ms.date: "04/07/2017"
+helpviewer_keywords:
+ - "Windows Forms, changing size"
+ - "Windows Forms, adjusting size"
+ - "Windows Forms, changing scale"
+ms.assetid: a014d2b3-3273-4521-95e1-00171033bf58
+---
+# Adjusting the size and scale of Windows Forms
+This topic provides links to information about resizing Windows Forms.
+
+## In This Section
+ [How to: Resize Windows Forms](how-to-resize-windows-forms.md)
+ Provides instructions for specifying the size of Windows Forms.
+
+ [Automatic Scaling in Windows Forms](automatic-scaling-in-windows-forms.md)
+ Discusses how automatic scaling enables a form and its controls to be displayed appropriately between machines.
+
+ [High DPI Support in Windows Forms](high-dpi-support-in-windows-forms.md)
+ Discusses Windows Forms' support for High DPI and dynamic scaling.
+
+## Reference
+
+ Describes this class and has links to all of its members.
+
+
+ Describes this class and has links to all of its members.
+
+
+ Describes this class and has links to all of its members.
+
+## Related sections
+ [Changing the appearance of Windows Forms](changing-the-appearance-of-windows-forms.md)
+ Provides links to topics describing other ways to change the appearance of Windows Forms.
diff --git a/dotnet-desktop-guide/framework/winforms/advanced/about-gdi-managed-code.md b/dotnet-desktop-guide/framework/winforms/advanced/about-gdi-managed-code.md
new file mode 100644
index 0000000000..8454c5fb06
--- /dev/null
+++ b/dotnet-desktop-guide/framework/winforms/advanced/about-gdi-managed-code.md
@@ -0,0 +1,61 @@
+---
+title: "About GDI+ Managed Code"
+ms.date: "03/30/2017"
+helpviewer_keywords:
+ - "GDI+, about GDI+"
+ - "GDI+"
+ - "graphics [Windows Forms], GDI+"
+ms.assetid: a98a76ab-e455-49c9-891c-0491ac932f2c
+---
+# About GDI+ Managed Code
+
+GDI+ is the portion of the Windows operating system that provides two-dimensional vector graphics, imaging, and typography. GDI+ improves on GDI (the Graphics Device Interface included with earlier versions of Windows) by adding new features and by optimizing existing features.
+
+The GDI+ managed class interface (a set of wrappers) is part of the .NET Framework, an environment for building, deploying, and running XML Web services and other applications.
+
+This section provides information about the GDI+ API for programmers using managed code.
+
+## In this section
+
+- [Lines, Curves, and Shapes](lines-curves-and-shapes.md)
+ Discusses vector graphics.
+
+- [Images, Bitmaps, and Metafiles](images-bitmaps-and-metafiles.md)
+ Discusses the type of images available and how to work with them.
+
+- [Coordinate Systems and Transformations](coordinate-systems-and-transformations.md)
+ Discusses how to transform graphics with GDI+.
+
+## Reference
+
+-
+ Describes this class and has links to all its members.
+
+-
+ Describes this class and has links to all its members.
+
+-
+ Describes this class and has links to all its members.
+
+-
+ Describes this class and has links to all its members.
+
+-
+ Describes this class and has links to all its members.
+
+-
+ Describes this class and has links to all its members.
+
+-
+ Describes this class and has links to all its members.
+
+-
+ Describes this class and has links to all its members.
+
+-
+ Describes this class and has links to all its members.
+
+## Related sections
+
+[Using Managed Graphics Classes](using-managed-graphics-classes.md)\
+Contains links to topics that demonstrate how to use the `Graphics` programming interface.
diff --git a/dotnet-desktop-guide/framework/winforms/advanced/alpha-blending-lines-and-fills.md b/dotnet-desktop-guide/framework/winforms/advanced/alpha-blending-lines-and-fills.md
new file mode 100644
index 0000000000..9c3a7696e4
--- /dev/null
+++ b/dotnet-desktop-guide/framework/winforms/advanced/alpha-blending-lines-and-fills.md
@@ -0,0 +1,37 @@
+---
+title: "Alpha Blending Lines and Fills"
+ms.date: "03/30/2017"
+helpviewer_keywords:
+ - "lines [Windows Forms], adding transparency"
+ - "examples [Windows Forms], alpha blending"
+ - "alpha blending [Windows Forms], using with lines"
+ - "alpha blending"
+ - "lines [Windows Forms], alpha blending"
+ - "fills [Windows Forms], alpha blending"
+ - "alpha blending [Windows Forms], using with fills"
+ - "shapes [Windows Forms], adding transparency"
+ms.assetid: 5440f48c-3ac9-44c3-b170-c1c110bdbab8
+---
+# Alpha Blending Lines and Fills
+In GDI+, a color is a 32-bit value with 8 bits each for alpha, red, green, and blue. The alpha value indicates the transparency of the color — the extent to which the color is blended with the background color. Alpha values range from 0 through 255, where 0 represents a fully transparent color, and 255 represents a fully opaque color.
+
+ Alpha blending is a pixel-by-pixel blending of source and background color data. Each of the three components (red, green, blue) of a given source color is blended with the corresponding component of the background color according to the following formula:
+
+ displayColor = sourceColor × alpha / 255 + backgroundColor × (255 – alpha) / 255
+
+ For example, suppose the red component of the source color is 150 and the red component of the background color is 100. If the alpha value is 200, the red component of the resultant color is calculated as follows:
+
+ 150 × 200 / 255 + 100 × (255 – 200) / 255 = 139
+
+## In This Section
+ [How to: Draw Opaque and Semitransparent Lines](how-to-draw-opaque-and-semitransparent-lines.md)
+ Shows how to draw alpha-blended lines.
+
+ [How to: Draw with Opaque and Semitransparent Brushes](how-to-draw-with-opaque-and-semitransparent-brushes.md)
+ Explains how to alpha-blend with brushes.
+
+ [How to: Use Compositing Mode to Control Alpha Blending](how-to-use-compositing-mode-to-control-alpha-blending.md)
+ Describes how to control alpha blending using .
+
+ [How to: Use a Color Matrix to Set Alpha Values in Images](how-to-use-a-color-matrix-to-set-alpha-values-in-images.md)
+ Explains how to use a object to control alpha blending.
diff --git a/dotnet-desktop-guide/framework/winforms/advanced/antialiasing-with-lines-and-curves.md b/dotnet-desktop-guide/framework/winforms/advanced/antialiasing-with-lines-and-curves.md
new file mode 100644
index 0000000000..36684a0007
--- /dev/null
+++ b/dotnet-desktop-guide/framework/winforms/advanced/antialiasing-with-lines-and-curves.md
@@ -0,0 +1,45 @@
+---
+title: "Antialiasing with Lines and Curves"
+ms.date: "03/30/2017"
+dev_langs:
+ - "csharp"
+ - "vb"
+helpviewer_keywords:
+ - "antialiasing"
+ - "antialiasing [Windows Forms], smoothing modes"
+ - "GDI+, antialiasing"
+ms.assetid: 810da1a4-c136-4abf-88df-68e49efdd8d4
+---
+# Antialiasing with Lines and Curves
+When you use GDI+ to draw a line, you provide the starting point and ending point of the line, but you do not have to provide any information about the individual pixels on the line. GDI+ works in conjunction with the display driver software to determine which pixels will be turned on to show the line on a particular display device.
+
+## Aliasing
+ Consider the straight red line that goes from the point (4, 2) to the point (16, 10). Assume the coordinate system has its origin in the upper-left corner and that the unit of measure is the pixel. Also assume that the x-axis points to the right and the y-axis points down. The following illustration shows an enlarged view of the red line drawn on a multicolored background.
+
+ 
+
+ The red pixels used to render the line are opaque. There are no partially transparent pixels in the line. This type of line rendering gives the line a jagged appearance, and the line looks somewhat like a staircase. This technique of representing a line with a staircase is called aliasing; the staircase is an alias for the theoretical line.
+
+## Antialiasing
+ A more sophisticated technique for rendering a line involves using partially transparent pixels along with opaque pixels. Pixels are set to pure red, or to some blend of red and the background color, depending on how close they are to the line. This type of rendering is called antialiasing and results in a line that the human eye perceives as more smooth. The following illustration shows how certain pixels are blended with the background to produce an antialiased line.
+
+ 
+
+ Antialiasing, also called smoothing, can also be applied to curves. The following illustration shows an enlarged view of a smoothed ellipse.
+
+ 
+
+ The following illustration shows the same ellipse in its actual size, once without antialiasing and once with antialiasing.
+
+ 
+
+ To draw lines and curves that use antialiasing, create an instance of the class and set its property to or . Then call one of the drawing methods of that same class.
+
+ [!code-csharp[LinesCurvesAndShapes#81](~/samples/snippets/csharp/VS_Snippets_Winforms/LinesCurvesAndShapes/CS/Class1.cs#81)]
+ [!code-vb[LinesCurvesAndShapes#81](~/samples/snippets/visualbasic/VS_Snippets_Winforms/LinesCurvesAndShapes/VB/Class1.vb#81)]
+
+## See also
+
+-
+- [Lines, Curves, and Shapes](lines-curves-and-shapes.md)
+- [How to: Use Antialiasing with Text](how-to-use-antialiasing-with-text.md)
diff --git a/dotnet-desktop-guide/framework/winforms/advanced/application-settings-architecture.md b/dotnet-desktop-guide/framework/winforms/advanced/application-settings-architecture.md
new file mode 100644
index 0000000000..19b2840185
--- /dev/null
+++ b/dotnet-desktop-guide/framework/winforms/advanced/application-settings-architecture.md
@@ -0,0 +1,151 @@
+---
+title: "Application Settings Architecture"
+ms.date: "03/30/2017"
+dev_langs:
+ - "csharp"
+ - "vb"
+helpviewer_keywords:
+ - "application settings [Windows Forms], architecture"
+ms.assetid: c8eb2ad0-fac6-4ea2-9140-675a4a44d562
+---
+# Application Settings Architecture
+This topic describes how the Application Settings architecture works, and explores advanced features of the architecture, such as grouped settings and settings keys.
+
+ The application settings architecture supports defining strongly typed settings with either application or user scope, and persisting the settings between application sessions. The architecture provides a default persistence engine for saving settings to and loading them from the local file system. The architecture also defines interfaces for supplying a custom persistence engine.
+
+ Interfaces are provided that enable custom components to persist their own settings when they are hosted in an application. By using settings keys, components can keep settings for multiple instances of the component separate.
+
+## Defining Settings
+ The application settings architecture is used within both ASP.NET and Windows Forms, and it contains a number of base classes that are shared across both environments. The most important is , which provides access to settings through a collection, and provides low-level methods for loading and saving settings. Each environment implements its own class derived from to provide additional settings functionality for that environment. In a Windows Forms-based application, all application settings must be defined on a class derived from the class, which adds the following functionality to the base class:
+
+- Higher-level loading and saving operations
+
+- Support for user-scoped settings
+
+- Reverting a user's settings to the predefined defaults
+
+- Upgrading settings from a previous application version
+
+- Validating settings, either before they are changed or before they are saved
+
+ The settings can be described using a number of attributes defined within the namespace; these are described in [Application Settings Attributes](application-settings-attributes.md). When you define a setting, you must apply it with either or , which describes whether the setting applies to the entire application or just to the current user.
+
+ The following code example defines a custom settings class with a single setting, `BackgroundColor`.
+
+ [!code-csharp[ApplicationSettings.Create#1](~/samples/snippets/csharp/VS_Snippets_Winforms/ApplicationSettings.Create/CS/MyAppSettings.cs#1)]
+ [!code-vb[ApplicationSettings.Create#1](~/samples/snippets/visualbasic/VS_Snippets_Winforms/ApplicationSettings.Create/VB/MyAppSettings.vb#1)]
+
+## Settings Persistence
+ The class does not itself persist or load settings; this job falls to the settings provider, a class that derives from . If a derived class of does not specify a settings provider through the , then the default provider, , is used.
+
+ The configuration system that was originally released with the .NET Framework supports providing static application configuration data through either the local computer's machine.config file or within an `app.`exe.config file that you deploy with your application. The class expands this native support in the following ways:
+
+- Application-scoped settings can be stored in either the machine.config or `app.`exe.config files. Machine.config is always read-only, while `app`.exe.config is restricted by security considerations to read-only for most applications.
+
+- User-scoped settings can be stored in `app`.exe.config files, in which case they are treated as static defaults.
+
+- Non-default user-scoped settings are stored in a new file, *user*.config, where *user* is the user name of the person currently executing the application. You can specify a default for a user-scoped setting with . Because user-scoped settings often change during application execution, `user`.config is always read/write.
+
+ All three configuration files store settings in XML format. The top-level XML element for application-scoped settings is ``, while `` is used for user-scoped settings. An `app`.exe.config file which contains both application-scoped settings and defaults for user-scoped settings would look like this:
+
+```xml
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Default
+
+
+ False
+
+
+
+
+
+
+ Form1
+
+
+ 595, 536
+
+
+
+
+```
+
+ For a definition of the elements within the application settings section of a configuration file, see [Application Settings Schema](https://docs.microsoft.com/dotnet/framework/configure-apps/file-schema/application-settings-schema).
+
+### Settings Bindings
+ Application settings uses the Windows Forms data binding architecture to provide two-way communication of settings updates between the settings object and components. If you use Visual Studio to create application settings and assign them to component properties, these bindings are generated automatically.
+
+ You can only bind an application setting to a component that supports the interface. Also, the component must implement a change event for a specific bound property, or notify application settings that the property has changed through the interface. If the component does not implement and you are binding through Visual Studio, the bound properties will be set the first time, but will not update. If the component implements but does not support property change notifications, the binding will not update in the settings file when the property is changed.
+
+ Some Windows Forms components, such as , do not support settings bindings.
+
+### Settings Serialization
+ When must save settings to disk, it performs the following actions:
+
+1. Uses reflection to examine all of the properties defined on your derived class, finding those that are applied with either or .
+
+2. Serializes the property to disk. It first attempts to call the or on the type's associated . If this does not succeed, it uses XML serialization instead.
+
+3. Determines which settings go in which files, based on the setting's attribute.
+
+ If you implement your own settings class, you can use the to mark a setting for either binary or custom serialization using the enumeration. For more information on creating your own settings class in code, see [How to: Create Application Settings](how-to-create-application-settings.md).
+
+### Settings File Locations
+ The location of the `app`.exe.config and *user*.config files will differ based on how the application is installed. For a Windows Forms-based application copied onto the local computer, `app`.exe.config will reside in the same directory as the base directory of the application's main executable file, and *user*.config will reside in the location specified by the property. For an application installed by means of ClickOnce, both of these files will reside in the ClickOnce Data Directory underneath %InstallRoot%\Documents and Settings\\*username*\Local Settings.
+
+ The storage location of these files is slightly different if a user has enabled roaming profiles, which enables a user to define different Windows and application settings when they are using other computers within a domain. In that case, both ClickOnce applications and non-ClickOnce applications will have their `app`.exe.config and *user*.config files stored under %InstallRoot%\Documents and Settings\\*username*\Application Data.
+
+ For more information about how the Application Settings feature works with the new deployment technology, see [ClickOnce and Application Settings](/visualstudio/deployment/clickonce-and-application-settings). For more information about the ClickOnce Data Directory, see [Accessing Local and Remote Data in ClickOnce Applications](/visualstudio/deployment/accessing-local-and-remote-data-in-clickonce-applications).
+
+## Application Settings and Security
+ Application settings are designed to work in partial trust, a restricted environment that is the default for Windows Forms applications hosted over the Internet or an intranet. No special permissions beyond partial trust are needed to use application settings with the default settings provider.
+
+ When application settings are used in a ClickOnce application, the `user`.config file is stored in the ClickOnce data directory. The size of the application's `user`.config file cannot exceed the data directory quota set by ClickOnce. For more information, see [ClickOnce and Application Settings](/visualstudio/deployment/clickonce-and-application-settings).
+
+## Custom Settings Providers
+ In the Application Settings architecture, there is a loose coupling between the applications settings wrapper class, derived from , and the associated settings provider or providers, derived from . This association is defined only by the applied to the wrapper class or its individual properties. If a settings provider is not explicitly specified, the default provider, , is used. As a result, this architecture supports creating and using custom settings providers.
+
+ For example, suppose that you want to develop and use `SqlSettingsProvider`, a provider that will store all settings data in a Microsoft SQL Server database. Your -derived class would receive this information in its `Initialize` method as a parameter of type . You would then implement the method to retrieve your settings from the data store, and to save them. Your provider can use the supplied to to determine the property's name, type, and scope, as well as any other settings attributes defined for that property.
+
+ Your provider will need to implement one property and one method whose implementations may not be obvious. The property is an abstract property of ; you should program it to return the following:
+
+ [!code-csharp[ApplicationSettings.Architecture#2](~/samples/snippets/csharp/VS_Snippets_Winforms/ApplicationSettings.Architecture/CS/DummyClass.cs#2)]
+ [!code-vb[ApplicationSettings.Architecture#2](~/samples/snippets/visualbasic/VS_Snippets_Winforms/ApplicationSettings.Architecture/VB/DummyProviderClass.vb#2)]
+
+ Your derived class must also implement an `Initialize` method that takes no arguments and returns no value. This method is not defined by .
+
+ Finally, you implement on your provider to provide support for refreshing settings, reverting settings to their defaults, and upgrading settings from one application version to another.
+
+ Once you have implemented and compiled your provider, you need to instruct your settings class to use this provider instead of the default. You accomplish this through the . If applied to an entire settings class, the provider is used for each setting that the class defines; if applied to individual settings, Application Settings architecture uses that provider for those settings only, and uses for the rest. The following code example shows how to instruct the settings class to use your custom provider.
+
+ [!code-csharp[ApplicationSettings.Architecture#1](~/samples/snippets/csharp/VS_Snippets_Winforms/ApplicationSettings.Architecture/CS/DummyClass.cs#1)]
+ [!code-vb[ApplicationSettings.Architecture#1](~/samples/snippets/visualbasic/VS_Snippets_Winforms/ApplicationSettings.Architecture/VB/DummyProviderClass.vb#1)]
+
+ A provider may be called from multiple threads simultaneously, but it will always write to the same storage location; therefore, the Application Settings architecture will only ever instantiate a single instance of your provider class.
+
+> [!IMPORTANT]
+> You should ensure that your provider is thread-safe, and only allows one thread at a time to write to the configuration files.
+
+ Your provider does not need to support all of the settings attributes defined in the namespace, though it must at a minimum support and , and should also support . For those attributes that it does not support, your provider should just fail without notification; it should not throw an exception. If the settings class uses an invalid combination of attributes, however — such as applying and to the same setting — your provider should throw an exception and cease operation.
+
+## See also
+
+-
+-
+-
+- [Application Settings Overview](application-settings-overview.md)
+- [Application Settings for Custom Controls](application-settings-for-custom-controls.md)
+- [ClickOnce and Application Settings](/visualstudio/deployment/clickonce-and-application-settings)
+- [Application Settings Schema](https://docs.microsoft.com/dotnet/framework/configure-apps/file-schema/application-settings-schema)
diff --git a/dotnet-desktop-guide/framework/winforms/advanced/application-settings-attributes.md b/dotnet-desktop-guide/framework/winforms/advanced/application-settings-attributes.md
new file mode 100644
index 0000000000..94e134a0a2
--- /dev/null
+++ b/dotnet-desktop-guide/framework/winforms/advanced/application-settings-attributes.md
@@ -0,0 +1,39 @@
+---
+title: "Application Settings Attributes"
+ms.date: "03/30/2017"
+helpviewer_keywords:
+ - "application settings [Windows Forms], attributes"
+ - "attributes [Windows Forms], application settings"
+ - "wrapper classes [Windows Forms], application settings"
+ms.assetid: 53caa66c-a9fb-43a5-953c-ad092590098d
+---
+# Application Settings Attributes
+The Application Settings architecture provides many attributes that can be applied either to the applications settings wrapper class or its individual properties. These attributes are examined at run time by the application settings infrastructure, often specifically the settings provider, in order to tailor its functioning to the stated needs of the custom wrapper.
+
+ The following table lists the attributes that can be applied to the application settings wrapper class, this class's individual properties, or both. By definition, only a single scope attribute—**UserScopedSettingAttribute** or **ApplicationScopedSettingAttribute**—must be applied to each and every settings property.
+
+> [!NOTE]
+> A custom settings provider, derived from the class, is only required to recognize the following three attributes: **ApplicationScopedSettingAttribute**, **UserScopedSettingAttribute**, and **DefaultSettingValueAttribute**.
+
+|Attribute|Target|Description|
+|---------------|------------|-----------------|
+||Both|Specifies the short name of the settings provider to use for persistence.
If this attribute is not supplied, the default provider, , is assumed.|
+||Both|Defines a property as a user-scoped application setting.|
+||Both|Defines a property as an application-scoped application setting.|
+||Property|Specifies a string that can be deserialized by the provider into the hard-coded default value for this property.
The does not require this attribute, and will override any value provided by this attribute if there is a value already persisted.|
+||Property|Provides the descriptive test for an individual setting, used primarily by run-time and design-time tools.|
+||Class|Provides an explicit name for a settings group. If this attribute is missing, uses the wrapper class name.|
+||Class|Provides the descriptive test for a settings group, used primarily by run-time and design-time tools.|
+||Both|Specifies zero or more manageability services that should be provided to the settings group or property. The available services are described by the enumeration.|
+||Property|Indicates that a setting belongs to a special, predefined category, such as a connection string, that suggests special processing by the settings provider. The predefined categories for this attribute are defined by the enumeration.|
+||Both|Specifies a preferred serialization mechanism for a settings group or property. The available serialization mechanisms are defined by the enumeration.|
+||Property|Specifies that a settings provider should disable all application upgrade functionality for the marked property.|
+
+ *Class* indicates that the attribute can be applied only to an application settings wrapper class. *Property* indicates that the attribute can be applied only settings properties. *Both* indicates that the attribute can be applied at either level.
+
+## See also
+
+-
+-
+- [Application Settings Architecture](application-settings-architecture.md)
+- [How to: Create Application Settings](how-to-create-application-settings.md)
diff --git a/dotnet-desktop-guide/framework/winforms/advanced/application-settings-for-custom-controls.md b/dotnet-desktop-guide/framework/winforms/advanced/application-settings-for-custom-controls.md
new file mode 100644
index 0000000000..381e92e6f4
--- /dev/null
+++ b/dotnet-desktop-guide/framework/winforms/advanced/application-settings-for-custom-controls.md
@@ -0,0 +1,46 @@
+---
+title: "Application Settings for Custom Controls"
+ms.date: "03/30/2017"
+helpviewer_keywords:
+ - "custom controls [Windows Forms], application settings"
+ - "application settings [Windows Forms], custom controls"
+ms.assetid: f44afb74-76cc-44f2-890a-44b7cdc211a1
+---
+# Application Settings for Custom Controls
+You must complete certain tasks to give your custom controls the ability to persist application settings when the controls are hosted in third-party applications.
+
+ Most of the documentation about the Application Settings feature is written under the assumption that you are creating a standalone application. However, if you are creating a control that other developers will host in their applications, you need to take a few additional steps for your control to persist its settings properly.
+
+## Application Settings and Custom Controls
+ For your control to properly persist its settings, it must encapsulate the process by creating its own dedicated applications settings wrapper class, derived from . Additionally, the main control class must implement the . The interface contains several properties as well as two methods, and . If you add your control to a form using the **Windows Forms Designer** in Visual Studio, Windows Forms will call automatically when the control is initialized; you must call yourself in the `Dispose` method of your control.
+
+ In addition, you should implement the following in order for application settings for custom controls to work properly in design-time environments such as Visual Studio:
+
+1. A custom application settings class with a constructor that takes an as a single parameter. Use this class to save and load all of your application settings. When you create a new instance of this class, pass your custom control using the constructor.
+
+2. Create this custom settings class after the control has been created and placed on a form, such as in the form's event handler.
+
+ For instructions on creating a custom settings class, see [How to: Create Application Settings](how-to-create-application-settings.md).
+
+## Settings Keys and Shared Settings
+ Some controls can be used multiple times within the same form. Most of the time, you will want these controls to persist their own individual settings. With the property on , you can supply a unique string that acts to disambiguate multiple versions of a control on a form.
+
+ The simplest way to implement is to use the property of the control for the . When you load or save the control's settings, you pass the value of on to the property of the class. Application Settings uses this unique key when it persists the user's settings to XML. The following code example shows how a `` section may look for an instance of a custom control named `CustomControl1` that saves a setting for its `Text` property.
+
+```xml
+
+
+
+ Hello, World
+
+
+
+```
+
+ Any instances of a control that do not supply a value for will share the same settings.
+
+## See also
+
+-
+-
+- [Application Settings Architecture](application-settings-architecture.md)
diff --git a/dotnet-desktop-guide/framework/winforms/advanced/application-settings-for-windows-forms.md b/dotnet-desktop-guide/framework/winforms/advanced/application-settings-for-windows-forms.md
new file mode 100644
index 0000000000..a806db7b36
--- /dev/null
+++ b/dotnet-desktop-guide/framework/winforms/advanced/application-settings-for-windows-forms.md
@@ -0,0 +1,40 @@
+---
+title: "Application Settings"
+ms.date: "04/07/2017"
+f1_keywords:
+ - "ClientApplicationSettings"
+helpviewer_keywords:
+ - "application settings [Windows Forms]"
+ - "Windows Forms, application settings"
+ms.assetid: 64090a34-8556-4904-8ea0-20efe9f8c886
+---
+# Application Settings for Windows Forms
+The Applications Settings feature of Windows Forms makes it easy to create, store, and maintain custom application and user preferences on the client. With Application Settings, you can store not only application data such as database connection strings, but also user-specific data, such as toolbar positions and most-recently used lists.
+
+## In This Section
+ [Application Settings Overview](application-settings-overview.md)
+ Discusses how to create and store settings data on behalf of your application and your users.
+
+ [Application Settings Architecture](application-settings-architecture.md)
+ Describes how the Application Settings feature works, and explores advanced features of the architecture such as grouped settings and settings keys.
+
+ [Application Settings Attributes](application-settings-attributes.md)
+ Lists and describes the attributes that can be applied to an application settings wrapper class or its settings properties.
+
+ [Application Settings for Custom Controls](application-settings-for-custom-controls.md)
+ Discusses what must be done to give your custom controls the ability to persist application settings when hosted in third-party applications.
+
+ [How to: Create Application Settings](how-to-create-application-settings.md)
+ Demonstrates creating new application settings that are persisted between application sessions.
+
+ [How to: Validate Application Settings](how-to-validate-application-settings.md)
+ Demonstrates validating application settings before they are persisted.
+
+## Related topics
+
+[Windows Forms Configuration Section](https://docs.microsoft.com/dotnet/framework/configure-apps/file-schema/winforms/index)
+Documents the settings to enable High DPI support in Windows Forms Application starting with the .NET Framework 4.7.
+
+## See also
+
+- [Windows Forms](../index.yml)
diff --git a/dotnet-desktop-guide/framework/winforms/advanced/application-settings-overview.md b/dotnet-desktop-guide/framework/winforms/advanced/application-settings-overview.md
new file mode 100644
index 0000000000..c1d2378801
--- /dev/null
+++ b/dotnet-desktop-guide/framework/winforms/advanced/application-settings-overview.md
@@ -0,0 +1,57 @@
+---
+title: "Application Settings Overview"
+description: Learn about the Application Settings feature of Windows Forms, for example how to create and store settings data on behalf of your application and your users.
+ms.date: "03/30/2017"
+f1_keywords:
+ - "ApplicationsSettingsOverview"
+helpviewer_keywords:
+ - "application settings [Windows Forms], about application settings"
+ - "dynamic properties"
+ - "user preferences [Windows Forms], tracking"
+ms.assetid: 0dd8bca5-a6bf-4ac4-8eec-5725d08b38dc
+---
+# Application Settings Overview
+
+This article discusses how to create and store settings data on behalf of your application and your users.
+
+ The Application Settings feature of Windows Forms makes it easy to create, store, and maintain custom application and user preferences on the client computer. With Windows Forms application settings, you can store not only application data such as database connection strings, but also user-specific data, such as user application preferences. Using Visual Studio or custom managed code, you can create new settings, read them from and write them to disk, bind them to properties on your forms, and validate settings data prior to loading and saving.
+
+ Application settings enables developers to save state in their application using very little custom code, and is a replacement for dynamic properties in previous versions of the .NET Framework. Application settings contains many improvements over dynamic properties, which are read-only, late-bound, and require more custom programming. The dynamic property classes have been retained in .NET Framework 2.0, but they are just shell classes that thinly wrap the application settings classes.
+
+## What Are Application Settings?
+ Your Windows Forms applications will often require data that's critical to running the application, but which you don't want to include directly in the application's code. If your application uses a Web Service or a database server, you may want to store this information in a separate file, so that you can change it in the future without recompiling. Similarly, your applications may require storing data that is specific to the current user. Most applications, for example, have user preferences that customize the application's appearance and behavior.
+
+ Application settings addresses both needs by providing an easy way to store both application-scoped and user-scoped settings on the client computer. Using Visual Studio or a code editor, you define a setting for a given property by specifying its name, data type, and scope (application or user). You can even place related settings into named groups for easier use and readability. Once defined, these settings are persisted and read back into memory automatically at run time. A pluggable architecture enables the persistence mechanism to be changed, but by default, the local file system is used.
+
+ Application settings works by persisting data as XML to different configuration (.config) files, corresponding to whether the setting is application-scoped or user-scoped. In most cases, the application-scoped settings are read-only; because they are program information, you will typically not need to overwrite them. By contrast, user-scoped settings can be read and written safely at run time, even if your application runs under partial trust. For more information about partial trust, see [Security in Windows Forms Overview](../security-in-windows-forms-overview.md).
+
+ Settings are stored as XML fragments in configuration files. Application-scoped settings are represented by the `` element, and generally are placed in *app*.exe.config, where *app* is the name of your main executable file. User-scoped settings are represented by the `` element and are placed in *user*.config, where *user* is the user name of the person currently running the application. You must deploy the *app*.exe.config file with your application; the settings architecture will create the *user*.config files on demand the first time the application saves settings for that user. You can also define a `` block within *app*.exe.config to provide default values for user-scoped settings.
+
+ Custom controls can also save their own settings by implementing the interface, which exposes the method. The Windows Forms control implements this interface to save the position of toolbars and toolbar items between application sessions. For more information about custom controls and application settings, see [Application Settings for Custom Controls](application-settings-for-custom-controls.md).
+
+## Limitations of Application Settings
+ You cannot use application settings in an unmanaged application that hosts the .NET Framework. Settings will not work in such environments as Visual Studio add-ins, C++ for Microsoft Office, control hosting in Internet Explorer, or Microsoft Outlook add-ins and projects.
+
+ You currently cannot bind to some properties in Windows Forms. The most notable example is the property, as binding to this property would cause unpredictable behavior at run time. You can usually work around these issues by saving and loading these settings programmatically.
+
+ Application settings has no built-in facility for encrypting information automatically. You should never store security-related information, such as database passwords, in clear text. If you want to store such sensitive information, you as the application developer are responsible for making sure it is secure. If you want to store connection strings, we recommend that you use Windows Integrated Security and not resort to hard-coding passwords into the URL. For more information, see [Code Access Security and ADO.NET](https://docs.microsoft.com/dotnet/framework/data/adonet/code-access-security).
+
+## Getting Started with Application Settings
+ If you use Visual Studio, you can define settings within the Windows Forms Designer using the **(ApplicationSettings)** property in the **Properties** window. When you define settings this way, Visual Studio automatically creates a custom managed wrapper class that associates each setting with a class property. Visual Studio also takes care of binding the setting to a property on a form or control so that the control's settings are restored automatically when its form is displayed, and saved automatically when the form is closed.
+
+ If you want more detailed control over your settings, you can define your own custom applications settings wrapper class. This is accomplished by deriving a class from , adding a property that corresponds to each setting, and applying special attributes to these properties. For details about creating wrapper classes, see [Application Settings Architecture](application-settings-architecture.md).
+
+ You can also use the class to bind settings programmatically to properties on forms and controls.
+
+## See also
+
+-
+-
+-
+-
+- [How to: Validate Application Settings](how-to-validate-application-settings.md)
+- [Managing Application Settings (.NET)](/visualstudio/ide/managing-application-settings-dotnet)
+- [How To: Read Settings at Run Time With C#](how-to-read-settings-at-run-time-with-csharp.md)
+- [Using Application Settings and User Settings](using-application-settings-and-user-settings.md)
+- [Application Settings Architecture](application-settings-architecture.md)
+- [Application Settings for Custom Controls](application-settings-for-custom-controls.md)
diff --git a/dotnet-desktop-guide/framework/winforms/advanced/bezier-splines-in-gdi.md b/dotnet-desktop-guide/framework/winforms/advanced/bezier-splines-in-gdi.md
new file mode 100644
index 0000000000..2c4ff29e5f
--- /dev/null
+++ b/dotnet-desktop-guide/framework/winforms/advanced/bezier-splines-in-gdi.md
@@ -0,0 +1,41 @@
+---
+title: "Bézier Splines in GDI+"
+ms.date: "03/30/2017"
+dev_langs:
+ - "csharp"
+ - "vb"
+helpviewer_keywords:
+ - "Bezier splines"
+ - "splines [Windows Forms], Bezier"
+ - "GDI+, Bezier splines"
+ms.assetid: 5774ce1e-87d4-4bc7-88c4-4862052781b8
+---
+# Bézier Splines in GDI+
+A Bézier spline is a curve specified by four points: two end points (p1 and p2) and two control points (c1 and c2). The curve begins at p1 and ends at p2. The curve does not pass through the control points, but the control points act as magnets, pulling the curve in certain directions and influencing the way the curve bends. The following illustration shows a Bézier curve along with its endpoints and control points.
+
+ 
+
+ The curve starts at p1 and moves toward the control point c1. The tangent line to the curve at p1 is the line drawn from p1 to c1. The tangent line at the endpoint p2 is the line drawn from c2 to p2.
+
+## Drawing Bézier Splines
+ To draw a Bézier spline, you need an instance of the class and a . The instance of the class provides the method, and the stores attributes, such as width and color, of the line used to render the curve. The is passed as one of the arguments to the method. The remaining arguments passed to the method are the endpoints and the control points. The following example draws a Bézier spline with starting point (0, 0), control points (40, 20) and (80, 150), and ending point (100, 10):
+
+ [!code-csharp[LinesCurvesAndShapes#71](~/samples/snippets/csharp/VS_Snippets_Winforms/LinesCurvesAndShapes/CS/Class1.cs#71)]
+ [!code-vb[LinesCurvesAndShapes#71](~/samples/snippets/visualbasic/VS_Snippets_Winforms/LinesCurvesAndShapes/VB/Class1.vb#71)]
+
+ The following illustration shows the curve, the control points, and two tangent lines.
+
+ 
+
+ Bézier splines were originally developed by Pierre Bézier for design in the automotive industry. They have since proven to be useful in many types of computer-aided design and are also used to define the outlines of fonts. Bézier splines can yield a wide variety of shapes, some of which are shown in the following illustration.
+
+ 
+
+## See also
+
+-
+-
+- [Lines, Curves, and Shapes](lines-curves-and-shapes.md)
+- [Constructing and Drawing Curves](constructing-and-drawing-curves.md)
+- [How to: Create Graphics Objects for Drawing](how-to-create-graphics-objects-for-drawing.md)
+- [How to: Create a Pen](how-to-create-a-pen.md)
diff --git a/dotnet-desktop-guide/framework/winforms/advanced/bi-directional-support-for-windows-forms-applications.md b/dotnet-desktop-guide/framework/winforms/advanced/bi-directional-support-for-windows-forms-applications.md
new file mode 100644
index 0000000000..7f233250d5
--- /dev/null
+++ b/dotnet-desktop-guide/framework/winforms/advanced/bi-directional-support-for-windows-forms-applications.md
@@ -0,0 +1,114 @@
+---
+title: Bi-Directional Support
+ms.date: "09/30/2017"
+helpviewer_keywords:
+ - "globalization [Windows Forms], bi-directional support in Windows"
+ - "Windows Forms, international"
+ - "localization [Windows Forms], bi-directional support in Windows"
+ - "bi-directional language support [Windows Forms], Windows applications"
+ - "Windows Forms, bi-directional support"
+---
+# Bi-Directional Support for Windows Forms Applications
+You can use Visual Studio to create Windows-based applications that support bi-directional (right-to-left) languages such as Arabic and Hebrew. This includes standard forms, dialog boxes, MDI forms, and all the controls you can work with in these forms—that is, all the objects in the namespace.
+
+## Culture Support
+ Culture and UI culture settings determine how an application works with dates, times, currency, and other information. Support for culture and UI culture is the same for bi-directional languages as it is for any other languages. For more information, see [Culture-specific classes for global Windows forms and web forms](/visualstudio/ide/globalizing-and-localizing-applications).
+
+## RightToLeft and RightToLeftLayout Properties
+ The base class, from which forms derive, includes a property that you can set to change the reading order of a form and its controls. If you set the form's property, by default controls on the form inherit this setting. However, you can also set the property individually on most controls. Also see [How to: Display Right-to-Left Text in Windows Forms for Globalization](https://docs.microsoft.com/previous-versions/visualstudio/visual-studio-2010/7d3337xw(v=vs.100)).
+
+ The effect of the property can differ from one control to another. In some controls the property only sets the reading order, as in the , and controls. In other controls, the property changes both reading order and layout. This includes the , and controls. Other controls require that the property be applied to mirror its layout from right to left. The following table provides details on how the and properties affect individual Windows Forms controls.
+
+|Control/Component|Effect of RightToLeft property|Effect of RightToLeftLayout property|Requires mirroring?|
+|------------------------|------------------------------------|------------------------------------------|-------------------------|
+||Sets the RTL reading order. Reverses