After pouring over the always useful MSDN documentation, I tried modifying my netTcpBinding to include the security mode of “None.” Amazingly, this solved the issue!

Make sure to set the bindingConfiguration in your service endpoint to the name of the binding, and it should work.

Normally, you would declare a DataTemplate in XAML, then associate it with a key, and then set an ItemsControl of some sort to use the named resource. In an implicit template, you don’t set the ItemsControl’s ItemTemplate property, and you omit the key on the DataTemplate. Instead, you associate it with a DataType, and at runtime, this template is applied to items matching the specified type of the DataTemplate.

In Pete Brown’s article on implicit templates, he demonstrates how to display different Twitter message types by having a base TwitterItem class, then other classes (such as DirectMessage) that derive from this class, ultimately instances of which are added to an ObservableCollection of type TwitterItem. Where the real power shines though, is in the fact that implicit data templates, at least in the Silverlight 5 beta, are not limited to being applied to ItemsControls! In fact, they can be used by ContentControls as well. Note – I couldn’t get them to work with the TreeView control in the beta, and I’m not quite sure why.

As far as I understand it, resource lookup for implicit templates appear to work as follows – the control searches for a DataTemplate matching the given DataType in its local resources, then moves up the visual tree to it’s parent and so on, until it eventually reaches the application level. If it can’t find a template, it uses the usual ToString() output.

Be careful when defining your DataTemplates – if you have two DataTemplates in the same ResourceDictionary that correspond to the same DataType, you’ll get a XamlParseException at runtime. It’ll look similar to this.

Example code is available for download here. For reference, here’s the XAML associated with this application. If you want to play with a live demo, you can try out the code here.

The idea behind Pivot is to allow Java 6 developers to create “installable internet applications,” or IIAs as they refer to them. While Pivot provides much more than a UI toolkit (including web service methods, collections, etc.), what I’ll be focusing on here is the UI side of things, or how to quickly create an application that creates a UI from an XML file with a Java codebehind file.

First off, head over to the Pivot site and download the SDK. Grab the Binary distribution. Next, extract those files to a directory on your machine where you keep common JAR files (For my Linux development machine, they’re usually under /usr/lib; YMMV).

Now, if you’re using Eclipse, create a new Java project, and open up the properties dialog. Head over to Java Build Path, and click the Libraries tab. Click Add External JARs, and find where you put the Pivot JARs. Select those, hit OK, and hit OK once more.

Now, create two packages: helloPivot and helloPivot.ui (do this by right-clicking the src directory, New, Package). Insert two files into the helloPivot package: App.java, and HelloWindow.java. Finally, add a text file to helloPivot.ui called HelloWindow.bxml. For this sample project, I’ve also downloaded the Apache Pivot logo to display on screen – place this in helloPivot.ui.

First off, the App.java file. I’ll present the file, then describe what’s going on.

package helloPivot;

import org.apache.pivot.beans.BXMLSerializer;
import org.apache.pivot.collections.*;
import org.apache.pivot.util.Vote;
import org.apache.pivot.wtk.*;

public class App implements Application
{
    private HelloWindow window;

    public static void main(String[] args)
    {
	String[] newArgs = new String[args.length + 1];
	newArgs[newArgs.length - 1] = "helloPivot.App";
	org.apache.pivot.wtk.DesktopApplicationContext.main(newArgs);
    }

    @Override
    public void startup(Display display, Map<String, String> properties)
	    throws Exception

    {
	final App toQuit = this;
	BXMLSerializer bxmlSerializer = new BXMLSerializer();
	window = (HelloWindow) bxmlSerializer.readObject(HelloWindow.class,
		"ui/HelloWindow.bxml");
	window.getWindowStateListeners().add(new WindowStateListener()
	{

	    @Override
	    public Vote previewWindowClose(Window arg0)
	    {
		return Vote.APPROVE;
	    }

	    @Override
	    public void windowCloseVetoed(Window arg0, Vote arg1){}

	    @Override
	    public void windowClosed(Window arg0, Display arg1, Window arg2)
	    {
		System.exit(0);
	    }

	    @Override
	    public void windowOpened(Window arg0){}

	});
	window.open(display);
    }

    @Override
    public boolean shutdown(boolean optional)
    {
	window.close();
	return false;
    }

    @Override
    public void suspend()
    {
    }

    @Override
    public void resume()
    {
    }

}

The main method basically calls Pivot and launches the application as a desktop window. I’m sure there’s a better way to do this, but it’s the first way I found. Next, startup() is called – this loads the bxml file that contains our UI, deserializes it, and then opens our main window. Inside startup we set our window listener as well – when the window is closed, we call System.exit(0). Next, HelloWindow.java.

package helloPivot;

import java.net.URL;

import org.apache.pivot.beans.Bindable;
import org.apache.pivot.collections.Map;
import org.apache.pivot.util.Resources;
import org.apache.pivot.wtk.BoxPane;
import org.apache.pivot.wtk.Button;
import org.apache.pivot.wtk.ButtonPressListener;
import org.apache.pivot.wtk.Component;
import org.apache.pivot.wtk.ComponentMouseButtonListener;
import org.apache.pivot.wtk.Label;
import org.apache.pivot.wtk.MessageType;
import org.apache.pivot.wtk.Mouse;
import org.apache.pivot.wtk.Orientation;
import org.apache.pivot.wtk.Prompt;
import org.apache.pivot.wtk.PushButton;
import org.apache.pivot.wtk.TablePane;
import org.apache.pivot.wtk.Window;

public class HelloWindow extends Window implements Bindable
{
    private PushButton quit;

    @Override
    public void initialize(Map<String, Object> namespace, URL location, Resources resources)
    {
	this.quit = (PushButton)namespace.get("quit");

	final Window toClose = this;
	this.quit.getButtonPressListeners().add(new ButtonPressListener()
	{
	    @Override
	    public void buttonPressed(Button arg0)
	    {
		toClose.close();
	    }
	});
    }
}

This class doesn’t do much, except define a button listener to deal with the button on our UI being clicked. From what I gather, when we initialize a new instance of a custom control/window, the initialize method is called, with namespace containing any objects on that UI that have the bxml:id attribute on it. Let’s show that UI so it makes some sense.

<local:HelloWindow title="Hello Apache Pivot!" maximized="true"
    xmlns:bxml="http://pivot.apache.org/bxml"
    xmlns:local="helloPivot"
    xmlns="org.apache.pivot.wtk">

	<BoxPane orientation="vertical" styles="{horizontalAlignment:'center',verticalAlignment:'center'}">
		<ImageView image="@logo.png" />
		<BoxPane orientation="horizontal" styles="{horizontalAlignment:'right'}">
			<PushButton bxml:id="quit" buttonData="Quit" />
		</BoxPane>
	</BoxPane>
</local:HelloWindow>

For those of you coming from the WPF/Silverlight world, the BoxPane is Pivot’s equivalent to a StackPanel. Notice the root of this XML file is local:HelloWindow. This is for two reasons: HelloWindow extends the Window class, and we want this file to eventually be associated with our underlying object instance (when we deserialize it). The local: namespace refers to the name of the package our class is in.

The final result if you build the project (and everything works)?

You can download the source from here. Enjoy!

So, I decided to break out a behavior for this task. Using the new ClickCount property provided by the MouseButtonEventArgs class (MSDN Documentation here), I was able to count the number of clicks, and if it was equal to 2, invoke a Command. Since Behaviors inherit from DependencyObject, they can participate in the binding system as well. Combine this with the new RelativeSource binding support in Silverlight 5, this opens up a whole new realm of binding possibilities! For PodTower, I have the behavior bound to a property of the DataContext on the main UserControl of the application. This allows me to bind up to the Commands on the viewmodel without having to do horrible back-end hack code.

Without further ado, here’s the code for the behavior. Note that I’ve included a conditional symbol called SILVERLIGHT5, so that if you want to use this behavior in Silverlight 4, you can.

using System;
using System.Windows;
using System.Windows.Input;
using System.Windows.Interactivity;

namespace PodTower
{
    public class DoubleClickInvokeCommandBehavior : Behavior
    {
        public ICommand Command
        {
            get { return (ICommand)GetValue(CommandProperty); }
            set { SetValue(CommandProperty, value); }
        }

        public static readonly DependencyProperty CommandProperty =
            DependencyProperty.Register("Command", typeof(ICommand), typeof(DoubleClickInvokeCommandBehavior), new PropertyMetadata(null));

        public Object CommandParameter
        {
            get { return (Object)GetValue(CommandParameterProperty); }
            set { SetValue(CommandParameterProperty, value); }
        }

        public static readonly DependencyProperty CommandParameterProperty =
            DependencyProperty.Register("CommandParameter", typeof(Object), typeof(DoubleClickInvokeCommandBehavior), new PropertyMetadata(null));

        protected override void OnAttached()
        {
            base.OnAttached();

            this.AssociatedObject.MouseLeftButtonDown += OnClick;
        }

        protected override void OnDetaching()
        {
            base.OnDetaching();
            this.AssociatedObject.MouseLeftButtonDown -= OnClick;
        }

#if !SILVERLIGHT5
        DateTime? _lastClick;
#endif

        void OnClick(object sender, MouseButtonEventArgs e)
        {
#if SILVERLIGHT5
            if (e.ClickCount != 2)
                return;
#else
            if (_lastClick == null)
            {
                _lastClick = DateTime.Now;
                return;
            }
            else
            {
                var now = DateTime.Now;
                var last = _lastClick.Value;
                _lastClick = now;

                if (now.Subtract(last).TotalMilliseconds > 250)
                    return;
            }
#endif
            if (this.Command == null || !this.Command.CanExecute(this.CommandParameter))
                return;

            this.Command.Execute(this.CommandParameter);
        }
    }
}

…and here’s an example of it used in the PodTower main UI.

Feel free to use this behavior in your own applications!