IHateSpaghetti {code}

Copied from the visual studio gallery page:

 Check it out + download

Visual Studio 2010 Productivity Power Tools

A set of extensions to Visual Studio Professional (and above) which improves developer productivity.

• Document Well 2010 Plus (More Info)
  One of the key pieces of feedback that we have received over several versions of Visual Studio is that users want to be able to customize the behaviour of their document tabs.  From the ordering of tabs to the position of the close buttons, user can now configure dozens of different options for their tabs.  Go to Tools -> Options -> Environment -> Document Tab Well to configure these options as you prefer:
  • Tab Well UI
    • Scrollable tabs
      Maintain spatial consistency of the documents that are included in the document well.
    • Vertical tabs
      Document tabs are shown vertically, allowing you to fit more tabs than are normally visible when shown horizontally.
    • Pinned tabs
      Allows you to pin tabs to keep them always visible and available.
    • Show close button in tab well
      Similar to Visual Studio 2008, will show a close button in the document well that will close the active tab.
  • Tab Behavior
    • Remove tabs by usage order (LRU)
      When a new tab is inserted and existing tabs don't fit in the document well, instead of removing the tab at the end of the well it will remove the least recently used tab. This ensures that frequently used tabs are readily available.
    • Show pinned tabs in a separate row/column
      Pinning tabs can quickly cause you to run out of space for regular tabs. The option allows you to always show pinned tabs in a separate row (or column, if displayed vertically) from regular tabs.
  • Sorting
    • Sort tabs by project
      Tabs will be sorted by the project they belong to, thus keeping them always together in the document tab well.
    • Sort tabs alphabetically
      Tabs will be sorted alphabetically. When Sort By Project is turned on, tabs will be sorted first by project and then alphabetically.
    • Sort tab well dropdown alphabetically
      The drop down menu at the right end of the document well is sorted alphabetically. This option allows ordering as the tabs are laid out in the document well.
  • Tab UI
    • Color tabs according to their project or according to regular expressions
      This option permits tabs to be colored according to the project they belong to. This is particularly useful when sorting tabs by project, as it allows you to immediately identify different groups of project documents.
      You can also configure regular expressions and assign a color to each one. If the name of a tab matches the configured regular expression, it will be colored with the assigned color.
    • Miscellaneous options that modify tab UI
      • Show document/toolwindow icon in tab
      • Show close button in tab
      • Modify dirty indicator style
        This option allows you to select from a set of different dirty indicators that you might prefer over the asterisk.
      • Modify minimum and maximum tab size
        Allows you to modify minimum and maximum tab size. Try setting minimum and maximum sizes to the same value, and you will have evenly spaced tabs.
• Searchable Add Reference Dialog (More Info)
  The new Add Reference dialog makes it faster and easier for you to find the reference that you are looking for and add it to your VB, C# or F# project.  From the Solution Explorer, simply right click on the References node, select the Add Reference command to see the updated Add Reference Dialog. 
• Highlight Current Line
  As the resolution of monitors increases, it’s becoming more difficult to find the caret in the code editor.  The highlight current line extension makes it easy to find the caret by highlighting the line that the caret is on in the editor.  You can even configure the default colour by changing the setting for “Current Line (Extension)” and “Current Line Inactive (Extension)” in Tools Options Fonts & Colors. 
• HTML Copy (More Info)
  This extension provides support for the HTML Clipboard format when copying code from the editor.  This means that you’ll no longer have to go fix up the formatting of your code when you paste it into a TFS bug form or any other HTML based control. 
• Triple Click
  It’s never been easier to select a line of code from the mouse by simple triple-clicking anywhere on the line. 
• Fix Mixed Tabs
  Some developers prefer tabs, others prefer spaces, and nobody likes mixing tabs & spaces.  This extension promotes developer harmony by warning as they are open or save a file that has a mixture of tabs & spaces.  The information bar also provides an easy way to fix the file to suit your preference. 
• Ctrl + Click Go To Definition
  This extension gives the editor a web browser by adding clickable hyperlinks to symbols in your code as you hold down the Ctrl key.
• Align Assignments
  This extension is useful for making your code a little more readable by aligning the assignments when you type Ctrl+Alt+] such that it takes this:
      
  And turns it into this:
     
  Please note: This may conflict with your formatting settings. E.g. in C# you will need to disable: Tools->Options->Text Editor->C#->Formatting->Spacing->"Ignore spaces in declaration statements"
• Colorized Parameter Help
  This extension improves consistency with the editor by applying syntax highlighting to the contents of the Parameter Help window for C# &VB. 
• Move Line Up/Down Commands
  This extension maps the Alt+Up Arrow & Alt+Down Arrow keys such that they will move the current line of code or the selected lines up and down through the editor. 
• Column Guides
  Since Visual Studio 2002, there has been a not so secret registry key which allowed user to draw a vertical line in the code editor.  This is very useful to remind developers that their full line of code or comments may not fit one a single screen. Thanks to this extension this feature has returned with UI configure it.  Simply place the cursor at the appropriate column and select Add Guideline from the context menu 

New msdn page on Visual Studio extensibility - UML Tools, DSL Tools, IDE, Debugger, and much more.

Check it out - here

Jean-Marc published a nice post on how to enable a DSL to MEF extensios. There's a followup post for those who migrated from VS2005 and missing the magical InternalsVisibleTo attribute in their AssemblyInfo.cs.

For more info on DSL tools see this code gallery page: http://code.msdn.microsoft.com/vsvmsdk

Eyal

In this post:

1) General overview of the way the toolbox items work in DSL tools for VS2010

2) Toolbox related Changes from VS2008 to VS2010

3) Customization of static toolbox items - how to grouped model elements into single toolbox item

In VS 2010 we change the way we manage toolbox items from being set explicitly during package initialization to being partially set(*) before the package has been created and initialized. The toolbox items that are set this way called static toolbox items (vs. dynamic toolbox items in VS2008).

* By partially I mean only the text, tooltip and icon are set (there are few more but they are there for technical reasons) – no action or any DSL-specific information is associated with the toolbox item –practically those toolbox items are stubs until their full initialization.

Q: Why did moved to static toolbox items?

A: By using this approach we were able to speed up the overall VS loading time because no package will be created (and initialized) prematurely just because it has some toolbox items.

 

The full initialization will occur when the specific designer will show up and someone will hover the toolbox item and at that point the partial toolbox items will be replaced with ModelingToolboxItem that will be created according to the following sequence diagram:

Blue line – VS will use package.GetToolboxItemData(..) to try and get the toolbox item data for each of the toolbox items ids you’ve hovered to replace it with the stub toolbox item and cache it in VS toolbox cache.

Red Line – Toolbox helper will create an instance of ModelingToolboxItem according to the toolbox item id.

 

Q: How would I add custom static toolbox items that are not mapped to a shape or logically group several model elements into single toolbox item?

A: The recommended approach is to add class attribute on partial package class (in DslPackage) and extending the ToolboxHelper class (in Dsl) and supporting the new toolbox item id.

 

Example for language name “MyLanguage”:

Under DslProject project:

   1: // See the generated Package.cs for examples

   2: [ProvideStaticToolboxItem(…, “MyNamesSpace.MyNewToolboxItem”,….)]

   3: partial class MyLangaugePackage : MylLanguagePackageBase

   4: {

   5: }

More info: ProvideStaticToolboxItemAttribute

Under Dsl project:

   1: partial class MyLanguageToolboxHelper : MyLanguagelToolboxHelperBase

   2: {

   3:     public override ModelingToolboxItem GetToolboxItem(string itemId, Store store)

   4:     {

   5:         if (store == null)

   6:         {

   7:             return null;

   8:         }

   9:         if (itemId != “MyNamesSpace.MyNewToolboxItem”)

  10:         {

  11:             return base.GetToolboxItem(itemId, store);

  12:         }

  13:  

  14:             

  15:         // return the custom toolbox item instance 

  16:         // see the generated ToolboxHelper.cs code for examples

  17:         return 

  18:             new ModelingToolboxItem(“MyNamesSpace.MyNewToolboxItem”,

  19:                         1, 

  20:                         …,

  21:                         …,

  22:                         …,

  23:                         …,

  24:                         …,

  25:                         …,

  26:                         CreateMyCustomPrototype(store), 

  27:                         …

  28:                         });

  29:     }

  30:  

  31:     private static ElementGroupPrototype CreateMyCustomPrototype (Store store)

  32:     {

  33:         ElementGroup elementGroup = new ElementGroup(store.DefaultPartition);

  34:  

  35:         // add all the model elements that create a logical group

  36:         // make sure to set the properties that will be used as defaults

  37:         elementGroup.AddGraph(/*Add model element 1 instance*/, true);

  38:         elementGroup.AddGraph(/*Add model element 2 instance */, true);

  39:         elementGroup.AddGraph(/*Add model element 3 instance */, true);

  40:         return elementGroup.CreatePrototype();

  41:     }

  42: }

More info: ModelingToolboxItem

One of the new features for DSL in VS2010 is DSL libraries, in this post I will explain how to use the new feature.

Prerequisites: VS SDK 2010 Beta2 and higher + DSL SDK 2010 Beta2 and higher.

DslLibrary is a DSL that is used as a library – you can extended it or just use it with you DslLibrary/DSL.

In order to start creating DslLibraries:

1. Start VS and then File->New->Project

2. Find the Domain-Specific Language Designer (under Other Project Type->Extensibility)

3. In the wizard choose DslLibrary and click Finish (or proceed with the wizard)

4. The wizard will unfold a single project solution with an empty model.

5. In DSL Explorer window right click on the root node and then add a Domain Class

6. Switch to Solution Explore Window and regenerate all (the command with the red rectangles surrounding it)

    Note: For the current example you want be needing the generated code so, just the .dsl file itself.

7. Create another DslLibrary or a DSL.

8. When the second language is unfolded switch to the DSL Explorer Window

9. Right click on the root of the tree and choose Add DSL Library Import

10. Select the import and set the file path to the library (relative or absolute), when you hit ENTER, if the path is valid the library will appear in the DSL Explorer Window

11. At this point you can use the library in your language.

Note: as soon as you will consume it in your DSL you will create a dependency that will require the library to be present on the specified path.

As of yesterday, you can download the new version of the DSL SDK.

We fixed some bugs and we added some really cool features such as better templates for WPF and Winforms based designers, T4 code generation at build time, domain model extensibility (you can even extend the Dsl designer itself), and DslLibraries and much more. For the full list see Jean-Marc's post.

There's a known issue with debugging Dsl designers using F5 - the toolbox items won't appear in the exp hive. In order to work around this (until the RC) you will have to run using CTRL+F5 (without debugging) and after the exphive will showup you will be able to attach the debugger. See this thread of more info.

Have fun

Jean-Marc has released another sample over the weekend:

Domain Model Extensibility, here is a quote from his post:

"The sample presents a DSL to explain the architecture of a multi-Tiered application. Each tier is made of components, which have ports. Connections are made between output ports and input ports. What is new is that a Domain Model Extension will add a “Security Extension” thus providing to the toolbox new items (an Audit Log), to a Tier new decorators, to Ports three new Domain properties related to the HTTP security, new validation methods, and new rules. I’m pretty sure you’ll like this sample very much."

You can find this sample and the other samples at: http://code.msdn.microsoft.com/DslTools

Check out the new WPF toolkit that was released today on WPF codeplex site.

The new stuff:

• Chart Controls
• Bug fixes for common issues, including:
   - DataGrid.DeleteCommand requires a current cell (as reported here)
   - DataGridColumn DisplayIndex ArgumentOutOfRange exception (as reported here)
   - DatePicker IsEnabled=False does not gray out (as reported here)
   - DatePicker Enter, Escape, and Spacebar inputs do not correctly commit/cancel edits and close the popup
   - VSM steady state animations fail to run

WPFToolkitBinaries WPFToolkitBinariesAndSource

The first DSL SDK 2010 Beta1 was just added by Jean-Marc and it demonstrates the usage of our new feature - ModelBus, used for model referencing.

The code and the documentation is available here: http://code.msdn.microsoft.com/DslTools

Side note: check out my first feature as MS employee - the ModelBus Picker - the WPF-based reference picker that pops when you click on the ellipsis for ModelBusReference typed properties ;-)

Feedback is appreciated

Jean-Marc has just announced about our release of DSL SDK for VS2010 Beta1 !

In that posts he covers about the new features we've added, sample and more!

We have a new code gallary page that is worth checking out: http://code.msdn.microsoft.com/DslTools (I planning to write a sample regarind our new WPF databinding features in the next week or two).  You can download the SDK here.

Cheers

Windows 7 specific APIs include demo , labs and presentaions:

Windows 7 Sensor and Location .NET Interop Sample Library

Windows 7 Multitouch .NET Interop Sample Library

Windows 7 Taskbar and Libraries .NET Interop Sample Library

Have fun

Are you intrigued by multi touch? The Windows Engineering team just posted a great article on how Touch was implemented in Windows 7 and on how software developers can tap into this: http://blogs.msdn.com/e7/archive/2009/03/25/touching-windows-7.aspx#comments
Check out these labs to find out how you can use Windows 7 touch with WPF 3.5 SP1: http://code.msdn.microsoft.com/WindowsTouch
This WPF 4.0 session from PDC shows you what you can expect next: http://channel9.msdn.com/pdc2008/PC03/

And here’s another cool thing this is the official quote from the WPF Tree Services & Controls Team:

We shipped some great new updates to the WPF Toolkit and WPF Futures on Codeplex earlier this week.  These included an updated version of the WPF Toolkit with over 20 high-priority bug fixes for DataGrid, DatePicker, & Calendar, and also a package of WPF Themes (matching those shipped with the Silverlight Toolkit) as a new addition to the WPF Futures.  We’ve also added a pointer to David Anson’s blog post with a preview of the WPF Chart Controls which are being written by the Presentation Platform Controls (PPC) team (the team who produces the Silverlight Toolkit).

Found this useful post you might want to know how to add tracing information for System.Net namespace:

<configuration>
    <system.diagnostics>
        <trace autoflush="true" />
                <sources>
                <source name="System.Net">
                        <listeners>
                <add name="System.Net"/>
                        </listeners>
                </source>
                <source name="System.Net.HttpListener">
                        <listeners>
                <add name="System.Net"/>
                        </listeners>
                </source>
        <source name="System.Net.Sockets">
                        <listeners>
                <add name="System.Net"/>
                        </listeners>
                </source>
        <source name="System.Net.Cache">
                        <listeners>
                <add name="System.Net"/>
                        </listeners>
                </source>
                </sources>
        <sharedListeners>
                <add
                 name="System.Net"
                 type="System.Diagnostics.TextWriterTraceListener"
                  initializeData="System.Net.trace.log"
                 traceOutputOptions = "ProcessId, DateTime"
                />
        </sharedListeners>
    <switches>
        <add name="System.Net" value="Verbose" />
        <add name="System.Net.Sockets" value="Verbose" />
        <add name="System.Net.Cache" value="Verbose" />
        <add name="System.Net.HttpListener" value="Verbose" />
    </switches>
    </system.diagnostics>
</configuration>

I was investigate a GDI/GDI+ related bug the other day and I found out that GDI+ doesn’t render RTL text very well. In order to render it correctly you need to render it using GDI.

This is done by Graphics.DrawString(…) / Graphics.MeasureString(..)

GDI Text rendering

This is done by TextRenderer.DrawText(..) / TextRenderer.MeasureText(…)

The interesting thing about GDI text measuring is that it sometimes the measured size might be larger than the maximum size so be aware of that!

Another point is to be aware of the GraphicsUnit in the Graphic.PageUnit instance vs. Font.Unit if one in pixels and the other is inches than it’s like comparing melons to oranges.

Test application

I've created this test application that might help you to see the differences between the two rendering technologies.

• http://windowsclient.net/articles/gdiptext.aspx
• http://support.microsoft.com/kb/307208
• http://blogs.msdn.com/cjacks/archive/2006/05/19/gdi-vs-gdi-text-rendering-performance.aspx