The way to do this in Windows XP has been to use the "All Users" account and add to the desktop folder.  The process is the same for Windows Vista, but "All Users" has been renamed "Public" and the "Desktop" folder is hidden by default.

To create shortcuts for everyone either

• Open Windows Explorer (Easiest way is Windows key + e)
• Type "C:\Users\Public\Desktop" directly
• Add shortcut to this folder

Or unhide all the folders and navigate there

• Open Windows Explorer (Easiest way is  Windows key + e)
• Press Alt to show the menu
• Open Tools->Folder options menu
• Select View tab
• For the Hidden Files and folders option check "show hidden files and folders"
• Now navigate to c:\users\public\desktop, you'll actually see it but it's ghosted out (because it's a hidden folder).
• Add shortcut to this folder

I'm sure there's a million other ways to do this -- but I hope this helps!

• DataSources window now works in Silverlight (as well as WPF) - you can now drag and drop from this window to your design surface to automatically hook up to data.
• Property Inspector window gets a facelift  --  now lets you sort by property source (e.g. see all the locally set versus inherited properties grouped together)
• {d:DataContext} markup extension lets you set design time data across Cider and Blend.
• UserControls can now use resources from App.xaml
• Designer now loads with broken controls -- a red x shows you the control that could not load, and a gold bar shows you the exact exception.  Previously you would have only gotten a "Problem Loading" screen.

We would love to get your feedback on these new features! 

In Windows 7, if you're using a larger display, the OS will automatically adjust for you, in the hopes that you will be more likely to be able to read text.

From this we see that there is a real end user benefit to tap into here. It turns out that there is existing infrastructure in Windows called “High DPI” which can be used to address this. High DPI is not a new feature for Windows 7, but it was not until Vista that the OS user-interface made significant investments in support for high DPI (beyond the infrastructure present earlier). To try this out in Vista, rt. Click desktop -> personalize and select “Adjust Font Size (DPI)” from the left hand column. Our thinking for Windows 7 was that if we enable high DPI out of the box on capable displays, we will enable users to have a full-fidelity experience and also significantly reduce eye strain for on-screen reading. There is even infrastructure available to us to detect a display’s native DPI so we can do a better job of configuring default settings out of the box. However, doing this will also open up the door to expose some issues with applications which may not be fully compatible with high DPI configurations. - Engineering Windows 7

It may be worth a look to see what your app looks like in 120 DPI.  In both windows forms and WPF, good use of the AutoSize features usually accomodates most scaling issues.  It can be tricky to set up, but once it works, it usually works well.

Windows Forms lets you set everything in pixels, and then during the loading process, it uses the AutoScale feature to magically multiply whatever you said by however bigger and/or smaller things are supposed to get. How much bigger/smaller things get is best calculated by taking the font size of the Form when you designed it (which is what AutoScaleBaseSize, AutoScaleDimensions are), then taking the new font size as currently run on the system.  The percent difference in size is used to adjust the size/location of controls.

For windows forms, check out the "AutoScale" section of this layout FAQ for tips as to how to use AutoScaleDimensions. 

WPF uses Device Independent Units, which is a fake unit that makes you always think you're drawing in 96DPI.  When it goes to render to the screen, it translates the DIU to DPI doing the math under the hood for you.  Charles Petzold does a good job explaining how the math works.  For the most part this system works well, though you need to know the tricks for image rendering and getting lines to draw crisply. 

Note this also means when doing WPF->Win32 interop, you need to translate back to the device coordinate system.  E.g. a WPF button that's set to Width=75, Height=23 is set to 75x23 DIU, not 75x23 pixels.  To translate back you can use Visual.PointToScreen or  PresentationSource.FromDependencyObject(dobj).CompositionTarget.TransformToDevice. 

In either system, if you have bitmap artwork in your application, you may want to consider whether or not you want to use a separate larger image for this mode - as in high DPI, the image will be stretched larger.

If I have any more specific tips, I will be sure to post them!

Today's tool I can share with you - I didn't want to flip back and forth between the repro steps in my bug reporting program and the program I was trying to fix. 

So I created a TopMost window that will always be there so I can see what the next step is. 

• Open Visual Studio 2008 or 2005, create a new Windows Forms application.
• Select the Form in the designer
• Open the Property Grid and find the TopMost property.  Set TopMost=true.
• Drag and drop a RichTextBox from the toolbox
• Select "Dock in parent container" from the designer action panel, or go to the property grid and choose Dock=Fill
• F5 to run the application
• Paste in repro steps from the bug! 
• (Tip - if the steps are in HTML, you may want to paste into word first, then the rich text box to get better formatting).

 And voila!

Quick and simple repro-step viewer that stays on top of all applications.

        public int MyProperty {

            get { return (int)GetValue(MyPropertyProperty); }

            set { SetValue(MyPropertyProperty, value); }

        }

        // Using a DependencyProperty as the backing store for MyProperty.  This enables animation, styling, binding, etc...

        public static readonly DependencyProperty MyPropertyProperty =

            DependencyProperty.Register("MyProperty", typeof(int), typeof(Window1), new UIPropertyMetadata(0, OnMyPropertyChanged));

        private static void OnMyPropertyChanged(DependencyObject dobj, DependencyPropertyChangedEventArgs e) {

            Window1 owner = dobj as Window1;

            if (owner != null) {

                // todo: execute property changed code.

            }

        }

Save this snippet to your disk as somefile.snippet (view source)
In VS 2008, open Tools > Code Snippets Manager
Choose the language (this is a C# snippet)
Choose import...
Find the .snippet file, import it, and voila!

Let’s assume we’re creating a BorderVisibility property on a UserControl.  It defaults to Visibility.Hidden.

Right click on the code editor.
Choose “Insert Snippet ...”
Choose NetFX30>Define a Dependency Property

Tab through and replace the fields in green. 

Replace the following:

·         int with our return type: Visibility

·         ownerclass with the class that defines the property, e.g. UserControl1

·         0 with the default value for the property Visibility.Hidden