Rob Relyea: XAML

Is Xaml human readable...

Fri, 08 Feb 2008 11:02:05 GMT

Scott Koon thinks not: http://scottkoon.org/2008/02/08/i-still-hate-xaml-though-quo/

Remember, my November 2004 blog post "Our 7 Goals for Xaml" - human readability was one of the goals...not the only goal.

Concise FlowDocument representation in Xml (with converter)

Fri, 08 Feb 2008 10:59:06 GMT

Interesting seeing an xml format with property elements like "<body.head>" and "<body.content>"...

Here is an example of the xml format that looks like it tries to be an html like representation of a document that is convertable to a flowdocument (from XML to FlowDocument Converter)

<p fontfamily="georgia" fontcolor="black" fontsize="12" fontstyle="normal" fontweight="normal">The decision – which also applies to cargo services – is significant, said industry watchers yesterday.</p
<p fontfamily="georgia" fontcolor="black" fontsize="12" fontstyle="normal" fontweight="normal">Although the December 2008 date had been set four years ago, there was no certainty that all members of the 10-nation grouping would agree to free up air travel by then, they said.</p>
<p>Mr Anthony Concil, a spokes man for the International Air Transport Association, a 240-member airline grouping told The Straits Times last night “Clearly, this is a big and con crete step in the right direc tion...What we are seeing is tha Asean has picked up the bal and is moving forward.”</p>

[update: turns out that format is NITF, which I've never looked at, I believe...which the Syndicated Client Experiences Starter Kit uses...funny that they seems to have used a Period in a tagname before Xaml did. Back in 2004 I listed some options we were considering for the syntax of Property Elements]

Kent Boogaart: Functional and Aesthetic Xaml

Thu, 07 Feb 2008 10:37:04 GMT

Ran into a comment by Kent on Kevin's post about WCF serialization with Xaml where he pointed toward this "Xaml" post where he discusses Xaml verbosity and separation of concerns into Functional and Aesthetic Xaml.

The New Iteration...xaml whitepaper

Sat, 19 Jan 2008 03:47:30 GMT

Karsten and Jaime have published a great whitepaper that looks at how Xaml transforms the collaboration between designers and developers in WPF: The New Iteration

The Blomsma Code - question on Xaml Validation @ compile time

Sat, 12 Jan 2008 10:45:30 GMT

Good question from The Blomsma Code, with an answer from WPF Designer PM Mark Wilson-Thomas. I chime in with a comment as well..

XAML validation - design vs. runtime error

Xaml doesn't have to be XML

Wed, 12 Dec 2007 00:37:42 GMT

Check out Handy Xaml's intro. One thing you'll see is an alternative Xaml textual format (no brackets, no quotes...). Cool! Lots of possibilities here...

Fundamentally, Xaml doesn't need to be tied to XML...XML is just one possible representation of the Xaml data model.

commonality: on Visual DSLs

Mon, 03 Dec 2007 21:01:46 GMT

Interesting post covering DSLs and some thoughts on Microsoft's direction here, with discussion of Xaml.

commality: What Irks Me About Visual DSLs

Do you use Internal Types in Xaml (if you compile to Baml)? Why? Should Silverlight enable?

Wed, 17 Oct 2007 09:27:32 GMT

WPF enables you to refer to Public or Internal types in Xaml. Internal types only work at runtime if they are loaded from Baml in the same assembly. We did this support so that people could build Windows/Pages/UserControls that could be part of your public API, while not requiring that all of the elements/objects that you use must be public.

2 questions related to this:

if you are using internal types in Xaml, why do you find it useful?
how critical do you think it is that Silverlight support a similar feature? why?

Daniel Cazzulino: Why XAML makes System.Configuration and Enterprise Library Configuration obsolete

Tue, 25 Sep 2007 13:16:02 GMT

http://www.clariusconsulting.net/blogs/kzu/archive/2007/09/24/WhyXAMLmakesSystemConfigurationandEnterpriseLibraryConfigurationobsolete.aspx

Xaml doesn't only create .Net objects...

Fri, 07 Sep 2007 22:11:36 GMT

Mike Taulty realizes that Xaml doesn't always create graphs of .Net objects.... XPS and now Silverlight 1.0 has shown that. This is how I think about it: Xaml represents data. That data is often hierarchical in nature. Systems can map that data into the creation of a graph of objects. Those objects may be .Net, unmanaged, or other type system objects. What happens with that "data" is up to the receiver/handler...

Obfuscation and Xaml/Baml

Thu, 16 Aug 2007 14:24:02 GMT

Thanks to a forum post "Code Protection and Licensing of WPF Applications", I write this response:

Baml is similar to IL in that it encodes type and member names. Unfortunately, we haven't documented baml like IL is, so obfuscators can't easily obfuscate WPF applications.

I believe the best approach today is to exclude from obfuscation any types/members which you define that you need to use in Xaml. If any type/member names change between creating the assembly (with baml) and runtime, the baml hasn't been updated to refer to the new types.

Unfortunately, we don't have the baml format published (as we think we will need to change it) and don't have an adequate API to help obfuscators.

We are investing to improve this in the future. Until then, I'd love to hear:

best practices to deal with this limitation today
feedback about how critical it is to improve this
any other feedback in this area

Thanks!

NameReferenceExtension - MarkupExtension to do name references

Tue, 24 Jul 2007 12:41:00 GMT

Several people have been asking for the ability to do name references to set a property on one object to another object somewhere in the Xaml document.

Forum Posts:

1) Sample of MarkupExtension taking in a FrameworkElement?

2) Create a markup extension: How to get an element by name and other problems...

Challenge

We plan to enable this in the XamlLanguage natively in the future...until then there are ways to make it work in .Net 3.0/3.5 with our XamlReader.

I built two generic CLR objects: Root and Node that I wanted to use like this:

<?xml version="1.0" encoding="utf-8" ?>
<Root xmlns="clr-namespace:XamlForumMEs;assembly=XamlForumMEs">

Implementing the first NameReference isn't too hard, since it is a backwards reference.

Implementing a NameReference so that it can do the forward reference (Node3 making Node4 a friend) is more challenging.

Brief Details of Sample

I made Root implement:

INameScope - so that each Name property setting would be registered with the root.
ISupportInitialize - so that Root would call BeginInit and EndInit at the start and end of parsing the tag.

Each time a NameReference was asked to Provide a value, I cached a DeferredFriend request in the Root.

At EndInit of Root, I set all DeferredFriends.

Not extremely pretty...but it may help some folks until we make this cleaner...

Download Link

http://robrelyea.com/demos/NameReference/NameReference.zip (a project that was built with VS2008 Beta2...if you are using VS2005, you need to manually copy the files into a new project)

Resharper 3 adds Xaml editing/refactoring support

Fri, 22 Jun 2007 14:37:38 GMT

I'm happy to see Xaml editing support announced in Resharper 3. [via Daniel Chiat]

(would love to know what people think of how they did in that area...)

Xaml + VB4 Frm files + ...

Thu, 21 Jun 2007 01:23:51 GMT

In "VB4: Xaml, I am your father" Tom Hollander discusses Xaml's similarity to VB .frm files. I've also heard Delphi developers compare it to one of their file formats.

Xaml isn't programming language specific & can also be used for many different sets of types (or Xaml Vocabularies), not just UI. But, yes, having a file format to specify hierarchical sets of objects with certain properties has been done a few ways before.

Mike Hillberg: Great Xaml Posts

Mon, 18 Jun 2007 17:12:03 GMT

Last September I pointed out: WpfBloggers.Add(WpfArchitects.MikeHillberg);

Since then, he's had a consistent set of thorough and well written content - primarily on Xaml and WPF. I wanted to call out these Xaml posts as things that I point people towards:

Update 6/25/2007: I've added a link to all of Mike's Xaml Language posts from http://robrelyea.com/xaml

Compile Xaml to C# (.cs)

Thu, 14 Jun 2007 13:20:41 GMT

I recently published XamlT @ http://XamlT.com which is a tool that has several useful functions for xaml users.

1) You can view information about the Types expressible in different Xaml Vocabularies (WPF, SL 1.0, SL 1.1, etc..)

2) You can also convert Xaml files into C#

A little background on Xaml & C#

[you can replace the words C# or .cs below with VB and it is all still true]

In WPF, we compile Xaml into a combination of C# (.g.cs) and a special binary form (.baml). So at runtime, in most cases, there doesn't need to be any Xml parsing happening - baml is an optimized, pre-tokenized version of the elements that were specified in the .xaml file.

Once a window/page is displayed in WPF, often people programmatically change the state of the tree or add new subtrees to the tree. If people know how to do something in Xaml, it isn't always simple to know the code to do the same thing.

That is why I built the Xaml -> C# tool into XamlT.

Related posts from the past

What tools generate .g.cs from XAML? Can it be done at runtime?
3 Coding Styles for Avalon Applications (this shows ways that markup and code can be mixed during compile and/or runtime)
.xaml, .baml, .g.cs details (discusses some details about baml, generated code)

"Acropolis" uses Xaml to define business logic components

Tue, 12 Jun 2007 11:38:42 GMT

David Hill explores a bit about why Acropolis chose to generate Xaml instead of code for business logic components. See "Why XAML?" section in his post.

An excerpt listing the benefits of XAML for Acropolis:

Using XAML gives you a very concise way to express the structural aspects of your component - not just the external ‘class interface', but how it is structured internally. For example, it allows you to cleanly define how any child components or services that your component uses are configured or interact with each other.
It allows you to concentrate more on the code that defines the actual implementation of your component. In other words, we want to make it so that 99%+ of the code that you do write is the actual code that will solve your business problem and not plumbing or glue code.
It is much easier for us (or you) to build visual designers or other tools (including test tools) for your component since its structure is more easily ‘machine-parsable'. It also allows for a looser coupling between the application model and the tools allowing each of them to evolve more quickly.

The 3rd point is an interesting observation. I don't think I have heard that benefit before...

To see some sample Xaml that Acropolis tools create, one place to look is the Walkthrough: Building an Acropolis RSS Reader Application.

Case Sensitivity of Xaml

Tue, 12 Jun 2007 11:27:12 GMT

Marius Gheorghe complains of Xaml's case-sensitivity in XAML case sensitivity and XAML case sensitivity.Reloaded where among other things he said:

Case sensitive markup code = pure evil

To tell you the truth, nobody has asked that question of "Why is Xaml case-sensitive" before, and we made the decision so long ago, I had to go talk to Mike Hillberg to get/recreate the reason why Xaml is case sensitive.

First, what is our behavior:

Xaml element names and attribute names map directly to Type, Property and Event names in a case-sensitive manner.
.Net Framework Design Guidelines (MSDN or book@Amazon) call for Pascal casing of Type, Property and Event names. (initial caps and capitalizing words inside the name as well...for example DrawingImage.)
Therefore, you'll find that Xaml generally needs to be Pascal cased for Element and Attribute names.
Attribute values in Xaml are generally case-insensitive. ("True", "true", or "TrUe" all work for a property of type boolean.) This is an artifact of the fact that we call TypeConverters to convert attribute values into the appropriate type, and most .Net type converters are type insensitive.

A few reasons:

XML is case sensitive for internationalization reasons.
XHTML, a XML vocabulary, also needed to make a choice; they chose lower case tag and attribute names:

XHTML is case sensitive, where as HTML is not case sensitive. Furthermore XHTML requires that all enumerated attribute values be lower case.
[Note, Xaml, as noted earlier, is a bit looser with attribute values...most attribute values are case-insensitive, but that is up to the TypeConverter which is used for that property value. We recommend that TypeConverters are case-insensitive unless they must be case-sensitive. Path.Data is one of the few case-sensitive attribute values that WPF has.]

The XHTML spec says why they made that choice:

XHTML documents must use lower case for all HTML element and attribute names. This difference is necessary because XML is case-sensitive e.g. <li> and <LI> are different tags.

Given that we needed to make a choice, we felt that consistency of casing between the type definition and the use in Xaml was the most natural choice.

So that is where we are and why. Thanks to Marius for asking the question and giving the feedback. So far, Marius' is the first mention I remember seeing of this since we've been published "Avalon" externally in October of 2003. I agree that hand editing of Xaml is harder due to this behavior.

Nathan Dunlap: Xaml Icon History

Thu, 24 May 2007 04:30:34 GMT

History of the Xaml Shield

David Heinemeier Hansson quote about flexibility & complexity

Wed, 23 May 2007 20:34:11 GMT

Computerworld.com has an interview with the Ruby-on-Rails creator. In it, I enjoyed this quote:

Flexibility is not free. It's overrated. And if you trade that flexibility in for some constraints, you get a lot of complexity removed from the equation, you get a lot of productivity back from all the stuff you don't have to do.

Matt Milner: Workflow and Xaml in VS

Mon, 21 May 2007 21:42:11 GMT

Matt Milner posted a set of templates to treat Xaml as uncompiled files in Windows Workflow Foundation (WF) projects.

Code vs. Markup or Markup + Code

Mon, 21 May 2007 20:15:26 GMT

XAML or F#? asks if F# isn't more concise and functional than Xaml.

Programming languages are very powerful, I'm sure we all have our favorites. In the end though, Programming Languages are difficult for a wide set of tools to deal with and manipulate. Xaml by comparison has fewer ways to represent an object tree than code - so it should be easier to build systems to manipulate that representation.

One of the advantages of having a canonical representation of an object tree, is that it serves as a great interchange enabler. That canonical representation doesn't need to be Xml, but it seems like a good choice.

Since Xaml Vocabularies need to buy into Xaml's "Markup==Object Model" philosophy, anything you can do from markup, can be done in code. In the end, declarative systems that can be used via markup and via code are what will likely succeed. Designing your system to work well in both worlds is key. Developers who want to only use Code can. Scenarios that require Markup and Code can easily be satisfied.

Useful background: Our 7 Goals For Xaml

Update 2007/05/22: Barry Kelly posts a response: "XML, the right format for object graph serialization".

BK: Sigh. The assumption of an "object tree" - object graphs usually aren't trees, they typically have lots of cross-references.

RR: Yes...my team usually corrects me from tree to graph...my mistake.

BK: Converting objects to XML requires some naming scheme for those objects which have relationships more complex than parent-child.

RR: Today in WPF we have resource references and bindings to properties, but no generic Xaml Language (x:) way to do the object graph...but we'd like to get there.

Ashish Shetty: Namescopes in WPF & Silverlight

Fri, 18 May 2007 00:52:39 GMT

Good post to read from Ashish: http://nerddawg.blogspot.com/2007/05/namescopes-in-silverlight.html

Chuck Jazdzewski: Xaml Conditional Compilation via MarkupCompatibility

Fri, 18 May 2007 00:49:33 GMT

More internal mail:

From: Me
Chuck showed an interesting way you can do “xaml conditional compilation” in A Tour of XAML VIII: More fun with Markup Compatibility

----------------------------------------------------------

From: Somebody inside of MS
I need to do something like this:
<ControlTemplate>
#if SOMESYMBOL
<ControlTemplate.Triggers>
Some triggers
</ControlTemplate.Triggers>
#endif
</ControlTemplate>
Is there any way to do it?

Charles Petzold: Video of Devscovery NYC Keynote

Sat, 12 May 2007 13:10:24 GMT

I'm about halfway into Charles' Devscoverty Keynote. I was happy to trip over a link in this Channel9 discussion about Xaml Editors. Interesting talk - love his book and his thoughts about Xaml and its impact.

Update: Very cool demos of Charles' evolution of a Planet viewing application he wrote long ago in Win32. Very nice in WPF...he wrote some custom elements and shows wiring them together in Xaml Cruncher (his Xaml Editor) with Xaml and databinding.

Lazycoder: Why use Xaml?

Fri, 11 May 2007 13:03:37 GMT

Lazycoder asks Why use Xaml? We designed it with the following goals in mind: Our 7 Goals for Xaml

Already some interesting comments on Lazycoder's post...

James Clark: TEDI, JSON

Fri, 11 May 2007 12:45:07 GMT

Very happy to find Don's pointer to James Clark's blog.

As somebody who has wrestled with representing Xaml Vocabularies in XSD, I'm always interested to read about possible new approaches.

.CompositeFont : another xaml data format

Wed, 04 Apr 2007 16:39:47 GMT

SerialSeb posted about font fallback and mentioned .compositeFont files in "WPF Tips'n'Tricks #2- Use Segoe UI on Vista and Tahoma on XP (and whatever else wherever else)"

I commented:

.compositeFont is an interesting file format from a Xaml perspective. Its data is representated in Xaml.

Michael Latta on Declarative vs. Imperative

Thu, 29 Mar 2007 09:42:43 GMT

Micheal Latta has an iteresting post "Declarative vs. Imperative". In it he compares the approach of Xaml for UI and Ruby for Rails for UI.

In the end, it seems like the thing he enjoys with Ruby is the ability to stay in one language:

You can make [treeviews] you anticipated in the XAML visible, but not create new ones. For that you need imperative code. In WPF this is C#. You need to change to a different language. In Ruby you stay in the same language for all cases, and you can place any of those operations in the system at any time. The program is not cast in stone the minute the class is loaded into the AppDomain as in the CLR. You do not need to use some arcane code generation API to create run-time dynamic logic.

If you spend time working with people on WPF, you'll often hear the "how can I do this in Xaml" question. Perhaps it is the draw to one language?

Xaml has shown strength in tooling...we already have many tools (designers and file format converters) for Xaml for UI. I'm not sure how this compares to imperative approaches. I understand how it compares to Windows Forms, but not Ruby. How does programming in teams, using visual designers, etc... affect this picture?

Very interesting...

XamlReader2 - helpful wrapper to XamlReader

Mon, 26 Mar 2007 10:24:48 GMT

I think XamlReader needs some more methods to make a few tasks easier.

Things I'd like to have be easier:

1) I hate having to cast the root that I am expecting:

RootType root = (RootType)XamlReader.Load(s);

I'd prefer:

RootType root = XamlReader<RootType>.Load(s);

2) I hate having to only pass a stream in

I'd like to be able to pass a filepath, FileInfo or a string:

String:

string strXaml = "<String xmlns=\"clr-namespace:System;assembly=mscorlib\">Hello world</String>";
string str = XamlReader2<string>.Load(strXaml);

FileInfo:

        FileInfo dataFile = new FileInfo("c:\\temp\\topics.xml");
        if (dataFile.Exists)
            Topics = XamlReader2<TopicCollection>.Load(dataFile);
        else
            Topics = new TopicCollection();

Thoughts?

Prototype of XamlReader2: (could have major bugs - please review before using...)

[Update: 3/27] Updated the Load(string) override implementation to use StringReader/XmlReader instead of MemoryStream, etc... Thanks for the comments!

using System;
using System.IO;
using System.Collections.Generic;
using System.Text;
using System.Xml;
using System.Windows.Markup;

namespace XamlHelper
{
    //This code is just a prototype of some helpers
    //to make XamlReading more convenient...let me know
    //what you think.
    public static class XamlReader2<T> where T : class
    {
        public static T Load(Stream stream)
        {
            object o = System.Windows.Markup.XamlReader.Load(stream);
            return CheckRootType(o);
        }

        public static T Load(XmlReader xmlReader)
        {
            object o = XamlReader.Load(xmlReader);
            return (CheckRootType(o));
        }

        private static T CheckRootType(object o)
        {
            T root = o as T;
            if (root != null)
                return root;
            else
                throw new Exception("Expected <" + typeof(T).Name + "> as root tag.");
        }

        public static T Load(FileInfo fileInfo)
        {
            if (!fileInfo.Exists)
                throw new FileNotFoundException(fileInfo.FullName + " doesn't exist.");
            StreamReader sr = new StreamReader(fileInfo.FullName);
            return XamlReader2<T>.Load(sr.BaseStream);
        }

        public static T Load(string xamlContainingString)
        {
            StringReader stringReader = new StringReader(xamlContainingString);
            XmlReader xmlReader = XmlTextReader.Create(stringReader, new XmlReaderSettings());
            return Load(xmlReader);
        }
    }
}

Good Progress on Xaml to Code Tool

Thu, 22 Mar 2007 14:12:58 GMT

[update 6/10/2007: I've posted a version of this Xaml to Code tool on http://XamlT.com. Select sample.xaml from the right side of the home page of the application and choose open.]

I mentioned last week that I was building a Xaml to Code converter.

It can now convert this Xaml:

<Window x:Class="xamlU.Window1"
   xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
   xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
   Title="xamlU" Height="471" Width="665" WindowState="Maximized">
   <Grid>
    <Grid.RowDefinitions>
       <RowDefinition Height="*" />
        <RowDefinition Height="*" />
    </Grid.RowDefinitions>
   <Button IsDefault="True">Ok</Button>
   <Button Grid.Row="1">Cancel</Button>
  </Grid>
</Window>

To this C#:

            Window Window1 = new Window();
            Window1.Title = "xamlU";
            Window1.Height = ((Double)new LengthConverter().ConvertFromString("471"));
            Window1.Width = ((Double)new LengthConverter().ConvertFromString("665"));
            Window1.WindowState = WindowState.Maximized;

            Grid Grid1 = new Grid();
            Window1.Content = Grid1;

            RowDefinition RowDefinition1 = new RowDefinition();
            RowDefinition1.Height = ((GridLength)new GridLengthConverter().ConvertFromString("*"));
            Grid1.RowDefinitions.Add(RowDefinition1);

            RowDefinition RowDefinition2 = new RowDefinition();
            RowDefinition2.Height = ((GridLength)new GridLengthConverter().ConvertFromString("*"));
            Grid1.RowDefinitions.Add(RowDefinition2);

            Button Button1 = new Button();
            Button1.IsDefault = true;
            Grid1.Children.Add(Button1);

            Button1.Content = "Ok";

            Button Button2 = new Button();
            Grid.SetRow(Button2, 1);
            Grid1.Children.Add(Button2);

            Button2.Content = "Cancel";

Required Enhancements

Handle Markup Extensions
Consider how x:Class should be handled
Support VB
Definitely more to think of and list here...

Possible Enhancements

Share instances of TypeConverters, instead of creating a new one for each property set.
Avoid using TypeConverters at all...figure out the object created from the type converter and convert it to code.

Concise Description of Xaml Language & Xaml Formats

Wed, 21 Mar 2007 13:16:12 GMT

I am doing some writing for work, and I'm yet again having to come up with a description of XAML - the language. Remember, there are Xaml Formats such as WPF/XAML, WPFe/XAML, WF/XAML (workflow foundation), & XPS/XAML. The Xaml Language is the common set of rules which those Xaml Formats all uphold.

My latest take

Xaml Format: a set of specific elements, usually extensible, used to declaratively model a system.
Xaml Langauge: a set of rules built on XML's strengths to provide a tool friendly, while still human-readable, file format which describes trees of objects from domain-specific class libraries.

Related information

Xaml Overview on MSDN
Xaml Language and Xaml Formats (initial blog post with "Xaml Formats" term)

Whitespace preservation in XAML

Tue, 20 Mar 2007 00:13:04 GMT

Fil asked about Collapsed Spaces Around <Run />

Using XamlPad, I was not able to reproduce this problem…all 6 hello worlds have spaces in them.

What is your repro?

<Page
 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 xmlns:System="clr-namespace:System;assembly=mscorlib">
 <StackPanel>
 <TextBlock>Hello World</TextBlock>
 <TextBlock><Run>Hello</Run> <Run>World</Run></TextBlock>
 <TextBlock><Bold>Hello</Bold> <Italic>World</Italic></TextBlock>
 <FlowDocumentPageViewer>
 <FlowDocument>
 <Paragraph>Hello World</Paragraph>
 <Paragraph><Run>Hello</Run> <Run>World</Run></Paragraph>
 <Paragraph><Bold>Hello</Bold> <Italic>World</Italic></Paragraph>
 </FlowDocument>
 </FlowDocumentPageViewer>
 </StackPanel>
</Page>

The SDK documents Whitespace Processing in XAML

Update: Corrado Cavalli, an MVP from Italy that I met last week, sent me mail pointing out a sample that reproed for him. Since it didn't repro for me in XamlPad, but he sent a picture, I decided to check to see if compiled xaml had the problem. It turns out that xaml and baml are consistent however I believe that this only repros in "Cider" in the March CTP. I'll work with the Cider team. Thanks!

Tool to convert from XAML to Code

Thu, 15 Mar 2007 15:35:32 GMT

[update 6/10/2007: I've posted a version of this Xaml to Code tool on http://XamlT.com. Select sample.xaml from the right side of the home page of the application and choose open.]

This has been a frequent request...

Today, I saw a WPF forum post asking again, so I started building this. I'm building it on top of some classes that help store information about types, properties, etc...

If you don't see anything in 1-2 weeks, please ping me with a comment on this post.

[Update: 3/16]

Here is a picture of how it looks now:

(as you may be able to see by the code, i have the basics going...)

Next steps:

Treating properties of type double appropriately
TypeConverters (don't call them from code...figure out the associated code...)
Property Elements
Markup Extensions
More?

The Xaml Icon

Tue, 13 Mar 2007 21:09:10 GMT

I forget who actually made this, but the icon for a xaml file is very nice...especially in very large icon mode in Windows Vista. Was that you Nathan?

Another New XamlPad

By the way, Nathan just pointed me towards CHATBlender...a new XamlPad that integrates with MSN Messenger (or is that Windows Live MSN Messenger .Net :-). I added it to my Xaml Editor List.

Internal MailBag: Collection Types in XAML

Mon, 26 Feb 2007 14:52:06 GMT

Another mail that mail be useful to others outside our firewall...

By the way, MSDN has a section that goes into Collection Types and XAML Collection Properties

From: Mike
Btw, the reason List<T> works is because it implements IList.

---

From: Rob
IList, IDictionary or Array are the collection types we support.

List<T> or IList<T> is recommended as well, as it suggests the type of the children.

IList<T> isn’t supported by itself…partially due to dev time and partially due to perf concerns…if I recall correctly.

---

From: Developer
I’m designing a class that I want to be able to use in XAML. The class which has a collection-valued property called “Children”.

If I define “Children” as IList<T>, I get the following error: 'Children' is a read-only IEnumerable property, so 'MyClass' must implement IAddChild.

If I define “Children” as List<T>, things seem to work fine.

Can someone clarify what types XAML supports for collections? Why is IList<T> not acceptable? What is the recommended usage here?

ServiceProvider and XAML: type converters and markup extensions

Fri, 16 Feb 2007 02:06:39 GMT

Internal Mail thread (read from bottom)...shared to make the info spread fastest...

Larry-
Thanks!

Wolf-
Not sure how well I’ve speced/documented this. Can you please add to SDK?

Basically, we should make sure that we document that service provider is available inside a type converter ConvertFrom call and inside ProvideValue.

We provide 3 different interfaces that you can GetService from the service provider.

Here are the concrete examples of how we use this mechanism in our code base…(examples are simplified a bit)

Example of using IProvideValueTarget – similar to how Binding does this:

public sealed override object ProvideValue(IServiceProvider serviceProvider)

      if (serviceProvider != null)

            IProvideValueTarget target1 = serviceProvider.GetService(typeof(IProvideValueTarget)) as IProvideValueTarget;

            Object obj1 =      target1.TargetObject;

            Object property1 = target1.TargetProperty;  //might be a propertyInfo or DependencyProperty

…

Example of using IXamlTypeResolver inside a ProvideValue call for TypeExtension (supports x:Type)

public override object ProvideValue(IServiceProvider serviceProvider)

            string typeName = "foo:Button";

            IXamlTypeResolver resolver1 = serviceProvider.GetService(typeof(IXamlTypeResolver)) as IXamlTypeResolver;

            if (resolver1 == null)

                  throw …

            Type type = resolver1.Resolve(typeName);

            if (type == null)

                  throw …

      return type;

}

Example of using IUriContext from inside a TypeConverter called during XamlReader or Baml load.

public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)

            IUriContext context1 = (IUriContext) context.GetService(typeof(IUriContext));

            if (context1.BaseUri != null)

                    Uri baseUri = context1.BaseUri

…

From: Larry

Rob, as far as I can see this isn’t documented in MSDN. MSDN documents that MarkupExtension.ProvideValue takes an IServiceProvider, but doesn’t say what it is or does. It also documents IProvideValueTarget, but says only (cryptically, in my opinion): “Reports object-property relationships for framework features such as binding on a dependency property”. It also warns you off with this: “This interface is used internally by some WPF types, and should not be used by application or type authors.”

If third parties are supposed to be able to implement markup extensions (are they, by the way?) this would need to be better documented.

Adam Calderon: WF XAML vs Code; WPF Features Demo Application

Thu, 15 Feb 2007 13:54:41 GMT

I discovered 3 interesting posts for XAML and WPF from Adam. Adam and I met at TechEd Boston 2006.

XAML vs Code for Workflow apps.

Since his post: The Windows Workflow Foundation team posted an XSD for workflow xaml files to help intellisense inside of VS' XML Editor.

Why do I need to know XAML
Additionally, he posts a demo app that he built with a series of web casts on WPF:

Debugging XAML Errors at Runtime

Sat, 10 Feb 2007 10:55:27 GMT

Reposting info that I posted on a forum thread. I've reordered and rewritten the content a bit.

When I have a mistake like this in my XAML:

<Grid Background="Greeeen">

Sometimes XAML intellisense will help you catch this kind of error...but not always. The XAML markup compiler doesn't currently catch errors like this. So you end up with this "Greeen" compiled into the assembly you are running (inside of the BAML binary stream.)

Debugging with VS 2005 at runtime, you will see errors like this (bad error message and pointing to the wrong location):

Cannot create instance of 'Window1' defined in assembly 'UsingWpfUtilities, Version=1.0.2593.18928, Culture=neutral, PublicKeyToken=null'. Exception has been thrown by the target of an invocation. Error in markup file 'UsingWpfUtilities;component/Window1.xaml' Line 1 Position 9.

We are working to improve this experience in VS "Orcas", but the best way to deal with this under VS 2005 is to:

Choose Debug\Exceptions\Add:

ComboBox: Common Lanaguage Runtime Exceptions
TextBox: System.Windows.Markup.XamlParseException

Check the "Thrown" box for that newly added Exception (S.W.M.XPE)

Debugging the app (F5) will now catch the XamlParseException and give you the following message:

Cannot convert the value in attribute 'Background' to object of type 'System.Windows.Media.Brush'. Token is not valid. Error at object 'System.Windows.Controls.Grid' in markup file 'UsingWpfUtilities;component/window1.xaml' Line 10 Position 6.

In builds of VS "Orcas" that aren't too far away, we'll do a few things to make this better:

1) The designer will get better, so that you'll need to spend less time typing XAML by hand.
2) The XAML editor will no longer be based on XSD, so that we'll be able to greatly improve the intellisense experience...red squiggles will really mean there is a problem!
3) At runtime, we'll try to relate the runtime exception back directly to the right place in the XAML.

Until then...sorry.

Finding all types in a xaml xmlns - code example

Mon, 05 Feb 2007 19:53:52 GMT

In the forums, "Jlansing" is digging into finding instances of DPs and also how to map TypeNames to the actual types.

Here is a code example of how to solve the typename to Type mapping as Xaml does it.

I'll enhance the code over time based on feedback.

string xmlNamespaceToEnumerate = "http://schemas.microsoft.com/winfx/2006/xaml/presentation";

List<Assembly> assemblyList = new List<Assembly>();

assemblyList.Add(typeof(System.Windows.Controls.Button).Assembly);

assemblyList.Add(typeof(System.Windows.Media.Brush).Assembly);

assemblyList.Add(typeof(System.Windows.Markup.XmlnsDefinitionAttribute).Assembly);

Dictionary<string, Type> typeDictionary = new Dictionary<string, Type>();

List<string> clrNamespaces = new List<string>();

foreach (Assembly a in assemblyList)

{

//Find all ClrNamespaces that match

object[] attrs = a.GetCustomAttributes(typeof(System.Windows.Markup.XmlnsDefinitionAttribute), false);

foreach (object attr in attrs)

{

System.Windows.Markup.XmlnsDefinitionAttribute xmlnsDef = attr as System.Windows.Markup.XmlnsDefinitionAttribute;

if (xmlnsDef.XmlNamespace == xmlNamespaceToEnumerate)

{

clrNamespaces.Add(xmlnsDef.ClrNamespace);

}

foreach (Type t in a.GetTypes())

{

if (t.IsPublic && clrNamespaces.Contains(t.Namespace))

{

typeDictionary.Add(t.Name, t);

}

Are you building a XAML based file format or class library?

Sun, 21 Jan 2007 14:44:20 GMT

We want to make sure we are aware of customers (different groups, companies, or individuals) that are design XAML based XML formats and/or class libraries.

As I blogged previously, within Microsoft, we have already shipped several:

http://schemas.microsoft.com/winfx/2006/xaml/presentation - WPF (Windows Presentation Foundation) types
http://schemas.microsoft.com/client/2007 - WPF/E*
http://schemas.microsoft.com/winfx/2006/xaml/workflow - WF (Windows Workflow Foundation) types
http://schemas.microsoft.com/xps/2005/06 - XPS (Xml Paper Specification)
http://schemas.microsoft.com/winfx/2006/xaml/composite-font - .compositeFont sdk entry. More.
* - Currently only available as a CTP (community technology preview) release.

There are many people who are designing class libraries that are extensions of those - such as a set of custom controls for WPF or custom activities for WF. Right now I'm interested in learning of new formats and uses that people are finding XAML useful for - outside of extensions of previous declarative systems.

Please email me at rob.relyea at microsoft dot com.

Intellisense in XAML for your types too!

Wed, 20 Sep 2006 13:40:10 GMT

Recently there were renewed requests from a control vendor and some developers in the forums for intellisense support for non-"xaml/presentation" types.

Looky here:

(This shows an XML editor view showing elements from a clr-namespace mixed in with element from xaml/presentation.)

I've spent some time the past few days trying to complete building a solution to enable this.

History of the XSD Generator

The ASP.NET team had to do similar things...generate an XSD using reflection against .Net assemblies. Several years ago, probably 2002 or early 2003, I got a drop of their code. I had a pm intern build a tool that would reflect on PresentationFramework, PresentationCore and WindowsBase and generate an XSD for "Avalon's" types.

Over the years, I ended up enhancing this tool to improve the intellisense experience for XAML inside of XSD aware tools. This included a major push during August of 2005 to make the XSD relect most of what was possible. (I no longer enforced that only a Page or Window could be at the root, for example, any object would be fine.) During that push, I ended up adding the concept of SubstitutionGroups to the XamlPresentation2006.xsd.

Substitution Groups

Substitution Groups enable you to model subclassing like model in schema. It gave me hope that I could support non-"xaml/presentation" types in XSD appropriately - something I had long though impossile with XSD.

Now I have been working on adapting the xsd generator to work on different .dlls.

For example, in my WpfUtilities dll that I am working on, I define a ProxyElement (which I'll write about in the future). If a new XSD is created that defines this element:

<xs:element name="ProxyElement" type="dProxyElement" substitutionGroup="wpf:sgDecorator"/>

And if we put that XSD in c:\program files\microsoft visual studio 8\xml\schemas with the right clr-namespace uri, intellisense works.

What is left

Unfortunately, I had to hand modify the output of the schema generation tool to make it work. I still need to:

adapt the XSD Generator to do all those things the right way
consider how to fix a problem I noticed in XamlPresentation2006.xsd (i didn't create substitution groups for elements which don't have subclasses.)
figure out where/how to ship this tool (and potential changes necessary for XamlPresentation2006.xsd) - i want to get it out soon...

Stop-Gap

As I've probably written about a few times, the Visual Studio team is planning on building a native XAML Editor...one that doesn't use XSD, but instead just directly examines types in assemblies, etc...

So, hopefully we can count the number of months that this will be useful on 1 (or maybe 2 hands)...